@lvce-editor/menu-worker 3.1.0 → 4.1.0

package/dist/menuWorkerMain.js

@@ -225,8 +225,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -249,14 +249,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -275,8 +275,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -286,8 +286,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -348,8 +348,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -369,8 +369,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -427,8 +427,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -440,8 +440,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -451,8 +451,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
 };
 const Message$1 = 3;
 const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -465,8 +465,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -506,56 +506,35 @@ const IpcParentWithMessagePort$1 = {
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
 };
-const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
-  callbacks[id] = fn;
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
 };
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
 const get$3 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
-let id$a = 0;
-const create$3$1 = () => {
-  return ++id$a;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$5(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -572,12 +551,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -706,7 +685,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -733,27 +712,27 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
 const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
@@ -762,27 +741,27 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$9 = (message, result) => {
   return {
-    jsonrpc: Two,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -812,35 +791,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -862,11 +841,51 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+
+const Two = '2.0';
+
+const create$8 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$7 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id$a = 0;
+const create$6 = () => {
+  return ++id$a;
+};
+
+const registerPromise = map => {
+  const id = create$6();
   const {
-    message,
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
     promise
-  } = create$2$1(method, params);
+  } = registerPromise(callbacks);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -875,60 +894,40 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send$1 = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$4 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
-
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-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 CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send$1(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$8(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -941,8 +940,9 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -951,6 +951,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -959,15 +960,17 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+
 const create$5 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -975,8 +978,10 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3 = async ({
+
+const create$4 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -986,13 +991,53 @@ const create$3 = async ({
   await send(port1);
   return create$5({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$3
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
 };
+
+const create$3 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$4({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+
 const create$2 = async ({
   commandMap
 }) => {
@@ -1003,10 +1048,7 @@ const create$2 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$2
-};
+
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1020,13 +1062,62 @@ const createMockRpc = ({
     return command(...params);
   };
   const mockRpc = {
+    invocations,
     invoke,
-    invokeAndTransfer: invoke,
-    invocations
+    invokeAndTransfer: invoke
   };
   return mockRpc;
 };
 
+const rpcs = Object.create(null);
+const set$4 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$2 = id => {
+  return rpcs[id];
+};
+const remove = id => {
+  delete rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+const create$1 = rpcId => {
+  return {
+    async dispose() {
+      const rpc = get$2(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$2(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$2(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$4(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$4(rpcId, rpc);
+    }
+  };
+};
+
+const Div$1 = 4;
 const Text = 12;
 
 const Button = 'event.button';
@@ -1166,34 +1257,14 @@ const Plus = '+';
 
 const getKeyCodeString = keyCode => {
   switch (keyCode) {
+    case Backquote$1:
+      return Backquote;
+    case Backslash$1:
+      return Backslash;
     case Backspace$1:
       return Backspace;
-    case Tab$1:
-      return Tab;
-    case Escape$1:
-      return Escape;
-    case Enter$1:
-      return Enter;
-    case Space$1:
-      return Space;
-    case PageUp$1:
-      return PageUp;
-    case PageDown$1:
-      return PageDown;
-    case End$1:
-      return End;
-    case Home$1:
-      return Home;
-    case LeftArrow$1:
-      return LeftArrow;
-    case UpArrow$1:
-      return UpArrow;
-    case RightArrow$1:
-      return RightArrow;
-    case DownArrow$1:
-      return DownArrow;
-    case Insert$1:
-      return Insert;
+    case Comma$1:
+      return Comma;
     case Delete$1:
       return Delete;
     case Digit0$1:
@@ -1216,6 +1287,32 @@ const getKeyCodeString = keyCode => {
       return Digit8;
     case Digit9$1:
       return Digit9;
+    case DownArrow$1:
+      return DownArrow;
+    case End$1:
+      return End;
+    case Enter$1:
+      return Enter;
+    case Equal$1:
+      return Equal;
+    case Escape$1:
+      return Escape;
+    case F1$1:
+      return F1;
+    case F2$1:
+      return F2;
+    case F3$1:
+      return F3;
+    case F4$1:
+      return F4;
+    case F5$1:
+      return F5;
+    case F6$1:
+      return F6;
+    case Home$1:
+      return Home;
+    case Insert$1:
+      return Insert;
     case KeyA$1:
       return KeyA;
     case KeyB$1:
@@ -1268,45 +1365,39 @@ const getKeyCodeString = keyCode => {
       return KeyY;
     case KeyZ$1:
       return KeyZ;
-    case F1$1:
-      return F1;
-    case F2$1:
-      return F2;
-    case F3$1:
-      return F3;
-    case F4$1:
-      return F4;
-    case F5$1:
-      return F5;
-    case F6$1:
-      return F6;
-    case Backslash$1:
-      return Backslash;
-    case Equal$1:
-      return Equal;
-    case Comma$1:
-      return Comma;
-    case Backquote$1:
-      return Backquote;
+    case LeftArrow$1:
+      return LeftArrow;
+    case Minus$1:
+      return Minus;
+    case PageDown$1:
+      return PageDown;
+    case PageUp$1:
+      return PageUp;
     case Plus$1:
       return Plus;
+    case RightArrow$1:
+      return RightArrow;
+    case Space$1:
+      return Space;
     case Star$1:
       return Star;
-    case Minus$1:
-      return Minus;
+    case Tab$1:
+      return Tab;
+    case UpArrow$1:
+      return UpArrow;
     default:
       return Unknown;
   }
 };
 
-const Script = 2;
-
 const CtrlCmd = 1 << 11 >>> 0;
 const Shift = 1 << 10 >>> 0;
 
 const Separator$2 = 1;
 const None$1 = 0;
 const SubMenu$1 = 4;
+const Checked$1 = 2;
+const Unchecked$1 = 3;
 const Disabled$1 = 5;
 const RestoreFocus$1 = 6;
 const Ignore$1 = 7;
@@ -1317,435 +1408,64 @@ const parseKey = rawKey => {
   const keyCode = rawKey & 0x00_00_00_ff;
   const key = getKeyCodeString(keyCode);
   return {
-    key,
     isCtrl,
-    isShift
-  };
-};
-
-const DebugWorker = 55;
-const RendererProcess = 1670;
-const RendererWorker$1 = 1;
-
-const FocusSelector = 'Viewlet.focusSelector';
-
-const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$2 = id => {
-  return rpcs[id];
-};
-
-const create$1 = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$2(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$2(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$4(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$2(rpcId);
-      await rpc.dispose();
-    }
+    isShift,
+    key
   };
 };
 
-const {
-  invoke: invoke$3,
-  set: set$3} = create$1(RendererProcess);
-
-const {
-  invoke: invoke$2,
-  invokeAndTransfer,
-  set: set$2,
-  dispose
-} = create$1(RendererWorker$1);
-const searchFileHtml = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
-};
-const getFilePathElectron = async file => {
-  return invoke$2('FileSystemHandle.getFilePathElectron', file);
-};
-/**
- * @deprecated
- */
-const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$2('ContextMenu.show', x, y, id, ...args);
-};
-const showContextMenu2 = async (uid, menuId, x, y, args) => {
-  number(uid);
-  number(menuId);
-  number(x);
-  number(y);
-  // @ts-ignore
-  await invoke$2('ContextMenu.show2', uid, menuId, x, y, args);
-};
-const getElectronVersion = async () => {
-  return invoke$2('Process.getElectronVersion');
-};
-const applyBulkReplacement = async bulkEdits => {
-  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
-};
-const setColorTheme = async id => {
-  // @ts-ignore
-  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
-};
-const getNodeVersion = async () => {
-  return invoke$2('Process.getNodeVersion');
-};
-const getChromeVersion = async () => {
-  return invoke$2('Process.getChromeVersion');
-};
-const getV8Version = async () => {
-  return invoke$2('Process.getV8Version');
-};
-const getFileHandles = async fileIds => {
-  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
-  return files;
-};
-const setWorkspacePath = async path => {
-  await invoke$2('Workspace.setPath', path);
-};
-const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer('WebView.registerInterceptor', id, port);
-};
-const unregisterWebViewInterceptor = async id => {
-  await invoke$2('WebView.unregisterInterceptor', id);
-};
-const sendMessagePortToEditorWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
-};
-const sendMessagePortToErrorWorker = async (port, rpcId) => {
-  const command = 'Errors.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
-};
-const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
-  const command = 'Markdown.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
-};
-const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
-};
-const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const readFile = async uri => {
-  return invoke$2('FileSystem.readFile', uri);
-};
-const getWebViewSecret = async key => {
-  // @ts-ignore
-  return invoke$2('WebView.getSecret', key);
-};
-const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
-};
-const setFocus = key => {
-  return invoke$2('Focus.setFocus', key);
-};
-const getFileIcon = async options => {
-  return invoke$2('IconTheme.getFileIcon', options);
-};
-const getColorThemeNames = async () => {
-  return invoke$2('ColorTheme.getColorThemeNames');
-};
-const disableExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.disable', id);
-};
-const enableExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.enable', id);
-};
-const handleDebugChange = async params => {
-  // @ts-ignore
-  return invoke$2('Run And Debug.handleChange', params);
-};
-const getFolderIcon = async options => {
-  return invoke$2('IconTheme.getFolderIcon', options);
-};
-const closeWidget = async widgetId => {
-  return invoke$2('Viewlet.closeWidget', widgetId);
-};
-const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
-};
-const sendMessagePortToSearchProcess = async port => {
-  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
-};
-const confirm = async (message, options) => {
-  // @ts-ignore
-  const result = await invoke$2('ConfirmPrompt.prompt', message, options);
-  return result;
-};
-const getRecentlyOpened$1 = async () => {
-  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
-};
-const getKeyBindings$1 = async () => {
-  return invoke$2('KeyBindingsInitial.getKeyBindings');
-};
-const writeClipBoardText = async text => {
-  await invoke$2('ClipBoard.writeText', /* text */text);
-};
-const readClipBoardText = async () => {
-  return invoke$2('ClipBoard.readText');
-};
-const writeClipBoardImage = async blob => {
-  // @ts-ignore
-  await invoke$2('ClipBoard.writeImage', /* text */blob);
-};
-const searchFileMemory = async uri => {
-  // @ts-ignore
-  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
-};
-const searchFileFetch = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
-};
-const showMessageBox = async options => {
-  return invoke$2('ElectronDialog.showMessageBox', options);
-};
-const handleDebugResumed = async params => {
-  await invoke$2('Run And Debug.handleResumed', params);
-};
-const openWidget = async name => {
-  await invoke$2('Viewlet.openWidget', name);
-};
-const getIcons = async requests => {
-  const icons = await invoke$2('IconTheme.getIcons', requests);
-  return icons;
-};
-const activateByEvent = event => {
-  return invoke$2('ExtensionHostManagement.activateByEvent', event);
-};
-const setAdditionalFocus = focusKey => {
-  // @ts-ignore
-  return invoke$2('Focus.setAdditionalFocus', focusKey);
-};
-const getActiveEditorId = () => {
-  // @ts-ignore
-  return invoke$2('GetActiveEditor.getActiveEditorId');
-};
-const getWorkspacePath = () => {
-  return invoke$2('Workspace.getPath');
-};
-const sendMessagePortToRendererProcess = async port => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
-};
-const sendMessagePortToTextMeasurementWorker = async port => {
-  const command = 'TextMeasurement.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
-};
-const sendMessagePortToSourceControlWorker = async port => {
-  const command = 'SourceControl.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
-};
-const getPreference = async key => {
-  return await invoke$2('Preferences.get', key);
-};
-const getAllExtensions = async () => {
-  return invoke$2('ExtensionManagement.getAllExtensions');
-};
-const rerenderEditor = async key => {
-  // @ts-ignore
-  return invoke$2('Editor.rerender', key);
-};
-const handleDebugPaused = async params => {
-  await invoke$2('Run And Debug.handlePaused', params);
-};
-const openUri = async (uri, focus, options) => {
-  await invoke$2('Main.openUri', uri, focus, options);
-};
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer(
-  // @ts-ignore
-  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
-};
-const handleDebugScriptParsed = async script => {
-  await invoke$2('Run And Debug.handleScriptParsed', script);
-};
-const getWindowId = async () => {
-  return invoke$2('GetWindowId.getWindowId');
-};
-const getBlob = async uri => {
-  // @ts-ignore
-  return invoke$2('FileSystem.getBlob', uri);
-};
-const getExtensionCommands = async () => {
-  return invoke$2('ExtensionHost.getCommands');
-};
-const showErrorDialog = async errorInfo => {
-  // @ts-ignore
-  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
-};
-const getFolderSize = async uri => {
-  // @ts-ignore
-  return await invoke$2('FileSystem.getFolderSize', uri);
-};
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.getExtension', id);
-};
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke$2('Markdown.getVirtualDom', html);
-};
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke$2('Markdown.renderMarkdown', markdown, options);
-};
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
-};
-const uninstallExtension = async id => {
-  return invoke$2('ExtensionManagement.uninstall', id);
-};
-const installExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.install', id);
-};
-const openExtensionSearch = async () => {
-  // @ts-ignore
-  return invoke$2('SideBar.openViewlet', 'Extensions');
-};
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke$2('Extensions.handleInput', searchValue, Script);
-};
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openExternal', uri);
-};
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openUrl', uri);
-};
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke$2('Preferences.getAll');
-};
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$2('FilePicker.showSaveFilePicker');
-};
-const getLogsDir = async () => {
-  // @ts-ignore
-  return invoke$2('PlatformPaths.getLogsDir');
+const DebugWorker = 55;
+const RendererProcess = 1670;
+const RendererWorker$1 = 1;
+
+const FocusSelector = 'Viewlet.focusSelector';
+
+const {
+  invoke: invoke$3,
+  set: set$3
+} = create$1(RendererProcess);
+
+const {
+  invoke: invoke$2,
+  invokeAndTransfer,
+  set: set$2
+} = create$1(RendererWorker$1);
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
 };
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$2(mockRpc);
-  return mockRpc;
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
 };
 
 const RendererWorker = {
   __proto__: null,
-  activateByEvent,
-  applyBulkReplacement,
-  closeWidget,
-  confirm,
-  disableExtension,
-  dispose,
-  enableExtension,
-  getActiveEditorId,
-  getAllExtensions,
-  getAllPreferences,
-  getBlob,
-  getChromeVersion,
-  getColorThemeNames,
-  getElectronVersion,
-  getExtension,
-  getExtensionCommands,
-  getFileHandles,
-  getFileIcon,
-  getFilePathElectron,
-  getFolderIcon,
-  getFolderSize,
-  getIcons,
-  getKeyBindings: getKeyBindings$1,
-  getLogsDir,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened: getRecentlyOpened$1,
-  getV8Version,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  installExtension,
   invoke: invoke$2,
   invokeAndTransfer,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri,
-  openUrl,
-  openWidget,
-  readClipBoardText,
-  readFile,
-  registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSourceControlWorker,
-  sendMessagePortToSyntaxHighlightingWorker,
   sendMessagePortToTextMeasurementWorker,
-  set: set$2,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
-  showContextMenu2,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText
+  set: set$2
+};
+
+const send$1 = port => {
+  return sendMessagePortToRendererProcess(port);
+};
+const createRendererProcessRpc = async () => {
+  try {
+    const rpc = await create$4({
+      commandMap: {},
+      send: send$1
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create renderer process rpc`);
+  }
+};
+
+const initializeRendererProcess = async () => {
+  const rpc = await createRendererProcessRpc();
+  set$3(rpc);
 };
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
@@ -1758,8 +1478,9 @@ const RendererWorker = {
 // TODO this code seems a bit too complicated, maybe it can be simplified
 
 const state$1 = {
-  menus: [],
-  latestTimeStamp: 0};
+  latestTimeStamp: 0,
+  menus: []
+};
 const addMenuInternal = menu => {
   if (state$1.menus.length > 5) {
     throw new Error('too many menus');
@@ -1796,6 +1517,54 @@ const closeSubMenu = async () => {
   await invoke$3(/* Menu.hideSubMenu */7903, /* parentIndex */parentMenu.focusedIndex);
 };
 
+const send = port => {
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+const createTextMeasurementWorkerRpc = async () => {
+  try {
+    const rpc = await create$3({
+      commandMap: {},
+      send
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create text measurement worker rpc`);
+  }
+};
+
+let rpcPromise;
+const getRpc = () => {
+  rpcPromise ||= createTextMeasurementWorkerRpc();
+  return rpcPromise;
+};
+const measureTextWidths = async (texts, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth) => {
+  const rpc = await getRpc();
+  return rpc.invoke('TextMeasurement.measureTextWidths', texts, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+};
+
+const FontWeight = 400;
+const FontSize = 13;
+const FontFamily = 'system-ui, Ubuntu, Droid Sans, sans-serif';
+const LetterSpacing = 0;
+const IsMonospaceFont = false;
+const CharWidth = 8;
+const getLabels = items => {
+  return items.map(item => item.label).filter(label => typeof label === 'string' && label);
+};
+const getMenuLabelWidths = async items => {
+  const labels = getLabels(items);
+  return measureTextWidths(labels, FontWeight, FontSize, FontFamily, LetterSpacing, IsMonospaceFont, CharWidth);
+};
+
+const MENU_MIN_WIDTH = 150;
+const MENU_ITEM_HORIZONTAL_PADDING = 56;
+const MENU_ITEM_HORIZONTAL_MARGIN = 8;
+const getMenuMeasuredWidth = async items => {
+  const labelWidths = await getMenuLabelWidths(items);
+  const maxLabelWidth = Math.max(0, ...labelWidths);
+  return Math.ceil(Math.max(MENU_MIN_WIDTH, maxLabelWidth + MENU_ITEM_HORIZONTAL_PADDING + MENU_ITEM_HORIZONTAL_MARGIN));
+};
+
 const Separator$1 = 1;
 const None = 0;
 const SubMenu = 4;
@@ -1806,7 +1575,7 @@ const RestoreFocus = 6;
 const Ignore = 7;
 
 // TODO lazyload menuEntries and use Command.execute (maybe)
-const CONTEXT_MENU_WIDTH$1 = 250;
+const MENU_TARGET_GAP = 5;
 
 // TODO difference between focusing with mouse or keyboard
 // with mouse -> open submenu
@@ -1837,8 +1606,8 @@ const getMenuHeight$1 = items => {
   }
   return height;
 };
-const getMenuBounds = (x, y, items) => {
-  const menuWidth = CONTEXT_MENU_WIDTH$1;
+const getMenuBounds = async (x, y, items) => {
+  const menuWidth = await getMenuMeasuredWidth(items);
   const menuHeight = getMenuHeight$1(items);
   const layoutState = {
     points: [0, 0]
@@ -1849,7 +1618,7 @@ const getMenuBounds = (x, y, items) => {
   // TODO what about separators?
 
   if (x + menuWidth > windowWidth) {
-    x -= menuWidth;
+    x -= menuWidth + MENU_TARGET_GAP;
     x = Math.max(x, 0);
   }
   if (y + menuHeight > windowHeight) {
@@ -1857,10 +1626,10 @@ const getMenuBounds = (x, y, items) => {
     y = Math.max(y, 0);
   }
   return {
-    x,
-    y,
+    height: menuHeight,
     width: menuWidth,
-    height: menuHeight
+    x,
+    y
   };
 };
 
@@ -1934,7 +1703,8 @@ const UiStrings$2 = {
   SelectAll: 'Select All',
   ToggleBlockComment: 'Toggle Block Comment',
   ToggleLineComment: 'Toggle Line Comment',
-  Undo: 'Undo'};
+  Undo: 'Undo'
+};
 const cut = () => {
   return i18nString(UiStrings$2.Cut);
 };
@@ -1984,49 +1754,49 @@ const TitleBar = 15;
 const View$1 = 16;
 
 const menuEntrySeparator = {
-  id: 'separator',
-  label: '',
+  command: '',
   flags: Separator$2,
-  command: ''
+  id: 'separator',
+  label: ''
 };
 
 const id$9 = Edit$1;
 const getMenuEntries$d = () => {
   return [{
-    id: 'undo',
-    label: undo(),
+    command: /* TODO */'-1',
     flags: Disabled,
-    command: /* TODO */'-1'
+    id: 'undo',
+    label: undo()
   }, {
-    id: 'redo',
-    label: redo(),
+    command: /* TODO */'-1',
     flags: Disabled,
-    command: /* TODO */'-1'
+    id: 'redo',
+    label: redo()
   }, menuEntrySeparator, {
-    id: 'cut',
-    label: cut(),
+    command: /* Editor.cut */'Editor.cut',
     flags: None,
-    command: /* Editor.cut */'Editor.cut'
+    id: 'cut',
+    label: cut()
   }, {
-    id: 'copy',
-    label: copy(),
+    command: /* Editor.copy */'Editor.copy',
     flags: None,
-    command: /* Editor.copy */'Editor.copy'
+    id: 'copy',
+    label: copy()
   }, {
-    id: 'paste',
-    label: paste(),
+    command: /* Editor.paste */'Editor.paste',
     flags: None,
-    command: /* Editor.paste */'Editor.paste'
+    id: 'paste',
+    label: paste()
   }, menuEntrySeparator, {
-    id: 'toggle-line-comment',
-    label: toggleLineComment(),
+    command: /* Editor.toggleLineComment */'Editor.toggleLineComment',
     flags: None,
-    command: /* Editor.toggleLineComment */'Editor.toggleLineComment'
+    id: 'toggle-line-comment',
+    label: toggleLineComment()
   }, {
-    id: 'toggle-block-comment',
-    label: toggleBlockComment(),
+    command: /* Editor.toggleBlockComment */'Editor.toggleBlockComment',
     flags: None,
-    command: /* Editor.toggleBlockComment */'Editor.toggleBlockComment'
+    id: 'toggle-block-comment',
+    label: toggleBlockComment()
   }];
 };
 
@@ -2040,15 +1810,14 @@ const MenuEntriesEdit = {
  * @enum {string}
  */
 const UiStrings$1 = {
+  Exit: 'Exit',
   NewFile: 'New File',
   NewWindow: 'New Window',
   OpenFile: 'Open File',
   OpenFolder: 'Open Folder',
   OpenRecent: 'Open Recent',
-  Exit: 'Exit',
   Save: 'Save',
-  SaveAll: 'Save All'
-};
+  SaveAll: 'Save All'};
 const newFile = () => {
   return i18nString(UiStrings$1.NewFile);
 };
@@ -2080,47 +1849,47 @@ const Electron = 2;
 const id$8 = File$2;
 const getMenuEntries$c = platform => {
   const entries = [{
-    id: 'newFile',
-    label: newFile(),
+    command: '-1',
     flags: None,
-    command: '-1'
+    id: 'newFile',
+    label: newFile()
   }, {
-    id: 'newWindow',
-    label: newWindow(),
+    command: /* Window.openNew */'Window.openNew',
     flags: None,
-    command: /* Window.openNew */'Window.openNew'
+    id: 'newWindow',
+    label: newWindow()
   }, menuEntrySeparator, {
-    id: 'openFile',
-    label: openFile(),
+    command: 'Dialog.openFile',
     flags: None,
-    command: 'Dialog.openFile'
+    id: 'openFile',
+    label: openFile()
   }, {
-    id: 'openFolder',
-    label: openFolder(),
+    command: 'Dialog.openFolder',
     flags: RestoreFocus,
-    command: 'Dialog.openFolder'
+    id: 'openFolder',
+    label: openFolder()
   }, {
-    id: OpenRecent,
-    label: openRecent(),
+    command: '',
     flags: SubMenu,
-    command: ''
+    id: OpenRecent,
+    label: openRecent()
   }, menuEntrySeparator, {
-    id: 'save',
-    label: save(),
+    command: 'Main.save',
     flags: None,
-    command: 'Main.save'
+    id: 'save',
+    label: save()
   }, {
-    id: 'saveAll',
-    label: saveAll(),
+    command: 'Main.saveAll',
     flags: None,
-    command: 'Main.saveAll'
+    id: 'saveAll',
+    label: saveAll()
   }];
   if (platform === Electron) {
     entries.push(menuEntrySeparator, {
-      id: 'exit',
-      label: exit(),
+      command: 'Chrome.exit',
       flags: Ignore,
-      command: 'Chrome.exit'
+      id: 'exit',
+      label: exit()
     });
   }
   return entries;
@@ -2170,25 +1939,25 @@ const getMenuEntries$a = async platform => {
   const entries = [];
   if (platform !== Web) {
     entries.push({
-      id: 'toggleDeveloperTools',
-      label: toggleDeveloperTools(),
+      command: 'Developer.toggleDeveloperTools',
       flags: None,
-      command: 'Developer.toggleDeveloperTools'
+      id: 'toggleDeveloperTools',
+      label: toggleDeveloperTools()
     }, {
-      id: 'openProcessExplorer',
-      label: openProcessExplorer(),
+      command: 'Developer.openProcessExplorer',
       flags: RestoreFocus,
-      command: 'Developer.openProcessExplorer'
+      id: 'openProcessExplorer',
+      label: openProcessExplorer()
     });
   }
   if (entries.length > 0) {
     entries.push(menuEntrySeparator);
   }
   entries.push({
-    id: 'about',
-    label: about(),
+    command: 'About.showAbout',
     flags: None,
-    command: 'About.showAbout'
+    id: 'about',
+    label: about()
   });
   return entries;
 };
@@ -2199,8 +1968,9 @@ const MenuEntriesHelp = {
   id: id$6
 };
 
-const getRecentlyOpened = () => {
-  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+const getRecentlyOpened = async () => {
+  const recentlyOpened = await invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+  return recentlyOpened;
 };
 
 const File = 'file://';
@@ -2224,10 +1994,10 @@ const toMenuItem = folder => {
   const homeDir = getHomeDir();
   const label = getTitle(homeDir, folder);
   return {
-    label,
-    flags: None,
+    args: [folder],
     command: 'Workspace.setPath',
-    args: [folder]
+    flags: None,
+    label
   };
 };
 const id$5 = OpenRecent;
@@ -2239,15 +2009,15 @@ const getMenuEntries$9 = async () => {
     items.push(...itemsToShow.map(toMenuItem), menuEntrySeparator);
   }
   items.push({
-    id: 'more',
-    label: '...',
+    command: 'QuickPick.showRecent',
     flags: None,
-    command: 'QuickPick.showRecent'
+    id: 'more',
+    label: '...'
   }, menuEntrySeparator, {
-    id: 'clearRecentlyOpened',
-    label: 'clear',
+    command: 'RecentlyOpened.clearRecentlyOpened',
     flags: None,
-    command: 'RecentlyOpened.clearRecentlyOpened'
+    id: 'clearRecentlyOpened',
+    label: 'clear'
   });
   return items;
 };
@@ -2272,30 +2042,30 @@ const MenuEntriesRun = {
 const id$3 = Selection$1;
 const getMenuEntries$7 = () => {
   return [{
-    id: 'selectAll',
-    label: selectAll(),
+    command: 'Editor.selectAll',
     flags: None,
-    command: 'Editor.selectAll'
+    id: 'selectAll',
+    label: selectAll()
   }, {
-    id: 'copyLineUp',
-    label: copyLineUp(),
+    command: 'Editor.copyLineUp',
     flags: None,
-    command: 'Editor.copyLineUp'
+    id: 'copyLineUp',
+    label: copyLineUp()
   }, {
-    id: 'copyLineDown',
-    label: copyLineDown(),
+    command: 'Editor.copyLineDown',
     flags: None,
-    command: 'Editor.copyLineDown'
+    id: 'copyLineDown',
+    label: copyLineDown()
   }, {
-    id: 'moveLineUp',
-    label: moveLineUp(),
+    command: 'Editor.moveLineUp',
     flags: Disabled,
-    command: 'Editor.moveLineUp'
+    id: 'moveLineUp',
+    label: moveLineUp()
   }, {
-    id: 'moveLineDown',
-    label: moveLineDown(),
+    command: 'Editor.moveLineDown',
     flags: Disabled,
-    command: 'Editor.moveLineDown'
+    id: 'moveLineDown',
+    label: moveLineDown()
   }];
 };
 
@@ -2309,8 +2079,7 @@ const MenuEntriesSelection = {
  * @enum {string}
  */
 const UiStrings = {
-  NewTerminal: 'New Terminal'
-};
+  NewTerminal: 'New Terminal'};
 const newTerminal = () => {
   return i18nString(UiStrings.NewTerminal);
 };
@@ -2318,11 +2087,11 @@ const newTerminal = () => {
 const id$2 = Terminal$1;
 const getMenuEntries$6 = () => {
   return [{
-    id: 'newTerminal',
-    label: newTerminal(),
-    flags: None,
+    args: ['Terminal'],
     command: 'Layout.togglePanel',
-    args: ['Terminal']
+    flags: None,
+    id: 'newTerminal',
+    label: newTerminal()
   }];
 };
 
@@ -2359,68 +2128,68 @@ const help = () => {
 
 const getMenuEntries$5 = () => {
   return [{
+    flags: SubMenu,
     id: File$2,
-    label: file(),
-    flags: SubMenu
+    label: file()
   }, {
+    flags: SubMenu,
     id: Edit$1,
-    label: edit(),
-    flags: SubMenu
+    label: edit()
   }, {
+    flags: SubMenu,
     id: Selection$1,
-    label: selection(),
-    flags: SubMenu
+    label: selection()
   }, {
+    flags: SubMenu,
     id: View$1,
-    label: view(),
-    flags: SubMenu
+    label: view()
   }, {
+    flags: SubMenu,
     id: Go$1,
-    label: go(),
-    flags: SubMenu
+    label: go()
   }, {
+    flags: SubMenu,
     id: Run$1,
-    label: run(),
     keyboardShortCut: 'Alt+r',
-    flags: SubMenu
+    label: run()
   }, {
+    flags: SubMenu,
     id: Terminal$1,
-    label: terminal(),
     keyboardShortCut: 'Alt+t',
-    flags: SubMenu
+    label: terminal()
   }, {
+    flags: SubMenu,
     id: Help$1,
-    label: help(),
     keyboardShortCut: 'Alt+h',
-    flags: SubMenu
+    label: help()
   }];
 };
 
 const getMenuEntries$4 = () => {
   return [{
+    flags: None,
     id: File$2,
-    label: file(),
-    flags: None
+    label: file()
   }, {
+    flags: None,
     id: Edit$1,
-    label: edit(),
-    flags: None
+    label: edit()
   }, {
+    flags: None,
     id: Selection$1,
-    label: selection(),
-    flags: None
+    label: selection()
   }, {
+    flags: None,
     id: View$1,
-    label: view(),
-    flags: None
+    label: view()
   }, {
+    flags: None,
     id: Go$1,
-    label: go(),
-    flags: None
+    label: go()
   }, {
+    flags: None,
     id: Help$1,
-    label: help(),
-    flags: None
+    label: help()
   }];
 };
 
@@ -2517,9 +2286,9 @@ const mergeClassNames = (...classNames) => {
 
 const text = data => {
   return {
-    type: Text,
+    childCount: 0,
     text: data,
-    childCount: 0
+    type: Text
   };
 };
 
@@ -2527,16 +2296,16 @@ const Div = 4;
 const Span = 8;
 
 const checkboxChecked = {
-  type: Div,
+  ariaChecked: true,
+  childCount: 2,
   className: mergeClassNames(MenuItem, MenuItemCheckMark),
   role: MenuItemCheckBox,
-  ariaChecked: true,
   tabIndex: -1,
-  childCount: 2
+  type: Div
 };
 const checkMark = {
-  type: Div,
-  className: mergeClassNames(MenuItemCheckmarkIcon, MaskIconCheck)
+  className: mergeClassNames(MenuItemCheckmarkIcon, MaskIconCheck),
+  type: Div
 };
 const getMenuItemCheckedDom = menuItem => {
   const {
@@ -2559,41 +2328,41 @@ const getKeyBindingString = (key, altKey, ctrlKey, shiftKey, metaKey) => {
 
 const getMenuItemDefaultDom = menuItem => {
   const {
-    label,
     isFocused,
-    key
+    key,
+    label
   } = menuItem;
   let className = MenuItem;
   if (isFocused) {
     className += ' ' + MenuItemFocused;
   }
   const dom = [{
-    type: Div,
+    childCount: 1,
     className,
     role: MenuItem$1,
     tabIndex: -1,
-    childCount: 1
+    type: Div
   }, text(label)];
   if (key) {
     dom[0].childCount++;
     const parsedKey = parseKey(key);
     const keyBindingsString = getKeyBindingString(parsedKey.key, false, parsedKey.isCtrl, parsedKey.isShift);
     dom.push({
-      type: Span,
+      childCount: 1,
       className: MenuItemKeyBinding,
-      childCount: 1
+      type: Span
     }, text(keyBindingsString));
   }
   return dom;
 };
 
 const disabled = {
-  type: Div,
+  childCount: 1,
   className: MenuItem,
+  disabled: true,
   role: MenuItem$1,
   tabIndex: -1,
-  disabled: true,
-  childCount: 1
+  type: Div
 };
 const getMenuItemDisabledDom = menuItem => {
   const {
@@ -2603,34 +2372,37 @@ const getMenuItemDisabledDom = menuItem => {
 };
 
 const getMenuItemsNoopDom = () => {
-  return [];
+  return [{
+    childCount: 1,
+    type: Div$1
+  }, text(`Unsupport menu item type`)];
 };
 
 const separator = {
-  type: Div,
+  childCount: 1,
   className: MenuItemSeparator,
   role: Separator,
-  childCount: 1
+  type: Div
 };
 const separatorLine = {
-  type: Div,
+  childCount: 0,
   className: MenuItemSeparatorLine,
-  childCount: 0
+  type: Div
 };
 const getMenuItemSeparatorDom = menuItem => {
   return [separator, separatorLine];
 };
 
 const arrowRight = {
-  type: Div,
+  childCount: 0,
   className: MenuItemSubMenuArrowRight,
-  childCount: 0
+  type: Div
 };
 const getMenuItemSubMenuDom = menuItem => {
   const {
-    label,
-    isFocused,
     isExpanded,
+    isFocused,
+    label,
     level
   } = menuItem;
   let className = MenuItem;
@@ -2639,24 +2411,24 @@ const getMenuItemSubMenuDom = menuItem => {
     className += ' ' + MenuItemFocused;
   }
   return [{
-    type: Div,
+    ariaExpanded: isExpanded,
+    ariaHasPopup: true,
+    ariaOwns: isExpanded ? `Menu-${level + 1}` : undefined,
+    childCount: 2,
     className,
     role: MenuItem$1,
     tabIndex: -1,
-    ariaHasPopup: true,
-    ariaExpanded: isExpanded,
-    ariaOwns: isExpanded ? `Menu-${level + 1}` : undefined,
-    childCount: 2
+    type: Div
   }, text(label), arrowRight];
 };
 
 const checkboxUnchecked = {
-  type: Div,
+  ariaChecked: false,
+  childCount: 1,
   className: MenuItem,
   role: MenuItemCheckBox,
-  ariaChecked: false,
   tabIndex: -1,
-  childCount: 1
+  type: Div
 };
 const getMenuItemUncheckedDom = menuItem => {
   const {
@@ -2667,20 +2439,20 @@ const getMenuItemUncheckedDom = menuItem => {
 
 const getMenuItemRenderer = flags => {
   switch (flags) {
+    case Checked:
+      return getMenuItemCheckedDom;
+    case Disabled:
+      return getMenuItemDisabledDom;
+    case Ignore:
     case None:
     case RestoreFocus:
-    case Ignore:
       return getMenuItemDefaultDom;
     case Separator$1:
       return getMenuItemSeparatorDom;
-    case Checked:
-      return getMenuItemCheckedDom;
-    case Unchecked:
-      return getMenuItemUncheckedDom;
-    case Disabled:
-      return getMenuItemDisabledDom;
     case SubMenu:
       return getMenuItemSubMenuDom;
+    case Unchecked:
+      return getMenuItemUncheckedDom;
     default:
       return getMenuItemsNoopDom;
   }
@@ -2696,11 +2468,11 @@ const getMenuItemVirtualDom = menuItem => {
 
 const getMenuVirtualDom = menuItems => {
   const dom = [{
-    type: Div,
+    childCount: menuItems.length,
     className: Menu,
     role: Menu$1,
     tabIndex: -1,
-    childCount: menuItems.length
+    type: Div
   }, ...menuItems.flatMap(getMenuItemVirtualDom)];
   return dom;
 };
@@ -2714,12 +2486,12 @@ const getVisible = (items, focusedIndex, expanded, level) => {
       label
     } = item;
     visibleItems.push({
-      label,
       flags,
-      isFocused: i === focusedIndex,
       isExpanded: i === focusedIndex && expanded,
-      level,
-      key: item.key
+      isFocused: i === focusedIndex,
+      key: item.key,
+      label,
+      level
     });
   }
   return visibleItems;
@@ -2752,8 +2524,8 @@ const getMenuHeight = items => {
 const getMenuHideCommands = async (restoreFocus = true) => {
   if (getCount() === 0) {
     return {
-      newMenus: [],
-      commands: []
+      commands: [],
+      newMenus: []
     };
   }
   reset();
@@ -2788,11 +2560,11 @@ const MENU_WIDTH = 150;
 
 const show$2 = async (x, y, id, mouseBlocking = false, ...args) => {
   const items = await getMenuEntriesWithKeyBindings(id, ...args);
-  const bounds = getMenuBounds(x, y, items);
+  const bounds = await getMenuBounds(x, y, items);
   const menu = addMenuInternal({
+    focusedIndex: -1,
     id,
     items,
-    focusedIndex: -1,
     level: getCount(),
     x: bounds.x,
     y: bounds.y
@@ -2803,11 +2575,11 @@ const show$2 = async (x, y, id, mouseBlocking = false, ...args) => {
 };
 const show2$2 = async (uid, menuId, x, y, mouseBlocking = false, ...args) => {
   const items = await getMenuEntriesWithKeyBindings2(uid, menuId, ...args);
-  const bounds = getMenuBounds(x, y, items);
+  const bounds = await getMenuBounds(x, y, items);
   const menu = addMenuInternal({
+    focusedIndex: -1,
     id: menuId,
     items,
-    focusedIndex: -1,
     level: getCount(),
     x: bounds.x,
     y: bounds.y
@@ -2903,8 +2675,8 @@ const create = () => {
     },
     set(uid, oldState, newState) {
       states[uid] = {
-        oldState,
-        newState
+        newState,
+        oldState
       };
     }
   };
@@ -2917,16 +2689,16 @@ const {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   return diff(oldState, newState);
 };
 
 const canBeFocused = item => {
   switch (item.flags) {
-    case Separator$2:
     case Disabled$1:
+    case Separator$2:
       return false;
     default:
       return true;
@@ -3033,36 +2805,36 @@ const FocusTitleBarMenuBar = 26;
 
 const getKeyBindings = () => {
   return [{
-    key: DownArrow$1,
     command: 'TitleBarMenuBar.handleKeyArrowDown',
+    key: DownArrow$1,
     when: FocusTitleBarMenuBar
   }, {
-    key: UpArrow$1,
     command: 'TitleBarMenuBar.handleKeyArrowUp',
+    key: UpArrow$1,
     when: FocusTitleBarMenuBar
   }, {
-    key: RightArrow$1,
     command: 'TitleBarMenuBar.handleKeyArrowRight',
+    key: RightArrow$1,
     when: FocusTitleBarMenuBar
   }, {
-    key: LeftArrow$1,
     command: 'TitleBarMenuBar.handleKeyArrowLeft',
+    key: LeftArrow$1,
     when: FocusTitleBarMenuBar
   }, {
-    key: Space$1,
     command: 'TitleBarMenuBar.handleKeySpace',
+    key: Space$1,
     when: FocusTitleBarMenuBar
   }, {
-    key: Home$1,
     command: 'TitleBarMenuBar.handleKeyHome',
+    key: Home$1,
     when: FocusTitleBarMenuBar
   }, {
-    key: End$1,
     command: 'TitleBarMenuBar.handleKeyEnd',
+    key: End$1,
     when: FocusTitleBarMenuBar
   }, {
-    key: Escape$1,
     command: 'TitleBarMenuBar.handleKeyEscape',
+    key: Escape$1,
     when: FocusTitleBarMenuBar
   }];
 };
@@ -3095,11 +2867,11 @@ const getMenuEntries = (id, platform) => {
 // TODO more tests
 
 const getMenuShowCommands = async (items, menuId, x, y, mouseBlocking = false) => {
-  const bounds = getMenuBounds(x, y, items);
+  const bounds = await getMenuBounds(x, y, items);
   const menu = addMenuInternal({
+    focusedIndex: -1,
     id: menuId,
     items,
-    focusedIndex: -1,
     level: getCount(),
     x: bounds.x,
     y: bounds.y
@@ -3107,9 +2879,9 @@ const getMenuShowCommands = async (items, menuId, x, y, mouseBlocking = false) =
   const visible = getVisible(menu.items, -1, false, menu.level);
   const dom = getMenuVirtualDom(visible).slice(1);
   return {
-    menus: getAll(),
+    commands: [/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking],
     menu,
-    commands: [/* Menu.show */'Menu.showMenu', /* x */bounds.x, /* y */bounds.y, /* width */bounds.width, /* height */bounds.height, /* items */menu.items, /* level */menu.level, /* parentIndex */-1, /* dom */dom, /* mouseBlocking */mouseBlocking]
+    menus: getAll()
   };
 };
 
@@ -3127,8 +2899,8 @@ const hideSubMenus = async level => {
 const MENU_DELAY_TRIANGLE = 300;
 const resolveAfterTimeout = async () => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   setTimeout(resolve, MENU_DELAY_TRIANGLE);
   await promise;
@@ -3141,14 +2913,14 @@ const showSubMenuAtEnter = async (level, index, enterX, enterY) => {
   const item = parentMenu.items[index];
   const subMenuItems = await getMenuEntries$1(item.id);
   const subMenu = addMenuInternal({
+    enterX,
+    enterY,
+    focusedIndex: -1,
     id: item.id,
     items: subMenuItems,
-    focusedIndex: -1,
     level: getCount(),
-    y: parentMenu.y + index * 25,
     x: parentMenu.x + MENU_WIDTH,
-    enterX,
-    enterY
+    y: parentMenu.y + index * 25
   });
   const width = getMenuWidth();
   const height = getMenuHeight(subMenuItems);
@@ -3273,8 +3045,8 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = async (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   set(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
@@ -3316,6 +3088,8 @@ const saveState = uid => {
   };
 };
 
+const selectIndexDefault = async () => {};
+
 const {
   invoke} = RendererWorker;
 
@@ -3323,36 +3097,46 @@ const executeMenuItemCommand = async item => {
   await invoke(item.command, ...(item.args || []));
 };
 
+const selectIndexIgnore = async (menu, item) => {
+  await executeMenuItemCommand(item);
+};
+
 const selectIndexNone = async (menu, item) => {
-  await Promise.all([hide(/* restoreFocus */false), executeMenuItemCommand(item)]);
+  await hide(/* restoreFocus */false);
+  await executeMenuItemCommand(item);
 };
+
 const selectIndexRestoreFocus = async (menu, item) => {
-  await Promise.all([hide(/* restoreFocus */true), executeMenuItemCommand(item)]);
+  await hide(/* restoreFocus */true);
+  await executeMenuItemCommand(item);
 };
+
 const selectIndexSubMenu = async (menu, item, index) => {
   if (menu.focusedIndex === index) {
     return;
   }
   await showSubMenu(menu.level, menu.focusedIndex);
 };
-const selectIndexDefault = async () => {};
-const selectIndexIgnore = async (menu, item) => {
-  await executeMenuItemCommand(item);
-};
+
 const getSelectIndexFunction = flags => {
   switch (flags) {
+    case Checked$1:
+      return selectIndexRestoreFocus;
+    case Ignore$1:
+      return selectIndexIgnore;
     case None$1:
       return selectIndexNone;
+    case RestoreFocus$1:
+      return selectIndexRestoreFocus;
     case SubMenu$1:
       return selectIndexSubMenu;
-    case RestoreFocus$1:
+    case Unchecked$1:
       return selectIndexRestoreFocus;
-    case Ignore$1:
-      return selectIndexIgnore;
     default:
       return selectIndexDefault;
   }
 };
+
 const selectIndex = async (level, index) => {
   const menu = get$1(level);
   // TODO avoid assignment
@@ -3421,31 +3205,15 @@ const commandMap = {
   'Menu.showSubMenu': showSubMenu
 };
 
-const send = port => {
-  return sendMessagePortToRendererProcess(port);
-};
-const createRendererProcessRpc = async () => {
-  try {
-    const rpc = await TransferMessagePortRpcParent.create({
-      commandMap: {},
-      send
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create renderer process rpc`);
-  }
-};
-
-const initializeRendererProcess = async () => {
-  const rpc = await createRendererProcessRpc();
-  set$3(rpc);
-};
-
-const listen = async () => {
-  const rpc = await WebWorkerRpcClient.create({
+const initializeRendererWorker = async () => {
+  const rpc = await create$2({
     commandMap: commandMap
   });
   set$2(rpc);
+};
+
+const listen = async () => {
+  await initializeRendererWorker();
   await initializeRendererProcess();
 };