@lvce-editor/static-server 0.45.14 → 0.45.16

package/static/{60d9b53 → 587acf8}/packages/terminal-worker/dist/terminalWorkerMain.js

@@ -1,4 +1,17 @@
-import { IpcChildWithModuleWorkerAndMessagePort, IpcChildWithModuleWorker } from '@lvce-editor/ipc/dist/browser.js';
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
+  }
+  return fn(...args);
+};
 
 class AssertionError extends Error {
   constructor(message) {
@@ -103,7 +116,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine$1 = '\n';
+const NewLine$2 = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -149,39 +162,39 @@ const constructError = (message, type, name) => {
   return new ErrorConstructor(message);
 };
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
+  return string.indexOf(NewLine$2, startIndex);
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$1 + parentStack;
+    parentStack = error.message + NewLine$2 + parentStack;
   }
   return parentStack;
 };
-const joinLines = lines => {
-  return lines.join(NewLine$1);
+const joinLines$1 = lines => {
+  return lines.join(NewLine$2);
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines = lines => {
-  return lines.split(NewLine$1);
+const splitLines$1 = lines => {
+  return lines.split(NewLine$2);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
+  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$1 + currentStack;
+    restoredError.stack = parentStack + NewLine$2 + 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$1 + error.data.stack + NewLine$1 + currentStack;
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$2 + error.data.stack + NewLine$2 + currentStack;
       } else if (error.data.stack) {
         restoredError.stack = error.data.stack;
       }
@@ -433,159 +446,6 @@ const handleResult = (id, result) => {
   resolve(id, result);
 };
 
-const state$1 = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined,
-  /**
-   * @type {any}
-   */
-  ipcPromise: undefined
-};
-
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`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 = 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;
-    }
-  }
-}
-
-const launchTerminalProcess = async () => {
-  try {
-    const ipc = await create$5({
-      method: NodeAlternate,
-      type: 'terminal-process',
-      name: 'Terminal Process',
-      initialCommand: 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess'
-    });
-    state$1.ipc = ipc;
-    handleIpc(ipc);
-  } catch (error) {
-    throw new VError(error, 'Failed to create terminal connection');
-  }
-};
-
-const listen$2 = async () => {
-  await launchTerminalProcess();
-};
-const invoke = (method, ...params) => {
-  return invoke$2(state$1.ipc, method, ...params);
-};
-const send = (method, ...params) => {
-  return send$1(state$1.ipc, method, ...params);
-};
-
 const BACKGROUND = "#c00ccc";
 const CHAR_WIDTH$2 = 12;
 const CHAR_HEIGHT$2 = 15;
@@ -1035,12 +895,9 @@ const parseArray = (array, {
           case /* c */99:
             break;
           case /* E */69:
-            nextLine();
           case /* D */68:
-            index();
             break;
           case /* 7 */55:
-            saveCursor();
             state = TopLevelContent;
             break;
           case /* 8 */56:
@@ -1048,7 +905,6 @@ const parseArray = (array, {
             state = TopLevelContent;
             break;
           case /* H */72:
-            tabSet();
             break;
           default:
             state = TopLevelContent;
@@ -1084,7 +940,6 @@ const parseArray = (array, {
             state = AfterQuestionMark;
             break;
           case /* @ */64:
-            insertBlankCharacters(params);
             state = TopLevelContent;
             break;
           case /* A */65:
@@ -1092,7 +947,6 @@ const parseArray = (array, {
             state = TopLevelContent;
             break;
           case /* B */66:
-            cursorDown(params);
             state = TopLevelContent;
             break;
           case /* C */67:
@@ -1104,15 +958,12 @@ const parseArray = (array, {
             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:
@@ -1120,7 +971,6 @@ const parseArray = (array, {
             state = TopLevelContent;
             break;
           case /* I */73:
-            cursorForwardTabulation(params);
             state = TopLevelContent;
             break;
           case /* J */74:
@@ -1132,71 +982,54 @@ const parseArray = (array, {
             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:
@@ -1204,7 +1037,6 @@ const parseArray = (array, {
             state = TopLevelContent;
             break;
           case /* u */117:
-            restoreCursor();
             state = TopLevelContent;
             break;
         }
@@ -1234,7 +1066,6 @@ const parseArray = (array, {
             break;
           case /* @ */64:
             params.push(currentParam);
-            insertBlankCharacters(params);
             state = TopLevelContent;
             break;
           case /* A */65:
@@ -1244,7 +1075,6 @@ const parseArray = (array, {
             break;
           case /* B */66:
             params.push(currentParam);
-            cursorDown(params);
             state = TopLevelContent;
             break;
           case /* C */67:
@@ -1259,17 +1089,14 @@ const parseArray = (array, {
             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:
@@ -1279,7 +1106,6 @@ const parseArray = (array, {
             break;
           case /* I */73:
             params.push(currentParam);
-            cursorForwardTabulation(params);
             state = TopLevelContent;
             break;
           case /* J */74:
@@ -1294,87 +1120,70 @@ const parseArray = (array, {
             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:
@@ -1430,11 +1239,9 @@ const parseArray = (array, {
             state = TopLevelContent;
             break;
           case /* h */104:
-            privateModeSet(params);
             state = TopLevelContent;
             break;
           case /* l */108:
-            privateModeReset(params);
             state = TopLevelContent;
             break;
         }
@@ -1470,12 +1277,10 @@ const parseArray = (array, {
             break;
           case /* h */104:
             params.push(currentParam);
-            privateModeSet(params);
             state = TopLevelContent;
             break;
           case /* l */108:
             params.push(currentParam);
-            privateModeReset(params);
             state = TopLevelContent;
             break;
         }
@@ -1484,7 +1289,6 @@ const parseArray = (array, {
       case AfterExclamationMark:
         switch (value) {
           case /* p */112:
-            softTerminalReset();
             state = TopLevelContent;
             break;
         }
@@ -1493,11 +1297,9 @@ const parseArray = (array, {
       case AfterSpace:
         switch (value) {
           case /* @ */64:
-            shiftLeftColumns(params);
             state = TopLevelContent;
             break;
           case /* q */113:
-            setCursorStyle(params);
             state = TopLevelContent;
             break;
           case /* t */116:
@@ -1522,7 +1324,6 @@ const parseArray = (array, {
             state = Osc2;
             break;
           case /* \u0007 */7:
-            setTextParameters(params);
             state = TopLevelContent;
             break;
         }
@@ -1552,7 +1353,6 @@ const parseArray = (array, {
       case Osc3:
         switch (value) {
           case /* \u0007 */7:
-            setTextParameters(params);
             state = TopLevelContent;
             break;
           default:
@@ -2139,7 +1939,7 @@ const createOffscreenTerminal = ({
   };
 };
 
-const create$4 = async ({
+const create$5 = async ({
   offscreenCanvasCursor,
   offscreenCanvasText,
   focusTextArea,
@@ -2156,160 +1956,43 @@ const create$4 = async ({
   return terminal;
 };
 
-const state = {
+const state$1 = {
   terminals: Object.create(null)
 };
 const get = id => {
-  return state.terminals[id];
+  return state$1.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');
+  state$1.terminals[id] = terminal;
 };
 
-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 requiresSocket = () => {
+  return false;
 };
-const handleKeyDown = (id, key) => {
-  const emulator = get(id);
-  emulator.handleKeyDown(key);
+const preparePrettyError = error => {
+  return error;
 };
-const handleMouseDown = id => {
-  const emulator = get(id);
-  emulator.handleMouseDown();
+const logError = error => {
+  console.error(error);
 };
-
-const commandMap = {
-  'Terminal.create': create$3,
-  'Viewlet.send': handleMessage,
-  'Terminal.handleBlur': handleBlur,
-  'Terminal.handleKeyDown': handleKeyDown,
-  'Terminal.handleMouseDown': handleMouseDown,
-  'OffscreenCanvas.handleResult': handleResult
+const handleMessage$1 = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
 };
 
-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;
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage$1);
+  } else {
+    ipc.onmessage = handleMessage$1;
   }
-  return ModuleWorkerAndMessagePort;
 };
 
-const getModule = method => {
-  switch (method) {
-    case ModuleWorker:
-      return IpcChildWithModuleWorker;
-    case ModuleWorkerAndMessagePort:
-      return IpcChildWithModuleWorkerAndMessagePort;
-    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 () => {
-  register(commandMap);
-  const ipc = await listen$1({
-    method: Auto()
-  });
-  handleIpc(ipc);
-  listen$3(ipc);
-};
-
-const main = async () => {
-  await listen();
-};
-
-main();
+const NodeAlternate = 8;
 
 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,
@@ -2325,7 +2008,7 @@ const sendMessagePortToElectron = async (port, initialCommand) => {
   await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
 };
 
-const create$2 = async options => {
+const create$4 = async options => {
   const {
     port1,
     port2
@@ -2334,70 +2017,11 @@ const create$2 = async options => {
   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 = () => {
+const withResolvers$1 = () => {
   let _resolve;
   const promise = new Promise(resolve => {
     _resolve = resolve;
@@ -2412,7 +2036,7 @@ const getFirstEvent = (eventTarget, eventMap) => {
   const {
     resolve,
     promise
-  } = withResolvers();
+  } = withResolvers$1();
   const listenerMap = Object.create(null);
   const cleanup = value => {
     for (const event of Object.keys(eventMap)) {
@@ -2454,18 +2078,74 @@ const getWebSocketUrl = type => {
   return `${wsProtocol}//${location.host}/websocket/${type}`;
 };
 
-class IpcError extends Error {
+let IpcError$1 = class IpcError extends Error {
   constructor(message) {
     super(message);
     this.name = 'IpcError';
   }
+};
+
+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$1 = '\n';
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$1, 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;
+    }
+  }
 }
 
 const stringifyCompact = value => {
   return JSON.stringify(value);
 };
 
-const create = async ({
+const create$3 = async ({
   type
 }) => {
   string(type);
@@ -2473,14 +2153,14 @@ const create = async ({
   const webSocket = new WebSocket(wsUrl);
   const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
   if (firstWebSocketEvent.type === Error$1) {
-    throw new IpcError(`WebSocket connection error`);
+    throw new IpcError$1(`WebSocket connection error`);
   }
   if (firstWebSocketEvent.type === Close) {
-    throw new IpcError(`Websocket connection was closed`);
+    throw new IpcError$1(`Websocket connection was closed`);
   }
   return webSocket;
 };
-const wrap = webSocket => {
+const wrap$1 = webSocket => {
   return {
     /**
      * @type {any}
@@ -2526,6 +2206,593 @@ const wrap = webSocket => {
 
 const IpcParentWithWebSocket = {
   __proto__: null,
-  create,
+  create: create$3,
+  wrap: wrap$1
+};
+
+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 create$2 = async options => {
+  switch (platform) {
+    case Web:
+    case Remote:
+      const module = IpcParentWithWebSocket;
+      const rawIpc = await module.create(options);
+      if (options.raw) {
+        return rawIpc;
+      }
+      return {
+        rawIpc,
+        module
+      };
+    case Electron:
+      return create$4(options);
+    default:
+      throw new Error('unsupported platform');
+  }
+};
+const wrap = 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$2,
   wrap
 };
+
+const getModule$1 = method => {
+  switch (method) {
+    case NodeAlternate:
+      return IpcParentWithNodeAlternate;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const create$1 = async ({
+  method,
+  ...options
+}) => {
+  const module = getModule$1(method);
+  // @ts-ignore
+  const rawIpc = await module.create(options);
+  if (options.raw) {
+    return rawIpc;
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const state = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined};
+
+const launchTerminalProcess = async () => {
+  try {
+    const ipc = await create$1({
+      method: NodeAlternate,
+      type: 'terminal-process',
+      name: 'Terminal Process',
+      initialCommand: 'HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess'
+    });
+    state.ipc = ipc;
+    handleIpc(ipc);
+  } catch (error) {
+    throw new VError(error, 'Failed to create terminal connection');
+  }
+};
+
+const listen$2 = async () => {
+  await launchTerminalProcess();
+};
+const invoke = (method, ...params) => {
+  return invoke$2(state.ipc, method, ...params);
+};
+const send = (method, ...params) => {
+  return send$1(state.ipc, method, ...params);
+};
+
+// 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 = 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$5({
+    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,
+  'Viewlet.send': handleMessage,
+  'Terminal.handleBlur': handleBlur,
+  'Terminal.handleKeyDown': handleKeyDown,
+  'Terminal.handleMouseDown': handleMouseDown,
+  'OffscreenCanvas.handleResult': handleResult
+};
+
+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 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 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 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 = '\n';
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+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 splitLines = lines => {
+  return lines.split(NewLine);
+};
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+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 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 isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+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 isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
+};
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
+};
+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
+  };
+};
+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 readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$8 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(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$f = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$8,
+  wrap: wrap$f
+};
+const withResolvers = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    resolve: _resolve,
+    promise
+  };
+};
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
+};
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$8(parentIpcRaw);
+  const parentIpc = wrap$f(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('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 {
+  getData(event) {
+    return getData$2(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$e = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
+};
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$6,
+  wrap: wrap$e
+};
+
+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 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 = getModule(method);
+  // @ts-ignore
+  const rawIpc = await module.listen();
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc);
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const listen = async () => {
+  register(commandMap);
+  const ipc = await listen$1({
+    method: Auto()
+  });
+  handleIpc(ipc);
+  listen$3(ipc);
+};
+
+const main = async () => {
+  await listen();
+};
+
+main();