@lvce-editor/server 0.38.9 → 0.40.0

package/static/f3cf31a/packages/terminal-worker/dist/terminalWorkerMain.js

@@ -1,2971 +0,0 @@
-let AssertionError$1 = class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-};
-const getType$2 = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const object = value => {
-  const type = getType$2(value);
-  if (type !== 'object') {
-    throw new AssertionError$1('expected value to be of type object');
-  }
-};
-const number$1 = value => {
-  const type = getType$2(value);
-  if (type !== 'number') {
-    throw new AssertionError$1('expected value to be of type number');
-  }
-};
-const string = value => {
-  const type = getType$2(value);
-  if (type !== 'string') {
-    throw new AssertionError$1('expected value to be of type string');
-  }
-};
-
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType$1 = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const number = value => {
-  const type = getType$1(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const state$1$1 = {
-  callbacks: Object.create(null)
-};
-const set$2 = (id, fn) => {
-  state$1$1.callbacks[id] = fn;
-};
-const get$2 = id => {
-  return state$1$1.callbacks[id];
-};
-const remove = id => {
-  delete state$1$1.callbacks[id];
-};
-const state$4 = {
-  id: 0
-};
-const create$3$1 = () => {
-  return ++state$4.id;
-};
-const warn = (...args) => {
-  console.warn(...args);
-};
-const withResolvers$2 = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = withResolvers$2();
-  set$2(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const resolve = (id, args) => {
-  number(id);
-  const fn = get$2(id);
-  if (!fn) {
-    console.log(args);
-    warn(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(args);
-  remove(id);
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
-  }
-}
-const NewLine$3 = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case DomException:
-        return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case ReferenceError$1:
-        return ReferenceError;
-      default:
-        return Error;
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
-  }
-  return Error;
-};
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
-  }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      error.name = name;
-    }
-    return error;
-  }
-  return new ErrorConstructor(message);
-};
-const getNewLineIndex$2 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$3, startIndex);
-};
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$3 + parentStack;
-  }
-  return parentStack;
-};
-const joinLines$1 = lines => {
-  return lines.join(NewLine$3);
-};
-const MethodNotFound = -32601;
-const Custom = -32001;
-const splitLines$1 = lines => {
-  return lines.split(NewLine$3);
-};
-const restoreJsonRpcError = error => {
-  if (error && error instanceof Error) {
-    return error;
-  }
-  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(1));
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$3 + currentStack;
-    return restoredError;
-  }
-  if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine$3 + error.data.stack + NewLine$3 + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex$2(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
-};
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
-  }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
-  }
-  throw new JsonRpcError('unexpected response message');
-};
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
-  }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
-  }
-  return undefined;
-};
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      message: error.message,
-      data: error.stack
-    };
-  }
-  return {
-    code: Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      type: getType(prettyError),
-      code: prettyError.code,
-      name: prettyError.name
-    }
-  };
-};
-const create$1$1 = (message, error) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error
-  };
-};
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
-};
-const create$7 = (message, result) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    result: result ?? null
-  };
-};
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$7(message, resultProperty);
-};
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
-  try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
-  }
-};
-const defaultPreparePrettyError = error => {
-  return error;
-};
-const defaultLogError = () => {
-  // ignore
-};
-const defaultRequiresSocket = () => {
-  return false;
-};
-const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
-  if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
-  }
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
-  }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-    return;
-  }
-  throw new JsonRpcError('unexpected message');
-};
-const send$1 = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$2 = async (ipc, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  ipc.send(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
-};
-const invokeAndTransfer$1 = async (ipc, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  ipc.sendAndTransfer(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
-};
-
-const state$3 = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined
-};
-const get$1 = () => {
-  return state$3.ipc;
-};
-const set$1 = ipc => {
-  state$3.ipc = ipc;
-};
-
-const invoke$1 = (method, ...params) => {
-  const ipc = get$1();
-  return invoke$2(ipc, method, ...params);
-};
-const invokeAndTransfer = async (method, ...params) => {
-  const ipc = get$1();
-  return invokeAndTransfer$1(ipc, method, ...params);
-};
-const listen$5 = ipc => {
-  set$1(ipc);
-};
-
-const create$6 = async canvasId => {
-  number$1(canvasId);
-  const {
-    id,
-    promise
-  } = registerPromise();
-  await invoke$1('OffscreenCanvas.createForTerminal', canvasId, id);
-  const response = await promise;
-  const canvas = response;
-  return canvas;
-};
-const handleResult = (id, result) => {
-  resolve(id, result);
-};
-
-const state$2 = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
-  /**
-   * @type {any}
-   */
-  ipcPromise: undefined
-};
-
-const state$1 = {
-  commands: Object.create(null)
-};
-const registerCommand = (key, fn) => {
-  state$1.commands[key] = fn;
-};
-const registerCommands = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
-};
-const getCommand = key => {
-  return state$1.commands[key];
-};
-
-const processName = 'terminal-worker';
-
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`[${processName}] command not found ${command}`);
-  }
-  return fn(...args);
-};
-
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
-};
-const logError = error => {
-  console.error(error);
-};
-const handleMessage$1 = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
-};
-
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage$1);
-  } else {
-    ipc.onmessage = handleMessage$1;
-  }
-};
-
-const NodeAlternate = 8;
-
-const getModule$1 = method => {
-  switch (method) {
-    case NodeAlternate:
-      return Promise.resolve().then(function () { return IpcParentWithNodeAlternate; });
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const create$5 = async ({
-  method,
-  ...options
-}) => {
-  const module = await getModule$1(method);
-  // @ts-ignore
-  const rawIpc = await module.create(options);
-  if (options.raw) {
-    return rawIpc;
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const normalizeLine$1 = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
-  }
-  return line;
-};
-const getCombinedMessage$1 = (error, message) => {
-  const stringifiedError = normalizeLine$1(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-const mergeStacks$1 = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
-let VError$1 = class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage$1(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks$1(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-};
-
-const launchTerminalProcess = async () => {
-  try {
-    const ipc = await create$5({
-      method: NodeAlternate,
-      type: 'terminal-process',
-      name: 'Terminal Process',
-      initialCommand: 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess'
-    });
-    state$2.ipc = ipc;
-    handleIpc(ipc);
-  } catch (error) {
-    throw new VError$1(error, 'Failed to create terminal connection');
-  }
-};
-
-const listen$2 = async () => {
-  await launchTerminalProcess();
-};
-const invoke = (method, ...params) => {
-  return invoke$2(state$2.ipc, method, ...params);
-};
-const send = (method, ...params) => {
-  return send$1(state$2.ipc, method, ...params);
-};
-
-const BACKGROUND = "#c00ccc";
-const CHAR_WIDTH$2 = 12;
-const CHAR_HEIGHT$2 = 15;
-
-/**
- *
- * @param {HTMLCanvasElement} canvas
- * @returns
- */
-const createDrawCursor = canvas => {
-  const ctx = canvas.getContext("2d");
-  let previousX = -1;
-  let previousY = -1;
-  let previousCursorStyle = -1;
-  const drawCursor = (x, y, cursorVisible, cursorStyle) => {
-    if (cursorVisible) {
-      if (previousX === x && previousY === y && previousCursorStyle === cursorStyle) {
-        return;
-      }
-      ctx.clearRect(previousX * CHAR_WIDTH$2, previousY * CHAR_HEIGHT$2, CHAR_WIDTH$2, CHAR_HEIGHT$2);
-      switch (cursorStyle) {
-        case /* bar */1:
-          break;
-        case /* block */2:
-          ctx.fillStyle = BACKGROUND;
-          ctx.fillRect(x * CHAR_WIDTH$2, y * CHAR_HEIGHT$2, CHAR_WIDTH$2, CHAR_HEIGHT$2);
-          break;
-        case /* underline */3:
-          break;
-        case /* blur */4:
-          ctx.strokeStyle = BACKGROUND;
-          ctx.strokeRect(x * CHAR_WIDTH$2, y * CHAR_HEIGHT$2, CHAR_WIDTH$2, CHAR_HEIGHT$2);
-          break;
-      }
-      previousX = x;
-      previousY = y;
-    } else {
-      ctx.clearRect(previousX * CHAR_WIDTH$2, previousY * CHAR_HEIGHT$2, CHAR_WIDTH$2, CHAR_HEIGHT$2);
-    }
-  };
-  return drawCursor;
-};
-
-const CHAR_WIDTH$1 = 12;
-const CHAR_HEIGHT$1 = 15;
-
-const supportsOffscreenCanvas = true;
-
-const supportsTransferToImageBitMap = (() => {
-  try {
-    supportsOffscreenCanvas ? (() => {
-      const canvas = new OffscreenCanvas(CHAR_WIDTH$1, CHAR_HEIGHT$1);
-      canvas.getContext("2d");
-      canvas.transferToImageBitmap();
-    })() : (() => {
-      const canvas = document.createElement("canvas");
-      canvas.width = CHAR_WIDTH$1;
-      canvas.height = CHAR_HEIGHT$1;
-      canvas.transferToImageBitmap();
-    })();
-    return true;
-  } catch {
-    return false;
-  }
-})();
-
-const tmpCanvas = new OffscreenCanvas(CHAR_WIDTH$1, CHAR_HEIGHT$1) ;
-const tmpCtx = tmpCanvas.getContext("2d", {
-  // desynchronized: true, // perf
-  alpha: false // perf
-});
-const bitmapCache = Object.create(null);
-const createDrawLines = (canvas, lines, bufferLines, offsets, attributes, rows, cols, defaultBackground, defaultForeground) => {
-  const ctx = canvas.getContext("2d", {
-    // desynchronized: true, // perf
-    alpha: false // perf
-  });
-  ctx.fillStyle = defaultBackground;
-  const drawChar = (char, x, y, background, foreground) => {
-    if (char === " " && background === defaultBackground) {
-      return;
-    }
-    const cacheKey = `${char}${background}${foreground}`;
-    if (!(cacheKey in bitmapCache)) {
-      tmpCtx.fillStyle = background;
-      tmpCtx.fillRect(0, 0, CHAR_WIDTH$1, CHAR_HEIGHT$1);
-      tmpCtx.font = `${CHAR_HEIGHT$1}px monospace`;
-      tmpCtx.fillStyle = foreground;
-      tmpCtx.fillText(char, 0, CHAR_HEIGHT$1);
-      bitmapCache[cacheKey] = supportsTransferToImageBitMap ? tmpCanvas.transferToImageBitmap() : tmpCtx.getImageData(0, 0, CHAR_WIDTH$1, CHAR_HEIGHT$1);
-    }
-    supportsTransferToImageBitMap ? ctx.drawImage(bitmapCache[cacheKey], x * CHAR_WIDTH$1, y * CHAR_HEIGHT$1) : ctx.putImageData(bitmapCache[cacheKey], x * CHAR_WIDTH$1, y * CHAR_HEIGHT$1);
-  };
-  const getChars = y => {
-    const text = new TextDecoder().decode(lines[y].subarray(0, offsets[y]));
-    const chars = [...text];
-    return chars;
-  };
-  const drawLine = (bufferY, positionY) => {
-    let x = -1;
-    const chars = getChars(bufferY);
-    // const chars = lines[y]
-    const attributesOnLine = attributes[bufferY] || {};
-    let currentAttributes = {
-      foreground: defaultForeground,
-      background: defaultBackground
-    };
-    while (++x < chars.length) {
-      currentAttributes = attributesOnLine[x] || currentAttributes;
-      // const { char, background, foreground } = chars[x]
-      const char = chars[x];
-      const background = currentAttributes.background || defaultBackground;
-      const foreground = currentAttributes.foreground || defaultForeground;
-      drawChar(char, x, positionY, background, foreground);
-    }
-  };
-  const clearLines = (x, y, width, height) => {
-    // ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height)
-    ctx.fillRect(x * CHAR_WIDTH$1, y * CHAR_HEIGHT$1, width * CHAR_WIDTH$1, height * CHAR_HEIGHT$1);
-  };
-  const drawLines = (start, end, bufferYEnd) => {
-    // // console.log('draw all lines')
-    // console.log({ start, end })
-    // console.log({ bufferYEnd })
-    clearLines(0, start, cols, end - start);
-    if (bufferYEnd < rows) {
-      for (let i = 0; i < rows - bufferYEnd; i++) {
-        drawLine(bufferLines - i - 1, rows - i);
-      }
-      for (let i = 0; i < bufferYEnd + 1; i++) {
-        drawLine(i, rows - (bufferYEnd - i));
-      }
-    } else {
-      for (let i = 0; i < rows; i++) {
-        drawLine(bufferYEnd - i, rows - i);
-      }
-    }
-  };
-  return drawLines;
-};
-
-const TopLevelContent = 1;
-const Escaped = 2;
-const Csi = 3;
-const AfterEscape3 = 4;
-const Charset = 5;
-const AfterEscape3AfterSemicolon = 6;
-const Osc = 8;
-const Dcs = 9;
-const AfterQuestionMark = 10;
-const AfterQuestionMark2 = 11;
-const AfterExclamationMark = 12;
-const AfterSpace = 14;
-const Osc2 = 16;
-const Osc3 = 17;
-
-const parseArray = (array, {
-  eraseInDisplay,
-  eraseToEndOfLine,
-  goToHome,
-  setCharAttributes,
-  bell,
-  cursorUp,
-  cursorDown,
-  cursorRight,
-  cursorLeft,
-  backspace,
-  print,
-  setGLevel,
-  saveCursor,
-  restoreCursor,
-  index,
-  tabSet,
-  reverseIndex,
-  keypadApplicationMode,
-  keypadNumericMode,
-  fullReset,
-  nextLine,
-  carriageReturn,
-  deleteCharacters,
-  setWindowTitle,
-  cursorPosition,
-  softTerminalReset,
-  cursorNextLine,
-  cursorPrecedingLine,
-  cursorCharacterAbsolute,
-  cursorForwardTabulation,
-  cursorBackwardTabulation,
-  insertLines,
-  deleteLines,
-  scrollUp,
-  scrollDown,
-  eraseCharacters,
-  characterPositionAbsolute,
-  characterPositionRelative,
-  repeatPrecedingGraphicCharacter,
-  sendDeviceAttributesPrimary,
-  sendDeviceAttributesTertiary,
-  linePositionAbsolute,
-  eraseInLine,
-  linePositionRelative,
-  horizontalAndVerticalPosition,
-  tabClear,
-  setMode,
-  resetMode,
-  lineFeed,
-  privateModeSet,
-  privateModeReset,
-  setCursorStyle,
-  shiftLeftColumns,
-  insertBlankCharacters,
-  setTextParameters
-}) => {
-  // let state = State.TopLevelContent
-  // let i = 0
-  // let currentParam
-  // let params = []
-  // let printStartIndex = -1
-
-  if (!(array instanceof Uint8Array)) {
-    throw new Error("invalid data, must be of type Uint8Array");
-  }
-  let state = TopLevelContent;
-  let i = 0;
-  let currentParam = 0;
-  let params = [];
-  let printStartIndex = -1;
-  while (i < array.length) {
-    const value = array[i];
-    switch (state) {
-      case TopLevelContent:
-        middle: switch (value) {
-          case 1:
-          case 2:
-          case 3:
-          case 4:
-          case 5:
-          case 6:
-            i++;
-            break;
-          case /* \u0007 */7:
-            bell();
-            i++;
-            break;
-          case /* \u0008 */8:
-            backspace();
-            i++;
-            break;
-          case /* \t */9:
-            i++;
-            break;
-          case /* \n */10:
-            lineFeed();
-            i++;
-            break;
-          case 11:
-          case 12:
-            i++;
-            break;
-          case /* \r */13:
-            carriageReturn();
-            i++;
-            break;
-          case 14:
-          case 15:
-          case 16:
-          case 17:
-          case 18:
-          case 19:
-          case 20:
-          case 21:
-          case 22:
-          case 23:
-          case 24:
-          case 25:
-          case 26:
-            i++;
-            break;
-          case /* \u001b */27:
-            state = Escaped;
-            i++;
-            break;
-          case 28:
-          case 29:
-          case 30:
-          case 31:
-            i++;
-            break;
-          case 32:
-          case 33:
-          case 34:
-          case 35:
-          case 36:
-          case 37:
-          case 38:
-          case 39:
-          case 40:
-          case 41:
-          case 42:
-          case 43:
-          case 44:
-          case 45:
-          case 46:
-          case 47:
-          case 48:
-          case 49:
-          case 50:
-          case 51:
-          case 52:
-          case 53:
-          case 54:
-          case 55:
-          case 56:
-          case 57:
-          case 58:
-          case 59:
-          case 60:
-          case 61:
-          case 62:
-          case 63:
-          case 64:
-          case 65:
-          case 66:
-          case 67:
-          case 68:
-          case 69:
-          case 70:
-          case 71:
-          case 72:
-          case 73:
-          case 74:
-          case 75:
-          case 76:
-          case 77:
-          case 78:
-          case 79:
-          case 80:
-          case 81:
-          case 82:
-          case 83:
-          case 84:
-          case 85:
-          case 86:
-          case 87:
-          case 88:
-          case 89:
-          case 90:
-          case 91:
-          case 92:
-          case 93:
-          case 94:
-          case 95:
-          case 96:
-          case 97:
-          case 98:
-          case 99:
-          case 100:
-          case 101:
-          case 102:
-          case 103:
-          case 104:
-          case 105:
-          case 106:
-          case 107:
-          case 108:
-          case 109:
-          case 110:
-          case 111:
-          case 112:
-          case 113:
-          case 114:
-          case 115:
-          case 116:
-          case 117:
-          case 118:
-          case 119:
-          case 120:
-          case 121:
-          case 122:
-          case 123:
-          case 124:
-          case 125:
-          case 126:
-          case 127:
-            printStartIndex = i++;
-            while (i < array.length) {
-              const element = array[i];
-              if (element >= 32 && element < 126) {
-                i++;
-                continue;
-              }
-              switch (element) {
-                case /* \u001b */27:
-                  print(array, printStartIndex, i);
-                  state = Escaped;
-                  i++;
-                  break middle;
-                case /* \u0007 */7:
-                  print(array, printStartIndex, i);
-                  bell();
-                  i++;
-                  state = TopLevelContent;
-                  break middle;
-                case /* \u0008 */8:
-                  print(array, printStartIndex, i);
-                  backspace();
-                  i++;
-                  state = TopLevelContent;
-                  break middle;
-                case /* \r */13:
-                  print(array, printStartIndex, i);
-                  carriageReturn();
-                  i++;
-                  state = TopLevelContent;
-                  break middle;
-                default:
-                  i++;
-                  break;
-              }
-            }
-            print(array, printStartIndex, i);
-            break;
-          default:
-            // TODO this is slow
-            throw new Error("no");
-        }
-        break;
-      case Escaped:
-        switch (value) {
-          case /* ( */40:
-            state = Charset;
-            break;
-          case /* [ */91:
-            params = [];
-            state = Csi;
-            break;
-          case /* ] */93:
-            state = Osc;
-            break;
-          case /* P */80:
-            state = Dcs;
-            break;
-          case /* _ */95:
-            break;
-          case /* ^ */94:
-            break;
-          case /* c */99:
-            break;
-          case /* E */69:
-            nextLine();
-          case /* D */68:
-            index();
-            break;
-          case /* 7 */55:
-            saveCursor();
-            state = TopLevelContent;
-            break;
-          case /* 8 */56:
-            backspace();
-            state = TopLevelContent;
-            break;
-          case /* H */72:
-            tabSet();
-            break;
-          default:
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case Charset:
-        i++;
-        break;
-      case Csi:
-        switch (value) {
-          case /*   */32:
-            state = AfterSpace;
-            break;
-          case /* ! */33:
-            state = AfterExclamationMark;
-            break;
-          case /* 0 */48:
-          case /* 1 */49:
-          case /* 2 */50:
-          case /* 3 */51:
-          case /* 4 */52:
-          case /* 5 */53:
-          case /* 6 */54:
-          case /* 7 */55:
-          case /* 8 */56:
-          case /* 9 */57:
-            currentParam = value - 48;
-            state = AfterEscape3;
-            break;
-          case /* ? */63:
-            state = AfterQuestionMark;
-            break;
-          case /* @ */64:
-            insertBlankCharacters(params);
-            state = TopLevelContent;
-            break;
-          case /* A */65:
-            cursorUp(params);
-            state = TopLevelContent;
-            break;
-          case /* B */66:
-            cursorDown(params);
-            state = TopLevelContent;
-            break;
-          case /* C */67:
-            cursorRight(params);
-            state = TopLevelContent;
-            break;
-          case /* D */68:
-            cursorLeft(params);
-            state = TopLevelContent;
-            break;
-          case /* E */69:
-            cursorNextLine(params);
-            state = TopLevelContent;
-            break;
-          case /* F */70:
-            cursorPrecedingLine(params);
-            state = TopLevelContent;
-            break;
-          case /* G */71:
-            cursorCharacterAbsolute(params);
-            state = TopLevelContent;
-            break;
-          case /* H */72:
-            cursorPosition(params);
-            state = TopLevelContent;
-            break;
-          case /* I */73:
-            cursorForwardTabulation(params);
-            state = TopLevelContent;
-            break;
-          case /* J */74:
-            eraseInDisplay(params);
-            state = TopLevelContent;
-            break;
-          case /* K */75:
-            eraseInLine(params);
-            state = TopLevelContent;
-            break;
-          case /* L */76:
-            insertLines(params);
-            state = TopLevelContent;
-            break;
-          case /* M */77:
-            deleteLines(params);
-            state = TopLevelContent;
-            break;
-          case /* P */80:
-            deleteCharacters(params);
-            state = TopLevelContent;
-            break;
-          case /* S */83:
-            scrollUp(params);
-            state = TopLevelContent;
-            break;
-          case /* T */84:
-            scrollDown(params);
-            state = TopLevelContent;
-            break;
-          case /* X */88:
-            eraseCharacters(params);
-            state = TopLevelContent;
-            break;
-          case /* Z */90:
-            cursorBackwardTabulation(params);
-            state = TopLevelContent;
-            break;
-          case /* ^ */94:
-            scrollDown(params);
-            state = TopLevelContent;
-            break;
-          case /* ` */96:
-            characterPositionAbsolute(params);
-            state = TopLevelContent;
-            break;
-          case /* a */97:
-            characterPositionRelative(params);
-            state = TopLevelContent;
-            break;
-          case /* b */98:
-            repeatPrecedingGraphicCharacter(params);
-            state = TopLevelContent;
-            break;
-          case /* d */100:
-            linePositionAbsolute(params);
-            state = TopLevelContent;
-            break;
-          case /* e */101:
-            linePositionRelative(params);
-            state = TopLevelContent;
-            break;
-          case /* f */102:
-            horizontalAndVerticalPosition(params);
-            state = TopLevelContent;
-            break;
-          case /* g */103:
-            tabClear(params);
-            state = TopLevelContent;
-            break;
-          case /* h */104:
-            setMode(params);
-            state = TopLevelContent;
-            break;
-          case /* l */108:
-            resetMode(params);
-            state = TopLevelContent;
-            break;
-          case /* m */109:
-            setCharAttributes(params);
-            state = TopLevelContent;
-            break;
-          case /* u */117:
-            restoreCursor();
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case AfterEscape3:
-        switch (value) {
-          case /*   */32:
-            params.push(currentParam);
-            state = AfterSpace;
-            break;
-          case /* ; */59:
-            params.push(currentParam);
-            state = AfterEscape3AfterSemicolon;
-            break;
-          case /* 0 */48:
-          case /* 1 */49:
-          case /* 2 */50:
-          case /* 3 */51:
-          case /* 4 */52:
-          case /* 5 */53:
-          case /* 6 */54:
-          case /* 7 */55:
-          case /* 8 */56:
-          case /* 9 */57:
-            currentParam = currentParam * 10 + value - 48;
-            break;
-          case /* @ */64:
-            params.push(currentParam);
-            insertBlankCharacters(params);
-            state = TopLevelContent;
-            break;
-          case /* A */65:
-            params.push(currentParam);
-            cursorUp(params);
-            state = TopLevelContent;
-            break;
-          case /* B */66:
-            params.push(currentParam);
-            cursorDown(params);
-            state = TopLevelContent;
-            break;
-          case /* C */67:
-            params.push(currentParam);
-            cursorRight(params);
-            state = TopLevelContent;
-            break;
-          case /* D */68:
-            params.push(currentParam);
-            cursorLeft(params);
-            state = TopLevelContent;
-            break;
-          case /* E */69:
-            params.push(currentParam);
-            cursorNextLine(params);
-            state = TopLevelContent;
-            break;
-          case /* F */70:
-            params.push(currentParam);
-            cursorPrecedingLine(params);
-            state = TopLevelContent;
-            break;
-          case /* G */71:
-            params.push(currentParam);
-            cursorCharacterAbsolute(params);
-            state = TopLevelContent;
-            break;
-          case /* H */72:
-            params.push(currentParam);
-            cursorPosition(params);
-            state = TopLevelContent;
-            break;
-          case /* I */73:
-            params.push(currentParam);
-            cursorForwardTabulation(params);
-            state = TopLevelContent;
-            break;
-          case /* J */74:
-            params.push(currentParam);
-            eraseInDisplay(params);
-            state = TopLevelContent;
-            break;
-          case /* K */75:
-            params.push(currentParam);
-            eraseInLine(params);
-            state = TopLevelContent;
-            break;
-          case /* L */76:
-            params.push(currentParam);
-            insertLines(params);
-            state = TopLevelContent;
-            break;
-          case /* M */77:
-            params.push(currentParam);
-            deleteLines(params);
-            state = TopLevelContent;
-            break;
-          case /* P */80:
-            params.push(currentParam);
-            deleteCharacters(params);
-            state = TopLevelContent;
-            break;
-          case /* S */83:
-            params.push(currentParam);
-            scrollUp(params);
-            state = TopLevelContent;
-            break;
-          case /* T */84:
-            params.push(currentParam);
-            scrollDown(params);
-            state = TopLevelContent;
-            break;
-          case /* X */88:
-            params.push(currentParam);
-            eraseCharacters(params);
-            state = TopLevelContent;
-            break;
-          case /* Z */90:
-            params.push(currentParam);
-            cursorBackwardTabulation(params);
-            state = TopLevelContent;
-            break;
-          case /* ^ */94:
-            params.push(currentParam);
-            scrollDown(params);
-            state = TopLevelContent;
-            break;
-          case /* ` */96:
-            params.push(currentParam);
-            characterPositionAbsolute(params);
-            state = TopLevelContent;
-            break;
-          case /* a */97:
-            params.push(currentParam);
-            characterPositionRelative(params);
-            state = TopLevelContent;
-            break;
-          case /* b */98:
-            params.push(currentParam);
-            repeatPrecedingGraphicCharacter(params);
-            state = TopLevelContent;
-            break;
-          case /* d */100:
-            params.push(currentParam);
-            linePositionAbsolute(params);
-            state = TopLevelContent;
-            break;
-          case /* e */101:
-            params.push(currentParam);
-            linePositionRelative(params);
-            state = TopLevelContent;
-            break;
-          case /* f */102:
-            params.push(currentParam);
-            horizontalAndVerticalPosition(params);
-            state = TopLevelContent;
-            break;
-          case /* g */103:
-            params.push(currentParam);
-            tabClear(params);
-            state = TopLevelContent;
-            break;
-          case /* h */104:
-            params.push(currentParam);
-            setMode(params);
-            state = TopLevelContent;
-            break;
-          case /* l */108:
-            params.push(currentParam);
-            resetMode(params);
-            state = TopLevelContent;
-            break;
-          case /* m */109:
-            params.push(currentParam);
-            setCharAttributes(params);
-            state = TopLevelContent;
-            break;
-          default:
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case AfterEscape3AfterSemicolon:
-        switch (value) {
-          case /* 0 */48:
-          case /* 1 */49:
-          case /* 2 */50:
-          case /* 3 */51:
-          case /* 4 */52:
-          case /* 5 */53:
-          case /* 6 */54:
-          case /* 7 */55:
-          case /* 8 */56:
-          case /* 9 */57:
-            currentParam = value - 48;
-            state = AfterEscape3;
-            break;
-        }
-        i++;
-        break;
-      case AfterQuestionMark:
-        switch (value) {
-          case /* 0 */48:
-          case /* 1 */49:
-          case /* 2 */50:
-          case /* 3 */51:
-          case /* 4 */52:
-          case /* 5 */53:
-          case /* 6 */54:
-          case /* 7 */55:
-          case /* 8 */56:
-          case /* 9 */57:
-            currentParam = value - 48;
-            state = AfterQuestionMark2;
-            break;
-          case /* J */74:
-            eraseInDisplay(params);
-            state = TopLevelContent;
-            break;
-          case /* K */75:
-            eraseInLine(params);
-            state = TopLevelContent;
-            break;
-          case /* h */104:
-            privateModeSet(params);
-            state = TopLevelContent;
-            break;
-          case /* l */108:
-            privateModeReset(params);
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case AfterQuestionMark2:
-        switch (value) {
-          case /* 0 */48:
-          case /* 1 */49:
-          case /* 2 */50:
-          case /* 3 */51:
-          case /* 4 */52:
-          case /* 5 */53:
-          case /* 6 */54:
-          case /* 7 */55:
-          case /* 8 */56:
-          case /* 9 */57:
-            currentParam = currentParam * 10 + value - 48;
-            break;
-          case /* ; */59:
-            params.push(currentParam);
-            state = AfterQuestionMark;
-            break;
-          case /* J */74:
-            params.push(currentParam);
-            eraseInDisplay(params);
-            state = TopLevelContent;
-            break;
-          case /* K */75:
-            params.push(currentParam);
-            eraseInLine(params);
-            state = TopLevelContent;
-            break;
-          case /* h */104:
-            params.push(currentParam);
-            privateModeSet(params);
-            state = TopLevelContent;
-            break;
-          case /* l */108:
-            params.push(currentParam);
-            privateModeReset(params);
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case AfterExclamationMark:
-        switch (value) {
-          case /* p */112:
-            softTerminalReset();
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case AfterSpace:
-        switch (value) {
-          case /* @ */64:
-            shiftLeftColumns(params);
-            state = TopLevelContent;
-            break;
-          case /* q */113:
-            setCursorStyle(params);
-            state = TopLevelContent;
-            break;
-          case /* t */116:
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case Osc:
-        switch (value) {
-          case /* 0 */48:
-          case /* 1 */49:
-          case /* 2 */50:
-          case /* 3 */51:
-          case /* 4 */52:
-          case /* 5 */53:
-          case /* 6 */54:
-          case /* 7 */55:
-          case /* 8 */56:
-          case /* 9 */57:
-            currentParam = value - 48;
-            state = Osc2;
-            break;
-          case /* \u0007 */7:
-            setTextParameters(params);
-            state = TopLevelContent;
-            break;
-        }
-        i++;
-        break;
-      case Osc2:
-        switch (value) {
-          case /* 0 */48:
-          case /* 1 */49:
-          case /* 2 */50:
-          case /* 3 */51:
-          case /* 4 */52:
-          case /* 5 */53:
-          case /* 6 */54:
-          case /* 7 */55:
-          case /* 8 */56:
-          case /* 9 */57:
-            currentParam = currentParam * 10 + value - 48;
-            break;
-          case /* ; */59:
-            params.push(currentParam);
-            state = Osc3;
-            break;
-        }
-        i++;
-        break;
-      case Osc3:
-        switch (value) {
-          case /* \u0007 */7:
-            setTextParameters(params);
-            state = TopLevelContent;
-            break;
-          default:
-            params.push(value);
-        }
-        i++;
-    }
-  }
-};
-
-// const demo = () => {
-//   const input = `simon (master *) playground $ `;
-//   createParse({
-//     cursorDown: () => console.log("cursor down"),
-//     cursorNextLine: () => console.log("cursor next line"),
-//     cursorCharacterAbsolute: () => console.log("cursor character absolute"),
-//     setCharAttributes: (params) => console.log("set char attributes", params),
-//     privateModeSet: (params) => console.log("private mode set", params),
-//     setMode: (params) => console.log("setMode", params),
-//     softTerminalReset: () => console.log("soft terminal reset"),
-//     setCursorStyle: (params) => console.log("set cursor style", params),
-//     restoreCursor: (params) => console.log("restore cursor", params),
-//     shiftLeftColumns: (params) => console.log("shiftLeftColumns", params),
-//     print: (params) => console.log("print", params),
-//     lineFeed: () => console.log("lineFeed"),
-//     bell: () => console.log("bell"),
-//     setTextParameters: (params) => console.log("set text parameters", params),
-//     carriageReturn: () => [],
-//     cursorPosition: () => {},
-//     eraseInDisplay: () => {},
-//     eraseInLine: () => {},
-//   })(new Uint8Array(Buffer.from(input, "utf-8")));
-// };
-
-// demo();
-
-const transformKey = event => {
-  const modifiers = (event.shiftKey ? 1 : 0) | (event.altKey ? 2 : 0) | (event.ctrlKey ? 4 : 0) | (event.metaKey ? 8 : 0);
-  switch (event.key) {
-    case "A":
-    case "B":
-    case "C":
-    case "D":
-    case "E":
-    case "F":
-    case "G":
-    case "H":
-    case "I":
-    case "J":
-    case "K":
-    case "L":
-    case "M":
-    case "N":
-    case "O":
-    case "P":
-    case "Q":
-    case "R":
-    case "S":
-    case "T":
-    case "U":
-    case "V":
-    case "W":
-    case "X":
-    case "Y":
-    case "Z":
-      if (event.ctrlKey) {
-        const char = String.fromCharCode(event.key.charCodeAt() - 64);
-        if (event.altKey) {
-          return `\u001b${char}`;
-        }
-        return char;
-      }
-      return event.key;
-    case "a":
-    case "b":
-    case "c":
-    case "d":
-    case "e":
-    case "f":
-    case "g":
-    case "h":
-    case "i":
-    case "j":
-    case "k":
-    case "l":
-    case "m":
-    case "n":
-    case "o":
-    case "p":
-    case "q":
-    case "r":
-    case "s":
-    case "t":
-    case "u":
-    case "v":
-    case "w":
-    case "x":
-    case "y":
-    case "z":
-      if (event.ctrlKey) {
-        // if (event.key === 'r' || event.key === 'l') {
-        //   event.preventDefault()
-        // }
-        const char = String.fromCharCode(event.key.charCodeAt() - 96);
-        if (event.altKey) {
-          return `\u001b${char}`;
-        }
-        return char;
-      }
-      return event.key;
-    case "F1":
-      return "\u001bOP";
-    case "F2":
-      return "\u001bOQ";
-    case "F3":
-      return "\u001bOR";
-    case "F4":
-      return "\u001bOS";
-    case "F5":
-      return "\u001b[15~";
-    case "F6":
-      return "\u001b[17~";
-    case "F7":
-      return "\u001b[18~";
-    case "F8":
-      return "\u001b[19~";
-    case "F9":
-      return "\u001b[20~";
-    case "F10":
-      return "\u001b[21~";
-    case "F11":
-      return "\u001b[23~";
-    case "F12":
-      return "\u001b[24~";
-    case "Home":
-      if (modifiers) {
-        return `\u001b[1;${modifiers + 1}H`;
-      }
-      return `\u001b[H`;
-    case "End":
-      if (modifiers) {
-        return `\u001b[1;${modifiers + 1}F`;
-      }
-      return `\u001b[F`;
-    case "Insert":
-      if (event.shiftKey || event.ctrlKey) {
-        return "";
-      }
-      return "\u001b[2~";
-    case "Delete":
-      if (modifiers) {
-        return `\u001b[3;${modifiers + 1}~`;
-      }
-      return "\u001b[3~";
-    case "ArrowUp":
-      // event.preventDefault()
-      if (modifiers) {
-        return `\u001b[1;${modifiers + 1}A`;
-      }
-      return "\u001b[A";
-    case "ArrowDown":
-      // event.preventDefault()
-      if (modifiers) {
-        return `\u001b[1;${modifiers + 1}B`;
-      }
-      return "\u001b[B";
-    case "ArrowRight":
-      // event.preventDefault()
-      if (modifiers) {
-        return `\u001b[1;${modifiers + 1}C`;
-      }
-      return "\u001b[C";
-    case "ArrowLeft":
-      // event.preventDefault()
-      if (modifiers) {
-        return `\u001b[1;${modifiers + 1}D`;
-      }
-      return "\u001b[D";
-    case "UIKeyInputUpArrow":
-      return "\u001b[A";
-    case "UIKeyInputDownArrow":
-      return "\u001b[B";
-    case "UIKeyInputRightArrow":
-      return "\u001b[C";
-    case "UIKeyInputLeftArrow":
-      return "\u001b[D";
-    case "Enter":
-      if (event.altKey) {
-        return "\u001b\r";
-      }
-      return "\n";
-    case "PageUp":
-      if (event.ctrlKey) {
-        return `\u001b[5;5~`;
-      }
-      return "\u001b[5~";
-    case "PageDown":
-      if (event.ctrlKey) {
-        return `\u001b[6;5~`;
-      }
-      return `\u001b[6~`;
-    case "Backspace":
-      if (event.altKey) {
-        return "\x17";
-      }
-      if (event.shiftKey) {
-        return "\u0008";
-      }
-      return "\x7f";
-    case "Tab":
-      // event.preventDefault()
-      if (event.shiftKey) {
-        return "\u001b[Z";
-      }
-      return "\t";
-    case "Escape":
-      if (event.altKey) {
-        return "\u001b\u001b";
-      }
-      return "\u001b";
-    case "/":
-      // event.preventDefault()
-      return "/";
-    case "?":
-      if (event.ctrlKey) {
-        return "\u007f";
-      }
-      if (event.altKey) {
-        return `\u001b?`;
-      }
-      return event.key;
-    case "|":
-      if (event.ctrlKey) {
-        return "\u001c";
-      }
-      if (event.altKey) {
-        return `\u001b|`;
-      }
-      return event.key;
-    case "{":
-      if (event.ctrlKey) {
-        return "\u001b";
-      }
-      if (event.altKey) {
-        return `\u001b{`;
-      }
-      return event.key;
-    case "}":
-      if (event.ctrlKey) {
-        return "\u001d";
-      }
-      if (event.altKey) {
-        return `\u001b}`;
-      }
-      return event.key;
-    case "_":
-      if (event.ctrlKey) {
-        return "\u001f";
-      }
-      if (event.altKey) {
-        return `\u001b_`;
-      }
-      return event.key;
-    case "^":
-      if (event.ctrlKey) {
-        return "\u001e";
-      }
-      if (event.altKey) {
-        return `\u001b^`;
-      }
-      return event.key;
-    case "@":
-      if (event.ctrlKey) {
-        return "\u0000";
-      }
-      if (event.altKey) {
-        return `\u001b@`;
-      }
-      return event.key;
-    case " ":
-      // event.preventDefault()
-      return ` `;
-    default:
-      if (event.key.length > 1) {
-        return "";
-      }
-      if (event.altKey) {
-        return `\u001b${event.key}`;
-      }
-      return event.key;
-  }
-};
-
-const CHAR_WIDTH = 13;
-const CHAR_HEIGHT = 15;
-const COLS = 80;
-const ROWS = 25;
-const BUFFER_LINES = 200;
-const noop = () => {};
-const createOffscreenTerminal = ({
-  background = "#000000",
-  foreground = "#ffffff",
-  handleInput,
-  bell = noop,
-  setWindowTitle = noop,
-  handleFocus = noop,
-  canvasText,
-  canvasCursor,
-  focusTextArea = noop
-}) => {
-  let focused = false;
-  const handleKeyDown = event => {
-    const transformedKey = transformKey(event);
-    if (transformedKey) {
-      handleInput(transformedKey);
-    }
-  };
-  const handleBlur = () => {
-    focused = false;
-    cursorStyle = /* blur */4;
-    requestAnimationFrame(render);
-  };
-  const focus = () => {
-    handleFocus();
-    if (focused) {
-      return;
-    }
-    focused = true;
-    cursorStyle = /* block */2;
-    focusTextArea();
-    requestAnimationFrame(render);
-  };
-  const WIDTH = COLS * CHAR_WIDTH;
-  const HEIGHT = ROWS * (CHAR_HEIGHT + 10);
-  canvasText.width = canvasCursor.width = WIDTH;
-  canvasText.height = canvasCursor.height = HEIGHT;
-  let bufferYEnd = ROWS;
-  let cursorYRelative = -ROWS;
-  let cursorXRelative = -COLS;
-  let cellForeground = "#ffffff";
-  let cellBackground = "#000000";
-  let cursorVisible = true;
-  let cursorStyle = /* block */2;
-  const dirty = {
-    start: 0,
-    end: 0
-  };
-
-  // self.stats = () => ({
-  //   cursorYRelative,
-  //   cursorXRelative,
-  //   x: COLS + cursorXRelative,
-  //   y: bufferYEnd + cursorYRelative,
-  // });
-
-  const lines = [];
-  // self.lines = lines;
-
-  const offsets = new Uint8Array(BUFFER_LINES);
-
-  // self.offsets = offsets;
-  let attributes = {};
-
-  // self.attributes = attributes;
-
-  for (let y = 0; y < BUFFER_LINES; y++) {
-    lines.push(new Uint8Array(300));
-  }
-  new TextDecoder();
-
-  // self.printLines = () => {
-  //   console.log(
-  //     lines.map((line, y) => textDecoder.decode(line.subarray(0, offsets[y])))
-  //   );
-  // };
-
-  const dirtyMark = y => {
-    // console.log('dirty' + y)
-    if (y < dirty.start) {
-      dirty.start = y;
-    } else if (y > dirty.end) {
-      dirty.end = y;
-    }
-  };
-  const dirtyClear = () => {
-    // console.log('dirty clear')
-    dirty.start = dirty.end = bufferYEnd + cursorYRelative;
-  };
-  const callbackFns = {
-    eraseInLine() {
-      const y = bufferYEnd + cursorYRelative;
-      const x = COLS + cursorXRelative;
-      offsets[y] = x;
-    },
-    eraseInDisplay() {
-      // console.log('erase in display')
-      offsets.fill(0);
-      cursorYRelative = -ROWS + 1;
-      cursorXRelative = -COLS;
-      bufferYEnd = ROWS;
-      for (const key of Object.keys(attributes)) {
-        delete attributes[key];
-      }
-      dirtyMark(0);
-      dirtyMark(ROWS);
-    },
-    setCharAttributes(params) {
-      if (params[1] === 7) {
-        [cellForeground, cellBackground] = [cellBackground, cellForeground];
-      } else if (params[1] === 35) {
-        cellForeground = "#8000ff";
-      } else if (params[1] === 32) {
-        cellForeground = "#09f900";
-      } else if (params[1] === 34) {
-        cellForeground = "#0090ff";
-      } else {
-        cellForeground = foreground;
-        cellBackground = background;
-      }
-      const y = bufferYEnd + cursorYRelative;
-      attributes[y] = attributes[y] || {};
-      attributes[y][offsets[y]] = {
-        foreground: cellForeground,
-        background: cellBackground
-      };
-    },
-    cursorUp() {
-      console.log("cursor up");
-    },
-    cursorDown() {
-      //       console.log('cursor down')
-    },
-    cursorRight() {
-      cursorXRelative++;
-    },
-    cursorLeft() {
-      console.log("cursor left");
-    },
-    backspace() {
-      cursorXRelative--;
-      // offsets[bufferYEnd + cursorYRelative]--
-    },
-    deleteChars(numberOfChars) {
-      const y = bufferYEnd + cursorYRelative;
-      // offsets[y] = x - 1
-      // cursorXRelative--
-      const x = COLS + cursorXRelative;
-      offsets[y] = x;
-    },
-    bell,
-    print(array, start, end) {
-      const subArray = array.subarray(start, end);
-      const y = bufferYEnd + cursorYRelative;
-      const x = COLS + cursorXRelative;
-      lines[y].set(subArray, x);
-      cursorXRelative += end - start;
-      offsets[y] = COLS + cursorXRelative;
-      dirtyMark(y);
-      if (x >= COLS - 1) {
-        // cursorYRelative++;
-        // console.log("wrap");
-        callbackFns.lineFeed();
-      }
-      // console.log("PRINT", { y, x, COLS, cursorXRelative, cursorYRelative });
-      // self.printLines();
-      // offsets[y] += end - start
-      // cursorXRelative = -COLS + offsets[y]
-    },
-    lineFeed() {
-      if (cursorYRelative === 0) {
-        bufferYEnd = (bufferYEnd + 1) % BUFFER_LINES;
-        offsets[bufferYEnd] = 0;
-        delete attributes[bufferYEnd];
-      } else {
-        cursorYRelative++;
-      }
-      cellForeground = foreground;
-      cellBackground = background;
-    },
-    carriageReturn() {
-      cursorXRelative = -COLS;
-    },
-    setWindowTitle,
-    cursorPosition(params) {
-      if (params.length === 2) {
-        const row = params[0];
-        const column = params[1];
-        cursorYRelative = -ROWS + row;
-        cursorXRelative = -COLS + column;
-      }
-    },
-    cursorShow() {
-      cursorVisible = true;
-    },
-    cursorHide() {
-      cursorVisible = false;
-    },
-    insertLines() {},
-    deleteLines() {},
-    setTextParameters() {},
-    privateModeSet() {},
-    privateModeReset() {},
-    eraseToEndOfLine() {},
-    goToHome() {},
-    setGLevel() {},
-    saveCursor() {},
-    restoreCursor() {},
-    index() {},
-    tabSet() {},
-    reverseIndex() {},
-    keypadApplicationMode() {},
-    keypadNumericMode() {},
-    fullReset() {},
-    nextLine() {},
-    deleteCharacters() {},
-    softTerminalReset() {},
-    cursorNextLine() {},
-    cursorPrecedingLine() {},
-    cursorCharacterAbsolute() {},
-    cursorForwardTabulation() {},
-    cursorBackwardTabulation() {},
-    scrollUp() {},
-    scrollDown() {},
-    eraseCharacters() {},
-    characterPositionAbsolute() {},
-    characterPositionRelative() {},
-    repeatPrecedingGraphicCharacter() {},
-    sendDeviceAttributesPrimary() {},
-    sendDeviceAttributesTertiary() {},
-    linePositionAbsolute() {},
-    linePositionRelative() {},
-    horizontalAndVerticalPosition() {},
-    tabClear() {},
-    setMode() {},
-    resetMode() {},
-    setCursorStyle() {},
-    shiftLeftColumns() {},
-    insertBlankCharacters() {}
-  };
-
-  // const parse = createParse(callbackFns);
-  const drawLines = createDrawLines(canvasText, lines, BUFFER_LINES, offsets, attributes, ROWS, COLS, background, foreground);
-  const drawCursor = createDrawCursor(canvasCursor);
-  let scheduled = false;
-
-  // self.drawLines = () => drawLines(dirty.start, dirty.end + 1);
-
-  const render = () => {
-    // console.log(dirty)
-    drawLines(dirty.start, dirty.end + 1, bufferYEnd);
-    const y = ROWS + cursorYRelative;
-    const x = COLS + cursorXRelative;
-    // TODO without closure
-    drawCursor(x, y, cursorVisible, cursorStyle);
-    scheduled = false;
-    dirtyClear();
-  };
-  const write = array => {
-    parseArray(array, callbackFns);
-    // if (lines.length > 1_000) {
-    //   lines.length = 1_000
-    // }
-    if (!scheduled) {
-      scheduled = true;
-      requestAnimationFrame(render);
-    }
-  };
-  const pasteText = text => {
-    // TODO bug first line not written
-    const fixedText = "\n" + text.replaceAll("\n", "\r\n");
-    const array = new TextEncoder().encode(fixedText);
-    write(array);
-  };
-  return {
-    write,
-    focus,
-    pasteText,
-    writeText: pasteText,
-    // TODO should this be exposed (only used for testing) maybe with _ prefix (internal)
-    lines,
-    handleKeyDown,
-    handleBlur,
-    handleMouseDown: focus
-  };
-};
-
-const create$4 = async ({
-  offscreenCanvasCursor,
-  offscreenCanvasText,
-  focusTextArea,
-  handleInput
-}) => {
-  object(offscreenCanvasCursor);
-  object(offscreenCanvasText);
-  const terminal = createOffscreenTerminal({
-    canvasCursor: offscreenCanvasCursor,
-    canvasText: offscreenCanvasText,
-    focusTextArea,
-    handleInput
-  });
-  return terminal;
-};
-
-const state = {
-  terminals: Object.create(null)
-};
-const get = id => {
-  return state.terminals[id];
-};
-const set = (id, terminal) => {
-  state.terminals[id] = terminal;
-};
-
-// electron sends uint8arrays directly
-// websocket sends the data as an object with data property
-// conpty sends the data as a string
-
-const toUint8Array = data => {
-  if (data instanceof Uint8Array) {
-    return data;
-  }
-  if (typeof data === 'string') {
-    return new TextEncoder().encode(data);
-  }
-  if (data.data) {
-    const actualData = data.data;
-    return new Uint8Array(actualData);
-  }
-  throw new Error('unexpected data type');
-};
-
-const create$3 = async (canvasTextId, canvasCursorId, id, cwd, command, args) => {
-  await listen$2();
-  const canvasCursor = await create$6(canvasCursorId);
-  const canvasText = await create$6(canvasTextId);
-  const emulator = await create$4({
-    offscreenCanvasCursor: canvasCursor,
-    offscreenCanvasText: canvasText,
-    focusTextArea() {
-      // TODO
-    },
-    handleInput(input) {
-      send('Terminal.write', id, input);
-    }
-  });
-  set(id, emulator);
-  await invoke('Terminal.create', id, cwd, command, args);
-};
-const handleMessage = (id, method, ...args) => {
-  const emulator = get(id);
-  if (method === 'handleData') {
-    const data = args[0];
-    const parsedData = toUint8Array(data);
-    emulator.write(parsedData);
-  }
-};
-const handleBlur = id => {
-  const emulator = get(id);
-  emulator.handleBlur();
-};
-const handleKeyDown = (id, key) => {
-  const emulator = get(id);
-  emulator.handleKeyDown(key);
-};
-const handleMouseDown = id => {
-  const emulator = get(id);
-  emulator.handleMouseDown();
-};
-
-const commandMap = {
-  'Terminal.create': create$3,
-  'Viewlet.send': handleMessage,
-  'Terminal.handleBlur': handleBlur,
-  'Terminal.handleKeyDown': handleKeyDown,
-  'Terminal.handleMouseDown': handleMouseDown,
-  'OffscreenCanvas.handleResult': handleResult
-};
-
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ReferencePort = 3;
-const ModuleWorkerAndMessagePort = 8;
-const Auto = () => {
-  if (globalThis.acceptPort) {
-    return MessagePort$1;
-  }
-  if (globalThis.acceptReferencePort) {
-    return ReferencePort;
-  }
-  return ModuleWorkerAndMessagePort;
-};
-
-const getData$1 = event => {
-  return event.data;
-};
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
-const isMessagePort = value => {
-  return value && value instanceof MessagePort;
-};
-const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === 'MessagePortMain';
-};
-const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
-};
-const isInstanceOf = (value, constructorName) => {
-  return value?.constructor?.name === constructorName;
-};
-const isSocket = value => {
-  return isInstanceOf(value, 'Socket');
-};
-const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
-const isTransferrable = value => {
-  for (const fn of transferrables) {
-    if (fn(value)) {
-      return true;
-    }
-  }
-  return false;
-};
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
-};
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
-  }
-}
-const readyMessage = 'ready';
-const listen$4 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
-};
-const signal$3 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-  }
-}
-const wrap$6 = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  listen: listen$4,
-  signal: signal$3,
-  wrap: wrap$6
-};
-const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
-const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
-const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine$1 = '\n';
-const joinLines = lines => {
-  return lines.join(NewLine$1);
-};
-const splitLines = lines => {
-  return lines.split(NewLine$1);
-};
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
-};
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
-  return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
-  };
-};
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
-};
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
-};
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
-};
-const getMessageCodeBlock = stderr => {
-  const lines = splitLines(stderr);
-  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
-  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
-  const relevantLines = lines.slice(startIndex, endIndex);
-  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
-  return relevantMessage;
-};
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
-};
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
-};
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
-};
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines(lines),
-      rest: []
-    };
-  }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break;
-    }
-  }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
-};
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
-  }
-  const lines = splitLines(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails(lines);
-  return {
-    message: `${actualMessage}`,
-    code: '',
-    stack: rest
-  };
-};
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
-  }
-  return line;
-};
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine = '\n';
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
-};
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex(parent);
-  const childNewLineIndex = getNewLineIndex(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
-class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-}
-let IpcError$1 = class IpcError extends VError {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        message,
-        code,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      // @ts-ignore
-      cause.code = code;
-      cause.stack = stack;
-      super(cause, betterMessage);
-    } else {
-      super(betterMessage);
-    }
-    // @ts-ignore
-    this.name = 'IpcError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
-  }
-};
-const withResolvers$1 = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = withResolvers$1();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
-};
-const listen$3 = async () => {
-  const parentIpcRaw = listen$4();
-  signal$3(parentIpcRaw);
-  const parentIpc = wrap$6(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError$1('unexpected first message');
-  }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      jsonrpc: '2.0',
-      id: firstMessage.id,
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
-  }
-  return globalThis;
-};
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    if (this._rawIpc.close) {
-      this._rawIpc.close();
-    }
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$5 = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
-};
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$3,
-  wrap: wrap$5
-};
-
-const getModule = method => {
-  switch (method) {
-    case ModuleWorker:
-      return IpcChildWithModuleWorker$1;
-    case ModuleWorkerAndMessagePort:
-      return IpcChildWithModuleWorkerAndMessagePort$1;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const listen$1 = async ({
-  method
-}) => {
-  const module = await getModule(method);
-  const rawIpc = await module.listen();
-  // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const listen = async () => {
-  registerCommands(commandMap);
-  const ipc = await listen$1({
-    method: Auto()
-  });
-  handleIpc(ipc);
-  listen$5(ipc);
-};
-
-const main = async () => {
-  await listen();
-};
-
-main();
-
-const getData = event => {
-  return event.data;
-};
-
-const Web = 'web';
-const Electron = 'electron';
-const Remote = 'remote';
-
-const getPlatform = () => {
-  // @ts-ignore
-  if (typeof PLATFORM !== 'undefined') {
-    // @ts-ignore
-    return PLATFORM;
-  }
-  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
-    return 'test';
-  }
-  // TODO find a better way to pass runtime environment
-  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
-    return Electron;
-  }
-  return Remote;
-};
-const platform = getPlatform(); // TODO tree-shake this out in production
-
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-const sendMessagePortToElectron = async (port, initialCommand) => {
-  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
-};
-
-const create$2 = async options => {
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  await sendMessagePortToElectron(port2, options.initialCommand);
-  return port1;
-};
-
-const create$1 = async options => {
-  switch (platform) {
-    case Web:
-    case Remote:
-      const module = await Promise.resolve().then(function () { return IpcParentWithWebSocket; });
-      const rawIpc = await module.create(options);
-      if (options.raw) {
-        return rawIpc;
-      }
-      return {
-        rawIpc,
-        module
-      };
-    case Electron:
-      return create$2(options);
-    default:
-      throw new Error('unsupported platform');
-  }
-};
-const wrap$1 = port => {
-  if (!(port instanceof MessagePort)) {
-    return port.module.wrap(port.rawIpc);
-  }
-  return {
-    port,
-    /**
-     * @type {any}
-     */
-    listener: undefined,
-    get onmessage() {
-      return this.listener;
-    },
-    set onmessage(listener) {
-      this.listener = listener;
-      const wrappedListener = event => {
-        const data = getData(event);
-        // @ts-ignore
-        listener({
-          data,
-          target: this
-        });
-      };
-      this.port.onmessage = wrappedListener;
-    },
-    send(message) {
-      this.port.postMessage(message);
-    },
-    sendAndTransfer(message, transfer) {
-      this.port.postMessage(message, transfer);
-    }
-  };
-};
-
-const IpcParentWithNodeAlternate = {
-  __proto__: null,
-  create: create$1,
-  wrap: wrap$1
-};
-
-const Open = 1;
-const Close = 2;
-const Error$1 = 3;
-
-const withResolvers = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-
-const getFirstEvent = (eventTarget, eventMap) => {
-  const {
-    resolve,
-    promise
-  } = withResolvers();
-  const listenerMap = Object.create(null);
-  const cleanup = value => {
-    for (const event of Object.keys(eventMap)) {
-      eventTarget.removeEventListener(event, listenerMap[event]);
-    }
-    resolve(value);
-  };
-  for (const [event, type] of Object.entries(eventMap)) {
-    const listener = event => {
-      cleanup({
-        type,
-        event
-      });
-    };
-    eventTarget.addEventListener(event, listener);
-    listenerMap[event] = listener;
-  }
-  return promise;
-};
-
-const waitForWebSocketToBeOpen = webSocket => {
-  return getFirstEvent(webSocket, {
-    open: Open,
-    close: Close,
-    error: Error$1
-  });
-};
-
-const Https = 'https:';
-const Ws = 'ws:';
-const Wss = 'wss:';
-
-const getWebSocketProtocol = () => {
-  return location.protocol === Https ? Wss : Ws;
-};
-
-const getWebSocketUrl = type => {
-  const wsProtocol = getWebSocketProtocol();
-  return `${wsProtocol}//${location.host}/websocket/${type}`;
-};
-
-class IpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'IpcError';
-  }
-}
-
-const stringifyCompact = value => {
-  return JSON.stringify(value);
-};
-
-const create = async ({
-  type
-}) => {
-  string(type);
-  const wsUrl = getWebSocketUrl(type);
-  const webSocket = new WebSocket(wsUrl);
-  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
-  if (firstWebSocketEvent.type === Error$1) {
-    throw new IpcError(`WebSocket connection error`);
-  }
-  if (firstWebSocketEvent.type === Close) {
-    throw new IpcError(`Websocket connection was closed`);
-  }
-  return webSocket;
-};
-const wrap = webSocket => {
-  return {
-    /**
-     * @type {any}
-     */
-    handleMessage: undefined,
-    webSocket,
-    get onmessage() {
-      return this.handleMessage;
-    },
-    set onmessage(listener) {
-      if (listener) {
-        // @ts-ignore
-        this.handleMessage = event => {
-          // TODO why are some events not instance of message event?
-          if (event instanceof MessageEvent) {
-            const data = JSON.parse(event.data);
-            // @ts-ignore
-            listener({
-              data,
-              target: this
-            });
-          } else {
-            // @ts-ignore
-            listener(event);
-          }
-        };
-      } else {
-        // @ts-ignore
-        this.handleMessage = null;
-      }
-      this.webSocket.onmessage = this.handleMessage;
-    },
-    send(message) {
-      if (this.webSocket.readyState !== webSocket.OPEN) {
-        // @ts-ignore
-        throw new VError$1(`Failed to send message: WebSocket is not open`);
-      }
-      const stringifiedMessage = stringifyCompact(message);
-      this.webSocket.send(stringifiedMessage);
-    }
-  };
-};
-
-const IpcParentWithWebSocket = {
-  __proto__: null,
-  create,
-  wrap
-};