// core/util/int.js
function toUnsigned32bit(toConvert) {
  return toConvert >>> 0;
}
function toSigned32bit(toConvert) {
  return toConvert | 0;
}

// core/util/logging.js
var _logLevel = "warn";
var Debug = () => {
};
var Info = () => {
};
var Warn = () => {
};
var Error2 = () => {
};
function initLogging(level) {
  if (typeof level === "undefined") {
    level = _logLevel;
  } else {
    _logLevel = level;
  }
  Debug = Info = Warn = Error2 = () => {
  };
  if (typeof window.console !== "undefined") {
    switch (level) {
      case "debug":
        Debug = console.debug.bind(window.console);
      case "info":
        Info = console.info.bind(window.console);
      case "warn":
        Warn = console.warn.bind(window.console);
      case "error":
        Error2 = console.error.bind(window.console);
      case "none":
        break;
      default:
        throw new window.Error("invalid logging type '" + level + "'");
    }
  }
}
initLogging();

// core/util/strings.js
function decodeUTF8(utf8string, allowLatin1 = false) {
  try {
    return decodeURIComponent(escape(utf8string));
  } catch (e2) {
    if (e2 instanceof URIError) {
      if (allowLatin1) {
        return utf8string;
      }
    }
    throw e2;
  }
}
function encodeUTF8(DOMString) {
  return unescape(encodeURIComponent(DOMString));
}

// core/base64.js
var base64_default = {
  /* Convert data (an array of integers) to a Base64 string. */
  toBase64Table: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".split(""),
  base64Pad: "=",
  encode(data) {
    "use strict";
    let result = "";
    const length = data.length;
    const lengthpad = length % 3;
    for (let i = 0; i < length - 2; i += 3) {
      result += this.toBase64Table[data[i] >> 2];
      result += this.toBase64Table[((data[i] & 3) << 4) + (data[i + 1] >> 4)];
      result += this.toBase64Table[((data[i + 1] & 15) << 2) + (data[i + 2] >> 6)];
      result += this.toBase64Table[data[i + 2] & 63];
    }
    const j = length - lengthpad;
    if (lengthpad === 2) {
      result += this.toBase64Table[data[j] >> 2];
      result += this.toBase64Table[((data[j] & 3) << 4) + (data[j + 1] >> 4)];
      result += this.toBase64Table[(data[j + 1] & 15) << 2];
      result += this.toBase64Table[64];
    } else if (lengthpad === 1) {
      result += this.toBase64Table[data[j] >> 2];
      result += this.toBase64Table[(data[j] & 3) << 4];
      result += this.toBase64Table[64];
      result += this.toBase64Table[64];
    }
    return result;
  },
  /* Convert Base64 data to a string */
  /* eslint-disable comma-spacing */
  toBinaryTable: [
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    62,
    -1,
    -1,
    -1,
    63,
    52,
    53,
    54,
    55,
    56,
    57,
    58,
    59,
    60,
    61,
    -1,
    -1,
    -1,
    0,
    -1,
    -1,
    -1,
    0,
    1,
    2,
    3,
    4,
    5,
    6,
    7,
    8,
    9,
    10,
    11,
    12,
    13,
    14,
    15,
    16,
    17,
    18,
    19,
    20,
    21,
    22,
    23,
    24,
    25,
    -1,
    -1,
    -1,
    -1,
    -1,
    -1,
    26,
    27,
    28,
    29,
    30,
    31,
    32,
    33,
    34,
    35,
    36,
    37,
    38,
    39,
    40,
    41,
    42,
    43,
    44,
    45,
    46,
    47,
    48,
    49,
    50,
    51,
    -1,
    -1,
    -1,
    -1,
    -1
  ],
  /* eslint-enable comma-spacing */
  decode(data, offset = 0) {
    let dataLength = data.indexOf("=") - offset;
    if (dataLength < 0) {
      dataLength = data.length - offset;
    }
    const resultLength = (dataLength >> 2) * 3 + Math.floor(dataLength % 4 / 1.5);
    const result = new Array(resultLength);
    let leftbits = 0;
    let leftdata = 0;
    for (let idx = 0, i = offset; i < data.length; i++) {
      const c2 = this.toBinaryTable[data.charCodeAt(i) & 127];
      const padding = data.charAt(i) === this.base64Pad;
      if (c2 === -1) {
        Error2("Illegal character code " + data.charCodeAt(i) + " at position " + i);
        continue;
      }
      leftdata = leftdata << 6 | c2;
      leftbits += 6;
      if (leftbits >= 8) {
        leftbits -= 8;
        if (!padding) {
          result[idx++] = leftdata >> leftbits & 255;
        }
        leftdata &= (1 << leftbits) - 1;
      }
    }
    if (leftbits) {
      const err2 = new Error("Corrupted base64 string");
      err2.name = "Base64-Error";
      throw err2;
    }
    return result;
  }
};

// core/util/browser.js
async function browserAsyncClipboardSupport() {
  if (!(navigator?.permissions?.query && navigator?.clipboard?.writeText && navigator?.clipboard?.readText)) {
    return "unsupported";
  }
  try {
    const writePerm = await navigator.permissions.query(
      { name: "clipboard-write", allowWithoutGesture: true }
    );
    const readPerm = await navigator.permissions.query(
      { name: "clipboard-read", allowWithoutGesture: false }
    );
    if (writePerm.state === "denied" || readPerm.state === "denied") {
      return "denied";
    }
    if ((writePerm.state === "granted" || writePerm.state === "prompt") && (readPerm.state === "granted" || readPerm.state === "prompt")) {
      return "available";
    }
  } catch {
    return "unsupported";
  }
  return "unsupported";
}
var isTouchDevice = "ontouchstart" in document.documentElement || // required for Chrome debugger
document.ontouchstart !== void 0 || // required for MS Surface
navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0;
window.addEventListener("touchstart", function onFirstTouch() {
  isTouchDevice = true;
  window.removeEventListener("touchstart", onFirstTouch, false);
}, false);
var dragThreshold = 10 * (window.devicePixelRatio || 1);
var _supportsCursorURIs = false;
try {
  const target = document.createElement("canvas");
  target.style.cursor = 'url("data:image/x-icon;base64,AAACAAEACAgAAAIAAgA4AQAAFgAAACgAAAAIAAAAEAAAAAEAIAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAD/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////AAAAAAAAAAAAAAAAAAAAAA==") 2 2, default';
  if (target.style.cursor.indexOf("url") === 0) {
    Info("Data URI scheme cursor supported");
    _supportsCursorURIs = true;
  } else {
    Warn("Data URI scheme cursor not supported");
  }
} catch (exc) {
  Error2("Data URI scheme cursor test exception: " + exc);
}
var supportsCursorURIs = _supportsCursorURIs;
var _hasScrollbarGutter = true;
try {
  const container = document.createElement("div");
  container.style.visibility = "hidden";
  container.style.overflow = "scroll";
  document.body.appendChild(container);
  const child = document.createElement("div");
  container.appendChild(child);
  const scrollbarWidth = container.offsetWidth - child.offsetWidth;
  container.parentNode.removeChild(container);
  _hasScrollbarGutter = scrollbarWidth != 0;
} catch (exc) {
  Error2("Scrollbar test exception: " + exc);
}
var supportsWebCodecsH264Decode = false;
async function _checkWebCodecsH264DecodeSupport() {
  if (!("VideoDecoder" in window)) {
    return false;
  }
  const config = {
    codec: "avc1.42401f",
    codedWidth: 1920,
    codedHeight: 1080,
    optimizeForLatency: true
  };
  let support = await VideoDecoder.isConfigSupported(config);
  if (!support.supported) {
    return false;
  }
  const data = new Uint8Array(base64_default.decode(
    "AAAAAWdCwBTZnpuAgICgAAADACAAAAZB4oVNAAAAAWjJYyyAAAABBgX//4HcRem95tlIt5Ys2CDZI+7veDI2NCAtIGNvcmUgMTY0IHIzMTA4IDMxZTE5ZjkgLSBILjI2NC9NUEVHLTQgQVZDIGNvZGVjIC0gQ29weWxlZnQgMjAwMy0yMDIzIC0gaHR0cDovL3d3dy52aWRlb2xhbi5vcmcveDI2NC5odG1sIC0gb3B0aW9uczogY2FiYWM9MCByZWY9NSBkZWJsb2NrPTE6MDowIGFuYWx5c2U9MHgxOjB4MTExIG1lPWhleCBzdWJtZT04IHBzeT0xIHBzeV9yZD0xLjAwOjAuMDAgbWl4ZWRfcmVmPTEgbWVfcmFuZ2U9MTYgY2hyb21hX21lPTEgdHJlbGxpcz0yIDh4OGRjdD0wIGNxbT0wIGRlYWR6b25lPTIxLDExIGZhc3RfcHNraXA9MSBjaHJvbWFfcXBfb2Zmc2V0PS0yIHRocmVhZHM9MSBsb29rYWhlYWRfdGhyZWFkcz0xIHNsaWNlZF90aHJlYWRzPTAgbnI9MCBkZWNpbWF0ZT0xIGludGVybGFjZWQ9MCBibHVyYXlfY29tcGF0PTAgY29uc3RyYWluZWRfaW50cmE9MCBiZnJhbWVzPTAgd2VpZ2h0cD0wIGtleWludD1pbmZpbml0ZSBrZXlpbnRfbWluPTI1IHNjZW5lY3V0PTQwIGludHJhX3JlZnJlc2g9MCByY19sb29rYWhlYWQ9NTAgcmM9YWJyIG1idHJlZT0xIGJpdHJhdGU9NDAwIHJhdGV0b2w9MS4wIHFjb21wPTAuNjAgcXBtaW49MCBxcG1heD02OSBxcHN0ZXA9NCBpcF9yYXRpbz0xLjQwIGFxPTE6MS4wMACAAAABZYiEBrxmKAAPVccAAS044AA5DRJMnkycJk4TPw=="
  ));
  let gotframe = false;
  let error = null;
  let decoder = new VideoDecoder({
    output: (frame) => {
      gotframe = true;
      frame.close();
    },
    error: (e2) => {
      error = e2;
    }
  });
  let chunk = new EncodedVideoChunk({
    timestamp: 0,
    type: "key",
    data
  });
  decoder.configure(config);
  decoder.decode(chunk);
  try {
    await decoder.flush();
  } catch (e2) {
    error = e2;
  }
  if (!gotframe) {
    return false;
  }
  if (error !== null) {
    return false;
  }
  return true;
}
supportsWebCodecsH264Decode = await _checkWebCodecsH264DecodeSupport();
function isMac() {
  return !!/mac/i.exec(navigator.platform);
}
function isWindows() {
  return !!/win/i.exec(navigator.platform);
}
function isIOS() {
  return !!/ipad/i.exec(navigator.platform) || !!/iphone/i.exec(navigator.platform) || !!/ipod/i.exec(navigator.platform);
}

// core/util/element.js
function clientToElement(x, y, elem) {
  const bounds = elem.getBoundingClientRect();
  let pos = { x: 0, y: 0 };
  if (x < bounds.left) {
    pos.x = 0;
  } else if (x >= bounds.right) {
    pos.x = bounds.width - 1;
  } else {
    pos.x = x - bounds.left;
  }
  if (y < bounds.top) {
    pos.y = 0;
  } else if (y >= bounds.bottom) {
    pos.y = bounds.height - 1;
  } else {
    pos.y = y - bounds.top;
  }
  return pos;
}

// core/util/events.js
function stopEvent(e2) {
  e2.stopPropagation();
  e2.preventDefault();
}
var _captureRecursion = false;
var _elementForUnflushedEvents = null;
document.captureElement = null;
function _captureProxy(e2) {
  if (_captureRecursion) return;
  const newEv = new e2.constructor(e2.type, e2);
  _captureRecursion = true;
  if (document.captureElement) {
    document.captureElement.dispatchEvent(newEv);
  } else {
    _elementForUnflushedEvents.dispatchEvent(newEv);
  }
  _captureRecursion = false;
  e2.stopPropagation();
  if (newEv.defaultPrevented) {
    e2.preventDefault();
  }
  if (e2.type === "mouseup") {
    releaseCapture();
  }
}
function _capturedElemChanged() {
  const proxyElem = document.getElementById("noVNC_mouse_capture_elem");
  proxyElem.style.cursor = window.getComputedStyle(document.captureElement).cursor;
}
var _captureObserver = new MutationObserver(_capturedElemChanged);
function setCapture(target) {
  if (target.setCapture) {
    target.setCapture();
    document.captureElement = target;
  } else {
    releaseCapture();
    let proxyElem = document.getElementById("noVNC_mouse_capture_elem");
    if (proxyElem === null) {
      proxyElem = document.createElement("div");
      proxyElem.id = "noVNC_mouse_capture_elem";
      proxyElem.style.position = "fixed";
      proxyElem.style.top = "0px";
      proxyElem.style.left = "0px";
      proxyElem.style.width = "100%";
      proxyElem.style.height = "100%";
      proxyElem.style.zIndex = 1e4;
      proxyElem.style.display = "none";
      document.body.appendChild(proxyElem);
      proxyElem.addEventListener("contextmenu", _captureProxy);
      proxyElem.addEventListener("mousemove", _captureProxy);
      proxyElem.addEventListener("mouseup", _captureProxy);
    }
    document.captureElement = target;
    _captureObserver.observe(target, { attributes: true });
    _capturedElemChanged();
    proxyElem.style.display = "";
    window.addEventListener("mousemove", _captureProxy);
    window.addEventListener("mouseup", _captureProxy);
  }
}
function releaseCapture() {
  if (document.releaseCapture) {
    document.releaseCapture();
    document.captureElement = null;
  } else {
    if (!document.captureElement) {
      return;
    }
    _elementForUnflushedEvents = document.captureElement;
    document.captureElement = null;
    _captureObserver.disconnect();
    const proxyElem = document.getElementById("noVNC_mouse_capture_elem");
    proxyElem.style.display = "none";
    window.removeEventListener("mousemove", _captureProxy);
    window.removeEventListener("mouseup", _captureProxy);
  }
}

// core/util/eventtarget.js
var EventTargetMixin = class {
  constructor() {
    this._listeners = /* @__PURE__ */ new Map();
  }
  addEventListener(type, callback) {
    if (!this._listeners.has(type)) {
      this._listeners.set(type, /* @__PURE__ */ new Set());
    }
    this._listeners.get(type).add(callback);
  }
  removeEventListener(type, callback) {
    if (this._listeners.has(type)) {
      this._listeners.get(type).delete(callback);
    }
  }
  dispatchEvent(event) {
    if (!this._listeners.has(event.type)) {
      return true;
    }
    this._listeners.get(event.type).forEach((callback) => callback.call(this, event));
    return !event.defaultPrevented;
  }
};

// core/display.js
var Display = class {
  constructor(target) {
    this._drawCtx = null;
    this._renderQ = [];
    this._flushPromise = null;
    this._fbWidth = 0;
    this._fbHeight = 0;
    this._prevDrawStyle = "";
    Debug(">> Display.constructor");
    this._target = target;
    if (!this._target) {
      throw new Error("Target must be set");
    }
    if (typeof this._target === "string") {
      throw new Error("target must be a DOM element");
    }
    if (!this._target.getContext) {
      throw new Error("no getContext method");
    }
    this._targetCtx = this._target.getContext("2d");
    this._viewportLoc = { "x": 0, "y": 0, "w": this._target.width, "h": this._target.height };
    this._backbuffer = document.createElement("canvas");
    this._drawCtx = this._backbuffer.getContext("2d");
    this._damageBounds = {
      left: 0,
      top: 0,
      right: this._backbuffer.width,
      bottom: this._backbuffer.height
    };
    Debug("User Agent: " + navigator.userAgent);
    Debug("<< Display.constructor");
    this._scale = 1;
    this._clipViewport = false;
  }
  // ===== PROPERTIES =====
  get scale() {
    return this._scale;
  }
  set scale(scale) {
    this._rescale(scale);
  }
  get clipViewport() {
    return this._clipViewport;
  }
  set clipViewport(viewport) {
    this._clipViewport = viewport;
    const vp = this._viewportLoc;
    this.viewportChangeSize(vp.w, vp.h);
    this.viewportChangePos(0, 0);
  }
  get width() {
    return this._fbWidth;
  }
  get height() {
    return this._fbHeight;
  }
  // ===== PUBLIC METHODS =====
  viewportChangePos(deltaX, deltaY) {
    const vp = this._viewportLoc;
    deltaX = Math.floor(deltaX);
    deltaY = Math.floor(deltaY);
    if (!this._clipViewport) {
      deltaX = -vp.w;
      deltaY = -vp.h;
    }
    const vx2 = vp.x + vp.w - 1;
    const vy2 = vp.y + vp.h - 1;
    if (deltaX < 0 && vp.x + deltaX < 0) {
      deltaX = -vp.x;
    }
    if (vx2 + deltaX >= this._fbWidth) {
      deltaX -= vx2 + deltaX - this._fbWidth + 1;
    }
    if (vp.y + deltaY < 0) {
      deltaY = -vp.y;
    }
    if (vy2 + deltaY >= this._fbHeight) {
      deltaY -= vy2 + deltaY - this._fbHeight + 1;
    }
    if (deltaX === 0 && deltaY === 0) {
      return;
    }
    Debug("viewportChange deltaX: " + deltaX + ", deltaY: " + deltaY);
    vp.x += deltaX;
    vp.y += deltaY;
    this._damage(vp.x, vp.y, vp.w, vp.h);
    this.flip();
  }
  viewportChangeSize(width, height) {
    if (!this._clipViewport || typeof width === "undefined" || typeof height === "undefined") {
      Debug("Setting viewport to full display region");
      width = this._fbWidth;
      height = this._fbHeight;
    }
    width = Math.floor(width);
    height = Math.floor(height);
    if (width > this._fbWidth) {
      width = this._fbWidth;
    }
    if (height > this._fbHeight) {
      height = this._fbHeight;
    }
    const vp = this._viewportLoc;
    if (vp.w !== width || vp.h !== height) {
      vp.w = width;
      vp.h = height;
      const canvas = this._target;
      canvas.width = width;
      canvas.height = height;
      this.viewportChangePos(0, 0);
      this._damage(vp.x, vp.y, vp.w, vp.h);
      this.flip();
      this._rescale(this._scale);
    }
  }
  absX(x) {
    if (this._scale === 0) {
      return 0;
    }
    return toSigned32bit(x / this._scale + this._viewportLoc.x);
  }
  absY(y) {
    if (this._scale === 0) {
      return 0;
    }
    return toSigned32bit(y / this._scale + this._viewportLoc.y);
  }
  resize(width, height) {
    this._prevDrawStyle = "";
    this._fbWidth = width;
    this._fbHeight = height;
    const canvas = this._backbuffer;
    if (canvas.width !== width || canvas.height !== height) {
      let saveImg = null;
      if (canvas.width > 0 && canvas.height > 0) {
        saveImg = this._drawCtx.getImageData(0, 0, canvas.width, canvas.height);
      }
      if (canvas.width !== width) {
        canvas.width = width;
      }
      if (canvas.height !== height) {
        canvas.height = height;
      }
      if (saveImg) {
        this._drawCtx.putImageData(saveImg, 0, 0);
      }
    }
    const vp = this._viewportLoc;
    this.viewportChangeSize(vp.w, vp.h);
    this.viewportChangePos(0, 0);
  }
  getImageData() {
    return this._drawCtx.getImageData(0, 0, this.width, this.height);
  }
  toDataURL(type, encoderOptions) {
    return this._backbuffer.toDataURL(type, encoderOptions);
  }
  toBlob(callback, type, quality) {
    return this._backbuffer.toBlob(callback, type, quality);
  }
  // Track what parts of the visible canvas that need updating
  _damage(x, y, w, h) {
    if (x < this._damageBounds.left) {
      this._damageBounds.left = x;
    }
    if (y < this._damageBounds.top) {
      this._damageBounds.top = y;
    }
    if (x + w > this._damageBounds.right) {
      this._damageBounds.right = x + w;
    }
    if (y + h > this._damageBounds.bottom) {
      this._damageBounds.bottom = y + h;
    }
  }
  // Update the visible canvas with the contents of the
  // rendering canvas
  flip(fromQueue) {
    if (this._renderQ.length !== 0 && !fromQueue) {
      this._renderQPush({
        "type": "flip"
      });
    } else {
      let x = this._damageBounds.left;
      let y = this._damageBounds.top;
      let w = this._damageBounds.right - x;
      let h = this._damageBounds.bottom - y;
      let vx = x - this._viewportLoc.x;
      let vy = y - this._viewportLoc.y;
      if (vx < 0) {
        w += vx;
        x -= vx;
        vx = 0;
      }
      if (vy < 0) {
        h += vy;
        y -= vy;
        vy = 0;
      }
      if (vx + w > this._viewportLoc.w) {
        w = this._viewportLoc.w - vx;
      }
      if (vy + h > this._viewportLoc.h) {
        h = this._viewportLoc.h - vy;
      }
      if (w > 0 && h > 0) {
        this._targetCtx.drawImage(
          this._backbuffer,
          x,
          y,
          w,
          h,
          vx,
          vy,
          w,
          h
        );
      }
      this._damageBounds.left = this._damageBounds.top = 65535;
      this._damageBounds.right = this._damageBounds.bottom = 0;
    }
  }
  pending() {
    return this._renderQ.length > 0;
  }
  flush() {
    if (this._renderQ.length === 0) {
      return Promise.resolve();
    } else {
      if (this._flushPromise === null) {
        this._flushPromise = new Promise((resolve) => {
          this._flushResolve = resolve;
        });
      }
      return this._flushPromise;
    }
  }
  fillRect(x, y, width, height, color, fromQueue) {
    if (this._renderQ.length !== 0 && !fromQueue) {
      this._renderQPush({
        "type": "fill",
        "x": x,
        "y": y,
        "width": width,
        "height": height,
        "color": color
      });
    } else {
      this._setFillColor(color);
      this._drawCtx.fillRect(x, y, width, height);
      this._damage(x, y, width, height);
    }
  }
  copyImage(oldX, oldY, newX, newY, w, h, fromQueue) {
    if (this._renderQ.length !== 0 && !fromQueue) {
      this._renderQPush({
        "type": "copy",
        "oldX": oldX,
        "oldY": oldY,
        "x": newX,
        "y": newY,
        "width": w,
        "height": h
      });
    } else {
      this._drawCtx.mozImageSmoothingEnabled = false;
      this._drawCtx.webkitImageSmoothingEnabled = false;
      this._drawCtx.msImageSmoothingEnabled = false;
      this._drawCtx.imageSmoothingEnabled = false;
      this._drawCtx.drawImage(
        this._backbuffer,
        oldX,
        oldY,
        w,
        h,
        newX,
        newY,
        w,
        h
      );
      this._damage(newX, newY, w, h);
    }
  }
  imageRect(x, y, width, height, mime, arr) {
    if (width === 0 || height === 0) {
      return;
    }
    const img = new Image();
    img.src = "data: " + mime + ";base64," + base64_default.encode(arr);
    this._renderQPush({
      "type": "img",
      "img": img,
      "x": x,
      "y": y,
      "width": width,
      "height": height
    });
  }
  videoFrame(x, y, width, height, frame) {
    this._renderQPush({
      "type": "frame",
      "frame": frame,
      "x": x,
      "y": y,
      "width": width,
      "height": height
    });
  }
  blitImage(x, y, width, height, arr, offset, fromQueue) {
    if (this._renderQ.length !== 0 && !fromQueue) {
      const newArr = new Uint8Array(width * height * 4);
      newArr.set(new Uint8Array(arr.buffer, 0, newArr.length));
      this._renderQPush({
        "type": "blit",
        "data": newArr,
        "x": x,
        "y": y,
        "width": width,
        "height": height
      });
    } else {
      let data = new Uint8ClampedArray(
        arr.buffer,
        arr.byteOffset + offset,
        width * height * 4
      );
      let img = new ImageData(data, width, height);
      this._drawCtx.putImageData(img, x, y);
      this._damage(x, y, width, height);
    }
  }
  drawImage(img, ...args) {
    this._drawCtx.drawImage(img, ...args);
    if (args.length <= 4) {
      const [x, y] = args;
      this._damage(x, y, img.width, img.height);
    } else {
      const [, , sw, sh, dx, dy] = args;
      this._damage(dx, dy, sw, sh);
    }
  }
  autoscale(containerWidth, containerHeight) {
    let scaleRatio;
    if (containerWidth === 0 || containerHeight === 0) {
      scaleRatio = 0;
    } else {
      const vp = this._viewportLoc;
      const targetAspectRatio = containerWidth / containerHeight;
      const fbAspectRatio = vp.w / vp.h;
      if (fbAspectRatio >= targetAspectRatio) {
        scaleRatio = containerWidth / vp.w;
      } else {
        scaleRatio = containerHeight / vp.h;
      }
    }
    this._rescale(scaleRatio);
  }
  // ===== PRIVATE METHODS =====
  _rescale(factor) {
    this._scale = factor;
    const vp = this._viewportLoc;
    const width = factor * vp.w + "px";
    const height = factor * vp.h + "px";
    if (this._target.style.width !== width || this._target.style.height !== height) {
      this._target.style.width = width;
      this._target.style.height = height;
    }
  }
  _setFillColor(color) {
    const newStyle = "rgb(" + color[0] + "," + color[1] + "," + color[2] + ")";
    if (newStyle !== this._prevDrawStyle) {
      this._drawCtx.fillStyle = newStyle;
      this._prevDrawStyle = newStyle;
    }
  }
  _renderQPush(action) {
    this._renderQ.push(action);
    if (this._renderQ.length === 1) {
      this._scanRenderQ();
    }
  }
  _resumeRenderQ() {
    this.removeEventListener("load", this._noVNCDisplay._resumeRenderQ);
    this._noVNCDisplay._scanRenderQ();
  }
  _scanRenderQ() {
    let ready = true;
    while (ready && this._renderQ.length > 0) {
      const a2 = this._renderQ[0];
      switch (a2.type) {
        case "flip":
          this.flip(true);
          break;
        case "copy":
          this.copyImage(a2.oldX, a2.oldY, a2.x, a2.y, a2.width, a2.height, true);
          break;
        case "fill":
          this.fillRect(a2.x, a2.y, a2.width, a2.height, a2.color, true);
          break;
        case "blit":
          this.blitImage(a2.x, a2.y, a2.width, a2.height, a2.data, 0, true);
          break;
        case "img":
          if (a2.img.complete) {
            if (a2.img.width !== a2.width || a2.img.height !== a2.height) {
              Error2("Decoded image has incorrect dimensions. Got " + a2.img.width + "x" + a2.img.height + ". Expected " + a2.width + "x" + a2.height + ".");
              return;
            }
            this.drawImage(a2.img, a2.x, a2.y);
            a2.img.src = "";
          } else {
            a2.img._noVNCDisplay = this;
            a2.img.addEventListener("load", this._resumeRenderQ);
            ready = false;
          }
          break;
        case "frame":
          if (a2.frame.ready) {
            let frame = a2.frame.frame;
            if (frame.codedWidth < a2.width || frame.codedHeight < a2.height) {
              Warn("Decoded video frame does not cover its full rectangle area. Expecting at least " + a2.width + "x" + a2.height + " but got " + frame.codedWidth + "x" + frame.codedHeight);
            }
            const sx = 0;
            const sy = 0;
            const sw = a2.width;
            const sh = a2.height;
            const dx = a2.x;
            const dy = a2.y;
            const dw = sw;
            const dh = sh;
            this.drawImage(frame, sx, sy, sw, sh, dx, dy, dw, dh);
            frame.close();
          } else {
            let display = this;
            a2.frame.promise.then(() => {
              display._scanRenderQ();
            });
            ready = false;
          }
          break;
      }
      if (ready) {
        this._renderQ.shift();
      }
    }
    if (this._renderQ.length === 0 && this._flushPromise !== null) {
      this._flushResolve();
      this._flushPromise = null;
      this._flushResolve = null;
    }
  }
};

// core/clipboard.js
var AsyncClipboard = class {
  constructor(target) {
    this._target = target || null;
    this._isAvailable = null;
    this._eventHandlers = {
      "focus": this._handleFocus.bind(this)
    };
    this.onpaste = () => {
    };
  }
  // ===== PRIVATE METHODS =====
  async _ensureAvailable() {
    if (this._isAvailable !== null) return this._isAvailable;
    try {
      const status = await browserAsyncClipboardSupport();
      this._isAvailable = status === "available";
    } catch {
      this._isAvailable = false;
    }
    return this._isAvailable;
  }
  async _handleFocus(event) {
    if (!await this._ensureAvailable()) return;
    try {
      const text = await navigator.clipboard.readText();
      this.onpaste(text);
    } catch (error) {
      Error2("Clipboard read failed: ", error);
    }
  }
  // ===== PUBLIC METHODS =====
  writeClipboard(text) {
    if (!this._isAvailable) return false;
    navigator.clipboard.writeText(text).catch((error) => Error2("Clipboard write failed: ", error));
    return true;
  }
  grab() {
    if (!this._target) return;
    this._ensureAvailable().then((isAvailable) => {
      if (isAvailable) {
        this._target.addEventListener("focus", this._eventHandlers.focus);
      }
    });
  }
  ungrab() {
    if (!this._target) return;
    this._target.removeEventListener("focus", this._eventHandlers.focus);
  }
};

// vendor/pako/lib/utils/common.js
function arraySet(dest, src, src_offs, len, dest_offs) {
  if (src.subarray && dest.subarray) {
    dest.set(src.subarray(src_offs, src_offs + len), dest_offs);
    return;
  }
  for (var i = 0; i < len; i++) {
    dest[dest_offs + i] = src[src_offs + i];
  }
}
var Buf8 = Uint8Array;
var Buf16 = Uint16Array;
var Buf32 = Int32Array;

// vendor/pako/lib/zlib/adler32.js
function adler32(adler, buf, len, pos) {
  var s1 = adler & 65535 | 0, s2 = adler >>> 16 & 65535 | 0, n = 0;
  while (len !== 0) {
    n = len > 2e3 ? 2e3 : len;
    len -= n;
    do {
      s1 = s1 + buf[pos++] | 0;
      s2 = s2 + s1 | 0;
    } while (--n);
    s1 %= 65521;
    s2 %= 65521;
  }
  return s1 | s2 << 16 | 0;
}

// vendor/pako/lib/zlib/crc32.js
function makeTable() {
  var c2, table = [];
  for (var n = 0; n < 256; n++) {
    c2 = n;
    for (var k = 0; k < 8; k++) {
      c2 = c2 & 1 ? 3988292384 ^ c2 >>> 1 : c2 >>> 1;
    }
    table[n] = c2;
  }
  return table;
}
var crcTable = makeTable();

// vendor/pako/lib/zlib/inffast.js
var BAD = 30;
var TYPE = 12;
function inflate_fast(strm, start) {
  var state;
  var _in;
  var last;
  var _out;
  var beg;
  var end;
  var dmax;
  var wsize;
  var whave;
  var wnext;
  var s_window;
  var hold;
  var bits;
  var lcode;
  var dcode;
  var lmask;
  var dmask;
  var here;
  var op;
  var len;
  var dist;
  var from;
  var from_source;
  var input, output;
  state = strm.state;
  _in = strm.next_in;
  input = strm.input;
  last = _in + (strm.avail_in - 5);
  _out = strm.next_out;
  output = strm.output;
  beg = _out - (start - strm.avail_out);
  end = _out + (strm.avail_out - 257);
  dmax = state.dmax;
  wsize = state.wsize;
  whave = state.whave;
  wnext = state.wnext;
  s_window = state.window;
  hold = state.hold;
  bits = state.bits;
  lcode = state.lencode;
  dcode = state.distcode;
  lmask = (1 << state.lenbits) - 1;
  dmask = (1 << state.distbits) - 1;
  top:
    do {
      if (bits < 15) {
        hold += input[_in++] << bits;
        bits += 8;
        hold += input[_in++] << bits;
        bits += 8;
      }
      here = lcode[hold & lmask];
      dolen:
        for (; ; ) {
          op = here >>> 24;
          hold >>>= op;
          bits -= op;
          op = here >>> 16 & 255;
          if (op === 0) {
            output[_out++] = here & 65535;
          } else if (op & 16) {
            len = here & 65535;
            op &= 15;
            if (op) {
              if (bits < op) {
                hold += input[_in++] << bits;
                bits += 8;
              }
              len += hold & (1 << op) - 1;
              hold >>>= op;
              bits -= op;
            }
            if (bits < 15) {
              hold += input[_in++] << bits;
              bits += 8;
              hold += input[_in++] << bits;
              bits += 8;
            }
            here = dcode[hold & dmask];
            dodist:
              for (; ; ) {
                op = here >>> 24;
                hold >>>= op;
                bits -= op;
                op = here >>> 16 & 255;
                if (op & 16) {
                  dist = here & 65535;
                  op &= 15;
                  if (bits < op) {
                    hold += input[_in++] << bits;
                    bits += 8;
                    if (bits < op) {
                      hold += input[_in++] << bits;
                      bits += 8;
                    }
                  }
                  dist += hold & (1 << op) - 1;
                  if (dist > dmax) {
                    strm.msg = "invalid distance too far back";
                    state.mode = BAD;
                    break top;
                  }
                  hold >>>= op;
                  bits -= op;
                  op = _out - beg;
                  if (dist > op) {
                    op = dist - op;
                    if (op > whave) {
                      if (state.sane) {
                        strm.msg = "invalid distance too far back";
                        state.mode = BAD;
                        break top;
                      }
                    }
                    from = 0;
                    from_source = s_window;
                    if (wnext === 0) {
                      from += wsize - op;
                      if (op < len) {
                        len -= op;
                        do {
                          output[_out++] = s_window[from++];
                        } while (--op);
                        from = _out - dist;
                        from_source = output;
                      }
                    } else if (wnext < op) {
                      from += wsize + wnext - op;
                      op -= wnext;
                      if (op < len) {
                        len -= op;
                        do {
                          output[_out++] = s_window[from++];
                        } while (--op);
                        from = 0;
                        if (wnext < len) {
                          op = wnext;
                          len -= op;
                          do {
                            output[_out++] = s_window[from++];
                          } while (--op);
                          from = _out - dist;
                          from_source = output;
                        }
                      }
                    } else {
                      from += wnext - op;
                      if (op < len) {
                        len -= op;
                        do {
                          output[_out++] = s_window[from++];
                        } while (--op);
                        from = _out - dist;
                        from_source = output;
                      }
                    }
                    while (len > 2) {
                      output[_out++] = from_source[from++];
                      output[_out++] = from_source[from++];
                      output[_out++] = from_source[from++];
                      len -= 3;
                    }
                    if (len) {
                      output[_out++] = from_source[from++];
                      if (len > 1) {
                        output[_out++] = from_source[from++];
                      }
                    }
                  } else {
                    from = _out - dist;
                    do {
                      output[_out++] = output[from++];
                      output[_out++] = output[from++];
                      output[_out++] = output[from++];
                      len -= 3;
                    } while (len > 2);
                    if (len) {
                      output[_out++] = output[from++];
                      if (len > 1) {
                        output[_out++] = output[from++];
                      }
                    }
                  }
                } else if ((op & 64) === 0) {
                  here = dcode[(here & 65535) + (hold & (1 << op) - 1)];
                  continue dodist;
                } else {
                  strm.msg = "invalid distance code";
                  state.mode = BAD;
                  break top;
                }
                break;
              }
          } else if ((op & 64) === 0) {
            here = lcode[(here & 65535) + (hold & (1 << op) - 1)];
            continue dolen;
          } else if (op & 32) {
            state.mode = TYPE;
            break top;
          } else {
            strm.msg = "invalid literal/length code";
            state.mode = BAD;
            break top;
          }
          break;
        }
    } while (_in < last && _out < end);
  len = bits >> 3;
  _in -= len;
  bits -= len << 3;
  hold &= (1 << bits) - 1;
  strm.next_in = _in;
  strm.next_out = _out;
  strm.avail_in = _in < last ? 5 + (last - _in) : 5 - (_in - last);
  strm.avail_out = _out < end ? 257 + (end - _out) : 257 - (_out - end);
  state.hold = hold;
  state.bits = bits;
  return;
}

// vendor/pako/lib/zlib/inftrees.js
var MAXBITS = 15;
var ENOUGH_LENS = 852;
var ENOUGH_DISTS = 592;
var CODES = 0;
var LENS = 1;
var DISTS = 2;
var lbase = [
  /* Length codes 257..285 base */
  3,
  4,
  5,
  6,
  7,
  8,
  9,
  10,
  11,
  13,
  15,
  17,
  19,
  23,
  27,
  31,
  35,
  43,
  51,
  59,
  67,
  83,
  99,
  115,
  131,
  163,
  195,
  227,
  258,
  0,
  0
];
var lext = [
  /* Length codes 257..285 extra */
  16,
  16,
  16,
  16,
  16,
  16,
  16,
  16,
  17,
  17,
  17,
  17,
  18,
  18,
  18,
  18,
  19,
  19,
  19,
  19,
  20,
  20,
  20,
  20,
  21,
  21,
  21,
  21,
  16,
  72,
  78
];
var dbase = [
  /* Distance codes 0..29 base */
  1,
  2,
  3,
  4,
  5,
  7,
  9,
  13,
  17,
  25,
  33,
  49,
  65,
  97,
  129,
  193,
  257,
  385,
  513,
  769,
  1025,
  1537,
  2049,
  3073,
  4097,
  6145,
  8193,
  12289,
  16385,
  24577,
  0,
  0
];
var dext = [
  /* Distance codes 0..29 extra */
  16,
  16,
  16,
  16,
  17,
  17,
  18,
  18,
  19,
  19,
  20,
  20,
  21,
  21,
  22,
  22,
  23,
  23,
  24,
  24,
  25,
  25,
  26,
  26,
  27,
  27,
  28,
  28,
  29,
  29,
  64,
  64
];
function inflate_table(type, lens, lens_index, codes, table, table_index, work, opts) {
  var bits = opts.bits;
  var len = 0;
  var sym = 0;
  var min = 0, max = 0;
  var root = 0;
  var curr = 0;
  var drop = 0;
  var left = 0;
  var used = 0;
  var huff = 0;
  var incr;
  var fill;
  var low;
  var mask;
  var next;
  var base = null;
  var base_index = 0;
  var end;
  var count = new Buf16(MAXBITS + 1);
  var offs = new Buf16(MAXBITS + 1);
  var extra = null;
  var extra_index = 0;
  var here_bits, here_op, here_val;
  for (len = 0; len <= MAXBITS; len++) {
    count[len] = 0;
  }
  for (sym = 0; sym < codes; sym++) {
    count[lens[lens_index + sym]]++;
  }
  root = bits;
  for (max = MAXBITS; max >= 1; max--) {
    if (count[max] !== 0) {
      break;
    }
  }
  if (root > max) {
    root = max;
  }
  if (max === 0) {
    table[table_index++] = 1 << 24 | 64 << 16 | 0;
    table[table_index++] = 1 << 24 | 64 << 16 | 0;
    opts.bits = 1;
    return 0;
  }
  for (min = 1; min < max; min++) {
    if (count[min] !== 0) {
      break;
    }
  }
  if (root < min) {
    root = min;
  }
  left = 1;
  for (len = 1; len <= MAXBITS; len++) {
    left <<= 1;
    left -= count[len];
    if (left < 0) {
      return -1;
    }
  }
  if (left > 0 && (type === CODES || max !== 1)) {
    return -1;
  }
  offs[1] = 0;
  for (len = 1; len < MAXBITS; len++) {
    offs[len + 1] = offs[len] + count[len];
  }
  for (sym = 0; sym < codes; sym++) {
    if (lens[lens_index + sym] !== 0) {
      work[offs[lens[lens_index + sym]]++] = sym;
    }
  }
  if (type === CODES) {
    base = extra = work;
    end = 19;
  } else if (type === LENS) {
    base = lbase;
    base_index -= 257;
    extra = lext;
    extra_index -= 257;
    end = 256;
  } else {
    base = dbase;
    extra = dext;
    end = -1;
  }
  huff = 0;
  sym = 0;
  len = min;
  next = table_index;
  curr = root;
  drop = 0;
  low = -1;
  used = 1 << root;
  mask = used - 1;
  if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
    return 1;
  }
  for (; ; ) {
    here_bits = len - drop;
    if (work[sym] < end) {
      here_op = 0;
      here_val = work[sym];
    } else if (work[sym] > end) {
      here_op = extra[extra_index + work[sym]];
      here_val = base[base_index + work[sym]];
    } else {
      here_op = 32 + 64;
      here_val = 0;
    }
    incr = 1 << len - drop;
    fill = 1 << curr;
    min = fill;
    do {
      fill -= incr;
      table[next + (huff >> drop) + fill] = here_bits << 24 | here_op << 16 | here_val | 0;
    } while (fill !== 0);
    incr = 1 << len - 1;
    while (huff & incr) {
      incr >>= 1;
    }
    if (incr !== 0) {
      huff &= incr - 1;
      huff += incr;
    } else {
      huff = 0;
    }
    sym++;
    if (--count[len] === 0) {
      if (len === max) {
        break;
      }
      len = lens[lens_index + work[sym]];
    }
    if (len > root && (huff & mask) !== low) {
      if (drop === 0) {
        drop = root;
      }
      next += min;
      curr = len - drop;
      left = 1 << curr;
      while (curr + drop < max) {
        left -= count[curr + drop];
        if (left <= 0) {
          break;
        }
        curr++;
        left <<= 1;
      }
      used += 1 << curr;
      if (type === LENS && used > ENOUGH_LENS || type === DISTS && used > ENOUGH_DISTS) {
        return 1;
      }
      low = huff & mask;
      table[low] = root << 24 | curr << 16 | next - table_index | 0;
    }
  }
  if (huff !== 0) {
    table[next + huff] = len - drop << 24 | 64 << 16 | 0;
  }
  opts.bits = root;
  return 0;
}

// vendor/pako/lib/zlib/inflate.js
var CODES2 = 0;
var LENS2 = 1;
var DISTS2 = 2;
var Z_FINISH = 4;
var Z_BLOCK = 5;
var Z_TREES = 6;
var Z_OK = 0;
var Z_STREAM_END = 1;
var Z_NEED_DICT = 2;
var Z_STREAM_ERROR = -2;
var Z_DATA_ERROR = -3;
var Z_MEM_ERROR = -4;
var Z_BUF_ERROR = -5;
var Z_DEFLATED = 8;
var HEAD = 1;
var FLAGS = 2;
var TIME = 3;
var OS = 4;
var EXLEN = 5;
var EXTRA = 6;
var NAME = 7;
var COMMENT = 8;
var HCRC = 9;
var DICTID = 10;
var DICT = 11;
var TYPE2 = 12;
var TYPEDO = 13;
var STORED = 14;
var COPY_ = 15;
var COPY = 16;
var TABLE = 17;
var LENLENS = 18;
var CODELENS = 19;
var LEN_ = 20;
var LEN = 21;
var LENEXT = 22;
var DIST = 23;
var DISTEXT = 24;
var MATCH = 25;
var LIT = 26;
var CHECK = 27;
var LENGTH = 28;
var DONE = 29;
var BAD2 = 30;
var MEM = 31;
var SYNC = 32;
var ENOUGH_LENS2 = 852;
var ENOUGH_DISTS2 = 592;
var MAX_WBITS = 15;
var DEF_WBITS = MAX_WBITS;
function zswap32(q) {
  return (q >>> 24 & 255) + (q >>> 8 & 65280) + ((q & 65280) << 8) + ((q & 255) << 24);
}
function InflateState() {
  this.mode = 0;
  this.last = false;
  this.wrap = 0;
  this.havedict = false;
  this.flags = 0;
  this.dmax = 0;
  this.check = 0;
  this.total = 0;
  this.head = null;
  this.wbits = 0;
  this.wsize = 0;
  this.whave = 0;
  this.wnext = 0;
  this.window = null;
  this.hold = 0;
  this.bits = 0;
  this.length = 0;
  this.offset = 0;
  this.extra = 0;
  this.lencode = null;
  this.distcode = null;
  this.lenbits = 0;
  this.distbits = 0;
  this.ncode = 0;
  this.nlen = 0;
  this.ndist = 0;
  this.have = 0;
  this.next = null;
  this.lens = new Buf16(320);
  this.work = new Buf16(288);
  this.lendyn = null;
  this.distdyn = null;
  this.sane = 0;
  this.back = 0;
  this.was = 0;
}
function inflateResetKeep(strm) {
  var state;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR;
  }
  state = strm.state;
  strm.total_in = strm.total_out = state.total = 0;
  strm.msg = "";
  if (state.wrap) {
    strm.adler = state.wrap & 1;
  }
  state.mode = HEAD;
  state.last = 0;
  state.havedict = 0;
  state.dmax = 32768;
  state.head = null;
  state.hold = 0;
  state.bits = 0;
  state.lencode = state.lendyn = new Buf32(ENOUGH_LENS2);
  state.distcode = state.distdyn = new Buf32(ENOUGH_DISTS2);
  state.sane = 1;
  state.back = -1;
  return Z_OK;
}
function inflateReset(strm) {
  var state;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR;
  }
  state = strm.state;
  state.wsize = 0;
  state.whave = 0;
  state.wnext = 0;
  return inflateResetKeep(strm);
}
function inflateReset2(strm, windowBits) {
  var wrap;
  var state;
  if (!strm || !strm.state) {
    return Z_STREAM_ERROR;
  }
  state = strm.state;
  if (windowBits < 0) {
    wrap = 0;
    windowBits = -windowBits;
  } else {
    wrap = (windowBits >> 4) + 1;
    if (windowBits < 48) {
      windowBits &= 15;
    }
  }
  if (windowBits && (windowBits < 8 || windowBits > 15)) {
    return Z_STREAM_ERROR;
  }
  if (state.window !== null && state.wbits !== windowBits) {
    state.window = null;
  }
  state.wrap = wrap;
  state.wbits = windowBits;
  return inflateReset(strm);
}
function inflateInit2(strm, windowBits) {
  var ret;
  var state;
  if (!strm) {
    return Z_STREAM_ERROR;
  }
  state = new InflateState();
  strm.state = state;
  state.window = null;
  ret = inflateReset2(strm, windowBits);
  if (ret !== Z_OK) {
    strm.state = null;
  }
  return ret;
}
function inflateInit(strm) {
  return inflateInit2(strm, DEF_WBITS);
}
var virgin = true;
var lenfix;
var distfix;
function fixedtables(state) {
  if (virgin) {
    var sym;
    lenfix = new Buf32(512);
    distfix = new Buf32(32);
    sym = 0;
    while (sym < 144) {
      state.lens[sym++] = 8;
    }
    while (sym < 256) {
      state.lens[sym++] = 9;
    }
    while (sym < 280) {
      state.lens[sym++] = 7;
    }
    while (sym < 288) {
      state.lens[sym++] = 8;
    }
    inflate_table(LENS2, state.lens, 0, 288, lenfix, 0, state.work, { bits: 9 });
    sym = 0;
    while (sym < 32) {
      state.lens[sym++] = 5;
    }
    inflate_table(DISTS2, state.lens, 0, 32, distfix, 0, state.work, { bits: 5 });
    virgin = false;
  }
  state.lencode = lenfix;
  state.lenbits = 9;
  state.distcode = distfix;
  state.distbits = 5;
}
function updatewindow(strm, src, end, copy) {
  var dist;
  var state = strm.state;
  if (state.window === null) {
    state.wsize = 1 << state.wbits;
    state.wnext = 0;
    state.whave = 0;
    state.window = new Buf8(state.wsize);
  }
  if (copy >= state.wsize) {
    arraySet(state.window, src, end - state.wsize, state.wsize, 0);
    state.wnext = 0;
    state.whave = state.wsize;
  } else {
    dist = state.wsize - state.wnext;
    if (dist > copy) {
      dist = copy;
    }
    arraySet(state.window, src, end - copy, dist, state.wnext);
    copy -= dist;
    if (copy) {
      arraySet(state.window, src, end - copy, copy, 0);
      state.wnext = copy;
      state.whave = state.wsize;
    } else {
      state.wnext += dist;
      if (state.wnext === state.wsize) {
        state.wnext = 0;
      }
      if (state.whave < state.wsize) {
        state.whave += dist;
      }
    }
  }
  return 0;
}
function inflate(strm, flush) {
  var state;
  var input, output;
  var next;
  var put;
  var have, left;
  var hold;
  var bits;
  var _in, _out;
  var copy;
  var from;
  var from_source;
  var here = 0;
  var here_bits, here_op, here_val;
  var last_bits, last_op, last_val;
  var len;
  var ret;
  var hbuf = new Buf8(4);
  var opts;
  var n;
  var order = (
    /* permutation of code lengths */
    [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]
  );
  if (!strm || !strm.state || !strm.output || !strm.input && strm.avail_in !== 0) {
    return Z_STREAM_ERROR;
  }
  state = strm.state;
  if (state.mode === TYPE2) {
    state.mode = TYPEDO;
  }
  put = strm.next_out;
  output = strm.output;
  left = strm.avail_out;
  next = strm.next_in;
  input = strm.input;
  have = strm.avail_in;
  hold = state.hold;
  bits = state.bits;
  _in = have;
  _out = left;
  ret = Z_OK;
  inf_leave:
    for (; ; ) {
      switch (state.mode) {
        case HEAD:
          if (state.wrap === 0) {
            state.mode = TYPEDO;
            break;
          }
          while (bits < 16) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (state.wrap & 2 && hold === 35615) {
            state.check = 0;
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            state.check = makeTable(state.check, hbuf, 2, 0);
            hold = 0;
            bits = 0;
            state.mode = FLAGS;
            break;
          }
          state.flags = 0;
          if (state.head) {
            state.head.done = false;
          }
          if (!(state.wrap & 1) || /* check if zlib header allowed */
          (((hold & 255) << 8) + (hold >> 8)) % 31) {
            strm.msg = "incorrect header check";
            state.mode = BAD2;
            break;
          }
          if ((hold & 15) !== Z_DEFLATED) {
            strm.msg = "unknown compression method";
            state.mode = BAD2;
            break;
          }
          hold >>>= 4;
          bits -= 4;
          len = (hold & 15) + 8;
          if (state.wbits === 0) {
            state.wbits = len;
          } else if (len > state.wbits) {
            strm.msg = "invalid window size";
            state.mode = BAD2;
            break;
          }
          state.dmax = 1 << len;
          strm.adler = state.check = 1;
          state.mode = hold & 512 ? DICTID : TYPE2;
          hold = 0;
          bits = 0;
          break;
        case FLAGS:
          while (bits < 16) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          state.flags = hold;
          if ((state.flags & 255) !== Z_DEFLATED) {
            strm.msg = "unknown compression method";
            state.mode = BAD2;
            break;
          }
          if (state.flags & 57344) {
            strm.msg = "unknown header flags set";
            state.mode = BAD2;
            break;
          }
          if (state.head) {
            state.head.text = hold >> 8 & 1;
          }
          if (state.flags & 512) {
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            state.check = makeTable(state.check, hbuf, 2, 0);
          }
          hold = 0;
          bits = 0;
          state.mode = TIME;
        /* falls through */
        case TIME:
          while (bits < 32) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (state.head) {
            state.head.time = hold;
          }
          if (state.flags & 512) {
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            hbuf[2] = hold >>> 16 & 255;
            hbuf[3] = hold >>> 24 & 255;
            state.check = makeTable(state.check, hbuf, 4, 0);
          }
          hold = 0;
          bits = 0;
          state.mode = OS;
        /* falls through */
        case OS:
          while (bits < 16) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (state.head) {
            state.head.xflags = hold & 255;
            state.head.os = hold >> 8;
          }
          if (state.flags & 512) {
            hbuf[0] = hold & 255;
            hbuf[1] = hold >>> 8 & 255;
            state.check = makeTable(state.check, hbuf, 2, 0);
          }
          hold = 0;
          bits = 0;
          state.mode = EXLEN;
        /* falls through */
        case EXLEN:
          if (state.flags & 1024) {
            while (bits < 16) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.length = hold;
            if (state.head) {
              state.head.extra_len = hold;
            }
            if (state.flags & 512) {
              hbuf[0] = hold & 255;
              hbuf[1] = hold >>> 8 & 255;
              state.check = makeTable(state.check, hbuf, 2, 0);
            }
            hold = 0;
            bits = 0;
          } else if (state.head) {
            state.head.extra = null;
          }
          state.mode = EXTRA;
        /* falls through */
        case EXTRA:
          if (state.flags & 1024) {
            copy = state.length;
            if (copy > have) {
              copy = have;
            }
            if (copy) {
              if (state.head) {
                len = state.head.extra_len - state.length;
                if (!state.head.extra) {
                  state.head.extra = new Array(state.head.extra_len);
                }
                arraySet(
                  state.head.extra,
                  input,
                  next,
                  // extra field is limited to 65536 bytes
                  // - no need for additional size check
                  copy,
                  /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                  len
                );
              }
              if (state.flags & 512) {
                state.check = makeTable(state.check, input, copy, next);
              }
              have -= copy;
              next += copy;
              state.length -= copy;
            }
            if (state.length) {
              break inf_leave;
            }
          }
          state.length = 0;
          state.mode = NAME;
        /* falls through */
        case NAME:
          if (state.flags & 2048) {
            if (have === 0) {
              break inf_leave;
            }
            copy = 0;
            do {
              len = input[next + copy++];
              if (state.head && len && state.length < 65536) {
                state.head.name += String.fromCharCode(len);
              }
            } while (len && copy < have);
            if (state.flags & 512) {
              state.check = makeTable(state.check, input, copy, next);
            }
            have -= copy;
            next += copy;
            if (len) {
              break inf_leave;
            }
          } else if (state.head) {
            state.head.name = null;
          }
          state.length = 0;
          state.mode = COMMENT;
        /* falls through */
        case COMMENT:
          if (state.flags & 4096) {
            if (have === 0) {
              break inf_leave;
            }
            copy = 0;
            do {
              len = input[next + copy++];
              if (state.head && len && state.length < 65536) {
                state.head.comment += String.fromCharCode(len);
              }
            } while (len && copy < have);
            if (state.flags & 512) {
              state.check = makeTable(state.check, input, copy, next);
            }
            have -= copy;
            next += copy;
            if (len) {
              break inf_leave;
            }
          } else if (state.head) {
            state.head.comment = null;
          }
          state.mode = HCRC;
        /* falls through */
        case HCRC:
          if (state.flags & 512) {
            while (bits < 16) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            if (hold !== (state.check & 65535)) {
              strm.msg = "header crc mismatch";
              state.mode = BAD2;
              break;
            }
            hold = 0;
            bits = 0;
          }
          if (state.head) {
            state.head.hcrc = state.flags >> 9 & 1;
            state.head.done = true;
          }
          strm.adler = state.check = 0;
          state.mode = TYPE2;
          break;
        case DICTID:
          while (bits < 32) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          strm.adler = state.check = zswap32(hold);
          hold = 0;
          bits = 0;
          state.mode = DICT;
        /* falls through */
        case DICT:
          if (state.havedict === 0) {
            strm.next_out = put;
            strm.avail_out = left;
            strm.next_in = next;
            strm.avail_in = have;
            state.hold = hold;
            state.bits = bits;
            return Z_NEED_DICT;
          }
          strm.adler = state.check = 1;
          state.mode = TYPE2;
        /* falls through */
        case TYPE2:
          if (flush === Z_BLOCK || flush === Z_TREES) {
            break inf_leave;
          }
        /* falls through */
        case TYPEDO:
          if (state.last) {
            hold >>>= bits & 7;
            bits -= bits & 7;
            state.mode = CHECK;
            break;
          }
          while (bits < 3) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          state.last = hold & 1;
          hold >>>= 1;
          bits -= 1;
          switch (hold & 3) {
            case 0:
              state.mode = STORED;
              break;
            case 1:
              fixedtables(state);
              state.mode = LEN_;
              if (flush === Z_TREES) {
                hold >>>= 2;
                bits -= 2;
                break inf_leave;
              }
              break;
            case 2:
              state.mode = TABLE;
              break;
            case 3:
              strm.msg = "invalid block type";
              state.mode = BAD2;
          }
          hold >>>= 2;
          bits -= 2;
          break;
        case STORED:
          hold >>>= bits & 7;
          bits -= bits & 7;
          while (bits < 32) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if ((hold & 65535) !== (hold >>> 16 ^ 65535)) {
            strm.msg = "invalid stored block lengths";
            state.mode = BAD2;
            break;
          }
          state.length = hold & 65535;
          hold = 0;
          bits = 0;
          state.mode = COPY_;
          if (flush === Z_TREES) {
            break inf_leave;
          }
        /* falls through */
        case COPY_:
          state.mode = COPY;
        /* falls through */
        case COPY:
          copy = state.length;
          if (copy) {
            if (copy > have) {
              copy = have;
            }
            if (copy > left) {
              copy = left;
            }
            if (copy === 0) {
              break inf_leave;
            }
            arraySet(output, input, next, copy, put);
            have -= copy;
            next += copy;
            left -= copy;
            put += copy;
            state.length -= copy;
            break;
          }
          state.mode = TYPE2;
          break;
        case TABLE:
          while (bits < 14) {
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          state.nlen = (hold & 31) + 257;
          hold >>>= 5;
          bits -= 5;
          state.ndist = (hold & 31) + 1;
          hold >>>= 5;
          bits -= 5;
          state.ncode = (hold & 15) + 4;
          hold >>>= 4;
          bits -= 4;
          if (state.nlen > 286 || state.ndist > 30) {
            strm.msg = "too many length or distance symbols";
            state.mode = BAD2;
            break;
          }
          state.have = 0;
          state.mode = LENLENS;
        /* falls through */
        case LENLENS:
          while (state.have < state.ncode) {
            while (bits < 3) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.lens[order[state.have++]] = hold & 7;
            hold >>>= 3;
            bits -= 3;
          }
          while (state.have < 19) {
            state.lens[order[state.have++]] = 0;
          }
          state.lencode = state.lendyn;
          state.lenbits = 7;
          opts = { bits: state.lenbits };
          ret = inflate_table(CODES2, state.lens, 0, 19, state.lencode, 0, state.work, opts);
          state.lenbits = opts.bits;
          if (ret) {
            strm.msg = "invalid code lengths set";
            state.mode = BAD2;
            break;
          }
          state.have = 0;
          state.mode = CODELENS;
        /* falls through */
        case CODELENS:
          while (state.have < state.nlen + state.ndist) {
            for (; ; ) {
              here = state.lencode[hold & (1 << state.lenbits) - 1];
              here_bits = here >>> 24;
              here_op = here >>> 16 & 255;
              here_val = here & 65535;
              if (here_bits <= bits) {
                break;
              }
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            if (here_val < 16) {
              hold >>>= here_bits;
              bits -= here_bits;
              state.lens[state.have++] = here_val;
            } else {
              if (here_val === 16) {
                n = here_bits + 2;
                while (bits < n) {
                  if (have === 0) {
                    break inf_leave;
                  }
                  have--;
                  hold += input[next++] << bits;
                  bits += 8;
                }
                hold >>>= here_bits;
                bits -= here_bits;
                if (state.have === 0) {
                  strm.msg = "invalid bit length repeat";
                  state.mode = BAD2;
                  break;
                }
                len = state.lens[state.have - 1];
                copy = 3 + (hold & 3);
                hold >>>= 2;
                bits -= 2;
              } else if (here_val === 17) {
                n = here_bits + 3;
                while (bits < n) {
                  if (have === 0) {
                    break inf_leave;
                  }
                  have--;
                  hold += input[next++] << bits;
                  bits += 8;
                }
                hold >>>= here_bits;
                bits -= here_bits;
                len = 0;
                copy = 3 + (hold & 7);
                hold >>>= 3;
                bits -= 3;
              } else {
                n = here_bits + 7;
                while (bits < n) {
                  if (have === 0) {
                    break inf_leave;
                  }
                  have--;
                  hold += input[next++] << bits;
                  bits += 8;
                }
                hold >>>= here_bits;
                bits -= here_bits;
                len = 0;
                copy = 11 + (hold & 127);
                hold >>>= 7;
                bits -= 7;
              }
              if (state.have + copy > state.nlen + state.ndist) {
                strm.msg = "invalid bit length repeat";
                state.mode = BAD2;
                break;
              }
              while (copy--) {
                state.lens[state.have++] = len;
              }
            }
          }
          if (state.mode === BAD2) {
            break;
          }
          if (state.lens[256] === 0) {
            strm.msg = "invalid code -- missing end-of-block";
            state.mode = BAD2;
            break;
          }
          state.lenbits = 9;
          opts = { bits: state.lenbits };
          ret = inflate_table(LENS2, state.lens, 0, state.nlen, state.lencode, 0, state.work, opts);
          state.lenbits = opts.bits;
          if (ret) {
            strm.msg = "invalid literal/lengths set";
            state.mode = BAD2;
            break;
          }
          state.distbits = 6;
          state.distcode = state.distdyn;
          opts = { bits: state.distbits };
          ret = inflate_table(DISTS2, state.lens, state.nlen, state.ndist, state.distcode, 0, state.work, opts);
          state.distbits = opts.bits;
          if (ret) {
            strm.msg = "invalid distances set";
            state.mode = BAD2;
            break;
          }
          state.mode = LEN_;
          if (flush === Z_TREES) {
            break inf_leave;
          }
        /* falls through */
        case LEN_:
          state.mode = LEN;
        /* falls through */
        case LEN:
          if (have >= 6 && left >= 258) {
            strm.next_out = put;
            strm.avail_out = left;
            strm.next_in = next;
            strm.avail_in = have;
            state.hold = hold;
            state.bits = bits;
            inflate_fast(strm, _out);
            put = strm.next_out;
            output = strm.output;
            left = strm.avail_out;
            next = strm.next_in;
            input = strm.input;
            have = strm.avail_in;
            hold = state.hold;
            bits = state.bits;
            if (state.mode === TYPE2) {
              state.back = -1;
            }
            break;
          }
          state.back = 0;
          for (; ; ) {
            here = state.lencode[hold & (1 << state.lenbits) - 1];
            here_bits = here >>> 24;
            here_op = here >>> 16 & 255;
            here_val = here & 65535;
            if (here_bits <= bits) {
              break;
            }
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if (here_op && (here_op & 240) === 0) {
            last_bits = here_bits;
            last_op = here_op;
            last_val = here_val;
            for (; ; ) {
              here = state.lencode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
              here_bits = here >>> 24;
              here_op = here >>> 16 & 255;
              here_val = here & 65535;
              if (last_bits + here_bits <= bits) {
                break;
              }
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            hold >>>= last_bits;
            bits -= last_bits;
            state.back += last_bits;
          }
          hold >>>= here_bits;
          bits -= here_bits;
          state.back += here_bits;
          state.length = here_val;
          if (here_op === 0) {
            state.mode = LIT;
            break;
          }
          if (here_op & 32) {
            state.back = -1;
            state.mode = TYPE2;
            break;
          }
          if (here_op & 64) {
            strm.msg = "invalid literal/length code";
            state.mode = BAD2;
            break;
          }
          state.extra = here_op & 15;
          state.mode = LENEXT;
        /* falls through */
        case LENEXT:
          if (state.extra) {
            n = state.extra;
            while (bits < n) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.length += hold & (1 << state.extra) - 1;
            hold >>>= state.extra;
            bits -= state.extra;
            state.back += state.extra;
          }
          state.was = state.length;
          state.mode = DIST;
        /* falls through */
        case DIST:
          for (; ; ) {
            here = state.distcode[hold & (1 << state.distbits) - 1];
            here_bits = here >>> 24;
            here_op = here >>> 16 & 255;
            here_val = here & 65535;
            if (here_bits <= bits) {
              break;
            }
            if (have === 0) {
              break inf_leave;
            }
            have--;
            hold += input[next++] << bits;
            bits += 8;
          }
          if ((here_op & 240) === 0) {
            last_bits = here_bits;
            last_op = here_op;
            last_val = here_val;
            for (; ; ) {
              here = state.distcode[last_val + ((hold & (1 << last_bits + last_op) - 1) >> last_bits)];
              here_bits = here >>> 24;
              here_op = here >>> 16 & 255;
              here_val = here & 65535;
              if (last_bits + here_bits <= bits) {
                break;
              }
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            hold >>>= last_bits;
            bits -= last_bits;
            state.back += last_bits;
          }
          hold >>>= here_bits;
          bits -= here_bits;
          state.back += here_bits;
          if (here_op & 64) {
            strm.msg = "invalid distance code";
            state.mode = BAD2;
            break;
          }
          state.offset = here_val;
          state.extra = here_op & 15;
          state.mode = DISTEXT;
        /* falls through */
        case DISTEXT:
          if (state.extra) {
            n = state.extra;
            while (bits < n) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            state.offset += hold & (1 << state.extra) - 1;
            hold >>>= state.extra;
            bits -= state.extra;
            state.back += state.extra;
          }
          if (state.offset > state.dmax) {
            strm.msg = "invalid distance too far back";
            state.mode = BAD2;
            break;
          }
          state.mode = MATCH;
        /* falls through */
        case MATCH:
          if (left === 0) {
            break inf_leave;
          }
          copy = _out - left;
          if (state.offset > copy) {
            copy = state.offset - copy;
            if (copy > state.whave) {
              if (state.sane) {
                strm.msg = "invalid distance too far back";
                state.mode = BAD2;
                break;
              }
            }
            if (copy > state.wnext) {
              copy -= state.wnext;
              from = state.wsize - copy;
            } else {
              from = state.wnext - copy;
            }
            if (copy > state.length) {
              copy = state.length;
            }
            from_source = state.window;
          } else {
            from_source = output;
            from = put - state.offset;
            copy = state.length;
          }
          if (copy > left) {
            copy = left;
          }
          left -= copy;
          state.length -= copy;
          do {
            output[put++] = from_source[from++];
          } while (--copy);
          if (state.length === 0) {
            state.mode = LEN;
          }
          break;
        case LIT:
          if (left === 0) {
            break inf_leave;
          }
          output[put++] = state.length;
          left--;
          state.mode = LEN;
          break;
        case CHECK:
          if (state.wrap) {
            while (bits < 32) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold |= input[next++] << bits;
              bits += 8;
            }
            _out -= left;
            strm.total_out += _out;
            state.total += _out;
            if (_out) {
              strm.adler = state.check = /*UPDATE(state.check, put - _out, _out);*/
              state.flags ? makeTable(state.check, output, _out, put - _out) : adler32(state.check, output, _out, put - _out);
            }
            _out = left;
            if ((state.flags ? hold : zswap32(hold)) !== state.check) {
              strm.msg = "incorrect data check";
              state.mode = BAD2;
              break;
            }
            hold = 0;
            bits = 0;
          }
          state.mode = LENGTH;
        /* falls through */
        case LENGTH:
          if (state.wrap && state.flags) {
            while (bits < 32) {
              if (have === 0) {
                break inf_leave;
              }
              have--;
              hold += input[next++] << bits;
              bits += 8;
            }
            if (hold !== (state.total & 4294967295)) {
              strm.msg = "incorrect length check";
              state.mode = BAD2;
              break;
            }
            hold = 0;
            bits = 0;
          }
          state.mode = DONE;
        /* falls through */
        case DONE:
          ret = Z_STREAM_END;
          break inf_leave;
        case BAD2:
          ret = Z_DATA_ERROR;
          break inf_leave;
        case MEM:
          return Z_MEM_ERROR;
        case SYNC:
        /* falls through */
        default:
          return Z_STREAM_ERROR;
      }
    }
  strm.next_out = put;
  strm.avail_out = left;
  strm.next_in = next;
  strm.avail_in = have;
  state.hold = hold;
  state.bits = bits;
  if (state.wsize || _out !== strm.avail_out && state.mode < BAD2 && (state.mode < CHECK || flush !== Z_FINISH)) {
    if (updatewindow(strm, strm.output, strm.next_out, _out - strm.avail_out)) {
      state.mode = MEM;
      return Z_MEM_ERROR;
    }
  }
  _in -= strm.avail_in;
  _out -= strm.avail_out;
  strm.total_in += _in;
  strm.total_out += _out;
  state.total += _out;
  if (state.wrap && _out) {
    strm.adler = state.check = /*UPDATE(state.check, strm.next_out - _out, _out);*/
    state.flags ? makeTable(state.check, output, _out, strm.next_out - _out) : adler32(state.check, output, _out, strm.next_out - _out);
  }
  strm.data_type = state.bits + (state.last ? 64 : 0) + (state.mode === TYPE2 ? 128 : 0) + (state.mode === LEN_ || state.mode === COPY_ ? 256 : 0);
  if ((_in === 0 && _out === 0 || flush === Z_FINISH) && ret === Z_OK) {
    ret = Z_BUF_ERROR;
  }
  return ret;
}

// vendor/pako/lib/zlib/zstream.js
function ZStream() {
  this.input = null;
  this.next_in = 0;
  this.avail_in = 0;
  this.total_in = 0;
  this.output = null;
  this.next_out = 0;
  this.avail_out = 0;
  this.total_out = 0;
  this.msg = "";
  this.state = null;
  this.data_type = 2;
  this.adler = 0;
}

// core/inflator.js
var Inflate = class {
  constructor() {
    this.strm = new ZStream();
    this.chunkSize = 1024 * 10 * 10;
    this.strm.output = new Uint8Array(this.chunkSize);
    inflateInit(this.strm);
  }
  setInput(data) {
    if (!data) {
      this.strm.input = null;
      this.strm.avail_in = 0;
      this.strm.next_in = 0;
    } else {
      this.strm.input = data;
      this.strm.avail_in = this.strm.input.length;
      this.strm.next_in = 0;
    }
  }
  inflate(expected) {
    if (expected > this.chunkSize) {
      this.chunkSize = expected;
      this.strm.output = new Uint8Array(this.chunkSize);
    }
    this.strm.next_out = 0;
    this.strm.avail_out = expected;
    let ret = inflate(this.strm, 0);
    if (ret < 0) {
      throw new Error("zlib inflate failed");
    }
    if (this.strm.next_out != expected) {
      throw new Error("Incomplete zlib block");
    }
    return new Uint8Array(this.strm.output.buffer, 0, this.strm.next_out);
  }
  reset() {
    inflateReset(this.strm);
  }
};

// vendor/pako/lib/zlib/trees.js
var Z_FIXED = 4;
var Z_BINARY = 0;
var Z_TEXT = 1;
var Z_UNKNOWN = 2;
function zero(buf) {
  var len = buf.length;
  while (--len >= 0) {
    buf[len] = 0;
  }
}
var STORED_BLOCK = 0;
var STATIC_TREES = 1;
var DYN_TREES = 2;
var MIN_MATCH = 3;
var MAX_MATCH = 258;
var LENGTH_CODES = 29;
var LITERALS = 256;
var L_CODES = LITERALS + 1 + LENGTH_CODES;
var D_CODES = 30;
var BL_CODES = 19;
var HEAP_SIZE = 2 * L_CODES + 1;
var MAX_BITS = 15;
var Buf_size = 16;
var MAX_BL_BITS = 7;
var END_BLOCK = 256;
var REP_3_6 = 16;
var REPZ_3_10 = 17;
var REPZ_11_138 = 18;
var extra_lbits = (
  /* extra bits for each length code */
  [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]
);
var extra_dbits = (
  /* extra bits for each distance code */
  [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]
);
var extra_blbits = (
  /* extra bits for each bit length code */
  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]
);
var bl_order = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
var DIST_CODE_LEN = 512;
var static_ltree = new Array((L_CODES + 2) * 2);
zero(static_ltree);
var static_dtree = new Array(D_CODES * 2);
zero(static_dtree);
var _dist_code = new Array(DIST_CODE_LEN);
zero(_dist_code);
var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);
zero(_length_code);
var base_length = new Array(LENGTH_CODES);
zero(base_length);
var base_dist = new Array(D_CODES);
zero(base_dist);
function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {
  this.static_tree = static_tree;
  this.extra_bits = extra_bits;
  this.extra_base = extra_base;
  this.elems = elems;
  this.max_length = max_length;
  this.has_stree = static_tree && static_tree.length;
}
var static_l_desc;
var static_d_desc;
var static_bl_desc;
function TreeDesc(dyn_tree, stat_desc) {
  this.dyn_tree = dyn_tree;
  this.max_code = 0;
  this.stat_desc = stat_desc;
}
function d_code(dist) {
  return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];
}
function put_short(s, w) {
  s.pending_buf[s.pending++] = w & 255;
  s.pending_buf[s.pending++] = w >>> 8 & 255;
}
function send_bits(s, value, length) {
  if (s.bi_valid > Buf_size - length) {
    s.bi_buf |= value << s.bi_valid & 65535;
    put_short(s, s.bi_buf);
    s.bi_buf = value >> Buf_size - s.bi_valid;
    s.bi_valid += length - Buf_size;
  } else {
    s.bi_buf |= value << s.bi_valid & 65535;
    s.bi_valid += length;
  }
}
function send_code(s, c2, tree) {
  send_bits(
    s,
    tree[c2 * 2],
    tree[c2 * 2 + 1]
    /*.Len*/
  );
}
function bi_reverse(code, len) {
  var res = 0;
  do {
    res |= code & 1;
    code >>>= 1;
    res <<= 1;
  } while (--len > 0);
  return res >>> 1;
}
function bi_flush(s) {
  if (s.bi_valid === 16) {
    put_short(s, s.bi_buf);
    s.bi_buf = 0;
    s.bi_valid = 0;
  } else if (s.bi_valid >= 8) {
    s.pending_buf[s.pending++] = s.bi_buf & 255;
    s.bi_buf >>= 8;
    s.bi_valid -= 8;
  }
}
function gen_bitlen(s, desc) {
  var tree = desc.dyn_tree;
  var max_code = desc.max_code;
  var stree = desc.stat_desc.static_tree;
  var has_stree = desc.stat_desc.has_stree;
  var extra = desc.stat_desc.extra_bits;
  var base = desc.stat_desc.extra_base;
  var max_length = desc.stat_desc.max_length;
  var h;
  var n, m;
  var bits;
  var xbits;
  var f2;
  var overflow = 0;
  for (bits = 0; bits <= MAX_BITS; bits++) {
    s.bl_count[bits] = 0;
  }
  tree[s.heap[s.heap_max] * 2 + 1] = 0;
  for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {
    n = s.heap[h];
    bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
    if (bits > max_length) {
      bits = max_length;
      overflow++;
    }
    tree[n * 2 + 1] = bits;
    if (n > max_code) {
      continue;
    }
    s.bl_count[bits]++;
    xbits = 0;
    if (n >= base) {
      xbits = extra[n - base];
    }
    f2 = tree[n * 2];
    s.opt_len += f2 * (bits + xbits);
    if (has_stree) {
      s.static_len += f2 * (stree[n * 2 + 1] + xbits);
    }
  }
  if (overflow === 0) {
    return;
  }
  do {
    bits = max_length - 1;
    while (s.bl_count[bits] === 0) {
      bits--;
    }
    s.bl_count[bits]--;
    s.bl_count[bits + 1] += 2;
    s.bl_count[max_length]--;
    overflow -= 2;
  } while (overflow > 0);
  for (bits = max_length; bits !== 0; bits--) {
    n = s.bl_count[bits];
    while (n !== 0) {
      m = s.heap[--h];
      if (m > max_code) {
        continue;
      }
      if (tree[m * 2 + 1] !== bits) {
        s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
        tree[m * 2 + 1] = bits;
      }
      n--;
    }
  }
}
function gen_codes(tree, max_code, bl_count) {
  var next_code = new Array(MAX_BITS + 1);
  var code = 0;
  var bits;
  var n;
  for (bits = 1; bits <= MAX_BITS; bits++) {
    next_code[bits] = code = code + bl_count[bits - 1] << 1;
  }
  for (n = 0; n <= max_code; n++) {
    var len = tree[n * 2 + 1];
    if (len === 0) {
      continue;
    }
    tree[n * 2] = bi_reverse(next_code[len]++, len);
  }
}
function tr_static_init() {
  var n;
  var bits;
  var length;
  var code;
  var dist;
  var bl_count = new Array(MAX_BITS + 1);
  length = 0;
  for (code = 0; code < LENGTH_CODES - 1; code++) {
    base_length[code] = length;
    for (n = 0; n < 1 << extra_lbits[code]; n++) {
      _length_code[length++] = code;
    }
  }
  _length_code[length - 1] = code;
  dist = 0;
  for (code = 0; code < 16; code++) {
    base_dist[code] = dist;
    for (n = 0; n < 1 << extra_dbits[code]; n++) {
      _dist_code[dist++] = code;
    }
  }
  dist >>= 7;
  for (; code < D_CODES; code++) {
    base_dist[code] = dist << 7;
    for (n = 0; n < 1 << extra_dbits[code] - 7; n++) {
      _dist_code[256 + dist++] = code;
    }
  }
  for (bits = 0; bits <= MAX_BITS; bits++) {
    bl_count[bits] = 0;
  }
  n = 0;
  while (n <= 143) {
    static_ltree[n * 2 + 1] = 8;
    n++;
    bl_count[8]++;
  }
  while (n <= 255) {
    static_ltree[n * 2 + 1] = 9;
    n++;
    bl_count[9]++;
  }
  while (n <= 279) {
    static_ltree[n * 2 + 1] = 7;
    n++;
    bl_count[7]++;
  }
  while (n <= 287) {
    static_ltree[n * 2 + 1] = 8;
    n++;
    bl_count[8]++;
  }
  gen_codes(static_ltree, L_CODES + 1, bl_count);
  for (n = 0; n < D_CODES; n++) {
    static_dtree[n * 2 + 1] = 5;
    static_dtree[n * 2] = bi_reverse(n, 5);
  }
  static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);
  static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);
  static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);
}
function init_block(s) {
  var n;
  for (n = 0; n < L_CODES; n++) {
    s.dyn_ltree[n * 2] = 0;
  }
  for (n = 0; n < D_CODES; n++) {
    s.dyn_dtree[n * 2] = 0;
  }
  for (n = 0; n < BL_CODES; n++) {
    s.bl_tree[n * 2] = 0;
  }
  s.dyn_ltree[END_BLOCK * 2] = 1;
  s.opt_len = s.static_len = 0;
  s.last_lit = s.matches = 0;
}
function bi_windup(s) {
  if (s.bi_valid > 8) {
    put_short(s, s.bi_buf);
  } else if (s.bi_valid > 0) {
    s.pending_buf[s.pending++] = s.bi_buf;
  }
  s.bi_buf = 0;
  s.bi_valid = 0;
}
function copy_block(s, buf, len, header) {
  bi_windup(s);
  if (header) {
    put_short(s, len);
    put_short(s, ~len);
  }
  arraySet(s.pending_buf, s.window, buf, len, s.pending);
  s.pending += len;
}
function smaller(tree, n, m, depth) {
  var _n2 = n * 2;
  var _m2 = m * 2;
  return tree[_n2] < tree[_m2] || tree[_n2] === tree[_m2] && depth[n] <= depth[m];
}
function pqdownheap(s, tree, k) {
  var v = s.heap[k];
  var j = k << 1;
  while (j <= s.heap_len) {
    if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {
      j++;
    }
    if (smaller(tree, v, s.heap[j], s.depth)) {
      break;
    }
    s.heap[k] = s.heap[j];
    k = j;
    j <<= 1;
  }
  s.heap[k] = v;
}
function compress_block(s, ltree, dtree) {
  var dist;
  var lc;
  var lx = 0;
  var code;
  var extra;
  if (s.last_lit !== 0) {
    do {
      dist = s.pending_buf[s.d_buf + lx * 2] << 8 | s.pending_buf[s.d_buf + lx * 2 + 1];
      lc = s.pending_buf[s.l_buf + lx];
      lx++;
      if (dist === 0) {
        send_code(s, lc, ltree);
      } else {
        code = _length_code[lc];
        send_code(s, code + LITERALS + 1, ltree);
        extra = extra_lbits[code];
        if (extra !== 0) {
          lc -= base_length[code];
          send_bits(s, lc, extra);
        }
        dist--;
        code = d_code(dist);
        send_code(s, code, dtree);
        extra = extra_dbits[code];
        if (extra !== 0) {
          dist -= base_dist[code];
          send_bits(s, dist, extra);
        }
      }
    } while (lx < s.last_lit);
  }
  send_code(s, END_BLOCK, ltree);
}
function build_tree(s, desc) {
  var tree = desc.dyn_tree;
  var stree = desc.stat_desc.static_tree;
  var has_stree = desc.stat_desc.has_stree;
  var elems = desc.stat_desc.elems;
  var n, m;
  var max_code = -1;
  var node;
  s.heap_len = 0;
  s.heap_max = HEAP_SIZE;
  for (n = 0; n < elems; n++) {
    if (tree[n * 2] !== 0) {
      s.heap[++s.heap_len] = max_code = n;
      s.depth[n] = 0;
    } else {
      tree[n * 2 + 1] = 0;
    }
  }
  while (s.heap_len < 2) {
    node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;
    tree[node * 2] = 1;
    s.depth[node] = 0;
    s.opt_len--;
    if (has_stree) {
      s.static_len -= stree[node * 2 + 1];
    }
  }
  desc.max_code = max_code;
  for (n = s.heap_len >> 1; n >= 1; n--) {
    pqdownheap(s, tree, n);
  }
  node = elems;
  do {
    n = s.heap[
      1
      /*SMALLEST*/
    ];
    s.heap[
      1
      /*SMALLEST*/
    ] = s.heap[s.heap_len--];
    pqdownheap(
      s,
      tree,
      1
      /*SMALLEST*/
    );
    m = s.heap[
      1
      /*SMALLEST*/
    ];
    s.heap[--s.heap_max] = n;
    s.heap[--s.heap_max] = m;
    tree[node * 2] = tree[n * 2] + tree[m * 2];
    s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;
    tree[n * 2 + 1] = tree[m * 2 + 1] = node;
    s.heap[
      1
      /*SMALLEST*/
    ] = node++;
    pqdownheap(
      s,
      tree,
      1
      /*SMALLEST*/
    );
  } while (s.heap_len >= 2);
  s.heap[--s.heap_max] = s.heap[
    1
    /*SMALLEST*/
  ];
  gen_bitlen(s, desc);
  gen_codes(tree, max_code, s.bl_count);
}
function scan_tree(s, tree, max_code) {
  var n;
  var prevlen = -1;
  var curlen;
  var nextlen = tree[0 * 2 + 1];
  var count = 0;
  var max_count = 7;
  var min_count = 4;
  if (nextlen === 0) {
    max_count = 138;
    min_count = 3;
  }
  tree[(max_code + 1) * 2 + 1] = 65535;
  for (n = 0; n <= max_code; n++) {
    curlen = nextlen;
    nextlen = tree[(n + 1) * 2 + 1];
    if (++count < max_count && curlen === nextlen) {
      continue;
    } else if (count < min_count) {
      s.bl_tree[curlen * 2] += count;
    } else if (curlen !== 0) {
      if (curlen !== prevlen) {
        s.bl_tree[curlen * 2]++;
      }
      s.bl_tree[REP_3_6 * 2]++;
    } else if (count <= 10) {
      s.bl_tree[REPZ_3_10 * 2]++;
    } else {
      s.bl_tree[REPZ_11_138 * 2]++;
    }
    count = 0;
    prevlen = curlen;
    if (nextlen === 0) {
      max_count = 138;
      min_count = 3;
    } else if (curlen === nextlen) {
      max_count = 6;
      min_count = 3;
    } else {
      max_count = 7;
      min_count = 4;
    }
  }
}
function send_tree(s, tree, max_code) {
  var n;
  var prevlen = -1;
  var curlen;
  var nextlen = tree[0 * 2 + 1];
  var count = 0;
  var max_count = 7;
  var min_count = 4;
  if (nextlen === 0) {
    max_count = 138;
    min_count = 3;
  }
  for (n = 0; n <= max_code; n++) {
    curlen = nextlen;
    nextlen = tree[(n + 1) * 2 + 1];
    if (++count < max_count && curlen === nextlen) {
      continue;
    } else if (count < min_count) {
      do {
        send_code(s, curlen, s.bl_tree);
      } while (--count !== 0);
    } else if (curlen !== 0) {
      if (curlen !== prevlen) {
        send_code(s, curlen, s.bl_tree);
        count--;
      }
      send_code(s, REP_3_6, s.bl_tree);
      send_bits(s, count - 3, 2);
    } else if (count <= 10) {
      send_code(s, REPZ_3_10, s.bl_tree);
      send_bits(s, count - 3, 3);
    } else {
      send_code(s, REPZ_11_138, s.bl_tree);
      send_bits(s, count - 11, 7);
    }
    count = 0;
    prevlen = curlen;
    if (nextlen === 0) {
      max_count = 138;
      min_count = 3;
    } else if (curlen === nextlen) {
      max_count = 6;
      min_count = 3;
    } else {
      max_count = 7;
      min_count = 4;
    }
  }
}
function build_bl_tree(s) {
  var max_blindex;
  scan_tree(s, s.dyn_ltree, s.l_desc.max_code);
  scan_tree(s, s.dyn_dtree, s.d_desc.max_code);
  build_tree(s, s.bl_desc);
  for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {
    if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !== 0) {
      break;
    }
  }
  s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
  return max_blindex;
}
function send_all_trees(s, lcodes, dcodes, blcodes) {
  var rank2;
  send_bits(s, lcodes - 257, 5);
  send_bits(s, dcodes - 1, 5);
  send_bits(s, blcodes - 4, 4);
  for (rank2 = 0; rank2 < blcodes; rank2++) {
    send_bits(s, s.bl_tree[bl_order[rank2] * 2 + 1], 3);
  }
  send_tree(s, s.dyn_ltree, lcodes - 1);
  send_tree(s, s.dyn_dtree, dcodes - 1);
}
function detect_data_type(s) {
  var black_mask = 4093624447;
  var n;
  for (n = 0; n <= 31; n++, black_mask >>>= 1) {
    if (black_mask & 1 && s.dyn_ltree[n * 2] !== 0) {
      return Z_BINARY;
    }
  }
  if (s.dyn_ltree[9 * 2] !== 0 || s.dyn_ltree[10 * 2] !== 0 || s.dyn_ltree[13 * 2] !== 0) {
    return Z_TEXT;
  }
  for (n = 32; n < LITERALS; n++) {
    if (s.dyn_ltree[n * 2] !== 0) {
      return Z_TEXT;
    }
  }
  return Z_BINARY;
}
var static_init_done = false;
function _tr_init(s) {
  if (!static_init_done) {
    tr_static_init();
    static_init_done = true;
  }
  s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);
  s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);
  s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);
  s.bi_buf = 0;
  s.bi_valid = 0;
  init_block(s);
}
function _tr_stored_block(s, buf, stored_len, last) {
  send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);
  copy_block(s, buf, stored_len, true);
}
function _tr_align(s) {
  send_bits(s, STATIC_TREES << 1, 3);
  send_code(s, END_BLOCK, static_ltree);
  bi_flush(s);
}
function _tr_flush_block(s, buf, stored_len, last) {
  var opt_lenb, static_lenb;
  var max_blindex = 0;
  if (s.level > 0) {
    if (s.strm.data_type === Z_UNKNOWN) {
      s.strm.data_type = detect_data_type(s);
    }
    build_tree(s, s.l_desc);
    build_tree(s, s.d_desc);
    max_blindex = build_bl_tree(s);
    opt_lenb = s.opt_len + 3 + 7 >>> 3;
    static_lenb = s.static_len + 3 + 7 >>> 3;
    if (static_lenb <= opt_lenb) {
      opt_lenb = static_lenb;
    }
  } else {
    opt_lenb = static_lenb = stored_len + 5;
  }
  if (stored_len + 4 <= opt_lenb && buf !== -1) {
    _tr_stored_block(s, buf, stored_len, last);
  } else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {
    send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);
    compress_block(s, static_ltree, static_dtree);
  } else {
    send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);
    send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);
    compress_block(s, s.dyn_ltree, s.dyn_dtree);
  }
  init_block(s);
  if (last) {
    bi_windup(s);
  }
}
function _tr_tally(s, dist, lc) {
  s.pending_buf[s.d_buf + s.last_lit * 2] = dist >>> 8 & 255;
  s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 255;
  s.pending_buf[s.l_buf + s.last_lit] = lc & 255;
  s.last_lit++;
  if (dist === 0) {
    s.dyn_ltree[lc * 2]++;
  } else {
    s.matches++;
    dist--;
    s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2]++;
    s.dyn_dtree[d_code(dist) * 2]++;
  }
  return s.last_lit === s.lit_bufsize - 1;
}

// vendor/pako/lib/zlib/messages.js
var messages_default = {
  2: "need dictionary",
  /* Z_NEED_DICT       2  */
  1: "stream end",
  /* Z_STREAM_END      1  */
  0: "",
  /* Z_OK              0  */
  "-1": "file error",
  /* Z_ERRNO         (-1) */
  "-2": "stream error",
  /* Z_STREAM_ERROR  (-2) */
  "-3": "data error",
  /* Z_DATA_ERROR    (-3) */
  "-4": "insufficient memory",
  /* Z_MEM_ERROR     (-4) */
  "-5": "buffer error",
  /* Z_BUF_ERROR     (-5) */
  "-6": "incompatible version"
  /* Z_VERSION_ERROR (-6) */
};

// vendor/pako/lib/zlib/deflate.js
var Z_NO_FLUSH = 0;
var Z_PARTIAL_FLUSH = 1;
var Z_FULL_FLUSH = 3;
var Z_FINISH2 = 4;
var Z_BLOCK2 = 5;
var Z_OK2 = 0;
var Z_STREAM_END2 = 1;
var Z_STREAM_ERROR2 = -2;
var Z_BUF_ERROR2 = -5;
var Z_DEFAULT_COMPRESSION = -1;
var Z_FILTERED = 1;
var Z_HUFFMAN_ONLY = 2;
var Z_RLE = 3;
var Z_FIXED2 = 4;
var Z_DEFAULT_STRATEGY = 0;
var Z_UNKNOWN2 = 2;
var Z_DEFLATED2 = 8;
var MAX_MEM_LEVEL = 9;
var MAX_WBITS2 = 15;
var DEF_MEM_LEVEL = 8;
var LENGTH_CODES2 = 29;
var LITERALS2 = 256;
var L_CODES2 = LITERALS2 + 1 + LENGTH_CODES2;
var D_CODES2 = 30;
var BL_CODES2 = 19;
var HEAP_SIZE2 = 2 * L_CODES2 + 1;
var MAX_BITS2 = 15;
var MIN_MATCH2 = 3;
var MAX_MATCH2 = 258;
var MIN_LOOKAHEAD = MAX_MATCH2 + MIN_MATCH2 + 1;
var PRESET_DICT = 32;
var INIT_STATE = 42;
var EXTRA_STATE = 69;
var NAME_STATE = 73;
var COMMENT_STATE = 91;
var HCRC_STATE = 103;
var BUSY_STATE = 113;
var FINISH_STATE = 666;
var BS_NEED_MORE = 1;
var BS_BLOCK_DONE = 2;
var BS_FINISH_STARTED = 3;
var BS_FINISH_DONE = 4;
var OS_CODE = 3;
function err(strm, errorCode) {
  strm.msg = messages_default[errorCode];
  return errorCode;
}
function rank(f2) {
  return (f2 << 1) - (f2 > 4 ? 9 : 0);
}
function zero2(buf) {
  var len = buf.length;
  while (--len >= 0) {
    buf[len] = 0;
  }
}
function flush_pending(strm) {
  var s = strm.state;
  var len = s.pending;
  if (len > strm.avail_out) {
    len = strm.avail_out;
  }
  if (len === 0) {
    return;
  }
  arraySet(strm.output, s.pending_buf, s.pending_out, len, strm.next_out);
  strm.next_out += len;
  s.pending_out += len;
  strm.total_out += len;
  strm.avail_out -= len;
  s.pending -= len;
  if (s.pending === 0) {
    s.pending_out = 0;
  }
}
function flush_block_only(s, last) {
  _tr_flush_block(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);
  s.block_start = s.strstart;
  flush_pending(s.strm);
}
function put_byte(s, b2) {
  s.pending_buf[s.pending++] = b2;
}
function putShortMSB(s, b2) {
  s.pending_buf[s.pending++] = b2 >>> 8 & 255;
  s.pending_buf[s.pending++] = b2 & 255;
}
function read_buf(strm, buf, start, size) {
  var len = strm.avail_in;
  if (len > size) {
    len = size;
  }
  if (len === 0) {
    return 0;
  }
  strm.avail_in -= len;
  arraySet(buf, strm.input, strm.next_in, len, start);
  if (strm.state.wrap === 1) {
    strm.adler = adler32(strm.adler, buf, len, start);
  } else if (strm.state.wrap === 2) {
    strm.adler = makeTable(strm.adler, buf, len, start);
  }
  strm.next_in += len;
  strm.total_in += len;
  return len;
}
function longest_match(s, cur_match) {
  var chain_length = s.max_chain_length;
  var scan = s.strstart;
  var match;
  var len;
  var best_len = s.prev_length;
  var nice_match = s.nice_match;
  var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;
  var _win = s.window;
  var wmask = s.w_mask;
  var prev = s.prev;
  var strend = s.strstart + MAX_MATCH2;
  var scan_end1 = _win[scan + best_len - 1];
  var scan_end = _win[scan + best_len];
  if (s.prev_length >= s.good_match) {
    chain_length >>= 2;
  }
  if (nice_match > s.lookahead) {
    nice_match = s.lookahead;
  }
  do {
    match = cur_match;
    if (_win[match + best_len] !== scan_end || _win[match + best_len - 1] !== scan_end1 || _win[match] !== _win[scan] || _win[++match] !== _win[scan + 1]) {
      continue;
    }
    scan += 2;
    match++;
    do {
    } while (_win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && _win[++scan] === _win[++match] && scan < strend);
    len = MAX_MATCH2 - (strend - scan);
    scan = strend - MAX_MATCH2;
    if (len > best_len) {
      s.match_start = cur_match;
      best_len = len;
      if (len >= nice_match) {
        break;
      }
      scan_end1 = _win[scan + best_len - 1];
      scan_end = _win[scan + best_len];
    }
  } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);
  if (best_len <= s.lookahead) {
    return best_len;
  }
  return s.lookahead;
}
function fill_window(s) {
  var _w_size = s.w_size;
  var p, n, m, more, str;
  do {
    more = s.window_size - s.lookahead - s.strstart;
    if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {
      arraySet(s.window, s.window, _w_size, _w_size, 0);
      s.match_start -= _w_size;
      s.strstart -= _w_size;
      s.block_start -= _w_size;
      n = s.hash_size;
      p = n;
      do {
        m = s.head[--p];
        s.head[p] = m >= _w_size ? m - _w_size : 0;
      } while (--n);
      n = _w_size;
      p = n;
      do {
        m = s.prev[--p];
        s.prev[p] = m >= _w_size ? m - _w_size : 0;
      } while (--n);
      more += _w_size;
    }
    if (s.strm.avail_in === 0) {
      break;
    }
    n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);
    s.lookahead += n;
    if (s.lookahead + s.insert >= MIN_MATCH2) {
      str = s.strstart - s.insert;
      s.ins_h = s.window[str];
      s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + 1]) & s.hash_mask;
      while (s.insert) {
        s.ins_h = (s.ins_h << s.hash_shift ^ s.window[str + MIN_MATCH2 - 1]) & s.hash_mask;
        s.prev[str & s.w_mask] = s.head[s.ins_h];
        s.head[s.ins_h] = str;
        str++;
        s.insert--;
        if (s.lookahead + s.insert < MIN_MATCH2) {
          break;
        }
      }
    }
  } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);
}
function deflate_stored(s, flush) {
  var max_block_size = 65535;
  if (max_block_size > s.pending_buf_size - 5) {
    max_block_size = s.pending_buf_size - 5;
  }
  for (; ; ) {
    if (s.lookahead <= 1) {
      fill_window(s);
      if (s.lookahead === 0 && flush === Z_NO_FLUSH) {
        return BS_NEED_MORE;
      }
      if (s.lookahead === 0) {
        break;
      }
    }
    s.strstart += s.lookahead;
    s.lookahead = 0;
    var max_start = s.block_start + max_block_size;
    if (s.strstart === 0 || s.strstart >= max_start) {
      s.lookahead = s.strstart - max_start;
      s.strstart = max_start;
      flush_block_only(s, false);
      if (s.strm.avail_out === 0) {
        return BS_NEED_MORE;
      }
    }
    if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {
      flush_block_only(s, false);
      if (s.strm.avail_out === 0) {
        return BS_NEED_MORE;
      }
    }
  }
  s.insert = 0;
  if (flush === Z_FINISH2) {
    flush_block_only(s, true);
    if (s.strm.avail_out === 0) {
      return BS_FINISH_STARTED;
    }
    return BS_FINISH_DONE;
  }
  if (s.strstart > s.block_start) {
    flush_block_only(s, false);
    if (s.strm.avail_out === 0) {
      return BS_NEED_MORE;
    }
  }
  return BS_NEED_MORE;
}
function deflate_fast(s, flush) {
  var hash_head;
  var bflush;
  for (; ; ) {
    if (s.lookahead < MIN_LOOKAHEAD) {
      fill_window(s);
      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
        return BS_NEED_MORE;
      }
      if (s.lookahead === 0) {
        break;
      }
    }
    hash_head = 0;
    if (s.lookahead >= MIN_MATCH2) {
      s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH2 - 1]) & s.hash_mask;
      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
      s.head[s.ins_h] = s.strstart;
    }
    if (hash_head !== 0 && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
      s.match_length = longest_match(s, hash_head);
    }
    if (s.match_length >= MIN_MATCH2) {
      bflush = _tr_tally(s, s.strstart - s.match_start, s.match_length - MIN_MATCH2);
      s.lookahead -= s.match_length;
      if (s.match_length <= s.max_lazy_match && s.lookahead >= MIN_MATCH2) {
        s.match_length--;
        do {
          s.strstart++;
          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH2 - 1]) & s.hash_mask;
          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
          s.head[s.ins_h] = s.strstart;
        } while (--s.match_length !== 0);
        s.strstart++;
      } else {
        s.strstart += s.match_length;
        s.match_length = 0;
        s.ins_h = s.window[s.strstart];
        s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + 1]) & s.hash_mask;
      }
    } else {
      bflush = _tr_tally(s, 0, s.window[s.strstart]);
      s.lookahead--;
      s.strstart++;
    }
    if (bflush) {
      flush_block_only(s, false);
      if (s.strm.avail_out === 0) {
        return BS_NEED_MORE;
      }
    }
  }
  s.insert = s.strstart < MIN_MATCH2 - 1 ? s.strstart : MIN_MATCH2 - 1;
  if (flush === Z_FINISH2) {
    flush_block_only(s, true);
    if (s.strm.avail_out === 0) {
      return BS_FINISH_STARTED;
    }
    return BS_FINISH_DONE;
  }
  if (s.last_lit) {
    flush_block_only(s, false);
    if (s.strm.avail_out === 0) {
      return BS_NEED_MORE;
    }
  }
  return BS_BLOCK_DONE;
}
function deflate_slow(s, flush) {
  var hash_head;
  var bflush;
  var max_insert;
  for (; ; ) {
    if (s.lookahead < MIN_LOOKAHEAD) {
      fill_window(s);
      if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {
        return BS_NEED_MORE;
      }
      if (s.lookahead === 0) {
        break;
      }
    }
    hash_head = 0;
    if (s.lookahead >= MIN_MATCH2) {
      s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH2 - 1]) & s.hash_mask;
      hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
      s.head[s.ins_h] = s.strstart;
    }
    s.prev_length = s.match_length;
    s.prev_match = s.match_start;
    s.match_length = MIN_MATCH2 - 1;
    if (hash_head !== 0 && s.prev_length < s.max_lazy_match && s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {
      s.match_length = longest_match(s, hash_head);
      if (s.match_length <= 5 && (s.strategy === Z_FILTERED || s.match_length === MIN_MATCH2 && s.strstart - s.match_start > 4096)) {
        s.match_length = MIN_MATCH2 - 1;
      }
    }
    if (s.prev_length >= MIN_MATCH2 && s.match_length <= s.prev_length) {
      max_insert = s.strstart + s.lookahead - MIN_MATCH2;
      bflush = _tr_tally(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH2);
      s.lookahead -= s.prev_length - 1;
      s.prev_length -= 2;
      do {
        if (++s.strstart <= max_insert) {
          s.ins_h = (s.ins_h << s.hash_shift ^ s.window[s.strstart + MIN_MATCH2 - 1]) & s.hash_mask;
          hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];
          s.head[s.ins_h] = s.strstart;
        }
      } while (--s.prev_length !== 0);
      s.match_available = 0;
      s.match_length = MIN_MATCH2 - 1;
      s.strstart++;
      if (bflush) {
        flush_block_only(s, false);
        if (s.strm.avail_out === 0) {
          return BS_NEED_MORE;
        }
      }
    } else if (s.match_available) {
      bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);
      if (bflush) {
        flush_block_only(s, false);
      }
      s.strstart++;
      s.lookahead--;
      if (s.strm.avail_out === 0) {
        return BS_NEED_MORE;
      }
    } else {
      s.match_available = 1;
      s.strstart++;
      s.lookahead--;
    }
  }
  if (s.match_available) {
    bflush = _tr_tally(s, 0, s.window[s.strstart - 1]);
    s.match_available = 0;
  }
  s.insert = s.strstart < MIN_MATCH2 - 1 ? s.strstart : MIN_MATCH2 - 1;
  if (flush === Z_FINISH2) {
    flush_block_only(s, true);
    if (s.strm.avail_out === 0) {
      return BS_FINISH_STARTED;
    }
    return BS_FINISH_DONE;
  }
  if (s.last_lit) {
    flush_block_only(s, false);
    if (s.strm.avail_out === 0) {
      return BS_NEED_MORE;
    }
  }
  return BS_BLOCK_DONE;
}
function deflate_rle(s, flush) {
  var bflush;
  var prev;
  var scan, strend;
  var _win = s.window;
  for (; ; ) {
    if (s.lookahead <= MAX_MATCH2) {
      fill_window(s);
      if (s.lookahead <= MAX_MATCH2 && flush === Z_NO_FLUSH) {
        return BS_NEED_MORE;
      }
      if (s.lookahead === 0) {
        break;
      }
    }
    s.match_length = 0;
    if (s.lookahead >= MIN_MATCH2 && s.strstart > 0) {
      scan = s.strstart - 1;
      prev = _win[scan];
      if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {
        strend = s.strstart + MAX_MATCH2;
        do {
        } while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] && scan < strend);
        s.match_length = MAX_MATCH2 - (strend - scan);
        if (s.match_length > s.lookahead) {
          s.match_length = s.lookahead;
        }
      }
    }
    if (s.match_length >= MIN_MATCH2) {
      bflush = _tr_tally(s, 1, s.match_length - MIN_MATCH2);
      s.lookahead -= s.match_length;
      s.strstart += s.match_length;
      s.match_length = 0;
    } else {
      bflush = _tr_tally(s, 0, s.window[s.strstart]);
      s.lookahead--;
      s.strstart++;
    }
    if (bflush) {
      flush_block_only(s, false);
      if (s.strm.avail_out === 0) {
        return BS_NEED_MORE;
      }
    }
  }
  s.insert = 0;
  if (flush === Z_FINISH2) {
    flush_block_only(s, true);
    if (s.strm.avail_out === 0) {
      return BS_FINISH_STARTED;
    }
    return BS_FINISH_DONE;
  }
  if (s.last_lit) {
    flush_block_only(s, false);
    if (s.strm.avail_out === 0) {
      return BS_NEED_MORE;
    }
  }
  return BS_BLOCK_DONE;
}
function deflate_huff(s, flush) {
  var bflush;
  for (; ; ) {
    if (s.lookahead === 0) {
      fill_window(s);
      if (s.lookahead === 0) {
        if (flush === Z_NO_FLUSH) {
          return BS_NEED_MORE;
        }
        break;
      }
    }
    s.match_length = 0;
    bflush = _tr_tally(s, 0, s.window[s.strstart]);
    s.lookahead--;
    s.strstart++;
    if (bflush) {
      flush_block_only(s, false);
      if (s.strm.avail_out === 0) {
        return BS_NEED_MORE;
      }
    }
  }
  s.insert = 0;
  if (flush === Z_FINISH2) {
    flush_block_only(s, true);
    if (s.strm.avail_out === 0) {
      return BS_FINISH_STARTED;
    }
    return BS_FINISH_DONE;
  }
  if (s.last_lit) {
    flush_block_only(s, false);
    if (s.strm.avail_out === 0) {
      return BS_NEED_MORE;
    }
  }
  return BS_BLOCK_DONE;
}
function Config(good_length, max_lazy, nice_length, max_chain, func) {
  this.good_length = good_length;
  this.max_lazy = max_lazy;
  this.nice_length = nice_length;
  this.max_chain = max_chain;
  this.func = func;
}
var configuration_table;
configuration_table = [
  /*      good lazy nice chain */
  new Config(0, 0, 0, 0, deflate_stored),
  /* 0 store only */
  new Config(4, 4, 8, 4, deflate_fast),
  /* 1 max speed, no lazy matches */
  new Config(4, 5, 16, 8, deflate_fast),
  /* 2 */
  new Config(4, 6, 32, 32, deflate_fast),
  /* 3 */
  new Config(4, 4, 16, 16, deflate_slow),
  /* 4 lazy matches */
  new Config(8, 16, 32, 32, deflate_slow),
  /* 5 */
  new Config(8, 16, 128, 128, deflate_slow),
  /* 6 */
  new Config(8, 32, 128, 256, deflate_slow),
  /* 7 */
  new Config(32, 128, 258, 1024, deflate_slow),
  /* 8 */
  new Config(32, 258, 258, 4096, deflate_slow)
  /* 9 max compression */
];
function lm_init(s) {
  s.window_size = 2 * s.w_size;
  zero2(s.head);
  s.max_lazy_match = configuration_table[s.level].max_lazy;
  s.good_match = configuration_table[s.level].good_length;
  s.nice_match = configuration_table[s.level].nice_length;
  s.max_chain_length = configuration_table[s.level].max_chain;
  s.strstart = 0;
  s.block_start = 0;
  s.lookahead = 0;
  s.insert = 0;
  s.match_length = s.prev_length = MIN_MATCH2 - 1;
  s.match_available = 0;
  s.ins_h = 0;
}
function DeflateState() {
  this.strm = null;
  this.status = 0;
  this.pending_buf = null;
  this.pending_buf_size = 0;
  this.pending_out = 0;
  this.pending = 0;
  this.wrap = 0;
  this.gzhead = null;
  this.gzindex = 0;
  this.method = Z_DEFLATED2;
  this.last_flush = -1;
  this.w_size = 0;
  this.w_bits = 0;
  this.w_mask = 0;
  this.window = null;
  this.window_size = 0;
  this.prev = null;
  this.head = null;
  this.ins_h = 0;
  this.hash_size = 0;
  this.hash_bits = 0;
  this.hash_mask = 0;
  this.hash_shift = 0;
  this.block_start = 0;
  this.match_length = 0;
  this.prev_match = 0;
  this.match_available = 0;
  this.strstart = 0;
  this.match_start = 0;
  this.lookahead = 0;
  this.prev_length = 0;
  this.max_chain_length = 0;
  this.max_lazy_match = 0;
  this.level = 0;
  this.strategy = 0;
  this.good_match = 0;
  this.nice_match = 0;
  this.dyn_ltree = new Buf16(HEAP_SIZE2 * 2);
  this.dyn_dtree = new Buf16((2 * D_CODES2 + 1) * 2);
  this.bl_tree = new Buf16((2 * BL_CODES2 + 1) * 2);
  zero2(this.dyn_ltree);
  zero2(this.dyn_dtree);
  zero2(this.bl_tree);
  this.l_desc = null;
  this.d_desc = null;
  this.bl_desc = null;
  this.bl_count = new Buf16(MAX_BITS2 + 1);
  this.heap = new Buf16(2 * L_CODES2 + 1);
  zero2(this.heap);
  this.heap_len = 0;
  this.heap_max = 0;
  this.depth = new Buf16(2 * L_CODES2 + 1);
  zero2(this.depth);
  this.l_buf = 0;
  this.lit_bufsize = 0;
  this.last_lit = 0;
  this.d_buf = 0;
  this.opt_len = 0;
  this.static_len = 0;
  this.matches = 0;
  this.insert = 0;
  this.bi_buf = 0;
  this.bi_valid = 0;
}
function deflateResetKeep(strm) {
  var s;
  if (!strm || !strm.state) {
    return err(strm, Z_STREAM_ERROR2);
  }
  strm.total_in = strm.total_out = 0;
  strm.data_type = Z_UNKNOWN2;
  s = strm.state;
  s.pending = 0;
  s.pending_out = 0;
  if (s.wrap < 0) {
    s.wrap = -s.wrap;
  }
  s.status = s.wrap ? INIT_STATE : BUSY_STATE;
  strm.adler = s.wrap === 2 ? 0 : 1;
  s.last_flush = Z_NO_FLUSH;
  _tr_init(s);
  return Z_OK2;
}
function deflateReset(strm) {
  var ret = deflateResetKeep(strm);
  if (ret === Z_OK2) {
    lm_init(strm.state);
  }
  return ret;
}
function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {
  if (!strm) {
    return Z_STREAM_ERROR2;
  }
  var wrap = 1;
  if (level === Z_DEFAULT_COMPRESSION) {
    level = 6;
  }
  if (windowBits < 0) {
    wrap = 0;
    windowBits = -windowBits;
  } else if (windowBits > 15) {
    wrap = 2;
    windowBits -= 16;
  }
  if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED2 || windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED2) {
    return err(strm, Z_STREAM_ERROR2);
  }
  if (windowBits === 8) {
    windowBits = 9;
  }
  var s = new DeflateState();
  strm.state = s;
  s.strm = strm;
  s.wrap = wrap;
  s.gzhead = null;
  s.w_bits = windowBits;
  s.w_size = 1 << s.w_bits;
  s.w_mask = s.w_size - 1;
  s.hash_bits = memLevel + 7;
  s.hash_size = 1 << s.hash_bits;
  s.hash_mask = s.hash_size - 1;
  s.hash_shift = ~~((s.hash_bits + MIN_MATCH2 - 1) / MIN_MATCH2);
  s.window = new Buf8(s.w_size * 2);
  s.head = new Buf16(s.hash_size);
  s.prev = new Buf16(s.w_size);
  s.lit_bufsize = 1 << memLevel + 6;
  s.pending_buf_size = s.lit_bufsize * 4;
  s.pending_buf = new Buf8(s.pending_buf_size);
  s.d_buf = 1 * s.lit_bufsize;
  s.l_buf = (1 + 2) * s.lit_bufsize;
  s.level = level;
  s.strategy = strategy;
  s.method = method;
  return deflateReset(strm);
}
function deflateInit(strm, level) {
  return deflateInit2(strm, level, Z_DEFLATED2, MAX_WBITS2, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);
}
function deflate(strm, flush) {
  var old_flush, s;
  var beg, val;
  if (!strm || !strm.state || flush > Z_BLOCK2 || flush < 0) {
    return strm ? err(strm, Z_STREAM_ERROR2) : Z_STREAM_ERROR2;
  }
  s = strm.state;
  if (!strm.output || !strm.input && strm.avail_in !== 0 || s.status === FINISH_STATE && flush !== Z_FINISH2) {
    return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR2 : Z_STREAM_ERROR2);
  }
  s.strm = strm;
  old_flush = s.last_flush;
  s.last_flush = flush;
  if (s.status === INIT_STATE) {
    if (s.wrap === 2) {
      strm.adler = 0;
      put_byte(s, 31);
      put_byte(s, 139);
      put_byte(s, 8);
      if (!s.gzhead) {
        put_byte(s, 0);
        put_byte(s, 0);
        put_byte(s, 0);
        put_byte(s, 0);
        put_byte(s, 0);
        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
        put_byte(s, OS_CODE);
        s.status = BUSY_STATE;
      } else {
        put_byte(
          s,
          (s.gzhead.text ? 1 : 0) + (s.gzhead.hcrc ? 2 : 0) + (!s.gzhead.extra ? 0 : 4) + (!s.gzhead.name ? 0 : 8) + (!s.gzhead.comment ? 0 : 16)
        );
        put_byte(s, s.gzhead.time & 255);
        put_byte(s, s.gzhead.time >> 8 & 255);
        put_byte(s, s.gzhead.time >> 16 & 255);
        put_byte(s, s.gzhead.time >> 24 & 255);
        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);
        put_byte(s, s.gzhead.os & 255);
        if (s.gzhead.extra && s.gzhead.extra.length) {
          put_byte(s, s.gzhead.extra.length & 255);
          put_byte(s, s.gzhead.extra.length >> 8 & 255);
        }
        if (s.gzhead.hcrc) {
          strm.adler = makeTable(strm.adler, s.pending_buf, s.pending, 0);
        }
        s.gzindex = 0;
        s.status = EXTRA_STATE;
      }
    } else {
      var header = Z_DEFLATED2 + (s.w_bits - 8 << 4) << 8;
      var level_flags = -1;
      if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {
        level_flags = 0;
      } else if (s.level < 6) {
        level_flags = 1;
      } else if (s.level === 6) {
        level_flags = 2;
      } else {
        level_flags = 3;
      }
      header |= level_flags << 6;
      if (s.strstart !== 0) {
        header |= PRESET_DICT;
      }
      header += 31 - header % 31;
      s.status = BUSY_STATE;
      putShortMSB(s, header);
      if (s.strstart !== 0) {
        putShortMSB(s, strm.adler >>> 16);
        putShortMSB(s, strm.adler & 65535);
      }
      strm.adler = 1;
    }
  }
  if (s.status === EXTRA_STATE) {
    if (s.gzhead.extra) {
      beg = s.pending;
      while (s.gzindex < (s.gzhead.extra.length & 65535)) {
        if (s.pending === s.pending_buf_size) {
          if (s.gzhead.hcrc && s.pending > beg) {
            strm.adler = makeTable(strm.adler, s.pending_buf, s.pending - beg, beg);
          }
          flush_pending(strm);
          beg = s.pending;
          if (s.pending === s.pending_buf_size) {
            break;
          }
        }
        put_byte(s, s.gzhead.extra[s.gzindex] & 255);
        s.gzindex++;
      }
      if (s.gzhead.hcrc && s.pending > beg) {
        strm.adler = makeTable(strm.adler, s.pending_buf, s.pending - beg, beg);
      }
      if (s.gzindex === s.gzhead.extra.length) {
        s.gzindex = 0;
        s.status = NAME_STATE;
      }
    } else {
      s.status = NAME_STATE;
    }
  }
  if (s.status === NAME_STATE) {
    if (s.gzhead.name) {
      beg = s.pending;
      do {
        if (s.pending === s.pending_buf_size) {
          if (s.gzhead.hcrc && s.pending > beg) {
            strm.adler = makeTable(strm.adler, s.pending_buf, s.pending - beg, beg);
          }
          flush_pending(strm);
          beg = s.pending;
          if (s.pending === s.pending_buf_size) {
            val = 1;
            break;
          }
        }
        if (s.gzindex < s.gzhead.name.length) {
          val = s.gzhead.name.charCodeAt(s.gzindex++) & 255;
        } else {
          val = 0;
        }
        put_byte(s, val);
      } while (val !== 0);
      if (s.gzhead.hcrc && s.pending > beg) {
        strm.adler = makeTable(strm.adler, s.pending_buf, s.pending - beg, beg);
      }
      if (val === 0) {
        s.gzindex = 0;
        s.status = COMMENT_STATE;
      }
    } else {
      s.status = COMMENT_STATE;
    }
  }
  if (s.status === COMMENT_STATE) {
    if (s.gzhead.comment) {
      beg = s.pending;
      do {
        if (s.pending === s.pending_buf_size) {
          if (s.gzhead.hcrc && s.pending > beg) {
            strm.adler = makeTable(strm.adler, s.pending_buf, s.pending - beg, beg);
          }
          flush_pending(strm);
          beg = s.pending;
          if (s.pending === s.pending_buf_size) {
            val = 1;
            break;
          }
        }
        if (s.gzindex < s.gzhead.comment.length) {
          val = s.gzhead.comment.charCodeAt(s.gzindex++) & 255;
        } else {
          val = 0;
        }
        put_byte(s, val);
      } while (val !== 0);
      if (s.gzhead.hcrc && s.pending > beg) {
        strm.adler = makeTable(strm.adler, s.pending_buf, s.pending - beg, beg);
      }
      if (val === 0) {
        s.status = HCRC_STATE;
      }
    } else {
      s.status = HCRC_STATE;
    }
  }
  if (s.status === HCRC_STATE) {
    if (s.gzhead.hcrc) {
      if (s.pending + 2 > s.pending_buf_size) {
        flush_pending(strm);
      }
      if (s.pending + 2 <= s.pending_buf_size) {
        put_byte(s, strm.adler & 255);
        put_byte(s, strm.adler >> 8 & 255);
        strm.adler = 0;
        s.status = BUSY_STATE;
      }
    } else {
      s.status = BUSY_STATE;
    }
  }
  if (s.pending !== 0) {
    flush_pending(strm);
    if (strm.avail_out === 0) {
      s.last_flush = -1;
      return Z_OK2;
    }
  } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH2) {
    return err(strm, Z_BUF_ERROR2);
  }
  if (s.status === FINISH_STATE && strm.avail_in !== 0) {
    return err(strm, Z_BUF_ERROR2);
  }
  if (strm.avail_in !== 0 || s.lookahead !== 0 || flush !== Z_NO_FLUSH && s.status !== FINISH_STATE) {
    var bstate = s.strategy === Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : s.strategy === Z_RLE ? deflate_rle(s, flush) : configuration_table[s.level].func(s, flush);
    if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {
      s.status = FINISH_STATE;
    }
    if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {
      if (strm.avail_out === 0) {
        s.last_flush = -1;
      }
      return Z_OK2;
    }
    if (bstate === BS_BLOCK_DONE) {
      if (flush === Z_PARTIAL_FLUSH) {
        _tr_align(s);
      } else if (flush !== Z_BLOCK2) {
        _tr_stored_block(s, 0, 0, false);
        if (flush === Z_FULL_FLUSH) {
          zero2(s.head);
          if (s.lookahead === 0) {
            s.strstart = 0;
            s.block_start = 0;
            s.insert = 0;
          }
        }
      }
      flush_pending(strm);
      if (strm.avail_out === 0) {
        s.last_flush = -1;
        return Z_OK2;
      }
    }
  }
  if (flush !== Z_FINISH2) {
    return Z_OK2;
  }
  if (s.wrap <= 0) {
    return Z_STREAM_END2;
  }
  if (s.wrap === 2) {
    put_byte(s, strm.adler & 255);
    put_byte(s, strm.adler >> 8 & 255);
    put_byte(s, strm.adler >> 16 & 255);
    put_byte(s, strm.adler >> 24 & 255);
    put_byte(s, strm.total_in & 255);
    put_byte(s, strm.total_in >> 8 & 255);
    put_byte(s, strm.total_in >> 16 & 255);
    put_byte(s, strm.total_in >> 24 & 255);
  } else {
    putShortMSB(s, strm.adler >>> 16);
    putShortMSB(s, strm.adler & 65535);
  }
  flush_pending(strm);
  if (s.wrap > 0) {
    s.wrap = -s.wrap;
  }
  return s.pending !== 0 ? Z_OK2 : Z_STREAM_END2;
}

// core/deflator.js
var Deflator = class {
  constructor() {
    this.strm = new ZStream();
    this.chunkSize = 1024 * 10 * 10;
    this.outputBuffer = new Uint8Array(this.chunkSize);
    deflateInit(this.strm, Z_DEFAULT_COMPRESSION);
  }
  deflate(inData) {
    this.strm.input = inData;
    this.strm.avail_in = this.strm.input.length;
    this.strm.next_in = 0;
    this.strm.output = this.outputBuffer;
    this.strm.avail_out = this.chunkSize;
    this.strm.next_out = 0;
    let lastRet = deflate(this.strm, Z_FULL_FLUSH);
    let outData = new Uint8Array(this.strm.output.buffer, 0, this.strm.next_out);
    if (lastRet < 0) {
      throw new Error("zlib deflate failed");
    }
    if (this.strm.avail_in > 0) {
      let chunks = [outData];
      let totalLen = outData.length;
      do {
        this.strm.output = new Uint8Array(this.chunkSize);
        this.strm.next_out = 0;
        this.strm.avail_out = this.chunkSize;
        lastRet = deflate(this.strm, Z_FULL_FLUSH);
        if (lastRet < 0) {
          throw new Error("zlib deflate failed");
        }
        let chunk = new Uint8Array(this.strm.output.buffer, 0, this.strm.next_out);
        totalLen += chunk.length;
        chunks.push(chunk);
      } while (this.strm.avail_in > 0);
      let newData = new Uint8Array(totalLen);
      let offset = 0;
      for (let i = 0; i < chunks.length; i++) {
        newData.set(chunks[i], offset);
        offset += chunks[i].length;
      }
      outData = newData;
    }
    this.strm.input = null;
    this.strm.avail_in = 0;
    this.strm.next_in = 0;
    return outData;
  }
};

// core/input/keysym.js
var keysym_default = {
  XK_VoidSymbol: 16777215,
  /* Void symbol */
  XK_BackSpace: 65288,
  /* Back space, back char */
  XK_Tab: 65289,
  XK_Linefeed: 65290,
  /* Linefeed, LF */
  XK_Clear: 65291,
  XK_Return: 65293,
  /* Return, enter */
  XK_Pause: 65299,
  /* Pause, hold */
  XK_Scroll_Lock: 65300,
  XK_Sys_Req: 65301,
  XK_Escape: 65307,
  XK_Delete: 65535,
  /* Delete, rubout */
  /* International & multi-key character composition */
  XK_Multi_key: 65312,
  /* Multi-key character compose */
  XK_Codeinput: 65335,
  XK_SingleCandidate: 65340,
  XK_MultipleCandidate: 65341,
  XK_PreviousCandidate: 65342,
  /* Japanese keyboard support */
  XK_Kanji: 65313,
  /* Kanji, Kanji convert */
  XK_Muhenkan: 65314,
  /* Cancel Conversion */
  XK_Henkan_Mode: 65315,
  /* Start/Stop Conversion */
  XK_Henkan: 65315,
  /* Alias for Henkan_Mode */
  XK_Romaji: 65316,
  /* to Romaji */
  XK_Hiragana: 65317,
  /* to Hiragana */
  XK_Katakana: 65318,
  /* to Katakana */
  XK_Hiragana_Katakana: 65319,
  /* Hiragana/Katakana toggle */
  XK_Zenkaku: 65320,
  /* to Zenkaku */
  XK_Hankaku: 65321,
  /* to Hankaku */
  XK_Zenkaku_Hankaku: 65322,
  /* Zenkaku/Hankaku toggle */
  XK_Touroku: 65323,
  /* Add to Dictionary */
  XK_Massyo: 65324,
  /* Delete from Dictionary */
  XK_Kana_Lock: 65325,
  /* Kana Lock */
  XK_Kana_Shift: 65326,
  /* Kana Shift */
  XK_Eisu_Shift: 65327,
  /* Alphanumeric Shift */
  XK_Eisu_toggle: 65328,
  /* Alphanumeric toggle */
  XK_Kanji_Bangou: 65335,
  /* Codeinput */
  XK_Zen_Koho: 65341,
  /* Multiple/All Candidate(s) */
  XK_Mae_Koho: 65342,
  /* Previous Candidate */
  /* Cursor control & motion */
  XK_Home: 65360,
  XK_Left: 65361,
  /* Move left, left arrow */
  XK_Up: 65362,
  /* Move up, up arrow */
  XK_Right: 65363,
  /* Move right, right arrow */
  XK_Down: 65364,
  /* Move down, down arrow */
  XK_Prior: 65365,
  /* Prior, previous */
  XK_Page_Up: 65365,
  XK_Next: 65366,
  /* Next */
  XK_Page_Down: 65366,
  XK_End: 65367,
  /* EOL */
  XK_Begin: 65368,
  /* BOL */
  /* Misc functions */
  XK_Select: 65376,
  /* Select, mark */
  XK_Print: 65377,
  XK_Execute: 65378,
  /* Execute, run, do */
  XK_Insert: 65379,
  /* Insert, insert here */
  XK_Undo: 65381,
  XK_Redo: 65382,
  /* Redo, again */
  XK_Menu: 65383,
  XK_Find: 65384,
  /* Find, search */
  XK_Cancel: 65385,
  /* Cancel, stop, abort, exit */
  XK_Help: 65386,
  /* Help */
  XK_Break: 65387,
  XK_Mode_switch: 65406,
  /* Character set switch */
  XK_script_switch: 65406,
  /* Alias for mode_switch */
  XK_Num_Lock: 65407,
  /* Keypad functions, keypad numbers cleverly chosen to map to ASCII */
  XK_KP_Space: 65408,
  /* Space */
  XK_KP_Tab: 65417,
  XK_KP_Enter: 65421,
  /* Enter */
  XK_KP_F1: 65425,
  /* PF1, KP_A, ... */
  XK_KP_F2: 65426,
  XK_KP_F3: 65427,
  XK_KP_F4: 65428,
  XK_KP_Home: 65429,
  XK_KP_Left: 65430,
  XK_KP_Up: 65431,
  XK_KP_Right: 65432,
  XK_KP_Down: 65433,
  XK_KP_Prior: 65434,
  XK_KP_Page_Up: 65434,
  XK_KP_Next: 65435,
  XK_KP_Page_Down: 65435,
  XK_KP_End: 65436,
  XK_KP_Begin: 65437,
  XK_KP_Insert: 65438,
  XK_KP_Delete: 65439,
  XK_KP_Equal: 65469,
  /* Equals */
  XK_KP_Multiply: 65450,
  XK_KP_Add: 65451,
  XK_KP_Separator: 65452,
  /* Separator, often comma */
  XK_KP_Subtract: 65453,
  XK_KP_Decimal: 65454,
  XK_KP_Divide: 65455,
  XK_KP_0: 65456,
  XK_KP_1: 65457,
  XK_KP_2: 65458,
  XK_KP_3: 65459,
  XK_KP_4: 65460,
  XK_KP_5: 65461,
  XK_KP_6: 65462,
  XK_KP_7: 65463,
  XK_KP_8: 65464,
  XK_KP_9: 65465,
  /*
   * Auxiliary functions; note the duplicate definitions for left and right
   * function keys;  Sun keyboards and a few other manufacturers have such
   * function key groups on the left and/or right sides of the keyboard.
   * We've not found a keyboard with more than 35 function keys total.
   */
  XK_F1: 65470,
  XK_F2: 65471,
  XK_F3: 65472,
  XK_F4: 65473,
  XK_F5: 65474,
  XK_F6: 65475,
  XK_F7: 65476,
  XK_F8: 65477,
  XK_F9: 65478,
  XK_F10: 65479,
  XK_F11: 65480,
  XK_L1: 65480,
  XK_F12: 65481,
  XK_L2: 65481,
  XK_F13: 65482,
  XK_L3: 65482,
  XK_F14: 65483,
  XK_L4: 65483,
  XK_F15: 65484,
  XK_L5: 65484,
  XK_F16: 65485,
  XK_L6: 65485,
  XK_F17: 65486,
  XK_L7: 65486,
  XK_F18: 65487,
  XK_L8: 65487,
  XK_F19: 65488,
  XK_L9: 65488,
  XK_F20: 65489,
  XK_L10: 65489,
  XK_F21: 65490,
  XK_R1: 65490,
  XK_F22: 65491,
  XK_R2: 65491,
  XK_F23: 65492,
  XK_R3: 65492,
  XK_F24: 65493,
  XK_R4: 65493,
  XK_F25: 65494,
  XK_R5: 65494,
  XK_F26: 65495,
  XK_R6: 65495,
  XK_F27: 65496,
  XK_R7: 65496,
  XK_F28: 65497,
  XK_R8: 65497,
  XK_F29: 65498,
  XK_R9: 65498,
  XK_F30: 65499,
  XK_R10: 65499,
  XK_F31: 65500,
  XK_R11: 65500,
  XK_F32: 65501,
  XK_R12: 65501,
  XK_F33: 65502,
  XK_R13: 65502,
  XK_F34: 65503,
  XK_R14: 65503,
  XK_F35: 65504,
  XK_R15: 65504,
  /* Modifiers */
  XK_Shift_L: 65505,
  /* Left shift */
  XK_Shift_R: 65506,
  /* Right shift */
  XK_Control_L: 65507,
  /* Left control */
  XK_Control_R: 65508,
  /* Right control */
  XK_Caps_Lock: 65509,
  /* Caps lock */
  XK_Shift_Lock: 65510,
  /* Shift lock */
  XK_Meta_L: 65511,
  /* Left meta */
  XK_Meta_R: 65512,
  /* Right meta */
  XK_Alt_L: 65513,
  /* Left alt */
  XK_Alt_R: 65514,
  /* Right alt */
  XK_Super_L: 65515,
  /* Left super */
  XK_Super_R: 65516,
  /* Right super */
  XK_Hyper_L: 65517,
  /* Left hyper */
  XK_Hyper_R: 65518,
  /* Right hyper */
  /*
   * Keyboard (XKB) Extension function and modifier keys
   * (from Appendix C of "The X Keyboard Extension: Protocol Specification")
   * Byte 3 = 0xfe
   */
  XK_ISO_Level3_Shift: 65027,
  /* AltGr */
  XK_ISO_Next_Group: 65032,
  XK_ISO_Prev_Group: 65034,
  XK_ISO_First_Group: 65036,
  XK_ISO_Last_Group: 65038,
  /*
   * Latin 1
   * (ISO/IEC 8859-1: Unicode U+0020..U+00FF)
   * Byte 3: 0
   */
  XK_space: 32,
  /* U+0020 SPACE */
  XK_exclam: 33,
  /* U+0021 EXCLAMATION MARK */
  XK_quotedbl: 34,
  /* U+0022 QUOTATION MARK */
  XK_numbersign: 35,
  /* U+0023 NUMBER SIGN */
  XK_dollar: 36,
  /* U+0024 DOLLAR SIGN */
  XK_percent: 37,
  /* U+0025 PERCENT SIGN */
  XK_ampersand: 38,
  /* U+0026 AMPERSAND */
  XK_apostrophe: 39,
  /* U+0027 APOSTROPHE */
  XK_quoteright: 39,
  /* deprecated */
  XK_parenleft: 40,
  /* U+0028 LEFT PARENTHESIS */
  XK_parenright: 41,
  /* U+0029 RIGHT PARENTHESIS */
  XK_asterisk: 42,
  /* U+002A ASTERISK */
  XK_plus: 43,
  /* U+002B PLUS SIGN */
  XK_comma: 44,
  /* U+002C COMMA */
  XK_minus: 45,
  /* U+002D HYPHEN-MINUS */
  XK_period: 46,
  /* U+002E FULL STOP */
  XK_slash: 47,
  /* U+002F SOLIDUS */
  XK_0: 48,
  /* U+0030 DIGIT ZERO */
  XK_1: 49,
  /* U+0031 DIGIT ONE */
  XK_2: 50,
  /* U+0032 DIGIT TWO */
  XK_3: 51,
  /* U+0033 DIGIT THREE */
  XK_4: 52,
  /* U+0034 DIGIT FOUR */
  XK_5: 53,
  /* U+0035 DIGIT FIVE */
  XK_6: 54,
  /* U+0036 DIGIT SIX */
  XK_7: 55,
  /* U+0037 DIGIT SEVEN */
  XK_8: 56,
  /* U+0038 DIGIT EIGHT */
  XK_9: 57,
  /* U+0039 DIGIT NINE */
  XK_colon: 58,
  /* U+003A COLON */
  XK_semicolon: 59,
  /* U+003B SEMICOLON */
  XK_less: 60,
  /* U+003C LESS-THAN SIGN */
  XK_equal: 61,
  /* U+003D EQUALS SIGN */
  XK_greater: 62,
  /* U+003E GREATER-THAN SIGN */
  XK_question: 63,
  /* U+003F QUESTION MARK */
  XK_at: 64,
  /* U+0040 COMMERCIAL AT */
  XK_A: 65,
  /* U+0041 LATIN CAPITAL LETTER A */
  XK_B: 66,
  /* U+0042 LATIN CAPITAL LETTER B */
  XK_C: 67,
  /* U+0043 LATIN CAPITAL LETTER C */
  XK_D: 68,
  /* U+0044 LATIN CAPITAL LETTER D */
  XK_E: 69,
  /* U+0045 LATIN CAPITAL LETTER E */
  XK_F: 70,
  /* U+0046 LATIN CAPITAL LETTER F */
  XK_G: 71,
  /* U+0047 LATIN CAPITAL LETTER G */
  XK_H: 72,
  /* U+0048 LATIN CAPITAL LETTER H */
  XK_I: 73,
  /* U+0049 LATIN CAPITAL LETTER I */
  XK_J: 74,
  /* U+004A LATIN CAPITAL LETTER J */
  XK_K: 75,
  /* U+004B LATIN CAPITAL LETTER K */
  XK_L: 76,
  /* U+004C LATIN CAPITAL LETTER L */
  XK_M: 77,
  /* U+004D LATIN CAPITAL LETTER M */
  XK_N: 78,
  /* U+004E LATIN CAPITAL LETTER N */
  XK_O: 79,
  /* U+004F LATIN CAPITAL LETTER O */
  XK_P: 80,
  /* U+0050 LATIN CAPITAL LETTER P */
  XK_Q: 81,
  /* U+0051 LATIN CAPITAL LETTER Q */
  XK_R: 82,
  /* U+0052 LATIN CAPITAL LETTER R */
  XK_S: 83,
  /* U+0053 LATIN CAPITAL LETTER S */
  XK_T: 84,
  /* U+0054 LATIN CAPITAL LETTER T */
  XK_U: 85,
  /* U+0055 LATIN CAPITAL LETTER U */
  XK_V: 86,
  /* U+0056 LATIN CAPITAL LETTER V */
  XK_W: 87,
  /* U+0057 LATIN CAPITAL LETTER W */
  XK_X: 88,
  /* U+0058 LATIN CAPITAL LETTER X */
  XK_Y: 89,
  /* U+0059 LATIN CAPITAL LETTER Y */
  XK_Z: 90,
  /* U+005A LATIN CAPITAL LETTER Z */
  XK_bracketleft: 91,
  /* U+005B LEFT SQUARE BRACKET */
  XK_backslash: 92,
  /* U+005C REVERSE SOLIDUS */
  XK_bracketright: 93,
  /* U+005D RIGHT SQUARE BRACKET */
  XK_asciicircum: 94,
  /* U+005E CIRCUMFLEX ACCENT */
  XK_underscore: 95,
  /* U+005F LOW LINE */
  XK_grave: 96,
  /* U+0060 GRAVE ACCENT */
  XK_quoteleft: 96,
  /* deprecated */
  XK_a: 97,
  /* U+0061 LATIN SMALL LETTER A */
  XK_b: 98,
  /* U+0062 LATIN SMALL LETTER B */
  XK_c: 99,
  /* U+0063 LATIN SMALL LETTER C */
  XK_d: 100,
  /* U+0064 LATIN SMALL LETTER D */
  XK_e: 101,
  /* U+0065 LATIN SMALL LETTER E */
  XK_f: 102,
  /* U+0066 LATIN SMALL LETTER F */
  XK_g: 103,
  /* U+0067 LATIN SMALL LETTER G */
  XK_h: 104,
  /* U+0068 LATIN SMALL LETTER H */
  XK_i: 105,
  /* U+0069 LATIN SMALL LETTER I */
  XK_j: 106,
  /* U+006A LATIN SMALL LETTER J */
  XK_k: 107,
  /* U+006B LATIN SMALL LETTER K */
  XK_l: 108,
  /* U+006C LATIN SMALL LETTER L */
  XK_m: 109,
  /* U+006D LATIN SMALL LETTER M */
  XK_n: 110,
  /* U+006E LATIN SMALL LETTER N */
  XK_o: 111,
  /* U+006F LATIN SMALL LETTER O */
  XK_p: 112,
  /* U+0070 LATIN SMALL LETTER P */
  XK_q: 113,
  /* U+0071 LATIN SMALL LETTER Q */
  XK_r: 114,
  /* U+0072 LATIN SMALL LETTER R */
  XK_s: 115,
  /* U+0073 LATIN SMALL LETTER S */
  XK_t: 116,
  /* U+0074 LATIN SMALL LETTER T */
  XK_u: 117,
  /* U+0075 LATIN SMALL LETTER U */
  XK_v: 118,
  /* U+0076 LATIN SMALL LETTER V */
  XK_w: 119,
  /* U+0077 LATIN SMALL LETTER W */
  XK_x: 120,
  /* U+0078 LATIN SMALL LETTER X */
  XK_y: 121,
  /* U+0079 LATIN SMALL LETTER Y */
  XK_z: 122,
  /* U+007A LATIN SMALL LETTER Z */
  XK_braceleft: 123,
  /* U+007B LEFT CURLY BRACKET */
  XK_bar: 124,
  /* U+007C VERTICAL LINE */
  XK_braceright: 125,
  /* U+007D RIGHT CURLY BRACKET */
  XK_asciitilde: 126,
  /* U+007E TILDE */
  XK_nobreakspace: 160,
  /* U+00A0 NO-BREAK SPACE */
  XK_exclamdown: 161,
  /* U+00A1 INVERTED EXCLAMATION MARK */
  XK_cent: 162,
  /* U+00A2 CENT SIGN */
  XK_sterling: 163,
  /* U+00A3 POUND SIGN */
  XK_currency: 164,
  /* U+00A4 CURRENCY SIGN */
  XK_yen: 165,
  /* U+00A5 YEN SIGN */
  XK_brokenbar: 166,
  /* U+00A6 BROKEN BAR */
  XK_section: 167,
  /* U+00A7 SECTION SIGN */
  XK_diaeresis: 168,
  /* U+00A8 DIAERESIS */
  XK_copyright: 169,
  /* U+00A9 COPYRIGHT SIGN */
  XK_ordfeminine: 170,
  /* U+00AA FEMININE ORDINAL INDICATOR */
  XK_guillemotleft: 171,
  /* U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */
  XK_notsign: 172,
  /* U+00AC NOT SIGN */
  XK_hyphen: 173,
  /* U+00AD SOFT HYPHEN */
  XK_registered: 174,
  /* U+00AE REGISTERED SIGN */
  XK_macron: 175,
  /* U+00AF MACRON */
  XK_degree: 176,
  /* U+00B0 DEGREE SIGN */
  XK_plusminus: 177,
  /* U+00B1 PLUS-MINUS SIGN */
  XK_twosuperior: 178,
  /* U+00B2 SUPERSCRIPT TWO */
  XK_threesuperior: 179,
  /* U+00B3 SUPERSCRIPT THREE */
  XK_acute: 180,
  /* U+00B4 ACUTE ACCENT */
  XK_mu: 181,
  /* U+00B5 MICRO SIGN */
  XK_paragraph: 182,
  /* U+00B6 PILCROW SIGN */
  XK_periodcentered: 183,
  /* U+00B7 MIDDLE DOT */
  XK_cedilla: 184,
  /* U+00B8 CEDILLA */
  XK_onesuperior: 185,
  /* U+00B9 SUPERSCRIPT ONE */
  XK_masculine: 186,
  /* U+00BA MASCULINE ORDINAL INDICATOR */
  XK_guillemotright: 187,
  /* U+00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */
  XK_onequarter: 188,
  /* U+00BC VULGAR FRACTION ONE QUARTER */
  XK_onehalf: 189,
  /* U+00BD VULGAR FRACTION ONE HALF */
  XK_threequarters: 190,
  /* U+00BE VULGAR FRACTION THREE QUARTERS */
  XK_questiondown: 191,
  /* U+00BF INVERTED QUESTION MARK */
  XK_Agrave: 192,
  /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE */
  XK_Aacute: 193,
  /* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE */
  XK_Acircumflex: 194,
  /* U+00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
  XK_Atilde: 195,
  /* U+00C3 LATIN CAPITAL LETTER A WITH TILDE */
  XK_Adiaeresis: 196,
  /* U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS */
  XK_Aring: 197,
  /* U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE */
  XK_AE: 198,
  /* U+00C6 LATIN CAPITAL LETTER AE */
  XK_Ccedilla: 199,
  /* U+00C7 LATIN CAPITAL LETTER C WITH CEDILLA */
  XK_Egrave: 200,
  /* U+00C8 LATIN CAPITAL LETTER E WITH GRAVE */
  XK_Eacute: 201,
  /* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */
  XK_Ecircumflex: 202,
  /* U+00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
  XK_Ediaeresis: 203,
  /* U+00CB LATIN CAPITAL LETTER E WITH DIAERESIS */
  XK_Igrave: 204,
  /* U+00CC LATIN CAPITAL LETTER I WITH GRAVE */
  XK_Iacute: 205,
  /* U+00CD LATIN CAPITAL LETTER I WITH ACUTE */
  XK_Icircumflex: 206,
  /* U+00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
  XK_Idiaeresis: 207,
  /* U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS */
  XK_ETH: 208,
  /* U+00D0 LATIN CAPITAL LETTER ETH */
  XK_Eth: 208,
  /* deprecated */
  XK_Ntilde: 209,
  /* U+00D1 LATIN CAPITAL LETTER N WITH TILDE */
  XK_Ograve: 210,
  /* U+00D2 LATIN CAPITAL LETTER O WITH GRAVE */
  XK_Oacute: 211,
  /* U+00D3 LATIN CAPITAL LETTER O WITH ACUTE */
  XK_Ocircumflex: 212,
  /* U+00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
  XK_Otilde: 213,
  /* U+00D5 LATIN CAPITAL LETTER O WITH TILDE */
  XK_Odiaeresis: 214,
  /* U+00D6 LATIN CAPITAL LETTER O WITH DIAERESIS */
  XK_multiply: 215,
  /* U+00D7 MULTIPLICATION SIGN */
  XK_Oslash: 216,
  /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
  XK_Ooblique: 216,
  /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */
  XK_Ugrave: 217,
  /* U+00D9 LATIN CAPITAL LETTER U WITH GRAVE */
  XK_Uacute: 218,
  /* U+00DA LATIN CAPITAL LETTER U WITH ACUTE */
  XK_Ucircumflex: 219,
  /* U+00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
  XK_Udiaeresis: 220,
  /* U+00DC LATIN CAPITAL LETTER U WITH DIAERESIS */
  XK_Yacute: 221,
  /* U+00DD LATIN CAPITAL LETTER Y WITH ACUTE */
  XK_THORN: 222,
  /* U+00DE LATIN CAPITAL LETTER THORN */
  XK_Thorn: 222,
  /* deprecated */
  XK_ssharp: 223,
  /* U+00DF LATIN SMALL LETTER SHARP S */
  XK_agrave: 224,
  /* U+00E0 LATIN SMALL LETTER A WITH GRAVE */
  XK_aacute: 225,
  /* U+00E1 LATIN SMALL LETTER A WITH ACUTE */
  XK_acircumflex: 226,
  /* U+00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX */
  XK_atilde: 227,
  /* U+00E3 LATIN SMALL LETTER A WITH TILDE */
  XK_adiaeresis: 228,
  /* U+00E4 LATIN SMALL LETTER A WITH DIAERESIS */
  XK_aring: 229,
  /* U+00E5 LATIN SMALL LETTER A WITH RING ABOVE */
  XK_ae: 230,
  /* U+00E6 LATIN SMALL LETTER AE */
  XK_ccedilla: 231,
  /* U+00E7 LATIN SMALL LETTER C WITH CEDILLA */
  XK_egrave: 232,
  /* U+00E8 LATIN SMALL LETTER E WITH GRAVE */
  XK_eacute: 233,
  /* U+00E9 LATIN SMALL LETTER E WITH ACUTE */
  XK_ecircumflex: 234,
  /* U+00EA LATIN SMALL LETTER E WITH CIRCUMFLEX */
  XK_ediaeresis: 235,
  /* U+00EB LATIN SMALL LETTER E WITH DIAERESIS */
  XK_igrave: 236,
  /* U+00EC LATIN SMALL LETTER I WITH GRAVE */
  XK_iacute: 237,
  /* U+00ED LATIN SMALL LETTER I WITH ACUTE */
  XK_icircumflex: 238,
  /* U+00EE LATIN SMALL LETTER I WITH CIRCUMFLEX */
  XK_idiaeresis: 239,
  /* U+00EF LATIN SMALL LETTER I WITH DIAERESIS */
  XK_eth: 240,
  /* U+00F0 LATIN SMALL LETTER ETH */
  XK_ntilde: 241,
  /* U+00F1 LATIN SMALL LETTER N WITH TILDE */
  XK_ograve: 242,
  /* U+00F2 LATIN SMALL LETTER O WITH GRAVE */
  XK_oacute: 243,
  /* U+00F3 LATIN SMALL LETTER O WITH ACUTE */
  XK_ocircumflex: 244,
  /* U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX */
  XK_otilde: 245,
  /* U+00F5 LATIN SMALL LETTER O WITH TILDE */
  XK_odiaeresis: 246,
  /* U+00F6 LATIN SMALL LETTER O WITH DIAERESIS */
  XK_division: 247,
  /* U+00F7 DIVISION SIGN */
  XK_oslash: 248,
  /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
  XK_ooblique: 248,
  /* U+00F8 LATIN SMALL LETTER O WITH STROKE */
  XK_ugrave: 249,
  /* U+00F9 LATIN SMALL LETTER U WITH GRAVE */
  XK_uacute: 250,
  /* U+00FA LATIN SMALL LETTER U WITH ACUTE */
  XK_ucircumflex: 251,
  /* U+00FB LATIN SMALL LETTER U WITH CIRCUMFLEX */
  XK_udiaeresis: 252,
  /* U+00FC LATIN SMALL LETTER U WITH DIAERESIS */
  XK_yacute: 253,
  /* U+00FD LATIN SMALL LETTER Y WITH ACUTE */
  XK_thorn: 254,
  /* U+00FE LATIN SMALL LETTER THORN */
  XK_ydiaeresis: 255,
  /* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */
  /*
   * Korean
   * Byte 3 = 0x0e
   */
  XK_Hangul: 65329,
  /* Hangul start/stop(toggle) */
  XK_Hangul_Hanja: 65332,
  /* Start Hangul->Hanja Conversion */
  XK_Hangul_Jeonja: 65336,
  /* Jeonja mode */
  /*
   * XFree86 vendor specific keysyms.
   *
   * The XFree86 keysym range is 0x10080001 - 0x1008FFFF.
   */
  XF86XK_ModeLock: 269025025,
  XF86XK_MonBrightnessUp: 269025026,
  XF86XK_MonBrightnessDown: 269025027,
  XF86XK_KbdLightOnOff: 269025028,
  XF86XK_KbdBrightnessUp: 269025029,
  XF86XK_KbdBrightnessDown: 269025030,
  XF86XK_Standby: 269025040,
  XF86XK_AudioLowerVolume: 269025041,
  XF86XK_AudioMute: 269025042,
  XF86XK_AudioRaiseVolume: 269025043,
  XF86XK_AudioPlay: 269025044,
  XF86XK_AudioStop: 269025045,
  XF86XK_AudioPrev: 269025046,
  XF86XK_AudioNext: 269025047,
  XF86XK_HomePage: 269025048,
  XF86XK_Mail: 269025049,
  XF86XK_Start: 269025050,
  XF86XK_Search: 269025051,
  XF86XK_AudioRecord: 269025052,
  XF86XK_Calculator: 269025053,
  XF86XK_Memo: 269025054,
  XF86XK_ToDoList: 269025055,
  XF86XK_Calendar: 269025056,
  XF86XK_PowerDown: 269025057,
  XF86XK_ContrastAdjust: 269025058,
  XF86XK_RockerUp: 269025059,
  XF86XK_RockerDown: 269025060,
  XF86XK_RockerEnter: 269025061,
  XF86XK_Back: 269025062,
  XF86XK_Forward: 269025063,
  XF86XK_Stop: 269025064,
  XF86XK_Refresh: 269025065,
  XF86XK_PowerOff: 269025066,
  XF86XK_WakeUp: 269025067,
  XF86XK_Eject: 269025068,
  XF86XK_ScreenSaver: 269025069,
  XF86XK_WWW: 269025070,
  XF86XK_Sleep: 269025071,
  XF86XK_Favorites: 269025072,
  XF86XK_AudioPause: 269025073,
  XF86XK_AudioMedia: 269025074,
  XF86XK_MyComputer: 269025075,
  XF86XK_VendorHome: 269025076,
  XF86XK_LightBulb: 269025077,
  XF86XK_Shop: 269025078,
  XF86XK_History: 269025079,
  XF86XK_OpenURL: 269025080,
  XF86XK_AddFavorite: 269025081,
  XF86XK_HotLinks: 269025082,
  XF86XK_BrightnessAdjust: 269025083,
  XF86XK_Finance: 269025084,
  XF86XK_Community: 269025085,
  XF86XK_AudioRewind: 269025086,
  XF86XK_BackForward: 269025087,
  XF86XK_Launch0: 269025088,
  XF86XK_Launch1: 269025089,
  XF86XK_Launch2: 269025090,
  XF86XK_Launch3: 269025091,
  XF86XK_Launch4: 269025092,
  XF86XK_Launch5: 269025093,
  XF86XK_Launch6: 269025094,
  XF86XK_Launch7: 269025095,
  XF86XK_Launch8: 269025096,
  XF86XK_Launch9: 269025097,
  XF86XK_LaunchA: 269025098,
  XF86XK_LaunchB: 269025099,
  XF86XK_LaunchC: 269025100,
  XF86XK_LaunchD: 269025101,
  XF86XK_LaunchE: 269025102,
  XF86XK_LaunchF: 269025103,
  XF86XK_ApplicationLeft: 269025104,
  XF86XK_ApplicationRight: 269025105,
  XF86XK_Book: 269025106,
  XF86XK_CD: 269025107,
  XF86XK_Calculater: 269025108,
  XF86XK_Clear: 269025109,
  XF86XK_Close: 269025110,
  XF86XK_Copy: 269025111,
  XF86XK_Cut: 269025112,
  XF86XK_Display: 269025113,
  XF86XK_DOS: 269025114,
  XF86XK_Documents: 269025115,
  XF86XK_Excel: 269025116,
  XF86XK_Explorer: 269025117,
  XF86XK_Game: 269025118,
  XF86XK_Go: 269025119,
  XF86XK_iTouch: 269025120,
  XF86XK_LogOff: 269025121,
  XF86XK_Market: 269025122,
  XF86XK_Meeting: 269025123,
  XF86XK_MenuKB: 269025125,
  XF86XK_MenuPB: 269025126,
  XF86XK_MySites: 269025127,
  XF86XK_New: 269025128,
  XF86XK_News: 269025129,
  XF86XK_OfficeHome: 269025130,
  XF86XK_Open: 269025131,
  XF86XK_Option: 269025132,
  XF86XK_Paste: 269025133,
  XF86XK_Phone: 269025134,
  XF86XK_Q: 269025136,
  XF86XK_Reply: 269025138,
  XF86XK_Reload: 269025139,
  XF86XK_RotateWindows: 269025140,
  XF86XK_RotationPB: 269025141,
  XF86XK_RotationKB: 269025142,
  XF86XK_Save: 269025143,
  XF86XK_ScrollUp: 269025144,
  XF86XK_ScrollDown: 269025145,
  XF86XK_ScrollClick: 269025146,
  XF86XK_Send: 269025147,
  XF86XK_Spell: 269025148,
  XF86XK_SplitScreen: 269025149,
  XF86XK_Support: 269025150,
  XF86XK_TaskPane: 269025151,
  XF86XK_Terminal: 269025152,
  XF86XK_Tools: 269025153,
  XF86XK_Travel: 269025154,
  XF86XK_UserPB: 269025156,
  XF86XK_User1KB: 269025157,
  XF86XK_User2KB: 269025158,
  XF86XK_Video: 269025159,
  XF86XK_WheelButton: 269025160,
  XF86XK_Word: 269025161,
  XF86XK_Xfer: 269025162,
  XF86XK_ZoomIn: 269025163,
  XF86XK_ZoomOut: 269025164,
  XF86XK_Away: 269025165,
  XF86XK_Messenger: 269025166,
  XF86XK_WebCam: 269025167,
  XF86XK_MailForward: 269025168,
  XF86XK_Pictures: 269025169,
  XF86XK_Music: 269025170,
  XF86XK_Battery: 269025171,
  XF86XK_Bluetooth: 269025172,
  XF86XK_WLAN: 269025173,
  XF86XK_UWB: 269025174,
  XF86XK_AudioForward: 269025175,
  XF86XK_AudioRepeat: 269025176,
  XF86XK_AudioRandomPlay: 269025177,
  XF86XK_Subtitle: 269025178,
  XF86XK_AudioCycleTrack: 269025179,
  XF86XK_CycleAngle: 269025180,
  XF86XK_FrameBack: 269025181,
  XF86XK_FrameForward: 269025182,
  XF86XK_Time: 269025183,
  XF86XK_Select: 269025184,
  XF86XK_View: 269025185,
  XF86XK_TopMenu: 269025186,
  XF86XK_Red: 269025187,
  XF86XK_Green: 269025188,
  XF86XK_Yellow: 269025189,
  XF86XK_Blue: 269025190,
  XF86XK_Suspend: 269025191,
  XF86XK_Hibernate: 269025192,
  XF86XK_TouchpadToggle: 269025193,
  XF86XK_TouchpadOn: 269025200,
  XF86XK_TouchpadOff: 269025201,
  XF86XK_AudioMicMute: 269025202,
  XF86XK_Switch_VT_1: 269024769,
  XF86XK_Switch_VT_2: 269024770,
  XF86XK_Switch_VT_3: 269024771,
  XF86XK_Switch_VT_4: 269024772,
  XF86XK_Switch_VT_5: 269024773,
  XF86XK_Switch_VT_6: 269024774,
  XF86XK_Switch_VT_7: 269024775,
  XF86XK_Switch_VT_8: 269024776,
  XF86XK_Switch_VT_9: 269024777,
  XF86XK_Switch_VT_10: 269024778,
  XF86XK_Switch_VT_11: 269024779,
  XF86XK_Switch_VT_12: 269024780,
  XF86XK_Ungrab: 269024800,
  XF86XK_ClearGrab: 269024801,
  XF86XK_Next_VMode: 269024802,
  XF86XK_Prev_VMode: 269024803,
  XF86XK_LogWindowTree: 269024804,
  XF86XK_LogGrabInfo: 269024805
};

// core/input/keysymdef.js
var codepoints = {
  256: 960,
  // XK_Amacron
  257: 992,
  // XK_amacron
  258: 451,
  // XK_Abreve
  259: 483,
  // XK_abreve
  260: 417,
  // XK_Aogonek
  261: 433,
  // XK_aogonek
  262: 454,
  // XK_Cacute
  263: 486,
  // XK_cacute
  264: 710,
  // XK_Ccircumflex
  265: 742,
  // XK_ccircumflex
  266: 709,
  // XK_Cabovedot
  267: 741,
  // XK_cabovedot
  268: 456,
  // XK_Ccaron
  269: 488,
  // XK_ccaron
  270: 463,
  // XK_Dcaron
  271: 495,
  // XK_dcaron
  272: 464,
  // XK_Dstroke
  273: 496,
  // XK_dstroke
  274: 938,
  // XK_Emacron
  275: 954,
  // XK_emacron
  278: 972,
  // XK_Eabovedot
  279: 1004,
  // XK_eabovedot
  280: 458,
  // XK_Eogonek
  281: 490,
  // XK_eogonek
  282: 460,
  // XK_Ecaron
  283: 492,
  // XK_ecaron
  284: 728,
  // XK_Gcircumflex
  285: 760,
  // XK_gcircumflex
  286: 683,
  // XK_Gbreve
  287: 699,
  // XK_gbreve
  288: 725,
  // XK_Gabovedot
  289: 757,
  // XK_gabovedot
  290: 939,
  // XK_Gcedilla
  291: 955,
  // XK_gcedilla
  292: 678,
  // XK_Hcircumflex
  293: 694,
  // XK_hcircumflex
  294: 673,
  // XK_Hstroke
  295: 689,
  // XK_hstroke
  296: 933,
  // XK_Itilde
  297: 949,
  // XK_itilde
  298: 975,
  // XK_Imacron
  299: 1007,
  // XK_imacron
  302: 967,
  // XK_Iogonek
  303: 999,
  // XK_iogonek
  304: 681,
  // XK_Iabovedot
  305: 697,
  // XK_idotless
  308: 684,
  // XK_Jcircumflex
  309: 700,
  // XK_jcircumflex
  310: 979,
  // XK_Kcedilla
  311: 1011,
  // XK_kcedilla
  312: 930,
  // XK_kra
  313: 453,
  // XK_Lacute
  314: 485,
  // XK_lacute
  315: 934,
  // XK_Lcedilla
  316: 950,
  // XK_lcedilla
  317: 421,
  // XK_Lcaron
  318: 437,
  // XK_lcaron
  321: 419,
  // XK_Lstroke
  322: 435,
  // XK_lstroke
  323: 465,
  // XK_Nacute
  324: 497,
  // XK_nacute
  325: 977,
  // XK_Ncedilla
  326: 1009,
  // XK_ncedilla
  327: 466,
  // XK_Ncaron
  328: 498,
  // XK_ncaron
  330: 957,
  // XK_ENG
  331: 959,
  // XK_eng
  332: 978,
  // XK_Omacron
  333: 1010,
  // XK_omacron
  336: 469,
  // XK_Odoubleacute
  337: 501,
  // XK_odoubleacute
  338: 5052,
  // XK_OE
  339: 5053,
  // XK_oe
  340: 448,
  // XK_Racute
  341: 480,
  // XK_racute
  342: 931,
  // XK_Rcedilla
  343: 947,
  // XK_rcedilla
  344: 472,
  // XK_Rcaron
  345: 504,
  // XK_rcaron
  346: 422,
  // XK_Sacute
  347: 438,
  // XK_sacute
  348: 734,
  // XK_Scircumflex
  349: 766,
  // XK_scircumflex
  350: 426,
  // XK_Scedilla
  351: 442,
  // XK_scedilla
  352: 425,
  // XK_Scaron
  353: 441,
  // XK_scaron
  354: 478,
  // XK_Tcedilla
  355: 510,
  // XK_tcedilla
  356: 427,
  // XK_Tcaron
  357: 443,
  // XK_tcaron
  358: 940,
  // XK_Tslash
  359: 956,
  // XK_tslash
  360: 989,
  // XK_Utilde
  361: 1021,
  // XK_utilde
  362: 990,
  // XK_Umacron
  363: 1022,
  // XK_umacron
  364: 733,
  // XK_Ubreve
  365: 765,
  // XK_ubreve
  366: 473,
  // XK_Uring
  367: 505,
  // XK_uring
  368: 475,
  // XK_Udoubleacute
  369: 507,
  // XK_udoubleacute
  370: 985,
  // XK_Uogonek
  371: 1017,
  // XK_uogonek
  376: 5054,
  // XK_Ydiaeresis
  377: 428,
  // XK_Zacute
  378: 444,
  // XK_zacute
  379: 431,
  // XK_Zabovedot
  380: 447,
  // XK_zabovedot
  381: 430,
  // XK_Zcaron
  382: 446,
  // XK_zcaron
  402: 2294,
  // XK_function
  466: 16777681,
  // XK_Ocaron
  711: 439,
  // XK_caron
  728: 418,
  // XK_breve
  729: 511,
  // XK_abovedot
  731: 434,
  // XK_ogonek
  733: 445,
  // XK_doubleacute
  901: 1966,
  // XK_Greek_accentdieresis
  902: 1953,
  // XK_Greek_ALPHAaccent
  904: 1954,
  // XK_Greek_EPSILONaccent
  905: 1955,
  // XK_Greek_ETAaccent
  906: 1956,
  // XK_Greek_IOTAaccent
  908: 1959,
  // XK_Greek_OMICRONaccent
  910: 1960,
  // XK_Greek_UPSILONaccent
  911: 1963,
  // XK_Greek_OMEGAaccent
  912: 1974,
  // XK_Greek_iotaaccentdieresis
  913: 1985,
  // XK_Greek_ALPHA
  914: 1986,
  // XK_Greek_BETA
  915: 1987,
  // XK_Greek_GAMMA
  916: 1988,
  // XK_Greek_DELTA
  917: 1989,
  // XK_Greek_EPSILON
  918: 1990,
  // XK_Greek_ZETA
  919: 1991,
  // XK_Greek_ETA
  920: 1992,
  // XK_Greek_THETA
  921: 1993,
  // XK_Greek_IOTA
  922: 1994,
  // XK_Greek_KAPPA
  923: 1995,
  // XK_Greek_LAMDA
  924: 1996,
  // XK_Greek_MU
  925: 1997,
  // XK_Greek_NU
  926: 1998,
  // XK_Greek_XI
  927: 1999,
  // XK_Greek_OMICRON
  928: 2e3,
  // XK_Greek_PI
  929: 2001,
  // XK_Greek_RHO
  931: 2002,
  // XK_Greek_SIGMA
  932: 2004,
  // XK_Greek_TAU
  933: 2005,
  // XK_Greek_UPSILON
  934: 2006,
  // XK_Greek_PHI
  935: 2007,
  // XK_Greek_CHI
  936: 2008,
  // XK_Greek_PSI
  937: 2009,
  // XK_Greek_OMEGA
  938: 1957,
  // XK_Greek_IOTAdieresis
  939: 1961,
  // XK_Greek_UPSILONdieresis
  940: 1969,
  // XK_Greek_alphaaccent
  941: 1970,
  // XK_Greek_epsilonaccent
  942: 1971,
  // XK_Greek_etaaccent
  943: 1972,
  // XK_Greek_iotaaccent
  944: 1978,
  // XK_Greek_upsilonaccentdieresis
  945: 2017,
  // XK_Greek_alpha
  946: 2018,
  // XK_Greek_beta
  947: 2019,
  // XK_Greek_gamma
  948: 2020,
  // XK_Greek_delta
  949: 2021,
  // XK_Greek_epsilon
  950: 2022,
  // XK_Greek_zeta
  951: 2023,
  // XK_Greek_eta
  952: 2024,
  // XK_Greek_theta
  953: 2025,
  // XK_Greek_iota
  954: 2026,
  // XK_Greek_kappa
  955: 2027,
  // XK_Greek_lamda
  956: 2028,
  // XK_Greek_mu
  957: 2029,
  // XK_Greek_nu
  958: 2030,
  // XK_Greek_xi
  959: 2031,
  // XK_Greek_omicron
  960: 2032,
  // XK_Greek_pi
  961: 2033,
  // XK_Greek_rho
  962: 2035,
  // XK_Greek_finalsmallsigma
  963: 2034,
  // XK_Greek_sigma
  964: 2036,
  // XK_Greek_tau
  965: 2037,
  // XK_Greek_upsilon
  966: 2038,
  // XK_Greek_phi
  967: 2039,
  // XK_Greek_chi
  968: 2040,
  // XK_Greek_psi
  969: 2041,
  // XK_Greek_omega
  970: 1973,
  // XK_Greek_iotadieresis
  971: 1977,
  // XK_Greek_upsilondieresis
  972: 1975,
  // XK_Greek_omicronaccent
  973: 1976,
  // XK_Greek_upsilonaccent
  974: 1979,
  // XK_Greek_omegaaccent
  1025: 1715,
  // XK_Cyrillic_IO
  1026: 1713,
  // XK_Serbian_DJE
  1027: 1714,
  // XK_Macedonia_GJE
  1028: 1716,
  // XK_Ukrainian_IE
  1029: 1717,
  // XK_Macedonia_DSE
  1030: 1718,
  // XK_Ukrainian_I
  1031: 1719,
  // XK_Ukrainian_YI
  1032: 1720,
  // XK_Cyrillic_JE
  1033: 1721,
  // XK_Cyrillic_LJE
  1034: 1722,
  // XK_Cyrillic_NJE
  1035: 1723,
  // XK_Serbian_TSHE
  1036: 1724,
  // XK_Macedonia_KJE
  1038: 1726,
  // XK_Byelorussian_SHORTU
  1039: 1727,
  // XK_Cyrillic_DZHE
  1040: 1761,
  // XK_Cyrillic_A
  1041: 1762,
  // XK_Cyrillic_BE
  1042: 1783,
  // XK_Cyrillic_VE
  1043: 1767,
  // XK_Cyrillic_GHE
  1044: 1764,
  // XK_Cyrillic_DE
  1045: 1765,
  // XK_Cyrillic_IE
  1046: 1782,
  // XK_Cyrillic_ZHE
  1047: 1786,
  // XK_Cyrillic_ZE
  1048: 1769,
  // XK_Cyrillic_I
  1049: 1770,
  // XK_Cyrillic_SHORTI
  1050: 1771,
  // XK_Cyrillic_KA
  1051: 1772,
  // XK_Cyrillic_EL
  1052: 1773,
  // XK_Cyrillic_EM
  1053: 1774,
  // XK_Cyrillic_EN
  1054: 1775,
  // XK_Cyrillic_O
  1055: 1776,
  // XK_Cyrillic_PE
  1056: 1778,
  // XK_Cyrillic_ER
  1057: 1779,
  // XK_Cyrillic_ES
  1058: 1780,
  // XK_Cyrillic_TE
  1059: 1781,
  // XK_Cyrillic_U
  1060: 1766,
  // XK_Cyrillic_EF
  1061: 1768,
  // XK_Cyrillic_HA
  1062: 1763,
  // XK_Cyrillic_TSE
  1063: 1790,
  // XK_Cyrillic_CHE
  1064: 1787,
  // XK_Cyrillic_SHA
  1065: 1789,
  // XK_Cyrillic_SHCHA
  1066: 1791,
  // XK_Cyrillic_HARDSIGN
  1067: 1785,
  // XK_Cyrillic_YERU
  1068: 1784,
  // XK_Cyrillic_SOFTSIGN
  1069: 1788,
  // XK_Cyrillic_E
  1070: 1760,
  // XK_Cyrillic_YU
  1071: 1777,
  // XK_Cyrillic_YA
  1072: 1729,
  // XK_Cyrillic_a
  1073: 1730,
  // XK_Cyrillic_be
  1074: 1751,
  // XK_Cyrillic_ve
  1075: 1735,
  // XK_Cyrillic_ghe
  1076: 1732,
  // XK_Cyrillic_de
  1077: 1733,
  // XK_Cyrillic_ie
  1078: 1750,
  // XK_Cyrillic_zhe
  1079: 1754,
  // XK_Cyrillic_ze
  1080: 1737,
  // XK_Cyrillic_i
  1081: 1738,
  // XK_Cyrillic_shorti
  1082: 1739,
  // XK_Cyrillic_ka
  1083: 1740,
  // XK_Cyrillic_el
  1084: 1741,
  // XK_Cyrillic_em
  1085: 1742,
  // XK_Cyrillic_en
  1086: 1743,
  // XK_Cyrillic_o
  1087: 1744,
  // XK_Cyrillic_pe
  1088: 1746,
  // XK_Cyrillic_er
  1089: 1747,
  // XK_Cyrillic_es
  1090: 1748,
  // XK_Cyrillic_te
  1091: 1749,
  // XK_Cyrillic_u
  1092: 1734,
  // XK_Cyrillic_ef
  1093: 1736,
  // XK_Cyrillic_ha
  1094: 1731,
  // XK_Cyrillic_tse
  1095: 1758,
  // XK_Cyrillic_che
  1096: 1755,
  // XK_Cyrillic_sha
  1097: 1757,
  // XK_Cyrillic_shcha
  1098: 1759,
  // XK_Cyrillic_hardsign
  1099: 1753,
  // XK_Cyrillic_yeru
  1100: 1752,
  // XK_Cyrillic_softsign
  1101: 1756,
  // XK_Cyrillic_e
  1102: 1728,
  // XK_Cyrillic_yu
  1103: 1745,
  // XK_Cyrillic_ya
  1105: 1699,
  // XK_Cyrillic_io
  1106: 1697,
  // XK_Serbian_dje
  1107: 1698,
  // XK_Macedonia_gje
  1108: 1700,
  // XK_Ukrainian_ie
  1109: 1701,
  // XK_Macedonia_dse
  1110: 1702,
  // XK_Ukrainian_i
  1111: 1703,
  // XK_Ukrainian_yi
  1112: 1704,
  // XK_Cyrillic_je
  1113: 1705,
  // XK_Cyrillic_lje
  1114: 1706,
  // XK_Cyrillic_nje
  1115: 1707,
  // XK_Serbian_tshe
  1116: 1708,
  // XK_Macedonia_kje
  1118: 1710,
  // XK_Byelorussian_shortu
  1119: 1711,
  // XK_Cyrillic_dzhe
  1168: 1725,
  // XK_Ukrainian_GHE_WITH_UPTURN
  1169: 1709,
  // XK_Ukrainian_ghe_with_upturn
  1488: 3296,
  // XK_hebrew_aleph
  1489: 3297,
  // XK_hebrew_bet
  1490: 3298,
  // XK_hebrew_gimel
  1491: 3299,
  // XK_hebrew_dalet
  1492: 3300,
  // XK_hebrew_he
  1493: 3301,
  // XK_hebrew_waw
  1494: 3302,
  // XK_hebrew_zain
  1495: 3303,
  // XK_hebrew_chet
  1496: 3304,
  // XK_hebrew_tet
  1497: 3305,
  // XK_hebrew_yod
  1498: 3306,
  // XK_hebrew_finalkaph
  1499: 3307,
  // XK_hebrew_kaph
  1500: 3308,
  // XK_hebrew_lamed
  1501: 3309,
  // XK_hebrew_finalmem
  1502: 3310,
  // XK_hebrew_mem
  1503: 3311,
  // XK_hebrew_finalnun
  1504: 3312,
  // XK_hebrew_nun
  1505: 3313,
  // XK_hebrew_samech
  1506: 3314,
  // XK_hebrew_ayin
  1507: 3315,
  // XK_hebrew_finalpe
  1508: 3316,
  // XK_hebrew_pe
  1509: 3317,
  // XK_hebrew_finalzade
  1510: 3318,
  // XK_hebrew_zade
  1511: 3319,
  // XK_hebrew_qoph
  1512: 3320,
  // XK_hebrew_resh
  1513: 3321,
  // XK_hebrew_shin
  1514: 3322,
  // XK_hebrew_taw
  1548: 1452,
  // XK_Arabic_comma
  1563: 1467,
  // XK_Arabic_semicolon
  1567: 1471,
  // XK_Arabic_question_mark
  1569: 1473,
  // XK_Arabic_hamza
  1570: 1474,
  // XK_Arabic_maddaonalef
  1571: 1475,
  // XK_Arabic_hamzaonalef
  1572: 1476,
  // XK_Arabic_hamzaonwaw
  1573: 1477,
  // XK_Arabic_hamzaunderalef
  1574: 1478,
  // XK_Arabic_hamzaonyeh
  1575: 1479,
  // XK_Arabic_alef
  1576: 1480,
  // XK_Arabic_beh
  1577: 1481,
  // XK_Arabic_tehmarbuta
  1578: 1482,
  // XK_Arabic_teh
  1579: 1483,
  // XK_Arabic_theh
  1580: 1484,
  // XK_Arabic_jeem
  1581: 1485,
  // XK_Arabic_hah
  1582: 1486,
  // XK_Arabic_khah
  1583: 1487,
  // XK_Arabic_dal
  1584: 1488,
  // XK_Arabic_thal
  1585: 1489,
  // XK_Arabic_ra
  1586: 1490,
  // XK_Arabic_zain
  1587: 1491,
  // XK_Arabic_seen
  1588: 1492,
  // XK_Arabic_sheen
  1589: 1493,
  // XK_Arabic_sad
  1590: 1494,
  // XK_Arabic_dad
  1591: 1495,
  // XK_Arabic_tah
  1592: 1496,
  // XK_Arabic_zah
  1593: 1497,
  // XK_Arabic_ain
  1594: 1498,
  // XK_Arabic_ghain
  1600: 1504,
  // XK_Arabic_tatweel
  1601: 1505,
  // XK_Arabic_feh
  1602: 1506,
  // XK_Arabic_qaf
  1603: 1507,
  // XK_Arabic_kaf
  1604: 1508,
  // XK_Arabic_lam
  1605: 1509,
  // XK_Arabic_meem
  1606: 1510,
  // XK_Arabic_noon
  1607: 1511,
  // XK_Arabic_ha
  1608: 1512,
  // XK_Arabic_waw
  1609: 1513,
  // XK_Arabic_alefmaksura
  1610: 1514,
  // XK_Arabic_yeh
  1611: 1515,
  // XK_Arabic_fathatan
  1612: 1516,
  // XK_Arabic_dammatan
  1613: 1517,
  // XK_Arabic_kasratan
  1614: 1518,
  // XK_Arabic_fatha
  1615: 1519,
  // XK_Arabic_damma
  1616: 1520,
  // XK_Arabic_kasra
  1617: 1521,
  // XK_Arabic_shadda
  1618: 1522,
  // XK_Arabic_sukun
  3585: 3489,
  // XK_Thai_kokai
  3586: 3490,
  // XK_Thai_khokhai
  3587: 3491,
  // XK_Thai_khokhuat
  3588: 3492,
  // XK_Thai_khokhwai
  3589: 3493,
  // XK_Thai_khokhon
  3590: 3494,
  // XK_Thai_khorakhang
  3591: 3495,
  // XK_Thai_ngongu
  3592: 3496,
  // XK_Thai_chochan
  3593: 3497,
  // XK_Thai_choching
  3594: 3498,
  // XK_Thai_chochang
  3595: 3499,
  // XK_Thai_soso
  3596: 3500,
  // XK_Thai_chochoe
  3597: 3501,
  // XK_Thai_yoying
  3598: 3502,
  // XK_Thai_dochada
  3599: 3503,
  // XK_Thai_topatak
  3600: 3504,
  // XK_Thai_thothan
  3601: 3505,
  // XK_Thai_thonangmontho
  3602: 3506,
  // XK_Thai_thophuthao
  3603: 3507,
  // XK_Thai_nonen
  3604: 3508,
  // XK_Thai_dodek
  3605: 3509,
  // XK_Thai_totao
  3606: 3510,
  // XK_Thai_thothung
  3607: 3511,
  // XK_Thai_thothahan
  3608: 3512,
  // XK_Thai_thothong
  3609: 3513,
  // XK_Thai_nonu
  3610: 3514,
  // XK_Thai_bobaimai
  3611: 3515,
  // XK_Thai_popla
  3612: 3516,
  // XK_Thai_phophung
  3613: 3517,
  // XK_Thai_fofa
  3614: 3518,
  // XK_Thai_phophan
  3615: 3519,
  // XK_Thai_fofan
  3616: 3520,
  // XK_Thai_phosamphao
  3617: 3521,
  // XK_Thai_moma
  3618: 3522,
  // XK_Thai_yoyak
  3619: 3523,
  // XK_Thai_rorua
  3620: 3524,
  // XK_Thai_ru
  3621: 3525,
  // XK_Thai_loling
  3622: 3526,
  // XK_Thai_lu
  3623: 3527,
  // XK_Thai_wowaen
  3624: 3528,
  // XK_Thai_sosala
  3625: 3529,
  // XK_Thai_sorusi
  3626: 3530,
  // XK_Thai_sosua
  3627: 3531,
  // XK_Thai_hohip
  3628: 3532,
  // XK_Thai_lochula
  3629: 3533,
  // XK_Thai_oang
  3630: 3534,
  // XK_Thai_honokhuk
  3631: 3535,
  // XK_Thai_paiyannoi
  3632: 3536,
  // XK_Thai_saraa
  3633: 3537,
  // XK_Thai_maihanakat
  3634: 3538,
  // XK_Thai_saraaa
  3635: 3539,
  // XK_Thai_saraam
  3636: 3540,
  // XK_Thai_sarai
  3637: 3541,
  // XK_Thai_saraii
  3638: 3542,
  // XK_Thai_saraue
  3639: 3543,
  // XK_Thai_sarauee
  3640: 3544,
  // XK_Thai_sarau
  3641: 3545,
  // XK_Thai_sarauu
  3642: 3546,
  // XK_Thai_phinthu
  3647: 3551,
  // XK_Thai_baht
  3648: 3552,
  // XK_Thai_sarae
  3649: 3553,
  // XK_Thai_saraae
  3650: 3554,
  // XK_Thai_sarao
  3651: 3555,
  // XK_Thai_saraaimaimuan
  3652: 3556,
  // XK_Thai_saraaimaimalai
  3653: 3557,
  // XK_Thai_lakkhangyao
  3654: 3558,
  // XK_Thai_maiyamok
  3655: 3559,
  // XK_Thai_maitaikhu
  3656: 3560,
  // XK_Thai_maiek
  3657: 3561,
  // XK_Thai_maitho
  3658: 3562,
  // XK_Thai_maitri
  3659: 3563,
  // XK_Thai_maichattawa
  3660: 3564,
  // XK_Thai_thanthakhat
  3661: 3565,
  // XK_Thai_nikhahit
  3664: 3568,
  // XK_Thai_leksun
  3665: 3569,
  // XK_Thai_leknung
  3666: 3570,
  // XK_Thai_leksong
  3667: 3571,
  // XK_Thai_leksam
  3668: 3572,
  // XK_Thai_leksi
  3669: 3573,
  // XK_Thai_lekha
  3670: 3574,
  // XK_Thai_lekhok
  3671: 3575,
  // XK_Thai_lekchet
  3672: 3576,
  // XK_Thai_lekpaet
  3673: 3577,
  // XK_Thai_lekkao
  8194: 2722,
  // XK_enspace
  8195: 2721,
  // XK_emspace
  8196: 2723,
  // XK_em3space
  8197: 2724,
  // XK_em4space
  8199: 2725,
  // XK_digitspace
  8200: 2726,
  // XK_punctspace
  8201: 2727,
  // XK_thinspace
  8202: 2728,
  // XK_hairspace
  8210: 2747,
  // XK_figdash
  8211: 2730,
  // XK_endash
  8212: 2729,
  // XK_emdash
  8213: 1967,
  // XK_Greek_horizbar
  8215: 3295,
  // XK_hebrew_doublelowline
  8216: 2768,
  // XK_leftsinglequotemark
  8217: 2769,
  // XK_rightsinglequotemark
  8218: 2813,
  // XK_singlelowquotemark
  8220: 2770,
  // XK_leftdoublequotemark
  8221: 2771,
  // XK_rightdoublequotemark
  8222: 2814,
  // XK_doublelowquotemark
  8224: 2801,
  // XK_dagger
  8225: 2802,
  // XK_doubledagger
  8226: 2790,
  // XK_enfilledcircbullet
  8229: 2735,
  // XK_doubbaselinedot
  8230: 2734,
  // XK_ellipsis
  8240: 2773,
  // XK_permille
  8242: 2774,
  // XK_minutes
  8243: 2775,
  // XK_seconds
  8248: 2812,
  // XK_caret
  8254: 1150,
  // XK_overline
  8361: 3839,
  // XK_Korean_Won
  8364: 8364,
  // XK_EuroSign
  8453: 2744,
  // XK_careof
  8470: 1712,
  // XK_numerosign
  8471: 2811,
  // XK_phonographcopyright
  8478: 2772,
  // XK_prescription
  8482: 2761,
  // XK_trademark
  8531: 2736,
  // XK_onethird
  8532: 2737,
  // XK_twothirds
  8533: 2738,
  // XK_onefifth
  8534: 2739,
  // XK_twofifths
  8535: 2740,
  // XK_threefifths
  8536: 2741,
  // XK_fourfifths
  8537: 2742,
  // XK_onesixth
  8538: 2743,
  // XK_fivesixths
  8539: 2755,
  // XK_oneeighth
  8540: 2756,
  // XK_threeeighths
  8541: 2757,
  // XK_fiveeighths
  8542: 2758,
  // XK_seveneighths
  8592: 2299,
  // XK_leftarrow
  8593: 2300,
  // XK_uparrow
  8594: 2301,
  // XK_rightarrow
  8595: 2302,
  // XK_downarrow
  8658: 2254,
  // XK_implies
  8660: 2253,
  // XK_ifonlyif
  8706: 2287,
  // XK_partialderivative
  8711: 2245,
  // XK_nabla
  8728: 3018,
  // XK_jot
  8730: 2262,
  // XK_radical
  8733: 2241,
  // XK_variation
  8734: 2242,
  // XK_infinity
  8743: 2270,
  // XK_logicaland
  8744: 2271,
  // XK_logicalor
  8745: 2268,
  // XK_intersection
  8746: 2269,
  // XK_union
  8747: 2239,
  // XK_integral
  8756: 2240,
  // XK_therefore
  8764: 2248,
  // XK_approximate
  8771: 2249,
  // XK_similarequal
  8773: 16785992,
  // XK_approxeq
  8800: 2237,
  // XK_notequal
  8801: 2255,
  // XK_identical
  8804: 2236,
  // XK_lessthanequal
  8805: 2238,
  // XK_greaterthanequal
  8834: 2266,
  // XK_includedin
  8835: 2267,
  // XK_includes
  8866: 3068,
  // XK_righttack
  8867: 3036,
  // XK_lefttack
  8868: 3010,
  // XK_downtack
  8869: 3022,
  // XK_uptack
  8968: 3027,
  // XK_upstile
  8970: 3012,
  // XK_downstile
  8981: 2810,
  // XK_telephonerecorder
  8992: 2212,
  // XK_topintegral
  8993: 2213,
  // XK_botintegral
  9109: 3020,
  // XK_quad
  9115: 2219,
  // XK_topleftparens
  9117: 2220,
  // XK_botleftparens
  9118: 2221,
  // XK_toprightparens
  9120: 2222,
  // XK_botrightparens
  9121: 2215,
  // XK_topleftsqbracket
  9123: 2216,
  // XK_botleftsqbracket
  9124: 2217,
  // XK_toprightsqbracket
  9126: 2218,
  // XK_botrightsqbracket
  9128: 2223,
  // XK_leftmiddlecurlybrace
  9132: 2224,
  // XK_rightmiddlecurlybrace
  9143: 2209,
  // XK_leftradical
  9146: 2543,
  // XK_horizlinescan1
  9147: 2544,
  // XK_horizlinescan3
  9148: 2546,
  // XK_horizlinescan7
  9149: 2547,
  // XK_horizlinescan9
  9225: 2530,
  // XK_ht
  9226: 2533,
  // XK_lf
  9227: 2537,
  // XK_vt
  9228: 2531,
  // XK_ff
  9229: 2532,
  // XK_cr
  9251: 2732,
  // XK_signifblank
  9252: 2536,
  // XK_nl
  9472: 2211,
  // XK_horizconnector
  9474: 2214,
  // XK_vertconnector
  9484: 2210,
  // XK_topleftradical
  9488: 2539,
  // XK_uprightcorner
  9492: 2541,
  // XK_lowleftcorner
  9496: 2538,
  // XK_lowrightcorner
  9500: 2548,
  // XK_leftt
  9508: 2549,
  // XK_rightt
  9516: 2551,
  // XK_topt
  9524: 2550,
  // XK_bott
  9532: 2542,
  // XK_crossinglines
  9618: 2529,
  // XK_checkerboard
  9642: 2791,
  // XK_enfilledsqbullet
  9643: 2785,
  // XK_enopensquarebullet
  9644: 2779,
  // XK_filledrectbullet
  9645: 2786,
  // XK_openrectbullet
  9646: 2783,
  // XK_emfilledrect
  9647: 2767,
  // XK_emopenrectangle
  9650: 2792,
  // XK_filledtribulletup
  9651: 2787,
  // XK_opentribulletup
  9654: 2781,
  // XK_filledrighttribullet
  9655: 2765,
  // XK_rightopentriangle
  9660: 2793,
  // XK_filledtribulletdown
  9661: 2788,
  // XK_opentribulletdown
  9664: 2780,
  // XK_filledlefttribullet
  9665: 2764,
  // XK_leftopentriangle
  9670: 2528,
  // XK_soliddiamond
  9675: 2766,
  // XK_emopencircle
  9679: 2782,
  // XK_emfilledcircle
  9702: 2784,
  // XK_enopencircbullet
  9734: 2789,
  // XK_openstar
  9742: 2809,
  // XK_telephone
  9747: 2762,
  // XK_signaturemark
  9756: 2794,
  // XK_leftpointer
  9758: 2795,
  // XK_rightpointer
  9792: 2808,
  // XK_femalesymbol
  9794: 2807,
  // XK_malesymbol
  9827: 2796,
  // XK_club
  9829: 2798,
  // XK_heart
  9830: 2797,
  // XK_diamond
  9837: 2806,
  // XK_musicalflat
  9839: 2805,
  // XK_musicalsharp
  10003: 2803,
  // XK_checkmark
  10007: 2804,
  // XK_ballotcross
  10013: 2777,
  // XK_latincross
  10016: 2800,
  // XK_maltesecross
  10216: 2748,
  // XK_leftanglebracket
  10217: 2750,
  // XK_rightanglebracket
  12289: 1188,
  // XK_kana_comma
  12290: 1185,
  // XK_kana_fullstop
  12300: 1186,
  // XK_kana_openingbracket
  12301: 1187,
  // XK_kana_closingbracket
  12443: 1246,
  // XK_voicedsound
  12444: 1247,
  // XK_semivoicedsound
  12449: 1191,
  // XK_kana_a
  12450: 1201,
  // XK_kana_A
  12451: 1192,
  // XK_kana_i
  12452: 1202,
  // XK_kana_I
  12453: 1193,
  // XK_kana_u
  12454: 1203,
  // XK_kana_U
  12455: 1194,
  // XK_kana_e
  12456: 1204,
  // XK_kana_E
  12457: 1195,
  // XK_kana_o
  12458: 1205,
  // XK_kana_O
  12459: 1206,
  // XK_kana_KA
  12461: 1207,
  // XK_kana_KI
  12463: 1208,
  // XK_kana_KU
  12465: 1209,
  // XK_kana_KE
  12467: 1210,
  // XK_kana_KO
  12469: 1211,
  // XK_kana_SA
  12471: 1212,
  // XK_kana_SHI
  12473: 1213,
  // XK_kana_SU
  12475: 1214,
  // XK_kana_SE
  12477: 1215,
  // XK_kana_SO
  12479: 1216,
  // XK_kana_TA
  12481: 1217,
  // XK_kana_CHI
  12483: 1199,
  // XK_kana_tsu
  12484: 1218,
  // XK_kana_TSU
  12486: 1219,
  // XK_kana_TE
  12488: 1220,
  // XK_kana_TO
  12490: 1221,
  // XK_kana_NA
  12491: 1222,
  // XK_kana_NI
  12492: 1223,
  // XK_kana_NU
  12493: 1224,
  // XK_kana_NE
  12494: 1225,
  // XK_kana_NO
  12495: 1226,
  // XK_kana_HA
  12498: 1227,
  // XK_kana_HI
  12501: 1228,
  // XK_kana_FU
  12504: 1229,
  // XK_kana_HE
  12507: 1230,
  // XK_kana_HO
  12510: 1231,
  // XK_kana_MA
  12511: 1232,
  // XK_kana_MI
  12512: 1233,
  // XK_kana_MU
  12513: 1234,
  // XK_kana_ME
  12514: 1235,
  // XK_kana_MO
  12515: 1196,
  // XK_kana_ya
  12516: 1236,
  // XK_kana_YA
  12517: 1197,
  // XK_kana_yu
  12518: 1237,
  // XK_kana_YU
  12519: 1198,
  // XK_kana_yo
  12520: 1238,
  // XK_kana_YO
  12521: 1239,
  // XK_kana_RA
  12522: 1240,
  // XK_kana_RI
  12523: 1241,
  // XK_kana_RU
  12524: 1242,
  // XK_kana_RE
  12525: 1243,
  // XK_kana_RO
  12527: 1244,
  // XK_kana_WA
  12530: 1190,
  // XK_kana_WO
  12531: 1245,
  // XK_kana_N
  12539: 1189,
  // XK_kana_conjunctive
  12540: 1200
  // XK_prolongedsound
};
var keysymdef_default = {
  lookup(u) {
    if (u >= 32 && u <= 255) {
      return u;
    }
    const keysym = codepoints[u];
    if (keysym !== void 0) {
      return keysym;
    }
    return 16777216 | u;
  }
};

// core/input/vkeys.js
var vkeys_default = {
  8: "Backspace",
  9: "Tab",
  10: "NumpadClear",
  13: "Enter",
  16: "ShiftLeft",
  17: "ControlLeft",
  18: "AltLeft",
  19: "Pause",
  20: "CapsLock",
  21: "Lang1",
  25: "Lang2",
  27: "Escape",
  28: "Convert",
  29: "NonConvert",
  32: "Space",
  33: "PageUp",
  34: "PageDown",
  35: "End",
  36: "Home",
  37: "ArrowLeft",
  38: "ArrowUp",
  39: "ArrowRight",
  40: "ArrowDown",
  41: "Select",
  44: "PrintScreen",
  45: "Insert",
  46: "Delete",
  47: "Help",
  48: "Digit0",
  49: "Digit1",
  50: "Digit2",
  51: "Digit3",
  52: "Digit4",
  53: "Digit5",
  54: "Digit6",
  55: "Digit7",
  56: "Digit8",
  57: "Digit9",
  91: "MetaLeft",
  92: "MetaRight",
  93: "ContextMenu",
  95: "Sleep",
  96: "Numpad0",
  97: "Numpad1",
  98: "Numpad2",
  99: "Numpad3",
  100: "Numpad4",
  101: "Numpad5",
  102: "Numpad6",
  103: "Numpad7",
  104: "Numpad8",
  105: "Numpad9",
  106: "NumpadMultiply",
  107: "NumpadAdd",
  108: "NumpadDecimal",
  109: "NumpadSubtract",
  110: "NumpadDecimal",
  // Duplicate, because buggy on Windows
  111: "NumpadDivide",
  112: "F1",
  113: "F2",
  114: "F3",
  115: "F4",
  116: "F5",
  117: "F6",
  118: "F7",
  119: "F8",
  120: "F9",
  121: "F10",
  122: "F11",
  123: "F12",
  124: "F13",
  125: "F14",
  126: "F15",
  127: "F16",
  128: "F17",
  129: "F18",
  130: "F19",
  131: "F20",
  132: "F21",
  133: "F22",
  134: "F23",
  135: "F24",
  144: "NumLock",
  145: "ScrollLock",
  166: "BrowserBack",
  167: "BrowserForward",
  168: "BrowserRefresh",
  169: "BrowserStop",
  170: "BrowserSearch",
  171: "BrowserFavorites",
  172: "BrowserHome",
  173: "AudioVolumeMute",
  174: "AudioVolumeDown",
  175: "AudioVolumeUp",
  176: "MediaTrackNext",
  177: "MediaTrackPrevious",
  178: "MediaStop",
  179: "MediaPlayPause",
  180: "LaunchMail",
  181: "MediaSelect",
  182: "LaunchApp1",
  183: "LaunchApp2",
  225: "AltRight"
  // Only when it is AltGraph
};

// core/input/fixedkeys.js
var fixedkeys_default = {
  // 3.1.1.1. Writing System Keys
  "Backspace": "Backspace",
  // 3.1.1.2. Functional Keys
  "AltLeft": "Alt",
  "AltRight": "Alt",
  // This could also be 'AltGraph'
  "CapsLock": "CapsLock",
  "ContextMenu": "ContextMenu",
  "ControlLeft": "Control",
  "ControlRight": "Control",
  "Enter": "Enter",
  "MetaLeft": "Meta",
  "MetaRight": "Meta",
  "ShiftLeft": "Shift",
  "ShiftRight": "Shift",
  "Tab": "Tab",
  // FIXME: Japanese/Korean keys
  // 3.1.2. Control Pad Section
  "Delete": "Delete",
  "End": "End",
  "Help": "Help",
  "Home": "Home",
  "Insert": "Insert",
  "PageDown": "PageDown",
  "PageUp": "PageUp",
  // 3.1.3. Arrow Pad Section
  "ArrowDown": "ArrowDown",
  "ArrowLeft": "ArrowLeft",
  "ArrowRight": "ArrowRight",
  "ArrowUp": "ArrowUp",
  // 3.1.4. Numpad Section
  "NumLock": "NumLock",
  "NumpadBackspace": "Backspace",
  "NumpadClear": "Clear",
  // 3.1.5. Function Section
  "Escape": "Escape",
  "F1": "F1",
  "F2": "F2",
  "F3": "F3",
  "F4": "F4",
  "F5": "F5",
  "F6": "F6",
  "F7": "F7",
  "F8": "F8",
  "F9": "F9",
  "F10": "F10",
  "F11": "F11",
  "F12": "F12",
  "F13": "F13",
  "F14": "F14",
  "F15": "F15",
  "F16": "F16",
  "F17": "F17",
  "F18": "F18",
  "F19": "F19",
  "F20": "F20",
  "F21": "F21",
  "F22": "F22",
  "F23": "F23",
  "F24": "F24",
  "F25": "F25",
  "F26": "F26",
  "F27": "F27",
  "F28": "F28",
  "F29": "F29",
  "F30": "F30",
  "F31": "F31",
  "F32": "F32",
  "F33": "F33",
  "F34": "F34",
  "F35": "F35",
  "PrintScreen": "PrintScreen",
  "ScrollLock": "ScrollLock",
  "Pause": "Pause",
  // 3.1.6. Media Keys
  "BrowserBack": "BrowserBack",
  "BrowserFavorites": "BrowserFavorites",
  "BrowserForward": "BrowserForward",
  "BrowserHome": "BrowserHome",
  "BrowserRefresh": "BrowserRefresh",
  "BrowserSearch": "BrowserSearch",
  "BrowserStop": "BrowserStop",
  "Eject": "Eject",
  "LaunchApp1": "LaunchMyComputer",
  "LaunchApp2": "LaunchCalendar",
  "LaunchMail": "LaunchMail",
  "MediaPlayPause": "MediaPlay",
  "MediaStop": "MediaStop",
  "MediaTrackNext": "MediaTrackNext",
  "MediaTrackPrevious": "MediaTrackPrevious",
  "Power": "Power",
  "Sleep": "Sleep",
  "AudioVolumeDown": "AudioVolumeDown",
  "AudioVolumeMute": "AudioVolumeMute",
  "AudioVolumeUp": "AudioVolumeUp",
  "WakeUp": "WakeUp"
};

// core/input/domkeytable.js
var DOMKeyTable = {};
function addStandard(key, standard) {
  if (standard === void 0) throw new Error('Undefined keysym for key "' + key + '"');
  if (key in DOMKeyTable) throw new Error('Duplicate entry for key "' + key + '"');
  DOMKeyTable[key] = [standard, standard, standard, standard];
}
function addLeftRight(key, left, right) {
  if (left === void 0) throw new Error('Undefined keysym for key "' + key + '"');
  if (right === void 0) throw new Error('Undefined keysym for key "' + key + '"');
  if (key in DOMKeyTable) throw new Error('Duplicate entry for key "' + key + '"');
  DOMKeyTable[key] = [left, left, right, left];
}
function addNumpad(key, standard, numpad) {
  if (standard === void 0) throw new Error('Undefined keysym for key "' + key + '"');
  if (numpad === void 0) throw new Error('Undefined keysym for key "' + key + '"');
  if (key in DOMKeyTable) throw new Error('Duplicate entry for key "' + key + '"');
  DOMKeyTable[key] = [standard, standard, standard, numpad];
}
addLeftRight("Alt", keysym_default.XK_Alt_L, keysym_default.XK_Alt_R);
addStandard("AltGraph", keysym_default.XK_ISO_Level3_Shift);
addStandard("CapsLock", keysym_default.XK_Caps_Lock);
addLeftRight("Control", keysym_default.XK_Control_L, keysym_default.XK_Control_R);
addLeftRight("Meta", keysym_default.XK_Super_L, keysym_default.XK_Super_R);
addStandard("NumLock", keysym_default.XK_Num_Lock);
addStandard("ScrollLock", keysym_default.XK_Scroll_Lock);
addLeftRight("Shift", keysym_default.XK_Shift_L, keysym_default.XK_Shift_R);
addNumpad("Enter", keysym_default.XK_Return, keysym_default.XK_KP_Enter);
addStandard("Tab", keysym_default.XK_Tab);
addNumpad(" ", keysym_default.XK_space, keysym_default.XK_KP_Space);
addNumpad("ArrowDown", keysym_default.XK_Down, keysym_default.XK_KP_Down);
addNumpad("ArrowLeft", keysym_default.XK_Left, keysym_default.XK_KP_Left);
addNumpad("ArrowRight", keysym_default.XK_Right, keysym_default.XK_KP_Right);
addNumpad("ArrowUp", keysym_default.XK_Up, keysym_default.XK_KP_Up);
addNumpad("End", keysym_default.XK_End, keysym_default.XK_KP_End);
addNumpad("Home", keysym_default.XK_Home, keysym_default.XK_KP_Home);
addNumpad("PageDown", keysym_default.XK_Next, keysym_default.XK_KP_Next);
addNumpad("PageUp", keysym_default.XK_Prior, keysym_default.XK_KP_Prior);
addStandard("Backspace", keysym_default.XK_BackSpace);
addNumpad("Clear", keysym_default.XK_Clear, keysym_default.XK_KP_Begin);
addStandard("Copy", keysym_default.XF86XK_Copy);
addStandard("Cut", keysym_default.XF86XK_Cut);
addNumpad("Delete", keysym_default.XK_Delete, keysym_default.XK_KP_Delete);
addNumpad("Insert", keysym_default.XK_Insert, keysym_default.XK_KP_Insert);
addStandard("Paste", keysym_default.XF86XK_Paste);
addStandard("Redo", keysym_default.XK_Redo);
addStandard("Undo", keysym_default.XK_Undo);
addStandard("Cancel", keysym_default.XK_Cancel);
addStandard("ContextMenu", keysym_default.XK_Menu);
addStandard("Escape", keysym_default.XK_Escape);
addStandard("Execute", keysym_default.XK_Execute);
addStandard("Find", keysym_default.XK_Find);
addStandard("Help", keysym_default.XK_Help);
addStandard("Pause", keysym_default.XK_Pause);
addStandard("Select", keysym_default.XK_Select);
addStandard("ZoomIn", keysym_default.XF86XK_ZoomIn);
addStandard("ZoomOut", keysym_default.XF86XK_ZoomOut);
addStandard("BrightnessDown", keysym_default.XF86XK_MonBrightnessDown);
addStandard("BrightnessUp", keysym_default.XF86XK_MonBrightnessUp);
addStandard("Eject", keysym_default.XF86XK_Eject);
addStandard("LogOff", keysym_default.XF86XK_LogOff);
addStandard("Power", keysym_default.XF86XK_PowerOff);
addStandard("PowerOff", keysym_default.XF86XK_PowerDown);
addStandard("PrintScreen", keysym_default.XK_Print);
addStandard("Hibernate", keysym_default.XF86XK_Hibernate);
addStandard("Standby", keysym_default.XF86XK_Standby);
addStandard("WakeUp", keysym_default.XF86XK_WakeUp);
addStandard("AllCandidates", keysym_default.XK_MultipleCandidate);
addStandard("Alphanumeric", keysym_default.XK_Eisu_toggle);
addStandard("CodeInput", keysym_default.XK_Codeinput);
addStandard("Compose", keysym_default.XK_Multi_key);
addStandard("Convert", keysym_default.XK_Henkan);
addStandard("GroupFirst", keysym_default.XK_ISO_First_Group);
addStandard("GroupLast", keysym_default.XK_ISO_Last_Group);
addStandard("GroupNext", keysym_default.XK_ISO_Next_Group);
addStandard("GroupPrevious", keysym_default.XK_ISO_Prev_Group);
addStandard("NonConvert", keysym_default.XK_Muhenkan);
addStandard("PreviousCandidate", keysym_default.XK_PreviousCandidate);
addStandard("SingleCandidate", keysym_default.XK_SingleCandidate);
addStandard("HangulMode", keysym_default.XK_Hangul);
addStandard("HanjaMode", keysym_default.XK_Hangul_Hanja);
addStandard("JunjaMode", keysym_default.XK_Hangul_Jeonja);
addStandard("Eisu", keysym_default.XK_Eisu_toggle);
addStandard("Hankaku", keysym_default.XK_Hankaku);
addStandard("Hiragana", keysym_default.XK_Hiragana);
addStandard("HiraganaKatakana", keysym_default.XK_Hiragana_Katakana);
addStandard("KanaMode", keysym_default.XK_Kana_Shift);
addStandard("KanjiMode", keysym_default.XK_Kanji);
addStandard("Katakana", keysym_default.XK_Katakana);
addStandard("Romaji", keysym_default.XK_Romaji);
addStandard("Zenkaku", keysym_default.XK_Zenkaku);
addStandard("ZenkakuHankaku", keysym_default.XK_Zenkaku_Hankaku);
addStandard("F1", keysym_default.XK_F1);
addStandard("F2", keysym_default.XK_F2);
addStandard("F3", keysym_default.XK_F3);
addStandard("F4", keysym_default.XK_F4);
addStandard("F5", keysym_default.XK_F5);
addStandard("F6", keysym_default.XK_F6);
addStandard("F7", keysym_default.XK_F7);
addStandard("F8", keysym_default.XK_F8);
addStandard("F9", keysym_default.XK_F9);
addStandard("F10", keysym_default.XK_F10);
addStandard("F11", keysym_default.XK_F11);
addStandard("F12", keysym_default.XK_F12);
addStandard("F13", keysym_default.XK_F13);
addStandard("F14", keysym_default.XK_F14);
addStandard("F15", keysym_default.XK_F15);
addStandard("F16", keysym_default.XK_F16);
addStandard("F17", keysym_default.XK_F17);
addStandard("F18", keysym_default.XK_F18);
addStandard("F19", keysym_default.XK_F19);
addStandard("F20", keysym_default.XK_F20);
addStandard("F21", keysym_default.XK_F21);
addStandard("F22", keysym_default.XK_F22);
addStandard("F23", keysym_default.XK_F23);
addStandard("F24", keysym_default.XK_F24);
addStandard("F25", keysym_default.XK_F25);
addStandard("F26", keysym_default.XK_F26);
addStandard("F27", keysym_default.XK_F27);
addStandard("F28", keysym_default.XK_F28);
addStandard("F29", keysym_default.XK_F29);
addStandard("F30", keysym_default.XK_F30);
addStandard("F31", keysym_default.XK_F31);
addStandard("F32", keysym_default.XK_F32);
addStandard("F33", keysym_default.XK_F33);
addStandard("F34", keysym_default.XK_F34);
addStandard("F35", keysym_default.XK_F35);
addStandard("Close", keysym_default.XF86XK_Close);
addStandard("MailForward", keysym_default.XF86XK_MailForward);
addStandard("MailReply", keysym_default.XF86XK_Reply);
addStandard("MailSend", keysym_default.XF86XK_Send);
addStandard("MediaFastForward", keysym_default.XF86XK_AudioForward);
addStandard("MediaPause", keysym_default.XF86XK_AudioPause);
addStandard("MediaPlay", keysym_default.XF86XK_AudioPlay);
addStandard("MediaRecord", keysym_default.XF86XK_AudioRecord);
addStandard("MediaRewind", keysym_default.XF86XK_AudioRewind);
addStandard("MediaStop", keysym_default.XF86XK_AudioStop);
addStandard("MediaTrackNext", keysym_default.XF86XK_AudioNext);
addStandard("MediaTrackPrevious", keysym_default.XF86XK_AudioPrev);
addStandard("New", keysym_default.XF86XK_New);
addStandard("Open", keysym_default.XF86XK_Open);
addStandard("Print", keysym_default.XK_Print);
addStandard("Save", keysym_default.XF86XK_Save);
addStandard("SpellCheck", keysym_default.XF86XK_Spell);
addStandard("AudioVolumeDown", keysym_default.XF86XK_AudioLowerVolume);
addStandard("AudioVolumeUp", keysym_default.XF86XK_AudioRaiseVolume);
addStandard("AudioVolumeMute", keysym_default.XF86XK_AudioMute);
addStandard("MicrophoneVolumeMute", keysym_default.XF86XK_AudioMicMute);
addStandard("LaunchApplication1", keysym_default.XF86XK_MyComputer);
addStandard("LaunchApplication2", keysym_default.XF86XK_Calculator);
addStandard("LaunchCalendar", keysym_default.XF86XK_Calendar);
addStandard("LaunchMail", keysym_default.XF86XK_Mail);
addStandard("LaunchMediaPlayer", keysym_default.XF86XK_AudioMedia);
addStandard("LaunchMusicPlayer", keysym_default.XF86XK_Music);
addStandard("LaunchPhone", keysym_default.XF86XK_Phone);
addStandard("LaunchScreenSaver", keysym_default.XF86XK_ScreenSaver);
addStandard("LaunchSpreadsheet", keysym_default.XF86XK_Excel);
addStandard("LaunchWebBrowser", keysym_default.XF86XK_WWW);
addStandard("LaunchWebCam", keysym_default.XF86XK_WebCam);
addStandard("LaunchWordProcessor", keysym_default.XF86XK_Word);
addStandard("BrowserBack", keysym_default.XF86XK_Back);
addStandard("BrowserFavorites", keysym_default.XF86XK_Favorites);
addStandard("BrowserForward", keysym_default.XF86XK_Forward);
addStandard("BrowserHome", keysym_default.XF86XK_HomePage);
addStandard("BrowserRefresh", keysym_default.XF86XK_Refresh);
addStandard("BrowserSearch", keysym_default.XF86XK_Search);
addStandard("BrowserStop", keysym_default.XF86XK_Stop);
addStandard("Dimmer", keysym_default.XF86XK_BrightnessAdjust);
addStandard("MediaAudioTrack", keysym_default.XF86XK_AudioCycleTrack);
addStandard("RandomToggle", keysym_default.XF86XK_AudioRandomPlay);
addStandard("SplitScreenToggle", keysym_default.XF86XK_SplitScreen);
addStandard("Subtitle", keysym_default.XF86XK_Subtitle);
addStandard("VideoModeNext", keysym_default.XF86XK_Next_VMode);
addNumpad("=", keysym_default.XK_equal, keysym_default.XK_KP_Equal);
addNumpad("+", keysym_default.XK_plus, keysym_default.XK_KP_Add);
addNumpad("-", keysym_default.XK_minus, keysym_default.XK_KP_Subtract);
addNumpad("*", keysym_default.XK_asterisk, keysym_default.XK_KP_Multiply);
addNumpad("/", keysym_default.XK_slash, keysym_default.XK_KP_Divide);
addNumpad(".", keysym_default.XK_period, keysym_default.XK_KP_Decimal);
addNumpad(",", keysym_default.XK_comma, keysym_default.XK_KP_Separator);
addNumpad("0", keysym_default.XK_0, keysym_default.XK_KP_0);
addNumpad("1", keysym_default.XK_1, keysym_default.XK_KP_1);
addNumpad("2", keysym_default.XK_2, keysym_default.XK_KP_2);
addNumpad("3", keysym_default.XK_3, keysym_default.XK_KP_3);
addNumpad("4", keysym_default.XK_4, keysym_default.XK_KP_4);
addNumpad("5", keysym_default.XK_5, keysym_default.XK_KP_5);
addNumpad("6", keysym_default.XK_6, keysym_default.XK_KP_6);
addNumpad("7", keysym_default.XK_7, keysym_default.XK_KP_7);
addNumpad("8", keysym_default.XK_8, keysym_default.XK_KP_8);
addNumpad("9", keysym_default.XK_9, keysym_default.XK_KP_9);
var domkeytable_default = DOMKeyTable;

// core/input/util.js
function getKeycode(evt) {
  if (evt.code) {
    switch (evt.code) {
      case "OSLeft":
        return "MetaLeft";
      case "OSRight":
        return "MetaRight";
    }
    return evt.code;
  }
  if (evt.keyCode in vkeys_default) {
    let code = vkeys_default[evt.keyCode];
    if (isMac() && code === "ContextMenu") {
      code = "MetaRight";
    }
    if (evt.location === 2) {
      switch (code) {
        case "ShiftLeft":
          return "ShiftRight";
        case "ControlLeft":
          return "ControlRight";
        case "AltLeft":
          return "AltRight";
      }
    }
    if (evt.location === 3) {
      switch (code) {
        case "Delete":
          return "NumpadDecimal";
        case "Insert":
          return "Numpad0";
        case "End":
          return "Numpad1";
        case "ArrowDown":
          return "Numpad2";
        case "PageDown":
          return "Numpad3";
        case "ArrowLeft":
          return "Numpad4";
        case "ArrowRight":
          return "Numpad6";
        case "Home":
          return "Numpad7";
        case "ArrowUp":
          return "Numpad8";
        case "PageUp":
          return "Numpad9";
        case "Enter":
          return "NumpadEnter";
      }
    }
    return code;
  }
  return "Unidentified";
}
function getKey(evt) {
  if (evt.key !== void 0 && evt.key !== "Unidentified") {
    switch (evt.key) {
      case "OS":
        return "Meta";
      case "LaunchMyComputer":
        return "LaunchApplication1";
      case "LaunchCalculator":
        return "LaunchApplication2";
    }
    switch (evt.key) {
      case "UIKeyInputUpArrow":
        return "ArrowUp";
      case "UIKeyInputDownArrow":
        return "ArrowDown";
      case "UIKeyInputLeftArrow":
        return "ArrowLeft";
      case "UIKeyInputRightArrow":
        return "ArrowRight";
      case "UIKeyInputEscape":
        return "Escape";
    }
    if (evt.key === "\0" && evt.code === "NumpadDecimal") {
      return "Delete";
    }
    return evt.key;
  }
  const code = getKeycode(evt);
  if (code in fixedkeys_default) {
    return fixedkeys_default[code];
  }
  if (evt.charCode) {
    return String.fromCharCode(evt.charCode);
  }
  return "Unidentified";
}
function getKeysym(evt) {
  const key = getKey(evt);
  if (key === "Unidentified") {
    return null;
  }
  if (key in domkeytable_default) {
    let location = evt.location;
    if (key === "Meta" && location === 0) {
      location = 2;
    }
    if (key === "Clear" && location === 3) {
      let code = getKeycode(evt);
      if (code === "NumLock") {
        location = 0;
      }
    }
    if (location === void 0 || location > 3) {
      location = 0;
    }
    if (key === "Meta") {
      let code = getKeycode(evt);
      if (code === "AltLeft") {
        return keysym_default.XK_Meta_L;
      } else if (code === "AltRight") {
        return keysym_default.XK_Meta_R;
      }
    }
    if (key === "Clear") {
      let code = getKeycode(evt);
      if (code === "NumLock") {
        return keysym_default.XK_Num_Lock;
      }
    }
    if (isWindows()) {
      switch (key) {
        case "Zenkaku":
        case "Hankaku":
          return keysym_default.XK_Zenkaku_Hankaku;
        case "Romaji":
        case "KanaMode":
          return keysym_default.XK_Romaji;
      }
    }
    return domkeytable_default[key][location];
  }
  if (key.length !== 1) {
    return null;
  }
  const codepoint = key.charCodeAt();
  if (codepoint) {
    return keysymdef_default.lookup(codepoint);
  }
  return null;
}

// core/input/keyboard.js
var Keyboard = class {
  constructor(target) {
    this._target = target || null;
    this._keyDownList = {};
    this._altGrArmed = false;
    this._eventHandlers = {
      "keyup": this._handleKeyUp.bind(this),
      "keydown": this._handleKeyDown.bind(this),
      "blur": this._allKeysUp.bind(this)
    };
    this.onkeyevent = () => {
    };
  }
  // ===== PRIVATE METHODS =====
  _sendKeyEvent(keysym, code, down, numlock = null, capslock = null) {
    if (down) {
      this._keyDownList[code] = keysym;
    } else {
      if (!(code in this._keyDownList)) {
        return;
      }
      delete this._keyDownList[code];
    }
    Debug("onkeyevent " + (down ? "down" : "up") + ", keysym: " + keysym, ", code: " + code + ", numlock: " + numlock + ", capslock: " + capslock);
    this.onkeyevent(keysym, code, down, numlock, capslock);
  }
  _getKeyCode(e2) {
    const code = getKeycode(e2);
    if (code !== "Unidentified") {
      return code;
    }
    if (e2.keyCode) {
      if (e2.keyCode !== 229) {
        return "Platform" + e2.keyCode;
      }
    }
    if (e2.keyIdentifier) {
      if (e2.keyIdentifier.substr(0, 2) !== "U+") {
        return e2.keyIdentifier;
      }
      const codepoint = parseInt(e2.keyIdentifier.substr(2), 16);
      const char = String.fromCharCode(codepoint).toUpperCase();
      return "Platform" + char.charCodeAt();
    }
    return "Unidentified";
  }
  _handleKeyDown(e2) {
    const code = this._getKeyCode(e2);
    let keysym = getKeysym(e2);
    let numlock = e2.getModifierState("NumLock");
    let capslock = e2.getModifierState("CapsLock");
    if (isMac() || isIOS()) {
      numlock = null;
    }
    if (this._altGrArmed) {
      this._altGrArmed = false;
      clearTimeout(this._altGrTimeout);
      if (code === "AltRight" && e2.timeStamp - this._altGrCtrlTime < 50) {
        keysym = keysym_default.XK_ISO_Level3_Shift;
      } else {
        this._sendKeyEvent(keysym_default.XK_Control_L, "ControlLeft", true, numlock, capslock);
      }
    }
    if (code === "Unidentified") {
      if (keysym) {
        this._sendKeyEvent(keysym, code, true, numlock, capslock);
        this._sendKeyEvent(keysym, code, false, numlock, capslock);
      }
      stopEvent(e2);
      return;
    }
    if (isMac() || isIOS()) {
      switch (keysym) {
        case keysym_default.XK_Super_L:
          keysym = keysym_default.XK_Alt_L;
          break;
        case keysym_default.XK_Super_R:
          keysym = keysym_default.XK_Super_L;
          break;
        case keysym_default.XK_Alt_L:
          keysym = keysym_default.XK_Mode_switch;
          break;
        case keysym_default.XK_Alt_R:
          keysym = keysym_default.XK_ISO_Level3_Shift;
          break;
      }
    }
    if (code in this._keyDownList) {
      keysym = this._keyDownList[code];
    }
    if ((isMac() || isIOS()) && (e2.metaKey && code !== "MetaLeft" && code !== "MetaRight")) {
      this._sendKeyEvent(keysym, code, true, numlock, capslock);
      this._sendKeyEvent(keysym, code, false, numlock, capslock);
      stopEvent(e2);
      return;
    }
    if ((isMac() || isIOS()) && code === "CapsLock") {
      this._sendKeyEvent(keysym_default.XK_Caps_Lock, "CapsLock", true, numlock, capslock);
      this._sendKeyEvent(keysym_default.XK_Caps_Lock, "CapsLock", false, numlock, capslock);
      stopEvent(e2);
      return;
    }
    const jpBadKeys = [
      keysym_default.XK_Zenkaku_Hankaku,
      keysym_default.XK_Eisu_toggle,
      keysym_default.XK_Katakana,
      keysym_default.XK_Hiragana,
      keysym_default.XK_Romaji
    ];
    if (isWindows() && jpBadKeys.includes(keysym)) {
      this._sendKeyEvent(keysym, code, true, numlock, capslock);
      this._sendKeyEvent(keysym, code, false, numlock, capslock);
      stopEvent(e2);
      return;
    }
    stopEvent(e2);
    if (code === "ControlLeft" && isWindows() && !("ControlLeft" in this._keyDownList)) {
      this._altGrArmed = true;
      this._altGrTimeout = setTimeout(this._interruptAltGrSequence.bind(this), 100);
      this._altGrCtrlTime = e2.timeStamp;
      return;
    }
    this._sendKeyEvent(keysym, code, true, numlock, capslock);
  }
  _handleKeyUp(e2) {
    stopEvent(e2);
    const code = this._getKeyCode(e2);
    this._interruptAltGrSequence();
    if ((isMac() || isIOS()) && code === "CapsLock") {
      this._sendKeyEvent(keysym_default.XK_Caps_Lock, "CapsLock", true);
      this._sendKeyEvent(keysym_default.XK_Caps_Lock, "CapsLock", false);
      return;
    }
    this._sendKeyEvent(this._keyDownList[code], code, false);
    if (isWindows() && (code === "ShiftLeft" || code === "ShiftRight")) {
      if ("ShiftRight" in this._keyDownList) {
        this._sendKeyEvent(
          this._keyDownList["ShiftRight"],
          "ShiftRight",
          false
        );
      }
      if ("ShiftLeft" in this._keyDownList) {
        this._sendKeyEvent(
          this._keyDownList["ShiftLeft"],
          "ShiftLeft",
          false
        );
      }
    }
  }
  _interruptAltGrSequence() {
    if (this._altGrArmed) {
      this._altGrArmed = false;
      clearTimeout(this._altGrTimeout);
      this._sendKeyEvent(keysym_default.XK_Control_L, "ControlLeft", true);
    }
  }
  _allKeysUp() {
    Debug(">> Keyboard.allKeysUp");
    this._interruptAltGrSequence();
    for (let code in this._keyDownList) {
      this._sendKeyEvent(this._keyDownList[code], code, false);
    }
    Debug("<< Keyboard.allKeysUp");
  }
  // ===== PUBLIC METHODS =====
  grab() {
    this._target.addEventListener("keydown", this._eventHandlers.keydown);
    this._target.addEventListener("keyup", this._eventHandlers.keyup);
    window.addEventListener("blur", this._eventHandlers.blur);
  }
  ungrab() {
    this._target.removeEventListener("keydown", this._eventHandlers.keydown);
    this._target.removeEventListener("keyup", this._eventHandlers.keyup);
    window.removeEventListener("blur", this._eventHandlers.blur);
    this._allKeysUp();
  }
};

// core/input/gesturehandler.js
var GH_NOGESTURE = 0;
var GH_ONETAP = 1;
var GH_TWOTAP = 2;
var GH_THREETAP = 4;
var GH_DRAG = 8;
var GH_LONGPRESS = 16;
var GH_TWODRAG = 32;
var GH_PINCH = 64;
var GH_INITSTATE = 127;
var GH_MOVE_THRESHOLD = 50;
var GH_ANGLE_THRESHOLD = 90;
var GH_MULTITOUCH_TIMEOUT = 250;
var GH_TAP_TIMEOUT = 1e3;
var GH_LONGPRESS_TIMEOUT = 1e3;
var GH_TWOTOUCH_TIMEOUT = 50;
var GestureHandler = class {
  constructor() {
    this._target = null;
    this._state = GH_INITSTATE;
    this._tracked = [];
    this._ignored = [];
    this._waitingRelease = false;
    this._releaseStart = 0;
    this._longpressTimeoutId = null;
    this._twoTouchTimeoutId = null;
    this._boundEventHandler = this._eventHandler.bind(this);
  }
  attach(target) {
    this.detach();
    this._target = target;
    this._target.addEventListener(
      "touchstart",
      this._boundEventHandler
    );
    this._target.addEventListener(
      "touchmove",
      this._boundEventHandler
    );
    this._target.addEventListener(
      "touchend",
      this._boundEventHandler
    );
    this._target.addEventListener(
      "touchcancel",
      this._boundEventHandler
    );
  }
  detach() {
    if (!this._target) {
      return;
    }
    this._stopLongpressTimeout();
    this._stopTwoTouchTimeout();
    this._target.removeEventListener(
      "touchstart",
      this._boundEventHandler
    );
    this._target.removeEventListener(
      "touchmove",
      this._boundEventHandler
    );
    this._target.removeEventListener(
      "touchend",
      this._boundEventHandler
    );
    this._target.removeEventListener(
      "touchcancel",
      this._boundEventHandler
    );
    this._target = null;
  }
  _eventHandler(e2) {
    let fn;
    e2.stopPropagation();
    e2.preventDefault();
    switch (e2.type) {
      case "touchstart":
        fn = this._touchStart;
        break;
      case "touchmove":
        fn = this._touchMove;
        break;
      case "touchend":
      case "touchcancel":
        fn = this._touchEnd;
        break;
    }
    for (let i = 0; i < e2.changedTouches.length; i++) {
      let touch = e2.changedTouches[i];
      fn.call(this, touch.identifier, touch.clientX, touch.clientY);
    }
  }
  _touchStart(id, x, y) {
    if (this._hasDetectedGesture() || this._state === GH_NOGESTURE) {
      this._ignored.push(id);
      return;
    }
    if (this._tracked.length > 0 && Date.now() - this._tracked[0].started > GH_MULTITOUCH_TIMEOUT) {
      this._state = GH_NOGESTURE;
      this._ignored.push(id);
      return;
    }
    if (this._waitingRelease) {
      this._state = GH_NOGESTURE;
      this._ignored.push(id);
      return;
    }
    this._tracked.push({
      id,
      started: Date.now(),
      active: true,
      firstX: x,
      firstY: y,
      lastX: x,
      lastY: y,
      angle: 0
    });
    switch (this._tracked.length) {
      case 1:
        this._startLongpressTimeout();
        break;
      case 2:
        this._state &= ~(GH_ONETAP | GH_DRAG | GH_LONGPRESS);
        this._stopLongpressTimeout();
        break;
      case 3:
        this._state &= ~(GH_TWOTAP | GH_TWODRAG | GH_PINCH);
        break;
      default:
        this._state = GH_NOGESTURE;
    }
  }
  _touchMove(id, x, y) {
    let touch = this._tracked.find((t) => t.id === id);
    if (touch === void 0) {
      return;
    }
    touch.lastX = x;
    touch.lastY = y;
    let deltaX = x - touch.firstX;
    let deltaY = y - touch.firstY;
    if (touch.firstX !== touch.lastX || touch.firstY !== touch.lastY) {
      touch.angle = Math.atan2(deltaY, deltaX) * 180 / Math.PI;
    }
    if (!this._hasDetectedGesture()) {
      if (Math.hypot(deltaX, deltaY) < GH_MOVE_THRESHOLD) {
        return;
      }
      this._state &= ~(GH_ONETAP | GH_TWOTAP | GH_THREETAP | GH_LONGPRESS);
      this._stopLongpressTimeout();
      if (this._tracked.length !== 1) {
        this._state &= ~GH_DRAG;
      }
      if (this._tracked.length !== 2) {
        this._state &= ~(GH_TWODRAG | GH_PINCH);
      }
      if (this._tracked.length === 2) {
        let prevTouch = this._tracked.find((t) => t.id !== id);
        let prevDeltaMove = Math.hypot(
          prevTouch.firstX - prevTouch.lastX,
          prevTouch.firstY - prevTouch.lastY
        );
        if (prevDeltaMove > GH_MOVE_THRESHOLD) {
          let deltaAngle = Math.abs(touch.angle - prevTouch.angle);
          deltaAngle = Math.abs((deltaAngle + 180) % 360 - 180);
          if (deltaAngle > GH_ANGLE_THRESHOLD) {
            this._state &= ~GH_TWODRAG;
          } else {
            this._state &= ~GH_PINCH;
          }
          if (this._isTwoTouchTimeoutRunning()) {
            this._stopTwoTouchTimeout();
          }
        } else if (!this._isTwoTouchTimeoutRunning()) {
          this._startTwoTouchTimeout();
        }
      }
      if (!this._hasDetectedGesture()) {
        return;
      }
      this._pushEvent("gesturestart");
    }
    this._pushEvent("gesturemove");
  }
  _touchEnd(id, x, y) {
    if (this._ignored.indexOf(id) !== -1) {
      this._ignored.splice(this._ignored.indexOf(id), 1);
      if (this._ignored.length === 0 && this._tracked.length === 0) {
        this._state = GH_INITSTATE;
        this._waitingRelease = false;
      }
      return;
    }
    if (!this._hasDetectedGesture() && this._isTwoTouchTimeoutRunning()) {
      this._stopTwoTouchTimeout();
      this._state = GH_NOGESTURE;
    }
    if (!this._hasDetectedGesture()) {
      this._state &= ~(GH_DRAG | GH_TWODRAG | GH_PINCH);
      this._state &= ~GH_LONGPRESS;
      this._stopLongpressTimeout();
      if (!this._waitingRelease) {
        this._releaseStart = Date.now();
        this._waitingRelease = true;
        switch (this._tracked.length) {
          case 1:
            this._state &= ~(GH_TWOTAP | GH_THREETAP);
            break;
          case 2:
            this._state &= ~(GH_ONETAP | GH_THREETAP);
            break;
        }
      }
    }
    if (this._waitingRelease) {
      if (Date.now() - this._releaseStart > GH_MULTITOUCH_TIMEOUT) {
        this._state = GH_NOGESTURE;
      }
      if (this._tracked.some((t) => Date.now() - t.started > GH_TAP_TIMEOUT)) {
        this._state = GH_NOGESTURE;
      }
      let touch = this._tracked.find((t) => t.id === id);
      touch.active = false;
      if (this._hasDetectedGesture()) {
        this._pushEvent("gesturestart");
      } else {
        if (this._state !== GH_NOGESTURE) {
          return;
        }
      }
    }
    if (this._hasDetectedGesture()) {
      this._pushEvent("gestureend");
    }
    for (let i = 0; i < this._tracked.length; i++) {
      if (this._tracked[i].active) {
        this._ignored.push(this._tracked[i].id);
      }
    }
    this._tracked = [];
    this._state = GH_NOGESTURE;
    if (this._ignored.indexOf(id) !== -1) {
      this._ignored.splice(this._ignored.indexOf(id), 1);
    }
    if (this._ignored.length === 0) {
      this._state = GH_INITSTATE;
      this._waitingRelease = false;
    }
  }
  _hasDetectedGesture() {
    if (this._state === GH_NOGESTURE) {
      return false;
    }
    if (this._state & this._state - 1) {
      return false;
    }
    if (this._state & (GH_ONETAP | GH_TWOTAP | GH_THREETAP)) {
      if (this._tracked.some((t) => t.active)) {
        return false;
      }
    }
    return true;
  }
  _startLongpressTimeout() {
    this._stopLongpressTimeout();
    this._longpressTimeoutId = setTimeout(
      () => this._longpressTimeout(),
      GH_LONGPRESS_TIMEOUT
    );
  }
  _stopLongpressTimeout() {
    clearTimeout(this._longpressTimeoutId);
    this._longpressTimeoutId = null;
  }
  _longpressTimeout() {
    if (this._hasDetectedGesture()) {
      throw new Error("A longpress gesture failed, conflict with a different gesture");
    }
    this._state = GH_LONGPRESS;
    this._pushEvent("gesturestart");
  }
  _startTwoTouchTimeout() {
    this._stopTwoTouchTimeout();
    this._twoTouchTimeoutId = setTimeout(
      () => this._twoTouchTimeout(),
      GH_TWOTOUCH_TIMEOUT
    );
  }
  _stopTwoTouchTimeout() {
    clearTimeout(this._twoTouchTimeoutId);
    this._twoTouchTimeoutId = null;
  }
  _isTwoTouchTimeoutRunning() {
    return this._twoTouchTimeoutId !== null;
  }
  _twoTouchTimeout() {
    if (this._tracked.length === 0) {
      throw new Error("A pinch or two drag gesture failed, no tracked touches");
    }
    let avgM = this._getAverageMovement();
    let avgMoveH = Math.abs(avgM.x);
    let avgMoveV = Math.abs(avgM.y);
    let avgD = this._getAverageDistance();
    let deltaTouchDistance = Math.abs(Math.hypot(avgD.first.x, avgD.first.y) - Math.hypot(avgD.last.x, avgD.last.y));
    if (avgMoveV < deltaTouchDistance && avgMoveH < deltaTouchDistance) {
      this._state = GH_PINCH;
    } else {
      this._state = GH_TWODRAG;
    }
    this._pushEvent("gesturestart");
    this._pushEvent("gesturemove");
  }
  _pushEvent(type) {
    let detail = { type: this._stateToGesture(this._state) };
    let avg = this._getPosition();
    let pos = avg.last;
    if (type === "gesturestart") {
      pos = avg.first;
    }
    switch (this._state) {
      case GH_TWODRAG:
      case GH_PINCH:
        pos = avg.first;
        break;
    }
    detail["clientX"] = pos.x;
    detail["clientY"] = pos.y;
    if (this._state === GH_PINCH) {
      let distance = this._getAverageDistance();
      if (type === "gesturestart") {
        detail["magnitudeX"] = distance.first.x;
        detail["magnitudeY"] = distance.first.y;
      } else {
        detail["magnitudeX"] = distance.last.x;
        detail["magnitudeY"] = distance.last.y;
      }
    } else if (this._state === GH_TWODRAG) {
      if (type === "gesturestart") {
        detail["magnitudeX"] = 0;
        detail["magnitudeY"] = 0;
      } else {
        let movement = this._getAverageMovement();
        detail["magnitudeX"] = movement.x;
        detail["magnitudeY"] = movement.y;
      }
    }
    let gev = new CustomEvent(type, { detail });
    this._target.dispatchEvent(gev);
  }
  _stateToGesture(state) {
    switch (state) {
      case GH_ONETAP:
        return "onetap";
      case GH_TWOTAP:
        return "twotap";
      case GH_THREETAP:
        return "threetap";
      case GH_DRAG:
        return "drag";
      case GH_LONGPRESS:
        return "longpress";
      case GH_TWODRAG:
        return "twodrag";
      case GH_PINCH:
        return "pinch";
    }
    throw new Error("Unknown gesture state: " + state);
  }
  _getPosition() {
    if (this._tracked.length === 0) {
      throw new Error("Failed to get gesture position, no tracked touches");
    }
    let size = this._tracked.length;
    let fx = 0, fy = 0, lx = 0, ly = 0;
    for (let i = 0; i < this._tracked.length; i++) {
      fx += this._tracked[i].firstX;
      fy += this._tracked[i].firstY;
      lx += this._tracked[i].lastX;
      ly += this._tracked[i].lastY;
    }
    return {
      first: {
        x: fx / size,
        y: fy / size
      },
      last: {
        x: lx / size,
        y: ly / size
      }
    };
  }
  _getAverageMovement() {
    if (this._tracked.length === 0) {
      throw new Error("Failed to get gesture movement, no tracked touches");
    }
    let totalH, totalV;
    totalH = totalV = 0;
    let size = this._tracked.length;
    for (let i = 0; i < this._tracked.length; i++) {
      totalH += this._tracked[i].lastX - this._tracked[i].firstX;
      totalV += this._tracked[i].lastY - this._tracked[i].firstY;
    }
    return {
      x: totalH / size,
      y: totalV / size
    };
  }
  _getAverageDistance() {
    if (this._tracked.length === 0) {
      throw new Error("Failed to get gesture distance, no tracked touches");
    }
    let first = this._tracked[0];
    let last = this._tracked[this._tracked.length - 1];
    let fdx = Math.abs(last.firstX - first.firstX);
    let fdy = Math.abs(last.firstY - first.firstY);
    let ldx = Math.abs(last.lastX - first.lastX);
    let ldy = Math.abs(last.lastY - first.lastY);
    return {
      first: { x: fdx, y: fdy },
      last: { x: ldx, y: ldy }
    };
  }
};

// core/util/cursor.js
var useFallback = !supportsCursorURIs || isTouchDevice;
var Cursor = class {
  constructor() {
    this._target = null;
    this._canvas = document.createElement("canvas");
    if (useFallback) {
      this._canvas.style.position = "fixed";
      this._canvas.style.zIndex = "65535";
      this._canvas.style.pointerEvents = "none";
      this._canvas.style.userSelect = "none";
      this._canvas.style.WebkitUserSelect = "none";
      this._canvas.style.visibility = "hidden";
    }
    this._position = { x: 0, y: 0 };
    this._hotSpot = { x: 0, y: 0 };
    this._eventHandlers = {
      "mouseover": this._handleMouseOver.bind(this),
      "mouseleave": this._handleMouseLeave.bind(this),
      "mousemove": this._handleMouseMove.bind(this),
      "mouseup": this._handleMouseUp.bind(this)
    };
  }
  attach(target) {
    if (this._target) {
      this.detach();
    }
    this._target = target;
    if (useFallback) {
      document.body.appendChild(this._canvas);
      const options = { capture: true, passive: true };
      this._target.addEventListener("mouseover", this._eventHandlers.mouseover, options);
      this._target.addEventListener("mouseleave", this._eventHandlers.mouseleave, options);
      this._target.addEventListener("mousemove", this._eventHandlers.mousemove, options);
      this._target.addEventListener("mouseup", this._eventHandlers.mouseup, options);
    }
    this.clear();
  }
  detach() {
    if (!this._target) {
      return;
    }
    if (useFallback) {
      const options = { capture: true, passive: true };
      this._target.removeEventListener("mouseover", this._eventHandlers.mouseover, options);
      this._target.removeEventListener("mouseleave", this._eventHandlers.mouseleave, options);
      this._target.removeEventListener("mousemove", this._eventHandlers.mousemove, options);
      this._target.removeEventListener("mouseup", this._eventHandlers.mouseup, options);
      if (document.contains(this._canvas)) {
        document.body.removeChild(this._canvas);
      }
    }
    this._target = null;
  }
  change(rgba, hotx, hoty, w, h) {
    if (w === 0 || h === 0) {
      this.clear();
      return;
    }
    this._position.x = this._position.x + this._hotSpot.x - hotx;
    this._position.y = this._position.y + this._hotSpot.y - hoty;
    this._hotSpot.x = hotx;
    this._hotSpot.y = hoty;
    let ctx = this._canvas.getContext("2d");
    this._canvas.width = w;
    this._canvas.height = h;
    let img = new ImageData(new Uint8ClampedArray(rgba), w, h);
    ctx.clearRect(0, 0, w, h);
    ctx.putImageData(img, 0, 0);
    if (useFallback) {
      this._updatePosition();
    } else {
      let url = this._canvas.toDataURL();
      this._target.style.cursor = "url(" + url + ")" + hotx + " " + hoty + ", default";
    }
  }
  clear() {
    this._target.style.cursor = "none";
    this._canvas.width = 0;
    this._canvas.height = 0;
    this._position.x = this._position.x + this._hotSpot.x;
    this._position.y = this._position.y + this._hotSpot.y;
    this._hotSpot.x = 0;
    this._hotSpot.y = 0;
  }
  // Mouse events might be emulated, this allows
  // moving the cursor in such cases
  move(clientX, clientY) {
    if (!useFallback) {
      return;
    }
    if (window.visualViewport) {
      this._position.x = clientX + window.visualViewport.offsetLeft;
      this._position.y = clientY + window.visualViewport.offsetTop;
    } else {
      this._position.x = clientX;
      this._position.y = clientY;
    }
    this._updatePosition();
    let target = document.elementFromPoint(clientX, clientY);
    this._updateVisibility(target);
  }
  _handleMouseOver(event) {
    this._handleMouseMove(event);
  }
  _handleMouseLeave(event) {
    this._updateVisibility(event.relatedTarget);
  }
  _handleMouseMove(event) {
    this._updateVisibility(event.target);
    this._position.x = event.clientX - this._hotSpot.x;
    this._position.y = event.clientY - this._hotSpot.y;
    this._updatePosition();
  }
  _handleMouseUp(event) {
    let target = document.elementFromPoint(event.clientX, event.clientY);
    this._updateVisibility(target);
    if (this._captureIsActive()) {
      window.setTimeout(() => {
        if (!this._target) {
          return;
        }
        target = document.elementFromPoint(
          event.clientX,
          event.clientY
        );
        this._updateVisibility(target);
      }, 0);
    }
  }
  _showCursor() {
    if (this._canvas.style.visibility === "hidden") {
      this._canvas.style.visibility = "";
    }
  }
  _hideCursor() {
    if (this._canvas.style.visibility !== "hidden") {
      this._canvas.style.visibility = "hidden";
    }
  }
  // Should we currently display the cursor?
  // (i.e. are we over the target, or a child of the target without a
  // different cursor set)
  _shouldShowCursor(target) {
    if (!target) {
      return false;
    }
    if (target === this._target) {
      return true;
    }
    if (!this._target.contains(target)) {
      return false;
    }
    if (window.getComputedStyle(target).cursor !== "none") {
      return false;
    }
    return true;
  }
  _updateVisibility(target) {
    if (this._captureIsActive()) {
      target = document.captureElement;
    }
    if (this._shouldShowCursor(target)) {
      this._showCursor();
    } else {
      this._hideCursor();
    }
  }
  _updatePosition() {
    this._canvas.style.left = this._position.x + "px";
    this._canvas.style.top = this._position.y + "px";
  }
  _captureIsActive() {
    return document.captureElement && document.documentElement.contains(document.captureElement);
  }
};

// core/websock.js
var MAX_RQ_GROW_SIZE = 40 * 1024 * 1024;
var DataChannel = {
  CONNECTING: "connecting",
  OPEN: "open",
  CLOSING: "closing",
  CLOSED: "closed"
};
var ReadyStates = {
  CONNECTING: [WebSocket.CONNECTING, DataChannel.CONNECTING],
  OPEN: [WebSocket.OPEN, DataChannel.OPEN],
  CLOSING: [WebSocket.CLOSING, DataChannel.CLOSING],
  CLOSED: [WebSocket.CLOSED, DataChannel.CLOSED]
};
var rawChannelProps = [
  "send",
  "close",
  "binaryType",
  "onerror",
  "onmessage",
  "onopen",
  "protocol",
  "readyState"
];
var Websock = class {
  constructor() {
    this._websocket = null;
    this._rQi = 0;
    this._rQlen = 0;
    this._rQbufferSize = 1024 * 1024 * 4;
    this._rQ = null;
    this._sQbufferSize = 1024 * 10;
    this._sQlen = 0;
    this._sQ = null;
    this._eventHandlers = {
      message: () => {
      },
      open: () => {
      },
      close: () => {
      },
      error: () => {
      }
    };
  }
  // Getters and setters
  get readyState() {
    let subState;
    if (this._websocket === null) {
      return "unused";
    }
    subState = this._websocket.readyState;
    if (ReadyStates.CONNECTING.includes(subState)) {
      return "connecting";
    } else if (ReadyStates.OPEN.includes(subState)) {
      return "open";
    } else if (ReadyStates.CLOSING.includes(subState)) {
      return "closing";
    } else if (ReadyStates.CLOSED.includes(subState)) {
      return "closed";
    }
    return "unknown";
  }
  // Receive queue
  rQpeek8() {
    return this._rQ[this._rQi];
  }
  rQskipBytes(bytes) {
    this._rQi += bytes;
  }
  rQshift8() {
    return this._rQshift(1);
  }
  rQshift16() {
    return this._rQshift(2);
  }
  rQshift32() {
    return this._rQshift(4);
  }
  // TODO(directxman12): test performance with these vs a DataView
  _rQshift(bytes) {
    let res = 0;
    for (let byte = bytes - 1; byte >= 0; byte--) {
      res += this._rQ[this._rQi++] << byte * 8;
    }
    return res >>> 0;
  }
  rQlen() {
    return this._rQlen - this._rQi;
  }
  rQshiftStr(len) {
    let str = "";
    for (let i = 0; i < len; i += 4096) {
      let part = this.rQshiftBytes(Math.min(4096, len - i), false);
      str += String.fromCharCode.apply(null, part);
    }
    return str;
  }
  rQshiftBytes(len, copy = true) {
    this._rQi += len;
    if (copy) {
      return this._rQ.slice(this._rQi - len, this._rQi);
    } else {
      return this._rQ.subarray(this._rQi - len, this._rQi);
    }
  }
  rQshiftTo(target, len) {
    target.set(new Uint8Array(this._rQ.buffer, this._rQi, len));
    this._rQi += len;
  }
  rQpeekBytes(len, copy = true) {
    if (copy) {
      return this._rQ.slice(this._rQi, this._rQi + len);
    } else {
      return this._rQ.subarray(this._rQi, this._rQi + len);
    }
  }
  // Check to see if we must wait for 'num' bytes (default to FBU.bytes)
  // to be available in the receive queue. Return true if we need to
  // wait (and possibly print a debug message), otherwise false.
  rQwait(msg, num, goback) {
    if (this._rQlen - this._rQi < num) {
      if (goback) {
        if (this._rQi < goback) {
          throw new Error("rQwait cannot backup " + goback + " bytes");
        }
        this._rQi -= goback;
      }
      return true;
    }
    return false;
  }
  // Send queue
  sQpush8(num) {
    this._sQensureSpace(1);
    this._sQ[this._sQlen++] = num;
  }
  sQpush16(num) {
    this._sQensureSpace(2);
    this._sQ[this._sQlen++] = num >> 8 & 255;
    this._sQ[this._sQlen++] = num >> 0 & 255;
  }
  sQpush32(num) {
    this._sQensureSpace(4);
    this._sQ[this._sQlen++] = num >> 24 & 255;
    this._sQ[this._sQlen++] = num >> 16 & 255;
    this._sQ[this._sQlen++] = num >> 8 & 255;
    this._sQ[this._sQlen++] = num >> 0 & 255;
  }
  sQpushString(str) {
    let bytes = str.split("").map((chr) => chr.charCodeAt(0));
    this.sQpushBytes(new Uint8Array(bytes));
  }
  sQpushBytes(bytes) {
    for (let offset = 0; offset < bytes.length; ) {
      this._sQensureSpace(1);
      let chunkSize = this._sQbufferSize - this._sQlen;
      if (chunkSize > bytes.length - offset) {
        chunkSize = bytes.length - offset;
      }
      this._sQ.set(bytes.subarray(offset, offset + chunkSize), this._sQlen);
      this._sQlen += chunkSize;
      offset += chunkSize;
    }
  }
  flush() {
    if (this._sQlen > 0 && this.readyState === "open") {
      this._websocket.send(new Uint8Array(this._sQ.buffer, 0, this._sQlen));
      this._sQlen = 0;
    }
  }
  _sQensureSpace(bytes) {
    if (this._sQbufferSize - this._sQlen < bytes) {
      this.flush();
    }
  }
  // Event handlers
  off(evt) {
    this._eventHandlers[evt] = () => {
    };
  }
  on(evt, handler) {
    this._eventHandlers[evt] = handler;
  }
  _allocateBuffers() {
    this._rQ = new Uint8Array(this._rQbufferSize);
    this._sQ = new Uint8Array(this._sQbufferSize);
  }
  init() {
    this._allocateBuffers();
    this._rQi = 0;
    this._websocket = null;
  }
  open(uri, protocols) {
    this.attach(new WebSocket(uri, protocols));
  }
  attach(rawChannel) {
    this.init();
    const channelProps = [...Object.keys(rawChannel), ...Object.getOwnPropertyNames(Object.getPrototypeOf(rawChannel))];
    for (let i = 0; i < rawChannelProps.length; i++) {
      const prop = rawChannelProps[i];
      if (channelProps.indexOf(prop) < 0) {
        throw new Error("Raw channel missing property: " + prop);
      }
    }
    this._websocket = rawChannel;
    this._websocket.binaryType = "arraybuffer";
    this._websocket.onmessage = this._recvMessage.bind(this);
    this._websocket.onopen = () => {
      Debug(">> WebSock.onopen");
      if (this._websocket.protocol) {
        Info("Server choose sub-protocol: " + this._websocket.protocol);
      }
      this._eventHandlers.open();
      Debug("<< WebSock.onopen");
    };
    this._websocket.onclose = (e2) => {
      Debug(">> WebSock.onclose");
      this._eventHandlers.close(e2);
      Debug("<< WebSock.onclose");
    };
    this._websocket.onerror = (e2) => {
      Debug(">> WebSock.onerror: " + e2);
      this._eventHandlers.error(e2);
      Debug("<< WebSock.onerror: " + e2);
    };
  }
  close() {
    if (this._websocket) {
      if (this.readyState === "connecting" || this.readyState === "open") {
        Info("Closing WebSocket connection");
        this._websocket.close();
      }
      this._websocket.onmessage = () => {
      };
    }
  }
  // private methods
  // We want to move all the unread data to the start of the queue,
  // e.g. compacting.
  // The function also expands the receive que if needed, and for
  // performance reasons we combine these two actions to avoid
  // unnecessary copying.
  _expandCompactRQ(minFit) {
    const requiredBufferSize = (this._rQlen - this._rQi + minFit) * 8;
    const resizeNeeded = this._rQbufferSize < requiredBufferSize;
    if (resizeNeeded) {
      this._rQbufferSize = Math.max(this._rQbufferSize * 2, requiredBufferSize);
    }
    if (this._rQbufferSize > MAX_RQ_GROW_SIZE) {
      this._rQbufferSize = MAX_RQ_GROW_SIZE;
      if (this._rQbufferSize - (this._rQlen - this._rQi) < minFit) {
        throw new Error("Receive queue buffer exceeded " + MAX_RQ_GROW_SIZE + " bytes, and the new message could not fit");
      }
    }
    if (resizeNeeded) {
      const oldRQbuffer = this._rQ.buffer;
      this._rQ = new Uint8Array(this._rQbufferSize);
      this._rQ.set(new Uint8Array(oldRQbuffer, this._rQi, this._rQlen - this._rQi));
    } else {
      this._rQ.copyWithin(0, this._rQi, this._rQlen);
    }
    this._rQlen = this._rQlen - this._rQi;
    this._rQi = 0;
  }
  // push arraybuffer values onto the end of the receive que
  _recvMessage(e2) {
    if (this._rQlen == this._rQi) {
      this._rQlen = 0;
      this._rQi = 0;
    }
    const u8 = new Uint8Array(e2.data);
    if (u8.length > this._rQbufferSize - this._rQlen) {
      this._expandCompactRQ(u8.length);
    }
    this._rQ.set(u8, this._rQlen);
    this._rQlen += u8.length;
    if (this._rQlen - this._rQi > 0) {
      this._eventHandlers.message();
    } else {
      Debug("Ignoring empty message");
    }
  }
};

// core/input/xtscancodes.js
var xtscancodes_default = {
  "Again": 57349,
  /* html:Again (Again) -> linux:129 (KEY_AGAIN) -> atset1:57349 */
  "AltLeft": 56,
  /* html:AltLeft (AltLeft) -> linux:56 (KEY_LEFTALT) -> atset1:56 */
  "AltRight": 57400,
  /* html:AltRight (AltRight) -> linux:100 (KEY_RIGHTALT) -> atset1:57400 */
  "ArrowDown": 57424,
  /* html:ArrowDown (ArrowDown) -> linux:108 (KEY_DOWN) -> atset1:57424 */
  "ArrowLeft": 57419,
  /* html:ArrowLeft (ArrowLeft) -> linux:105 (KEY_LEFT) -> atset1:57419 */
  "ArrowRight": 57421,
  /* html:ArrowRight (ArrowRight) -> linux:106 (KEY_RIGHT) -> atset1:57421 */
  "ArrowUp": 57416,
  /* html:ArrowUp (ArrowUp) -> linux:103 (KEY_UP) -> atset1:57416 */
  "AudioVolumeDown": 57390,
  /* html:AudioVolumeDown (AudioVolumeDown) -> linux:114 (KEY_VOLUMEDOWN) -> atset1:57390 */
  "AudioVolumeMute": 57376,
  /* html:AudioVolumeMute (AudioVolumeMute) -> linux:113 (KEY_MUTE) -> atset1:57376 */
  "AudioVolumeUp": 57392,
  /* html:AudioVolumeUp (AudioVolumeUp) -> linux:115 (KEY_VOLUMEUP) -> atset1:57392 */
  "Backquote": 41,
  /* html:Backquote (Backquote) -> linux:41 (KEY_GRAVE) -> atset1:41 */
  "Backslash": 43,
  /* html:Backslash (Backslash) -> linux:43 (KEY_BACKSLASH) -> atset1:43 */
  "Backspace": 14,
  /* html:Backspace (Backspace) -> linux:14 (KEY_BACKSPACE) -> atset1:14 */
  "BracketLeft": 26,
  /* html:BracketLeft (BracketLeft) -> linux:26 (KEY_LEFTBRACE) -> atset1:26 */
  "BracketRight": 27,
  /* html:BracketRight (BracketRight) -> linux:27 (KEY_RIGHTBRACE) -> atset1:27 */
  "BrowserBack": 57450,
  /* html:BrowserBack (BrowserBack) -> linux:158 (KEY_BACK) -> atset1:57450 */
  "BrowserFavorites": 57446,
  /* html:BrowserFavorites (BrowserFavorites) -> linux:156 (KEY_BOOKMARKS) -> atset1:57446 */
  "BrowserForward": 57449,
  /* html:BrowserForward (BrowserForward) -> linux:159 (KEY_FORWARD) -> atset1:57449 */
  "BrowserHome": 57394,
  /* html:BrowserHome (BrowserHome) -> linux:172 (KEY_HOMEPAGE) -> atset1:57394 */
  "BrowserRefresh": 57447,
  /* html:BrowserRefresh (BrowserRefresh) -> linux:173 (KEY_REFRESH) -> atset1:57447 */
  "BrowserSearch": 57445,
  /* html:BrowserSearch (BrowserSearch) -> linux:217 (KEY_SEARCH) -> atset1:57445 */
  "BrowserStop": 57448,
  /* html:BrowserStop (BrowserStop) -> linux:128 (KEY_STOP) -> atset1:57448 */
  "CapsLock": 58,
  /* html:CapsLock (CapsLock) -> linux:58 (KEY_CAPSLOCK) -> atset1:58 */
  "Comma": 51,
  /* html:Comma (Comma) -> linux:51 (KEY_COMMA) -> atset1:51 */
  "ContextMenu": 57437,
  /* html:ContextMenu (ContextMenu) -> linux:127 (KEY_COMPOSE) -> atset1:57437 */
  "ControlLeft": 29,
  /* html:ControlLeft (ControlLeft) -> linux:29 (KEY_LEFTCTRL) -> atset1:29 */
  "ControlRight": 57373,
  /* html:ControlRight (ControlRight) -> linux:97 (KEY_RIGHTCTRL) -> atset1:57373 */
  "Convert": 121,
  /* html:Convert (Convert) -> linux:92 (KEY_HENKAN) -> atset1:121 */
  "Copy": 57464,
  /* html:Copy (Copy) -> linux:133 (KEY_COPY) -> atset1:57464 */
  "Cut": 57404,
  /* html:Cut (Cut) -> linux:137 (KEY_CUT) -> atset1:57404 */
  "Delete": 57427,
  /* html:Delete (Delete) -> linux:111 (KEY_DELETE) -> atset1:57427 */
  "Digit0": 11,
  /* html:Digit0 (Digit0) -> linux:11 (KEY_0) -> atset1:11 */
  "Digit1": 2,
  /* html:Digit1 (Digit1) -> linux:2 (KEY_1) -> atset1:2 */
  "Digit2": 3,
  /* html:Digit2 (Digit2) -> linux:3 (KEY_2) -> atset1:3 */
  "Digit3": 4,
  /* html:Digit3 (Digit3) -> linux:4 (KEY_3) -> atset1:4 */
  "Digit4": 5,
  /* html:Digit4 (Digit4) -> linux:5 (KEY_4) -> atset1:5 */
  "Digit5": 6,
  /* html:Digit5 (Digit5) -> linux:6 (KEY_5) -> atset1:6 */
  "Digit6": 7,
  /* html:Digit6 (Digit6) -> linux:7 (KEY_6) -> atset1:7 */
  "Digit7": 8,
  /* html:Digit7 (Digit7) -> linux:8 (KEY_7) -> atset1:8 */
  "Digit8": 9,
  /* html:Digit8 (Digit8) -> linux:9 (KEY_8) -> atset1:9 */
  "Digit9": 10,
  /* html:Digit9 (Digit9) -> linux:10 (KEY_9) -> atset1:10 */
  "Eject": 57469,
  /* html:Eject (Eject) -> linux:162 (KEY_EJECTCLOSECD) -> atset1:57469 */
  "End": 57423,
  /* html:End (End) -> linux:107 (KEY_END) -> atset1:57423 */
  "Enter": 28,
  /* html:Enter (Enter) -> linux:28 (KEY_ENTER) -> atset1:28 */
  "Equal": 13,
  /* html:Equal (Equal) -> linux:13 (KEY_EQUAL) -> atset1:13 */
  "Escape": 1,
  /* html:Escape (Escape) -> linux:1 (KEY_ESC) -> atset1:1 */
  "F1": 59,
  /* html:F1 (F1) -> linux:59 (KEY_F1) -> atset1:59 */
  "F10": 68,
  /* html:F10 (F10) -> linux:68 (KEY_F10) -> atset1:68 */
  "F11": 87,
  /* html:F11 (F11) -> linux:87 (KEY_F11) -> atset1:87 */
  "F12": 88,
  /* html:F12 (F12) -> linux:88 (KEY_F12) -> atset1:88 */
  "F13": 93,
  /* html:F13 (F13) -> linux:183 (KEY_F13) -> atset1:93 */
  "F14": 94,
  /* html:F14 (F14) -> linux:184 (KEY_F14) -> atset1:94 */
  "F15": 95,
  /* html:F15 (F15) -> linux:185 (KEY_F15) -> atset1:95 */
  "F16": 85,
  /* html:F16 (F16) -> linux:186 (KEY_F16) -> atset1:85 */
  "F17": 57347,
  /* html:F17 (F17) -> linux:187 (KEY_F17) -> atset1:57347 */
  "F18": 57463,
  /* html:F18 (F18) -> linux:188 (KEY_F18) -> atset1:57463 */
  "F19": 57348,
  /* html:F19 (F19) -> linux:189 (KEY_F19) -> atset1:57348 */
  "F2": 60,
  /* html:F2 (F2) -> linux:60 (KEY_F2) -> atset1:60 */
  "F20": 90,
  /* html:F20 (F20) -> linux:190 (KEY_F20) -> atset1:90 */
  "F21": 116,
  /* html:F21 (F21) -> linux:191 (KEY_F21) -> atset1:116 */
  "F22": 57465,
  /* html:F22 (F22) -> linux:192 (KEY_F22) -> atset1:57465 */
  "F23": 109,
  /* html:F23 (F23) -> linux:193 (KEY_F23) -> atset1:109 */
  "F24": 111,
  /* html:F24 (F24) -> linux:194 (KEY_F24) -> atset1:111 */
  "F3": 61,
  /* html:F3 (F3) -> linux:61 (KEY_F3) -> atset1:61 */
  "F4": 62,
  /* html:F4 (F4) -> linux:62 (KEY_F4) -> atset1:62 */
  "F5": 63,
  /* html:F5 (F5) -> linux:63 (KEY_F5) -> atset1:63 */
  "F6": 64,
  /* html:F6 (F6) -> linux:64 (KEY_F6) -> atset1:64 */
  "F7": 65,
  /* html:F7 (F7) -> linux:65 (KEY_F7) -> atset1:65 */
  "F8": 66,
  /* html:F8 (F8) -> linux:66 (KEY_F8) -> atset1:66 */
  "F9": 67,
  /* html:F9 (F9) -> linux:67 (KEY_F9) -> atset1:67 */
  "Find": 57409,
  /* html:Find (Find) -> linux:136 (KEY_FIND) -> atset1:57409 */
  "Help": 57461,
  /* html:Help (Help) -> linux:138 (KEY_HELP) -> atset1:57461 */
  "Hiragana": 119,
  /* html:Hiragana (Lang4) -> linux:91 (KEY_HIRAGANA) -> atset1:119 */
  "Home": 57415,
  /* html:Home (Home) -> linux:102 (KEY_HOME) -> atset1:57415 */
  "Insert": 57426,
  /* html:Insert (Insert) -> linux:110 (KEY_INSERT) -> atset1:57426 */
  "IntlBackslash": 86,
  /* html:IntlBackslash (IntlBackslash) -> linux:86 (KEY_102ND) -> atset1:86 */
  "IntlRo": 115,
  /* html:IntlRo (IntlRo) -> linux:89 (KEY_RO) -> atset1:115 */
  "IntlYen": 125,
  /* html:IntlYen (IntlYen) -> linux:124 (KEY_YEN) -> atset1:125 */
  "KanaMode": 112,
  /* html:KanaMode (KanaMode) -> linux:93 (KEY_KATAKANAHIRAGANA) -> atset1:112 */
  "Katakana": 120,
  /* html:Katakana (Lang3) -> linux:90 (KEY_KATAKANA) -> atset1:120 */
  "KeyA": 30,
  /* html:KeyA (KeyA) -> linux:30 (KEY_A) -> atset1:30 */
  "KeyB": 48,
  /* html:KeyB (KeyB) -> linux:48 (KEY_B) -> atset1:48 */
  "KeyC": 46,
  /* html:KeyC (KeyC) -> linux:46 (KEY_C) -> atset1:46 */
  "KeyD": 32,
  /* html:KeyD (KeyD) -> linux:32 (KEY_D) -> atset1:32 */
  "KeyE": 18,
  /* html:KeyE (KeyE) -> linux:18 (KEY_E) -> atset1:18 */
  "KeyF": 33,
  /* html:KeyF (KeyF) -> linux:33 (KEY_F) -> atset1:33 */
  "KeyG": 34,
  /* html:KeyG (KeyG) -> linux:34 (KEY_G) -> atset1:34 */
  "KeyH": 35,
  /* html:KeyH (KeyH) -> linux:35 (KEY_H) -> atset1:35 */
  "KeyI": 23,
  /* html:KeyI (KeyI) -> linux:23 (KEY_I) -> atset1:23 */
  "KeyJ": 36,
  /* html:KeyJ (KeyJ) -> linux:36 (KEY_J) -> atset1:36 */
  "KeyK": 37,
  /* html:KeyK (KeyK) -> linux:37 (KEY_K) -> atset1:37 */
  "KeyL": 38,
  /* html:KeyL (KeyL) -> linux:38 (KEY_L) -> atset1:38 */
  "KeyM": 50,
  /* html:KeyM (KeyM) -> linux:50 (KEY_M) -> atset1:50 */
  "KeyN": 49,
  /* html:KeyN (KeyN) -> linux:49 (KEY_N) -> atset1:49 */
  "KeyO": 24,
  /* html:KeyO (KeyO) -> linux:24 (KEY_O) -> atset1:24 */
  "KeyP": 25,
  /* html:KeyP (KeyP) -> linux:25 (KEY_P) -> atset1:25 */
  "KeyQ": 16,
  /* html:KeyQ (KeyQ) -> linux:16 (KEY_Q) -> atset1:16 */
  "KeyR": 19,
  /* html:KeyR (KeyR) -> linux:19 (KEY_R) -> atset1:19 */
  "KeyS": 31,
  /* html:KeyS (KeyS) -> linux:31 (KEY_S) -> atset1:31 */
  "KeyT": 20,
  /* html:KeyT (KeyT) -> linux:20 (KEY_T) -> atset1:20 */
  "KeyU": 22,
  /* html:KeyU (KeyU) -> linux:22 (KEY_U) -> atset1:22 */
  "KeyV": 47,
  /* html:KeyV (KeyV) -> linux:47 (KEY_V) -> atset1:47 */
  "KeyW": 17,
  /* html:KeyW (KeyW) -> linux:17 (KEY_W) -> atset1:17 */
  "KeyX": 45,
  /* html:KeyX (KeyX) -> linux:45 (KEY_X) -> atset1:45 */
  "KeyY": 21,
  /* html:KeyY (KeyY) -> linux:21 (KEY_Y) -> atset1:21 */
  "KeyZ": 44,
  /* html:KeyZ (KeyZ) -> linux:44 (KEY_Z) -> atset1:44 */
  "Lang1": 114,
  /* html:Lang1 (Lang1) -> linux:122 (KEY_HANGEUL) -> atset1:114 */
  "Lang2": 113,
  /* html:Lang2 (Lang2) -> linux:123 (KEY_HANJA) -> atset1:113 */
  "Lang3": 120,
  /* html:Lang3 (Lang3) -> linux:90 (KEY_KATAKANA) -> atset1:120 */
  "Lang4": 119,
  /* html:Lang4 (Lang4) -> linux:91 (KEY_HIRAGANA) -> atset1:119 */
  "Lang5": 118,
  /* html:Lang5 (Lang5) -> linux:85 (KEY_ZENKAKUHANKAKU) -> atset1:118 */
  "LaunchApp1": 57451,
  /* html:LaunchApp1 (LaunchApp1) -> linux:157 (KEY_COMPUTER) -> atset1:57451 */
  "LaunchApp2": 57377,
  /* html:LaunchApp2 (LaunchApp2) -> linux:140 (KEY_CALC) -> atset1:57377 */
  "LaunchMail": 57452,
  /* html:LaunchMail (LaunchMail) -> linux:155 (KEY_MAIL) -> atset1:57452 */
  "MediaPlayPause": 57378,
  /* html:MediaPlayPause (MediaPlayPause) -> linux:164 (KEY_PLAYPAUSE) -> atset1:57378 */
  "MediaSelect": 57453,
  /* html:MediaSelect (MediaSelect) -> linux:226 (KEY_MEDIA) -> atset1:57453 */
  "MediaStop": 57380,
  /* html:MediaStop (MediaStop) -> linux:166 (KEY_STOPCD) -> atset1:57380 */
  "MediaTrackNext": 57369,
  /* html:MediaTrackNext (MediaTrackNext) -> linux:163 (KEY_NEXTSONG) -> atset1:57369 */
  "MediaTrackPrevious": 57360,
  /* html:MediaTrackPrevious (MediaTrackPrevious) -> linux:165 (KEY_PREVIOUSSONG) -> atset1:57360 */
  "MetaLeft": 57435,
  /* html:MetaLeft (MetaLeft) -> linux:125 (KEY_LEFTMETA) -> atset1:57435 */
  "MetaRight": 57436,
  /* html:MetaRight (MetaRight) -> linux:126 (KEY_RIGHTMETA) -> atset1:57436 */
  "Minus": 12,
  /* html:Minus (Minus) -> linux:12 (KEY_MINUS) -> atset1:12 */
  "NonConvert": 123,
  /* html:NonConvert (NonConvert) -> linux:94 (KEY_MUHENKAN) -> atset1:123 */
  "NumLock": 69,
  /* html:NumLock (NumLock) -> linux:69 (KEY_NUMLOCK) -> atset1:69 */
  "Numpad0": 82,
  /* html:Numpad0 (Numpad0) -> linux:82 (KEY_KP0) -> atset1:82 */
  "Numpad1": 79,
  /* html:Numpad1 (Numpad1) -> linux:79 (KEY_KP1) -> atset1:79 */
  "Numpad2": 80,
  /* html:Numpad2 (Numpad2) -> linux:80 (KEY_KP2) -> atset1:80 */
  "Numpad3": 81,
  /* html:Numpad3 (Numpad3) -> linux:81 (KEY_KP3) -> atset1:81 */
  "Numpad4": 75,
  /* html:Numpad4 (Numpad4) -> linux:75 (KEY_KP4) -> atset1:75 */
  "Numpad5": 76,
  /* html:Numpad5 (Numpad5) -> linux:76 (KEY_KP5) -> atset1:76 */
  "Numpad6": 77,
  /* html:Numpad6 (Numpad6) -> linux:77 (KEY_KP6) -> atset1:77 */
  "Numpad7": 71,
  /* html:Numpad7 (Numpad7) -> linux:71 (KEY_KP7) -> atset1:71 */
  "Numpad8": 72,
  /* html:Numpad8 (Numpad8) -> linux:72 (KEY_KP8) -> atset1:72 */
  "Numpad9": 73,
  /* html:Numpad9 (Numpad9) -> linux:73 (KEY_KP9) -> atset1:73 */
  "NumpadAdd": 78,
  /* html:NumpadAdd (NumpadAdd) -> linux:78 (KEY_KPPLUS) -> atset1:78 */
  "NumpadComma": 126,
  /* html:NumpadComma (NumpadComma) -> linux:121 (KEY_KPCOMMA) -> atset1:126 */
  "NumpadDecimal": 83,
  /* html:NumpadDecimal (NumpadDecimal) -> linux:83 (KEY_KPDOT) -> atset1:83 */
  "NumpadDivide": 57397,
  /* html:NumpadDivide (NumpadDivide) -> linux:98 (KEY_KPSLASH) -> atset1:57397 */
  "NumpadEnter": 57372,
  /* html:NumpadEnter (NumpadEnter) -> linux:96 (KEY_KPENTER) -> atset1:57372 */
  "NumpadEqual": 89,
  /* html:NumpadEqual (NumpadEqual) -> linux:117 (KEY_KPEQUAL) -> atset1:89 */
  "NumpadMultiply": 55,
  /* html:NumpadMultiply (NumpadMultiply) -> linux:55 (KEY_KPASTERISK) -> atset1:55 */
  "NumpadParenLeft": 57462,
  /* html:NumpadParenLeft (NumpadParenLeft) -> linux:179 (KEY_KPLEFTPAREN) -> atset1:57462 */
  "NumpadParenRight": 57467,
  /* html:NumpadParenRight (NumpadParenRight) -> linux:180 (KEY_KPRIGHTPAREN) -> atset1:57467 */
  "NumpadSubtract": 74,
  /* html:NumpadSubtract (NumpadSubtract) -> linux:74 (KEY_KPMINUS) -> atset1:74 */
  "Open": 100,
  /* html:Open (Open) -> linux:134 (KEY_OPEN) -> atset1:100 */
  "PageDown": 57425,
  /* html:PageDown (PageDown) -> linux:109 (KEY_PAGEDOWN) -> atset1:57425 */
  "PageUp": 57417,
  /* html:PageUp (PageUp) -> linux:104 (KEY_PAGEUP) -> atset1:57417 */
  "Paste": 101,
  /* html:Paste (Paste) -> linux:135 (KEY_PASTE) -> atset1:101 */
  "Pause": 57414,
  /* html:Pause (Pause) -> linux:119 (KEY_PAUSE) -> atset1:57414 */
  "Period": 52,
  /* html:Period (Period) -> linux:52 (KEY_DOT) -> atset1:52 */
  "Power": 57438,
  /* html:Power (Power) -> linux:116 (KEY_POWER) -> atset1:57438 */
  "PrintScreen": 84,
  /* html:PrintScreen (PrintScreen) -> linux:99 (KEY_SYSRQ) -> atset1:84 */
  "Props": 57350,
  /* html:Props (Props) -> linux:130 (KEY_PROPS) -> atset1:57350 */
  "Quote": 40,
  /* html:Quote (Quote) -> linux:40 (KEY_APOSTROPHE) -> atset1:40 */
  "ScrollLock": 70,
  /* html:ScrollLock (ScrollLock) -> linux:70 (KEY_SCROLLLOCK) -> atset1:70 */
  "Semicolon": 39,
  /* html:Semicolon (Semicolon) -> linux:39 (KEY_SEMICOLON) -> atset1:39 */
  "ShiftLeft": 42,
  /* html:ShiftLeft (ShiftLeft) -> linux:42 (KEY_LEFTSHIFT) -> atset1:42 */
  "ShiftRight": 54,
  /* html:ShiftRight (ShiftRight) -> linux:54 (KEY_RIGHTSHIFT) -> atset1:54 */
  "Slash": 53,
  /* html:Slash (Slash) -> linux:53 (KEY_SLASH) -> atset1:53 */
  "Sleep": 57439,
  /* html:Sleep (Sleep) -> linux:142 (KEY_SLEEP) -> atset1:57439 */
  "Space": 57,
  /* html:Space (Space) -> linux:57 (KEY_SPACE) -> atset1:57 */
  "Suspend": 57381,
  /* html:Suspend (Suspend) -> linux:205 (KEY_SUSPEND) -> atset1:57381 */
  "Tab": 15,
  /* html:Tab (Tab) -> linux:15 (KEY_TAB) -> atset1:15 */
  "Undo": 57351,
  /* html:Undo (Undo) -> linux:131 (KEY_UNDO) -> atset1:57351 */
  "WakeUp": 57443
  /* html:WakeUp (WakeUp) -> linux:143 (KEY_WAKEUP) -> atset1:57443 */
};

// core/encodings.js
var encodings = {
  encodingRaw: 0,
  encodingCopyRect: 1,
  encodingRRE: 2,
  encodingHextile: 5,
  encodingZlib: 6,
  encodingTight: 7,
  encodingZRLE: 16,
  encodingTightPNG: -260,
  encodingJPEG: 21,
  encodingH264: 50,
  pseudoEncodingQualityLevel9: -23,
  pseudoEncodingQualityLevel0: -32,
  pseudoEncodingDesktopSize: -223,
  pseudoEncodingLastRect: -224,
  pseudoEncodingCursor: -239,
  pseudoEncodingQEMUExtendedKeyEvent: -258,
  pseudoEncodingQEMULedEvent: -261,
  pseudoEncodingDesktopName: -307,
  pseudoEncodingExtendedDesktopSize: -308,
  pseudoEncodingXvp: -309,
  pseudoEncodingFence: -312,
  pseudoEncodingContinuousUpdates: -313,
  pseudoEncodingExtendedMouseButtons: -316,
  pseudoEncodingCompressLevel9: -247,
  pseudoEncodingCompressLevel0: -256,
  pseudoEncodingVMwareCursor: 1464686180,
  pseudoEncodingExtendedClipboard: 3231835598
};

// core/crypto/aes.js
var AESECBCipher = class _AESECBCipher {
  constructor() {
    this._key = null;
  }
  get algorithm() {
    return { name: "AES-ECB" };
  }
  static async importKey(key, _algorithm, extractable, keyUsages) {
    const cipher = new _AESECBCipher();
    await cipher._importKey(key, extractable, keyUsages);
    return cipher;
  }
  async _importKey(key, extractable, keyUsages) {
    this._key = await window.crypto.subtle.importKey(
      "raw",
      key,
      { name: "AES-CBC" },
      extractable,
      keyUsages
    );
  }
  async encrypt(_algorithm, plaintext) {
    const x = new Uint8Array(plaintext);
    if (x.length % 16 !== 0 || this._key === null) {
      return null;
    }
    const n = x.length / 16;
    for (let i = 0; i < n; i++) {
      const y = new Uint8Array(await window.crypto.subtle.encrypt({
        name: "AES-CBC",
        iv: new Uint8Array(16)
      }, this._key, x.slice(i * 16, i * 16 + 16))).slice(0, 16);
      x.set(y, i * 16);
    }
    return x;
  }
};
var AESEAXCipher = class _AESEAXCipher {
  constructor() {
    this._rawKey = null;
    this._ctrKey = null;
    this._cbcKey = null;
    this._zeroBlock = new Uint8Array(16);
    this._prefixBlock0 = this._zeroBlock;
    this._prefixBlock1 = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
    this._prefixBlock2 = new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]);
  }
  get algorithm() {
    return { name: "AES-EAX" };
  }
  async _encryptBlock(block) {
    const encrypted = await window.crypto.subtle.encrypt({
      name: "AES-CBC",
      iv: this._zeroBlock
    }, this._cbcKey, block);
    return new Uint8Array(encrypted).slice(0, 16);
  }
  async _initCMAC() {
    const k1 = await this._encryptBlock(this._zeroBlock);
    const k2 = new Uint8Array(16);
    const v = k1[0] >>> 6;
    for (let i = 0; i < 15; i++) {
      k2[i] = k1[i + 1] >> 6 | k1[i] << 2;
      k1[i] = k1[i + 1] >> 7 | k1[i] << 1;
    }
    const lut = [0, 135, 14, 137];
    k2[14] ^= v >>> 1;
    k2[15] = k1[15] << 2 ^ lut[v];
    k1[15] = k1[15] << 1 ^ lut[v >> 1];
    this._k1 = k1;
    this._k2 = k2;
  }
  async _encryptCTR(data, counter) {
    const encrypted = await window.crypto.subtle.encrypt({
      name: "AES-CTR",
      counter,
      length: 128
    }, this._ctrKey, data);
    return new Uint8Array(encrypted);
  }
  async _decryptCTR(data, counter) {
    const decrypted = await window.crypto.subtle.decrypt({
      name: "AES-CTR",
      counter,
      length: 128
    }, this._ctrKey, data);
    return new Uint8Array(decrypted);
  }
  async _computeCMAC(data, prefixBlock) {
    if (prefixBlock.length !== 16) {
      return null;
    }
    const n = Math.floor(data.length / 16);
    const m = Math.ceil(data.length / 16);
    const r = data.length - n * 16;
    const cbcData = new Uint8Array((m + 1) * 16);
    cbcData.set(prefixBlock);
    cbcData.set(data, 16);
    if (r === 0) {
      for (let i = 0; i < 16; i++) {
        cbcData[n * 16 + i] ^= this._k1[i];
      }
    } else {
      cbcData[(n + 1) * 16 + r] = 128;
      for (let i = 0; i < 16; i++) {
        cbcData[(n + 1) * 16 + i] ^= this._k2[i];
      }
    }
    let cbcEncrypted = await window.crypto.subtle.encrypt({
      name: "AES-CBC",
      iv: this._zeroBlock
    }, this._cbcKey, cbcData);
    cbcEncrypted = new Uint8Array(cbcEncrypted);
    const mac = cbcEncrypted.slice(cbcEncrypted.length - 32, cbcEncrypted.length - 16);
    return mac;
  }
  static async importKey(key, _algorithm, _extractable, _keyUsages) {
    const cipher = new _AESEAXCipher();
    await cipher._importKey(key);
    return cipher;
  }
  async _importKey(key) {
    this._rawKey = key;
    this._ctrKey = await window.crypto.subtle.importKey(
      "raw",
      key,
      { name: "AES-CTR" },
      false,
      ["encrypt", "decrypt"]
    );
    this._cbcKey = await window.crypto.subtle.importKey(
      "raw",
      key,
      { name: "AES-CBC" },
      false,
      ["encrypt"]
    );
    await this._initCMAC();
  }
  async encrypt(algorithm, message) {
    const ad = algorithm.additionalData;
    const nonce = algorithm.iv;
    const nCMAC = await this._computeCMAC(nonce, this._prefixBlock0);
    const encrypted = await this._encryptCTR(message, nCMAC);
    const adCMAC = await this._computeCMAC(ad, this._prefixBlock1);
    const mac = await this._computeCMAC(encrypted, this._prefixBlock2);
    for (let i = 0; i < 16; i++) {
      mac[i] ^= nCMAC[i] ^ adCMAC[i];
    }
    const res = new Uint8Array(16 + encrypted.length);
    res.set(encrypted);
    res.set(mac, encrypted.length);
    return res;
  }
  async decrypt(algorithm, data) {
    const encrypted = data.slice(0, data.length - 16);
    const ad = algorithm.additionalData;
    const nonce = algorithm.iv;
    const mac = data.slice(data.length - 16);
    const nCMAC = await this._computeCMAC(nonce, this._prefixBlock0);
    const adCMAC = await this._computeCMAC(ad, this._prefixBlock1);
    const computedMac = await this._computeCMAC(encrypted, this._prefixBlock2);
    for (let i = 0; i < 16; i++) {
      computedMac[i] ^= nCMAC[i] ^ adCMAC[i];
    }
    if (computedMac.length !== mac.length) {
      return null;
    }
    for (let i = 0; i < mac.length; i++) {
      if (computedMac[i] !== mac[i]) {
        return null;
      }
    }
    const res = await this._decryptCTR(encrypted, nCMAC);
    return res;
  }
};

// core/crypto/des.js
var PC2 = [
  13,
  16,
  10,
  23,
  0,
  4,
  2,
  27,
  14,
  5,
  20,
  9,
  22,
  18,
  11,
  3,
  25,
  7,
  15,
  6,
  26,
  19,
  12,
  1,
  40,
  51,
  30,
  36,
  46,
  54,
  29,
  39,
  50,
  44,
  32,
  47,
  43,
  48,
  38,
  55,
  33,
  52,
  45,
  41,
  49,
  35,
  28,
  31
];
var totrot = [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28];
var z = 0;
var a;
var b;
var c;
var d;
var e;
var f;
a = 1 << 16;
b = 1 << 24;
c = a | b;
d = 1 << 2;
e = 1 << 10;
f = d | e;
var SP1 = [
  c | e,
  z | z,
  a | z,
  c | f,
  c | d,
  a | f,
  z | d,
  a | z,
  z | e,
  c | e,
  c | f,
  z | e,
  b | f,
  c | d,
  b | z,
  z | d,
  z | f,
  b | e,
  b | e,
  a | e,
  a | e,
  c | z,
  c | z,
  b | f,
  a | d,
  b | d,
  b | d,
  a | d,
  z | z,
  z | f,
  a | f,
  b | z,
  a | z,
  c | f,
  z | d,
  c | z,
  c | e,
  b | z,
  b | z,
  z | e,
  c | d,
  a | z,
  a | e,
  b | d,
  z | e,
  z | d,
  b | f,
  a | f,
  c | f,
  a | d,
  c | z,
  b | f,
  b | d,
  z | f,
  a | f,
  c | e,
  z | f,
  b | e,
  b | e,
  z | z,
  a | d,
  a | e,
  z | z,
  c | d
];
a = 1 << 20;
b = 1 << 31;
c = a | b;
d = 1 << 5;
e = 1 << 15;
f = d | e;
var SP2 = [
  c | f,
  b | e,
  z | e,
  a | f,
  a | z,
  z | d,
  c | d,
  b | f,
  b | d,
  c | f,
  c | e,
  b | z,
  b | e,
  a | z,
  z | d,
  c | d,
  a | e,
  a | d,
  b | f,
  z | z,
  b | z,
  z | e,
  a | f,
  c | z,
  a | d,
  b | d,
  z | z,
  a | e,
  z | f,
  c | e,
  c | z,
  z | f,
  z | z,
  a | f,
  c | d,
  a | z,
  b | f,
  c | z,
  c | e,
  z | e,
  c | z,
  b | e,
  z | d,
  c | f,
  a | f,
  z | d,
  z | e,
  b | z,
  z | f,
  c | e,
  a | z,
  b | d,
  a | d,
  b | f,
  b | d,
  a | d,
  a | e,
  z | z,
  b | e,
  z | f,
  b | z,
  c | d,
  c | f,
  a | e
];
a = 1 << 17;
b = 1 << 27;
c = a | b;
d = 1 << 3;
e = 1 << 9;
f = d | e;
var SP3 = [
  z | f,
  c | e,
  z | z,
  c | d,
  b | e,
  z | z,
  a | f,
  b | e,
  a | d,
  b | d,
  b | d,
  a | z,
  c | f,
  a | d,
  c | z,
  z | f,
  b | z,
  z | d,
  c | e,
  z | e,
  a | e,
  c | z,
  c | d,
  a | f,
  b | f,
  a | e,
  a | z,
  b | f,
  z | d,
  c | f,
  z | e,
  b | z,
  c | e,
  b | z,
  a | d,
  z | f,
  a | z,
  c | e,
  b | e,
  z | z,
  z | e,
  a | d,
  c | f,
  b | e,
  b | d,
  z | e,
  z | z,
  c | d,
  b | f,
  a | z,
  b | z,
  c | f,
  z | d,
  a | f,
  a | e,
  b | d,
  c | z,
  b | f,
  z | f,
  c | z,
  a | f,
  z | d,
  c | d,
  a | e
];
a = 1 << 13;
b = 1 << 23;
c = a | b;
d = 1 << 0;
e = 1 << 7;
f = d | e;
var SP4 = [
  c | d,
  a | f,
  a | f,
  z | e,
  c | e,
  b | f,
  b | d,
  a | d,
  z | z,
  c | z,
  c | z,
  c | f,
  z | f,
  z | z,
  b | e,
  b | d,
  z | d,
  a | z,
  b | z,
  c | d,
  z | e,
  b | z,
  a | d,
  a | e,
  b | f,
  z | d,
  a | e,
  b | e,
  a | z,
  c | e,
  c | f,
  z | f,
  b | e,
  b | d,
  c | z,
  c | f,
  z | f,
  z | z,
  z | z,
  c | z,
  a | e,
  b | e,
  b | f,
  z | d,
  c | d,
  a | f,
  a | f,
  z | e,
  c | f,
  z | f,
  z | d,
  a | z,
  b | d,
  a | d,
  c | e,
  b | f,
  a | d,
  a | e,
  b | z,
  c | d,
  z | e,
  b | z,
  a | z,
  c | e
];
a = 1 << 25;
b = 1 << 30;
c = a | b;
d = 1 << 8;
e = 1 << 19;
f = d | e;
var SP5 = [
  z | d,
  a | f,
  a | e,
  c | d,
  z | e,
  z | d,
  b | z,
  a | e,
  b | f,
  z | e,
  a | d,
  b | f,
  c | d,
  c | e,
  z | f,
  b | z,
  a | z,
  b | e,
  b | e,
  z | z,
  b | d,
  c | f,
  c | f,
  a | d,
  c | e,
  b | d,
  z | z,
  c | z,
  a | f,
  a | z,
  c | z,
  z | f,
  z | e,
  c | d,
  z | d,
  a | z,
  b | z,
  a | e,
  c | d,
  b | f,
  a | d,
  b | z,
  c | e,
  a | f,
  b | f,
  z | d,
  a | z,
  c | e,
  c | f,
  z | f,
  c | z,
  c | f,
  a | e,
  z | z,
  b | e,
  c | z,
  z | f,
  a | d,
  b | d,
  z | e,
  z | z,
  b | e,
  a | f,
  b | d
];
a = 1 << 22;
b = 1 << 29;
c = a | b;
d = 1 << 4;
e = 1 << 14;
f = d | e;
var SP6 = [
  b | d,
  c | z,
  z | e,
  c | f,
  c | z,
  z | d,
  c | f,
  a | z,
  b | e,
  a | f,
  a | z,
  b | d,
  a | d,
  b | e,
  b | z,
  z | f,
  z | z,
  a | d,
  b | f,
  z | e,
  a | e,
  b | f,
  z | d,
  c | d,
  c | d,
  z | z,
  a | f,
  c | e,
  z | f,
  a | e,
  c | e,
  b | z,
  b | e,
  z | d,
  c | d,
  a | e,
  c | f,
  a | z,
  z | f,
  b | d,
  a | z,
  b | e,
  b | z,
  z | f,
  b | d,
  c | f,
  a | e,
  c | z,
  a | f,
  c | e,
  z | z,
  c | d,
  z | d,
  z | e,
  c | z,
  a | f,
  z | e,
  a | d,
  b | f,
  z | z,
  c | e,
  b | z,
  a | d,
  b | f
];
a = 1 << 21;
b = 1 << 26;
c = a | b;
d = 1 << 1;
e = 1 << 11;
f = d | e;
var SP7 = [
  a | z,
  c | d,
  b | f,
  z | z,
  z | e,
  b | f,
  a | f,
  c | e,
  c | f,
  a | z,
  z | z,
  b | d,
  z | d,
  b | z,
  c | d,
  z | f,
  b | e,
  a | f,
  a | d,
  b | e,
  b | d,
  c | z,
  c | e,
  a | d,
  c | z,
  z | e,
  z | f,
  c | f,
  a | e,
  z | d,
  b | z,
  a | e,
  b | z,
  a | e,
  a | z,
  b | f,
  b | f,
  c | d,
  c | d,
  z | d,
  a | d,
  b | z,
  b | e,
  a | z,
  c | e,
  z | f,
  a | f,
  c | e,
  z | f,
  b | d,
  c | f,
  c | z,
  a | e,
  z | z,
  z | d,
  c | f,
  z | z,
  a | f,
  c | z,
  z | e,
  b | d,
  b | e,
  z | e,
  a | d
];
a = 1 << 18;
b = 1 << 28;
c = a | b;
d = 1 << 6;
e = 1 << 12;
f = d | e;
var SP8 = [
  b | f,
  z | e,
  a | z,
  c | f,
  b | z,
  b | f,
  z | d,
  b | z,
  a | d,
  c | z,
  c | f,
  a | e,
  c | e,
  a | f,
  z | e,
  z | d,
  c | z,
  b | d,
  b | e,
  z | f,
  a | e,
  a | d,
  c | d,
  c | e,
  z | f,
  z | z,
  z | z,
  c | d,
  b | d,
  b | e,
  a | f,
  a | z,
  a | f,
  a | z,
  c | e,
  z | e,
  z | d,
  c | d,
  z | e,
  a | f,
  b | e,
  z | d,
  b | d,
  c | z,
  c | d,
  b | z,
  a | z,
  b | f,
  z | z,
  c | f,
  a | d,
  b | d,
  c | z,
  b | e,
  b | f,
  z | z,
  c | f,
  a | e,
  a | e,
  z | f,
  z | f,
  a | d,
  b | z,
  c | e
];
var DES = class {
  constructor(password) {
    this.keys = [];
    const pc1m = [], pcr = [], kn = [];
    for (let j = 0, l = 56; j < 56; ++j, l -= 8) {
      l += l < -5 ? 65 : l < -3 ? 31 : l < -1 ? 63 : l === 27 ? 35 : 0;
      const m = l & 7;
      pc1m[j] = (password[l >>> 3] & 1 << m) !== 0 ? 1 : 0;
    }
    for (let i = 0; i < 16; ++i) {
      const m = i << 1;
      const n = m + 1;
      kn[m] = kn[n] = 0;
      for (let o = 28; o < 59; o += 28) {
        for (let j = o - 28; j < o; ++j) {
          const l = j + totrot[i];
          pcr[j] = l < o ? pc1m[l] : pc1m[l - 28];
        }
      }
      for (let j = 0; j < 24; ++j) {
        if (pcr[PC2[j]] !== 0) {
          kn[m] |= 1 << 23 - j;
        }
        if (pcr[PC2[j + 24]] !== 0) {
          kn[n] |= 1 << 23 - j;
        }
      }
    }
    for (let i = 0, rawi = 0, KnLi = 0; i < 16; ++i) {
      const raw0 = kn[rawi++];
      const raw1 = kn[rawi++];
      this.keys[KnLi] = (raw0 & 16515072) << 6;
      this.keys[KnLi] |= (raw0 & 4032) << 10;
      this.keys[KnLi] |= (raw1 & 16515072) >>> 10;
      this.keys[KnLi] |= (raw1 & 4032) >>> 6;
      ++KnLi;
      this.keys[KnLi] = (raw0 & 258048) << 12;
      this.keys[KnLi] |= (raw0 & 63) << 16;
      this.keys[KnLi] |= (raw1 & 258048) >>> 4;
      this.keys[KnLi] |= raw1 & 63;
      ++KnLi;
    }
  }
  // Encrypt 8 bytes of text
  enc8(text) {
    const b2 = text.slice();
    let l, r, x;
    l = b2[0] << 24 | b2[1] << 16 | b2[2] << 8 | b2[3];
    r = b2[4] << 24 | b2[5] << 16 | b2[6] << 8 | b2[7];
    x = (l >>> 4 ^ r) & 252645135;
    r ^= x;
    l ^= x << 4;
    x = (l >>> 16 ^ r) & 65535;
    r ^= x;
    l ^= x << 16;
    x = (r >>> 2 ^ l) & 858993459;
    l ^= x;
    r ^= x << 2;
    x = (r >>> 8 ^ l) & 16711935;
    l ^= x;
    r ^= x << 8;
    r = r << 1 | r >>> 31 & 1;
    x = (l ^ r) & 2863311530;
    l ^= x;
    r ^= x;
    l = l << 1 | l >>> 31 & 1;
    for (let i = 0, keysi = 0; i < 8; ++i) {
      x = r << 28 | r >>> 4;
      x ^= this.keys[keysi++];
      let fval = SP7[x & 63];
      fval |= SP5[x >>> 8 & 63];
      fval |= SP3[x >>> 16 & 63];
      fval |= SP1[x >>> 24 & 63];
      x = r ^ this.keys[keysi++];
      fval |= SP8[x & 63];
      fval |= SP6[x >>> 8 & 63];
      fval |= SP4[x >>> 16 & 63];
      fval |= SP2[x >>> 24 & 63];
      l ^= fval;
      x = l << 28 | l >>> 4;
      x ^= this.keys[keysi++];
      fval = SP7[x & 63];
      fval |= SP5[x >>> 8 & 63];
      fval |= SP3[x >>> 16 & 63];
      fval |= SP1[x >>> 24 & 63];
      x = l ^ this.keys[keysi++];
      fval |= SP8[x & 63];
      fval |= SP6[x >>> 8 & 63];
      fval |= SP4[x >>> 16 & 63];
      fval |= SP2[x >>> 24 & 63];
      r ^= fval;
    }
    r = r << 31 | r >>> 1;
    x = (l ^ r) & 2863311530;
    l ^= x;
    r ^= x;
    l = l << 31 | l >>> 1;
    x = (l >>> 8 ^ r) & 16711935;
    r ^= x;
    l ^= x << 8;
    x = (l >>> 2 ^ r) & 858993459;
    r ^= x;
    l ^= x << 2;
    x = (r >>> 16 ^ l) & 65535;
    l ^= x;
    r ^= x << 16;
    x = (r >>> 4 ^ l) & 252645135;
    l ^= x;
    r ^= x << 4;
    x = [r, l];
    for (let i = 0; i < 8; i++) {
      b2[i] = (x[i >>> 2] >>> 8 * (3 - i % 4)) % 256;
      if (b2[i] < 0) {
        b2[i] += 256;
      }
    }
    return b2;
  }
};
var DESECBCipher = class _DESECBCipher {
  constructor() {
    this._cipher = null;
  }
  get algorithm() {
    return { name: "DES-ECB" };
  }
  static importKey(key, _algorithm, _extractable, _keyUsages) {
    const cipher = new _DESECBCipher();
    cipher._importKey(key);
    return cipher;
  }
  _importKey(key, _extractable, _keyUsages) {
    this._cipher = new DES(key);
  }
  encrypt(_algorithm, plaintext) {
    const x = new Uint8Array(plaintext);
    if (x.length % 8 !== 0 || this._cipher === null) {
      return null;
    }
    const n = x.length / 8;
    for (let i = 0; i < n; i++) {
      x.set(this._cipher.enc8(x.slice(i * 8, i * 8 + 8)), i * 8);
    }
    return x;
  }
};
var DESCBCCipher = class _DESCBCCipher {
  constructor() {
    this._cipher = null;
  }
  get algorithm() {
    return { name: "DES-CBC" };
  }
  static importKey(key, _algorithm, _extractable, _keyUsages) {
    const cipher = new _DESCBCCipher();
    cipher._importKey(key);
    return cipher;
  }
  _importKey(key) {
    this._cipher = new DES(key);
  }
  encrypt(algorithm, plaintext) {
    const x = new Uint8Array(plaintext);
    let y = new Uint8Array(algorithm.iv);
    if (x.length % 8 !== 0 || this._cipher === null) {
      return null;
    }
    const n = x.length / 8;
    for (let i = 0; i < n; i++) {
      for (let j = 0; j < 8; j++) {
        y[j] ^= plaintext[i * 8 + j];
      }
      y = this._cipher.enc8(y);
      x.set(y, i * 8);
    }
    return x;
  }
};

// core/crypto/bigint.js
function modPow(b2, e2, m) {
  let r = 1n;
  b2 = b2 % m;
  while (e2 > 0n) {
    if ((e2 & 1n) === 1n) {
      r = r * b2 % m;
    }
    e2 = e2 >> 1n;
    b2 = b2 * b2 % m;
  }
  return r;
}
function bigIntToU8Array(bigint, padLength = 0) {
  let hex = bigint.toString(16);
  if (padLength === 0) {
    padLength = Math.ceil(hex.length / 2);
  }
  hex = hex.padStart(padLength * 2, "0");
  const length = hex.length / 2;
  const arr = new Uint8Array(length);
  for (let i = 0; i < length; i++) {
    arr[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
  }
  return arr;
}
function u8ArrayToBigInt(arr) {
  let hex = "0x";
  for (let i = 0; i < arr.length; i++) {
    hex += arr[i].toString(16).padStart(2, "0");
  }
  return BigInt(hex);
}

// core/crypto/rsa.js
var RSACipher = class _RSACipher {
  constructor() {
    this._keyLength = 0;
    this._keyBytes = 0;
    this._n = null;
    this._e = null;
    this._d = null;
    this._nBigInt = null;
    this._eBigInt = null;
    this._dBigInt = null;
    this._extractable = false;
  }
  get algorithm() {
    return { name: "RSA-PKCS1-v1_5" };
  }
  _base64urlDecode(data) {
    data = data.replace(/-/g, "+").replace(/_/g, "/");
    data = data.padEnd(Math.ceil(data.length / 4) * 4, "=");
    return base64_default.decode(data);
  }
  _padArray(arr, length) {
    const res = new Uint8Array(length);
    res.set(arr, length - arr.length);
    return res;
  }
  static async generateKey(algorithm, extractable, _keyUsages) {
    const cipher = new _RSACipher();
    await cipher._generateKey(algorithm, extractable);
    return { privateKey: cipher };
  }
  async _generateKey(algorithm, extractable) {
    this._keyLength = algorithm.modulusLength;
    this._keyBytes = Math.ceil(this._keyLength / 8);
    const key = await window.crypto.subtle.generateKey(
      {
        name: "RSA-OAEP",
        modulusLength: algorithm.modulusLength,
        publicExponent: algorithm.publicExponent,
        hash: { name: "SHA-256" }
      },
      true,
      ["encrypt", "decrypt"]
    );
    const privateKey = await window.crypto.subtle.exportKey("jwk", key.privateKey);
    this._n = this._padArray(this._base64urlDecode(privateKey.n), this._keyBytes);
    this._nBigInt = u8ArrayToBigInt(this._n);
    this._e = this._padArray(this._base64urlDecode(privateKey.e), this._keyBytes);
    this._eBigInt = u8ArrayToBigInt(this._e);
    this._d = this._padArray(this._base64urlDecode(privateKey.d), this._keyBytes);
    this._dBigInt = u8ArrayToBigInt(this._d);
    this._extractable = extractable;
  }
  static async importKey(key, _algorithm, extractable, keyUsages) {
    if (keyUsages.length !== 1 || keyUsages[0] !== "encrypt") {
      throw new Error("only support importing RSA public key");
    }
    const cipher = new _RSACipher();
    await cipher._importKey(key, extractable);
    return cipher;
  }
  async _importKey(key, extractable) {
    const n = key.n;
    const e2 = key.e;
    if (n.length !== e2.length) {
      throw new Error("the sizes of modulus and public exponent do not match");
    }
    this._keyBytes = n.length;
    this._keyLength = this._keyBytes * 8;
    this._n = new Uint8Array(this._keyBytes);
    this._e = new Uint8Array(this._keyBytes);
    this._n.set(n);
    this._e.set(e2);
    this._nBigInt = u8ArrayToBigInt(this._n);
    this._eBigInt = u8ArrayToBigInt(this._e);
    this._extractable = extractable;
  }
  async encrypt(_algorithm, message) {
    if (message.length > this._keyBytes - 11) {
      return null;
    }
    const ps = new Uint8Array(this._keyBytes - message.length - 3);
    window.crypto.getRandomValues(ps);
    for (let i = 0; i < ps.length; i++) {
      ps[i] = Math.floor(ps[i] * 254 / 255 + 1);
    }
    const em = new Uint8Array(this._keyBytes);
    em[1] = 2;
    em.set(ps, 2);
    em.set(message, ps.length + 3);
    const emBigInt = u8ArrayToBigInt(em);
    const c2 = modPow(emBigInt, this._eBigInt, this._nBigInt);
    return bigIntToU8Array(c2, this._keyBytes);
  }
  async decrypt(_algorithm, message) {
    if (message.length !== this._keyBytes) {
      return null;
    }
    const msgBigInt = u8ArrayToBigInt(message);
    const emBigInt = modPow(msgBigInt, this._dBigInt, this._nBigInt);
    const em = bigIntToU8Array(emBigInt, this._keyBytes);
    if (em[0] !== 0 || em[1] !== 2) {
      return null;
    }
    let i = 2;
    for (; i < em.length; i++) {
      if (em[i] === 0) {
        break;
      }
    }
    if (i === em.length) {
      return null;
    }
    return em.slice(i + 1, em.length);
  }
  async exportKey() {
    if (!this._extractable) {
      throw new Error("key is not extractable");
    }
    return { n: this._n, e: this._e, d: this._d };
  }
};

// core/crypto/dh.js
var DHPublicKey = class {
  constructor(key) {
    this._key = key;
  }
  get algorithm() {
    return { name: "DH" };
  }
  exportKey() {
    return this._key;
  }
};
var DHCipher = class _DHCipher {
  constructor() {
    this._g = null;
    this._p = null;
    this._gBigInt = null;
    this._pBigInt = null;
    this._privateKey = null;
  }
  get algorithm() {
    return { name: "DH" };
  }
  static generateKey(algorithm, _extractable) {
    const cipher = new _DHCipher();
    cipher._generateKey(algorithm);
    return { privateKey: cipher, publicKey: new DHPublicKey(cipher._publicKey) };
  }
  _generateKey(algorithm) {
    const g = algorithm.g;
    const p = algorithm.p;
    this._keyBytes = p.length;
    this._gBigInt = u8ArrayToBigInt(g);
    this._pBigInt = u8ArrayToBigInt(p);
    this._privateKey = window.crypto.getRandomValues(new Uint8Array(this._keyBytes));
    this._privateKeyBigInt = u8ArrayToBigInt(this._privateKey);
    this._publicKey = bigIntToU8Array(modPow(
      this._gBigInt,
      this._privateKeyBigInt,
      this._pBigInt
    ), this._keyBytes);
  }
  deriveBits(algorithm, length) {
    const bytes = Math.ceil(length / 8);
    const pkey = new Uint8Array(algorithm.public);
    const len = bytes > this._keyBytes ? bytes : this._keyBytes;
    const secret = modPow(u8ArrayToBigInt(pkey), this._privateKeyBigInt, this._pBigInt);
    return bigIntToU8Array(secret, len).slice(0, len);
  }
};

// core/crypto/md5.js
async function MD5(d2) {
  let s = "";
  for (let i = 0; i < d2.length; i++) {
    s += String.fromCharCode(d2[i]);
  }
  return M(V(Y(X(s), 8 * s.length)));
}
function M(d2) {
  let f2 = new Uint8Array(d2.length);
  for (let i = 0; i < d2.length; i++) {
    f2[i] = d2.charCodeAt(i);
  }
  return f2;
}
function X(d2) {
  let r = Array(d2.length >> 2);
  for (let m = 0; m < r.length; m++) r[m] = 0;
  for (let m = 0; m < 8 * d2.length; m += 8) r[m >> 5] |= (255 & d2.charCodeAt(m / 8)) << m % 32;
  return r;
}
function V(d2) {
  let r = "";
  for (let m = 0; m < 32 * d2.length; m += 8) r += String.fromCharCode(d2[m >> 5] >>> m % 32 & 255);
  return r;
}
function Y(d2, g) {
  d2[g >> 5] |= 128 << g % 32, d2[14 + (g + 64 >>> 9 << 4)] = g;
  let m = 1732584193, f2 = -271733879, r = -1732584194, i = 271733878;
  for (let n = 0; n < d2.length; n += 16) {
    let h = m, t = f2, g2 = r, e2 = i;
    f2 = ii(f2 = ii(f2 = ii(f2 = ii(f2 = hh(f2 = hh(f2 = hh(f2 = hh(f2 = gg(f2 = gg(f2 = gg(f2 = gg(f2 = ff(f2 = ff(f2 = ff(f2 = ff(f2, r = ff(r, i = ff(i, m = ff(m, f2, r, i, d2[n + 0], 7, -680876936), f2, r, d2[n + 1], 12, -389564586), m, f2, d2[n + 2], 17, 606105819), i, m, d2[n + 3], 22, -1044525330), r = ff(r, i = ff(i, m = ff(m, f2, r, i, d2[n + 4], 7, -176418897), f2, r, d2[n + 5], 12, 1200080426), m, f2, d2[n + 6], 17, -1473231341), i, m, d2[n + 7], 22, -45705983), r = ff(r, i = ff(i, m = ff(m, f2, r, i, d2[n + 8], 7, 1770035416), f2, r, d2[n + 9], 12, -1958414417), m, f2, d2[n + 10], 17, -42063), i, m, d2[n + 11], 22, -1990404162), r = ff(r, i = ff(i, m = ff(m, f2, r, i, d2[n + 12], 7, 1804603682), f2, r, d2[n + 13], 12, -40341101), m, f2, d2[n + 14], 17, -1502002290), i, m, d2[n + 15], 22, 1236535329), r = gg(r, i = gg(i, m = gg(m, f2, r, i, d2[n + 1], 5, -165796510), f2, r, d2[n + 6], 9, -1069501632), m, f2, d2[n + 11], 14, 643717713), i, m, d2[n + 0], 20, -373897302), r = gg(r, i = gg(i, m = gg(m, f2, r, i, d2[n + 5], 5, -701558691), f2, r, d2[n + 10], 9, 38016083), m, f2, d2[n + 15], 14, -660478335), i, m, d2[n + 4], 20, -405537848), r = gg(r, i = gg(i, m = gg(m, f2, r, i, d2[n + 9], 5, 568446438), f2, r, d2[n + 14], 9, -1019803690), m, f2, d2[n + 3], 14, -187363961), i, m, d2[n + 8], 20, 1163531501), r = gg(r, i = gg(i, m = gg(m, f2, r, i, d2[n + 13], 5, -1444681467), f2, r, d2[n + 2], 9, -51403784), m, f2, d2[n + 7], 14, 1735328473), i, m, d2[n + 12], 20, -1926607734), r = hh(r, i = hh(i, m = hh(m, f2, r, i, d2[n + 5], 4, -378558), f2, r, d2[n + 8], 11, -2022574463), m, f2, d2[n + 11], 16, 1839030562), i, m, d2[n + 14], 23, -35309556), r = hh(r, i = hh(i, m = hh(m, f2, r, i, d2[n + 1], 4, -1530992060), f2, r, d2[n + 4], 11, 1272893353), m, f2, d2[n + 7], 16, -155497632), i, m, d2[n + 10], 23, -1094730640), r = hh(r, i = hh(i, m = hh(m, f2, r, i, d2[n + 13], 4, 681279174), f2, r, d2[n + 0], 11, -358537222), m, f2, d2[n + 3], 16, -722521979), i, m, d2[n + 6], 23, 76029189), r = hh(r, i = hh(i, m = hh(m, f2, r, i, d2[n + 9], 4, -640364487), f2, r, d2[n + 12], 11, -421815835), m, f2, d2[n + 15], 16, 530742520), i, m, d2[n + 2], 23, -995338651), r = ii(r, i = ii(i, m = ii(m, f2, r, i, d2[n + 0], 6, -198630844), f2, r, d2[n + 7], 10, 1126891415), m, f2, d2[n + 14], 15, -1416354905), i, m, d2[n + 5], 21, -57434055), r = ii(r, i = ii(i, m = ii(m, f2, r, i, d2[n + 12], 6, 1700485571), f2, r, d2[n + 3], 10, -1894986606), m, f2, d2[n + 10], 15, -1051523), i, m, d2[n + 1], 21, -2054922799), r = ii(r, i = ii(i, m = ii(m, f2, r, i, d2[n + 8], 6, 1873313359), f2, r, d2[n + 15], 10, -30611744), m, f2, d2[n + 6], 15, -1560198380), i, m, d2[n + 13], 21, 1309151649), r = ii(r, i = ii(i, m = ii(m, f2, r, i, d2[n + 4], 6, -145523070), f2, r, d2[n + 11], 10, -1120210379), m, f2, d2[n + 2], 15, 718787259), i, m, d2[n + 9], 21, -343485551), m = add(m, h), f2 = add(f2, t), r = add(r, g2), i = add(i, e2);
  }
  return Array(m, f2, r, i);
}
function cmn(d2, g, m, f2, r, i) {
  return add(rol(add(add(g, d2), add(f2, i)), r), m);
}
function ff(d2, g, m, f2, r, i, n) {
  return cmn(g & m | ~g & f2, d2, g, r, i, n);
}
function gg(d2, g, m, f2, r, i, n) {
  return cmn(g & f2 | m & ~f2, d2, g, r, i, n);
}
function hh(d2, g, m, f2, r, i, n) {
  return cmn(g ^ m ^ f2, d2, g, r, i, n);
}
function ii(d2, g, m, f2, r, i, n) {
  return cmn(m ^ (g | ~f2), d2, g, r, i, n);
}
function add(d2, g) {
  let m = (65535 & d2) + (65535 & g);
  return (d2 >> 16) + (g >> 16) + (m >> 16) << 16 | 65535 & m;
}
function rol(d2, g) {
  return d2 << g | d2 >>> 32 - g;
}

// core/crypto/crypto.js
var LegacyCrypto = class {
  constructor() {
    this._algorithms = {
      "AES-ECB": AESECBCipher,
      "AES-EAX": AESEAXCipher,
      "DES-ECB": DESECBCipher,
      "DES-CBC": DESCBCCipher,
      "RSA-PKCS1-v1_5": RSACipher,
      "DH": DHCipher,
      "MD5": MD5
    };
  }
  encrypt(algorithm, key, data) {
    if (key.algorithm.name !== algorithm.name) {
      throw new Error("algorithm does not match");
    }
    if (typeof key.encrypt !== "function") {
      throw new Error("key does not support encryption");
    }
    return key.encrypt(algorithm, data);
  }
  decrypt(algorithm, key, data) {
    if (key.algorithm.name !== algorithm.name) {
      throw new Error("algorithm does not match");
    }
    if (typeof key.decrypt !== "function") {
      throw new Error("key does not support encryption");
    }
    return key.decrypt(algorithm, data);
  }
  importKey(format, keyData, algorithm, extractable, keyUsages) {
    if (format !== "raw") {
      throw new Error("key format is not supported");
    }
    const alg = this._algorithms[algorithm.name];
    if (typeof alg === "undefined" || typeof alg.importKey !== "function") {
      throw new Error("algorithm is not supported");
    }
    return alg.importKey(keyData, algorithm, extractable, keyUsages);
  }
  generateKey(algorithm, extractable, keyUsages) {
    const alg = this._algorithms[algorithm.name];
    if (typeof alg === "undefined" || typeof alg.generateKey !== "function") {
      throw new Error("algorithm is not supported");
    }
    return alg.generateKey(algorithm, extractable, keyUsages);
  }
  exportKey(format, key) {
    if (format !== "raw") {
      throw new Error("key format is not supported");
    }
    if (typeof key.exportKey !== "function") {
      throw new Error("key does not support exportKey");
    }
    return key.exportKey();
  }
  digest(algorithm, data) {
    const alg = this._algorithms[algorithm];
    if (typeof alg !== "function") {
      throw new Error("algorithm is not supported");
    }
    return alg(data);
  }
  deriveBits(algorithm, key, length) {
    if (key.algorithm.name !== algorithm.name) {
      throw new Error("algorithm does not match");
    }
    if (typeof key.deriveBits !== "function") {
      throw new Error("key does not support deriveBits");
    }
    return key.deriveBits(algorithm, length);
  }
};
var crypto_default = new LegacyCrypto();

// core/ra2.js
var RA2Cipher = class {
  constructor() {
    this._cipher = null;
    this._counter = new Uint8Array(16);
  }
  async setKey(key) {
    this._cipher = await crypto_default.importKey(
      "raw",
      key,
      { name: "AES-EAX" },
      false,
      ["encrypt, decrypt"]
    );
  }
  async makeMessage(message) {
    const ad = new Uint8Array([(message.length & 65280) >>> 8, message.length & 255]);
    const encrypted = await crypto_default.encrypt({
      name: "AES-EAX",
      iv: this._counter,
      additionalData: ad
    }, this._cipher, message);
    for (let i = 0; i < 16 && this._counter[i]++ === 255; i++) ;
    const res = new Uint8Array(message.length + 2 + 16);
    res.set(ad);
    res.set(encrypted, 2);
    return res;
  }
  async receiveMessage(length, encrypted) {
    const ad = new Uint8Array([(length & 65280) >>> 8, length & 255]);
    const res = await crypto_default.decrypt({
      name: "AES-EAX",
      iv: this._counter,
      additionalData: ad
    }, this._cipher, encrypted);
    for (let i = 0; i < 16 && this._counter[i]++ === 255; i++) ;
    return res;
  }
};
var RSAAESAuthenticationState = class extends EventTargetMixin {
  constructor(sock, getCredentials) {
    super();
    this._hasStarted = false;
    this._checkSock = null;
    this._checkCredentials = null;
    this._approveServerResolve = null;
    this._sockReject = null;
    this._credentialsReject = null;
    this._approveServerReject = null;
    this._sock = sock;
    this._getCredentials = getCredentials;
  }
  _waitSockAsync(len) {
    return new Promise((resolve, reject) => {
      const hasData = () => !this._sock.rQwait("RA2", len);
      if (hasData()) {
        resolve();
      } else {
        this._checkSock = () => {
          if (hasData()) {
            resolve();
            this._checkSock = null;
            this._sockReject = null;
          }
        };
        this._sockReject = reject;
      }
    });
  }
  _waitApproveKeyAsync() {
    return new Promise((resolve, reject) => {
      this._approveServerResolve = resolve;
      this._approveServerReject = reject;
    });
  }
  _waitCredentialsAsync(subtype) {
    const hasCredentials = () => {
      if (subtype === 1 && this._getCredentials().username !== void 0 && this._getCredentials().password !== void 0) {
        return true;
      } else if (subtype === 2 && this._getCredentials().password !== void 0) {
        return true;
      }
      return false;
    };
    return new Promise((resolve, reject) => {
      if (hasCredentials()) {
        resolve();
      } else {
        this._checkCredentials = () => {
          if (hasCredentials()) {
            resolve();
            this._checkCredentials = null;
            this._credentialsReject = null;
          }
        };
        this._credentialsReject = reject;
      }
    });
  }
  checkInternalEvents() {
    if (this._checkSock !== null) {
      this._checkSock();
    }
    if (this._checkCredentials !== null) {
      this._checkCredentials();
    }
  }
  approveServer() {
    if (this._approveServerResolve !== null) {
      this._approveServerResolve();
      this._approveServerResolve = null;
    }
  }
  disconnect() {
    if (this._sockReject !== null) {
      this._sockReject(new Error("disconnect normally"));
      this._sockReject = null;
    }
    if (this._credentialsReject !== null) {
      this._credentialsReject(new Error("disconnect normally"));
      this._credentialsReject = null;
    }
    if (this._approveServerReject !== null) {
      this._approveServerReject(new Error("disconnect normally"));
      this._approveServerReject = null;
    }
  }
  async negotiateRA2neAuthAsync() {
    this._hasStarted = true;
    await this._waitSockAsync(4);
    const serverKeyLengthBuffer = this._sock.rQpeekBytes(4);
    const serverKeyLength = this._sock.rQshift32();
    if (serverKeyLength < 1024) {
      throw new Error("RA2: server public key is too short: " + serverKeyLength);
    } else if (serverKeyLength > 8192) {
      throw new Error("RA2: server public key is too long: " + serverKeyLength);
    }
    const serverKeyBytes = Math.ceil(serverKeyLength / 8);
    await this._waitSockAsync(serverKeyBytes * 2);
    const serverN = this._sock.rQshiftBytes(serverKeyBytes);
    const serverE = this._sock.rQshiftBytes(serverKeyBytes);
    const serverRSACipher = await crypto_default.importKey(
      "raw",
      { n: serverN, e: serverE },
      { name: "RSA-PKCS1-v1_5" },
      false,
      ["encrypt"]
    );
    const serverPublickey = new Uint8Array(4 + serverKeyBytes * 2);
    serverPublickey.set(serverKeyLengthBuffer);
    serverPublickey.set(serverN, 4);
    serverPublickey.set(serverE, 4 + serverKeyBytes);
    let approveKey = this._waitApproveKeyAsync();
    this.dispatchEvent(new CustomEvent("serververification", {
      detail: { type: "RSA", publickey: serverPublickey }
    }));
    await approveKey;
    const clientKeyLength = 2048;
    const clientKeyBytes = Math.ceil(clientKeyLength / 8);
    const clientRSACipher = (await crypto_default.generateKey({
      name: "RSA-PKCS1-v1_5",
      modulusLength: clientKeyLength,
      publicExponent: new Uint8Array([1, 0, 1])
    }, true, ["encrypt"])).privateKey;
    const clientExportedRSAKey = await crypto_default.exportKey("raw", clientRSACipher);
    const clientN = clientExportedRSAKey.n;
    const clientE = clientExportedRSAKey.e;
    const clientPublicKey = new Uint8Array(4 + clientKeyBytes * 2);
    clientPublicKey[0] = (clientKeyLength & 4278190080) >>> 24;
    clientPublicKey[1] = (clientKeyLength & 16711680) >>> 16;
    clientPublicKey[2] = (clientKeyLength & 65280) >>> 8;
    clientPublicKey[3] = clientKeyLength & 255;
    clientPublicKey.set(clientN, 4);
    clientPublicKey.set(clientE, 4 + clientKeyBytes);
    this._sock.sQpushBytes(clientPublicKey);
    this._sock.flush();
    const clientRandom = new Uint8Array(16);
    window.crypto.getRandomValues(clientRandom);
    const clientEncryptedRandom = await crypto_default.encrypt(
      { name: "RSA-PKCS1-v1_5" },
      serverRSACipher,
      clientRandom
    );
    const clientRandomMessage = new Uint8Array(2 + serverKeyBytes);
    clientRandomMessage[0] = (serverKeyBytes & 65280) >>> 8;
    clientRandomMessage[1] = serverKeyBytes & 255;
    clientRandomMessage.set(clientEncryptedRandom, 2);
    this._sock.sQpushBytes(clientRandomMessage);
    this._sock.flush();
    await this._waitSockAsync(2);
    if (this._sock.rQshift16() !== clientKeyBytes) {
      throw new Error("RA2: wrong encrypted message length");
    }
    const serverEncryptedRandom = this._sock.rQshiftBytes(clientKeyBytes);
    const serverRandom = await crypto_default.decrypt(
      { name: "RSA-PKCS1-v1_5" },
      clientRSACipher,
      serverEncryptedRandom
    );
    if (serverRandom === null || serverRandom.length !== 16) {
      throw new Error("RA2: corrupted server encrypted random");
    }
    let clientSessionKey = new Uint8Array(32);
    let serverSessionKey = new Uint8Array(32);
    clientSessionKey.set(serverRandom);
    clientSessionKey.set(clientRandom, 16);
    serverSessionKey.set(clientRandom);
    serverSessionKey.set(serverRandom, 16);
    clientSessionKey = await window.crypto.subtle.digest("SHA-1", clientSessionKey);
    clientSessionKey = new Uint8Array(clientSessionKey).slice(0, 16);
    serverSessionKey = await window.crypto.subtle.digest("SHA-1", serverSessionKey);
    serverSessionKey = new Uint8Array(serverSessionKey).slice(0, 16);
    const clientCipher = new RA2Cipher();
    await clientCipher.setKey(clientSessionKey);
    const serverCipher = new RA2Cipher();
    await serverCipher.setKey(serverSessionKey);
    let serverHash = new Uint8Array(8 + serverKeyBytes * 2 + clientKeyBytes * 2);
    let clientHash = new Uint8Array(8 + serverKeyBytes * 2 + clientKeyBytes * 2);
    serverHash.set(serverPublickey);
    serverHash.set(clientPublicKey, 4 + serverKeyBytes * 2);
    clientHash.set(clientPublicKey);
    clientHash.set(serverPublickey, 4 + clientKeyBytes * 2);
    serverHash = await window.crypto.subtle.digest("SHA-1", serverHash);
    clientHash = await window.crypto.subtle.digest("SHA-1", clientHash);
    serverHash = new Uint8Array(serverHash);
    clientHash = new Uint8Array(clientHash);
    this._sock.sQpushBytes(await clientCipher.makeMessage(clientHash));
    this._sock.flush();
    await this._waitSockAsync(2 + 20 + 16);
    if (this._sock.rQshift16() !== 20) {
      throw new Error("RA2: wrong server hash");
    }
    const serverHashReceived = await serverCipher.receiveMessage(
      20,
      this._sock.rQshiftBytes(20 + 16)
    );
    if (serverHashReceived === null) {
      throw new Error("RA2: failed to authenticate the message");
    }
    for (let i = 0; i < 20; i++) {
      if (serverHashReceived[i] !== serverHash[i]) {
        throw new Error("RA2: wrong server hash");
      }
    }
    await this._waitSockAsync(2 + 1 + 16);
    if (this._sock.rQshift16() !== 1) {
      throw new Error("RA2: wrong subtype");
    }
    let subtype = await serverCipher.receiveMessage(
      1,
      this._sock.rQshiftBytes(1 + 16)
    );
    if (subtype === null) {
      throw new Error("RA2: failed to authenticate the message");
    }
    subtype = subtype[0];
    let waitCredentials = this._waitCredentialsAsync(subtype);
    if (subtype === 1) {
      if (this._getCredentials().username === void 0 || this._getCredentials().password === void 0) {
        this.dispatchEvent(new CustomEvent(
          "credentialsrequired",
          { detail: { types: ["username", "password"] } }
        ));
      }
    } else if (subtype === 2) {
      if (this._getCredentials().password === void 0) {
        this.dispatchEvent(new CustomEvent(
          "credentialsrequired",
          { detail: { types: ["password"] } }
        ));
      }
    } else {
      throw new Error("RA2: wrong subtype");
    }
    await waitCredentials;
    let username;
    if (subtype === 1) {
      username = encodeUTF8(this._getCredentials().username).slice(0, 255);
    } else {
      username = "";
    }
    const password = encodeUTF8(this._getCredentials().password).slice(0, 255);
    const credentials = new Uint8Array(username.length + password.length + 2);
    credentials[0] = username.length;
    credentials[username.length + 1] = password.length;
    for (let i = 0; i < username.length; i++) {
      credentials[i + 1] = username.charCodeAt(i);
    }
    for (let i = 0; i < password.length; i++) {
      credentials[username.length + 2 + i] = password.charCodeAt(i);
    }
    this._sock.sQpushBytes(await clientCipher.makeMessage(credentials));
    this._sock.flush();
  }
  get hasStarted() {
    return this._hasStarted;
  }
  set hasStarted(s) {
    this._hasStarted = s;
  }
};

// core/decoders/raw.js
var RawDecoder = class {
  constructor() {
    this._lines = 0;
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    if (width === 0 || height === 0) {
      return true;
    }
    if (this._lines === 0) {
      this._lines = height;
    }
    const pixelSize = depth == 8 ? 1 : 4;
    const bytesPerLine = width * pixelSize;
    while (this._lines > 0) {
      if (sock.rQwait("RAW", bytesPerLine)) {
        return false;
      }
      const curY = y + (height - this._lines);
      let data = sock.rQshiftBytes(bytesPerLine, false);
      if (depth == 8) {
        const newdata = new Uint8Array(width * 4);
        for (let i = 0; i < width; i++) {
          newdata[i * 4 + 0] = (data[i] >> 0 & 3) * 255 / 3;
          newdata[i * 4 + 1] = (data[i] >> 2 & 3) * 255 / 3;
          newdata[i * 4 + 2] = (data[i] >> 4 & 3) * 255 / 3;
          newdata[i * 4 + 3] = 255;
        }
        data = newdata;
      }
      for (let i = 0; i < width; i++) {
        data[i * 4 + 3] = 255;
      }
      display.blitImage(x, curY, width, 1, data, 0);
      this._lines--;
    }
    return true;
  }
};

// core/decoders/copyrect.js
var CopyRectDecoder = class {
  decodeRect(x, y, width, height, sock, display, depth) {
    if (sock.rQwait("COPYRECT", 4)) {
      return false;
    }
    let deltaX = sock.rQshift16();
    let deltaY = sock.rQshift16();
    if (width === 0 || height === 0) {
      return true;
    }
    display.copyImage(deltaX, deltaY, x, y, width, height);
    return true;
  }
};

// core/decoders/rre.js
var RREDecoder = class {
  constructor() {
    this._subrects = 0;
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    if (this._subrects === 0) {
      if (sock.rQwait("RRE", 4 + 4)) {
        return false;
      }
      this._subrects = sock.rQshift32();
      let color = sock.rQshiftBytes(4);
      display.fillRect(x, y, width, height, color);
    }
    while (this._subrects > 0) {
      if (sock.rQwait("RRE", 4 + 8)) {
        return false;
      }
      let color = sock.rQshiftBytes(4);
      let sx = sock.rQshift16();
      let sy = sock.rQshift16();
      let swidth = sock.rQshift16();
      let sheight = sock.rQshift16();
      display.fillRect(x + sx, y + sy, swidth, sheight, color);
      this._subrects--;
    }
    return true;
  }
};

// core/decoders/hextile.js
var HextileDecoder = class {
  constructor() {
    this._tiles = 0;
    this._lastsubencoding = 0;
    this._tileBuffer = new Uint8Array(16 * 16 * 4);
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    if (this._tiles === 0) {
      this._tilesX = Math.ceil(width / 16);
      this._tilesY = Math.ceil(height / 16);
      this._totalTiles = this._tilesX * this._tilesY;
      this._tiles = this._totalTiles;
    }
    while (this._tiles > 0) {
      let bytes = 1;
      if (sock.rQwait("HEXTILE", bytes)) {
        return false;
      }
      let subencoding = sock.rQpeek8();
      if (subencoding > 30) {
        throw new Error("Illegal hextile subencoding (subencoding: " + subencoding + ")");
      }
      const currTile = this._totalTiles - this._tiles;
      const tileX = currTile % this._tilesX;
      const tileY = Math.floor(currTile / this._tilesX);
      const tx = x + tileX * 16;
      const ty = y + tileY * 16;
      const tw = Math.min(16, x + width - tx);
      const th = Math.min(16, y + height - ty);
      if (subencoding & 1) {
        bytes += tw * th * 4;
      } else {
        if (subencoding & 2) {
          bytes += 4;
        }
        if (subencoding & 4) {
          bytes += 4;
        }
        if (subencoding & 8) {
          bytes++;
          if (sock.rQwait("HEXTILE", bytes)) {
            return false;
          }
          let subrects = sock.rQpeekBytes(bytes).at(-1);
          if (subencoding & 16) {
            bytes += subrects * (4 + 2);
          } else {
            bytes += subrects * 2;
          }
        }
      }
      if (sock.rQwait("HEXTILE", bytes)) {
        return false;
      }
      sock.rQshift8();
      if (subencoding === 0) {
        if (this._lastsubencoding & 1) {
          Debug("     Ignoring blank after RAW");
        } else {
          display.fillRect(tx, ty, tw, th, this._background);
        }
      } else if (subencoding & 1) {
        let pixels = tw * th;
        let data = sock.rQshiftBytes(pixels * 4, false);
        for (let i = 0; i < pixels; i++) {
          data[i * 4 + 3] = 255;
        }
        display.blitImage(tx, ty, tw, th, data, 0);
      } else {
        if (subencoding & 2) {
          this._background = new Uint8Array(sock.rQshiftBytes(4));
        }
        if (subencoding & 4) {
          this._foreground = new Uint8Array(sock.rQshiftBytes(4));
        }
        this._startTile(tx, ty, tw, th, this._background);
        if (subencoding & 8) {
          let subrects = sock.rQshift8();
          for (let s = 0; s < subrects; s++) {
            let color;
            if (subencoding & 16) {
              color = sock.rQshiftBytes(4);
            } else {
              color = this._foreground;
            }
            const xy = sock.rQshift8();
            const sx = xy >> 4;
            const sy = xy & 15;
            const wh = sock.rQshift8();
            const sw = (wh >> 4) + 1;
            const sh = (wh & 15) + 1;
            this._subTile(sx, sy, sw, sh, color);
          }
        }
        this._finishTile(display);
      }
      this._lastsubencoding = subencoding;
      this._tiles--;
    }
    return true;
  }
  // start updating a tile
  _startTile(x, y, width, height, color) {
    this._tileX = x;
    this._tileY = y;
    this._tileW = width;
    this._tileH = height;
    const red = color[0];
    const green = color[1];
    const blue = color[2];
    const data = this._tileBuffer;
    for (let i = 0; i < width * height * 4; i += 4) {
      data[i] = red;
      data[i + 1] = green;
      data[i + 2] = blue;
      data[i + 3] = 255;
    }
  }
  // update sub-rectangle of the current tile
  _subTile(x, y, w, h, color) {
    const red = color[0];
    const green = color[1];
    const blue = color[2];
    const xend = x + w;
    const yend = y + h;
    const data = this._tileBuffer;
    const width = this._tileW;
    for (let j = y; j < yend; j++) {
      for (let i = x; i < xend; i++) {
        const p = (i + j * width) * 4;
        data[p] = red;
        data[p + 1] = green;
        data[p + 2] = blue;
        data[p + 3] = 255;
      }
    }
  }
  // draw the current tile to the screen
  _finishTile(display) {
    display.blitImage(
      this._tileX,
      this._tileY,
      this._tileW,
      this._tileH,
      this._tileBuffer,
      0
    );
  }
};

// core/decoders/zlib.js
var ZlibDecoder = class {
  constructor() {
    this._zlib = new Inflate();
    this._length = 0;
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    if (width === 0 || height === 0) {
      return true;
    }
    if (this._length === 0) {
      if (sock.rQwait("ZLIB", 4)) {
        return false;
      }
      this._length = sock.rQshift32();
    }
    if (sock.rQwait("ZLIB", this._length)) {
      return false;
    }
    let data = new Uint8Array(sock.rQshiftBytes(this._length, false));
    this._length = 0;
    this._zlib.setInput(data);
    data = this._zlib.inflate(width * height * 4);
    this._zlib.setInput(null);
    for (let i = 0; i < width * height; i++) {
      data[i * 4 + 3] = 255;
    }
    display.blitImage(x, y, width, height, data, 0);
    return true;
  }
};

// core/decoders/tight.js
var TightDecoder = class {
  constructor() {
    this._ctl = null;
    this._filter = null;
    this._numColors = 0;
    this._palette = new Uint8Array(1024);
    this._len = 0;
    this._zlibs = [];
    for (let i = 0; i < 4; i++) {
      this._zlibs[i] = new Inflate();
    }
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    if (this._ctl === null) {
      if (sock.rQwait("TIGHT compression-control", 1)) {
        return false;
      }
      this._ctl = sock.rQshift8();
      for (let i = 0; i < 4; i++) {
        if (this._ctl >> i & 1) {
          this._zlibs[i].reset();
          Info("Reset zlib stream " + i);
        }
      }
      this._ctl = this._ctl >> 4;
    }
    let ret;
    if (this._ctl === 8) {
      ret = this._fillRect(
        x,
        y,
        width,
        height,
        sock,
        display,
        depth
      );
    } else if (this._ctl === 9) {
      ret = this._jpegRect(
        x,
        y,
        width,
        height,
        sock,
        display,
        depth
      );
    } else if (this._ctl === 10) {
      ret = this._pngRect(
        x,
        y,
        width,
        height,
        sock,
        display,
        depth
      );
    } else if ((this._ctl & 8) == 0) {
      ret = this._basicRect(
        this._ctl,
        x,
        y,
        width,
        height,
        sock,
        display,
        depth
      );
    } else {
      throw new Error("Illegal tight compression received (ctl: " + this._ctl + ")");
    }
    if (ret) {
      this._ctl = null;
    }
    return ret;
  }
  _fillRect(x, y, width, height, sock, display, depth) {
    if (sock.rQwait("TIGHT", 3)) {
      return false;
    }
    let pixel = sock.rQshiftBytes(3);
    display.fillRect(x, y, width, height, pixel, false);
    return true;
  }
  _jpegRect(x, y, width, height, sock, display, depth) {
    let data = this._readData(sock);
    if (data === null) {
      return false;
    }
    display.imageRect(x, y, width, height, "image/jpeg", data);
    return true;
  }
  _pngRect(x, y, width, height, sock, display, depth) {
    throw new Error("PNG received in standard Tight rect");
  }
  _basicRect(ctl, x, y, width, height, sock, display, depth) {
    if (this._filter === null) {
      if (ctl & 4) {
        if (sock.rQwait("TIGHT", 1)) {
          return false;
        }
        this._filter = sock.rQshift8();
      } else {
        this._filter = 0;
      }
    }
    let streamId = ctl & 3;
    let ret;
    switch (this._filter) {
      case 0:
        ret = this._copyFilter(
          streamId,
          x,
          y,
          width,
          height,
          sock,
          display,
          depth
        );
        break;
      case 1:
        ret = this._paletteFilter(
          streamId,
          x,
          y,
          width,
          height,
          sock,
          display,
          depth
        );
        break;
      case 2:
        ret = this._gradientFilter(
          streamId,
          x,
          y,
          width,
          height,
          sock,
          display,
          depth
        );
        break;
      default:
        throw new Error("Illegal tight filter received (ctl: " + this._filter + ")");
    }
    if (ret) {
      this._filter = null;
    }
    return ret;
  }
  _copyFilter(streamId, x, y, width, height, sock, display, depth) {
    const uncompressedSize = width * height * 3;
    let data;
    if (uncompressedSize === 0) {
      return true;
    }
    if (uncompressedSize < 12) {
      if (sock.rQwait("TIGHT", uncompressedSize)) {
        return false;
      }
      data = sock.rQshiftBytes(uncompressedSize);
    } else {
      data = this._readData(sock);
      if (data === null) {
        return false;
      }
      this._zlibs[streamId].setInput(data);
      data = this._zlibs[streamId].inflate(uncompressedSize);
      this._zlibs[streamId].setInput(null);
    }
    let rgbx = new Uint8Array(width * height * 4);
    for (let i = 0, j = 0; i < width * height * 4; i += 4, j += 3) {
      rgbx[i] = data[j];
      rgbx[i + 1] = data[j + 1];
      rgbx[i + 2] = data[j + 2];
      rgbx[i + 3] = 255;
    }
    display.blitImage(x, y, width, height, rgbx, 0, false);
    return true;
  }
  _paletteFilter(streamId, x, y, width, height, sock, display, depth) {
    if (this._numColors === 0) {
      if (sock.rQwait("TIGHT palette", 1)) {
        return false;
      }
      const numColors = sock.rQpeek8() + 1;
      const paletteSize = numColors * 3;
      if (sock.rQwait("TIGHT palette", 1 + paletteSize)) {
        return false;
      }
      this._numColors = numColors;
      sock.rQskipBytes(1);
      sock.rQshiftTo(this._palette, paletteSize);
    }
    const bpp = this._numColors <= 2 ? 1 : 8;
    const rowSize = Math.floor((width * bpp + 7) / 8);
    const uncompressedSize = rowSize * height;
    let data;
    if (uncompressedSize === 0) {
      return true;
    }
    if (uncompressedSize < 12) {
      if (sock.rQwait("TIGHT", uncompressedSize)) {
        return false;
      }
      data = sock.rQshiftBytes(uncompressedSize);
    } else {
      data = this._readData(sock);
      if (data === null) {
        return false;
      }
      this._zlibs[streamId].setInput(data);
      data = this._zlibs[streamId].inflate(uncompressedSize);
      this._zlibs[streamId].setInput(null);
    }
    if (this._numColors == 2) {
      this._monoRect(x, y, width, height, data, this._palette, display);
    } else {
      this._paletteRect(x, y, width, height, data, this._palette, display);
    }
    this._numColors = 0;
    return true;
  }
  _monoRect(x, y, width, height, data, palette, display) {
    const dest = this._getScratchBuffer(width * height * 4);
    const w = Math.floor((width + 7) / 8);
    const w1 = Math.floor(width / 8);
    for (let y2 = 0; y2 < height; y2++) {
      let dp, sp, x2;
      for (x2 = 0; x2 < w1; x2++) {
        for (let b2 = 7; b2 >= 0; b2--) {
          dp = (y2 * width + x2 * 8 + 7 - b2) * 4;
          sp = (data[y2 * w + x2] >> b2 & 1) * 3;
          dest[dp] = palette[sp];
          dest[dp + 1] = palette[sp + 1];
          dest[dp + 2] = palette[sp + 2];
          dest[dp + 3] = 255;
        }
      }
      for (let b2 = 7; b2 >= 8 - width % 8; b2--) {
        dp = (y2 * width + x2 * 8 + 7 - b2) * 4;
        sp = (data[y2 * w + x2] >> b2 & 1) * 3;
        dest[dp] = palette[sp];
        dest[dp + 1] = palette[sp + 1];
        dest[dp + 2] = palette[sp + 2];
        dest[dp + 3] = 255;
      }
    }
    display.blitImage(x, y, width, height, dest, 0, false);
  }
  _paletteRect(x, y, width, height, data, palette, display) {
    const dest = this._getScratchBuffer(width * height * 4);
    const total = width * height * 4;
    for (let i = 0, j = 0; i < total; i += 4, j++) {
      const sp = data[j] * 3;
      dest[i] = palette[sp];
      dest[i + 1] = palette[sp + 1];
      dest[i + 2] = palette[sp + 2];
      dest[i + 3] = 255;
    }
    display.blitImage(x, y, width, height, dest, 0, false);
  }
  _gradientFilter(streamId, x, y, width, height, sock, display, depth) {
    const uncompressedSize = width * height * 3;
    let data;
    if (uncompressedSize === 0) {
      return true;
    }
    if (uncompressedSize < 12) {
      if (sock.rQwait("TIGHT", uncompressedSize)) {
        return false;
      }
      data = sock.rQshiftBytes(uncompressedSize);
    } else {
      data = this._readData(sock);
      if (data === null) {
        return false;
      }
      this._zlibs[streamId].setInput(data);
      data = this._zlibs[streamId].inflate(uncompressedSize);
      this._zlibs[streamId].setInput(null);
    }
    let rgbx = new Uint8Array(4 * width * height);
    let rgbxIndex = 0, dataIndex = 0;
    let left = new Uint8Array(3);
    for (let x2 = 0; x2 < width; x2++) {
      for (let c2 = 0; c2 < 3; c2++) {
        const prediction = left[c2];
        const value = data[dataIndex++] + prediction;
        rgbx[rgbxIndex++] = value;
        left[c2] = value;
      }
      rgbx[rgbxIndex++] = 255;
    }
    let upperIndex = 0;
    let upper = new Uint8Array(3), upperleft = new Uint8Array(3);
    for (let y2 = 1; y2 < height; y2++) {
      left.fill(0);
      upperleft.fill(0);
      for (let x2 = 0; x2 < width; x2++) {
        for (let c2 = 0; c2 < 3; c2++) {
          upper[c2] = rgbx[upperIndex++];
          let prediction = left[c2] + upper[c2] - upperleft[c2];
          if (prediction < 0) {
            prediction = 0;
          } else if (prediction > 255) {
            prediction = 255;
          }
          const value = data[dataIndex++] + prediction;
          rgbx[rgbxIndex++] = value;
          upperleft[c2] = upper[c2];
          left[c2] = value;
        }
        rgbx[rgbxIndex++] = 255;
        upperIndex++;
      }
    }
    display.blitImage(x, y, width, height, rgbx, 0, false);
    return true;
  }
  _readData(sock) {
    if (this._len === 0) {
      if (sock.rQwait("TIGHT", 3)) {
        return null;
      }
      let byte;
      byte = sock.rQshift8();
      this._len = byte & 127;
      if (byte & 128) {
        byte = sock.rQshift8();
        this._len |= (byte & 127) << 7;
        if (byte & 128) {
          byte = sock.rQshift8();
          this._len |= byte << 14;
        }
      }
    }
    if (sock.rQwait("TIGHT", this._len)) {
      return null;
    }
    let data = sock.rQshiftBytes(this._len, false);
    this._len = 0;
    return data;
  }
  _getScratchBuffer(size) {
    if (!this._scratchBuffer || this._scratchBuffer.length < size) {
      this._scratchBuffer = new Uint8Array(size);
    }
    return this._scratchBuffer;
  }
};

// core/decoders/tightpng.js
var TightPNGDecoder = class extends TightDecoder {
  _pngRect(x, y, width, height, sock, display, depth) {
    let data = this._readData(sock);
    if (data === null) {
      return false;
    }
    display.imageRect(x, y, width, height, "image/png", data);
    return true;
  }
  _basicRect(ctl, x, y, width, height, sock, display, depth) {
    throw new Error("BasicCompression received in TightPNG rect");
  }
};

// core/decoders/zrle.js
var ZRLE_TILE_WIDTH = 64;
var ZRLE_TILE_HEIGHT = 64;
var ZRLEDecoder = class {
  constructor() {
    this._length = 0;
    this._inflator = new Inflate();
    this._pixelBuffer = new Uint8Array(ZRLE_TILE_WIDTH * ZRLE_TILE_HEIGHT * 4);
    this._tileBuffer = new Uint8Array(ZRLE_TILE_WIDTH * ZRLE_TILE_HEIGHT * 4);
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    if (this._length === 0) {
      if (sock.rQwait("ZLib data length", 4)) {
        return false;
      }
      this._length = sock.rQshift32();
    }
    if (sock.rQwait("Zlib data", this._length)) {
      return false;
    }
    const data = sock.rQshiftBytes(this._length, false);
    this._inflator.setInput(data);
    for (let ty = y; ty < y + height; ty += ZRLE_TILE_HEIGHT) {
      let th = Math.min(ZRLE_TILE_HEIGHT, y + height - ty);
      for (let tx = x; tx < x + width; tx += ZRLE_TILE_WIDTH) {
        let tw = Math.min(ZRLE_TILE_WIDTH, x + width - tx);
        const tileSize = tw * th;
        const subencoding = this._inflator.inflate(1)[0];
        if (subencoding === 0) {
          const data2 = this._readPixels(tileSize);
          display.blitImage(tx, ty, tw, th, data2, 0, false);
        } else if (subencoding === 1) {
          const background = this._readPixels(1);
          display.fillRect(tx, ty, tw, th, [background[0], background[1], background[2]]);
        } else if (subencoding >= 2 && subencoding <= 16) {
          const data2 = this._decodePaletteTile(subencoding, tileSize, tw, th);
          display.blitImage(tx, ty, tw, th, data2, 0, false);
        } else if (subencoding === 128) {
          const data2 = this._decodeRLETile(tileSize);
          display.blitImage(tx, ty, tw, th, data2, 0, false);
        } else if (subencoding >= 130 && subencoding <= 255) {
          const data2 = this._decodeRLEPaletteTile(subencoding - 128, tileSize);
          display.blitImage(tx, ty, tw, th, data2, 0, false);
        } else {
          throw new Error("Unknown subencoding: " + subencoding);
        }
      }
    }
    this._length = 0;
    return true;
  }
  _getBitsPerPixelInPalette(paletteSize) {
    if (paletteSize <= 2) {
      return 1;
    } else if (paletteSize <= 4) {
      return 2;
    } else if (paletteSize <= 16) {
      return 4;
    }
  }
  _readPixels(pixels) {
    let data = this._pixelBuffer;
    const buffer = this._inflator.inflate(3 * pixels);
    for (let i = 0, j = 0; i < pixels * 4; i += 4, j += 3) {
      data[i] = buffer[j];
      data[i + 1] = buffer[j + 1];
      data[i + 2] = buffer[j + 2];
      data[i + 3] = 255;
    }
    return data;
  }
  _decodePaletteTile(paletteSize, tileSize, tilew, tileh) {
    const data = this._tileBuffer;
    const palette = this._readPixels(paletteSize);
    const bitsPerPixel = this._getBitsPerPixelInPalette(paletteSize);
    const mask = (1 << bitsPerPixel) - 1;
    let offset = 0;
    let encoded = this._inflator.inflate(1)[0];
    for (let y = 0; y < tileh; y++) {
      let shift = 8 - bitsPerPixel;
      for (let x = 0; x < tilew; x++) {
        if (shift < 0) {
          shift = 8 - bitsPerPixel;
          encoded = this._inflator.inflate(1)[0];
        }
        let indexInPalette = encoded >> shift & mask;
        data[offset] = palette[indexInPalette * 4];
        data[offset + 1] = palette[indexInPalette * 4 + 1];
        data[offset + 2] = palette[indexInPalette * 4 + 2];
        data[offset + 3] = palette[indexInPalette * 4 + 3];
        offset += 4;
        shift -= bitsPerPixel;
      }
      if (shift < 8 - bitsPerPixel && y < tileh - 1) {
        encoded = this._inflator.inflate(1)[0];
      }
    }
    return data;
  }
  _decodeRLETile(tileSize) {
    const data = this._tileBuffer;
    let i = 0;
    while (i < tileSize) {
      const pixel = this._readPixels(1);
      const length = this._readRLELength();
      for (let j = 0; j < length; j++) {
        data[i * 4] = pixel[0];
        data[i * 4 + 1] = pixel[1];
        data[i * 4 + 2] = pixel[2];
        data[i * 4 + 3] = pixel[3];
        i++;
      }
    }
    return data;
  }
  _decodeRLEPaletteTile(paletteSize, tileSize) {
    const data = this._tileBuffer;
    const palette = this._readPixels(paletteSize);
    let offset = 0;
    while (offset < tileSize) {
      let indexInPalette = this._inflator.inflate(1)[0];
      let length = 1;
      if (indexInPalette >= 128) {
        indexInPalette -= 128;
        length = this._readRLELength();
      }
      if (indexInPalette > paletteSize) {
        throw new Error("Too big index in palette: " + indexInPalette + ", palette size: " + paletteSize);
      }
      if (offset + length > tileSize) {
        throw new Error("Too big rle length in palette mode: " + length + ", allowed length is: " + (tileSize - offset));
      }
      for (let j = 0; j < length; j++) {
        data[offset * 4] = palette[indexInPalette * 4];
        data[offset * 4 + 1] = palette[indexInPalette * 4 + 1];
        data[offset * 4 + 2] = palette[indexInPalette * 4 + 2];
        data[offset * 4 + 3] = palette[indexInPalette * 4 + 3];
        offset++;
      }
    }
    return data;
  }
  _readRLELength() {
    let length = 0;
    let current;
    do {
      current = this._inflator.inflate(1)[0];
      length += current;
    } while (current === 255);
    return length + 1;
  }
};

// core/decoders/jpeg.js
var JPEGDecoder = class {
  constructor() {
    this._cachedQuantTables = [];
    this._cachedHuffmanTables = [];
    this._segments = [];
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    while (true) {
      let segment = this._readSegment(sock);
      if (segment === null) {
        return false;
      }
      this._segments.push(segment);
      if (segment[1] === 217) {
        break;
      }
    }
    let huffmanTables = [];
    let quantTables = [];
    for (let segment of this._segments) {
      let type = segment[1];
      if (type === 196) {
        huffmanTables.push(segment);
      } else if (type === 219) {
        quantTables.push(segment);
      }
    }
    const sofIndex = this._segments.findIndex(
      (x2) => x2[1] == 192 || x2[1] == 194
    );
    if (sofIndex == -1) {
      throw new Error("Illegal JPEG image without SOF");
    }
    if (quantTables.length === 0) {
      this._segments.splice(
        sofIndex + 1,
        0,
        ...this._cachedQuantTables
      );
    }
    if (huffmanTables.length === 0) {
      this._segments.splice(
        sofIndex + 1,
        0,
        ...this._cachedHuffmanTables
      );
    }
    let length = 0;
    for (let segment of this._segments) {
      length += segment.length;
    }
    let data = new Uint8Array(length);
    length = 0;
    for (let segment of this._segments) {
      data.set(segment, length);
      length += segment.length;
    }
    display.imageRect(x, y, width, height, "image/jpeg", data);
    if (huffmanTables.length !== 0) {
      this._cachedHuffmanTables = huffmanTables;
    }
    if (quantTables.length !== 0) {
      this._cachedQuantTables = quantTables;
    }
    this._segments = [];
    return true;
  }
  _readSegment(sock) {
    if (sock.rQwait("JPEG", 2)) {
      return null;
    }
    let marker = sock.rQshift8();
    if (marker != 255) {
      throw new Error("Illegal JPEG marker received (byte: " + marker + ")");
    }
    let type = sock.rQshift8();
    if (type >= 208 && type <= 217 || type == 1) {
      return new Uint8Array([marker, type]);
    }
    if (sock.rQwait("JPEG", 2, 2)) {
      return null;
    }
    let length = sock.rQshift16();
    if (length < 2) {
      throw new Error("Illegal JPEG length received (length: " + length + ")");
    }
    if (sock.rQwait("JPEG", length - 2, 4)) {
      return null;
    }
    let extra = 0;
    if (type === 218) {
      if (sock.rQwait("JPEG", length - 2 + 2, 4)) {
        return null;
      }
      let len = sock.rQlen();
      let data = sock.rQpeekBytes(len, false);
      while (true) {
        let idx = data.indexOf(255, length - 2 + extra);
        if (idx === -1) {
          sock.rQwait("JPEG", Infinity, 4);
          return null;
        }
        if (idx === len - 1) {
          sock.rQwait("JPEG", Infinity, 4);
          return null;
        }
        if (data.at(idx + 1) === 0 || data.at(idx + 1) >= 208 && data.at(idx + 1) <= 215) {
          extra = idx + 2 - (length - 2);
          continue;
        }
        extra = idx - (length - 2);
        break;
      }
    }
    let segment = new Uint8Array(2 + length + extra);
    segment[0] = marker;
    segment[1] = type;
    segment[2] = length >> 8;
    segment[3] = length;
    segment.set(sock.rQshiftBytes(length - 2 + extra, false), 4);
    return segment;
  }
};

// core/decoders/h264.js
var H264Parser = class {
  constructor(data) {
    this._data = data;
    this._index = 0;
    this.profileIdc = null;
    this.constraintSet = null;
    this.levelIdc = null;
  }
  _getStartSequenceLen(index) {
    let data = this._data;
    if (data[index + 0] == 0 && data[index + 1] == 0 && data[index + 2] == 0 && data[index + 3] == 1) {
      return 4;
    }
    if (data[index + 0] == 0 && data[index + 1] == 0 && data[index + 2] == 1) {
      return 3;
    }
    return 0;
  }
  _indexOfNextNalUnit(index) {
    let data = this._data;
    for (let i = index; i < data.length; ++i) {
      if (this._getStartSequenceLen(i) != 0) {
        return i;
      }
    }
    return -1;
  }
  _parseSps(index) {
    this.profileIdc = this._data[index];
    this.constraintSet = this._data[index + 1];
    this.levelIdc = this._data[index + 2];
  }
  _parseNalUnit(index) {
    const firstByte = this._data[index];
    if (firstByte & 128) {
      throw new Error("H264 parsing sanity check failed, forbidden zero bit is set");
    }
    const unitType = firstByte & 31;
    switch (unitType) {
      case 1:
        return { slice: true };
      case 5:
        return { slice: true, key: true };
      case 6:
        return {};
      case 7:
        this._parseSps(index + 1);
        return {};
      case 8:
        return {};
      default:
        Warn("Unhandled unit type: ", unitType);
        break;
    }
    return {};
  }
  parse() {
    const startIndex = this._index;
    let isKey = false;
    while (this._index < this._data.length) {
      const startSequenceLen = this._getStartSequenceLen(this._index);
      if (startSequenceLen == 0) {
        throw new Error("Invalid start sequence in bit stream");
      }
      const { slice, key } = this._parseNalUnit(this._index + startSequenceLen);
      let nextIndex = this._indexOfNextNalUnit(this._index + startSequenceLen);
      if (nextIndex == -1) {
        this._index = this._data.length;
      } else {
        this._index = nextIndex;
      }
      if (key) {
        isKey = true;
      }
      if (slice) {
        break;
      }
    }
    if (startIndex === this._index) {
      return null;
    }
    return {
      frame: this._data.subarray(startIndex, this._index),
      key: isKey
    };
  }
};
var H264Context = class {
  constructor(width, height) {
    this.lastUsed = 0;
    this._width = width;
    this._height = height;
    this._profileIdc = null;
    this._constraintSet = null;
    this._levelIdc = null;
    this._decoder = null;
    this._pendingFrames = [];
  }
  _handleFrame(frame) {
    let pending = this._pendingFrames.shift();
    if (pending === void 0) {
      throw new Error("Pending frame queue empty when receiving frame from decoder");
    }
    if (pending.timestamp != frame.timestamp) {
      throw new Error("Video frame timestamp mismatch. Expected " + frame.timestamp + " but but got " + pending.timestamp);
    }
    pending.frame = frame;
    pending.ready = true;
    pending.resolve();
    if (!pending.keep) {
      frame.close();
    }
  }
  _handleError(e2) {
    throw new Error("Failed to decode frame: " + e2.message);
  }
  _configureDecoder(profileIdc, constraintSet, levelIdc) {
    if (this._decoder === null || this._decoder.state === "closed") {
      this._decoder = new VideoDecoder({
        output: (frame) => this._handleFrame(frame),
        error: (e2) => this._handleError(e2)
      });
    }
    const codec = "avc1." + profileIdc.toString(16).padStart(2, "0") + constraintSet.toString(16).padStart(2, "0") + levelIdc.toString(16).padStart(2, "0");
    this._decoder.configure({
      codec,
      codedWidth: this._width,
      codedHeight: this._height,
      optimizeForLatency: true
    });
  }
  _preparePendingFrame(timestamp) {
    let pending = {
      timestamp,
      promise: null,
      resolve: null,
      frame: null,
      ready: false,
      keep: false
    };
    pending.promise = new Promise((resolve) => {
      pending.resolve = resolve;
    });
    this._pendingFrames.push(pending);
    return pending;
  }
  decode(payload) {
    let parser = new H264Parser(payload);
    let result = null;
    let timestamp = Math.round(window.performance.now() * 1e3);
    while (true) {
      let encodedFrame = parser.parse();
      if (encodedFrame === null) {
        break;
      }
      if (parser.profileIdc !== null) {
        self._profileIdc = parser.profileIdc;
        self._constraintSet = parser.constraintSet;
        self._levelIdc = parser.levelIdc;
      }
      if (this._decoder === null || this._decoder.state !== "configured") {
        if (!encodedFrame.key) {
          Warn("Missing key frame. Can't decode until one arrives");
          continue;
        }
        if (self._profileIdc === null) {
          Warn("Cannot config decoder. Have not received SPS and PPS yet.");
          continue;
        }
        this._configureDecoder(
          self._profileIdc,
          self._constraintSet,
          self._levelIdc
        );
      }
      result = this._preparePendingFrame(timestamp);
      const chunk = new EncodedVideoChunk({
        timestamp,
        type: encodedFrame.key ? "key" : "delta",
        data: encodedFrame.frame
      });
      try {
        this._decoder.decode(chunk);
      } catch (e2) {
        Warn("Failed to decode:", e2);
      }
    }
    if (result !== null) {
      result.keep = true;
    }
    return result;
  }
};
var H264Decoder = class {
  constructor() {
    this._tick = 0;
    this._contexts = {};
  }
  _contextId(x, y, width, height) {
    return [x, y, width, height].join(",");
  }
  _findOldestContextId() {
    let oldestTick = Number.MAX_VALUE;
    let oldestKey = void 0;
    for (const [key, value] of Object.entries(this._contexts)) {
      if (value.lastUsed < oldestTick) {
        oldestTick = value.lastUsed;
        oldestKey = key;
      }
    }
    return oldestKey;
  }
  _createContext(x, y, width, height) {
    const maxContexts = 64;
    if (Object.keys(this._contexts).length >= maxContexts) {
      let oldestContextId = this._findOldestContextId();
      delete this._contexts[oldestContextId];
    }
    let context = new H264Context(width, height);
    this._contexts[this._contextId(x, y, width, height)] = context;
    return context;
  }
  _getContext(x, y, width, height) {
    let context = this._contexts[this._contextId(x, y, width, height)];
    return context !== void 0 ? context : this._createContext(x, y, width, height);
  }
  _resetContext(x, y, width, height) {
    delete this._contexts[this._contextId(x, y, width, height)];
  }
  _resetAllContexts() {
    this._contexts = {};
  }
  decodeRect(x, y, width, height, sock, display, depth) {
    const resetContextFlag = 1;
    const resetAllContextsFlag = 2;
    if (sock.rQwait("h264 header", 8)) {
      return false;
    }
    const length = sock.rQshift32();
    const flags = sock.rQshift32();
    if (sock.rQwait("h264 payload", length, 8)) {
      return false;
    }
    if (flags & resetAllContextsFlag) {
      this._resetAllContexts();
    } else if (flags & resetContextFlag) {
      this._resetContext(x, y, width, height);
    }
    let context = this._getContext(x, y, width, height);
    context.lastUsed = this._tick++;
    if (length !== 0) {
      let payload = sock.rQshiftBytes(length, false);
      let frame = context.decode(payload);
      if (frame !== null) {
        display.videoFrame(x, y, width, height, frame);
      }
    }
    return true;
  }
};

// core/rfb.js
var DISCONNECT_TIMEOUT = 3;
var DEFAULT_BACKGROUND = "rgb(40, 40, 40)";
var MOUSE_MOVE_DELAY = 17;
var WHEEL_STEP = 50;
var WHEEL_LINE_HEIGHT = 19;
var GESTURE_ZOOMSENS = 75;
var GESTURE_SCRLSENS = 50;
var DOUBLE_TAP_TIMEOUT = 1e3;
var DOUBLE_TAP_THRESHOLD = 50;
var securityTypeNone = 1;
var securityTypeVNCAuth = 2;
var securityTypeRA2ne = 6;
var securityTypeTight = 16;
var securityTypeVeNCrypt = 19;
var securityTypeXVP = 22;
var securityTypeARD = 30;
var securityTypeMSLogonII = 113;
var securityTypeUnixLogon = 129;
var securityTypePlain = 256;
var extendedClipboardFormatText = 1;
var extendedClipboardFormatRtf = 1 << 1;
var extendedClipboardFormatHtml = 1 << 2;
var extendedClipboardFormatDib = 1 << 3;
var extendedClipboardFormatFiles = 1 << 4;
var extendedClipboardActionCaps = 1 << 24;
var extendedClipboardActionRequest = 1 << 25;
var extendedClipboardActionPeek = 1 << 26;
var extendedClipboardActionNotify = 1 << 27;
var extendedClipboardActionProvide = 1 << 28;
var RFB = class _RFB extends EventTargetMixin {
  constructor(target, urlOrChannel, options) {
    if (!target) {
      throw new Error("Must specify target");
    }
    if (!urlOrChannel) {
      throw new Error("Must specify URL, WebSocket or RTCDataChannel");
    }
    if (!window.isSecureContext) {
      Error2("noVNC requires a secure context (TLS). Expect crashes!");
    }
    super();
    this._target = target;
    if (typeof urlOrChannel === "string") {
      this._url = urlOrChannel;
    } else {
      this._url = null;
      this._rawChannel = urlOrChannel;
    }
    options = options || {};
    this._rfbCredentials = options.credentials || {};
    this._shared = "shared" in options ? !!options.shared : true;
    this._repeaterID = options.repeaterID || "";
    this._wsProtocols = options.wsProtocols || [];
    this._rfbConnectionState = "";
    this._rfbInitState = "";
    this._rfbAuthScheme = -1;
    this._rfbCleanDisconnect = true;
    this._rfbRSAAESAuthenticationState = null;
    this._rfbVersion = 0;
    this._rfbMaxVersion = 3.8;
    this._rfbTightVNC = false;
    this._rfbVeNCryptState = 0;
    this._rfbXvpVer = 0;
    this._fbWidth = 0;
    this._fbHeight = 0;
    this._fbName = "";
    this._capabilities = { power: false };
    this._supportsFence = false;
    this._supportsContinuousUpdates = false;
    this._enabledContinuousUpdates = false;
    this._supportsSetDesktopSize = false;
    this._screenID = 0;
    this._screenFlags = 0;
    this._pendingRemoteResize = false;
    this._lastResize = 0;
    this._qemuExtKeyEventSupported = false;
    this._extendedPointerEventSupported = false;
    this._clipboardText = null;
    this._clipboardServerCapabilitiesActions = {};
    this._clipboardServerCapabilitiesFormats = {};
    this._sock = null;
    this._display = null;
    this._flushing = false;
    this._asyncClipboard = null;
    this._keyboard = null;
    this._gestures = null;
    this._resizeObserver = null;
    this._disconnTimer = null;
    this._resizeTimeout = null;
    this._mouseMoveTimer = null;
    this._decoders = {};
    this._FBU = {
      rects: 0,
      x: 0,
      y: 0,
      width: 0,
      height: 0,
      encoding: null
    };
    this._mousePos = {};
    this._mouseButtonMask = 0;
    this._mouseLastMoveTime = 0;
    this._viewportDragging = false;
    this._viewportDragPos = {};
    this._viewportHasMoved = false;
    this._accumulatedWheelDeltaX = 0;
    this._accumulatedWheelDeltaY = 0;
    this._gestureLastTapTime = null;
    this._gestureFirstDoubleTapEv = null;
    this._gestureLastMagnitudeX = 0;
    this._gestureLastMagnitudeY = 0;
    this._eventHandlers = {
      focusCanvas: this._focusCanvas.bind(this),
      handleResize: this._handleResize.bind(this),
      handleMouse: this._handleMouse.bind(this),
      handleWheel: this._handleWheel.bind(this),
      handleGesture: this._handleGesture.bind(this),
      handleRSAAESCredentialsRequired: this._handleRSAAESCredentialsRequired.bind(this),
      handleRSAAESServerVerification: this._handleRSAAESServerVerification.bind(this)
    };
    Debug(">> RFB.constructor");
    this._screen = document.createElement("div");
    this._screen.style.display = "flex";
    this._screen.style.width = "100%";
    this._screen.style.height = "100%";
    this._screen.style.overflow = "auto";
    this._screen.style.background = DEFAULT_BACKGROUND;
    this._canvas = document.createElement("canvas");
    this._canvas.style.margin = "auto";
    this._canvas.style.outline = "none";
    this._canvas.width = 0;
    this._canvas.height = 0;
    this._canvas.tabIndex = -1;
    this._screen.appendChild(this._canvas);
    this._cursor = new Cursor();
    this._cursorImage = _RFB.cursors.none;
    this._decoders[encodings.encodingRaw] = new RawDecoder();
    this._decoders[encodings.encodingCopyRect] = new CopyRectDecoder();
    this._decoders[encodings.encodingRRE] = new RREDecoder();
    this._decoders[encodings.encodingHextile] = new HextileDecoder();
    this._decoders[encodings.encodingZlib] = new ZlibDecoder();
    this._decoders[encodings.encodingTight] = new TightDecoder();
    this._decoders[encodings.encodingTightPNG] = new TightPNGDecoder();
    this._decoders[encodings.encodingZRLE] = new ZRLEDecoder();
    this._decoders[encodings.encodingJPEG] = new JPEGDecoder();
    this._decoders[encodings.encodingH264] = new H264Decoder();
    try {
      this._display = new Display(this._canvas);
    } catch (exc) {
      Error2("Display exception: " + exc);
      throw exc;
    }
    this._asyncClipboard = new AsyncClipboard(this._canvas);
    this._asyncClipboard.onpaste = this.clipboardPasteFrom.bind(this);
    this._keyboard = new Keyboard(this._canvas);
    this._keyboard.onkeyevent = this._handleKeyEvent.bind(this);
    this._remoteCapsLock = null;
    this._remoteNumLock = null;
    this._gestures = new GestureHandler();
    this._sock = new Websock();
    this._sock.on("open", this._socketOpen.bind(this));
    this._sock.on("close", this._socketClose.bind(this));
    this._sock.on("message", this._handleMessage.bind(this));
    this._sock.on("error", this._socketError.bind(this));
    this._expectedClientWidth = null;
    this._expectedClientHeight = null;
    this._resizeObserver = new ResizeObserver(this._eventHandlers.handleResize);
    this._updateConnectionState("connecting");
    Debug("<< RFB.constructor");
    this.dragViewport = false;
    this.focusOnClick = true;
    this._viewOnly = false;
    this._clipViewport = false;
    this._clippingViewport = false;
    this._scaleViewport = false;
    this._resizeSession = false;
    this._showDotCursor = false;
    this._qualityLevel = 6;
    this._compressionLevel = 2;
  }
  // ===== PROPERTIES =====
  get viewOnly() {
    return this._viewOnly;
  }
  set viewOnly(viewOnly) {
    this._viewOnly = viewOnly;
    if (this._rfbConnectionState === "connecting" || this._rfbConnectionState === "connected") {
      if (viewOnly) {
        this._keyboard.ungrab();
        this._asyncClipboard.ungrab();
      } else {
        this._keyboard.grab();
        this._asyncClipboard.grab();
      }
    }
  }
  get capabilities() {
    return this._capabilities;
  }
  get clippingViewport() {
    return this._clippingViewport;
  }
  _setClippingViewport(on) {
    if (on === this._clippingViewport) {
      return;
    }
    this._clippingViewport = on;
    this.dispatchEvent(new CustomEvent(
      "clippingviewport",
      { detail: this._clippingViewport }
    ));
  }
  get touchButton() {
    return 0;
  }
  set touchButton(button) {
    Warn("Using old API!");
  }
  get clipViewport() {
    return this._clipViewport;
  }
  set clipViewport(viewport) {
    this._clipViewport = viewport;
    this._updateClip();
  }
  get scaleViewport() {
    return this._scaleViewport;
  }
  set scaleViewport(scale) {
    this._scaleViewport = scale;
    if (scale && this._clipViewport) {
      this._updateClip();
    }
    this._updateScale();
    if (!scale && this._clipViewport) {
      this._updateClip();
    }
  }
  get resizeSession() {
    return this._resizeSession;
  }
  set resizeSession(resize) {
    this._resizeSession = resize;
    if (resize) {
      this._requestRemoteResize();
    }
  }
  get showDotCursor() {
    return this._showDotCursor;
  }
  set showDotCursor(show) {
    this._showDotCursor = show;
    this._refreshCursor();
  }
  get background() {
    return this._screen.style.background;
  }
  set background(cssValue) {
    this._screen.style.background = cssValue;
  }
  get qualityLevel() {
    return this._qualityLevel;
  }
  set qualityLevel(qualityLevel) {
    if (!Number.isInteger(qualityLevel) || qualityLevel < 0 || qualityLevel > 9) {
      Error2("qualityLevel must be an integer between 0 and 9");
      return;
    }
    if (this._qualityLevel === qualityLevel) {
      return;
    }
    this._qualityLevel = qualityLevel;
    if (this._rfbConnectionState === "connected") {
      this._sendEncodings();
    }
  }
  get compressionLevel() {
    return this._compressionLevel;
  }
  set compressionLevel(compressionLevel) {
    if (!Number.isInteger(compressionLevel) || compressionLevel < 0 || compressionLevel > 9) {
      Error2("compressionLevel must be an integer between 0 and 9");
      return;
    }
    if (this._compressionLevel === compressionLevel) {
      return;
    }
    this._compressionLevel = compressionLevel;
    if (this._rfbConnectionState === "connected") {
      this._sendEncodings();
    }
  }
  // ===== PUBLIC METHODS =====
  disconnect() {
    this._updateConnectionState("disconnecting");
    this._sock.off("error");
    this._sock.off("message");
    this._sock.off("open");
    if (this._rfbRSAAESAuthenticationState !== null) {
      this._rfbRSAAESAuthenticationState.disconnect();
    }
  }
  approveServer() {
    if (this._rfbRSAAESAuthenticationState !== null) {
      this._rfbRSAAESAuthenticationState.approveServer();
    }
  }
  sendCredentials(creds) {
    this._rfbCredentials = creds;
    this._resumeAuthentication();
  }
  sendCtrlAltDel() {
    if (this._rfbConnectionState !== "connected" || this._viewOnly) {
      return;
    }
    Info("Sending Ctrl-Alt-Del");
    this.sendKey(keysym_default.XK_Control_L, "ControlLeft", true);
    this.sendKey(keysym_default.XK_Alt_L, "AltLeft", true);
    this.sendKey(keysym_default.XK_Delete, "Delete", true);
    this.sendKey(keysym_default.XK_Delete, "Delete", false);
    this.sendKey(keysym_default.XK_Alt_L, "AltLeft", false);
    this.sendKey(keysym_default.XK_Control_L, "ControlLeft", false);
  }
  machineShutdown() {
    this._xvpOp(1, 2);
  }
  machineReboot() {
    this._xvpOp(1, 3);
  }
  machineReset() {
    this._xvpOp(1, 4);
  }
  // Send a key press. If 'down' is not specified then send a down key
  // followed by an up key.
  sendKey(keysym, code, down) {
    if (this._rfbConnectionState !== "connected" || this._viewOnly) {
      return;
    }
    if (down === void 0) {
      this.sendKey(keysym, code, true);
      this.sendKey(keysym, code, false);
      return;
    }
    const scancode = xtscancodes_default[code];
    if (this._qemuExtKeyEventSupported && scancode) {
      keysym = keysym || 0;
      Info("Sending key (" + (down ? "down" : "up") + "): keysym " + keysym + ", scancode " + scancode);
      _RFB.messages.QEMUExtendedKeyEvent(this._sock, keysym, down, scancode);
    } else {
      if (!keysym) {
        return;
      }
      Info("Sending keysym (" + (down ? "down" : "up") + "): " + keysym);
      _RFB.messages.keyEvent(this._sock, keysym, down ? 1 : 0);
    }
  }
  focus(options) {
    this._canvas.focus(options);
  }
  blur() {
    this._canvas.blur();
  }
  clipboardPasteFrom(text) {
    if (this._rfbConnectionState !== "connected" || this._viewOnly) {
      return;
    }
    if (this._clipboardServerCapabilitiesFormats[extendedClipboardFormatText] && this._clipboardServerCapabilitiesActions[extendedClipboardActionNotify]) {
      this._clipboardText = text;
      _RFB.messages.extendedClipboardNotify(this._sock, [extendedClipboardFormatText]);
    } else {
      let length, i;
      let data;
      length = 0;
      for (let codePoint of text) {
        length++;
      }
      data = new Uint8Array(length);
      i = 0;
      for (let codePoint of text) {
        let code = codePoint.codePointAt(0);
        if (code > 255) {
          code = 63;
        }
        data[i++] = code;
      }
      _RFB.messages.clientCutText(this._sock, data);
    }
  }
  getImageData() {
    return this._display.getImageData();
  }
  toDataURL(type, encoderOptions) {
    return this._display.toDataURL(type, encoderOptions);
  }
  toBlob(callback, type, quality) {
    return this._display.toBlob(callback, type, quality);
  }
  // ===== PRIVATE METHODS =====
  _connect() {
    Debug(">> RFB.connect");
    if (this._url) {
      Info(`connecting to ${this._url}`);
      this._sock.open(this._url, this._wsProtocols);
    } else {
      Info(`attaching ${this._rawChannel} to Websock`);
      this._sock.attach(this._rawChannel);
      if (this._sock.readyState === "closed") {
        throw Error("Cannot use already closed WebSocket/RTCDataChannel");
      }
      if (this._sock.readyState === "open") {
        this._socketOpen();
      }
    }
    this._target.appendChild(this._screen);
    this._gestures.attach(this._canvas);
    this._cursor.attach(this._canvas);
    this._refreshCursor();
    this._resizeObserver.observe(this._screen);
    this._canvas.addEventListener("mousedown", this._eventHandlers.focusCanvas);
    this._canvas.addEventListener("touchstart", this._eventHandlers.focusCanvas);
    this._canvas.addEventListener("mousedown", this._eventHandlers.handleMouse);
    this._canvas.addEventListener("mouseup", this._eventHandlers.handleMouse);
    this._canvas.addEventListener("mousemove", this._eventHandlers.handleMouse);
    this._canvas.addEventListener("click", this._eventHandlers.handleMouse);
    this._canvas.addEventListener("contextmenu", this._eventHandlers.handleMouse);
    this._canvas.addEventListener("wheel", this._eventHandlers.handleWheel);
    this._canvas.addEventListener("gesturestart", this._eventHandlers.handleGesture);
    this._canvas.addEventListener("gesturemove", this._eventHandlers.handleGesture);
    this._canvas.addEventListener("gestureend", this._eventHandlers.handleGesture);
    Debug("<< RFB.connect");
  }
  _disconnect() {
    Debug(">> RFB.disconnect");
    this._cursor.detach();
    this._canvas.removeEventListener("gesturestart", this._eventHandlers.handleGesture);
    this._canvas.removeEventListener("gesturemove", this._eventHandlers.handleGesture);
    this._canvas.removeEventListener("gestureend", this._eventHandlers.handleGesture);
    this._canvas.removeEventListener("wheel", this._eventHandlers.handleWheel);
    this._canvas.removeEventListener("mousedown", this._eventHandlers.handleMouse);
    this._canvas.removeEventListener("mouseup", this._eventHandlers.handleMouse);
    this._canvas.removeEventListener("mousemove", this._eventHandlers.handleMouse);
    this._canvas.removeEventListener("click", this._eventHandlers.handleMouse);
    this._canvas.removeEventListener("contextmenu", this._eventHandlers.handleMouse);
    this._canvas.removeEventListener("mousedown", this._eventHandlers.focusCanvas);
    this._canvas.removeEventListener("touchstart", this._eventHandlers.focusCanvas);
    this._resizeObserver.disconnect();
    this._keyboard.ungrab();
    this._gestures.detach();
    this._sock.close();
    try {
      this._target.removeChild(this._screen);
    } catch (e2) {
      if (e2.name === "NotFoundError") {
      } else {
        throw e2;
      }
    }
    clearTimeout(this._resizeTimeout);
    clearTimeout(this._mouseMoveTimer);
    Debug("<< RFB.disconnect");
  }
  _socketOpen() {
    if (this._rfbConnectionState === "connecting" && this._rfbInitState === "") {
      this._rfbInitState = "ProtocolVersion";
      Debug("Starting VNC handshake");
    } else {
      this._fail("Unexpected server connection while " + this._rfbConnectionState);
    }
  }
  _socketClose(e2) {
    Debug("WebSocket on-close event");
    let msg = "";
    if (e2.code) {
      msg = "(code: " + e2.code;
      if (e2.reason) {
        msg += ", reason: " + e2.reason;
      }
      msg += ")";
    }
    switch (this._rfbConnectionState) {
      case "connecting":
        this._fail("Connection closed " + msg);
        break;
      case "connected":
        this._updateConnectionState("disconnecting");
        this._updateConnectionState("disconnected");
        break;
      case "disconnecting":
        this._updateConnectionState("disconnected");
        break;
      case "disconnected":
        this._fail("Unexpected server disconnect when already disconnected " + msg);
        break;
      default:
        this._fail("Unexpected server disconnect before connecting " + msg);
        break;
    }
    this._sock.off("close");
    this._rawChannel = null;
  }
  _socketError(e2) {
    Warn("WebSocket on-error event");
  }
  _focusCanvas(event) {
    if (!this.focusOnClick) {
      return;
    }
    this.focus({ preventScroll: true });
  }
  _setDesktopName(name) {
    this._fbName = name;
    this.dispatchEvent(new CustomEvent(
      "desktopname",
      { detail: { name: this._fbName } }
    ));
  }
  _saveExpectedClientSize() {
    this._expectedClientWidth = this._screen.clientWidth;
    this._expectedClientHeight = this._screen.clientHeight;
  }
  _currentClientSize() {
    return [this._screen.clientWidth, this._screen.clientHeight];
  }
  _clientHasExpectedSize() {
    const [currentWidth, currentHeight] = this._currentClientSize();
    return currentWidth == this._expectedClientWidth && currentHeight == this._expectedClientHeight;
  }
  // Handle browser window resizes
  _handleResize() {
    if (this._clientHasExpectedSize()) {
      return;
    }
    window.requestAnimationFrame(() => {
      this._updateClip();
      this._updateScale();
      this._saveExpectedClientSize();
    });
    this._requestRemoteResize();
  }
  // Update state of clipping in Display object, and make sure the
  // configured viewport matches the current screen size
  _updateClip() {
    const curClip = this._display.clipViewport;
    let newClip = this._clipViewport;
    if (this._scaleViewport) {
      newClip = false;
    }
    if (curClip !== newClip) {
      this._display.clipViewport = newClip;
    }
    if (newClip) {
      const size = this._screenSize();
      this._display.viewportChangeSize(size.w, size.h);
      this._fixScrollbars();
      this._setClippingViewport(size.w < this._display.width || size.h < this._display.height);
    } else {
      this._setClippingViewport(false);
    }
    if (curClip !== newClip) {
      this._saveExpectedClientSize();
    }
  }
  _updateScale() {
    if (!this._scaleViewport) {
      this._display.scale = 1;
    } else {
      const size = this._screenSize();
      this._display.autoscale(size.w, size.h);
    }
    this._fixScrollbars();
  }
  // Requests a change of remote desktop size. This message is an extension
  // and may only be sent if we have received an ExtendedDesktopSize message
  _requestRemoteResize() {
    if (!this._resizeSession) {
      return;
    }
    if (this._viewOnly) {
      return;
    }
    if (!this._supportsSetDesktopSize) {
      return;
    }
    if (this._pendingRemoteResize) {
      return;
    }
    if (Date.now() - this._lastResize < 100) {
      clearTimeout(this._resizeTimeout);
      this._resizeTimeout = setTimeout(
        this._requestRemoteResize.bind(this),
        100 - (Date.now() - this._lastResize)
      );
      return;
    }
    this._resizeTimeout = null;
    const size = this._screenSize();
    if (size.w === this._fbWidth && size.h === this._fbHeight) {
      return;
    }
    this._pendingRemoteResize = true;
    this._lastResize = Date.now();
    _RFB.messages.setDesktopSize(
      this._sock,
      Math.floor(size.w),
      Math.floor(size.h),
      this._screenID,
      this._screenFlags
    );
    Debug("Requested new desktop size: " + size.w + "x" + size.h);
  }
  // Gets the the size of the available screen
  _screenSize() {
    let r = this._screen.getBoundingClientRect();
    return { w: r.width, h: r.height };
  }
  _fixScrollbars() {
    const orig = this._screen.style.overflow;
    this._screen.style.overflow = "hidden";
    this._screen.getBoundingClientRect();
    this._screen.style.overflow = orig;
  }
  /*
   * Connection states:
   *   connecting
   *   connected
   *   disconnecting
   *   disconnected - permanent state
   */
  _updateConnectionState(state) {
    const oldstate = this._rfbConnectionState;
    if (state === oldstate) {
      Debug("Already in state '" + state + "', ignoring");
      return;
    }
    if (oldstate === "disconnected") {
      Error2("Tried changing state of a disconnected RFB object");
      return;
    }
    switch (state) {
      case "connected":
        if (oldstate !== "connecting") {
          Error2("Bad transition to connected state, previous connection state: " + oldstate);
          return;
        }
        break;
      case "disconnected":
        if (oldstate !== "disconnecting") {
          Error2("Bad transition to disconnected state, previous connection state: " + oldstate);
          return;
        }
        break;
      case "connecting":
        if (oldstate !== "") {
          Error2("Bad transition to connecting state, previous connection state: " + oldstate);
          return;
        }
        break;
      case "disconnecting":
        if (oldstate !== "connected" && oldstate !== "connecting") {
          Error2("Bad transition to disconnecting state, previous connection state: " + oldstate);
          return;
        }
        break;
      default:
        Error2("Unknown connection state: " + state);
        return;
    }
    this._rfbConnectionState = state;
    Debug("New state '" + state + "', was '" + oldstate + "'.");
    if (this._disconnTimer && state !== "disconnecting") {
      Debug("Clearing disconnect timer");
      clearTimeout(this._disconnTimer);
      this._disconnTimer = null;
      this._sock.off("close");
    }
    switch (state) {
      case "connecting":
        this._connect();
        break;
      case "connected":
        this.dispatchEvent(new CustomEvent("connect", { detail: {} }));
        break;
      case "disconnecting":
        this._disconnect();
        this._disconnTimer = setTimeout(() => {
          Error2("Disconnection timed out.");
          this._updateConnectionState("disconnected");
        }, DISCONNECT_TIMEOUT * 1e3);
        break;
      case "disconnected":
        this.dispatchEvent(new CustomEvent(
          "disconnect",
          { detail: { clean: this._rfbCleanDisconnect } }
        ));
        break;
    }
  }
  /* Print errors and disconnect
   *
   * The parameter 'details' is used for information that
   * should be logged but not sent to the user interface.
   */
  _fail(details) {
    switch (this._rfbConnectionState) {
      case "disconnecting":
        Error2("Failed when disconnecting: " + details);
        break;
      case "connected":
        Error2("Failed while connected: " + details);
        break;
      case "connecting":
        Error2("Failed when connecting: " + details);
        break;
      default:
        Error2("RFB failure: " + details);
        break;
    }
    this._rfbCleanDisconnect = false;
    this._updateConnectionState("disconnecting");
    this._updateConnectionState("disconnected");
    return false;
  }
  _setCapability(cap, val) {
    this._capabilities[cap] = val;
    this.dispatchEvent(new CustomEvent(
      "capabilities",
      { detail: { capabilities: this._capabilities } }
    ));
  }
  _handleMessage() {
    if (this._sock.rQwait("message", 1)) {
      Warn("handleMessage called on an empty receive queue");
      return;
    }
    switch (this._rfbConnectionState) {
      case "disconnected":
        Error2("Got data while disconnected");
        break;
      case "connected":
        while (true) {
          if (this._flushing) {
            break;
          }
          if (!this._normalMsg()) {
            break;
          }
          if (this._sock.rQwait("message", 1)) {
            break;
          }
        }
        break;
      case "connecting":
        while (this._rfbConnectionState === "connecting") {
          if (!this._initMsg()) {
            break;
          }
        }
        break;
      default:
        Error2("Got data while in an invalid state");
        break;
    }
  }
  _handleKeyEvent(keysym, code, down, numlock, capslock) {
    if (code == "CapsLock" && down) {
      this._remoteCapsLock = null;
    }
    if (this._remoteCapsLock !== null && capslock !== null && this._remoteCapsLock !== capslock && down) {
      Debug("Fixing remote caps lock");
      this.sendKey(keysym_default.XK_Caps_Lock, "CapsLock", true);
      this.sendKey(keysym_default.XK_Caps_Lock, "CapsLock", false);
      this._remoteCapsLock = null;
    }
    if (code == "NumLock" && down) {
      this._remoteNumLock = null;
    }
    if (this._remoteNumLock !== null && numlock !== null && this._remoteNumLock !== numlock && down) {
      Debug("Fixing remote num lock");
      this.sendKey(keysym_default.XK_Num_Lock, "NumLock", true);
      this.sendKey(keysym_default.XK_Num_Lock, "NumLock", false);
      this._remoteNumLock = null;
    }
    this.sendKey(keysym, code, down);
  }
  static _convertButtonMask(buttons) {
    const buttonMaskMap = {
      0: 1 << 0,
      // Left
      1: 1 << 2,
      // Right
      2: 1 << 1,
      // Middle
      3: 1 << 7,
      // Back
      4: 1 << 8
      // Forward
    };
    let bmask = 0;
    for (let i = 0; i < 5; i++) {
      if (buttons & 1 << i) {
        bmask |= buttonMaskMap[i];
      }
    }
    return bmask;
  }
  _handleMouse(ev) {
    if (ev.type === "click") {
      if (ev.target !== this._canvas) {
        return;
      }
    }
    ev.stopPropagation();
    ev.preventDefault();
    if (ev.type === "click" || ev.type === "contextmenu") {
      return;
    }
    let pos = clientToElement(
      ev.clientX,
      ev.clientY,
      this._canvas
    );
    let bmask = _RFB._convertButtonMask(ev.buttons);
    let down = ev.type == "mousedown";
    switch (ev.type) {
      case "mousedown":
      case "mouseup":
        if (this.dragViewport) {
          if (down && !this._viewportDragging) {
            this._viewportDragging = true;
            this._viewportDragPos = { "x": pos.x, "y": pos.y };
            this._viewportHasMoved = false;
            this._flushMouseMoveTimer(pos.x, pos.y);
            this._mouseButtonMask = bmask;
            break;
          } else {
            this._viewportDragging = false;
            if (this._viewportHasMoved) {
              this._mouseButtonMask = bmask;
              break;
            }
            this._sendMouse(pos.x, pos.y, this._mouseButtonMask);
          }
        }
        if (down) {
          setCapture(this._canvas);
        }
        this._handleMouseButton(pos.x, pos.y, bmask);
        break;
      case "mousemove":
        if (this._viewportDragging) {
          const deltaX = this._viewportDragPos.x - pos.x;
          const deltaY = this._viewportDragPos.y - pos.y;
          if (this._viewportHasMoved || (Math.abs(deltaX) > dragThreshold || Math.abs(deltaY) > dragThreshold)) {
            this._viewportHasMoved = true;
            this._viewportDragPos = { "x": pos.x, "y": pos.y };
            this._display.viewportChangePos(deltaX, deltaY);
          }
          break;
        }
        this._handleMouseMove(pos.x, pos.y);
        break;
    }
  }
  _handleMouseButton(x, y, bmask) {
    this._flushMouseMoveTimer(x, y);
    this._mouseButtonMask = bmask;
    this._sendMouse(x, y, this._mouseButtonMask);
  }
  _handleMouseMove(x, y) {
    this._mousePos = { "x": x, "y": y };
    if (this._mouseMoveTimer == null) {
      const timeSinceLastMove = Date.now() - this._mouseLastMoveTime;
      if (timeSinceLastMove > MOUSE_MOVE_DELAY) {
        this._sendMouse(x, y, this._mouseButtonMask);
        this._mouseLastMoveTime = Date.now();
      } else {
        this._mouseMoveTimer = setTimeout(() => {
          this._handleDelayedMouseMove();
        }, MOUSE_MOVE_DELAY - timeSinceLastMove);
      }
    }
  }
  _handleDelayedMouseMove() {
    this._mouseMoveTimer = null;
    this._sendMouse(
      this._mousePos.x,
      this._mousePos.y,
      this._mouseButtonMask
    );
    this._mouseLastMoveTime = Date.now();
  }
  _sendMouse(x, y, mask) {
    if (this._rfbConnectionState !== "connected") {
      return;
    }
    if (this._viewOnly) {
      return;
    }
    if (mask & 32768) {
      throw new Error("Illegal mouse button mask (mask: " + mask + ")");
    }
    let extendedMouseButtons = mask & 32640;
    if (this._extendedPointerEventSupported && extendedMouseButtons) {
      _RFB.messages.extendedPointerEvent(
        this._sock,
        this._display.absX(x),
        this._display.absY(y),
        mask
      );
    } else {
      _RFB.messages.pointerEvent(
        this._sock,
        this._display.absX(x),
        this._display.absY(y),
        mask
      );
    }
  }
  _handleWheel(ev) {
    if (this._rfbConnectionState !== "connected") {
      return;
    }
    if (this._viewOnly) {
      return;
    }
    ev.stopPropagation();
    ev.preventDefault();
    let pos = clientToElement(
      ev.clientX,
      ev.clientY,
      this._canvas
    );
    let bmask = _RFB._convertButtonMask(ev.buttons);
    let dX = ev.deltaX;
    let dY = ev.deltaY;
    if (ev.deltaMode !== 0) {
      dX *= WHEEL_LINE_HEIGHT;
      dY *= WHEEL_LINE_HEIGHT;
    }
    this._accumulatedWheelDeltaX += dX;
    this._accumulatedWheelDeltaY += dY;
    if (Math.abs(this._accumulatedWheelDeltaX) >= WHEEL_STEP) {
      if (this._accumulatedWheelDeltaX < 0) {
        this._handleMouseButton(pos.x, pos.y, bmask | 1 << 5);
        this._handleMouseButton(pos.x, pos.y, bmask);
      } else if (this._accumulatedWheelDeltaX > 0) {
        this._handleMouseButton(pos.x, pos.y, bmask | 1 << 6);
        this._handleMouseButton(pos.x, pos.y, bmask);
      }
      this._accumulatedWheelDeltaX = 0;
    }
    if (Math.abs(this._accumulatedWheelDeltaY) >= WHEEL_STEP) {
      if (this._accumulatedWheelDeltaY < 0) {
        this._handleMouseButton(pos.x, pos.y, bmask | 1 << 3);
        this._handleMouseButton(pos.x, pos.y, bmask);
      } else if (this._accumulatedWheelDeltaY > 0) {
        this._handleMouseButton(pos.x, pos.y, bmask | 1 << 4);
        this._handleMouseButton(pos.x, pos.y, bmask);
      }
      this._accumulatedWheelDeltaY = 0;
    }
  }
  _fakeMouseMove(ev, elementX, elementY) {
    this._handleMouseMove(elementX, elementY);
    this._cursor.move(ev.detail.clientX, ev.detail.clientY);
  }
  _handleTapEvent(ev, bmask) {
    let pos = clientToElement(
      ev.detail.clientX,
      ev.detail.clientY,
      this._canvas
    );
    if (this._gestureLastTapTime !== null && Date.now() - this._gestureLastTapTime < DOUBLE_TAP_TIMEOUT && this._gestureFirstDoubleTapEv.detail.type === ev.detail.type) {
      let dx = this._gestureFirstDoubleTapEv.detail.clientX - ev.detail.clientX;
      let dy = this._gestureFirstDoubleTapEv.detail.clientY - ev.detail.clientY;
      let distance = Math.hypot(dx, dy);
      if (distance < DOUBLE_TAP_THRESHOLD) {
        pos = clientToElement(
          this._gestureFirstDoubleTapEv.detail.clientX,
          this._gestureFirstDoubleTapEv.detail.clientY,
          this._canvas
        );
      } else {
        this._gestureFirstDoubleTapEv = ev;
      }
    } else {
      this._gestureFirstDoubleTapEv = ev;
    }
    this._gestureLastTapTime = Date.now();
    this._fakeMouseMove(this._gestureFirstDoubleTapEv, pos.x, pos.y);
    this._handleMouseButton(pos.x, pos.y, bmask);
    this._handleMouseButton(pos.x, pos.y, 0);
  }
  _handleGesture(ev) {
    let magnitude;
    let pos = clientToElement(
      ev.detail.clientX,
      ev.detail.clientY,
      this._canvas
    );
    switch (ev.type) {
      case "gesturestart":
        switch (ev.detail.type) {
          case "onetap":
            this._handleTapEvent(ev, 1);
            break;
          case "twotap":
            this._handleTapEvent(ev, 4);
            break;
          case "threetap":
            this._handleTapEvent(ev, 2);
            break;
          case "drag":
            if (this.dragViewport) {
              this._viewportHasMoved = false;
              this._viewportDragging = true;
              this._viewportDragPos = { "x": pos.x, "y": pos.y };
            } else {
              this._fakeMouseMove(ev, pos.x, pos.y);
              this._handleMouseButton(pos.x, pos.y, 1);
            }
            break;
          case "longpress":
            if (this.dragViewport) {
              this._viewportHasMoved = false;
              this._viewportDragPos = { "x": pos.x, "y": pos.y };
            } else {
              this._fakeMouseMove(ev, pos.x, pos.y);
              this._handleMouseButton(pos.x, pos.y, 4);
            }
            break;
          case "twodrag":
            this._gestureLastMagnitudeX = ev.detail.magnitudeX;
            this._gestureLastMagnitudeY = ev.detail.magnitudeY;
            this._fakeMouseMove(ev, pos.x, pos.y);
            break;
          case "pinch":
            this._gestureLastMagnitudeX = Math.hypot(
              ev.detail.magnitudeX,
              ev.detail.magnitudeY
            );
            this._fakeMouseMove(ev, pos.x, pos.y);
            break;
        }
        break;
      case "gesturemove":
        switch (ev.detail.type) {
          case "onetap":
          case "twotap":
          case "threetap":
            break;
          case "drag":
          case "longpress":
            if (this.dragViewport) {
              this._viewportDragging = true;
              const deltaX = this._viewportDragPos.x - pos.x;
              const deltaY = this._viewportDragPos.y - pos.y;
              if (this._viewportHasMoved || (Math.abs(deltaX) > dragThreshold || Math.abs(deltaY) > dragThreshold)) {
                this._viewportHasMoved = true;
                this._viewportDragPos = { "x": pos.x, "y": pos.y };
                this._display.viewportChangePos(deltaX, deltaY);
              }
            } else {
              this._fakeMouseMove(ev, pos.x, pos.y);
            }
            break;
          case "twodrag":
            this._fakeMouseMove(ev, pos.x, pos.y);
            while (ev.detail.magnitudeY - this._gestureLastMagnitudeY > GESTURE_SCRLSENS) {
              this._handleMouseButton(pos.x, pos.y, 8);
              this._handleMouseButton(pos.x, pos.y, 0);
              this._gestureLastMagnitudeY += GESTURE_SCRLSENS;
            }
            while (ev.detail.magnitudeY - this._gestureLastMagnitudeY < -GESTURE_SCRLSENS) {
              this._handleMouseButton(pos.x, pos.y, 16);
              this._handleMouseButton(pos.x, pos.y, 0);
              this._gestureLastMagnitudeY -= GESTURE_SCRLSENS;
            }
            while (ev.detail.magnitudeX - this._gestureLastMagnitudeX > GESTURE_SCRLSENS) {
              this._handleMouseButton(pos.x, pos.y, 32);
              this._handleMouseButton(pos.x, pos.y, 0);
              this._gestureLastMagnitudeX += GESTURE_SCRLSENS;
            }
            while (ev.detail.magnitudeX - this._gestureLastMagnitudeX < -GESTURE_SCRLSENS) {
              this._handleMouseButton(pos.x, pos.y, 64);
              this._handleMouseButton(pos.x, pos.y, 0);
              this._gestureLastMagnitudeX -= GESTURE_SCRLSENS;
            }
            break;
          case "pinch":
            this._fakeMouseMove(ev, pos.x, pos.y);
            magnitude = Math.hypot(ev.detail.magnitudeX, ev.detail.magnitudeY);
            if (Math.abs(magnitude - this._gestureLastMagnitudeX) > GESTURE_ZOOMSENS) {
              this._handleKeyEvent(keysym_default.XK_Control_L, "ControlLeft", true);
              while (magnitude - this._gestureLastMagnitudeX > GESTURE_ZOOMSENS) {
                this._handleMouseButton(pos.x, pos.y, 8);
                this._handleMouseButton(pos.x, pos.y, 0);
                this._gestureLastMagnitudeX += GESTURE_ZOOMSENS;
              }
              while (magnitude - this._gestureLastMagnitudeX < -GESTURE_ZOOMSENS) {
                this._handleMouseButton(pos.x, pos.y, 16);
                this._handleMouseButton(pos.x, pos.y, 0);
                this._gestureLastMagnitudeX -= GESTURE_ZOOMSENS;
              }
            }
            this._handleKeyEvent(keysym_default.XK_Control_L, "ControlLeft", false);
            break;
        }
        break;
      case "gestureend":
        switch (ev.detail.type) {
          case "onetap":
          case "twotap":
          case "threetap":
          case "pinch":
          case "twodrag":
            break;
          case "drag":
            if (this.dragViewport) {
              this._viewportDragging = false;
            } else {
              this._fakeMouseMove(ev, pos.x, pos.y);
              this._handleMouseButton(pos.x, pos.y, 0);
            }
            break;
          case "longpress":
            if (this._viewportHasMoved) {
              break;
            }
            if (this.dragViewport && !this._viewportHasMoved) {
              this._fakeMouseMove(ev, pos.x, pos.y);
              this._handleMouseButton(pos.x, pos.y, 4);
              this._handleMouseButton(pos.x, pos.y, 0);
              this._viewportDragging = false;
            } else {
              this._fakeMouseMove(ev, pos.x, pos.y);
              this._handleMouseButton(pos.x, pos.y, 0);
            }
            break;
        }
        break;
    }
  }
  _flushMouseMoveTimer(x, y) {
    if (this._mouseMoveTimer !== null) {
      clearTimeout(this._mouseMoveTimer);
      this._mouseMoveTimer = null;
      this._sendMouse(x, y, this._mouseButtonMask);
    }
  }
  // Message handlers
  _negotiateProtocolVersion() {
    if (this._sock.rQwait("version", 12)) {
      return false;
    }
    const sversion = this._sock.rQshiftStr(12).substr(4, 7);
    Info("Server ProtocolVersion: " + sversion);
    let isRepeater = 0;
    switch (sversion) {
      case "000.000":
        isRepeater = 1;
        break;
      case "003.003":
      case "003.006":
        this._rfbVersion = 3.3;
        break;
      case "003.007":
        this._rfbVersion = 3.7;
        break;
      case "003.008":
      case "003.889":
      // Apple Remote Desktop
      case "004.000":
      // Intel AMT KVM
      case "004.001":
      // RealVNC 4.6
      case "005.000":
        this._rfbVersion = 3.8;
        break;
      default:
        return this._fail("Invalid server version " + sversion);
    }
    if (isRepeater) {
      let repeaterID = "ID:" + this._repeaterID;
      while (repeaterID.length < 250) {
        repeaterID += "\0";
      }
      this._sock.sQpushString(repeaterID);
      this._sock.flush();
      return true;
    }
    if (this._rfbVersion > this._rfbMaxVersion) {
      this._rfbVersion = this._rfbMaxVersion;
    }
    const cversion = "00" + parseInt(this._rfbVersion, 10) + ".00" + this._rfbVersion * 10 % 10;
    this._sock.sQpushString("RFB " + cversion + "\n");
    this._sock.flush();
    Debug("Sent ProtocolVersion: " + cversion);
    this._rfbInitState = "Security";
  }
  _isSupportedSecurityType(type) {
    const clientTypes = [
      securityTypeNone,
      securityTypeVNCAuth,
      securityTypeRA2ne,
      securityTypeTight,
      securityTypeVeNCrypt,
      securityTypeXVP,
      securityTypeARD,
      securityTypeMSLogonII,
      securityTypePlain
    ];
    return clientTypes.includes(type);
  }
  _negotiateSecurity() {
    if (this._rfbVersion >= 3.7) {
      const numTypes = this._sock.rQshift8();
      if (this._sock.rQwait("security type", numTypes, 1)) {
        return false;
      }
      if (numTypes === 0) {
        this._rfbInitState = "SecurityReason";
        this._securityContext = "no security types";
        this._securityStatus = 1;
        return true;
      }
      const types = this._sock.rQshiftBytes(numTypes);
      Debug("Server security types: " + types);
      this._rfbAuthScheme = -1;
      for (let type of types) {
        if (this._isSupportedSecurityType(type)) {
          this._rfbAuthScheme = type;
          break;
        }
      }
      if (this._rfbAuthScheme === -1) {
        return this._fail("Unsupported security types (types: " + types + ")");
      }
      this._sock.sQpush8(this._rfbAuthScheme);
      this._sock.flush();
    } else {
      if (this._sock.rQwait("security scheme", 4)) {
        return false;
      }
      this._rfbAuthScheme = this._sock.rQshift32();
      if (this._rfbAuthScheme == 0) {
        this._rfbInitState = "SecurityReason";
        this._securityContext = "authentication scheme";
        this._securityStatus = 1;
        return true;
      }
    }
    this._rfbInitState = "Authentication";
    Debug("Authenticating using scheme: " + this._rfbAuthScheme);
    return true;
  }
  _handleSecurityReason() {
    if (this._sock.rQwait("reason length", 4)) {
      return false;
    }
    const strlen = this._sock.rQshift32();
    let reason = "";
    if (strlen > 0) {
      if (this._sock.rQwait("reason", strlen, 4)) {
        return false;
      }
      reason = this._sock.rQshiftStr(strlen);
    }
    if (reason !== "") {
      this.dispatchEvent(new CustomEvent(
        "securityfailure",
        { detail: {
          status: this._securityStatus,
          reason
        } }
      ));
      return this._fail("Security negotiation failed on " + this._securityContext + " (reason: " + reason + ")");
    } else {
      this.dispatchEvent(new CustomEvent(
        "securityfailure",
        { detail: { status: this._securityStatus } }
      ));
      return this._fail("Security negotiation failed on " + this._securityContext);
    }
  }
  // authentication
  _negotiateXvpAuth() {
    if (this._rfbCredentials.username === void 0 || this._rfbCredentials.password === void 0 || this._rfbCredentials.target === void 0) {
      this.dispatchEvent(new CustomEvent(
        "credentialsrequired",
        { detail: { types: ["username", "password", "target"] } }
      ));
      return false;
    }
    this._sock.sQpush8(this._rfbCredentials.username.length);
    this._sock.sQpush8(this._rfbCredentials.target.length);
    this._sock.sQpushString(this._rfbCredentials.username);
    this._sock.sQpushString(this._rfbCredentials.target);
    this._sock.flush();
    this._rfbAuthScheme = securityTypeVNCAuth;
    return this._negotiateAuthentication();
  }
  // VeNCrypt authentication, currently only supports version 0.2 and only Plain subtype
  _negotiateVeNCryptAuth() {
    if (this._rfbVeNCryptState == 0) {
      if (this._sock.rQwait("vencrypt version", 2)) {
        return false;
      }
      const major = this._sock.rQshift8();
      const minor = this._sock.rQshift8();
      if (!(major == 0 && minor == 2)) {
        return this._fail("Unsupported VeNCrypt version " + major + "." + minor);
      }
      this._sock.sQpush8(0);
      this._sock.sQpush8(2);
      this._sock.flush();
      this._rfbVeNCryptState = 1;
    }
    if (this._rfbVeNCryptState == 1) {
      if (this._sock.rQwait("vencrypt ack", 1)) {
        return false;
      }
      const res = this._sock.rQshift8();
      if (res != 0) {
        return this._fail("VeNCrypt failure " + res);
      }
      this._rfbVeNCryptState = 2;
    }
    if (this._rfbVeNCryptState == 2) {
      if (this._sock.rQwait("vencrypt subtypes length", 1)) {
        return false;
      }
      const subtypesLength = this._sock.rQshift8();
      if (subtypesLength < 1) {
        return this._fail("VeNCrypt subtypes empty");
      }
      this._rfbVeNCryptSubtypesLength = subtypesLength;
      this._rfbVeNCryptState = 3;
    }
    if (this._rfbVeNCryptState == 3) {
      if (this._sock.rQwait("vencrypt subtypes", 4 * this._rfbVeNCryptSubtypesLength)) {
        return false;
      }
      const subtypes = [];
      for (let i = 0; i < this._rfbVeNCryptSubtypesLength; i++) {
        subtypes.push(this._sock.rQshift32());
      }
      this._rfbAuthScheme = -1;
      for (let type of subtypes) {
        if (type === securityTypeVeNCrypt) {
          continue;
        }
        if (this._isSupportedSecurityType(type)) {
          this._rfbAuthScheme = type;
          break;
        }
      }
      if (this._rfbAuthScheme === -1) {
        return this._fail("Unsupported security types (types: " + subtypes + ")");
      }
      this._sock.sQpush32(this._rfbAuthScheme);
      this._sock.flush();
      this._rfbVeNCryptState = 4;
      return true;
    }
  }
  _negotiatePlainAuth() {
    if (this._rfbCredentials.username === void 0 || this._rfbCredentials.password === void 0) {
      this.dispatchEvent(new CustomEvent(
        "credentialsrequired",
        { detail: { types: ["username", "password"] } }
      ));
      return false;
    }
    const user = encodeUTF8(this._rfbCredentials.username);
    const pass = encodeUTF8(this._rfbCredentials.password);
    this._sock.sQpush32(user.length);
    this._sock.sQpush32(pass.length);
    this._sock.sQpushString(user);
    this._sock.sQpushString(pass);
    this._sock.flush();
    this._rfbInitState = "SecurityResult";
    return true;
  }
  _negotiateStdVNCAuth() {
    if (this._sock.rQwait("auth challenge", 16)) {
      return false;
    }
    if (this._rfbCredentials.password === void 0) {
      this.dispatchEvent(new CustomEvent(
        "credentialsrequired",
        { detail: { types: ["password"] } }
      ));
      return false;
    }
    const challenge = Array.prototype.slice.call(this._sock.rQshiftBytes(16));
    const response = _RFB.genDES(this._rfbCredentials.password, challenge);
    this._sock.sQpushBytes(response);
    this._sock.flush();
    this._rfbInitState = "SecurityResult";
    return true;
  }
  _negotiateARDAuth() {
    if (this._rfbCredentials.username === void 0 || this._rfbCredentials.password === void 0) {
      this.dispatchEvent(new CustomEvent(
        "credentialsrequired",
        { detail: { types: ["username", "password"] } }
      ));
      return false;
    }
    if (this._rfbCredentials.ardPublicKey != void 0 && this._rfbCredentials.ardCredentials != void 0) {
      this._sock.sQpushBytes(this._rfbCredentials.ardCredentials);
      this._sock.sQpushBytes(this._rfbCredentials.ardPublicKey);
      this._sock.flush();
      this._rfbCredentials.ardCredentials = null;
      this._rfbCredentials.ardPublicKey = null;
      this._rfbInitState = "SecurityResult";
      return true;
    }
    if (this._sock.rQwait("read ard", 4)) {
      return false;
    }
    let generator = this._sock.rQshiftBytes(2);
    let keyLength = this._sock.rQshift16();
    if (this._sock.rQwait("read ard keylength", keyLength * 2, 4)) {
      return false;
    }
    let prime = this._sock.rQshiftBytes(keyLength);
    let serverPublicKey = this._sock.rQshiftBytes(keyLength);
    let clientKey = crypto_default.generateKey(
      { name: "DH", g: generator, p: prime },
      false,
      ["deriveBits"]
    );
    this._negotiateARDAuthAsync(keyLength, serverPublicKey, clientKey);
    return false;
  }
  async _negotiateARDAuthAsync(keyLength, serverPublicKey, clientKey) {
    const clientPublicKey = crypto_default.exportKey("raw", clientKey.publicKey);
    const sharedKey = crypto_default.deriveBits(
      { name: "DH", public: serverPublicKey },
      clientKey.privateKey,
      keyLength * 8
    );
    const username = encodeUTF8(this._rfbCredentials.username).substring(0, 63);
    const password = encodeUTF8(this._rfbCredentials.password).substring(0, 63);
    const credentials = window.crypto.getRandomValues(new Uint8Array(128));
    for (let i = 0; i < username.length; i++) {
      credentials[i] = username.charCodeAt(i);
    }
    credentials[username.length] = 0;
    for (let i = 0; i < password.length; i++) {
      credentials[64 + i] = password.charCodeAt(i);
    }
    credentials[64 + password.length] = 0;
    const key = await crypto_default.digest("MD5", sharedKey);
    const cipher = await crypto_default.importKey(
      "raw",
      key,
      { name: "AES-ECB" },
      false,
      ["encrypt"]
    );
    const encrypted = await crypto_default.encrypt({ name: "AES-ECB" }, cipher, credentials);
    this._rfbCredentials.ardCredentials = encrypted;
    this._rfbCredentials.ardPublicKey = clientPublicKey;
    this._resumeAuthentication();
  }
  _negotiateTightUnixAuth() {
    if (this._rfbCredentials.username === void 0 || this._rfbCredentials.password === void 0) {
      this.dispatchEvent(new CustomEvent(
        "credentialsrequired",
        { detail: { types: ["username", "password"] } }
      ));
      return false;
    }
    this._sock.sQpush32(this._rfbCredentials.username.length);
    this._sock.sQpush32(this._rfbCredentials.password.length);
    this._sock.sQpushString(this._rfbCredentials.username);
    this._sock.sQpushString(this._rfbCredentials.password);
    this._sock.flush();
    this._rfbInitState = "SecurityResult";
    return true;
  }
  _negotiateTightTunnels(numTunnels) {
    const clientSupportedTunnelTypes = {
      0: { vendor: "TGHT", signature: "NOTUNNEL" }
    };
    const serverSupportedTunnelTypes = {};
    for (let i = 0; i < numTunnels; i++) {
      const capCode = this._sock.rQshift32();
      const capVendor = this._sock.rQshiftStr(4);
      const capSignature = this._sock.rQshiftStr(8);
      serverSupportedTunnelTypes[capCode] = { vendor: capVendor, signature: capSignature };
    }
    Debug("Server Tight tunnel types: " + serverSupportedTunnelTypes);
    if (serverSupportedTunnelTypes[1] && serverSupportedTunnelTypes[1].vendor === "SICR" && serverSupportedTunnelTypes[1].signature === "SCHANNEL") {
      Debug("Detected Siemens server. Assuming NOTUNNEL support.");
      serverSupportedTunnelTypes[0] = { vendor: "TGHT", signature: "NOTUNNEL" };
    }
    if (serverSupportedTunnelTypes[0]) {
      if (serverSupportedTunnelTypes[0].vendor != clientSupportedTunnelTypes[0].vendor || serverSupportedTunnelTypes[0].signature != clientSupportedTunnelTypes[0].signature) {
        return this._fail("Client's tunnel type had the incorrect vendor or signature");
      }
      Debug("Selected tunnel type: " + clientSupportedTunnelTypes[0]);
      this._sock.sQpush32(0);
      this._sock.flush();
      return false;
    } else {
      return this._fail("Server wanted tunnels, but doesn't support the notunnel type");
    }
  }
  _negotiateTightAuth() {
    if (!this._rfbTightVNC) {
      if (this._sock.rQwait("num tunnels", 4)) {
        return false;
      }
      const numTunnels = this._sock.rQshift32();
      if (numTunnels > 0 && this._sock.rQwait("tunnel capabilities", 16 * numTunnels, 4)) {
        return false;
      }
      this._rfbTightVNC = true;
      if (numTunnels > 0) {
        this._negotiateTightTunnels(numTunnels);
        return false;
      }
    }
    if (this._sock.rQwait("sub auth count", 4)) {
      return false;
    }
    const subAuthCount = this._sock.rQshift32();
    if (subAuthCount === 0) {
      this._rfbInitState = "SecurityResult";
      return true;
    }
    if (this._sock.rQwait("sub auth capabilities", 16 * subAuthCount, 4)) {
      return false;
    }
    const clientSupportedTypes = {
      "STDVNOAUTH__": 1,
      "STDVVNCAUTH_": 2,
      "TGHTULGNAUTH": 129
    };
    const serverSupportedTypes = [];
    for (let i = 0; i < subAuthCount; i++) {
      this._sock.rQshift32();
      const capabilities = this._sock.rQshiftStr(12);
      serverSupportedTypes.push(capabilities);
    }
    Debug("Server Tight authentication types: " + serverSupportedTypes);
    for (let authType in clientSupportedTypes) {
      if (serverSupportedTypes.indexOf(authType) != -1) {
        this._sock.sQpush32(clientSupportedTypes[authType]);
        this._sock.flush();
        Debug("Selected authentication type: " + authType);
        switch (authType) {
          case "STDVNOAUTH__":
            this._rfbInitState = "SecurityResult";
            return true;
          case "STDVVNCAUTH_":
            this._rfbAuthScheme = securityTypeVNCAuth;
            return true;
          case "TGHTULGNAUTH":
            this._rfbAuthScheme = securityTypeUnixLogon;
            return true;
          default:
            return this._fail("Unsupported tiny auth scheme (scheme: " + authType + ")");
        }
      }
    }
    return this._fail("No supported sub-auth types!");
  }
  _handleRSAAESCredentialsRequired(event) {
    this.dispatchEvent(event);
  }
  _handleRSAAESServerVerification(event) {
    this.dispatchEvent(event);
  }
  _negotiateRA2neAuth() {
    if (this._rfbRSAAESAuthenticationState === null) {
      this._rfbRSAAESAuthenticationState = new RSAAESAuthenticationState(this._sock, () => this._rfbCredentials);
      this._rfbRSAAESAuthenticationState.addEventListener(
        "serververification",
        this._eventHandlers.handleRSAAESServerVerification
      );
      this._rfbRSAAESAuthenticationState.addEventListener(
        "credentialsrequired",
        this._eventHandlers.handleRSAAESCredentialsRequired
      );
    }
    this._rfbRSAAESAuthenticationState.checkInternalEvents();
    if (!this._rfbRSAAESAuthenticationState.hasStarted) {
      this._rfbRSAAESAuthenticationState.negotiateRA2neAuthAsync().catch((e2) => {
        if (e2.message !== "disconnect normally") {
          this._fail(e2.message);
        }
      }).then(() => {
        this._rfbInitState = "SecurityResult";
        return true;
      }).finally(() => {
        this._rfbRSAAESAuthenticationState.removeEventListener(
          "serververification",
          this._eventHandlers.handleRSAAESServerVerification
        );
        this._rfbRSAAESAuthenticationState.removeEventListener(
          "credentialsrequired",
          this._eventHandlers.handleRSAAESCredentialsRequired
        );
        this._rfbRSAAESAuthenticationState = null;
      });
    }
    return false;
  }
  _negotiateMSLogonIIAuth() {
    if (this._sock.rQwait("mslogonii dh param", 24)) {
      return false;
    }
    if (this._rfbCredentials.username === void 0 || this._rfbCredentials.password === void 0) {
      this.dispatchEvent(new CustomEvent(
        "credentialsrequired",
        { detail: { types: ["username", "password"] } }
      ));
      return false;
    }
    const g = this._sock.rQshiftBytes(8);
    const p = this._sock.rQshiftBytes(8);
    const A = this._sock.rQshiftBytes(8);
    const dhKey = crypto_default.generateKey({ name: "DH", g, p }, true, ["deriveBits"]);
    const B = crypto_default.exportKey("raw", dhKey.publicKey);
    const secret = crypto_default.deriveBits({ name: "DH", public: A }, dhKey.privateKey, 64);
    const key = crypto_default.importKey("raw", secret, { name: "DES-CBC" }, false, ["encrypt"]);
    const username = encodeUTF8(this._rfbCredentials.username).substring(0, 255);
    const password = encodeUTF8(this._rfbCredentials.password).substring(0, 63);
    let usernameBytes = new Uint8Array(256);
    let passwordBytes = new Uint8Array(64);
    window.crypto.getRandomValues(usernameBytes);
    window.crypto.getRandomValues(passwordBytes);
    for (let i = 0; i < username.length; i++) {
      usernameBytes[i] = username.charCodeAt(i);
    }
    usernameBytes[username.length] = 0;
    for (let i = 0; i < password.length; i++) {
      passwordBytes[i] = password.charCodeAt(i);
    }
    passwordBytes[password.length] = 0;
    usernameBytes = crypto_default.encrypt({ name: "DES-CBC", iv: secret }, key, usernameBytes);
    passwordBytes = crypto_default.encrypt({ name: "DES-CBC", iv: secret }, key, passwordBytes);
    this._sock.sQpushBytes(B);
    this._sock.sQpushBytes(usernameBytes);
    this._sock.sQpushBytes(passwordBytes);
    this._sock.flush();
    this._rfbInitState = "SecurityResult";
    return true;
  }
  _negotiateAuthentication() {
    switch (this._rfbAuthScheme) {
      case securityTypeNone:
        if (this._rfbVersion >= 3.8) {
          this._rfbInitState = "SecurityResult";
        } else {
          this._rfbInitState = "ClientInitialisation";
        }
        return true;
      case securityTypeXVP:
        return this._negotiateXvpAuth();
      case securityTypeARD:
        return this._negotiateARDAuth();
      case securityTypeVNCAuth:
        return this._negotiateStdVNCAuth();
      case securityTypeTight:
        return this._negotiateTightAuth();
      case securityTypeVeNCrypt:
        return this._negotiateVeNCryptAuth();
      case securityTypePlain:
        return this._negotiatePlainAuth();
      case securityTypeUnixLogon:
        return this._negotiateTightUnixAuth();
      case securityTypeRA2ne:
        return this._negotiateRA2neAuth();
      case securityTypeMSLogonII:
        return this._negotiateMSLogonIIAuth();
      default:
        return this._fail("Unsupported auth scheme (scheme: " + this._rfbAuthScheme + ")");
    }
  }
  _handleSecurityResult() {
    if (this._sock.rQwait("VNC auth response ", 4)) {
      return false;
    }
    const status = this._sock.rQshift32();
    if (status === 0) {
      this._rfbInitState = "ClientInitialisation";
      Debug("Authentication OK");
      return true;
    } else {
      if (this._rfbVersion >= 3.8) {
        this._rfbInitState = "SecurityReason";
        this._securityContext = "security result";
        this._securityStatus = status;
        return true;
      } else {
        this.dispatchEvent(new CustomEvent(
          "securityfailure",
          { detail: { status } }
        ));
        return this._fail("Security handshake failed");
      }
    }
  }
  _negotiateServerInit() {
    if (this._sock.rQwait("server initialization", 24)) {
      return false;
    }
    const width = this._sock.rQshift16();
    const height = this._sock.rQshift16();
    const bpp = this._sock.rQshift8();
    const depth = this._sock.rQshift8();
    const bigEndian = this._sock.rQshift8();
    const trueColor = this._sock.rQshift8();
    const redMax = this._sock.rQshift16();
    const greenMax = this._sock.rQshift16();
    const blueMax = this._sock.rQshift16();
    const redShift = this._sock.rQshift8();
    const greenShift = this._sock.rQshift8();
    const blueShift = this._sock.rQshift8();
    this._sock.rQskipBytes(3);
    const nameLength = this._sock.rQshift32();
    if (this._sock.rQwait("server init name", nameLength, 24)) {
      return false;
    }
    let name = this._sock.rQshiftStr(nameLength);
    name = decodeUTF8(name, true);
    if (this._rfbTightVNC) {
      if (this._sock.rQwait("TightVNC extended server init header", 8, 24 + nameLength)) {
        return false;
      }
      const numServerMessages = this._sock.rQshift16();
      const numClientMessages = this._sock.rQshift16();
      const numEncodings = this._sock.rQshift16();
      this._sock.rQskipBytes(2);
      const totalMessagesLength = (numServerMessages + numClientMessages + numEncodings) * 16;
      if (this._sock.rQwait("TightVNC extended server init header", totalMessagesLength, 32 + nameLength)) {
        return false;
      }
      this._sock.rQskipBytes(16 * numServerMessages);
      this._sock.rQskipBytes(16 * numClientMessages);
      this._sock.rQskipBytes(16 * numEncodings);
    }
    Info("Screen: " + width + "x" + height + ", bpp: " + bpp + ", depth: " + depth + ", bigEndian: " + bigEndian + ", trueColor: " + trueColor + ", redMax: " + redMax + ", greenMax: " + greenMax + ", blueMax: " + blueMax + ", redShift: " + redShift + ", greenShift: " + greenShift + ", blueShift: " + blueShift);
    this._setDesktopName(name);
    this._resize(width, height);
    if (!this._viewOnly) {
      this._keyboard.grab();
      this._asyncClipboard.grab();
    }
    this._fbDepth = 24;
    if (this._fbName === "Intel(r) AMT KVM") {
      Warn("Intel AMT KVM only supports 8/16 bit depths. Using low color mode.");
      this._fbDepth = 8;
    }
    _RFB.messages.pixelFormat(this._sock, this._fbDepth, true);
    this._sendEncodings();
    _RFB.messages.fbUpdateRequest(this._sock, false, 0, 0, this._fbWidth, this._fbHeight);
    this._updateConnectionState("connected");
    return true;
  }
  _sendEncodings() {
    const encs = [];
    encs.push(encodings.encodingCopyRect);
    if (this._fbDepth == 24) {
      if (supportsWebCodecsH264Decode) {
        encs.push(encodings.encodingH264);
      }
      encs.push(encodings.encodingTight);
      encs.push(encodings.encodingTightPNG);
      encs.push(encodings.encodingZRLE);
      encs.push(encodings.encodingJPEG);
      encs.push(encodings.encodingHextile);
      encs.push(encodings.encodingRRE);
      encs.push(encodings.encodingZlib);
    }
    encs.push(encodings.encodingRaw);
    encs.push(encodings.pseudoEncodingQualityLevel0 + this._qualityLevel);
    encs.push(encodings.pseudoEncodingCompressLevel0 + this._compressionLevel);
    encs.push(encodings.pseudoEncodingDesktopSize);
    encs.push(encodings.pseudoEncodingLastRect);
    encs.push(encodings.pseudoEncodingQEMUExtendedKeyEvent);
    encs.push(encodings.pseudoEncodingQEMULedEvent);
    encs.push(encodings.pseudoEncodingExtendedDesktopSize);
    encs.push(encodings.pseudoEncodingXvp);
    encs.push(encodings.pseudoEncodingFence);
    encs.push(encodings.pseudoEncodingContinuousUpdates);
    encs.push(encodings.pseudoEncodingDesktopName);
    encs.push(encodings.pseudoEncodingExtendedClipboard);
    encs.push(encodings.pseudoEncodingExtendedMouseButtons);
    if (this._fbDepth == 24) {
      encs.push(encodings.pseudoEncodingVMwareCursor);
      encs.push(encodings.pseudoEncodingCursor);
    }
    _RFB.messages.clientEncodings(this._sock, encs);
  }
  /* RFB protocol initialization states:
   *   ProtocolVersion
   *   Security
   *   Authentication
   *   SecurityResult
   *   ClientInitialization - not triggered by server message
   *   ServerInitialization
   */
  _initMsg() {
    switch (this._rfbInitState) {
      case "ProtocolVersion":
        return this._negotiateProtocolVersion();
      case "Security":
        return this._negotiateSecurity();
      case "Authentication":
        return this._negotiateAuthentication();
      case "SecurityResult":
        return this._handleSecurityResult();
      case "SecurityReason":
        return this._handleSecurityReason();
      case "ClientInitialisation":
        this._sock.sQpush8(this._shared ? 1 : 0);
        this._sock.flush();
        this._rfbInitState = "ServerInitialisation";
        return true;
      case "ServerInitialisation":
        return this._negotiateServerInit();
      default:
        return this._fail("Unknown init state (state: " + this._rfbInitState + ")");
    }
  }
  // Resume authentication handshake after it was paused for some
  // reason, e.g. waiting for a password from the user
  _resumeAuthentication() {
    setTimeout(this._initMsg.bind(this), 0);
  }
  _handleSetColourMapMsg() {
    Debug("SetColorMapEntries");
    return this._fail("Unexpected SetColorMapEntries message");
  }
  _writeClipboard(text) {
    if (this._viewOnly) return;
    if (this._asyncClipboard.writeClipboard(text)) return;
    this.dispatchEvent(
      new CustomEvent("clipboard", { detail: { text } })
    );
  }
  _handleServerCutText() {
    Debug("ServerCutText");
    if (this._sock.rQwait("ServerCutText header", 7, 1)) {
      return false;
    }
    this._sock.rQskipBytes(3);
    let length = this._sock.rQshift32();
    length = toSigned32bit(length);
    if (this._sock.rQwait("ServerCutText content", Math.abs(length), 8)) {
      return false;
    }
    if (length >= 0) {
      const text = this._sock.rQshiftStr(length);
      if (this._viewOnly) {
        return true;
      }
      this._writeClipboard(text);
    } else {
      length = Math.abs(length);
      const flags = this._sock.rQshift32();
      let formats = flags & 65535;
      let actions = flags & 4278190080;
      let isCaps = !!(actions & extendedClipboardActionCaps);
      if (isCaps) {
        this._clipboardServerCapabilitiesFormats = {};
        this._clipboardServerCapabilitiesActions = {};
        for (let i = 0; i <= 15; i++) {
          let index = 1 << i;
          if (formats & index) {
            this._clipboardServerCapabilitiesFormats[index] = true;
            this._sock.rQshift32();
          }
        }
        for (let i = 24; i <= 31; i++) {
          let index = 1 << i;
          this._clipboardServerCapabilitiesActions[index] = !!(actions & index);
        }
        let clientActions = [
          extendedClipboardActionCaps,
          extendedClipboardActionRequest,
          extendedClipboardActionPeek,
          extendedClipboardActionNotify,
          extendedClipboardActionProvide
        ];
        _RFB.messages.extendedClipboardCaps(this._sock, clientActions, { extendedClipboardFormatText: 0 });
      } else if (actions === extendedClipboardActionRequest) {
        if (this._viewOnly) {
          return true;
        }
        if (this._clipboardText != null && this._clipboardServerCapabilitiesActions[extendedClipboardActionProvide]) {
          if (formats & extendedClipboardFormatText) {
            _RFB.messages.extendedClipboardProvide(this._sock, [extendedClipboardFormatText], [this._clipboardText]);
          }
        }
      } else if (actions === extendedClipboardActionPeek) {
        if (this._viewOnly) {
          return true;
        }
        if (this._clipboardServerCapabilitiesActions[extendedClipboardActionNotify]) {
          if (this._clipboardText != null) {
            _RFB.messages.extendedClipboardNotify(this._sock, [extendedClipboardFormatText]);
          } else {
            _RFB.messages.extendedClipboardNotify(this._sock, []);
          }
        }
      } else if (actions === extendedClipboardActionNotify) {
        if (this._viewOnly) {
          return true;
        }
        if (this._clipboardServerCapabilitiesActions[extendedClipboardActionRequest]) {
          if (formats & extendedClipboardFormatText) {
            _RFB.messages.extendedClipboardRequest(this._sock, [extendedClipboardFormatText]);
          }
        }
      } else if (actions === extendedClipboardActionProvide) {
        if (this._viewOnly) {
          return true;
        }
        if (!(formats & extendedClipboardFormatText)) {
          return true;
        }
        this._clipboardText = null;
        let zlibStream = this._sock.rQshiftBytes(length - 4);
        let streamInflator = new Inflate();
        let textData = null;
        streamInflator.setInput(zlibStream);
        for (let i = 0; i <= 15; i++) {
          let format = 1 << i;
          if (formats & format) {
            let size = 0;
            let sizeArray = streamInflator.inflate(4);
            size |= sizeArray[0] << 24;
            size |= sizeArray[1] << 16;
            size |= sizeArray[2] << 8;
            size |= sizeArray[3];
            let chunk = streamInflator.inflate(size);
            if (format === extendedClipboardFormatText) {
              textData = chunk;
            }
          }
        }
        streamInflator.setInput(null);
        if (textData !== null) {
          let tmpText = "";
          for (let i = 0; i < textData.length; i++) {
            tmpText += String.fromCharCode(textData[i]);
          }
          textData = tmpText;
          textData = decodeUTF8(textData);
          if (textData.length > 0 && "\0" === textData.charAt(textData.length - 1)) {
            textData = textData.slice(0, -1);
          }
          textData = textData.replaceAll("\r\n", "\n");
          this._writeClipboard(textData);
        }
      } else {
        return this._fail("Unexpected action in extended clipboard message: " + actions);
      }
    }
    return true;
  }
  _handleServerFenceMsg() {
    if (this._sock.rQwait("ServerFence header", 8, 1)) {
      return false;
    }
    this._sock.rQskipBytes(3);
    let flags = this._sock.rQshift32();
    let length = this._sock.rQshift8();
    if (this._sock.rQwait("ServerFence payload", length, 9)) {
      return false;
    }
    if (length > 64) {
      Warn("Bad payload length (" + length + ") in fence response");
      length = 64;
    }
    const payload = this._sock.rQshiftStr(length);
    this._supportsFence = true;
    if (!(flags & 1 << 31)) {
      return this._fail("Unexpected fence response");
    }
    flags &= 1 << 0 | 1 << 1;
    _RFB.messages.clientFence(this._sock, flags, payload);
    return true;
  }
  _handleXvpMsg() {
    if (this._sock.rQwait("XVP version and message", 3, 1)) {
      return false;
    }
    this._sock.rQskipBytes(1);
    const xvpVer = this._sock.rQshift8();
    const xvpMsg = this._sock.rQshift8();
    switch (xvpMsg) {
      case 0:
        Error2("XVP operation failed");
        break;
      case 1:
        this._rfbXvpVer = xvpVer;
        Info("XVP extensions enabled (version " + this._rfbXvpVer + ")");
        this._setCapability("power", true);
        break;
      default:
        this._fail("Illegal server XVP message (msg: " + xvpMsg + ")");
        break;
    }
    return true;
  }
  _normalMsg() {
    let msgType;
    if (this._FBU.rects > 0) {
      msgType = 0;
    } else {
      msgType = this._sock.rQshift8();
    }
    let first, ret;
    switch (msgType) {
      case 0:
        ret = this._framebufferUpdate();
        if (ret && !this._enabledContinuousUpdates) {
          _RFB.messages.fbUpdateRequest(
            this._sock,
            true,
            0,
            0,
            this._fbWidth,
            this._fbHeight
          );
        }
        return ret;
      case 1:
        return this._handleSetColourMapMsg();
      case 2:
        Debug("Bell");
        this.dispatchEvent(new CustomEvent(
          "bell",
          { detail: {} }
        ));
        return true;
      case 3:
        return this._handleServerCutText();
      case 150:
        first = !this._supportsContinuousUpdates;
        this._supportsContinuousUpdates = true;
        this._enabledContinuousUpdates = false;
        if (first) {
          this._enabledContinuousUpdates = true;
          this._updateContinuousUpdates();
          Info("Enabling continuous updates.");
        } else {
        }
        return true;
      case 248:
        return this._handleServerFenceMsg();
      case 250:
        return this._handleXvpMsg();
      default:
        this._fail("Unexpected server message (type " + msgType + ")");
        Debug("sock.rQpeekBytes(30): " + this._sock.rQpeekBytes(30));
        return true;
    }
  }
  _framebufferUpdate() {
    if (this._FBU.rects === 0) {
      if (this._sock.rQwait("FBU header", 3, 1)) {
        return false;
      }
      this._sock.rQskipBytes(1);
      this._FBU.rects = this._sock.rQshift16();
      if (this._display.pending()) {
        this._flushing = true;
        this._display.flush().then(() => {
          this._flushing = false;
          if (!this._sock.rQwait("message", 1)) {
            this._handleMessage();
          }
        });
        return false;
      }
    }
    while (this._FBU.rects > 0) {
      if (this._FBU.encoding === null) {
        if (this._sock.rQwait("rect header", 12)) {
          return false;
        }
        this._FBU.x = this._sock.rQshift16();
        this._FBU.y = this._sock.rQshift16();
        this._FBU.width = this._sock.rQshift16();
        this._FBU.height = this._sock.rQshift16();
        this._FBU.encoding = this._sock.rQshift32();
        this._FBU.encoding >>= 0;
      }
      if (!this._handleRect()) {
        return false;
      }
      this._FBU.rects--;
      this._FBU.encoding = null;
    }
    this._display.flip();
    return true;
  }
  _handleRect() {
    switch (this._FBU.encoding) {
      case encodings.pseudoEncodingLastRect:
        this._FBU.rects = 1;
        return true;
      case encodings.pseudoEncodingVMwareCursor:
        return this._handleVMwareCursor();
      case encodings.pseudoEncodingCursor:
        return this._handleCursor();
      case encodings.pseudoEncodingQEMUExtendedKeyEvent:
        this._qemuExtKeyEventSupported = true;
        return true;
      case encodings.pseudoEncodingDesktopName:
        return this._handleDesktopName();
      case encodings.pseudoEncodingDesktopSize:
        this._resize(this._FBU.width, this._FBU.height);
        return true;
      case encodings.pseudoEncodingExtendedDesktopSize:
        return this._handleExtendedDesktopSize();
      case encodings.pseudoEncodingExtendedMouseButtons:
        this._extendedPointerEventSupported = true;
        return true;
      case encodings.pseudoEncodingQEMULedEvent:
        return this._handleLedEvent();
      default:
        return this._handleDataRect();
    }
  }
  _handleVMwareCursor() {
    const hotx = this._FBU.x;
    const hoty = this._FBU.y;
    const w = this._FBU.width;
    const h = this._FBU.height;
    if (this._sock.rQwait("VMware cursor encoding", 1)) {
      return false;
    }
    const cursorType = this._sock.rQshift8();
    this._sock.rQshift8();
    let rgba;
    const bytesPerPixel = 4;
    if (cursorType == 0) {
      const PIXEL_MASK = 4294967040 | 0;
      rgba = new Array(w * h * bytesPerPixel);
      if (this._sock.rQwait(
        "VMware cursor classic encoding",
        w * h * bytesPerPixel * 2,
        2
      )) {
        return false;
      }
      let andMask = new Array(w * h);
      for (let pixel = 0; pixel < w * h; pixel++) {
        andMask[pixel] = this._sock.rQshift32();
      }
      let xorMask = new Array(w * h);
      for (let pixel = 0; pixel < w * h; pixel++) {
        xorMask[pixel] = this._sock.rQshift32();
      }
      for (let pixel = 0; pixel < w * h; pixel++) {
        if (andMask[pixel] == 0) {
          let bgr = xorMask[pixel];
          let r = bgr >> 8 & 255;
          let g = bgr >> 16 & 255;
          let b2 = bgr >> 24 & 255;
          rgba[pixel * bytesPerPixel] = r;
          rgba[pixel * bytesPerPixel + 1] = g;
          rgba[pixel * bytesPerPixel + 2] = b2;
          rgba[pixel * bytesPerPixel + 3] = 255;
        } else if ((andMask[pixel] & PIXEL_MASK) == PIXEL_MASK) {
          if (xorMask[pixel] == 0) {
            rgba[pixel * bytesPerPixel] = 0;
            rgba[pixel * bytesPerPixel + 1] = 0;
            rgba[pixel * bytesPerPixel + 2] = 0;
            rgba[pixel * bytesPerPixel + 3] = 0;
          } else if ((xorMask[pixel] & PIXEL_MASK) == PIXEL_MASK) {
            rgba[pixel * bytesPerPixel] = 0;
            rgba[pixel * bytesPerPixel + 1] = 0;
            rgba[pixel * bytesPerPixel + 2] = 0;
            rgba[pixel * bytesPerPixel + 3] = 255;
          } else {
            rgba[pixel * bytesPerPixel] = 0;
            rgba[pixel * bytesPerPixel + 1] = 0;
            rgba[pixel * bytesPerPixel + 2] = 0;
            rgba[pixel * bytesPerPixel + 3] = 255;
          }
        } else {
          rgba[pixel * bytesPerPixel] = 0;
          rgba[pixel * bytesPerPixel + 1] = 0;
          rgba[pixel * bytesPerPixel + 2] = 0;
          rgba[pixel * bytesPerPixel + 3] = 255;
        }
      }
    } else if (cursorType == 1) {
      if (this._sock.rQwait(
        "VMware cursor alpha encoding",
        w * h * 4,
        2
      )) {
        return false;
      }
      rgba = new Array(w * h * bytesPerPixel);
      for (let pixel = 0; pixel < w * h; pixel++) {
        let data = this._sock.rQshift32();
        rgba[pixel * 4] = data >> 24 & 255;
        rgba[pixel * 4 + 1] = data >> 16 & 255;
        rgba[pixel * 4 + 2] = data >> 8 & 255;
        rgba[pixel * 4 + 3] = data & 255;
      }
    } else {
      Warn("The given cursor type is not supported: " + cursorType + " given.");
      return false;
    }
    this._updateCursor(rgba, hotx, hoty, w, h);
    return true;
  }
  _handleCursor() {
    const hotx = this._FBU.x;
    const hoty = this._FBU.y;
    const w = this._FBU.width;
    const h = this._FBU.height;
    const pixelslength = w * h * 4;
    const masklength = Math.ceil(w / 8) * h;
    let bytes = pixelslength + masklength;
    if (this._sock.rQwait("cursor encoding", bytes)) {
      return false;
    }
    const pixels = this._sock.rQshiftBytes(pixelslength);
    const mask = this._sock.rQshiftBytes(masklength);
    let rgba = new Uint8Array(w * h * 4);
    let pixIdx = 0;
    for (let y = 0; y < h; y++) {
      for (let x = 0; x < w; x++) {
        let maskIdx = y * Math.ceil(w / 8) + Math.floor(x / 8);
        let alpha = mask[maskIdx] << x % 8 & 128 ? 255 : 0;
        rgba[pixIdx] = pixels[pixIdx + 2];
        rgba[pixIdx + 1] = pixels[pixIdx + 1];
        rgba[pixIdx + 2] = pixels[pixIdx];
        rgba[pixIdx + 3] = alpha;
        pixIdx += 4;
      }
    }
    this._updateCursor(rgba, hotx, hoty, w, h);
    return true;
  }
  _handleDesktopName() {
    if (this._sock.rQwait("DesktopName", 4)) {
      return false;
    }
    let length = this._sock.rQshift32();
    if (this._sock.rQwait("DesktopName", length, 4)) {
      return false;
    }
    let name = this._sock.rQshiftStr(length);
    name = decodeUTF8(name, true);
    this._setDesktopName(name);
    return true;
  }
  _handleLedEvent() {
    if (this._sock.rQwait("LED status", 1)) {
      return false;
    }
    let data = this._sock.rQshift8();
    let numLock = data & 2 ? true : false;
    let capsLock = data & 4 ? true : false;
    this._remoteCapsLock = capsLock;
    this._remoteNumLock = numLock;
    return true;
  }
  _handleExtendedDesktopSize() {
    if (this._sock.rQwait("ExtendedDesktopSize", 4)) {
      return false;
    }
    const numberOfScreens = this._sock.rQpeek8();
    let bytes = 4 + numberOfScreens * 16;
    if (this._sock.rQwait("ExtendedDesktopSize", bytes)) {
      return false;
    }
    const firstUpdate = !this._supportsSetDesktopSize;
    this._supportsSetDesktopSize = true;
    this._sock.rQskipBytes(1);
    this._sock.rQskipBytes(3);
    for (let i = 0; i < numberOfScreens; i += 1) {
      if (i === 0) {
        this._screenID = this._sock.rQshift32();
        this._sock.rQskipBytes(2);
        this._sock.rQskipBytes(2);
        this._sock.rQskipBytes(2);
        this._sock.rQskipBytes(2);
        this._screenFlags = this._sock.rQshift32();
      } else {
        this._sock.rQskipBytes(16);
      }
    }
    if (this._FBU.x === 1) {
      this._pendingRemoteResize = false;
    }
    if (this._FBU.x === 1 && this._FBU.y !== 0) {
      let msg;
      switch (this._FBU.y) {
        case 1:
          msg = "Resize is administratively prohibited";
          break;
        case 2:
          msg = "Out of resources";
          break;
        case 3:
          msg = "Invalid screen layout";
          break;
        default:
          msg = "Unknown reason";
          break;
      }
      Warn("Server did not accept the resize request: " + msg);
    } else {
      this._resize(this._FBU.width, this._FBU.height);
    }
    if (firstUpdate) {
      this._requestRemoteResize();
    }
    if (this._FBU.x === 1 && this._FBU.y === 0) {
      this._requestRemoteResize();
    }
    return true;
  }
  _handleDataRect() {
    let decoder = this._decoders[this._FBU.encoding];
    if (!decoder) {
      this._fail("Unsupported encoding (encoding: " + this._FBU.encoding + ")");
      return false;
    }
    try {
      return decoder.decodeRect(
        this._FBU.x,
        this._FBU.y,
        this._FBU.width,
        this._FBU.height,
        this._sock,
        this._display,
        this._fbDepth
      );
    } catch (err2) {
      this._fail("Error decoding rect: " + err2);
      return false;
    }
  }
  _updateContinuousUpdates() {
    if (!this._enabledContinuousUpdates) {
      return;
    }
    _RFB.messages.enableContinuousUpdates(
      this._sock,
      true,
      0,
      0,
      this._fbWidth,
      this._fbHeight
    );
  }
  // Handle resize-messages from the server
  _resize(width, height) {
    this._fbWidth = width;
    this._fbHeight = height;
    this._display.resize(this._fbWidth, this._fbHeight);
    this._updateClip();
    this._updateScale();
    this._updateContinuousUpdates();
    this._saveExpectedClientSize();
  }
  _xvpOp(ver, op) {
    if (this._rfbXvpVer < ver) {
      return;
    }
    Info("Sending XVP operation " + op + " (version " + ver + ")");
    _RFB.messages.xvpOp(this._sock, ver, op);
  }
  _updateCursor(rgba, hotx, hoty, w, h) {
    this._cursorImage = {
      rgbaPixels: rgba,
      hotx,
      hoty,
      w,
      h
    };
    this._refreshCursor();
  }
  _shouldShowDotCursor() {
    if (!this._showDotCursor) {
      return false;
    }
    for (let i = 3; i < this._cursorImage.rgbaPixels.length; i += 4) {
      if (this._cursorImage.rgbaPixels[i]) {
        return false;
      }
    }
    return true;
  }
  _refreshCursor() {
    if (this._rfbConnectionState !== "connecting" && this._rfbConnectionState !== "connected") {
      return;
    }
    const image = this._shouldShowDotCursor() ? _RFB.cursors.dot : this._cursorImage;
    this._cursor.change(
      image.rgbaPixels,
      image.hotx,
      image.hoty,
      image.w,
      image.h
    );
  }
  static genDES(password, challenge) {
    const passwordChars = password.split("").map((c2) => c2.charCodeAt(0));
    const key = crypto_default.importKey(
      "raw",
      passwordChars,
      { name: "DES-ECB" },
      false,
      ["encrypt"]
    );
    return crypto_default.encrypt({ name: "DES-ECB" }, key, challenge);
  }
};
RFB.messages = {
  keyEvent(sock, keysym, down) {
    sock.sQpush8(4);
    sock.sQpush8(down);
    sock.sQpush16(0);
    sock.sQpush32(keysym);
    sock.flush();
  },
  QEMUExtendedKeyEvent(sock, keysym, down, keycode) {
    function getRFBkeycode(xtScanCode) {
      const upperByte = keycode >> 8;
      const lowerByte = keycode & 255;
      if (upperByte === 224 && lowerByte < 127) {
        return lowerByte | 128;
      }
      return xtScanCode;
    }
    sock.sQpush8(255);
    sock.sQpush8(0);
    sock.sQpush16(down);
    sock.sQpush32(keysym);
    const RFBkeycode = getRFBkeycode(keycode);
    sock.sQpush32(RFBkeycode);
    sock.flush();
  },
  pointerEvent(sock, x, y, mask) {
    sock.sQpush8(5);
    mask = mask & 127;
    sock.sQpush8(mask);
    sock.sQpush16(x);
    sock.sQpush16(y);
    sock.flush();
  },
  extendedPointerEvent(sock, x, y, mask) {
    sock.sQpush8(5);
    let higherBits = mask >> 7 & 255;
    if (higherBits & 252) {
      throw new Error("Invalid mouse button mask: " + mask);
    }
    let lowerBits = mask & 127;
    lowerBits |= 128;
    sock.sQpush8(lowerBits);
    sock.sQpush16(x);
    sock.sQpush16(y);
    sock.sQpush8(higherBits);
    sock.flush();
  },
  // Used to build Notify and Request data.
  _buildExtendedClipboardFlags(actions, formats) {
    let data = new Uint8Array(4);
    let formatFlag = 0;
    let actionFlag = 0;
    for (let i = 0; i < actions.length; i++) {
      actionFlag |= actions[i];
    }
    for (let i = 0; i < formats.length; i++) {
      formatFlag |= formats[i];
    }
    data[0] = actionFlag >> 24;
    data[1] = 0;
    data[2] = 0;
    data[3] = formatFlag;
    return data;
  },
  extendedClipboardProvide(sock, formats, inData) {
    let deflator = new Deflator();
    let dataToDeflate = [];
    for (let i = 0; i < formats.length; i++) {
      if (formats[i] != extendedClipboardFormatText) {
        throw new Error("Unsupported extended clipboard format for Provide message.");
      }
      inData[i] = inData[i].replace(/\r\n|\r|\n/gm, "\r\n");
      let text = encodeUTF8(inData[i] + "\0");
      dataToDeflate.push(
        text.length >> 24 & 255,
        text.length >> 16 & 255,
        text.length >> 8 & 255,
        text.length & 255
      );
      for (let j = 0; j < text.length; j++) {
        dataToDeflate.push(text.charCodeAt(j));
      }
    }
    let deflatedData = deflator.deflate(new Uint8Array(dataToDeflate));
    let data = new Uint8Array(4 + deflatedData.length);
    data.set(RFB.messages._buildExtendedClipboardFlags(
      [extendedClipboardActionProvide],
      formats
    ));
    data.set(deflatedData, 4);
    RFB.messages.clientCutText(sock, data, true);
  },
  extendedClipboardNotify(sock, formats) {
    let flags = RFB.messages._buildExtendedClipboardFlags(
      [extendedClipboardActionNotify],
      formats
    );
    RFB.messages.clientCutText(sock, flags, true);
  },
  extendedClipboardRequest(sock, formats) {
    let flags = RFB.messages._buildExtendedClipboardFlags(
      [extendedClipboardActionRequest],
      formats
    );
    RFB.messages.clientCutText(sock, flags, true);
  },
  extendedClipboardCaps(sock, actions, formats) {
    let formatKeys = Object.keys(formats);
    let data = new Uint8Array(4 + 4 * formatKeys.length);
    formatKeys.map((x) => parseInt(x));
    formatKeys.sort((a2, b2) => a2 - b2);
    data.set(RFB.messages._buildExtendedClipboardFlags(actions, []));
    let loopOffset = 4;
    for (let i = 0; i < formatKeys.length; i++) {
      data[loopOffset] = formats[formatKeys[i]] >> 24;
      data[loopOffset + 1] = formats[formatKeys[i]] >> 16;
      data[loopOffset + 2] = formats[formatKeys[i]] >> 8;
      data[loopOffset + 3] = formats[formatKeys[i]] >> 0;
      loopOffset += 4;
      data[3] |= 1 << formatKeys[i];
    }
    RFB.messages.clientCutText(sock, data, true);
  },
  clientCutText(sock, data, extended = false) {
    sock.sQpush8(6);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.sQpush8(0);
    let length;
    if (extended) {
      length = toUnsigned32bit(-data.length);
    } else {
      length = data.length;
    }
    sock.sQpush32(length);
    sock.sQpushBytes(data);
    sock.flush();
  },
  setDesktopSize(sock, width, height, id, flags) {
    sock.sQpush8(251);
    sock.sQpush8(0);
    sock.sQpush16(width);
    sock.sQpush16(height);
    sock.sQpush8(1);
    sock.sQpush8(0);
    sock.sQpush32(id);
    sock.sQpush16(0);
    sock.sQpush16(0);
    sock.sQpush16(width);
    sock.sQpush16(height);
    sock.sQpush32(flags);
    sock.flush();
  },
  clientFence(sock, flags, payload) {
    sock.sQpush8(248);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.sQpush32(flags);
    sock.sQpush8(payload.length);
    sock.sQpushString(payload);
    sock.flush();
  },
  enableContinuousUpdates(sock, enable, x, y, width, height) {
    sock.sQpush8(150);
    sock.sQpush8(enable);
    sock.sQpush16(x);
    sock.sQpush16(y);
    sock.sQpush16(width);
    sock.sQpush16(height);
    sock.flush();
  },
  pixelFormat(sock, depth, trueColor) {
    let bpp;
    if (depth > 16) {
      bpp = 32;
    } else if (depth > 8) {
      bpp = 16;
    } else {
      bpp = 8;
    }
    const bits = Math.floor(depth / 3);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.sQpush8(bpp);
    sock.sQpush8(depth);
    sock.sQpush8(0);
    sock.sQpush8(trueColor ? 1 : 0);
    sock.sQpush16((1 << bits) - 1);
    sock.sQpush16((1 << bits) - 1);
    sock.sQpush16((1 << bits) - 1);
    sock.sQpush8(bits * 0);
    sock.sQpush8(bits * 1);
    sock.sQpush8(bits * 2);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.sQpush8(0);
    sock.flush();
  },
  clientEncodings(sock, encodings2) {
    sock.sQpush8(2);
    sock.sQpush8(0);
    sock.sQpush16(encodings2.length);
    for (let i = 0; i < encodings2.length; i++) {
      sock.sQpush32(encodings2[i]);
    }
    sock.flush();
  },
  fbUpdateRequest(sock, incremental, x, y, w, h) {
    if (typeof x === "undefined") {
      x = 0;
    }
    if (typeof y === "undefined") {
      y = 0;
    }
    sock.sQpush8(3);
    sock.sQpush8(incremental ? 1 : 0);
    sock.sQpush16(x);
    sock.sQpush16(y);
    sock.sQpush16(w);
    sock.sQpush16(h);
    sock.flush();
  },
  xvpOp(sock, ver, op) {
    sock.sQpush8(250);
    sock.sQpush8(0);
    sock.sQpush8(ver);
    sock.sQpush8(op);
    sock.flush();
  }
};
RFB.cursors = {
  none: {
    rgbaPixels: new Uint8Array(),
    w: 0,
    h: 0,
    hotx: 0,
    hoty: 0
  },
  dot: {
    /* eslint-disable indent */
    rgbaPixels: new Uint8Array([
      255,
      255,
      255,
      255,
      0,
      0,
      0,
      255,
      255,
      255,
      255,
      255,
      0,
      0,
      0,
      255,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      255,
      255,
      255,
      255,
      255,
      0,
      0,
      0,
      255,
      255,
      255,
      255,
      255
    ]),
    /* eslint-enable indent */
    w: 3,
    h: 3,
    hotx: 1,
    hoty: 1
  }
};
export {
  RFB as default
};

// Expose RFB globally for non-module scripts
if (typeof window !== 'undefined') window.RFB = RFB;