@lvce-editor/output-view 2.0.0 → 2.2.0

package/dist/outputViewWorkerMain.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);
@@ -450,9 +450,9 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+const create$5 = async ({
+  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');
@@ -501,61 +501,19 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5$1,
+  create: create$5,
   signal: signal$1,
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$8 = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$2 = id => {
   return callbacks[id];
 };
 const remove$1 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$8(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);
@@ -749,9 +707,9 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (id, error) => {
+const create$1$2 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -760,22 +718,22 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
+  return create$1$2(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$3 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$3(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -862,29 +820,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$5 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$3 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -907,24 +842,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 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(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$5(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$3(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -941,7 +939,7 @@ 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) {
@@ -959,15 +957,16 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
+const create$4 = 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 +974,9 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3 = async ({
+const create$2$1 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -984,16 +984,17 @@ const create$3 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$4({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3
+  create: create$2$1
 };
-const create$4 = async ({
+const create$1$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1005,7 +1006,7 @@ const create$4 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$1$1
 };
 const createMockRpc = ({
   commandMap
@@ -1020,98 +1021,13 @@ const createMockRpc = ({
     return command(...params);
   };
   const mockRpc = {
+    invocations,
     invoke,
-    invokeAndTransfer: invoke,
-    invocations
+    invokeAndTransfer: invoke
   };
   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 {
-          oldState,
-          newState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (oldState === newerState || 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 ToolBar = 'toolbar';
 
 const Button = 1;
@@ -1132,24 +1048,25 @@ const UpArrow = 14;
 const RightArrow = 15;
 const DownArrow = 16;
 
-const Script$1 = 2;
-
-const DebugWorker = 55;
 const ExtensionHostWorker = 44;
 const FileSystemWorker$1 = 209;
 const OutputWorker = 7001;
-const RendererWorker$1 = 1;
+const RendererWorker = 1;
 
 const rpcs = Object.create(null);
-const set$7 = (id, rpc) => {
+const set$6 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-const create$1 = rpcId => {
+const create$2 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -1163,436 +1080,105 @@ const create$1 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$7(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
+      set$6(rpcId, rpc);
     }
   };
 };
 
 const {
-  invoke: invoke$4,
+  dispose: dispose$1,
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$2,
-  set: set$6,
-  dispose: dispose$2
-} = create$1(ExtensionHostWorker);
+  set: set$5
+} = create$2(ExtensionHostWorker);
 const executeReferenceProvider = async (id, offset) => {
   // @ts-ignore
-  return invoke$4('ExtensionHostReference.executeReferenceProvider', id, offset);
+  return invoke$3('ExtensionHostReference.executeReferenceProvider', id, offset);
 };
 const executeFileReferenceProvider = async id => {
   // @ts-ignore
-  return invoke$4('ExtensionHostReference.executeFileReferenceProvider', id);
+  return invoke$3('ExtensionHostReference.executeFileReferenceProvider', id);
 };
 const getRuntimeStatus = async extensionId => {
   // @ts-ignore
-  return invoke$4('ExtensionHost.getRuntimeStatus', extensionId);
+  return invoke$3('ExtensionHost.getRuntimeStatus', extensionId);
 };
-const registerMockRpc$2 = commandMap => {
+const registerMockRpc$1 = commandMap => {
   const mockRpc = createMockRpc({
     commandMap
   });
-  set$6(mockRpc);
+  set$5(mockRpc);
   return mockRpc;
 };
 
 const ExtensionHost = {
   __proto__: null,
-  dispose: dispose$2,
+  dispose: dispose$1,
   executeFileReferenceProvider,
   executeReferenceProvider,
   getRuntimeStatus,
-  invoke: invoke$4,
-  invokeAndTransfer: invokeAndTransfer$2,
-  registerMockRpc: registerMockRpc$2,
-  set: set$6
-};
-
-const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$1,
-  set: set$5,
-  dispose: dispose$1
-} = create$1(FileSystemWorker$1);
-const remove = async dirent => {
-  return invoke$3('FileSystem.remove', dirent);
-};
-const readDirWithFileTypes = async uri => {
-  return invoke$3('FileSystem.readDirWithFileTypes', uri);
-};
-const getPathSeparator = async root => {
-  // @ts-ignore
-  return invoke$3('FileSystem.getPathSeparator', root);
-};
-const getRealPath = async path => {
-  return invoke$3('FileSystem.getRealPath', path);
-};
-const stat = async dirent => {
-  return invoke$3('FileSystem.stat', dirent);
-};
-const createFile = async uri => {
-  return invoke$3('FileSystem.writeFile', uri, '');
-};
-const readFile$2 = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
-};
-const writeFile$1 = async (uri, content) => {
-  return invoke$3('FileSystem.writeFile', uri, content);
-};
-const mkdir = async uri => {
-  return invoke$3('FileSystem.mkdir', uri);
-};
-const rename = async (oldUri, newUri) => {
-  return invoke$3('FileSystem.rename', oldUri, newUri);
-};
-const copy = async (oldUri, newUri) => {
-  return invoke$3('FileSystem.copy', oldUri, newUri);
-};
-const exists = async uri => {
-  // @ts-ignore
-  return invoke$3('FileSystem.exists', uri);
-};
-const getFolderSize$1 = async uri => {
-  // @ts-ignore
-  return invoke$3('FileSystem.getFolderSize', uri);
-};
-const readFileAsBlob = async uri => {
-  // @ts-ignore
-  return invoke$3('FileSystem.readFileAsBlob', uri);
-};
-const appendFile = async (uri, text) => {
-  // @ts-ignore
-  return invoke$3('FileSystem.appendFile', uri, text);
-};
-const registerMockRpc$1 = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$5(mockRpc);
-  return mockRpc;
-};
-
-const FileSystemWorker = {
-  __proto__: null,
-  appendFile,
-  copy,
-  createFile,
-  dispose: dispose$1,
-  exists,
-  getFolderSize: getFolderSize$1,
-  getPathSeparator,
-  getRealPath,
   invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$1,
-  mkdir,
-  readDirWithFileTypes,
-  readFile: readFile$2,
-  readFileAsBlob,
+  invokeAndTransfer: invokeAndTransfer$2,
   registerMockRpc: registerMockRpc$1,
-  remove,
-  rename,
-  set: set$5,
-  stat,
-  writeFile: writeFile$1
+  set: set$5
 };
 
 const {
-  invoke: invoke$2,
-  invokeAndTransfer,
-  set: set$4,
-  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$2 = 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 = 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 handleWorkspaceRefresh = async () => {
-  return invoke$2('Layout.handleWorkspaceRefresh');
-};
-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$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$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 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');
+  dispose,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$4
+} = create$2(FileSystemWorker$1);
+const remove = async dirent => {
+  return invoke$2('FileSystem.remove', dirent);
 };
-const showErrorDialog = async errorInfo => {
-  // @ts-ignore
-  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
+const readDirWithFileTypes = async uri => {
+  return invoke$2('FileSystem.readDirWithFileTypes', uri);
 };
-const getFolderSize = async uri => {
-  // @ts-ignore
-  return await invoke$2('FileSystem.getFolderSize', uri);
+const getPathSeparator = async root => {
+  return invoke$2('FileSystem.getPathSeparator', root);
 };
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.getExtension', id);
+const getRealPath = async path => {
+  return invoke$2('FileSystem.getRealPath', path);
 };
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke$2('Markdown.getVirtualDom', html);
+const stat = async dirent => {
+  return invoke$2('FileSystem.stat', dirent);
 };
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke$2('Markdown.renderMarkdown', markdown, options);
+const createFile = async uri => {
+  return invoke$2('FileSystem.writeFile', uri, '');
 };
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
+const readFile$1 = async uri => {
+  return invoke$2('FileSystem.readFile', uri);
 };
-const uninstallExtension = async id => {
-  return invoke$2('ExtensionManagement.uninstall', id);
+const writeFile$1 = async (uri, content) => {
+  return invoke$2('FileSystem.writeFile', uri, content);
 };
-const installExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.install', id);
+const mkdir = async uri => {
+  return invoke$2('FileSystem.mkdir', uri);
 };
-const openExtensionSearch = async () => {
-  // @ts-ignore
-  return invoke$2('SideBar.openViewlet', 'Extensions');
+const rename = async (oldUri, newUri) => {
+  return invoke$2('FileSystem.rename', oldUri, newUri);
 };
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke$2('Extensions.handleInput', searchValue, Script$1);
+const copy = async (oldUri, newUri) => {
+  return invoke$2('FileSystem.copy', oldUri, newUri);
 };
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openExternal', uri);
+const exists = async uri => {
+  return invoke$2('FileSystem.exists', uri);
 };
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openUrl', uri);
+const getFolderSize = async uri => {
+  return invoke$2('FileSystem.getFolderSize', uri);
 };
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke$2('Preferences.getAll');
+const readFileAsBlob = async uri => {
+  return invoke$2('FileSystem.readFileAsBlob', uri);
 };
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$2('FilePicker.showSaveFilePicker');
+const appendFile = async (uri, text) => {
+  return invoke$2('FileSystem.appendFile', uri, text);
 };
-const getLogsDir$1 = async () => {
-  // @ts-ignore
-  return invoke$2('PlatformPaths.getLogsDir');
+const watchFile = async (watchId, uri, rpcId) => {
+  await invoke$2('FileSystem.watchFile', watchId, uri, rpcId);
 };
-const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
-  return invoke$2(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+const unwatchFile = async watchId => {
+  await invoke$2('FileSystem.unwatchFile', watchId);
 };
 const registerMockRpc = commandMap => {
   const mockRpc = createMockRpc({
@@ -1602,96 +1188,146 @@ const registerMockRpc = commandMap => {
   return mockRpc;
 };
 
-const RendererWorker = {
+const FileSystemWorker = {
   __proto__: null,
-  activateByEvent: activateByEvent$1,
-  applyBulkReplacement,
-  closeWidget,
-  confirm,
-  disableExtension,
+  appendFile,
+  copy,
+  createFile,
   dispose,
-  enableExtension,
-  getActiveEditorId,
-  getAllExtensions,
-  getAllPreferences,
-  getBlob,
-  getChromeVersion,
-  getColorThemeNames,
-  getElectronVersion,
-  getExtension,
-  getExtensionCommands,
-  getFileHandles,
-  getFileIcon,
-  getFilePathElectron,
-  getFolderIcon,
+  exists,
   getFolderSize,
-  getIcons,
-  getKeyBindings: getKeyBindings$1,
-  getLogsDir: getLogsDir$1,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened,
-  getV8Version,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  handleWorkspaceRefresh,
-  installExtension,
+  getPathSeparator,
+  getRealPath,
   invoke: invoke$2,
-  invokeAndTransfer,
-  measureTextBlockHeight,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri,
-  openUrl,
-  openWidget,
-  readClipBoardText,
+  invokeAndTransfer: invokeAndTransfer$1,
+  mkdir,
+  readDirWithFileTypes,
   readFile: readFile$1,
+  readFileAsBlob,
   registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$2,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSourceControlWorker,
-  sendMessagePortToSyntaxHighlightingWorker,
-  sendMessagePortToTextMeasurementWorker,
+  remove,
+  rename,
   set: set$4,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
-  showContextMenu2,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText
+  stat,
+  unwatchFile,
+  watchFile,
+  writeFile: writeFile$1
+};
+
+const {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$3
+} = create$2(RendererWorker);
+const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const activateByEvent = (event, assetDir, platform) => {
+  return invoke$1('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$1('FilePicker.showSaveFilePicker');
+};
+const getLogsDir$1 = async () => {
+  // @ts-ignore
+  return invoke$1('PlatformPaths.getLogsDir');
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$1 = () => {
+  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 {
+          oldState,
+          newState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || 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 {
-  set: set$3,
   readFile,
+  set: set$2,
   writeFile
 } = FileSystemWorker;
 
@@ -1764,31 +1400,31 @@ const loadLines = async uri => {
     const content = await readFile(uri);
     const lines = content.split('\n').map(parseLine);
     return {
+      code: 0,
       error: '',
-      lines,
-      code: 0
+      lines
     };
   } catch (error) {
     if (isFileNotFoundError(error)) {
       return {
+        code: 1,
         error: `log file not found`,
-        lines: [],
-        code: 1
+        lines: []
       };
     }
     return {
+      code: 2,
       error: `${error}`,
-      lines: [],
-      code: 2
+      lines: []
     };
   }
 };
 
 const clear = async state => {
   const {
-    selectedOption,
+    filterValue,
     options,
-    filterValue
+    selectedOption
   } = state;
   // TODO make uri a property of state to make the code simpler
   const option = options.find(option => option.id === selectedOption);
@@ -1800,17 +1436,17 @@ const clear = async state => {
   } = option;
   await writeFile(uri, '');
   const {
-    lines,
     code,
-    error
+    error,
+    lines
   } = await loadLines(uri);
   const filteredItems = filterItems(lines, filterValue);
   return {
     ...state,
-    listItems: lines,
     error,
     errorCode: code,
-    filteredItems
+    filteredItems,
+    listItems: lines
   };
 };
 
@@ -1826,12 +1462,13 @@ const Script = 2;
 
 const {
   get,
-  set: set$2,
-  wrapCommand,
-  wrapGetter,
-  getKeys,
   getCommandIds,
-  registerCommands} = create$2();
+  getKeys,
+  registerCommands,
+  set: set$1,
+  wrapCommand,
+  wrapGetter
+} = create$1();
 
 const create = (id, uri, x, y, width, height, platform, parentId) => {
   number(parentId);
@@ -1865,7 +1502,7 @@ const create = (id, uri, x, y, width, height, platform, parentId) => {
     x,
     y
   };
-  set$2(id, state, state);
+  set$1(id, state, state);
 };
 
 const isEqual$2 = (oldState, newState) => {
@@ -1900,8 +1537,8 @@ const diff = (oldState, newState) => {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
@@ -1946,9 +1583,9 @@ const mergeClassNames = (...classNames) => {
 
 const text = data => {
   return {
-    type: Text$1,
+    childCount: 0,
     text: data,
-    childCount: 0
+    type: Text$1
   };
 };
 
@@ -1956,53 +1593,53 @@ const FocusProblems = 19;
 
 const getKeyBindings = () => {
   return [{
-    key: DownArrow,
     command: 'Problems.focusNext',
+    key: DownArrow,
     when: FocusProblems
   }, {
-    key: UpArrow,
     command: 'Problems.focusPrevious',
+    key: UpArrow,
     when: FocusProblems
   }, {
-    key: Home,
     command: 'Problems.focusFirst',
+    key: Home,
     when: FocusProblems
   }, {
-    key: PageUp,
     command: 'Problems.focusFirst',
+    key: PageUp,
     when: FocusProblems
   }, {
-    key: PageDown,
     command: 'Problems.focusLast',
+    key: PageDown,
     when: FocusProblems
   }, {
-    key: End,
     command: 'Problems.focusLast',
+    key: End,
     when: FocusProblems
   }, {
-    key: Space,
     command: 'Problems.selectCurrent',
+    key: Space,
     when: FocusProblems
   }, {
-    key: Home,
     command: 'Problems.focusFirst',
+    key: Home,
     when: FocusProblems
   }, {
-    key: End,
     command: 'Problems.focusLast',
+    key: End,
     when: FocusProblems
   }, {
-    key: LeftArrow,
     command: 'Problems.handleArrowLeft',
+    key: LeftArrow,
     when: FocusProblems
   }, {
-    key: RightArrow,
     command: 'Problems.handleArrowRight',
+    key: RightArrow,
     when: FocusProblems
   }];
 };
 
-const Filter$1 = 'filter';
+const Filter$2 = 'filter';
 const Output$1 = 'output';
 const MainProcess = 'MainProcess';
 const SharedProcess = 'SharedProcess';
@@ -2053,8 +1690,8 @@ const handleFilterInput = async (state, value, inputSource = User) => {
   const filteredItems = filterItems(listItems, value);
   return {
     ...state,
-    filterValue: value,
     filteredItems: filteredItems,
+    filterValue: value,
     inputSource
   };
 };
@@ -2064,14 +1701,6 @@ const createWatchId = () => {
   return watchId;
 };
 
-const {
-  invoke: invoke$1,
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$1,
-  set: set$1,
-  activateByEvent
-} = RendererWorker;
-
 const handleFileChange = async watchId => {
   const keys = getKeys();
   for (const key of keys) {
@@ -2098,14 +1727,12 @@ const setupChangeListener = async (oldWatchId, newWatchId, uri) => {
   try {
     if (oldWatchId) {
       unregisterWatchCallback(oldWatchId);
-      // @ts-ignore
-      await invoke$3('FileSystem.unwatchFile', oldWatchId);
+      await unwatchFile(oldWatchId);
     }
     // TODO dispose old watcher
     const rpcId = OutputWorker;
     registerWatchCallback(newWatchId, handleFileChange);
-    // @ts-ignore
-    await invoke$3('FileSystem.watchFile', newWatchId, /* path */uri, rpcId);
+    await watchFile(newWatchId, uri, rpcId);
   } catch {
     // ignore
   }
@@ -2113,8 +1740,8 @@ const setupChangeListener = async (oldWatchId, newWatchId, uri) => {
 
 const selectChannel = async (state, id) => {
   const {
-    options,
     filterValue,
+    options,
     watchId
   } = state;
   const matchingOption = options.find(option => option.id === id);
@@ -2123,9 +1750,9 @@ const selectChannel = async (state, id) => {
   }
   // TODO potential race condtion when switching output channels fast
   const {
-    lines,
+    code,
     error,
-    code
+    lines
   } = await loadLines(matchingOption.uri);
 
   // TODO memory leak and race condition, need to dispose file watcher of previous uri
@@ -2136,8 +1763,8 @@ const selectChannel = async (state, id) => {
     ...state,
     error,
     errorCode: code,
-    listItems: lines,
     filteredItems,
+    listItems: lines,
     selectedOption: id,
     watchId: newWatchId
   };
@@ -2164,8 +1791,8 @@ const createExtensionHostRpc = async () => {
 };
 
 const {
-  set,
-  invoke
+  invoke,
+  set
 } = ExtensionHost;
 
 const initializeExtensionHost = async () => {
@@ -2191,7 +1818,7 @@ const createFileSystemWorkerRpc = async () => {
 
 const initializeFileSystemWorker = async () => {
   const rpc = await createFileSystemWorkerRpc();
-  set$3(rpc);
+  set$2(rpc);
 };
 
 const initialize = async () => {
@@ -2200,8 +1827,7 @@ const initialize = async () => {
 
 const getLogsDir = async () => {
   try {
-    // @ts-ignore
-    return await invoke$1('PlatformPaths.getLogsDir');
+    return await getLogsDir$1();
   } catch {
     return `file:///tmp`;
   }
@@ -2232,6 +1858,7 @@ const i18nString = (key, placeholders = emptyObject) => {
 };
 
 const ClearOutput = 'clear output';
+const Filter$1 = 'Filter';
 const LogFileNotFound$1 = 'The log file was not found.';
 const Settings = 'Settings';
 const TurnOffAutoScroll = 'Turn auto scrolling off';
@@ -2248,20 +1875,23 @@ const settings = () => {
 const logFileNotFound = () => {
   return i18nString(LogFileNotFound$1);
 };
+const filter = () => {
+  return i18nString(Filter$1);
+};
 
 const loadButtons = () => {
   return [{
+    icon: 'MaskIconClearAll',
     id: Clear,
-    label: clearOutput(),
-    icon: 'MaskIconClearAll'
+    label: clearOutput()
   }, {
+    icon: 'MaskIconListFlat',
     id: ScrollLock,
-    label: turnOffAutoScroll(),
-    icon: 'MaskIconListFlat'
+    label: turnOffAutoScroll()
   }, {
+    icon: 'MaskIconSettingsGear',
     id: Settings$1,
-    label: settings(),
-    icon: 'MaskIconSettingsGear'
+    label: settings()
   }];
 };
 
@@ -2274,6 +1904,7 @@ const getExtensionOptions = async () => {
     // TODO make api more declarative:
     // output channels are registered in extension manifest
     // only downside: it might show channels for extensions that are not active
+    // @ts-ignore
     await activateByEvent('onOutput');
     // @ts-ignore
     const channels = await invoke('Output.getEnabledProviders');
@@ -2324,8 +1955,8 @@ const restoreState = savedState => {
   const scrollLockEnabled = getSavedScrollLockEnabled(savedState);
   return {
     filterValue,
-    selectedOption,
-    scrollLockEnabled
+    scrollLockEnabled,
+    selectedOption
   };
 };
 
@@ -2349,9 +1980,9 @@ const loadContent = async (state, savedState) => {
   const collapsedUris = getSavedCollapsedUris(savedState);
   const logsFolderPath = await getLogsDir();
   const {
-    selectedOption,
     filterValue,
-    scrollLockEnabled
+    scrollLockEnabled,
+    selectedOption
   } = restoreState(savedState);
   const selectedId = getSelectedItem(selectedOption, platform);
   const options = await loadOptions(platform, logsFolderPath);
@@ -2363,9 +1994,9 @@ const loadContent = async (state, savedState) => {
     uri
   } = option;
   const {
-    lines,
+    code,
     error,
-    code
+    lines
   } = await loadLines(uri);
   const filteredItems = filterItems(lines, filterValue);
   const newWatchId = createWatchId();
@@ -2410,22 +2041,22 @@ const refresh = async state => {
     return state;
   }
   const {
-    lines,
+    code,
     error,
-    code
+    lines
   } = await loadLines(matchingOption.uri);
   const filteredItems = filterItems(lines, filterValue);
   return {
     ...state,
-    listItems: lines,
-    filteredItems,
     error,
-    errorCode: code
+    errorCode: code,
+    filteredItems,
+    listItems: lines
   };
 };
 
 const renderFilterValue = (oldState, newState) => {
-  return ['Viewlet.setValueByName', newState.parentId, Filter$1, newState.filterValue];
+  return ['Viewlet.setValueByName', newState.parentId, Filter$2, newState.filterValue];
 };
 
 const Filter = 'Filter';
@@ -2444,9 +2075,9 @@ const Error$1 = 'Error';
 const Line = 'Line';
 
 const parentNode = {
-  type: Div,
+  childCount: 1,
   className: Line,
-  childCount: 1
+  type: Div
 };
 const getLineDom = parts => {
   const children = [];
@@ -2455,11 +2086,11 @@ const getLineDom = parts => {
       children.push(text(part.value));
     } else {
       children.push({
-        type: A,
+        childCount: 1,
         href: part.value,
-        target: '_blank',
         rel: 'noopener noreferrer',
-        childCount: 1
+        target: '_blank',
+        type: A
       }, text(part.value));
     }
   }
@@ -2475,11 +2106,11 @@ const getContentDom = (lines, error) => {
     return [];
   }
   return [{
-    type: Div,
+    childCount: lines.length,
     className: OutputContent,
     role: 'log',
     tabIndex: 0,
-    childCount: lines.length
+    type: Div
   }, ...lines.flatMap(getLineDom)];
 };
 
@@ -2487,10 +2118,10 @@ const LogFileNotFound = 1;
 
 const getLogFileNotFoundDom = () => {
   return [{
-    type: Div,
+    childCount: 1,
     className: Message,
     tabIndex: 0,
-    childCount: 1
+    type: Div
   }, text(logFileNotFound())];
 };
 
@@ -2502,18 +2133,18 @@ const getErrorDom = (errorCode, error) => {
     return getLogFileNotFoundDom();
   }
   return [{
-    type: Div,
+    childCount: 1,
     className: Error$1,
     tabIndex: 0,
-    childCount: 1
+    type: Div
   }, text(error)];
 };
 
 const getOutputVirtualDom = (lines, errorCode, error) => {
   return [{
-    type: Div,
+    childCount: 1,
     className: mergeClassNames(Viewlet, Output),
-    childCount: 1
+    type: Div
   }, ...getContentDom(lines, error), ...getErrorDom(errorCode, error)];
 };
 
@@ -2530,10 +2161,10 @@ const renderSelectedItem = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
-    case RenderItems:
-      return renderItems;
     case RenderFilterValue:
       return renderFilterValue;
+    case RenderItems:
+      return renderItems;
     case RenderSelectedItem:
       return renderSelectedItem;
     default:
@@ -2552,10 +2183,10 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
-  set$2(uid, newState, newState);
+  set$1(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2570,20 +2201,20 @@ const HandleButtonClick = 'handleButtonClick';
 
 const getActionButtonVirtualDom = button => {
   const {
+    icon,
     id,
-    label,
-    icon
+    label
   } = button;
   return [{
-    type: Button,
+    childCount: 1,
     className: IconButton,
     name: id,
+    onClick: HandleButtonClick,
     title: label,
-    childCount: 1,
-    onClick: HandleButtonClick
+    type: Button
   }, {
-    type: Div,
-    className: mergeClassNames(MaskIcon, icon)
+    className: mergeClassNames(MaskIcon, icon),
+    type: Div
   }];
 };
 
@@ -2592,18 +2223,18 @@ const getActionButtonsVirtualDom = buttons => {
 };
 
 const getFilterVirtualDom = () => {
-  const placeholder = 'Filter';
+  const placeholder = filter();
   return [{
-    type: Div,
+    childCount: 1,
     className: Filter,
-    childCount: 1
+    type: Div
   }, {
-    type: Input,
-    className: mergeClassNames(InputBox, FilterInput),
     childCount: 0,
-    placeholder,
+    className: mergeClassNames(InputBox, FilterInput),
+    name: Filter$2,
     onInput: HandleFilterInput,
-    name: Filter$1
+    placeholder,
+    type: Input
   }];
 };
 
@@ -2613,20 +2244,20 @@ const getOptionVirtualDom = option => {
     label
   } = option;
   return [{
-    type: Option$1,
-    className: Option,
     childCount: 1,
+    className: Option,
+    type: Option$1,
     value: id
   }, text(label)];
 };
 
 const getSelectVirtualDom = options => {
   return [{
-    type: Select$1,
-    className: Select,
     childCount: options.length,
+    className: Select,
     name: Output$1,
-    onChange: HandleSelect
+    onChange: HandleSelect,
+    type: Select$1
   }, ...options.flatMap(getOptionVirtualDom)];
 };
 
@@ -2638,17 +2269,17 @@ const getChildCount = buttonsLength => {
 const getActionsVirtualDom = (options, buttons) => {
   const childCount = getChildCount(buttons.length);
   return [{
-    type: Div,
+    childCount,
     className: Actions,
     role: ToolBar,
-    childCount
+    type: Div
   }, ...getFilterVirtualDom(), ...getSelectVirtualDom(options), ...getActionButtonsVirtualDom(buttons)];
 };
 
 const renderActions = state => {
   const {
-    options,
-    buttons
+    buttons,
+    options
   } = state;
   const dom = getActionsVirtualDom(options, buttons);
   return dom;
@@ -2698,11 +2329,8 @@ const serializeLines = lines => {
   return lines.map(serializeLineParts).join('\n');
 };
 
-// no local use of Line/LinePart here; serializeLines handles typing
-
 const saveOutputAs = async state => {
-  // @ts-ignore
-  const uri = await invoke$1('FilePicker.showSaveFilePicker');
+  const uri = await showSaveFilePicker();
   if (!uri) {
     return state;
   }
@@ -2717,16 +2345,16 @@ const saveOutputAs = async state => {
 
 const saveState = state => {
   const {
-    filterValue,
     collapsedUris,
-    selectedOption,
-    scrollLockEnabled
+    filterValue,
+    scrollLockEnabled,
+    selectedOption
   } = state;
   return {
-    filterValue,
     collapsedUris,
-    selectedOption,
-    scrollLockEnabled
+    filterValue,
+    scrollLockEnabled,
+    selectedOption
   };
 };
 
@@ -2786,7 +2414,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMapRef
   });
-  set$1(rpc);
+  set$3(rpc);
 };
 
 const main = async () => {