@lvce-editor/renderer-process 1.0.0 → 2.0.0

package/dist/rendererProcessMain.js

@@ -51,6 +51,7 @@ const WindowTitle = 39;
 const KeyBindings$1 = 41;
 const PointerCapture = 42;
 const GetFilePathElectron = 43;
+const HandleMessagePort = 44;
 
 const getModuleId = commandId => {
   switch (commandId) {
@@ -201,6 +202,8 @@ const getModuleId = commandId => {
       return PointerCapture;
     case 'GetFilePathElectron.getFilePathElectron':
       return GetFilePathElectron;
+    case 'HandleMessagePort.handleMessagePort':
+      return HandleMessagePort;
     default:
       throw new CommandNotFoundError(commandId);
   }
@@ -217,7 +220,7 @@ const getCombinedErrorMessage = (error, message) => {
   return `${error}`;
 };
 
-const mergeStacks = (parent, child) => {
+const mergeStacks$1 = (parent, child) => {
   if (!child) {
     return parent;
   }
@@ -247,14 +250,14 @@ const getErrorStack = error => {
   }
   return '';
 };
-class VError extends Error {
+let VError$1 = class VError extends Error {
   constructor(error, message) {
     const combinedMessage = getCombinedErrorMessage(error, message);
     super(combinedMessage);
     this.name = 'VError';
     if (error instanceof Error) {
       const errorStack = getErrorStack(error);
-      this.stack = mergeStacks(this.stack, errorStack);
+      this.stack = mergeStacks$1(this.stack, errorStack);
     }
     if (error.codeFrame) {
       // @ts-ignore
@@ -262,7 +265,7 @@ class VError extends Error {
     }
     this.cause = error;
   }
-}
+};
 
 const state$b = {
   commands: Object.create(null),
@@ -292,7 +295,7 @@ const loadModule$1 = async moduleId => {
       // @ts-ignore
       Error.captureStackTrace(error, loadModule$1);
     }
-    throw new VError(error, `failed to load module ${moduleId}`);
+    throw new VError$1(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
@@ -312,7 +315,7 @@ const executeCommandAsync = async (command, ...args) => {
   try {
     await loadCommand(command);
   } catch (error) {
-    throw new VError(error, `Failed to load command ${command}`);
+    throw new VError$1(error, `Failed to load command ${command}`);
   }
   if (!(command in state$b.commands)) {
     if (hasThrown.has(command)) {
@@ -454,6 +457,8 @@ const load$1 = moduleId => {
       return Promise.resolve().then(function () { return PointerCapture_ipc; });
     case GetFilePathElectron:
       return Promise.resolve().then(function () { return GetFilePathElectron_ipc; });
+    case HandleMessagePort:
+      return Promise.resolve().then(function () { return HandleMessagePort_ipc; });
     default:
       throw new Error(`module ${moduleId} not found`);
   }
@@ -546,7 +551,7 @@ const create$3$1 = () => {
 const warn$1 = (...args) => {
   console.warn(...args);
 };
-const withResolvers$1 = () => {
+const withResolvers$2 = () => {
   /**
    * @type {any}
    */
@@ -564,7 +569,7 @@ const registerPromise = () => {
   const {
     resolve,
     promise
-  } = withResolvers$1();
+  } = withResolvers$2();
   set$5(id, resolve);
   return {
     id,
@@ -604,7 +609,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine$1 = '\n';
+const NewLine$3 = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -651,21 +656,21 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
 };
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
+const joinLines$2 = lines => {
+  return lines.join(NewLine$3);
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines$1 = lines => {
-  return lines.split(NewLine$1);
+const splitLines$2 = lines => {
+  return lines.split(NewLine$3);
 };
 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$3 + parentStack;
   }
   return parentStack;
 };
@@ -673,18 +678,18 @@ const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines$1(splitLines$1(new Error().stack).slice(1));
+  const currentStack = joinLines$2(splitLines$2(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$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$1 + error.data.stack + NewLine$1 + currentStack;
+        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;
       }
@@ -705,7 +710,7 @@ const restoreJsonRpcError = error => {
         // TODO accessing stack might be slow
         const lowerStack = restoredError.stack || '';
         // @ts-ignore
-        const indexNewLine = getNewLineIndex$1(lowerStack);
+        const indexNewLine = getNewLineIndex$2(lowerStack);
         const parentStack = getParentStack(error);
         // @ts-ignore
         restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
@@ -852,18 +857,18 @@ const unhandleIpc = ipc => {
 
 const isElectron = platform === Electron$1;
 
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
+const MessagePort$2 = 1;
+const ModuleWorker$1 = 2;
 const ReferencePort = 3;
 const ModuleWorkerWithMessagePort = 4;
 const Electron = 5;
-const Auto = ModuleWorker;
+const Auto = ModuleWorker$1;
 
-const getModule = method => {
+const getModule$1 = method => {
   switch (method) {
-    case ModuleWorker:
+    case ModuleWorker$1:
       return Promise.resolve().then(function () { return IpcParentWithModuleWorker; });
-    case MessagePort$1:
+    case MessagePort$2:
       return Promise.resolve().then(function () { return IpcParentWithMessagePort; });
     case ReferencePort:
       return Promise.resolve().then(function () { return IpcParentWithReferencePort; });
@@ -880,7 +885,7 @@ const create$K = async ({
   method,
   ...options
 }) => {
-  const module = await getModule(method);
+  const module = await getModule$1(method);
   // @ts-ignore
   return module.create(options);
 };
@@ -1066,7 +1071,7 @@ const getJson = async (url, options = {}) => {
   } catch (error) {
     if (error && error instanceof TypeError && error.message === 'Failed to fetch') {
       // @ts-expect-error
-      throw new VError(`Failed to request json from "${url}". Make sure that the server is running and has CORS enabled`);
+      throw new VError$1(`Failed to request json from "${url}". Make sure that the server is running and has CORS enabled`);
     }
     if (error && error instanceof HTTPError) {
       let json;
@@ -1078,7 +1083,7 @@ const getJson = async (url, options = {}) => {
       }
       if (json?.message) {
         // @ts-expect-error
-        throw new VError(`Failed to request json from "${url}": ${json.message}`);
+        throw new VError$1(`Failed to request json from "${url}": ${json.message}`);
       }
     }
     // @ts-ignore
@@ -1094,21 +1099,21 @@ const getText$1 = async (url, options = {}) => {
     return await ky(url, options).text();
   } catch (error) {
     if (error && error instanceof TypeError && error.message === 'Failed to fetch') {
-      throw new VError(error, `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`);
+      throw new VError$1(error, `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`);
     }
-    throw new VError(error, `Failed to request text from "${url}"`);
+    throw new VError$1(error, `Failed to request text from "${url}"`);
   }
 };
 
-const NewLine = '\n';
+const NewLine$2 = '\n';
 
-const splitLines = lines => {
+const splitLines$1 = lines => {
   string(lines);
-  return lines.split(NewLine);
+  return lines.split(NewLine$2);
 };
 
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const RE_AT$1 = /^\s+at/;
+const RE_AT_PROMISE_INDEX$1 = /^\s*at async Promise.all \(index \d+\)$/;
 const RE_OBJECT_AS = /^\s*at Object\.\w+ \[as ([\w.]+)]/;
 const RE_OBJECT = /^\s*at Object\.(\w+)/;
 const RE_PATH_1$1 = /\((.*):(\d+):(\d+)\)$/;
@@ -1121,13 +1126,13 @@ const RE_JSON_RPC_INVOKE = /^\s*at invoke .*JsonRpc\.js/;
 const RE_ASSERT = /^\s*at .*\/Assert\.js/;
 const RE_CONSTRUCT_ERROR = /^\s*at constructError /;
 const isInternalLine = line => {
-  return RE_AT_PROMISE_INDEX.test(line);
+  return RE_AT_PROMISE_INDEX$1.test(line);
 };
 const isRelevantLine = line => {
   return !isInternalLine(line);
 };
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line) || RE_PATH_2$1.test(line) || RE_PATH_3$1.test(line);
+const isNormalStackLine$1 = line => {
+  return RE_AT$1.test(line) && !RE_AT_PROMISE_INDEX$1.test(line) || RE_PATH_2$1.test(line) || RE_PATH_3$1.test(line);
 };
 const isApplicationUsefulLine = (line, index) => {
   if (index === 0) {
@@ -1158,8 +1163,8 @@ const cleanLine = line => {
   }
   return line;
 };
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
+const getDetails$1 = lines => {
+  const index = lines.findIndex(isNormalStackLine$1);
   return {
     custom: lines.slice(0, index),
     actualStack: lines.slice(index).map(cleanLine)
@@ -1183,11 +1188,11 @@ const mergeCustom = (custom, relevantStack) => {
 };
 const cleanStack = stack => {
   string(stack);
-  const lines = splitLines(stack);
+  const lines = splitLines$1(stack);
   const {
     custom,
     actualStack
-  } = getDetails(lines);
+  } = getDetails$1(lines);
   const relevantStack = actualStack.filter(isRelevantLine).filter(isApplicationUsefulLine);
   const merged = mergeCustom(custom, relevantStack);
   return merged;
@@ -1296,7 +1301,7 @@ const create$J = (rawLines, loc, opts = {}) => {
     } else {
       return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`;
     }
-  }).join(NewLine);
+  }).join(NewLine$2);
 
   // @ts-ignore
   if (opts.message && !hasColumns) {
@@ -1312,8 +1317,8 @@ const create$J = (rawLines, loc, opts = {}) => {
  * @param {number|undefined} startIndex
  * @returns
  */
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
 };
 
 const isActualSourceFile = path => {
@@ -1341,8 +1346,8 @@ const getIsFirefox = () => {
  */
 const isFirefox = getIsFirefox();
 
-const joinLines = lines => {
-  return lines.join(NewLine);
+const joinLines$1 = lines => {
+  return lines.join(NewLine$2);
 };
 
 const warn = (...args) => {
@@ -1484,7 +1489,7 @@ const getOriginalPosition = (sourceMap, line, column) => {
       originalColumn
     };
   } catch (error) {
-    throw new VError(error, `Failed to get original sourcemap position`);
+    throw new VError$1(error, `Failed to get original sourcemap position`);
   }
 };
 
@@ -1511,7 +1516,7 @@ const prepareErrorMessageWithCodeFrame = error => {
   }
   const message = getErrorMessage(error);
   const lines = cleanStack(error.stack);
-  const relevantStack = joinLines(lines);
+  const relevantStack = joinLines$1(lines);
   if (error.codeFrame) {
     return {
       message,
@@ -1560,14 +1565,14 @@ const toAbsoluteUrl = (file, relativePath) => {
 };
 const getSourceMapMatch = text => {
   string(text);
-  const index = text.lastIndexOf(NewLine, text.length - 2);
+  const index = text.lastIndexOf(NewLine$2, text.length - 2);
   const lastLine = text.slice(index + 1, -1);
   const lastLineMatch = lastLine.match(RE_SOURCE_MAP);
   if (lastLineMatch) {
     return lastLineMatch;
   }
   // @ts-ignore
-  const secondLastLineIndex = getNewLineIndex(text, index - 1);
+  const secondLastLineIndex = getNewLineIndex$1(text, index - 1);
   const secondLastLine = text.slice(secondLastLineIndex, index);
   const secondLastLineMatch = secondLastLine.match(RE_SOURCE_MAP);
   return secondLastLineMatch;
@@ -1595,7 +1600,7 @@ const prepareErrorMessageWithoutCodeFrame = async error => {
     const parsedLine = parseInt(line);
     const parsedColumn = parseInt(column);
     const message = getErrorMessage(error);
-    const relevantStack = joinLines(lines);
+    const relevantStack = joinLines$1(lines);
     if (sourceMapMatch) {
       const sourceMapUrl = sourceMapMatch[1];
       const sourceMapAbsolutePath = getSourceMapAbsolutePath(path, sourceMapUrl);
@@ -1755,15 +1760,15 @@ const play = async src => {
   await audio.play();
 };
 
-const name$w = 'Audio';
-const Commands$x = {
+const name$x = 'Audio';
+const Commands$y = {
   play: play
 };
 
 const Audio_ipc = {
   __proto__: null,
-  Commands: Commands$x,
-  name: name$w
+  Commands: Commands$y,
+  name: name$x
 };
 
 const readText = async () => {
@@ -1784,8 +1789,8 @@ const execCopy = async () => {
   await writeText(text);
 };
 
-const name$v = 'ClipBoard';
-const Commands$w = {
+const name$w = 'ClipBoard';
+const Commands$x = {
   execCopy: execCopy,
   readText: readText,
   writeImage: writeImage,
@@ -1794,23 +1799,23 @@ const Commands$w = {
 
 const ClipBoard_ipc = {
   __proto__: null,
-  Commands: Commands$w,
-  name: name$v
+  Commands: Commands$x,
+  name: name$w
 };
 
 const prompt$1 = message => {
   return confirm(message);
 };
 
-const name$u = 'ConfirmPrompt';
-const Commands$v = {
+const name$v = 'ConfirmPrompt';
+const Commands$w = {
   prompt: prompt$1
 };
 
 const ConfirmPrompt_ipc = {
   __proto__: null,
-  Commands: Commands$v,
-  name: name$u
+  Commands: Commands$w,
+  name: name$v
 };
 
 const state$7 = {
@@ -1835,15 +1840,15 @@ const addCssStyleSheet = async (id, text) => {
   document.adoptedStyleSheets.push(sheet);
 };
 
-const name$t = 'Css';
-const Commands$u = {
+const name$u = 'Css';
+const Commands$v = {
   addCssStyleSheet: addCssStyleSheet
 };
 
 const Css_ipc = {
   __proto__: null,
-  Commands: Commands$u,
-  name: name$t
+  Commands: Commands$v,
+  name: name$u
 };
 
 const modules = ['ActivityBar', 'Ajax', 'Allocator', 'Callback', 'Command', 'Context', 'ContextMenu', 'Delay', 'Developer', 'DomPool', 'Editor', 'Exec', 'ExtensionHost', 'FileSystem', 'KeyBindings', 'Layout', 'Main', 'Notification', 'Panel', 'Parts', 'QuickPick', 'Renderer', 'RendererWorker', 'Search', 'SharedProcess', 'SideBar', 'StatusBar', 'TitleBar', 'Viewlet', 'ViewletController', 'ViewService', 'Vscode', 'Window', 'Workbench', 'Worker', 'Workspace'];
@@ -1863,15 +1868,15 @@ const showState = async () => {
   info(state);
 };
 
-const name$s = 'Developer';
-const Commands$t = {
+const name$t = 'Developer';
+const Commands$u = {
   showState: showState
 };
 
 const Developer_ipc = {
   __proto__: null,
-  Commands: Commands$t,
-  name: name$s
+  Commands: Commands$u,
+  name: name$t
 };
 
 const downloadFile = (fileName, url) => {
@@ -1881,15 +1886,15 @@ const downloadFile = (fileName, url) => {
   a.click();
 };
 
-const name$r = 'Download';
-const Commands$s = {
+const name$s = 'Download';
+const Commands$t = {
   downloadFile: downloadFile
 };
 
 const Download_ipc = {
   __proto__: null,
-  Commands: Commands$s,
-  name: name$r
+  Commands: Commands$t,
+  name: name$s
 };
 
 // based on https://github.com/microsoft/vscode/blob/5f87632829dc3ac80203e2377727935184399431/src/vs/base/browser/ui/aria/aria.ts (License MIT)
@@ -2056,15 +2061,15 @@ const create$I = (message, x, y) => {
   };
 };
 
-const name$q = 'EditorError';
-const Commands$r = {
+const name$r = 'EditorError';
+const Commands$s = {
   create: create$I
 };
 
 const EditorError_ipc = {
   __proto__: null,
-  Commands: Commands$r,
-  name: name$q
+  Commands: Commands$s,
+  name: name$r
 };
 
 const state$4 = {
@@ -2191,8 +2196,8 @@ const finish = state => {
   return value;
 };
 
-const name$p = 'EditorRename';
-const Commands$q = {
+const name$q = 'EditorRename';
+const Commands$r = {
   create: create$G,
   dispose: dispose$i,
   finish: finish
@@ -2200,8 +2205,8 @@ const Commands$q = {
 
 const EditorRename_ipc = {
   __proto__: null,
-  Commands: Commands$q,
-  name: name$p
+  Commands: Commands$r,
+  name: name$q
 };
 
 const showDirectoryPicker = options => {
@@ -2217,8 +2222,8 @@ const showSaveFilePicker = options => {
   return window.showSaveFilePicker(options);
 };
 
-const name$o = 'FilePicker';
-const Commands$p = {
+const name$p = 'FilePicker';
+const Commands$q = {
   showDirectoryPicker: showDirectoryPicker,
   showFilePicker: showFilePicker,
   showSaveFilePicker: showSaveFilePicker
@@ -2226,23 +2231,23 @@ const Commands$p = {
 
 const FilePicker_ipc = {
   __proto__: null,
-  Commands: Commands$p,
-  name: name$o
+  Commands: Commands$q,
+  name: name$p
 };
 
 const requestPermission = (handle, options) => {
   return handle.requestPermission(options);
 };
 
-const name$n = 'FileSystemHandle';
-const Commands$o = {
+const name$o = 'FileSystemHandle';
+const Commands$p = {
   requestPermission: requestPermission
 };
 
 const FileSystemHandle_ipc = {
   __proto__: null,
-  Commands: Commands$o,
-  name: name$n
+  Commands: Commands$p,
+  name: name$o
 };
 
 const handleImageLoad = event => {
@@ -2316,8 +2321,8 @@ const ImagePreview$1 = {
   update
 };
 
-const name$m = 'ImagePreview';
-const Commands$n = {
+const name$n = 'ImagePreview';
+const Commands$o = {
   create: create$F,
   dispose: dispose$h,
   showError: showError,
@@ -2326,8 +2331,8 @@ const Commands$n = {
 
 const ImagePreview_ipc = {
   __proto__: null,
-  Commands: Commands$n,
-  name: name$m
+  Commands: Commands$o,
+  name: name$n
 };
 
 const getOrigin = () => {
@@ -2383,41 +2388,41 @@ const getInitData = () => {
   return initData;
 };
 
-const name$l = 'InitData';
-const Commands$m = {
+const name$m = 'InitData';
+const Commands$n = {
   getInitData: getInitData
 };
 
 const InitData_ipc = {
   __proto__: null,
-  Commands: Commands$m,
-  name: name$l
+  Commands: Commands$n,
+  name: name$m
 };
 
-const name$k = 'IpcParent';
-const Commands$l = {
+const name$l = 'IpcParent';
+const Commands$m = {
   create: create$K
 };
 
 const IpcParent_ipc = {
   __proto__: null,
-  Commands: Commands$l,
-  name: name$k
+  Commands: Commands$m,
+  name: name$l
 };
 
-const name$j = 'Layout';
-const Commands$k = {
+const name$k = 'Layout';
+const Commands$l = {
   getBounds: getBounds
 };
 
 const Layout_ipc = {
   __proto__: null,
-  Commands: Commands$k,
-  name: name$j
+  Commands: Commands$l,
+  name: name$k
 };
 
-const name$i = 'Location';
-const Commands$j = {
+const name$j = 'Location';
+const Commands$k = {
   getHref: getHref,
   getPathName: getPathName,
   hydrate: hydrate,
@@ -2426,8 +2431,8 @@ const Commands$j = {
 
 const Location_ipc = {
   __proto__: null,
-  Commands: Commands$j,
-  name: name$i
+  Commands: Commands$k,
+  name: name$j
 };
 
 const measureTextHeight = (text, fontSize, fontFamily) => {
@@ -2445,15 +2450,15 @@ const measureTextHeight = (text, fontSize, fontFamily) => {
   return height;
 };
 
-const name$h = 'MeasureTextHeight';
-const Commands$i = {
+const name$i = 'MeasureTextHeight';
+const Commands$j = {
   measureTextHeight: measureTextHeight
 };
 
 const MeasureTextHeight_ipc = {
   __proto__: null,
-  Commands: Commands$i,
-  name: name$h
+  Commands: Commands$j,
+  name: name$i
 };
 
 const setThemeColor = color => {
@@ -2465,15 +2470,15 @@ const setThemeColor = color => {
   meta.content = color;
 };
 
-const name$g = 'Meta';
-const Commands$h = {
+const name$h = 'Meta';
+const Commands$i = {
   setThemeColor: setThemeColor
 };
 
 const Meta_ipc = {
   __proto__: null,
-  Commands: Commands$h,
-  name: name$g
+  Commands: Commands$i,
+  name: name$h
 };
 
 const create$Notification = message => {
@@ -2531,10 +2536,10 @@ const dispose$g = id => {
   // const $Notification = state.$Notifications
 };
 
-const name$f = 'Notification';
+const name$g = 'Notification';
 
 // prettier-ignore
-const Commands$g = {
+const Commands$h = {
   create: create$E,
   createWithOptions: createWithOptions,
   dispose: dispose$g
@@ -2542,8 +2547,8 @@ const Commands$g = {
 
 const Notification_ipc = {
   __proto__: null,
-  Commands: Commands$g,
-  name: name$f
+  Commands: Commands$h,
+  name: name$g
 };
 
 const Two = '2.0';
@@ -2572,17 +2577,17 @@ const create$D = (canvasId, callbackId) => {
   }, [offscreenCanvas]);
 };
 
-const name$e = 'OffscreenCanvas';
+const name$f = 'OffscreenCanvas';
 
 // prettier-ignore
-const Commands$f = {
+const Commands$g = {
   create: create$D
 };
 
 const OffscreenCanvas_ipc = {
   __proto__: null,
-  Commands: Commands$f,
-  name: name$e
+  Commands: Commands$g,
+  name: name$f
 };
 
 // TODO this module should be called dom or dom utils
@@ -3208,7 +3213,7 @@ const create$Menu$1 = () => {
   // })
   $Menu.onkeydown = handleKeyDown$5;
   $Menu.addEventListener(FocusOut, handleFocusOut$1);
-  $Menu.oncontextmenu = handleContextMenu$9;
+  $Menu.oncontextmenu = handleContextMenu$a;
   // $ContextMenu.onfocus = handleFocus
   // $ContextMenu.onblur = handleBlur
   return $Menu;
@@ -3237,14 +3242,14 @@ const handleBackDropMouseDown = event => {
   stopPropagation(event);
   send( /* Menu.hide */'Menu.hide');
 };
-const handleContextMenu$9 = event => {
+const handleContextMenu$a = event => {
   preventDefault(event);
 };
 const showMenu = (x, y, width, height, items, level, parentIndex = -1, dom, mouseBlocking = false) => {
   if (mouseBlocking) {
     const $BackDrop = create$BackDrop();
     $BackDrop.onmousedown = handleBackDropMouseDown;
-    $BackDrop.oncontextmenu = handleContextMenu$9;
+    $BackDrop.oncontextmenu = handleContextMenu$a;
     // @ts-expect-error
     state$2.$BackDrop = $BackDrop;
     append$1($BackDrop);
@@ -3343,8 +3348,8 @@ const hide = (restoreFocus = true) => {
   }
 };
 
-const name$d = 'Menu';
-const Commands$e = {
+const name$e = 'Menu';
+const Commands$f = {
   focusIndex: focusIndex,
   hide: hide,
   hideSubMenu: hideSubMenu,
@@ -3354,23 +3359,23 @@ const Commands$e = {
 
 const Menu_ipc = {
   __proto__: null,
-  Commands: Commands$e,
-  name: name$d
+  Commands: Commands$f,
+  name: name$e
 };
 
 const openUrl = url => {
   open(url);
 };
 
-const name$c = 'Open';
-const Commands$d = {
+const name$d = 'Open';
+const Commands$e = {
   openUrl: openUrl
 };
 
 const Open_ipc = {
   __proto__: null,
-  Commands: Commands$d,
-  name: name$c
+  Commands: Commands$e,
+  name: name$d
 };
 
 const isElectronUserAgentSpecificMemoryError = error => {
@@ -3409,18 +3414,18 @@ const getMemory = () => {
   };
 };
 
-const name$b = 'Performance';
+const name$c = 'Performance';
 
 // prettier-ignore
-const Commands$c = {
+const Commands$d = {
   getMemory: getMemory,
   measureUserAgentSpecificMemory: measureUserAgentSpecificMemory
 };
 
 const Performance_ipc = {
   __proto__: null,
-  Commands: Commands$c,
-  name: name$b
+  Commands: Commands$d,
+  name: name$c
 };
 
 const prompt = (message, defaultValue) => {
@@ -3428,15 +3433,15 @@ const prompt = (message, defaultValue) => {
   return window.prompt(message, defaultValue);
 };
 
-const name$a = 'Prompt';
-const Commands$b = {
+const name$b = 'Prompt';
+const Commands$c = {
   prompt: prompt
 };
 
 const Prompt_ipc = {
   __proto__: null,
-  Commands: Commands$b,
-  name: name$a
+  Commands: Commands$c,
+  name: name$b
 };
 
 const screenCaptures = Object.create(null);
@@ -3461,7 +3466,7 @@ const start = async (id, options) => {
     const captureStream = await navigator.mediaDevices.getUserMedia(options);
     set$1(id, captureStream);
   } catch (error) {
-    throw new VError(error, `Failed to start screen capture`);
+    throw new VError$1(error, `Failed to start screen capture`);
   }
 };
 const dispose$f = async (id, options) => {
@@ -3473,20 +3478,20 @@ const dispose$f = async (id, options) => {
     }
     remove(id);
   } catch (error) {
-    throw new VError(error, `Failed to start screen capture`);
+    throw new VError$1(error, `Failed to start screen capture`);
   }
 };
 
-const name$9 = 'ScreenCapture';
-const Commands$a = {
+const name$a = 'ScreenCapture';
+const Commands$b = {
   dispose: dispose$f,
   start: start
 };
 
 const ScreenCapture_ipc = {
   __proto__: null,
-  Commands: Commands$a,
-  name: name$9
+  Commands: Commands$b,
+  name: name$a
 };
 
 const htmlElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdo', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'command', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'link', 'map', 'mark', 'menu', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'pre', 'progress', 'q', 'rp', 'rt', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'sub', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr'];
@@ -3992,10 +3997,10 @@ const checkMultiElementCondition = async (locator, fnName, options) => {
   throw new AssertionError(message);
 };
 
-const name$8 = 'TestFrameWork';
+const name$9 = 'TestFrameWork';
 
 // prettier-ignore
-const Commands$9 = {
+const Commands$a = {
   checkMultiElementCondition: checkMultiElementCondition,
   checkSingleElementCondition: checkSingleElementCondition,
   performAction: performAction,
@@ -4005,8 +4010,8 @@ const Commands$9 = {
 
 const TestFrameWork_ipc = {
   __proto__: null,
-  Commands: Commands$9,
-  name: name$8
+  Commands: Commands$a,
+  name: name$9
 };
 
 const objects = Object.create(null);
@@ -4014,15 +4019,15 @@ const transfer = (objectId, transferable) => {
   objects[objectId] = transferable;
 };
 
-const name$7 = 'Transferrable';
-const Commands$8 = {
+const name$8 = 'Transferrable';
+const Commands$9 = {
   transfer: transfer
 };
 
 const Transferrable_ipc = {
   __proto__: null,
-  Commands: Commands$8,
-  name: name$7
+  Commands: Commands$9,
+  name: name$8
 };
 
 const state$1 = {
@@ -4313,7 +4318,7 @@ const loadModule = async id => {
     const module = await load(id);
     state.modules[id] = module;
   } catch (error) {
-    throw new VError(error, `Failed to load ${id}`);
+    throw new VError$1(error, `Failed to load ${id}`);
   }
 };
 const invoke = (viewletId, method, ...args) => {
@@ -4687,8 +4692,8 @@ const setBounds$5 = (id, left, top, width, height) => {
   setBounds$6($Viewlet, left, top, width, height);
 };
 
-const name$6 = 'Viewlet';
-const Commands$7 = {
+const name$7 = 'Viewlet';
+const Commands$8 = {
   addKeyBindings: addKeyBindings,
   appendViewlet: appendViewlet,
   dispose: dispose$e,
@@ -4708,8 +4713,8 @@ const Commands$7 = {
 
 const Viewlet_ipc = {
   __proto__: null,
-  Commands: Commands$7,
-  name: name$6
+  Commands: Commands$8,
+  name: name$7
 };
 
 const LocalStorage = 1;
@@ -4752,8 +4757,8 @@ const clear$1 = storageType => {
   storage.clear();
 };
 
-const name$5 = 'WebStorage';
-const Commands$6 = {
+const name$6 = 'WebStorage';
+const Commands$7 = {
   clear: clear$1,
   getAll: getAll,
   getItem: getItem,
@@ -4763,8 +4768,8 @@ const Commands$6 = {
 
 const WebStorage_ipc = {
   __proto__: null,
-  Commands: Commands$6,
-  name: name$5
+  Commands: Commands$7,
+  name: name$6
 };
 
 const reload$1 = () => {
@@ -4794,8 +4799,8 @@ const onVisibilityChange = () => {
   document.addEventListener('pointerleave', handlePointerLeave);
 };
 
-const name$4 = 'Window';
-const Commands$5 = {
+const name$5 = 'Window';
+const Commands$6 = {
   close: close$1,
   maximize: maximize,
   minimize: minimize,
@@ -4806,34 +4811,34 @@ const Commands$5 = {
 
 const Window_ipc = {
   __proto__: null,
-  Commands: Commands$5,
-  name: name$4
+  Commands: Commands$6,
+  name: name$5
 };
 
 const set = title => {
   document.title = title;
 };
 
-const name$3 = 'WindowTitle';
-const Commands$4 = {
+const name$4 = 'WindowTitle';
+const Commands$5 = {
   set: set
 };
 
 const WindowTitle_ipc = {
   __proto__: null,
-  Commands: Commands$4,
-  name: name$3
+  Commands: Commands$5,
+  name: name$4
 };
 
-const name$2 = 'KeyBindings';
-const Commands$3 = {
+const name$3 = 'KeyBindings';
+const Commands$4 = {
   setIdentifiers: setIdentifiers
 };
 
 const KeyBindings_ipc = {
   __proto__: null,
-  Commands: Commands$3,
-  name: name$2
+  Commands: Commands$4,
+  name: name$3
 };
 
 // workaround for not being setPointerCapture() not working on
@@ -4849,16 +4854,16 @@ const unmock = () => {
   Element.prototype.releasePointerCapture = globalThis._originalReleasePointerCapture;
 };
 
-const name$1 = 'PointerCapture';
-const Commands$2 = {
+const name$2 = 'PointerCapture';
+const Commands$3 = {
   mock: mock,
   unmock: unmock
 };
 
 const PointerCapture_ipc = {
   __proto__: null,
-  Commands: Commands$2,
-  name: name$1
+  Commands: Commands$3,
+  name: name$2
 };
 
 const isFile = value => {
@@ -4876,43 +4881,510 @@ const getFilePathElectron = async file => {
   return filePath;
 };
 
-const name = 'GetFilePathElectron';
-const Commands$1 = {
+const name$1 = 'GetFilePathElectron';
+const Commands$2 = {
   getFilePathElectron: getFilePathElectron
 };
 
 const GetFilePathElectron_ipc = {
   __proto__: null,
-  Commands: Commands$1,
-  name
+  Commands: Commands$2,
+  name: name$1
 };
 
-const Message = 'message';
-const Error$1 = 'error';
+const MessagePort$1 = 1;
+const ModuleWorker = 2;
+const ModuleWorkerAndMessagePort = 8;
 
-const withResolvers = () => {
-  /**
-   * @type {any}
-   */
-  let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve;
-    _reject = reject;
-  });
-  return {
-    resolve: _resolve,
-    reject: _reject,
-    promise
-  };
+const getData$1 = event => {
+  return event.data;
 };
-
-const getFirstEvent = (eventTarget, eventMap) => {
-  const {
-    resolve,
+const attachEvents$d = 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$d(this);
+  }
+}
+const readyMessage = 'ready';
+const listen$3 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$2 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$5 = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$3,
+  signal: signal$2,
+  wrap: wrap$5
+};
+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 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 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 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$2 = async () => {
+  const parentIpcRaw = listen$3();
+  signal$2(parentIpcRaw);
+  const parentIpc = wrap$5(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.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, transfer) {
+    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$4 = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
+};
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$2,
+  wrap: wrap$4
+};
+const listen$1 = () => {
+  return window;
+};
+const signal$1 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithWindow extends Ipc {
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, location.origin, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    const wrapped = event => {
+      const {
+        ports
+      } = event;
+      if (ports.length) {
+        return;
+      }
+      callback(event);
+      this._rawIpc.removeEventListener('message', wrapped);
+    };
+    this._rawIpc.addEventListener('message', wrapped);
+  }
+}
+const wrap$3 = window => {
+  return new IpcChildWithWindow(window);
+};
+const IpcChildWithWindow$1 = {
+  __proto__: null,
+  listen: listen$1,
+  signal: signal$1,
+  wrap: wrap$3
+};
+const listen$4 = ({
+  port
+}) => {
+  return port;
+};
+const signal = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message, transfer) {
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$2 = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$4,
+  signal,
+  wrap: wrap$2
+};
+
+const getModule = method => {
+  switch (method) {
+    case ModuleWorker:
+      return IpcChildWithModuleWorker$1;
+    case ModuleWorkerAndMessagePort:
+      return IpcChildWithModuleWorkerAndMessagePort$1;
+    case MessagePort$1:
+      return IpcChildWithMessagePort$1;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const listen = async ({
+  method,
+  ...options
+}) => {
+  const module = await getModule(method);
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const handleMessagePort = async port => {
+  const ipc = await listen({
+    method: MessagePort$1,
+    port
+  });
+  handleIpc(ipc);
+};
+
+const name = 'HandleMessagePort';
+const Commands$1 = {
+  handleMessagePort: handleMessagePort
+};
+
+const HandleMessagePort_ipc = {
+  __proto__: null,
+  Commands: Commands$1,
+  name
+};
+
+const Message = 'message';
+const Error$1 = 'error';
+
+const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise
+  };
+};
+
+const getFirstEvent = (eventTarget, eventMap) => {
+  const {
+    resolve,
     promise
   } = withResolvers();
   const listenerMap = Object.create(null);
@@ -4961,9 +5433,9 @@ const isErrorEvent = event => {
 class WorkerError extends Error {
   constructor(event) {
     super(event.message);
-    const stackLines = splitLines(this.stack);
+    const stackLines = splitLines$1(this.stack);
     const relevantLines = stackLines.slice(1);
-    const relevant = joinLines(relevantLines);
+    const relevant = joinLines$1(relevantLines);
     this.stack = `${event.message}
     at Module (${event.filename}:${event.lineno}:${event.colno})
 ${relevant}`;
@@ -5131,76 +5603,6 @@ const handleIpcOnce = ipc => {
   }
 };
 
-const getData$1 = event => {
-  return event.data;
-};
-const attachEvents$d = 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$d(this);
-  }
-}
-const readyMessage = 'ready';
-const listen = () => {
-  return window;
-};
-const signal = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithWindow extends Ipc {
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message, transfer) {
-    this._rawIpc.postMessage(message, location.origin, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    const wrapped = event => {
-      const {
-        ports
-      } = event;
-      if (ports.length) {
-        return;
-      }
-      callback(event);
-      this._rawIpc.removeEventListener('message', wrapped);
-    };
-    this._rawIpc.addEventListener('message', wrapped);
-  }
-}
-const wrap$2 = window => {
-  return new IpcChildWithWindow(window);
-};
-const IpcChildWithWindow$1 = {
-  __proto__: null,
-  listen,
-  signal,
-  wrap: wrap$2
-};
-
 // TODO use handleIncomingIpc function
 const create$x = async ({
   port,
@@ -5263,7 +5665,7 @@ const handleFocus$c = () => {
 
 // TODO use context menu events function again
 
-const handleContextMenu$8 = event => {
+const handleContextMenu$9 = event => {
   preventDefault(event);
   const {
     button,
@@ -5277,7 +5679,7 @@ const returnValue$5 = true;
 const ViewletActivityBarEvents = {
   __proto__: null,
   handleBlur: handleBlur$9,
-  handleContextMenu: handleContextMenu$8,
+  handleContextMenu: handleContextMenu$9,
   handleFocus: handleFocus$c,
   handleMouseDown: handleMouseDown$3,
   returnValue: returnValue$5
@@ -5307,10 +5709,10 @@ forwardViewletCommand('clearFilter');
 const close = forwardViewletCommand('close');
 forwardViewletCommand('closeEditor');
 const closeMenu$1 = forwardViewletCommand('closeMenu');
-const compositionEnd = forwardViewletCommand('compositionEnd');
-const compositionStart = forwardViewletCommand('compositionStart');
-const compositionUpdate = forwardViewletCommand('compositionUpdate');
-const cut = forwardViewletCommand('cut');
+forwardViewletCommand('compositionEnd');
+forwardViewletCommand('compositionStart');
+forwardViewletCommand('compositionUpdate');
+forwardViewletCommand('cut');
 forwardViewletCommand('focus');
 forwardViewletCommand('focusIndex');
 const focusNext = forwardViewletCommand('focusNext');
@@ -5332,7 +5734,7 @@ forwardViewletCommand('handleClickOpenFile');
 forwardViewletCommand('handleClickRestore');
 const handleClickTab$2 = forwardViewletCommand('handleClickTab');
 forwardViewletCommand('handleClickToggleMaximize');
-const handleContextMenu$7 = forwardViewletCommand('handleContextMenu');
+const handleContextMenu$8 = forwardViewletCommand('handleContextMenu');
 const handleDoubleClick = forwardViewletCommand('handleDoubleClick');
 const handleDragEnd$1 = forwardViewletCommand('handleDragEnd');
 const handleDragLeave$1 = forwardViewletCommand('handleDragLeave');
@@ -5352,10 +5754,10 @@ forwardViewletCommand('handleListFocus');
 const handleMenuClick$1 = forwardViewletCommand('handleMenuClick');
 const handleMenuMouseOver$1 = forwardViewletCommand('handleMenuMouseOver');
 const handleMouseDown$2 = forwardViewletCommand('handleMouseDown');
-const handleMouseMove$1 = forwardViewletCommand('handleMouseMove');
+forwardViewletCommand('handleMouseMove');
 const handleMouseOut$1 = forwardViewletCommand('handleMouseOut');
 const handleMouseOver$1 = forwardViewletCommand('handleMouseOver');
-const handlePointerCaptureLost$3 = forwardViewletCommand('handlePointerCaptureLost');
+forwardViewletCommand('handlePointerCaptureLost');
 const handlePointerDown$7 = forwardViewletCommand('handlePointerDown');
 const handlePointerMove$1 = forwardViewletCommand('handlePointerMove');
 forwardViewletCommand('handlePointerOver');
@@ -5366,12 +5768,12 @@ const handleResizerClick = forwardViewletCommand('handleResizerClick');
 const handleResizerMove = forwardViewletCommand('handleResizerMove');
 const handleScrollBarCaptureLost = forwardViewletCommand('handleScrollBarCaptureLost');
 const handleScrollBarClick = forwardViewletCommand('handleScrollBarClick');
-const handleScrollBarHorizontalMove = forwardViewletCommand('handleScrollBarHorizontalMove');
-const handleScrollBarHorizontalPointerDown$1 = forwardViewletCommand('handleScrollBarHorizontalPointerDown');
+forwardViewletCommand('handleScrollBarHorizontalMove');
+forwardViewletCommand('handleScrollBarHorizontalPointerDown');
 const handleScrollBarMove = forwardViewletCommand('handleScrollBarMove');
 const handleScrollBarThumbPointerMove$3 = forwardViewletCommand('handleScrollBarThumbPointerMove');
-const handleScrollBarVerticalMove = forwardViewletCommand('handleScrollBarMove');
-const handleScrollBarVerticalPointerDown$1 = forwardViewletCommand('handleScrollBarVerticalPointerDown');
+forwardViewletCommand('handleScrollBarMove');
+forwardViewletCommand('handleScrollBarVerticalPointerDown');
 forwardViewletCommand('handleSliderPointerDown');
 const handleSliderPointerMove$1 = forwardViewletCommand('handleSliderPointerMove');
 const handleTabClick = forwardViewletCommand('handleTabClick');
@@ -5384,19 +5786,19 @@ const handleTouchMove$1 = forwardViewletCommand('handleTouchMove');
 const handleTouchStart$1 = forwardViewletCommand('handleTouchStart');
 const handleWheel$4 = forwardViewletCommand('handleWheel');
 const hidePanel = forwardViewletCommand('hidePanel');
-const moveRectangleSelectionPx = forwardViewletCommand('moveRectangleSelectionPx');
-const moveSelectionPx = forwardViewletCommand('moveSelectionPx');
-const paste = forwardViewletCommand('paste');
+forwardViewletCommand('moveRectangleSelectionPx');
+forwardViewletCommand('moveSelectionPx');
+forwardViewletCommand('paste');
 forwardViewletCommand('replaceAll');
 const selectIndex = forwardViewletCommand('selectIndex');
-const setDelta = forwardViewletCommand('setDelta');
+forwardViewletCommand('setDelta');
 forwardViewletCommand('toggleMatchCase');
 forwardViewletCommand('toggleMatchWholeWord');
 const toggleMaximize = forwardViewletCommand('toggleMaximize');
 const toggleReplace = forwardViewletCommand('toggleReplace');
 forwardViewletCommand('toggleUseRegularExpression');
 forwardViewletCommand('type');
-const typeWithAutoClosing = forwardViewletCommand('typeWithAutoClosing');
+forwardViewletCommand('typeWithAutoClosing');
 const updateEditingValue = forwardViewletCommand('updateEditingValue');
 
 const handleAudioError = event => {
@@ -6124,7 +6526,7 @@ const handleWheel$2 = event => {
  *
  * @param {MouseEvent} event
  */
-const handleContextMenu$6 = event => {
+const handleContextMenu$7 = event => {
   preventDefault(event);
   const {
     button,
@@ -6132,7 +6534,7 @@ const handleContextMenu$6 = event => {
     clientY
   } = event;
   const uid = fromEvent(event);
-  handleContextMenu$7(uid, button, clientX, clientY);
+  handleContextMenu$8(uid, button, clientX, clientY);
 };
 const handleError$5 = event => {
   const uid = fromEvent(event);
@@ -6157,7 +6559,7 @@ const attachEvents$a = state => {
   attachEvents$c($Viewlet, {
     [PointerDown]: handlePointerDown$5,
     [PointerUp]: handlePointerUp,
-    [ContextMenu]: handleContextMenu$6,
+    [ContextMenu]: handleContextMenu$7,
     [FocusIn]: handleFocus$9
   });
   $Viewlet.addEventListener(Error$3, handleError$5, Capture);
@@ -6221,12 +6623,26 @@ const QuickInput = 'Quick Input';
 const SideBar = 'Side Bar';
 const StatusBar = 'Status Bar';
 
+const attachEventsFunctional = ($Node, eventMap) => {
+  for (const [key] of Object.entries(eventMap)) {
+    if (key === 'returnValue') {
+      continue;
+    }
+    attachEvent($Node, eventMap, key, key);
+  }
+};
+
 const Text$1 = 'text';
 
 const getText = clipBoardData => {
   return clipBoardData.getData(Text$1);
 };
 
+const detachEvent = ($Node, key, listener) => {
+  const wrapped = getWrappedListener(listener, true);
+  $Node.removeEventListener(key, wrapped);
+};
+
 const None = 0;
 const Ctrl = 1;
 const Alt$1 = 2;
@@ -6241,8 +6657,6 @@ const getModifierKey = event => {
   return None;
 };
 
-const InsertText = 'insertText';
-
 const toSimpleTouch = touch => {
   return {
     x: touch.clientX,
@@ -6266,17 +6680,6 @@ const toSimpleTouchEvent = event => {
   };
 };
 
-const handleContextMenu$5 = event => {
-  preventDefault(event);
-  const {
-    button,
-    clientX,
-    clientY
-  } = event;
-  const uid = fromEvent(event);
-  handleContextMenu$7(uid, button, clientX, clientY);
-};
-
 // TODO so many things in this file
 
 
@@ -6285,23 +6688,20 @@ const handleContextMenu$5 = event => {
 // TODO tree shake out mobile support when targeting electron -> less code -> less event listeners -> less memory -> less cpu
 
 const handleFocus$8 = event => {
-  const uid = fromEvent(event);
-  handleFocus$b(uid);
+  return ['handleFocus'];
 };
 const handleMouseMove = event => {
-  const uid = fromEvent(event);
   const {
     clientX,
     clientY,
     altKey
   } = event;
-  handleMouseMove$1(uid, clientX, clientY, altKey);
+  return ['handleMouseMove', clientX, clientY, altKey];
 };
 const handleBlur$6 = event => {
   // needed for save on blur
   // also needed to close completions on blur
-  const uid = fromEvent(event);
-  handleBlur$8(uid);
+  return ['handleBlur'];
 };
 
 /**
@@ -6310,19 +6710,11 @@ const handleBlur$6 = event => {
  */
 const handleBeforeInput$1 = event => {
   preventDefault(event);
-  const uid = fromEvent(event);
   const {
     inputType,
     data
   } = event;
-  switch (inputType) {
-    case InsertText:
-      typeWithAutoClosing(uid, data);
-      break;
-  }
-  // if (!event.data) {
-  //   return
-  // }
+  return ['handleBeforeInput', inputType, data];
 };
 
 // TODO composition should be better supported,
@@ -6333,36 +6725,31 @@ const handleBeforeInput$1 = event => {
 // - vscode does not draw a line, but displays characters during composition
 
 const handleCompositionStart = event => {
-  const uid = fromEvent(event);
   const {
     data
   } = event;
-  compositionStart(uid, data);
+  return ['compositionStart', data];
 };
 const handleCompositionUpdate = event => {
-  const uid = fromEvent(event);
   const {
     data
   } = event;
-  compositionUpdate(uid, data);
+  return ['compositionUpdate', data];
 };
 const handleCompositionEnd = event => {
-  const uid = fromEvent(event);
   const {
     data
   } = event;
-  compositionEnd(uid, data);
+  return ['compositionEnd', data];
 };
 const handleCut = event => {
   preventDefault(event);
-  const uid = fromEvent(event);
-  cut(uid);
+  return ['cut'];
 };
 const isRightClick = event => {
   return event.button === RightClick;
 };
 const handleEditorPointerMove = event => {
-  const uid = fromEvent(event);
   const {
     clientX,
     clientY,
@@ -6370,19 +6757,17 @@ const handleEditorPointerMove = event => {
   } = event;
   // TODO if/else should be in renderer worker
   if (altKey) {
-    moveRectangleSelectionPx(uid, clientX, clientY);
-  } else {
-    moveSelectionPx(uid, clientX, clientY);
+    return ['moveRectangleSelectionPx', clientX, clientY];
   }
+  return ['moveSelectionPx', clientX, clientY];
 };
 const handleEditorLostPointerCapture = event => {
-  const uid = fromEvent(event);
   const {
     target
   } = event;
-  target.removeEventListener(PointerMove, handleEditorPointerMove);
-  target.removeEventListener(LostPointerCapture, handleEditorLostPointerCapture);
-  handlePointerCaptureLost$3(uid);
+  detachEvent(target, PointerMove, handleEditorPointerMove);
+  detachEvent(target, LostPointerCapture, handleEditorLostPointerCapture);
+  return ['handlePointerCaptureLost'];
 };
 
 /**
@@ -6395,14 +6780,17 @@ const handleEditorPointerDown = event => {
     pointerId
   } = event;
   target.setPointerCapture(pointerId);
-  target.addEventListener(PointerMove, handleEditorPointerMove, Active);
-  target.addEventListener(LostPointerCapture, handleEditorLostPointerCapture);
+  attachEventsFunctional(target, {
+    [PointerMove]: handleEditorPointerMove,
+    [LostPointerCapture]: handleEditorLostPointerCapture,
+    returnValue: true
+  });
+  return [];
 };
 const handleMouseDown$1 = event => {
   if (isRightClick(event)) {
-    return;
+    return [];
   }
-  const uid = fromEvent(event);
   preventDefault(event);
   const {
     clientX,
@@ -6410,7 +6798,7 @@ const handleMouseDown$1 = event => {
     detail
   } = event;
   const modifier = getModifierKey(event);
-  handleMouseDown$2(uid, modifier, clientX, clientY, detail);
+  return ['handleMouseDown', modifier, clientX, clientY, detail];
 };
 
 // TODO figure out whether it is possible to register hover provider without mousemove
@@ -6421,7 +6809,6 @@ const handleMouseDown$1 = event => {
  * @param {WheelEvent} event
  */
 const handleWheel$1 = event => {
-  const uid = fromEvent(event);
   const {
     deltaMode,
     deltaX,
@@ -6430,16 +6817,15 @@ const handleWheel$1 = event => {
   // event.preventDefault()
   // const state = EditorHelper.getStateFromEvent(event)
   // TODO send editor id
-  setDelta(uid, deltaMode, deltaX, deltaY);
+  return ['setDelta', deltaMode, deltaX, deltaY];
 };
 const handlePaste = event => {
   preventDefault(event);
-  const uid = fromEvent(event);
   const {
     clipboardData
   } = event;
   const text = getText(clipboardData);
-  paste(uid, text);
+  return ['paste', text];
 };
 
 /**
@@ -6447,11 +6833,10 @@ const handlePaste = event => {
  * @param {PointerEvent} event
  */
 const handleScrollBarThumbVerticalPointerMove = event => {
-  const uid = fromEvent(event);
   const {
     clientY
   } = event;
-  handleScrollBarVerticalMove(uid, clientY);
+  return ['handleScrollBarVerticalMove', clientY];
 };
 
 /**
@@ -6464,6 +6849,7 @@ const handleScrollBarVerticalPointerUp = event => {
     pointerId
   } = event;
   stopTracking(target, pointerId, handleScrollBarThumbVerticalPointerMove, handleScrollBarVerticalPointerUp);
+  return [];
 };
 
 /**
@@ -6471,14 +6857,13 @@ const handleScrollBarVerticalPointerUp = event => {
  * @param {PointerEvent} event
  */
 const handleScrollBarVerticalPointerDown = event => {
-  const uid = fromEvent(event);
   const {
     target,
     pointerId,
     clientY
   } = event;
   startTracking(target, pointerId, handleScrollBarThumbVerticalPointerMove, handleScrollBarVerticalPointerUp);
-  handleScrollBarVerticalPointerDown$1(uid, clientY);
+  return ['handleScrollBarVerticalPointerDown', clientY];
 };
 
 /**
@@ -6489,8 +6874,7 @@ const handleScrollBarThumbHorizontalPointerMove = event => {
   const {
     clientX
   } = event;
-  const uid = fromEvent(event);
-  handleScrollBarHorizontalMove(uid, clientX);
+  return ['handleScrollBarHorizontalMove', clientX];
 };
 
 /**
@@ -6503,6 +6887,7 @@ const handleScrollBarHorizontalPointerUp = event => {
     pointerId
   } = event;
   stopTracking(target, pointerId, handleScrollBarThumbHorizontalPointerMove, handleScrollBarHorizontalPointerUp);
+  return [];
 };
 
 /**
@@ -6516,12 +6901,21 @@ const handleScrollBarHorizontalPointerDown = event => {
     clientX
   } = event;
   startTracking(target, pointerId, handleScrollBarThumbHorizontalPointerMove, handleScrollBarHorizontalPointerUp);
-  handleScrollBarHorizontalPointerDown$1(clientX);
+  return ['handleScrollBarHorizontalPointerDown', clientX];
 };
 const handleScrollBarContextMenu = event => {
   preventDefault(event);
   stopPropagation(event);
 };
+const handleContextMenu$6 = event => {
+  preventDefault(event);
+  const {
+    button,
+    clientX,
+    clientY
+  } = event;
+  return ['handleContextMenu', button, clientX, clientY];
+};
 
 const setCursors = (state, dom) => {
   object(state);
@@ -6594,7 +6988,7 @@ const create$n = () => {
   $EditorInput.setAttribute('spellcheck', False);
   $EditorInput.role = TextBox;
   // TODO where to best put listeners (side effects)
-  attachEvents$c($EditorInput, {
+  attachEventsFunctional($EditorInput, {
     [BeforeInput]: handleBeforeInput$1,
     [CompositionStart]: handleCompositionStart,
     [CompositionUpdate]: handleCompositionUpdate,
@@ -6602,7 +6996,8 @@ const create$n = () => {
     [Focus]: handleFocus$8,
     [Blur]: handleBlur$6,
     [Cut]: handleCut,
-    [Paste]: handlePaste
+    [Paste]: handlePaste,
+    returnValue: true
   });
   $EditorInput.name = 'editor';
   const $LayerCursor = document.createElement('div');
@@ -6611,9 +7006,10 @@ const create$n = () => {
   $LayerText.className = 'EditorRows';
   const $LayerGutter = document.createElement('div');
   $LayerGutter.className = 'Gutter';
-  attachEvents$c($LayerText, {
+  attachEventsFunctional($LayerText, {
     [MouseDown]: handleMouseDown$1,
-    [PointerDown]: handleEditorPointerDown
+    [PointerDown]: handleEditorPointerDown,
+    returnValue: true
   });
   const $ScrollBarThumbVertical = document.createElement('div');
   $ScrollBarThumbVertical.className = 'ScrollBarThumb ScrollBarThumbVertical';
@@ -6623,9 +7019,10 @@ const create$n = () => {
   $ScrollBarDiagnostics.className = 'EditorScrollBarDiagnostics';
   const $ScrollBarVertical = document.createElement('div');
   $ScrollBarVertical.className = 'ScrollBar ScrollBarVertical';
-  attachEvents$c($ScrollBarVertical, {
+  attachEventsFunctional($ScrollBarVertical, {
     [PointerDown]: handleScrollBarVerticalPointerDown,
-    [ContextMenu]: handleScrollBarContextMenu
+    [ContextMenu]: handleScrollBarContextMenu,
+    returnValue: true
   });
   $ScrollBarVertical.append($ScrollBarThumbVertical);
   const $ScrollBarThumbHorizontal = document.createElement('div');
@@ -6633,8 +7030,9 @@ const create$n = () => {
   const $ScrollBarHorizontal = document.createElement('div');
   $ScrollBarHorizontal.className = 'ScrollBar ScrollBarHorizontal';
   $ScrollBarHorizontal.append($ScrollBarThumbHorizontal);
-  attachEvents$c($ScrollBarHorizontal, {
-    [PointerDown]: handleScrollBarHorizontalPointerDown
+  attachEventsFunctional($ScrollBarHorizontal, {
+    [PointerDown]: handleScrollBarHorizontalPointerDown,
+    returnValue: true
   });
 
   // $EditorRows.addEventListener('mousemove', handleMouseMove, { passive: true })
@@ -6664,11 +7062,11 @@ const create$n = () => {
   $Editor.className = 'Viewlet Editor';
   $Editor.role = Code;
   $Editor.append($LayerGutter, $EditorContent);
-  attachEvents$c($Editor, {
-    [ContextMenu]: handleContextMenu$5
+  attachEventsFunctional($Editor, {
+    [ContextMenu]: handleContextMenu$6,
+    [Wheel]: handleWheel$1,
+    returnValue: true
   });
-  $Editor.addEventListener(Wheel, handleWheel$1, Passive);
-  // $Editor.addEventListener(DomEventType.MouseMove, EditorEvents.handlePointerMove, DomEventOptions.Passive)
   return {
     $LayerCursor,
     $LayerSelections,
@@ -6864,6 +7262,17 @@ const ViewletError = {
   setMessage: setMessage$1
 };
 
+const handleContextMenu$5 = event => {
+  preventDefault(event);
+  const {
+    button,
+    clientX,
+    clientY
+  } = event;
+  const uid = fromEvent(event);
+  handleContextMenu$8(uid, button, clientX, clientY);
+};
+
 const CopyMove = 'copyMove';
 
 const Text = 'text';
@@ -8347,7 +8756,7 @@ const handleContextMenu$4 = event => {
     clientY
   } = event;
   const uid = fromEvent(event);
-  handleContextMenu$7(uid, clientX, clientY);
+  handleContextMenu$8(uid, clientX, clientY);
 };
 
 // TODO Main should not be bound to Editor -> Lazy load Editor