@lvce-editor/static-server 0.59.3 → 0.59.5

package/static/{22a0480 → 2c9ff1f}/packages/source-control-worker/dist/sourceControlWorkerMain.js

@@ -60,37 +60,45 @@ 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 = 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;
   }
 };
 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 string = value => {
   const type = getType(value);
-  if (type !== 'string') {
+  if (type !== String) {
     throw new AssertionError('expected value to be of type string');
   }
 };
@@ -344,22 +352,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
   });
@@ -438,7 +435,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   const {
     resolve,
     promise
-  } = withResolvers();
+  } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
     for (const event of Object.keys(eventMap)) {
@@ -534,11 +531,11 @@ const remove = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
@@ -616,6 +613,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);
 };
@@ -626,19 +634,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);
@@ -719,6 +724,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 {
@@ -731,7 +747,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,
@@ -739,20 +755,20 @@ 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) => {
+const create$6 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -761,14 +777,29 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$6(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 => {
@@ -823,7 +854,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;
@@ -854,13 +885,19 @@ const send = (transport, method, ...params) => {
   const message = create$4(method, params);
   transport.send(message);
 };
-const invoke$3 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
+const invokeAndTransfer$2 = (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);
@@ -871,7 +908,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);
 };
@@ -887,10 +924,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$3(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
+      return invokeAndTransfer$2(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -928,7 +965,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$2 = async ({
+const create$5 = async ({
   commandMap,
   messagePort
 }) => {
@@ -944,11 +981,25 @@ const create$2 = async ({
   messagePort.start();
   return rpc;
 };
-const PlainMessagePortRpcParent = {
+const create$3 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$2
+  create: create$3
 };
-const create$1 = async ({
+const create$2 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -960,11 +1011,485 @@ const create$1 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$1
+  create: create$2
+};
+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 None = 'none';
+const ToolBar = 'toolbar';
+const Tree = 'tree';
+const TreeItem$1 = 'treeitem';
+
+const Button$2 = 1;
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+const TextArea = 62;
+
+const TargetValue = 'event.target.value';
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const Button$1 = 'event.button';
+const DeltaMode = 'event.deltaMode';
+const DeltaY = 'event.deltaY';
+const TargetName = 'event.target.name';
+
+const User = 1;
+
+const DebugWorker = 55;
+const ExtensionHostWorker = 44;
+const RendererWorker$1 = 1;
+const SourceControlWorker = 66;
+
+const SetCss = 'Viewlet.setCss';
+const SetDom2 = 'Viewlet.setDom2';
+const SetValueByName = 'Viewlet.setValueByName';
+
+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();
+    }
+  };
+};
+
+const {
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$3,
+  dispose: dispose$1
+} = create$1(ExtensionHostWorker);
+const executeReferenceProvider = async (id, offset) => {
+  // @ts-ignore
+  return invoke$3('ExtensionHostReference.executeReferenceProvider', id, offset);
+};
+const executeFileReferenceProvider = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionHostReference.executeFileReferenceProvider', id);
+};
+const getRuntimeStatus = async extensionId => {
+  // @ts-ignore
+  return invoke$3('ExtensionHost.getRuntimeStatus', extensionId);
+};
+const registerMockRpc$1 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$3(mockRpc);
+  return mockRpc;
+};
+
+const ExtensionHost = {
+  __proto__: null,
+  dispose: dispose$1,
+  executeFileReferenceProvider,
+  executeReferenceProvider,
+  getRuntimeStatus,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
+  registerMockRpc: registerMockRpc$1,
+  set: set$3
 };
 
+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);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$2('ContextMenu.show', x, y, id, ...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 sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile$1 = 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$1 = 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$1 = 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 = async () => {
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$2('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$2('ClipBoard.writeText', /* text */text);
+};
+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$1 = 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 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$1 = 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);
+};
+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 registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$2(mockRpc);
+  return mockRpc;
+};
+
+const RendererWorker = {
+  __proto__: null,
+  activateByEvent: activateByEvent$1,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon: getFileIcon$1,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
+  invoke: invoke$2,
+  invokeAndTransfer,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri: openUri$1,
+  openUrl,
+  openWidget,
+  readFile: readFile$1,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$2,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
 const create = () => {
   const states = Object.create(null);
+  const commandMapRef = {};
   return {
     get(uid) {
       return states[uid];
@@ -1005,6 +1530,15 @@ const create = () => {
       };
       return wrapped;
     },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
     diff(uid, modules, numbers) {
       const {
         oldState,
@@ -1018,14 +1552,28 @@ const create = () => {
         }
       }
       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 {
-  get: get$2,
-  set: set$4,
-  wrapCommand
+  get: get$1,
+  set: set$1,
+  wrapCommand,
+  getCommandIds,
+  registerCommands,
+  wrapGetter
 } = create();
 
 const create2 = (id, uri, x, y, width, height, workspacePath) => {
@@ -1050,6 +1598,7 @@ const create2 = (id, uri, x, y, width, height, workspacePath) => {
     maxLineY: 0,
     merge: [],
     minimumSliderSize: 20,
+    inputBoxHeight: 30,
     minLineY: 0,
     providerId: '',
     root: '',
@@ -1062,20 +1611,40 @@ const create2 = (id, uri, x, y, width, height, workspacePath) => {
     workingTree: [],
     workspacePath,
     x,
-    y
+    y,
+    inputPlaceholder: '',
+    inputSource: 0,
+    maxInputLines: 5,
+    inputFontFamily: 'system-ui, Ubuntu, "Droid Sans", sans-serif',
+    inputFontSize: 13,
+    inputFontWeight: 400,
+    inputLetterSpacing: 0,
+    inputLineHeight: 20,
+    inputBoxMaxHeight: 214,
+    history: [],
+    viewMode: 1
   };
-  set$4(id, state, state);
+  set$1(id, state, state);
+};
+
+const isEqual$2 = (oldState, newState) => {
+  return oldState.inputBoxHeight === newState.inputBoxHeight;
 };
 
 const RenderItems = 4;
+const RenderValue = 8;
+const RenderCss = 10;
 
-const diffType = RenderItems;
-const isEqual = (oldState, newState) => {
+const isEqual$1 = (oldState, newState) => {
   return oldState.allGroups === newState.allGroups && oldState.visibleItems === newState.visibleItems && oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.deltaY === newState.deltaY;
 };
 
-const modules = [isEqual];
-const numbers = [diffType];
+const isEqual = (oldState, newState) => {
+  return newState.inputSource === User || oldState.inputValue === newState.inputValue;
+};
+
+const modules = [isEqual$1, isEqual, isEqual$2];
+const numbers = [RenderItems, RenderValue, RenderCss];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -1092,73 +1661,25 @@ const diff2 = uid => {
   const {
     oldState,
     newState
-  } = get$2(uid);
+  } = get$1(uid);
   const result = diff(oldState, newState);
   return result;
 };
 
-const commandIds = ['acceptInput', 'focus', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusNone', 'focusPrevious', 'refresh', 'handleClickSourceControlButtons', 'handleClick', 'handleClickAt', 'handleFocus', 'handleIconThemeChange', 'handleMouseOut', 'handleMouseOutAt', 'handleMouseOver', 'handleMouseOverAt', 'handleWheel', 'selectIndex'];
-
-const getCommandIds = () => {
-  return commandIds;
-};
-
-const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-const RendererWorker$1 = 1;
-const ExtensionHostWorker = 44;
-const invoke$2 = (method, ...params) => {
-  const rpc = get$1(RendererWorker$1);
-  // @ts-ignore
-  return rpc.invoke(method, ...params);
-};
-const invokeAndTransfer$2 = (method, ...params) => {
-  const rpc = get$1(RendererWorker$1);
-  // @ts-ignore
-  return rpc.invokeAndTransfer(method, ...params);
-};
-const set$2 = rpc => {
-  set$3(RendererWorker$1, rpc);
-};
-const RendererWorker = {
-  __proto__: null,
-  invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$2,
-  set: set$2
-};
-const invoke$1$1 = (method, ...params) => {
-  const rpc = get$1(ExtensionHostWorker);
-  // @ts-ignore
-  return rpc.invoke(method, ...params);
-};
-const set$1$1 = rpc => {
-  set$3(ExtensionHostWorker, rpc);
-};
-const ExtensionHost = {
-  __proto__: null,
-  invoke: invoke$1$1,
-  set: set$1$1
+const getInfo = uid => {
+  const {
+    newState
+  } = get$1(uid);
+  return newState.allGroups;
 };
 
-const {
-  invoke: invoke$1,
-  invokeAndTransfer,
-  set: set$1
-} = RendererWorker;
-
 const activateByEvent = event => {
-  return invoke$1('ExtensionHostManagement.activateByEvent', event);
+  return activateByEvent$1(event);
 };
 
 const {
-  invoke,
-  set
-} = ExtensionHost;
+  invoke: invoke$1,
+  set} = ExtensionHost;
 
 const executeProvider = async ({
   event,
@@ -1167,7 +1688,7 @@ const executeProvider = async ({
 }) => {
   await activateByEvent(event);
   // @ts-ignore
-  const result = await invoke(method, ...params);
+  const result = await invoke$1(method, ...params);
   return result;
 };
 
@@ -1292,8 +1813,11 @@ const getMissingIconRequests = (dirents, fileIconCache) => {
   return missingRequests;
 };
 
+const {
+  invoke} = RendererWorker;
+
 const requestFileIcons = async requests => {
-  const results = await invoke$1('IconTheme.getIcons', requests);
+  const results = await invoke('IconTheme.getIcons', requests);
   return results;
 };
 
@@ -1375,6 +1899,28 @@ const getGroups = async enabledProviderIds => {
   };
 };
 
+const getTextHeight = async (input, width, fontFamily, fontSize, fontWeight, letterSpacing, lineHeight) => {
+  try {
+    const actualInput = '\n' + input;
+    // TODO line height could also be like 1.5
+    const lineHeightPx = `${lineHeight}px`;
+    // @ts-ignore
+    const height = await invoke$2(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+    return height;
+  } catch {
+    // fallback
+    const lines = input.split('\n');
+    const lineCount = lines.length;
+    const inputHeight = lineCount * lineHeight;
+    return inputHeight;
+  }
+};
+
+const getInputHeight = async (input, width, fontFamily, fontWeight, fontSize, letterSpacing, lineHeight) => {
+  const height = await getTextHeight(input, width, fontFamily, fontSize, fontWeight, letterSpacing, lineHeight);
+  return height;
+};
+
 const getListHeight = (itemsLength, itemHeight, maxHeight) => {
   number(itemsLength);
   number(itemHeight);
@@ -1437,7 +1983,7 @@ const get = key => {
 };
 
 const getExtensions = async () => {
-  return invoke('Extensions.getExtensions');
+  return invoke$1('Extensions.getExtensions');
 };
 
 const requestSourceActions = async () => {
@@ -1463,6 +2009,19 @@ const restoreExpandedGroups = groups => {
   }, Object.create(null));
 };
 
+const getRestoredInputValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'inputValue' in savedState && typeof savedState['inputValue'] === 'string') {
+    return savedState.inputValue;
+  }
+  return '';
+};
+const restoreState = savedState => {
+  const inputValue = getRestoredInputValue(savedState);
+  return {
+    inputValue
+  };
+};
+
 const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
   if (size >= contentSize) {
     return 0;
@@ -1470,16 +2029,47 @@ const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
   return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
 };
 
-const loadContent = async state => {
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+const MessageEnterToCommitOnMaster = `Message (Enter) to commit on 'master'`;
+const SourceControlInput$1 = 'Source Control Input';
+
+const messageEnterToCommitOnMaster = () => {
+  return i18nString(MessageEnterToCommitOnMaster);
+};
+const sourceControlInput = () => {
+  return i18nString(SourceControlInput$1);
+};
+
+const loadContent = async (state, savedState) => {
   const {
     itemHeight,
     height,
     minimumSliderSize,
     workspacePath,
-    fileIconCache
+    fileIconCache,
+    width,
+    inputFontFamily,
+    inputFontSize,
+    inputFontWeight,
+    inputLetterSpacing,
+    inputLineHeight
   } = state;
   const root = workspacePath;
   const scheme = getProtocol(root);
+  const {
+    inputValue
+  } = restoreState(savedState);
   const enabledProviderIds = await getEnabledProviderIds(scheme, root);
   const {
     allGroups,
@@ -1499,20 +2089,25 @@ const loadContent = async state => {
   const newFileIconCache = await getFileIcons(displayItems, fileIconCache);
   const visibleItems = getVisibleSourceControlItems(displayItems, minLineY, maxLineY, actionsCache, newFileIconCache);
   const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, total);
+  const inputPlaceholder = messageEnterToCommitOnMaster();
+  const inputBoxHeight = await getInputHeight(inputValue, width, inputFontFamily, inputFontSize, inputFontWeight, inputLetterSpacing, inputLineHeight);
   return {
     ...state,
+    actionsCache,
     allGroups,
+    enabledProviderIds,
+    fileIconCache: newFileIconCache,
+    finalDeltaY,
     gitRoot,
+    inputBoxHeight,
+    inputPlaceholder,
+    inputValue,
     items: displayItems,
-    visibleItems,
-    enabledProviderIds,
-    root,
-    splitButtonEnabled,
     maxLineY,
+    root,
     scrollBarHeight,
-    finalDeltaY,
-    fileIconCache: newFileIconCache,
-    actionsCache
+    splitButtonEnabled,
+    visibleItems
   };
 };
 
@@ -1526,7 +2121,7 @@ const handleButtonClick = async (state, clickedIndex) => {
     return state;
   }
   await executeCommand(button.command, item.file);
-  const newState = await loadContent(state);
+  const newState = await loadContent(state, {});
   return newState;
 };
 
@@ -1542,6 +2137,7 @@ const getIndex = (state, eventX, eventY) => {
 };
 
 const warn = (...args) => {
+  // @ts-ignore
   console.warn(...args);
 };
 
@@ -1655,12 +2251,20 @@ const handleClickDirectoryExpanded = async (state, item) => {
 };
 
 const readFile = async (uri, encoding = 'utf8') => {
-  const content = await invoke$1('FileSystem.readFile', uri);
+  const content = await readFile$1(uri);
   return content;
 };
 
 const openUri = uri => {
-  return invoke$1('Main.openUri', uri);
+  return openUri$1(uri);
+};
+
+const openDiffEditor = async (before, afterPath, width) => {
+  // TODO handle error
+  // TODO should only pass uris to diff editor, diff editor should then resolve file contents
+  {
+    await openUri(`inline-diff://data://${before}<->${afterPath}`);
+  }
 };
 
 const handleClickFile = async (state, item) => {
@@ -1672,9 +2276,7 @@ const handleClickFile = async (state, item) => {
   const absolutePath = `${root}/${item.file}`;
   // TODO handle error
   const [fileBefore] = await Promise.all([getFileBefore(providerId, item.file), readFile(absolutePath)]);
-  {
-    await openUri(`inline-diff://data://${fileBefore}<->${absolutePath}`);
-  }
+  await openDiffEditor(fileBefore, absolutePath);
   return state;
 };
 
@@ -1694,7 +2296,7 @@ const selectIndex = async (state, index) => {
     case File:
       return handleClickFile(state, item);
     default:
-      console.warn(`unknown item type: ${item.type}`);
+      warn(`unknown item type: ${item.type}`);
       return state;
   }
 };
@@ -1708,7 +2310,7 @@ const handleClickAt = async (state, eventX, eventY, name) => {
 };
 
 const show = async (x, y, id, ...args) => {
-  return invoke$1('ContextMenu.show', x, y, id, ...args);
+  return showContextMenu(x, y, id, ...args);
 };
 
 const SourceControl$1 = 22;
@@ -1722,6 +2324,24 @@ const handleFocus = async state => {
   return state;
 };
 
+const handleInput = async (state, value, inputSource = User) => {
+  const {
+    width,
+    inputFontFamily,
+    inputFontSize,
+    inputFontWeight,
+    inputLetterSpacing,
+    inputLineHeight
+  } = state;
+  const inputBoxHeight = await getInputHeight(value, width, inputFontFamily, inputFontWeight, inputFontSize, inputLetterSpacing, inputLineHeight);
+  return {
+    ...state,
+    inputValue: value,
+    inputSource,
+    inputBoxHeight
+  };
+};
+
 const handleMouseOut = (state, index) => {
   const {
     items
@@ -1786,34 +2406,15 @@ const handleWheel = async (state, deltaMode, deltaY) => {
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-const SourceControlWorker = 66;
-
 const sendMessagePortToExtensionHostWorker = async port => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, SourceControlWorker);
+  await sendMessagePortToExtensionHostWorker$1(port, SourceControlWorker);
 };
 
 const createExtensionHostRpc = async () => {
   try {
-    const {
-      port1,
-      port2
-    } = getPortTuple();
-    await sendMessagePortToExtensionHostWorker(port2);
-    const rpc = await PlainMessagePortRpcParent.create({
+    const rpc = await TransferMessagePortRpcParent.create({
       commandMap: {},
-      messagePort: port1
+      send: sendMessagePortToExtensionHostWorker
     });
     return rpc;
   } catch (error) {
@@ -1826,6 +2427,30 @@ const initialize = async () => {
   set(extensionHostRpc);
 };
 
+const renderCss = (oldState, newState) => {
+  const {
+    id,
+    inputBoxHeight
+  } = newState;
+  const css = `:root {
+  --SourceControlInputHeight: ${inputBoxHeight}px;
+}
+`;
+  return [SetCss, id, css];
+};
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
 const Actions = 'Actions';
 const SourceControlButtons = 'SourceControlButtons';
 const Grow = 'Grow';
@@ -1852,84 +2477,43 @@ const SplitButtonDropDown = 'SplitButtonDropDown';
 const SplitButtonDropDownDisabled = 'SplitButtonDropDownDisabled';
 const SplitButtonSeparator = 'SplitButtonSeparator';
 const StrikeThrough = 'StrikeThrough';
-const TreeItem$1 = 'TreeItem';
+const TreeItem = 'TreeItem';
 const Viewlet = 'Viewlet';
 
-const HandleClickAt = 'handleClickAt';
-const HandleContextMenu = 'handleContextMenu';
-const HandleFocus = 'handleFocus';
-const HandleInput = 'handleInput';
-const HandleMouseOut = 'handleMouseOut';
-const HandleMouseOutAt = 'handleMouseOutAt';
-const HandleMouseOver = 'handleMouseOver';
-const HandleMouseOverAt = 'handleMouseOverAt';
-const HandleWheel = 'handleWheel';
-
-const SourceControlInput$1 = 'SourceControlInput';
-
-const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
-const i18nString = (key, placeholders = emptyObject) => {
-  if (placeholders === emptyObject) {
-    return key;
-  }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
-};
+const HandleClickAt = 1;
+const HandleContextMenu = 2;
+const HandleFocus = 3;
+const HandleInput = 4;
+const HandleMouseOut = 5;
+const HandleMouseOutAt = 6;
+const HandleMouseOver = 7;
+const HandleMouseOverAt = 8;
+const HandleWheel = 9;
 
-const MessageEnterToCommitOnMaster = `Message (Enter) to commit on 'master'`;
-const SourceControlInput = 'Source Control Input';
+const SourceControlInput = 'SourceControlInput';
 
-const messageEnterToCommitOnMaster = () => {
-  return i18nString(MessageEnterToCommitOnMaster);
-};
-const sourceControlInput = () => {
-  return i18nString(SourceControlInput);
-};
-
-const Button$1 = 1;
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Img = 17;
-
-const getSourceControlHeaderVirtualDom = () => {
+const getSourceControlInputDom = inputPlaceholder => {
   return [{
-    type: Div,
-    className: SourceControlHeader,
-    childCount: 1
-  }, {
-    type: Input,
-    className: InputBox,
+    type: TextArea,
+    className: mergeClassNames(InputBox, 'MultilineInputBox'),
     ariaLabel: sourceControlInput(),
     autocapitalize: 'off',
     autocorrect: 'off',
     childCount: 0,
-    name: SourceControlInput$1,
+    name: SourceControlInput,
     onFocus: HandleFocus,
     onInput: HandleInput,
-    placeholder: messageEnterToCommitOnMaster(),
+    placeholder: inputPlaceholder,
     spellcheck: false
   }];
 };
 
-const None = 'none';
-const ToolBar = 'toolbar';
-const Tree = 'tree';
-const TreeItem = 'treeitem';
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-const Text = 12;
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
+const getSourceControlHeaderVirtualDom = inputPlaceholder => {
+  return [{
+    type: Div,
+    className: SourceControlHeader,
+    childCount: 1
+  }, ...getSourceControlInputDom(inputPlaceholder)];
 };
 
 const getBadgeVirtualDom = (className, count) => {
@@ -1955,7 +2539,7 @@ const getButtonVirtualDom = button => {
     label
   } = button;
   return [{
-    type: Button$1,
+    type: Button$2,
     className: SourceControlButton,
     title: label,
     ariaLabel: label,
@@ -1975,12 +2559,13 @@ const getButtonsVirtualDom = buttons => {
   }, ...buttons.flatMap(getButtonVirtualDom)];
 };
 
+const classNameDefault = mergeClassNames(Label, Grow);
+const classNameStrikeThrough = mergeClassNames(classNameDefault, StrikeThrough);
 const getLabelClassName = decorationStrikeThrough => {
-  let className = mergeClassNames(Label, Grow);
   if (decorationStrikeThrough) {
-    className = mergeClassNames(className, StrikeThrough);
+    return classNameStrikeThrough;
   }
-  return className;
+  return classNameDefault;
 };
 
 const PaddingLeft = '1rem';
@@ -2002,13 +2587,14 @@ const createItemDirectory = item => {
   const hasButtons = buttons.length;
   return [{
     type: Div,
-    className: TreeItem$1,
-    role: TreeItem,
+    className: TreeItem,
+    role: TreeItem$1,
     ariaExpanded: type === DirectoryExpanded,
     ariaPosInSet: posInSet,
     ariaSetSize: setSize,
     childCount: 3 + (hasButtons ? 1 : 0),
     paddingLeft: PaddingLeft,
+    // TODO classname for indent / padding
     paddingRight: PaddingRight
   }, {
     type: Div,
@@ -2062,8 +2648,8 @@ const createItemOther = item => {
   const buttonsDom = getButtonsVirtualDom(buttons);
   dom.push({
     type: Div,
-    className: TreeItem$1,
-    role: TreeItem,
+    className: TreeItem,
+    role: TreeItem$1,
     ariaPosInSet: posInSet,
     ariaSetSize: setSize,
     title: file,
@@ -2124,11 +2710,11 @@ const getSplitButtonVirtualDom = (hasItems, splitButtonEnabled, buttonText) => {
   }
   return [{
     type: Div,
-    className: `${SplitButton} ${hasItems ? '' : SplitButtonDisabled}`,
+    className: mergeClassNames(SplitButton, hasItems ? '' : SplitButtonDisabled),
     childCount: 3
   }, {
     type: Div,
-    className: `${SplitButtonContent} ${hasItems ? '' : SplitButtonContentDisabled}`,
+    className: mergeClassNames(SplitButtonContent, hasItems ? '' : SplitButtonContentDisabled),
     childCount: 1,
     tabIndex: 0
   }, text(buttonText), {
@@ -2137,17 +2723,17 @@ const getSplitButtonVirtualDom = (hasItems, splitButtonEnabled, buttonText) => {
     childCount: 0
   }, {
     type: Div,
-    className: `${SplitButtonDropDown} ${hasItems ? '' : SplitButtonDropDownDisabled}`,
+    className: mergeClassNames(SplitButtonDropDown, hasItems ? '' : SplitButtonDropDownDisabled),
     childCount: 1,
     tabIndex: 0
   }, {
     type: Div,
-    className: `${MaskIcon} ${MaskIconChevronDown}`,
+    className: mergeClassNames(MaskIcon, MaskIconChevronDown),
     childCount: 0
   }];
 };
 
-const getSourceControlVirtualDom = (items, splitButtonEnabled) => {
+const getSourceControlVirtualDom = (items, splitButtonEnabled, inputPlaceholder) => {
   const hasItems = items.length > 0;
   const dom = [{
     type: Div,
@@ -2158,20 +2744,37 @@ const getSourceControlVirtualDom = (items, splitButtonEnabled) => {
     onMouseOut: HandleMouseOut,
     onWheel: HandleWheel,
     childCount: splitButtonEnabled ? 3 : 2
-  }, ...getSourceControlHeaderVirtualDom(), ...getSplitButtonVirtualDom(hasItems, splitButtonEnabled, 'Commit'), ...getSourceControlListVirtualDom(items)];
+  }, ...getSourceControlHeaderVirtualDom(inputPlaceholder), ...getSplitButtonVirtualDom(hasItems, splitButtonEnabled, 'Commit'), ...getSourceControlListVirtualDom(items)];
   return dom;
 };
 
 const renderItems = (oldState, newState) => {
-  const visible = newState.visibleItems;
-  const dom = getSourceControlVirtualDom(visible, newState.splitButtonEnabled);
-  return ['Viewlet.setDom2', dom];
+  const {
+    visibleItems,
+    splitButtonEnabled,
+    inputPlaceholder,
+    id
+  } = newState;
+  const dom = getSourceControlVirtualDom(visibleItems, splitButtonEnabled, inputPlaceholder);
+  return [SetDom2, id, dom];
+};
+
+const renderValue = (oldState, newState) => {
+  const {
+    id,
+    inputValue
+  } = newState;
+  return [SetValueByName, id, SourceControlInput, inputValue];
 };
 
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderItems:
       return renderItems;
+    case RenderValue:
+      return renderValue;
+    case RenderCss:
+      return renderCss;
     default:
       throw new Error('unknown renderer');
   }
@@ -2193,8 +2796,8 @@ const render2 = (uid, diffResult) => {
   const {
     oldState,
     newState
-  } = get$2(uid);
-  set$4(uid, newState, newState);
+  } = get$1(uid);
+  set$1(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2208,7 +2811,7 @@ const getActionButtonVirtualDom = action => {
     command
   } = action;
   return [{
-    type: Button$1,
+    type: Button$2,
     className: IconButton,
     title: id,
     'data-command': command,
@@ -2234,7 +2837,7 @@ const getActionsVirtualDom = actions => {
   }, ...actions.flatMap(getActionVirtualDom)];
 };
 
-const renderActions = uid => {
+const renderActions = state => {
   const actions = [];
   const dom = getActionsVirtualDom(actions);
   return dom;
@@ -2243,61 +2846,59 @@ const renderActions = uid => {
 const renderEventListeners = () => {
   return [{
     name: HandleWheel,
-    params: ['handleWheel', 'event.deltaMode', 'event.deltaY'],
+    params: ['handleWheel', DeltaMode, DeltaY],
     passive: true
   }, {
     name: HandleFocus,
     params: ['handleFocus']
   }, {
     name: HandleClickAt,
-    params: ['handleClickAt', 'event.clientX', 'event.clientY', 'event.target.name']
+    params: ['handleClickAt', ClientX, ClientY, TargetName]
   }, {
     name: HandleMouseOverAt,
-    params: ['handleMouseOverAt', 'event.clientX', 'event.clientY']
+    params: ['handleMouseOverAt', ClientX, ClientY]
   }, {
     name: HandleMouseOver,
-    params: ['handleMouseOver', 'event.clientX', 'event.clientY']
+    params: ['handleMouseOver', ClientX, ClientY]
   }, {
     name: HandleMouseOutAt,
-    params: ['handleMouseOutAt', 'event.clientX', 'event.clientY']
+    params: ['handleMouseOutAt', ClientX, ClientY]
   }, {
     name: HandleInput,
-    params: ['handleInput', 'event.target.value']
+    params: ['handleInput', TargetValue]
   }, {
     name: HandleContextMenu,
-    params: ['handleContextMenu', 'event.button', 'event.clientX', 'event.clientY'],
+    params: ['handleContextMenu', Button$1, ClientX, ClientY],
     preventDefault: true
   }, {
     name: HandleWheel,
-    params: ['handleWheel', 'event.deltaMode', 'event.deltaY'],
+    params: ['handleWheel', DeltaMode, DeltaY],
     passive: true
   }];
 };
 
 const saveState = uid => {
   number(uid);
-  const value = get$2(uid);
+  const value = get$1(uid);
   const {
     newState
   } = value;
   const {
     root,
     maxLineY,
-    expandedGroups
+    expandedGroups,
+    inputValue
   } = newState;
   return {
     root,
     minLineY: 0,
     maxLineY,
     deltaY: 0,
-    expandedGroups
+    expandedGroups,
+    inputValue
   };
 };
 
-const terminate = () => {
-  globalThis.close();
-};
-
 const updateIcons = async state => {
   const {
     items,
@@ -2313,16 +2914,32 @@ const updateIcons = async state => {
   };
 };
 
+const viewAsList = state => {
+  return {
+    ...state,
+    viewMode: 1
+  };
+};
+
+const viewAsTree = state => {
+  return {
+    ...state,
+    viewMode: 2
+  };
+};
+
 const commandMap = {
   'Initialize.initialize': initialize,
   'SourceControl.create2': create2,
   'SourceControl.diff2': diff2,
   'SourceControl.getCommandIds': getCommandIds,
+  'SourceControl.getInfo': getInfo,
   'SourceControl.handleButtonClick': wrapCommand(handleButtonClick),
   'SourceControl.handleClickAt': wrapCommand(handleClickAt),
   'SourceControl.handleClickSourceControlButtons': wrapCommand(handleClickSourceControlButtons),
   'SourceControl.handleContextMenu': wrapCommand(handleContextMenu),
   'SourceControl.handleFocus': wrapCommand(handleFocus),
+  'SourceControl.handleInput': wrapCommand(handleInput),
   'SourceControl.handleMouseOut': wrapCommand(handleMouseOut),
   'SourceControl.handleMouseOutAt': wrapCommand(handleMouseOutAt),
   'SourceControl.handleMouseOver': wrapCommand(handleMouseOver),
@@ -2331,20 +2948,24 @@ const commandMap = {
   'SourceControl.loadContent': wrapCommand(loadContent),
   'SourceControl.refresh': wrapCommand(refresh),
   'SourceControl.render2': render2,
+  'SourceControl.renderActions': wrapGetter(renderActions),
   'SourceControl.renderActions2': renderActions,
   'SourceControl.renderEventListeners': renderEventListeners,
   'SourceControl.saveState': saveState,
   'SourceControl.selectIndex': wrapCommand(selectIndex),
   'SourceControl.setDeltaY': wrapCommand(setDeltaY),
   'SourceControl.terminate': terminate,
-  'SourceControl.updateIcons': wrapCommand(updateIcons)
+  'SourceControl.updateIcons': wrapCommand(updateIcons),
+  'SourceControl.viewAsList': wrapCommand(viewAsList),
+  'SourceControl.viewAsTree': wrapCommand(viewAsTree)
 };
 
 const listen = async () => {
+  registerCommands(commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const main = async () => {