@lvce-editor/problems-view 1.18.0 → 1.19.0

package/dist/problemsViewWorkerMain.js

@@ -2,46 +2,72 @@ const toCommandId = key => {
   const dotIndex = key.indexOf('.');
   return key.slice(dotIndex + 1);
 };
-const create$6 = () => {
+const create$a = () => {
   const states = Object.create(null);
   const commandMapRef = {};
   return {
-    get(uid) {
-      return states[uid];
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
     },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = 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;
     },
     dispose(uid) {
       delete states[uid];
     },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
     getKeys() {
       return Object.keys(states).map(key => {
-        return Number.parseInt(key);
+        return Number.parseFloat(key);
       });
     },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
     },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
-          oldState,
-          newState
+          newState,
+          oldState
         } = states[uid];
         const newerState = await fn(newState, ...args);
         if (oldState === newerState || newState === newerState) {
           return;
         }
-        const latest = states[uid];
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
         states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
+          newState: latestNew,
+          oldState: latestOld.oldState
         };
       };
       return wrapped;
@@ -55,27 +81,36 @@ const create$6 = () => {
       };
       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]);
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
         }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
     }
   };
 };
@@ -83,40 +118,6 @@ 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);
@@ -581,7 +582,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1$1 = 3;
-const create$5 = async ({
+const create$5$1 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
@@ -632,11 +633,32 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5,
+  create: create$5$1,
   signal: signal$1,
   wrap: wrap$5
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const get$2 = id => {
@@ -661,12 +683,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -822,56 +844,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1$2 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$2(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$3 = (message, result) => {
+const create$9 = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$3(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -901,35 +923,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -952,36 +974,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$s = (method, params) => {
+
+const create$8 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+
+const create$7 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -990,15 +993,14 @@ const create$r = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$q = () => {
+const create$6 = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$6();
   const {
     promise,
     resolve
@@ -1010,13 +1012,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1052,12 +1053,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$8(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -1072,6 +1074,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -1080,6 +1083,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -1089,7 +1093,40 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-/* eslint-disable @typescript-eslint/no-misused-promises */
+const create$5 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const create$4 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
 
 const createSharedLazyRpc = factory => {
   let rpcPromise;
@@ -1118,57 +1155,22 @@ const createSharedLazyRpc = factory => {
     }
   };
 };
-const create$i = async ({
+
+const create$3 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$2({
+    return create$4({
       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({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
-};
+
 const create$2 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$4({
-    commandMap,
-    isMessagePortOpen,
-    messagePort: port2
-  });
-};
-const create$1$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1178,10 +1180,7 @@ const create$1$1 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$1$1
-};
+
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1250,81 +1249,41 @@ const create$1 = rpcId => {
   };
 };
 
+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 ProblemsFilter$1 = 25;
+
+const Checked = 2;
+const Unchecked = 3;
+
+const EditorWorker$1 = 99;
+const RendererWorker$1 = 1;
+
 const {
-  dispose: dispose$1,
   invoke: invoke$1,
-  invokeAndTransfer: invokeAndTransfer$1,
-  registerMockRpc: registerMockRpc$1,
   set: set$3
 } = create$1(EditorWorker$1);
-const sendMessagePortToExtensionHostWorker$1 = async port => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$1(
-  // @ts-ignore
-  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
-};
-// TODO add tests for this
-const activateByEvent$1 = async event => {
-  // @ts-ignore
-  await invoke$1('ActivateByEvent.activateByEvent', event);
-};
-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);
-};
-const closeWidget$1 = async (editorUid, widgetId, widgetName, focusId) => {
-  // @ts-ignore
-  await invoke$1('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
-};
-const getWordAt = async (uid, rowIndex, columnIndex) => {
-  // @ts-ignore
-  const word = await invoke$1('Editor.getWordAt2', uid, rowIndex, columnIndex);
-  return word;
-};
-const getLines = async editorUid => {
-  const lines = await invoke$1('Editor.getLines2', editorUid);
-  return lines;
-};
-const getPositionAtCursor = async parentUid => {
-  const position = await invoke$1('Editor.getPositionAtCursor', parentUid);
-  return position;
-};
-const getOffsetAtCursor = async editorId => {
-  // @ts-ignore
-  return await invoke$1('Editor.getOffsetAtCursor', editorId);
-};
-const getSelections = async editorUid => {
-  const selections = await invoke$1('Editor.getSelections2', editorUid);
-  return selections;
-};
-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);
-};
-const updateDebugInfo = async info => {
-  await invoke$1('Editor.updateDebugInfo', info);
-};
-const getUri = async editorUid => {
-  // @ts-ignore
-  return invoke$1('Editor.getUri', editorUid);
-};
-const getLanguageId = async editorUid => {
-  // @ts-ignore
-  return invoke$1('Editor.getLanguageId', editorUid);
-};
 const getProblems$2 = async () => {
   // @ts-ignore
   return invoke$1('Editor.getProblems');
@@ -1332,463 +1291,38 @@ const getProblems$2 = async () => {
 
 const EditorWorker = {
   __proto__: null,
-  activateByEvent: activateByEvent$1,
-  applyDocumentEdits,
-  applyEdit,
-  applyWorkspaceEdit,
-  closeFind2,
-  closeWidget: closeWidget$1,
-  dispose: dispose$1,
-  getLanguageId,
-  getLines,
-  getOffsetAtCursor,
-  getPositionAtCursor,
   getProblems: getProblems$2,
-  getSelections,
-  getUri,
-  getWordAt,
-  getWordAtOffset2,
-  getWordBefore,
   invoke: invoke$1,
-  invokeAndTransfer: invokeAndTransfer$1,
-  registerMockRpc: registerMockRpc$1,
-  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
-  set: set$3,
-  updateDebugInfo
+  set: set$3
 };
 
 const {
-  dispose,
   invoke,
   invokeAndTransfer,
-  registerMockRpc,
   set: set$2
 } = create$1(RendererWorker$1);
-const searchFileHtml = async uri => {
-  return invoke('ExtensionHost.searchFileWithHtml', uri);
-};
-const getFilePathElectron = async file => {
-  return invoke('FileSystemHandle.getFilePathElectron', file);
-};
-/**
- * @deprecated
- */
-const showContextMenu = async (x, y, id, ...args) => {
-  return invoke('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('ContextMenu.show2', uid, menuId, x, y, args);
 };
-const getElectronVersion = async () => {
-  return invoke('Process.getElectronVersion');
-};
-const applyBulkReplacement = async bulkEdits => {
-  await invoke('BulkReplacement.applyBulkReplacement', bulkEdits);
-};
-const setColorTheme = async id => {
-  // @ts-ignore
-  return invoke(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
-};
-const getNodeVersion = async () => {
-  return invoke('Process.getNodeVersion');
-};
-const getChromeVersion = async () => {
-  return invoke('Process.getChromeVersion');
-};
-const getV8Version = async () => {
-  return invoke('Process.getV8Version');
-};
-const getFileHandles = async fileIds => {
-  const files = await invoke('FileSystemHandle.getFileHandles', fileIds);
-  return files;
-};
-const setWorkspacePath = async path => {
-  await invoke('Workspace.setPath', path);
-};
-const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer('WebView.registerInterceptor', id, port);
-};
-const unregisterWebViewInterceptor = async id => {
-  await invoke('WebView.unregisterInterceptor', id);
-};
 const sendMessagePortToEditorWorker$1 = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
 };
-const sendMessagePortToErrorWorker = async (port, rpcId) => {
-  const command = 'Errors.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
-};
-const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
-  const command = 'Markdown.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
-};
-const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
-};
-const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const readFile = async uri => {
-  return invoke('FileSystem.readFile', uri);
-};
-const getWebViewSecret = async key => {
-  // @ts-ignore
-  return invoke('WebView.getSecret', key);
-};
-const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
-};
-const setFocus = key => {
-  return invoke('Focus.setFocus', key);
-};
-const getFileIcon = async options => {
-  return invoke('IconTheme.getFileIcon', options);
-};
-const getColorThemeNames = async () => {
-  return invoke('ColorTheme.getColorThemeNames');
-};
-const disableExtension = async id => {
-  // @ts-ignore
-  return invoke('ExtensionManagement.disable', id);
-};
-const enableExtension = async id => {
-  // @ts-ignore
-  return invoke('ExtensionManagement.enable', id);
-};
-const handleDebugChange = async params => {
-  // @ts-ignore
-  return invoke('Run And Debug.handleChange', params);
-};
-const getFolderIcon = async options => {
-  return invoke('IconTheme.getFolderIcon', options);
-};
-const handleWorkspaceRefresh = async () => {
-  return invoke('Layout.handleWorkspaceRefresh');
-};
-const closeWidget = async widgetId => {
-  return invoke('Viewlet.closeWidget', widgetId);
-};
-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');
-};
-const confirm = async (message, options) => {
-  // @ts-ignore
-  const result = await invoke('ConfirmPrompt.prompt', message, options);
-  return result;
-};
-const getRecentlyOpened = async () => {
-  return invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
-};
-const getKeyBindings$1 = async () => {
-  return invoke('KeyBindingsInitial.getKeyBindings');
-};
 const writeClipBoardText$1 = async text => {
   await invoke('ClipBoard.writeText', /* text */text);
 };
-const readClipBoardText = async () => {
-  return invoke('ClipBoard.readText');
-};
-const writeClipBoardImage = async blob => {
-  // @ts-ignore
-  await invoke('ClipBoard.writeImage', /* text */blob);
-};
-const searchFileMemory = async uri => {
-  // @ts-ignore
-  return invoke('ExtensionHost.searchFileWithMemory', uri);
-};
-const searchFileFetch = async uri => {
-  return invoke('ExtensionHost.searchFileWithFetch', uri);
-};
-const showMessageBox = async options => {
-  return invoke('ElectronDialog.showMessageBox', options);
-};
-const handleDebugResumed = async params => {
-  await invoke('Run And Debug.handleResumed', params);
-};
-const openWidget = async name => {
-  await invoke('Viewlet.openWidget', name);
-};
-const getIcons = async requests => {
-  const icons = await invoke('IconTheme.getIcons', requests);
-  return icons;
-};
-const activateByEvent = (event, assetDir, platform) => {
-  return invoke('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
-};
-const setAdditionalFocus = focusKey => {
-  // @ts-ignore
-  return invoke('Focus.setAdditionalFocus', focusKey);
-};
-const getActiveEditorId = () => {
-  // @ts-ignore
-  return invoke('GetActiveEditor.getActiveEditorId');
-};
-const getWorkspacePath = () => {
-  return invoke('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 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);
-};
-const getAllExtensions = async () => {
-  return invoke('ExtensionManagement.getAllExtensions');
-};
-const rerenderEditor = async key => {
-  // @ts-ignore
-  return invoke('Editor.rerender', key);
-};
-const handleDebugPaused = async params => {
-  await invoke('Run And Debug.handlePaused', params);
-};
-const openUri = async (uri, focus, options) => {
-  await invoke('Main.openUri', uri, focus, options);
-};
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer(
-  // @ts-ignore
-  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
-};
-const handleDebugScriptParsed = async script => {
-  await invoke('Run And Debug.handleScriptParsed', script);
-};
-const getWindowId = async () => {
-  return invoke('GetWindowId.getWindowId');
-};
-const getBlob = async uri => {
-  // @ts-ignore
-  return invoke('FileSystem.getBlob', uri);
-};
-const getExtensionCommands = async () => {
-  return invoke('ExtensionHost.getCommands');
-};
-const showErrorDialog = async errorInfo => {
-  // @ts-ignore
-  await invoke('ErrorHandling.showErrorDialog', errorInfo);
-};
-const getFolderSize = async uri => {
-  // @ts-ignore
-  return await invoke('FileSystem.getFolderSize', uri);
-};
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke('ExtensionManagement.getExtension', id);
-};
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke('Markdown.getVirtualDom', html);
-};
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke('Markdown.renderMarkdown', markdown, options);
-};
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke('OpenNativeFolder.openNativeFolder', uri);
-};
-const uninstallExtension = async id => {
-  return invoke('ExtensionManagement.uninstall', id);
-};
-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');
-};
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke('Extensions.handleInput', searchValue, Script$1);
-};
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke('Open.openExternal', uri);
-};
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke('Open.openUrl', uri);
-};
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke('Preferences.getAll');
-};
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke('FilePicker.showSaveFilePicker');
-};
-const getLogsDir = async () => {
-  // @ts-ignore
-  return invoke('PlatformPaths.getLogsDir');
-};
-const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
-  return invoke(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
-};
-const refreshOutput = async () => {
-  await invoke('Output.refresh');
-};
 
 const RendererWorker = {
   __proto__: null,
-  activateByEvent,
-  applyBulkReplacement,
-  closeWidget,
-  closeWindow,
-  confirm,
-  disableExtension,
-  dispose,
-  enableExtension,
-  getActiveEditorId,
-  getAllExtensions,
-  getAllPreferences,
-  getBlob,
-  getChromeVersion,
-  getColorThemeNames,
-  getElectronVersion,
-  getExtension,
-  getExtensionCommands,
-  getFileHandles,
-  getFileIcon,
-  getFilePathElectron,
-  getFolderIcon,
-  getFolderSize,
-  getIcons,
-  getKeyBindings: getKeyBindings$1,
-  getLogsDir,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened,
-  getV8Version,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  handleWorkspaceRefresh,
-  installExtension,
   invoke,
   invokeAndTransfer,
-  maximizeWindow,
-  measureTextBlockHeight,
-  minimizeWindow,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri,
-  openUrl,
-  openWidget,
-  readClipBoardText,
-  readFile,
-  refreshOutput,
-  registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
   sendMessagePortToEditorWorker: sendMessagePortToEditorWorker$1,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToExtensionManagementWorker,
-  sendMessagePortToFileSearchWorker,
-  sendMessagePortToFileSystemProcess,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToIframeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSharedProcess,
-  sendMessagePortToSourceControlWorker,
-  sendMessagePortToSyntaxHighlightingWorker,
-  sendMessagePortToTextMeasurementWorker,
   set: set$2,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
   showContextMenu2,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unmaximizeWindow,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
   writeClipBoardText: writeClipBoardText$1
 };
 
@@ -1822,7 +1356,7 @@ const {
   set,
   wrapCommand,
   wrapGetter
-} = create$6();
+} = create$a();
 
 const None = 0;
 const Table = 1;
@@ -2152,6 +1686,13 @@ const handleArrowRight = state => {
   };
 };
 
+const handleBlur = state => {
+  return {
+    ...state,
+    focusedIndex: -2
+  };
+};
+
 const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
   const relativeY = eventY - y + deltaY;
   const index = Math.floor(relativeY / itemHeight);
@@ -2459,6 +2000,17 @@ const getActionButtonVirtualDom = action => {
   }, getIconVirtualDom(icon)];
 };
 
+const getFilterBadgeDom = badgeText => {
+  if (!badgeText) {
+    return [];
+  }
+  return [{
+    childCount: 1,
+    className: FilterBadge,
+    type: Div
+  }, text(badgeText)];
+};
+
 const getInputBoxVirtualDom = (name, onInput, placeholder) => {
   return {
     autocapitalize: 'off',
@@ -2486,22 +2038,12 @@ const getChildCount = badgeText => {
   childCount++; // action button
   return childCount;
 };
-const getBadgeDom = badgeText => {
-  if (!badgeText) {
-    return [];
-  }
-  return [{
-    childCount: 1,
-    className: FilterBadge,
-    type: Div
-  }, text(badgeText)];
-};
 const getProblemsFilterVirtualDom = action => {
   return [{
     childCount: getChildCount(action.badgeText),
     className: Filter$1,
     type: Div
-  }, getInputBoxVirtualDom(Filter$2, action.command, action.placeholder || ''), ...getBadgeDom(action.badgeText), ...getActionButtonVirtualDom({
+  }, getInputBoxVirtualDom(Filter$2, action.command, action.placeholder || ''), ...getFilterBadgeDom(action.badgeText), ...getActionButtonVirtualDom({
     command: 'more filters',
     icon: Filter,
     id: 'more filters'})];
@@ -2818,9 +2360,7 @@ const getProblemsVirtualDom$1 = (viewMode, problems, filterValue, message) => {
 };
 
 const getProblemsVirtualDom = (viewMode, problems, filterValue, isSmall, message) => {
-  // TODO avoid mutation
-  const dom = [];
-  dom.push({
+  const baseDom = {
     childCount: 1,
     className: mergeClassNames(Viewlet, Problems),
     onBlur: HandleBlur,
@@ -2828,16 +2368,13 @@ const getProblemsVirtualDom = (viewMode, problems, filterValue, isSmall, message
     onPointerDown: HandlePointerDown,
     tabIndex: 0,
     type: Div
-  });
-  if (isSmall) {
-    dom[0].childCount++;
-    dom.push(...getProblemsFilterVirtualDom({
-      badgeText: '',
-      command: HandleFilterInput,
-      placeholder: filter()}));
-  }
-  dom.push(...getProblemsVirtualDom$1(viewMode, problems, filterValue, message));
-  return dom;
+  };
+  const filterDom = isSmall ? getProblemsFilterVirtualDom({
+    badgeText: '',
+    command: HandleFilterInput,
+    placeholder: filter()}) : [];
+  const itemsDom = getProblemsVirtualDom$1(viewMode, problems, filterValue, message);
+  return [baseDom, ...filterDom, ...itemsDom];
 };
 
 const matchesFilterValue = (string, filterValueLower) => {
@@ -2846,6 +2383,7 @@ const matchesFilterValue = (string, filterValueLower) => {
   }
   return 0;
 };
+
 const getListItemType = (listItemType, isCollapsed) => {
   if (listItemType === Item) {
     return Item;
@@ -2891,6 +2429,7 @@ const getIcon = uri => {
   }
   return getFileNameIcon();
 };
+
 const getVisibleProblems = (problems, collapsedUris, focusedIndex, filterValue) => {
   array(problems);
   array(collapsedUris);
@@ -3105,6 +2644,7 @@ const commandMap = {
   'Problems.getMenuIds': getMenuIds,
   'Problems.handleArrowLeft': wrapCommand(handleArrowLeft),
   'Problems.handleArrowRight': wrapCommand(handleArrowRight),
+  'Problems.handleBlur': wrapCommand(handleBlur),
   'Problems.handleClickAt': wrapCommand(handleClickAt),
   'Problems.handleClickButton': wrapCommand(handleClickButton),
   'Problems.handleClickMoreFilters': wrapCommand(handleClickMoreFilters),
@@ -3130,7 +2670,7 @@ const send = port => {
 };
 const initializeEditorWorkerRpc = async () => {
   try {
-    const rpc = await LazyTransferMessagePortRpcParent.create({
+    const rpc = await create$3({
       commandMap: {},
       send
     });
@@ -3142,7 +2682,7 @@ const initializeEditorWorkerRpc = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await WebWorkerRpcClient.create({
+  const rpc = await create$2({
     commandMap: commandMapRef
   });
   set$1(rpc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/problems-view",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "Problems View Worker",
   "repository": {
     "type": "git",