@lvce-editor/title-bar-worker 2.3.0 → 2.5.0

package/dist/titleBarWorkerMain.js

@@ -60,58 +60,54 @@ class AssertionError extends Error {
     this.name = 'AssertionError';
   }
 }
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown$1 = 8;
 const getType = value => {
   switch (typeof value) {
     case 'number':
-      return 'number';
+      return Number$1;
     case 'function':
-      return 'function';
+      return Function;
     case 'string':
-      return 'string';
+      return String;
     case 'object':
       if (value === null) {
-        return 'null';
+        return Null;
       }
       if (Array.isArray(value)) {
-        return 'array';
+        return Array$1;
       }
-      return 'object';
+      return Object$1;
     case 'boolean':
-      return 'boolean';
+      return Boolean$1;
     default:
-      return 'unknown';
+      return Unknown$1;
   }
 };
 const object = value => {
   const type = getType(value);
-  if (type !== 'object') {
+  if (type !== Object$1) {
     throw new AssertionError('expected value to be of type object');
   }
 };
 const number = value => {
   const type = getType(value);
-  if (type !== 'number') {
+  if (type !== Number$1) {
     throw new AssertionError('expected value to be of type number');
   }
 };
 const array = value => {
   const type = getType(value);
-  if (type !== 'array') {
+  if (type !== Array$1) {
     throw new AssertionError('expected value to be of type array');
   }
 };
-const string = value => {
-  const type = getType(value);
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-const boolean = value => {
-  const type = getType(value);
-  if (type !== 'boolean') {
-    throw new AssertionError('expected value to be of type boolean');
-  }
-};
 
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
@@ -362,22 +358,11 @@ class IpcChildWithModuleWorker extends Ipc {
 const wrap$f = global => {
   return new IpcChildWithModuleWorker(global);
 };
-const withResolvers = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    resolve: _resolve,
-    promise
-  };
-};
 const waitForFirstMessage = async port => {
   const {
     resolve,
     promise
-  } = withResolvers();
+  } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
   });
@@ -458,11 +443,11 @@ const remove = id => {
   delete callbacks[id];
 };
 let id$a = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id$a;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
@@ -540,6 +525,17 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
 const getNewLineIndex = (string, startIndex = undefined) => {
   return string.indexOf(NewLine, startIndex);
 };
@@ -550,19 +546,16 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
 const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
     return error;
   }
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -643,6 +636,17 @@ const getErrorType = prettyError => {
   }
   return undefined;
 };
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const getStack = prettyError => {
+  const stackString = prettyError.stack || '';
+  const newLineIndex = stackString.indexOf('\n');
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
@@ -655,7 +659,7 @@ const getErrorProperty = (error, prettyError) => {
     code: Custom,
     message: prettyError.message,
     data: {
-      stack: prettyError.stack,
+      stack: getStack(prettyError),
       codeFrame: prettyError.codeFrame,
       type: getErrorType(prettyError),
       code: prettyError.code,
@@ -663,18 +667,18 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (message, error) => {
+const create$1$1 = (id, error) => {
   return {
     jsonrpc: Two,
-    id: message.id,
+    id,
     error
   };
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
+  return create$1$1(id, errorProperty);
 };
 const create$5 = (message, result) => {
   return {
@@ -687,12 +691,27 @@ const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
   return create$5(message, resultProperty);
 };
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
     const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
     return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
   }
 };
 const defaultPreparePrettyError = error => {
@@ -747,7 +766,7 @@ const handleJsonRpcMessage = async (...args) => {
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -778,13 +797,19 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+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);
@@ -795,7 +820,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -811,10 +836,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -852,7 +877,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$2 = async ({
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -864,7 +889,110 @@ const create$2 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$2
+  create: create$3
+};
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$2 = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    get(uid) {
+      return states[uid];
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        oldState,
+        newState
+      };
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseInt(key);
+      });
+    },
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (newState === newerState) {
+          return;
+        }
+        const latest = states[uid];
+        states[uid] = {
+          oldState: latest.oldState,
+          newState: newerState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        newState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
 };
 
 const RenderEntries = 1;
@@ -900,25 +1028,11 @@ const diff = (oldState, newState) => {
   return diffResult;
 };
 
-const create$1 = () => {
-  const states = Object.create(null);
-  return {
-    get(uid) {
-      return states[uid];
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
-    }
-  };
-};
-
 const {
   get: get$1,
-  set: set$1
-} = create$1();
+  set: set$3,
+  wrapCommand
+} = create$2();
 
 const diff2 = uid => {
   const {
@@ -934,104 +1048,77 @@ const getCommandIds = () => {
   return commandsIds;
 };
 
-const Backspace$1 = 1;
-const Tab$1 = 2;
-const Enter$1 = 3;
-const Escape$1 = 8;
-const Space$1 = 9;
-const PageUp$1 = 10;
-const PageDown$1 = 11;
-const End$1 = 255;
-const Home$1 = 12;
-const LeftArrow$1 = 13;
-const UpArrow$1 = 14;
-const RightArrow$1 = 15;
-const DownArrow$1 = 16;
-const Insert$1 = 17;
-const Delete$1 = 18;
-const Digit0$1 = 19;
-const Digit1$1 = 20;
-const Digit2$1 = 21;
-const Digit3$1 = 22;
-const Digit4$1 = 23;
-const Digit5$1 = 24;
-const Digit6$1 = 25;
-const Digit7$1 = 26;
-const Digit8$1 = 27;
-const Digit9$1 = 28;
-const KeyA$1 = 29;
-const KeyB$1 = 30;
-const KeyC$1 = 31;
-const KeyD$1 = 32;
-const KeyE$1 = 33;
-const KeyF$1 = 34;
-const KeyG$1 = 35;
-const KeyH$1 = 36;
-const KeyI$1 = 37;
-const KeyJ$1 = 38;
-const KeyK$1 = 39;
-const KeyL$1 = 40;
-const KeyM$1 = 41;
-const KeyN$1 = 42;
-const KeyO$1 = 43;
-const KeyP$1 = 44;
-const KeyQ$1 = 45;
-const KeyR$1 = 46;
-const KeyS$1 = 47;
-const KeyT$1 = 48;
-const KeyU$1 = 49;
-const KeyV$1 = 50;
-const KeyW$1 = 51;
-const KeyX$1 = 52;
-const KeyY$1 = 53;
-const KeyZ$1 = 54;
-const F1$1 = 57;
-const F2$1 = 58;
-const F3$1 = 59;
-const F4$1 = 60;
-const F5$1 = 61;
-const F6$1 = 62;
-const Equal$1 = 84;
-const Comma$1 = 85;
-const Minus$1 = 86;
-const Backquote$1 = 89;
-const Backslash$1 = 91;
-const Star$1 = 131;
-const Plus$1 = 132;
+const Button = 1;
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const I = 16;
+const Img = 17;
+
+const Escape$2 = 8;
+const Space$2 = 9;
+const End$2 = 255;
+const Home$2 = 12;
+const LeftArrow$2 = 13;
+const UpArrow$2 = 14;
+const RightArrow$2 = 15;
+const DownArrow$2 = 16;
+
+const CtrlCmd = 1 << 11 >>> 0;
+const Shift = 1 << 10 >>> 0;
+
+const DebugWorker = 55;
+const RendererWorker$1 = 1;
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
+const px = value => {
+  return `${value}px`;
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
 
 const FocusTitleBarMenuBar = 26;
 
-const getKeyBindings = () => {
+const getKeyBindings$1 = () => {
   return [{
-    key: DownArrow$1,
+    key: DownArrow$2,
     command: 'TitleBarMenuBar.handleKeyArrowDown',
     when: FocusTitleBarMenuBar
   }, {
-    key: UpArrow$1,
+    key: UpArrow$2,
     command: 'TitleBarMenuBar.handleKeyArrowUp',
     when: FocusTitleBarMenuBar
   }, {
-    key: RightArrow$1,
+    key: RightArrow$2,
     command: 'TitleBarMenuBar.handleKeyArrowRight',
     when: FocusTitleBarMenuBar
   }, {
-    key: LeftArrow$1,
+    key: LeftArrow$2,
     command: 'TitleBarMenuBar.handleKeyArrowLeft',
     when: FocusTitleBarMenuBar
   }, {
-    key: Space$1,
+    key: Space$2,
     command: 'TitleBarMenuBar.handleKeySpace',
     when: FocusTitleBarMenuBar
   }, {
-    key: Home$1,
+    key: Home$2,
     command: 'TitleBarMenuBar.handleKeyHome',
     when: FocusTitleBarMenuBar
   }, {
-    key: End$1,
+    key: End$2,
     command: 'TitleBarMenuBar.handleKeyEnd',
     when: FocusTitleBarMenuBar
   }, {
-    key: Escape$1,
+    key: Escape$2,
     command: 'TitleBarMenuBar.handleKeyEscape',
     when: FocusTitleBarMenuBar
   }];
@@ -1103,7 +1190,7 @@ const moveLineDown = () => {
 };
 
 const Edit$1 = 2;
-const File$1 = 5;
+const File$2 = 5;
 const Go$1 = 6;
 const Help$1 = 7;
 const OpenRecent = 9;
@@ -1217,7 +1304,7 @@ const Web = 1;
 const Electron = 2;
 const Remote = 3;
 
-const id$8 = File$1;
+const id$8 = File$2;
 const getMenuEntries$c = platform => {
   const entries = [{
     id: 'newFile',
@@ -1288,7 +1375,7 @@ const CheckForUpdates = 'Check For Updates';
 const ClearRecentlyOpened = 'Clear Recently Opened';
 const Close = 'Close';
 const Edit = 'Edit';
-const File = 'File';
+const File$1 = 'File';
 const Go = 'Go';
 const Help = 'Help';
 const Maximize = 'Maximize';
@@ -1365,25 +1452,390 @@ const MenuEntriesHelp = {
 };
 
 const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
   return rpcs[id];
 };
-const RendererWorker$1 = 1;
-const invoke$2 = (method, ...params) => {
-  const rpc = get(RendererWorker$1);
+
+const create$1 = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$2(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+
+const {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$1,
+  dispose
+} = create$1(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$1('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$1('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$1('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$1('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$1('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$1(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$1('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$1('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$1('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$1('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$1('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$1('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
-  return rpc.invoke(method, ...params);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
-const set$2 = rpc => {
-  set$3(RendererWorker$1, rpc);
+const readFile = async uri => {
+  return invoke$1('FileSystem.readFile', uri);
 };
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$1('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus$1 = key => {
+  return invoke$1('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$1('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$1('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$1('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$1('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$1('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$1('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened$1 = async () => {
+  return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$1('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$1('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$1('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$1('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$1('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$1('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$1('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$1('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$1('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke$1('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$1('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$1('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$1('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const getPreference = async key => {
+  return await invoke$1('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$1('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$1('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$1('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$1('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$1('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$1('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$1('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$1('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$1('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$1('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$1('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$1('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$1('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$1('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$1('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$1('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$1('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$1('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$1('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$1('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  return invoke$1('PlatformPaths.getLogsDir');
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$1(mockRpc);
+  return mockRpc;
+};
+
 const RendererWorker = {
   __proto__: null,
-  invoke: invoke$2,
-  set: set$2
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened: getRecentlyOpened$1,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
+  invoke: invoke$1,
+  invokeAndTransfer,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readFile,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$1,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus: setFocus$1,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
 };
 
 const {
@@ -1395,10 +1847,15 @@ const getRecentlyOpened = () => {
   return invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
 };
 
-const getTitle = uri => {
+const File = 'file://';
+
+const getTitle = (homeDir, uri) => {
   if (!uri) {
     return '';
   }
+  if (uri.startsWith(File)) {
+    return uri.slice(File.length);
+  }
   return uri;
 };
 
@@ -1409,9 +1866,14 @@ const clearRecentlyOpened = () => {
   return i18nString(ClearRecentlyOpened);
 };
 
+const getHomeDir = () => {
+  return '';
+};
+
 const MAX_MENU_RECENT_ENTRIES = 10;
 const toMenuItem = folder => {
-  const label = getTitle(folder);
+  const homeDir = getHomeDir();
+  const label = getTitle(homeDir, folder);
   return {
     label,
     flags: None$1,
@@ -1522,7 +1984,7 @@ const MenuEntriesTerminal = {
 };
 
 const file = () => {
-  return i18nString(File);
+  return i18nString(File$1);
 };
 const edit = () => {
   return i18nString(Edit);
@@ -1557,7 +2019,7 @@ const close$1 = () => {
 
 const getMenuEntries$5 = () => {
   return [{
-    id: File$1,
+    id: File$2,
     label: file(),
     flags: SubMenu
   }, {
@@ -1596,7 +2058,7 @@ const getMenuEntries$5 = () => {
 
 const getMenuEntries$4 = () => {
   return [{
-    id: File$1,
+    id: File$2,
     label: file(),
     flags: None$1
   }, {
@@ -1737,12 +2199,6 @@ const MenuItemCheckBox = 'menuitemcheckbox';
 const None = 'none';
 const Separator = 'separator';
 
-const Button = 1;
-const Div = 4;
-const I = 16;
-const Img = 17;
-const Span = 8;
-
 const getIconVirtualDom = (icon, type = Div) => {
   return {
     type,
@@ -1769,18 +2225,6 @@ const createTitleBarButton = button => {
   return dom;
 };
 
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-const Text = 12;
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
-};
-
 const getTitleBarButtonsVirtualDom = buttons => {
   const dom = [{
     type: Div,
@@ -1790,12 +2234,13 @@ const getTitleBarButtonsVirtualDom = buttons => {
   return dom;
 };
 
+const parentNode = {
+  type: Div,
+  className: mergeClassNames(Viewlet, TitleBarIcon),
+  childCount: 1
+};
 const getTitleBarIconVirtualDom = iconSrc => {
-  return [{
-    type: Div,
-    className: mergeClassNames(Viewlet, TitleBarIcon),
-    childCount: 1
-  }, {
+  return [parentNode, {
     type: Img,
     className: TitleBarIconIcon,
     src: iconSrc,
@@ -1804,16 +2249,16 @@ const getTitleBarIconVirtualDom = iconSrc => {
   }];
 };
 
-const HandleClick = 'handleClick';
-const HandleClickMinimize = 'handleClickMinimize';
-const HandleClickToggleClose = 'handleClickToggleClose';
-const HandleClickToggleMaximize = 'handleClickToggleMaximize';
-const HandleFocusIn = 'handleFocusIn';
-const HandleFocusOut = 'handleFocusOut';
-const HandlePointerOut = 'handlePointerOut';
-const HandlePointerOver = 'handlePointerOver';
-const HandleMenuClick = 'handleMenuClick';
-const HandleMenuMouseOver = 'handleMenuMouseOver';
+const HandleClick = 1;
+const HandleClickMinimize = 2;
+const HandleClickToggleClose = 3;
+const HandleClickToggleMaximize = 4;
+const HandleFocusIn = 5;
+const HandleFocusOut = 6;
+const HandlePointerOut = 7;
+const HandlePointerOver = 8;
+const HandleMenuClick = 9;
+const HandleMenuMouseOver = 10;
 
 const getItemVirtualDom = item => {
   // @ts-ignore
@@ -1823,6 +2268,7 @@ const getItemVirtualDom = item => {
     isOpen,
     isFocused
   } = item;
+  // TODO avoid mutation
   const dom = [];
   dom.push({
     type: Div,
@@ -1902,7 +2348,8 @@ const handleClickToggleMaximize = async state => {
   return state;
 };
 
-const handleClick$1 = (state, className) => {
+// TODO use button name property
+const handleClick$1 = async (state, className) => {
   if (className.includes('Minimize')) {
     return handleClickMinimize(state);
   }
@@ -2137,7 +2584,7 @@ const handlePointerOut = (state, clientX, clientY) => {
   if (index === -1) {
     return state;
   }
-  return handleMouseOut(state, index);
+  return handleMouseOut(state);
 };
 
 const handleMouseOverMenuClosed = (state, index) => {
@@ -2161,74 +2608,46 @@ const handlePointerOver = (state, clientX, clientY) => {
   return handleMouseOver(state, index);
 };
 
-const getFontString = (fontWeight, fontSize, fontFamily) => {
-  return `${fontWeight} ${fontSize}px ${fontFamily}`;
-};
-
-const createTextMeasureContext = () => {
+const createTextMeasureContext = (letterSpacing, font) => {
   const canvas = new OffscreenCanvas(0, 0);
   const ctx = canvas.getContext('2d');
   if (!ctx) {
     throw new Error('Failed to get canvas context 2d');
   }
+  ctx.letterSpacing = letterSpacing;
+  ctx.font = font;
   return ctx;
 };
 
-const state = {
-  ctx: undefined
-};
-const getOrCreate = createCtx => {
-  if (state.ctx) {
-    return state.ctx;
-  }
-  state.ctx = createCtx();
-  return state.ctx;
-};
-
-const getContext = () => {
-  const ctx = getOrCreate(createTextMeasureContext);
-  return ctx;
-};
-
-const px = value => {
-  return `${value}px`;
+const getFontString = (fontWeight, fontSize, fontFamily) => {
+  return `${fontWeight} ${fontSize}px ${fontFamily}`;
 };
 
-const getLetterSpacingString = letterSpacing => {
-  return px(letterSpacing);
-};
-const measureTextWidth = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  string(text);
-  number(fontWeight);
-  number(fontSize);
-  string(fontFamily);
-  boolean(isMonoSpaceFont);
-  number(charWidth);
+const measureTextWidths = (texts, fontWeight, fontSize, fontFamily, letterSpacing) => {
   if (typeof letterSpacing !== 'number') {
     throw new TypeError('letterSpacing must be of type number');
   }
-  const letterSpacingString = getLetterSpacingString(letterSpacing);
+  const letterSpacingString = px(letterSpacing);
   const fontString = getFontString(fontWeight, fontSize, fontFamily);
-  const ctx = getContext();
-  ctx.letterSpacing = letterSpacingString;
-  ctx.font = fontString;
-  const metrics = ctx.measureText(text);
-  const {
-    width
-  } = metrics;
-  return width;
-};
-
-const measureTitleBarEntryWidth = (label, fontWeight, fontSize, fontFamily, letterSpacing) => {
-  const isMonospaceFont = false;
-  const charWidth = 0;
-  return measureTextWidth(label, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth);
+  const ctx = createTextMeasureContext(letterSpacingString, fontString);
+  const widths = [];
+  for (const text of texts) {
+    const metrics = ctx.measureText(text);
+    const {
+      width
+    } = metrics;
+    widths.push(width);
+  }
+  return widths;
 };
 
 const addWidths = (entries, labelPadding, fontWeight, fontSize, fontFamily, letterSpacing) => {
+  const labels = entries.map(entry => entry.label);
+  const widths = measureTextWidths(labels, fontWeight, fontSize, fontFamily, letterSpacing);
   const withWidths = [];
-  for (const entry of entries) {
-    const textWidth = measureTitleBarEntryWidth(entry.label, fontWeight, fontSize, fontFamily, letterSpacing);
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const textWidth = widths[i];
     const width = textWidth + labelPadding * 2;
     withWidths.push({
       ...entry,
@@ -2337,6 +2756,71 @@ const getKeyBindingString = (key, altKey, ctrlKey, shiftKey, metaKey) => {
   return string;
 };
 
+const Backspace$1 = 1;
+const Tab$1 = 2;
+const Enter$1 = 3;
+const Escape$1 = 8;
+const Space$1 = 9;
+const PageUp$1 = 10;
+const PageDown$1 = 11;
+const End$1 = 255;
+const Home$1 = 12;
+const LeftArrow$1 = 13;
+const UpArrow$1 = 14;
+const RightArrow$1 = 15;
+const DownArrow$1 = 16;
+const Insert$1 = 17;
+const Delete$1 = 18;
+const Digit0$1 = 19;
+const Digit1$1 = 20;
+const Digit2$1 = 21;
+const Digit3$1 = 22;
+const Digit4$1 = 23;
+const Digit5$1 = 24;
+const Digit6$1 = 25;
+const Digit7$1 = 26;
+const Digit8$1 = 27;
+const Digit9$1 = 28;
+const KeyA$1 = 29;
+const KeyB$1 = 30;
+const KeyC$1 = 31;
+const KeyD$1 = 32;
+const KeyE$1 = 33;
+const KeyF$1 = 34;
+const KeyG$1 = 35;
+const KeyH$1 = 36;
+const KeyI$1 = 37;
+const KeyJ$1 = 38;
+const KeyK$1 = 39;
+const KeyL$1 = 40;
+const KeyM$1 = 41;
+const KeyN$1 = 42;
+const KeyO$1 = 43;
+const KeyP$1 = 44;
+const KeyQ$1 = 45;
+const KeyR$1 = 46;
+const KeyS$1 = 47;
+const KeyT$1 = 48;
+const KeyU$1 = 49;
+const KeyV$1 = 50;
+const KeyW$1 = 51;
+const KeyX$1 = 52;
+const KeyY$1 = 53;
+const KeyZ$1 = 54;
+const F1$1 = 57;
+const F2$1 = 58;
+const F3$1 = 59;
+const F4$1 = 60;
+const F5$1 = 61;
+const F6$1 = 62;
+const Equal$1 = 84;
+const Comma$1 = 85;
+const Minus$1 = 86;
+const Backquote$1 = 89;
+const Backslash$1 = 91;
+const Star$1 = 131;
+const Plus$1 = 132;
+
 const Unknown = 'Unknown';
 const Backspace = 'Backspace';
 const Tab = 'Tab';
@@ -2538,9 +3022,6 @@ const getKeyCodeString = keyCode => {
   }
 };
 
-const CtrlCmd = 1 << 11 >>> 0;
-const Shift = 1 << 10 >>> 0;
-
 const parseKey = rawKey => {
   number(rawKey);
   const isCtrl = Boolean(rawKey & CtrlCmd);
@@ -2554,16 +3035,20 @@ const parseKey = rawKey => {
   };
 };
 
+const classNameFocused = mergeClassNames(MenuItem$1, MenuItemFocused);
+const getMenuItemClassName = isFocused => {
+  if (isFocused) {
+    return classNameFocused;
+  }
+  return MenuItem$1;
+};
 const getMenuItemDefaultDom = menuItem => {
   const {
     label,
     isFocused,
     key
   } = menuItem;
-  let className = MenuItem$1;
-  if (isFocused) {
-    className += ' ' + MenuItemFocused;
-  }
+  const className = getMenuItemClassName(isFocused);
   const dom = [];
   dom.push({
     type: Div,
@@ -2783,7 +3268,7 @@ const render2 = async (uid, diffResult) => {
     oldState,
     newState
   } = get$1(uid);
-  set$1(uid, newState, newState);
+  set$3(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2828,10 +3313,6 @@ const saveState = uid => {
   };
 };
 
-const terminate = () => {
-  globalThis.close();
-};
-
 const create = (id, uri, x, y, width, height) => {
   const state = {
     uid: id,
@@ -2848,9 +3329,10 @@ const create = (id, uri, x, y, width, height) => {
     x,
     y,
     width,
-    height
+    height,
+    iconWidth: 30
   };
-  set$1(id, state, state);
+  set$3(id, state, state);
   return state;
 };
 
@@ -2965,10 +3447,7 @@ const handleFocusOut = async state => {
   return state;
 };
 
-/**
- * @param {boolean} focus
- */
-const openMenu = (state, focus) => {
+const openMenu = async (state, focus) => {
   const {
     focusedIndex
   } = state;
@@ -3326,7 +3805,7 @@ const handleMenuMouseOver = async (state, level, index) => {
   };
 };
 
-const toggleMenu = state => {
+const toggleMenu = async state => {
   const {
     isMenuOpen
   } = state;
@@ -3336,21 +3815,6 @@ const toggleMenu = state => {
   return openMenu(state, /* focus */false);
 };
 
-const wrapCommand = fn => {
-  const wrapped = async (uid, ...args) => {
-    const {
-      newState
-    } = get$1(uid);
-    const newerState = await fn(newState, ...args);
-    if (newState === newerState) {
-      return;
-    }
-    const latest = get$1(uid);
-    set$1(uid, latest.oldState, newerState);
-  };
-  return wrapped;
-};
-
 const commandMap = {
   'TitleBar.getButtonsVirtualDom': getTitleBarButtonsVirtualDom,
   'TitleBar.getIconVirtualDom': getTitleBarIconVirtualDom,
@@ -3370,11 +3834,11 @@ const commandMap = {
   'TitleBarMenuBar.focusNext': wrapCommand(focusNext),
   'TitleBarMenuBar.focusPrevious': wrapCommand(focusPrevious),
   'TitleBarMenuBar.getCommands': getCommandIds,
-  'TitleBarMenuBar.getKeyBindings': getKeyBindings,
+  'TitleBarMenuBar.getKeyBindings': getKeyBindings$1,
   'TitleBarMenuBar.getMenus': getMenus,
+  'TitleBarMenuBar.getTitleBarButtons': getTitleBarButtons,
   'TitleBarMenuBar.getVirtualDom': getTitleBarMenuBarVirtualDom,
   'TitleBarMenuBar.handleClick': wrapCommand(handleClick),
-  'TitleBarMenuBar.getTitleBarButtons': getTitleBarButtons,
   'TitleBarMenuBar.handleClickAt': wrapCommand(handleClickAt),
   'TitleBarMenuBar.handleFocus': wrapCommand(handleFocus),
   'TitleBarMenuBar.handleFocusOut': wrapCommand(handleFocusOut),