@lvce-editor/static-server 0.70.19 → 0.70.21

package/static/{711ab07 → a0480e0}/packages/problems-view/dist/problemsViewWorkerMain.js

@@ -1,3 +1,122 @@
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$6 = () => {
+  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 None$1 = 'none';
+const ToolBar = 'toolbar';
+const Tree = 'tree';
+const TreeItem = 'treeitem';
+
+const Button$1 = 1;
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+const A = 53;
+
+const Space = 9;
+const PageUp = 10;
+const PageDown = 11;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+
+const Script$1 = 2;
+
+const ProblemsFilter$1 = 25;
+
+const Checked = 2;
+const Unchecked = 3;
+
+const DebugWorker = 55;
+const EditorWorker$1 = 99;
+const RendererWorker$1 = 1;
+
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -237,8 +356,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 => {
@@ -261,14 +380,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) => {
@@ -287,8 +406,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -298,8 +417,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -360,8 +479,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -381,8 +500,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();
@@ -439,8 +558,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 => {
@@ -452,8 +571,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);
@@ -462,9 +581,9 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1$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');
@@ -477,8 +596,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -513,61 +632,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$6 = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$2 = id => {
   return callbacks[id];
 };
-const remove = 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$6(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);
@@ -718,7 +795,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -761,9 +838,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
   };
@@ -772,22 +849,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,
@@ -874,29 +951,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$1 = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -919,24 +973,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$1(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$2(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -953,7 +1070,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) {
@@ -971,15 +1088,63 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+const create$i = async ({
   commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$2({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+const LazyTransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$i
+};
+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);
@@ -987,8 +1152,9 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3 = async ({
+const create$2 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -996,16 +1162,13 @@ 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
-};
-const create$4 = async ({
+const create$1$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1017,7 +1180,7 @@ const create$4 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$1$1
 };
 const createMockRpc = ({
   commandMap
@@ -1032,137 +1195,31 @@ const createMockRpc = ({
     return command(...params);
   };
   const mockRpc = {
+    invocations,
     invoke,
-    invokeAndTransfer: invoke,
-    invocations
+    invokeAndTransfer: invoke
   };
   return mockRpc;
 };
 
-const toCommandId$1 = 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$1);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
-    }
-  };
-};
-const terminate = () => {
-  globalThis.close();
-};
-
-const None$1 = 'none';
-const ToolBar = 'toolbar';
-const Tree = 'tree';
-const TreeItem = 'treeitem';
-
-const Button$1 = 1;
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-const A = 53;
-
-const Space = 9;
-const PageUp = 10;
-const PageDown = 11;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-
-const Script$1 = 2;
-
-const DebugWorker = 55;
-const EditorWorker$1 = 99;
-const RendererWorker$1 = 1;
-
 const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
+const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
+const remove = id => {
+  delete rpcs[id];
+};
 
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
 const create$1 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -1175,21 +1232,30 @@ const create$1 = rpcId => {
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
-    set(rpc) {
-      set$5(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$4(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$4(rpcId, rpc);
     }
   };
 };
 
 const {
+  dispose: dispose$1,
   invoke: invoke$1,
   invokeAndTransfer: invokeAndTransfer$1,
-  set: set$4,
-  dispose: dispose$1
+  registerMockRpc: registerMockRpc$1,
+  set: set$3
 } = create$1(EditorWorker$1);
 const sendMessagePortToExtensionHostWorker$1 = async port => {
   const command = 'HandleMessagePort.handleMessagePort2';
@@ -1206,6 +1272,10 @@ const applyEdit = async (editorUid, changes) => {
   // @ts-ignore
   await invoke$1('Editor.applyEdit2', editorUid, changes);
 };
+const applyDocumentEdits = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$1('Editor.applyDocumentEdits', editorUid, changes);
+};
 const applyWorkspaceEdit = async (editorUid, changes) => {
   // @ts-ignore
   await invoke$1('Editor.applyWorkspaceEdit', editorUid, changes);
@@ -1238,6 +1308,9 @@ const getSelections = async editorUid => {
 const getWordAtOffset2 = async editorUid => {
   return invoke$1('Editor.getWordAtOffset2', editorUid);
 };
+const closeFind2 = async editorUid => {
+  return invoke$1('Editor.closeFind2', editorUid);
+};
 const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
   return invoke$1('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
 };
@@ -1256,19 +1329,14 @@ const getProblems$2 = async () => {
   // @ts-ignore
   return invoke$1('Editor.getProblems');
 };
-const registerMockRpc$1 = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$4(mockRpc);
-  return mockRpc;
-};
 
 const EditorWorker = {
   __proto__: null,
   activateByEvent: activateByEvent$1,
+  applyDocumentEdits,
   applyEdit,
   applyWorkspaceEdit,
+  closeFind2,
   closeWidget: closeWidget$1,
   dispose: dispose$1,
   getLanguageId,
@@ -1285,15 +1353,16 @@ const EditorWorker = {
   invokeAndTransfer: invokeAndTransfer$1,
   registerMockRpc: registerMockRpc$1,
   sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  set: set$4,
+  set: set$3,
   updateDebugInfo
 };
 
 const {
+  dispose,
   invoke,
   invokeAndTransfer,
-  set: set$3,
-  dispose
+  registerMockRpc,
+  set: set$2
 } = create$1(RendererWorker$1);
 const searchFileHtml = async uri => {
   return invoke('ExtensionHost.searchFileWithHtml', uri);
@@ -1416,6 +1485,10 @@ const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
+const sendMessagePortToFileSearchWorker = async (port, rpcId = 0) => {
+  const command = 'QuickPick.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSearchWorker', port, command, rpcId);
+};
 const sendMessagePortToSearchProcess = async port => {
   await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
 };
@@ -1460,8 +1533,8 @@ const getIcons = async requests => {
   const icons = await invoke('IconTheme.getIcons', requests);
   return icons;
 };
-const activateByEvent = event => {
-  return invoke('ExtensionHostManagement.activateByEvent', event);
+const activateByEvent = (event, assetDir, platform) => {
+  return invoke('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
 };
 const setAdditionalFocus = focusKey => {
   // @ts-ignore
@@ -1489,10 +1562,23 @@ const sendMessagePortToSourceControlWorker = async port => {
   // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
 };
+const sendMessagePortToSharedProcess = async port => {
+  const command = 'HandleElectronMessagePort.handleElectronMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
+};
 const sendMessagePortToFileSystemProcess = async (port, rpcId) => {
   const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, rpcId);
 };
+const sendMessagePortToIframeWorker = async (port, rpcId) => {
+  const command = 'Iframes.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker', port, command, rpcId);
+};
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = 'Extensions.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
+};
 const getPreference = async key => {
   return await invoke('Preferences.get', key);
 };
@@ -1558,6 +1644,22 @@ const installExtension = async id => {
   // @ts-ignore
   return invoke('ExtensionManagement.install', id);
 };
+const minimizeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.minimize');
+};
+const unmaximizeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.unmaximize');
+};
+const maximizeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.maximize');
+};
+const closeWindow = async () => {
+  // @ts-ignore
+  return invoke('ElectronWindow.close');
+};
 const openExtensionSearch = async () => {
   // @ts-ignore
   return invoke('SideBar.openViewlet', 'Extensions');
@@ -1589,12 +1691,8 @@ const getLogsDir = async () => {
 const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
   return invoke(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
 };
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$3(mockRpc);
-  return mockRpc;
+const refreshOutput = async () => {
+  await invoke('Output.refresh');
 };
 
 const RendererWorker = {
@@ -1602,6 +1700,7 @@ const RendererWorker = {
   activateByEvent,
   applyBulkReplacement,
   closeWidget,
+  closeWindow,
   confirm,
   disableExtension,
   dispose,
@@ -1639,7 +1738,9 @@ const RendererWorker = {
   installExtension,
   invoke,
   invokeAndTransfer,
+  maximizeWindow,
   measureTextBlockHeight,
+  minimizeWindow,
   openExtensionSearch,
   openExternal,
   openNativeFolder,
@@ -1648,6 +1749,7 @@ const RendererWorker = {
   openWidget,
   readClipBoardText,
   readFile,
+  refreshOutput,
   registerMockRpc,
   registerWebViewInterceptor,
   renderMarkdown,
@@ -1658,16 +1760,20 @@ const RendererWorker = {
   sendMessagePortToEditorWorker: sendMessagePortToEditorWorker$1,
   sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker,
+  sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToFileSearchWorker,
   sendMessagePortToFileSystemProcess,
   sendMessagePortToFileSystemWorker,
   sendMessagePortToIconThemeWorker,
+  sendMessagePortToIframeWorker,
   sendMessagePortToMarkdownWorker,
   sendMessagePortToRendererProcess,
   sendMessagePortToSearchProcess,
+  sendMessagePortToSharedProcess,
   sendMessagePortToSourceControlWorker,
   sendMessagePortToSyntaxHighlightingWorker,
   sendMessagePortToTextMeasurementWorker,
-  set: set$3,
+  set: set$2,
   setAdditionalFocus,
   setColorTheme,
   setExtensionsSearchValue,
@@ -1680,6 +1786,7 @@ const RendererWorker = {
   showMessageBox,
   showSaveFilePicker,
   uninstallExtension,
+  unmaximizeWindow,
   unregisterWebViewInterceptor,
   writeClipBoardImage,
   writeClipBoardText: writeClipBoardText$1
@@ -1687,7 +1794,7 @@ const RendererWorker = {
 
 const {
   sendMessagePortToEditorWorker,
-  set: set$2,
+  set: set$1,
   writeClipBoardText
 } = RendererWorker;
 
@@ -1710,9 +1817,12 @@ const Script = 2;
 
 const {
   get,
-  set: set$1,
-  wrapCommand
-} = create$2();
+  getCommandIds,
+  registerCommands,
+  set,
+  wrapCommand,
+  wrapGetter
+} = create$6();
 
 const None = 0;
 const Table = 1;
@@ -1732,6 +1842,9 @@ const create = (id, uri, x, y, width, height, workspaceUri) => {
     message: '',
     minLineY: 0,
     problems: [],
+    showErrors: true,
+    showInfos: true,
+    showWarnings: true,
     smallWidthBreakPoint: 650,
     uid: id,
     viewMode: None,
@@ -1740,7 +1853,7 @@ const create = (id, uri, x, y, width, height, workspaceUri) => {
     x,
     y
   };
-  set$1(id, state, state);
+  set(id, state, state);
 };
 
 const isEqual$1 = (oldState, newState) => {
@@ -1784,27 +1897,15 @@ const focusIndex = (state, index) => {
   };
 };
 
-const commandMapRef = {};
-
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const getCommandIds = () => {
-  const keys = Object.keys(commandMapRef);
-  const ids = keys.map(toCommandId);
-  return ids;
-};
-
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
 
 const text = data => {
   return {
-    type: Text,
+    childCount: 0,
     text: data,
-    childCount: 0
+    type: Text
   };
 };
 
@@ -1858,6 +1959,130 @@ const getKeyBindings = () => {
   }];
 };
 
+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 ClearFilters = 'Clear Filters';
+const Code = 'Code';
+const File = 'File';
+const Filter$3 = 'Filter';
+const LineColumn = '[Ln {PH1}, Col {PH2}]';
+const Message$1 = 'Message';
+const NoProblemsDetected = 'No problems have been detected in the workspace.';
+const NoResultsFoundWithProvidedFilterCriteria = 'No results found with provided filter criteria.';
+const ProblemsDetected = 'Some problems have been detected in the workspace.';
+const ShowingOfItems = 'Showing {PH1} of {PH2} ';
+const Source = 'Source';
+const CollapseAll$1 = 'Collapse All';
+const ViewAsTable = 'View as Table';
+const ViewAsList = 'View as List';
+const ShowErrors = 'Show Errors';
+const ShowWarnings = 'Show Warnings';
+const ShowInfos = 'Show Infos';
+
+const noProblemsDetected = () => {
+  return i18nString(NoProblemsDetected);
+};
+const getMessage = problemsCount => {
+  if (problemsCount === 0) {
+    return i18nString(NoProblemsDetected);
+  }
+  return i18nString(ProblemsDetected);
+};
+const atLineColumn = (line, column) => {
+  return i18nString(LineColumn, {
+    PH1: line,
+    PH2: column
+  });
+};
+const clearFilter = () => {
+  return i18nString(ClearFilters);
+};
+const code = () => {
+  return i18nString(Code);
+};
+const message = () => {
+  return i18nString(Message$1);
+};
+const file = () => {
+  return i18nString(File);
+};
+const filter = () => {
+  return i18nString(Filter$3);
+};
+const showingOf = (visibleCount, totalCount) => {
+  return i18nString(ShowingOfItems, {
+    PH1: visibleCount,
+    PH2: totalCount
+  });
+};
+const source = () => {
+  return i18nString(Source);
+};
+const noResultsFoundWithProvidedFilterCriteria = () => {
+  return i18nString(NoResultsFoundWithProvidedFilterCriteria);
+};
+const collapseAll = () => {
+  return i18nString(CollapseAll$1);
+};
+const viewAsList$1 = () => {
+  return i18nString(ViewAsList);
+};
+const viewAsTable$1 = () => {
+  return i18nString(ViewAsTable);
+};
+const showErrors = () => {
+  return i18nString(ShowErrors);
+};
+const showWarnings = () => {
+  return i18nString(ShowWarnings);
+};
+const showInfos = () => {
+  return i18nString(ShowInfos);
+};
+
+const getMenuEntriesFilter = state => [{
+  command: '-1',
+  flags: state.showErrors ? Checked : Unchecked,
+  id: 'show-errors',
+  label: showErrors()
+}, {
+  command: '-1',
+  flags: state.showWarnings ? Checked : Unchecked,
+  id: 'show-warnings',
+  label: showWarnings()
+}, {
+  command: '-1',
+  flags: state.showInfos ? Checked : Unchecked,
+  id: 'show-infos',
+  label: showInfos()
+}];
+
+const getMenuEntries2 = (state, props) => {
+  const {
+    menuId
+  } = props;
+  switch (menuId) {
+    case ProblemsFilter$1:
+      return getMenuEntriesFilter(state);
+    default:
+      return [];
+  }
+};
+
+const getMenuIds = () => {
+  return [ProblemsFilter$1];
+};
+
 const Item = 0;
 const Expanded = 1;
 const Collapsed = 2;
@@ -1960,7 +2185,27 @@ const handleClickButton = async (state, name) => {
   return state;
 };
 
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
+};
+
+const handleClickMoreFilters = async (state, eventX, eventY) => {
+  const {
+    uid
+  } = state;
+  await show2(uid, ProblemsFilter$1, eventX, eventY, {
+    menuId: ProblemsFilter$1
+  });
+  return state;
+};
+
 const handleContextMenu = async (state, eventX, eventY) => {
+  const {
+    uid
+  } = state;
+  await show2(uid, ProblemsFilter$1, eventX, eventY, {
+    menuId: ProblemsFilter$1
+  });
   return state;
 };
 
@@ -1979,30 +2224,12 @@ const handleIconThemeChange = state => {
   };
 };
 
-const send = port => {
-  return sendMessagePortToEditorWorker(port, 0);
-};
-const createEditorWorkerRpc = async () => {
-  try {
-    const rpc = await TransferMessagePortRpcParent.create({
-      commandMap: {},
-      send
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create editor worker rpc`);
-  }
+const initialize = async () => {
+  // function is not needed anymore
 };
 
 const {
-  getProblems: getProblems$1,
-  set
-} = EditorWorker;
-
-const initialize = async () => {
-  const rpc = await createEditorWorkerRpc();
-  set(rpc);
-};
+  getProblems: getProblems$1} = EditorWorker;
 
 const toProblem = (diagnostic, index) => {
   const {
@@ -2114,85 +2341,6 @@ const getProblems = async workspaceUri => {
   }
 };
 
-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 ClearFilters = 'Clear Filters';
-const Code = 'Code';
-const File = 'File';
-const Filter$3 = 'Filter';
-const LineColumn = '[Ln {PH1}, Col {PH2}]';
-const Message$1 = 'Message';
-const NoProblemsDetected = 'No problems have been detected in the workspace.';
-const NoResultsFoundWithProvidedFilterCriteria = 'No results found with provided filter criteria.';
-const ProblemsDetected = 'Some problems have been detected in the workspace.';
-const ShowingOfItems = 'Showing {PH1} of {PH2} ';
-const Source = 'Source';
-const CollapseAll$1 = 'Collapse All';
-const ViewAsTable = 'View as Table';
-const ViewAsList = 'View as List';
-
-const noProblemsDetected = () => {
-  return i18nString(NoProblemsDetected);
-};
-const getMessage = problemsCount => {
-  if (problemsCount === 0) {
-    return i18nString(NoProblemsDetected);
-  }
-  return i18nString(ProblemsDetected);
-};
-const atLineColumn = (line, column) => {
-  return i18nString(LineColumn, {
-    PH1: line,
-    PH2: column
-  });
-};
-const clearFilter = () => {
-  return i18nString(ClearFilters);
-};
-const code = () => {
-  return i18nString(Code);
-};
-const message = () => {
-  return i18nString(Message$1);
-};
-const file = () => {
-  return i18nString(File);
-};
-const filter = () => {
-  return i18nString(Filter$3);
-};
-const showingOf = (visibleCount, totalCount) => {
-  return i18nString(ShowingOfItems, {
-    PH1: visibleCount,
-    PH2: totalCount
-  });
-};
-const source = () => {
-  return i18nString(Source);
-};
-const noResultsFoundWithProvidedFilterCriteria = () => {
-  return i18nString(NoResultsFoundWithProvidedFilterCriteria);
-};
-const collapseAll = () => {
-  return i18nString(CollapseAll$1);
-};
-const viewAsList$1 = () => {
-  return i18nString(ViewAsList);
-};
-const viewAsTable$1 = () => {
-  return i18nString(ViewAsTable);
-};
-
 const getSavedViewMode = savedState => {
   if (savedState && typeof savedState.viewMode === 'number') {
     return savedState.viewMode;
@@ -2280,11 +2428,12 @@ const ProblemsTableRowOdd = 'ProblemsTableRowOdd';
 const ProblemsWarningIcon = 'ProblemsWarningIcon';
 const Viewlet = 'Viewlet';
 
-const HandleBlur = 'handleBlur';
-const HandleClearFilterClick = 'handleClearFilterClick';
-const HandleContextMenu = 'handleContextMenu';
-const HandleFilterInput = 'handleFilterInput';
-const HandlePointerDown = 'handlePointerDown';
+const HandleBlur = 1;
+const HandleClearFilterClick = 2;
+const HandleContextMenu = 3;
+const HandleFilterInput = 4;
+const HandlePointerDown = 5;
+const HandleClickMoreFilters = 6;
 
 const getIconVirtualDom = (icon, type = Div) => {
   return {
@@ -2316,8 +2465,8 @@ const getInputBoxVirtualDom = (name, onInput, placeholder) => {
     autocorrect: 'off',
     className: InputBox,
     name,
-    onInput: onInput,
-    placeholder: placeholder,
+    onInput,
+    placeholder,
     spellcheck: false,
     type: Input
   };
@@ -2355,8 +2504,7 @@ const getProblemsFilterVirtualDom = action => {
   }, getInputBoxVirtualDom(Filter$2, action.command, action.placeholder || ''), ...getBadgeDom(action.badgeText), ...getActionButtonVirtualDom({
     command: 'more filters',
     icon: Filter,
-    id: 'more filters' // TODO use i18n string
-  })];
+    id: 'more filters'})];
 };
 
 const getNoResultsWithFilterVirtualDom = () => {
@@ -2806,7 +2954,7 @@ const render2 = (uid, diffResult) => {
     newState,
     oldState
   } = get(uid);
-  set$1(uid, newState, newState);
+  set(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -2906,6 +3054,9 @@ const renderEventListeners = () => {
   }, {
     name: HandlePointerDown,
     params: ['handleClickAt', 'event.clientX', 'event.clientY']
+  }, {
+    name: HandleClickMoreFilters,
+    params: ['handleClickMoreFilters']
   }];
 };
 
@@ -2950,10 +3101,13 @@ const commandMap = {
   'Problems.focusIndex': wrapCommand(focusIndex),
   'Problems.getCommandIds': getCommandIds,
   'Problems.getKeyBindings': getKeyBindings,
+  'Problems.getMenuEntries2': wrapGetter(getMenuEntries2),
+  'Problems.getMenuIds': getMenuIds,
   'Problems.handleArrowLeft': wrapCommand(handleArrowLeft),
   'Problems.handleArrowRight': wrapCommand(handleArrowRight),
   'Problems.handleClickAt': wrapCommand(handleClickAt),
   'Problems.handleClickButton': wrapCommand(handleClickButton),
+  'Problems.handleClickMoreFilters': wrapCommand(handleClickMoreFilters),
   'Problems.handleContextMenu': wrapCommand(handleContextMenu),
   'Problems.handleFilterInput': wrapCommand(handleFilterInput),
   'Problems.handleIconThemeChange': wrapCommand(handleIconThemeChange),
@@ -2963,18 +3117,41 @@ const commandMap = {
   'Problems.renderActions': renderActions,
   'Problems.renderEventListeners': renderEventListeners,
   'Problems.resize': resize,
-  'Problems.saveState': saveState,
+  'Problems.saveState': wrapGetter(saveState),
   'Problems.terminate': terminate,
   'Problems.viewAsList': wrapCommand(viewAsList),
   'Problems.viewAsTable': wrapCommand(viewAsTable)
 };
 
-const listen = async () => {
-  Object.assign(commandMapRef, commandMap);
+const commandMapRef = {};
+
+const send = port => {
+  return sendMessagePortToEditorWorker(port, 0);
+};
+const initializeEditorWorkerRpc = async () => {
+  try {
+    const rpc = await LazyTransferMessagePortRpcParent.create({
+      commandMap: {},
+      send
+    });
+    set$3(rpc);
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create editor worker rpc`);
+  }
+};
+
+const initializeRendererWorker = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMapRef
   });
-  set$2(rpc);
+  set$1(rpc);
+};
+
+const listen = async () => {
+  Object.assign(commandMapRef, commandMap);
+  registerCommands(commandMap);
+  await Promise.all([initializeRendererWorker(), initializeEditorWorkerRpc()]);
 };
 
 const main = async () => {