@lvce-editor/static-server 0.66.9 → 0.66.10

package/static/{36e0225 → c3a0ed8}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -596,13 +596,13 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
+const set$4 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$3 = id => {
   return callbacks[id];
 };
-const remove$1 = id => {
+const remove$2 = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -615,7 +615,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$5(id, resolve);
+  set$4(id, resolve);
   return {
     id,
     promise
@@ -787,7 +787,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove$1(id);
+  remove$2(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -960,7 +960,7 @@ const send$1 = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$4 = (ipc, method, ...params) => {
+const invoke$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
@@ -999,7 +999,7 @@ const createRpc = ipc => {
       send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
+      return invoke$3(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$1(ipc, method, ...params);
@@ -1136,109 +1136,6 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$4
 };
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invoke,
-    invokeAndTransfer: invoke,
-    invocations
-  };
-  return mockRpc;
-};
-
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$3 = () => {
-  const states = Object.create(null);
-  const commandMapRef = {};
-  return {
-    get(uid) {
-      return states[uid];
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
-    },
-    dispose(uid) {
-      delete states[uid];
-    },
-    getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseInt(key);
-      });
-    },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
-          return;
-        }
-        const latest = states[uid];
-        states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        newState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
-    }
-  };
-};
-const terminate = () => {
-  globalThis.close();
-};
 
 const Alert = 'alert';
 const Button$3 = 'button';
@@ -1337,11 +1234,12 @@ const LeftClick = 0;
 const Electron = 2;
 const Remote = 3;
 
-const DebugWorker = 55;
-const RendererWorker$1 = 1;
+const RendererWorker = 1;
 const SearchProcess = 77;
 const IconThemeWorker = 7009;
 
+const Match$1 = 2;
+
 const FocusElementByName = 'Viewlet.focusElementByName';
 const SetDom2 = 'Viewlet.setDom2';
 const SetFocusContext = 'Viewlet.setFocusContext';
@@ -1364,6 +1262,178 @@ const FocusSearchWholeWord = 34;
 const FocusToggleDetails = 1010;
 const FocusToggleReplace = 1020;
 
+const rpcs = Object.create(null);
+const set$3 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get$2 = id => {
+  return rpcs[id];
+};
+
+const create$3 = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get$2(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get$2(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$3(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get$2(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+
+const {
+  invoke: invoke$2,
+  set: set$2} = create$3(IconThemeWorker);
+const getIcons = async iconRequests => {
+  // @ts-ignore
+  return invoke$2('IconTheme.getIcons', iconRequests);
+};
+
+const {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$1} = create$3(RendererWorker);
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  // @ts-ignore
+  await invoke$1('ContextMenu.show2', uid, menuId, x, y, args);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const writeClipBoardText = async text => {
+  await invoke$1('ClipBoard.writeText', /* text */text);
+};
+const openUri$1 = async (uri, focus, options) => {
+  await invoke$1('Main.openUri', uri, focus, options);
+};
+
+const createLazyRpc = rpcId => {
+  let rpcPromise;
+  let factory;
+  const createRpc = async () => {
+    const rpc = await factory();
+    set$3(rpcId, rpc);
+  };
+  const ensureRpc = async () => {
+    if (!rpcPromise) {
+      rpcPromise = createRpc();
+    }
+    await rpcPromise;
+  };
+  return {
+    setFactory(value) {
+      factory = value;
+    },
+    async invoke(method, ...params) {
+      await ensureRpc();
+      const rpc = get$2(rpcId);
+      return rpc.invoke(method, ...params);
+    }
+  };
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$2 = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    get(uid) {
+      return states[uid];
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        oldState,
+        newState
+      };
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseInt(key);
+      });
+    },
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (newState === newerState) {
+          return;
+        }
+        const latest = states[uid];
+        states[uid] = {
+          oldState: latest.oldState,
+          newState: newerState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        newState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
+};
+
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
@@ -1661,434 +1731,6 @@ const collapseDetails = state => {
   };
 };
 
-const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$2 = id => {
-  return rpcs[id];
-};
-
-const create$2 = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$2(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$2(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$4(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$2(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
-
-const {
-  invoke: invoke$3,
-  set: set$3} = create$2(IconThemeWorker);
-const getIcons$1 = async iconRequests => {
-  // @ts-ignore
-  return invoke$3('IconTheme.getIcons', iconRequests);
-};
-
-const {
-  invoke: invoke$2,
-  invokeAndTransfer,
-  set: set$2,
-  dispose
-} = create$2(RendererWorker$1);
-const searchFileHtml = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
-};
-const getFilePathElectron = async file => {
-  return invoke$2('FileSystemHandle.getFilePathElectron', file);
-};
-const showContextMenu$1 = async (x, y, id, ...args) => {
-  return invoke$2('ContextMenu.show', x, y, id, ...args);
-};
-const getElectronVersion = async () => {
-  return invoke$2('Process.getElectronVersion');
-};
-const applyBulkReplacement$1 = 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 = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const readFile = 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 closeWidget = async widgetId => {
-  return invoke$2('Viewlet.closeWidget', widgetId);
-};
-const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
-};
-const sendMessagePortToSearchProcess$1 = 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$1 = async text => {
-  await invoke$2('ClipBoard.writeText', /* text */text);
-};
-const writeClipBoardImage = async blob => {
-  // @ts-ignore
-  await invoke$2('ClipBoard.writeImage', /* text */blob);
-};
-const searchFileMemory = async uri => {
-  // @ts-ignore
-  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
-};
-const searchFileFetch = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
-};
-const showMessageBox = async options => {
-  return invoke$2('ElectronDialog.showMessageBox', options);
-};
-const handleDebugResumed = async params => {
-  await invoke$2('Run And Debug.handleResumed', params);
-};
-const openWidget = async name => {
-  await invoke$2('Viewlet.openWidget', name);
-};
-const getIcons = async requests => {
-  const icons = await invoke$2('IconTheme.getIcons', requests);
-  return icons;
-};
-const activateByEvent = event => {
-  return invoke$2('ExtensionHostManagement.activateByEvent', event);
-};
-const setAdditionalFocus = focusKey => {
-  // @ts-ignore
-  return invoke$2('Focus.setAdditionalFocus', focusKey);
-};
-const getActiveEditorId = () => {
-  // @ts-ignore
-  return invoke$2('GetActiveEditor.getActiveEditorId');
-};
-const getWorkspacePath = () => {
-  return invoke$2('Workspace.getPath');
-};
-const sendMessagePortToRendererProcess = async port => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
-};
-const getPreference = async key => {
-  return await invoke$2('Preferences.get', key);
-};
-const getAllExtensions = async () => {
-  return invoke$2('ExtensionManagement.getAllExtensions');
-};
-const rerenderEditor = async key => {
-  // @ts-ignore
-  return invoke$2('Editor.rerender', key);
-};
-const handleDebugPaused = async params => {
-  await invoke$2('Run And Debug.handlePaused', params);
-};
-const openUri$2 = async (uri, focus, options) => {
-  await invoke$2('Main.openUri', uri, focus, options);
-};
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer(
-  // @ts-ignore
-  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
-};
-const handleDebugScriptParsed = async script => {
-  await invoke$2('Run And Debug.handleScriptParsed', script);
-};
-const getWindowId = async () => {
-  return invoke$2('GetWindowId.getWindowId');
-};
-const getBlob = async uri => {
-  // @ts-ignore
-  return invoke$2('FileSystem.getBlob', uri);
-};
-const getExtensionCommands = async () => {
-  return invoke$2('ExtensionHost.getCommands');
-};
-const showErrorDialog = async errorInfo => {
-  // @ts-ignore
-  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
-};
-const getFolderSize = async uri => {
-  // @ts-ignore
-  return await invoke$2('FileSystem.getFolderSize', uri);
-};
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.getExtension', id);
-};
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke$2('Markdown.getVirtualDom', html);
-};
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke$2('Markdown.renderMarkdown', markdown, options);
-};
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
-};
-const uninstallExtension = async id => {
-  return invoke$2('ExtensionManagement.uninstall', id);
-};
-const installExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.install', id);
-};
-const openExtensionSearch = async () => {
-  // @ts-ignore
-  return invoke$2('SideBar.openViewlet', 'Extensions');
-};
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke$2('Extensions.handleInput', searchValue);
-};
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openExternal', uri);
-};
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openUrl', uri);
-};
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke$2('Preferences.getAll');
-};
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$2('FilePicker.showSaveFilePicker');
-};
-const getLogsDir = async () => {
-  // @ts-ignore
-  return invoke$2('PlatformPaths.getLogsDir');
-};
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$2(mockRpc);
-  return mockRpc;
-};
-
-const RendererWorker = {
-  __proto__: null,
-  activateByEvent,
-  applyBulkReplacement: applyBulkReplacement$1,
-  closeWidget,
-  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,
-  installExtension,
-  invoke: invoke$2,
-  invokeAndTransfer,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri: openUri$2,
-  openUrl,
-  openWidget,
-  readFile,
-  registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess: sendMessagePortToSearchProcess$1,
-  sendMessagePortToSyntaxHighlightingWorker,
-  set: set$2,
-  setAdditionalFocus,
-  setColorTheme,
-  setExtensionsSearchValue,
-  setFocus,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu: showContextMenu$1,
-  showErrorDialog,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText: writeClipBoardText$1
-};
-
-const createLazyRpc = rpcId => {
-  let rpcPromise;
-  let factory;
-  const createRpc = async () => {
-    const rpc = await factory();
-    set$4(rpcId, rpc);
-  };
-  const ensureRpc = async () => {
-    if (!rpcPromise) {
-      rpcPromise = createRpc();
-    }
-    await rpcPromise;
-  };
-  return {
-    setFactory(value) {
-      factory = value;
-    },
-    async invoke(method, ...params) {
-      await ensureRpc();
-      const rpc = get$2(rpcId);
-      return rpc.invoke(method, ...params);
-    }
-  };
-};
-
-const {
-  invoke: invoke$1,
-  openUri: openUri$1,
-  sendMessagePortToSearchProcess,
-  set: set$1,
-  showContextMenu,
-  writeClipBoardText} = RendererWorker;
-
 const copy = async state => {
   const {
     items,
@@ -2124,7 +1766,7 @@ const {
   registerCommands,
   getCommandIds,
   wrapGetter
-} = create$3();
+} = create$2();
 
 const List = 1;
 
@@ -2203,7 +1845,9 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, v
     limitHit: false,
     limitHitWarning: '',
     limit: 20_000,
-    fileIconCache: {}
+    fileIconCache: {},
+    removeButtonWidth: 20,
+    removeButtonRight: 0
   };
   set(uid, state, state);
   return state;
@@ -2228,7 +1872,7 @@ const isEqual$5 = (oldState, newState) => {
 };
 
 const isEqual$4 = (oldState, newState) => {
-  return oldState.focus === newState.focus;
+  return oldState.focus === newState.focus && oldState.focused === newState.focused;
 };
 
 const diffType$3 = RenderIncludeValue;
@@ -2274,12 +1918,222 @@ const diff2 = uid => {
   return diffResult;
 };
 
+const getFilePath = text => {
+  // TODO make api stricter so that results always have the same shape
+  if (text.startsWith('./')) {
+    return text.slice(2);
+  }
+  return text;
+};
+
+const getIconsCached = (dirents, fileIconCache) => {
+  return dirents.map(dirent => {
+    if (dirent.type === Match$1) {
+      return '';
+    }
+    const path = getFilePath(dirent.text);
+    return fileIconCache[path];
+  });
+};
+
+const getFileName = path => {
+  const slashIndex = path.lastIndexOf('/');
+  if (slashIndex === -1) {
+    return path;
+  }
+  return path.slice(slashIndex + 1);
+};
+
+const isFile = match => {
+  return match.type === File;
+};
+
+const getMissingDirents = (searchResults, fileIconCache) => {
+  const missingDirents = [];
+  const files = searchResults.filter(isFile);
+  for (const file of files) {
+    const uri = getFilePath(file.text);
+    if (!(uri in fileIconCache)) {
+      missingDirents.push(file);
+    }
+  }
+  return missingDirents;
+};
+const toIconRequest = item => {
+  const filePath = getFilePath(item.text);
+  const fileName = getFileName(filePath);
+  return {
+    type: File$1,
+    name: fileName,
+    path: filePath
+  };
+};
+const getMissingIconRequests = (dirents, fileIconCache) => {
+  const missingRequests = getMissingDirents(dirents, fileIconCache);
+  const iconRequests = missingRequests.map(toIconRequest);
+  return iconRequests;
+};
+
+const Directory = 3;
+const DirectoryExpanded = 4;
+
+const getSimpleIconRequestType = direntType => {
+  if (direntType === Directory || direntType === DirectoryExpanded) {
+    return 2;
+  }
+  return 1;
+};
+
+const toSimpleIconRequest = request => {
+  return {
+    name: request.name,
+    type: getSimpleIconRequestType(request.type)
+  };
+};
+
+const requestFileIcons = async requests => {
+  if (requests.length === 0) {
+    return [];
+  }
+  const simpleRequests = requests.map(toSimpleIconRequest);
+  const icons = await getIcons(simpleRequests);
+  return icons;
+};
+
+const updateIconCache = (iconCache, missingRequests, newIcons) => {
+  if (missingRequests.length === 0) {
+    return iconCache;
+  }
+  const newFileIconCache = {
+    ...iconCache
+  };
+  for (let i = 0; i < missingRequests.length; i++) {
+    const request = missingRequests[i];
+    const icon = newIcons[i];
+    newFileIconCache[request.path] = icon;
+  }
+  return newFileIconCache;
+};
+
+const getFileIcons = async (items, fileIconCache) => {
+  const missingRequests = getMissingIconRequests(items, fileIconCache);
+  const newIcons = await requestFileIcons(missingRequests);
+  const newFileIconCache = updateIconCache(fileIconCache, missingRequests, newIcons);
+  const icons = getIconsCached(items, newFileIconCache);
+  return {
+    icons,
+    newFileIconCache
+  };
+};
+
+const getNewMinMax = (newItemsLength, minLineY, maxLineY, deltaY, itemHeight) => {
+  if (maxLineY > newItemsLength) {
+    const diff = maxLineY - minLineY;
+    const newMinLineY = Math.max(newItemsLength - diff, 0);
+    const newDeltaY = newMinLineY * itemHeight;
+    return {
+      newDeltaY,
+      newMinLineY,
+      newMaxLineY: newItemsLength
+    };
+  }
+  return {
+    newDeltaY: deltaY,
+    newMinLineY: minLineY,
+    newMaxLineY: maxLineY
+  };
+};
+
 // based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
 
-const remove = (array, index, deleteCount) => {
+const remove$1 = (array, index, deleteCount) => {
   return array.toSpliced(index, deleteCount);
 };
 
+const getSetSize = (items, index) => {
+  let setSize = 0;
+  for (let i = index + 1; i < items.length; i++) {
+    if (items[i].type === File) {
+      break;
+    }
+    setSize++;
+  }
+  return setSize;
+};
+const getRemoveIndicesFile = (items, item, index, matchCount, fileCount) => {
+  const setSize = getSetSize(items, index);
+  return {
+    startIndex: index,
+    removeCount: setSize + 1,
+    newFocusedIndex: index + setSize + 1 < items.length ? index : index - 1,
+    newFileCount: fileCount - 1,
+    newMatchCount: matchCount - setSize
+  };
+};
+const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
+  for (let i = index; i >= 0; i--) {
+    if (items[i].type === File) {
+      const setSize = getSetSize(items, i);
+      if (setSize === 1) {
+        return {
+          startIndex: i,
+          removeCount: 2,
+          newFocusedIndex: i - 1,
+          newFileCount: fileCount - 1,
+          newMatchCount: matchCount - 1
+        };
+      }
+      return {
+        startIndex: index,
+        removeCount: 1,
+        newFocusedIndex: index,
+        newFileCount: fileCount,
+        newMatchCount: matchCount - 1
+      };
+    }
+  }
+  throw new Error('could not compute indices to remove');
+};
+const getRemoveIndices = (items, index, matchCount, fileCount) => {
+  const item = items[index];
+  switch (item.type) {
+    case File:
+      return getRemoveIndicesFile(items, item, index, matchCount, fileCount);
+    case Match:
+      return getRemoveIndicesMatch(items, index, matchCount, fileCount);
+    default:
+      throw new Error('unknown search result type');
+  }
+};
+const removeItemFromItems = (items, index, matchCount, fileCount) => {
+  const {
+    startIndex,
+    removeCount,
+    newFocusedIndex,
+    newFileCount,
+    newMatchCount
+  } = getRemoveIndices(items, index, matchCount, fileCount);
+  const newItems = remove$1(items, startIndex, removeCount);
+  return {
+    newItems,
+    newFocusedIndex,
+    newFileCount,
+    newMatchCount
+  };
+};
+
+const getScrollBarSize$1 = (size, contentSize, minimumSliderSize) => {
+  if (size >= contentSize) {
+    return 0;
+  }
+  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
+};
+const getScrollBarOffset$1 = (delta, finalDelta, size, scrollBarSize) => {
+  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
+  return scrollBarOffset;
+};
+const getScrollBarY$1 = getScrollBarOffset$1;
+
 const emptyObject = {};
 const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
 const i18nString = (key, placeholders = emptyObject) => {
@@ -2309,6 +2163,7 @@ const Include = 'Include';
 const ManyResultsInManyFiles = '{PH1} results in {PH2} files';
 const ManyResultsInOneFile = '{PH1} results in 1 file';
 const MatchCase$1 = 'Match Case';
+const Remove$1 = 'Remove';
 const MatchWholeWord$1 = 'Match Whole Word';
 const NoResults = 'No results found';
 const Oneresult = '1 result in 1 file';
@@ -2342,6 +2197,9 @@ const toggleReplace$1 = () => {
 const matchCase = () => {
   return i18nString(MatchCase$1);
 };
+const remove = () => {
+  return i18nString(Remove$1);
+};
 const preserveCase = () => {
   return i18nString(PreserveCase$1);
 };
@@ -2486,98 +2344,13 @@ const getStatusMessage = (resultCount, fileResultCount) => {
   return manyResultsInManyFiles(resultCount, fileResultCount);
 };
 
-const getSetSize = (items, index) => {
-  let setSize = 0;
-  for (let i = index + 1; i < items.length; i++) {
-    if (items[i].type === File) {
-      break;
-    }
-    setSize++;
-  }
-  return setSize;
-};
-const getRemoveIndicesFile = (items, item, index, matchCount, fileCount) => {
-  const setSize = getSetSize(items, index);
-  return {
-    startIndex: index,
-    removeCount: setSize + 1,
-    newFocusedIndex: index + setSize + 1 < items.length ? index : index - 1,
-    newFileCount: fileCount - 1,
-    newMatchCount: matchCount - setSize
-  };
-};
-const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
-  for (let i = index; i >= 0; i--) {
-    if (items[i].type === File) {
-      const setSize = getSetSize(items, i);
-      if (setSize === 1) {
-        return {
-          startIndex: i,
-          removeCount: 2,
-          newFocusedIndex: i - 1,
-          newFileCount: fileCount - 1,
-          newMatchCount: matchCount - 1
-        };
-      }
-      return {
-        startIndex: index,
-        removeCount: 1,
-        newFocusedIndex: index,
-        newFileCount: fileCount,
-        newMatchCount: matchCount - 1
-      };
-    }
-  }
-  throw new Error('could not compute indices to remove');
-};
-const getRemoveIndices = (items, index, matchCount, fileCount) => {
-  const item = items[index];
-  switch (item.type) {
-    case File:
-      return getRemoveIndicesFile(items, item, index, matchCount, fileCount);
-    case Match:
-      return getRemoveIndicesMatch(items, index, matchCount, fileCount);
-    default:
-      throw new Error('unknown search result type');
-  }
-};
-const removeItemFromItems = (items, index, matchCount, fileCount) => {
-  const {
-    startIndex,
-    removeCount,
-    newFocusedIndex,
-    newFileCount,
-    newMatchCount
-  } = getRemoveIndices(items, index, matchCount, fileCount);
-  const newItems = remove(items, startIndex, removeCount);
-  return {
-    newItems,
-    newFocusedIndex,
-    newFileCount,
-    newMatchCount
-  };
-};
-const getNewMinMax = (newItemsLength, minLineY, maxLineY, deltaY, itemHeight) => {
-  if (maxLineY > newItemsLength) {
-    const diff = maxLineY - minLineY;
-    const newMinLineY = Math.max(newItemsLength - diff, 0);
-    const newDeltaY = newMinLineY * itemHeight;
-    return {
-      newDeltaY,
-      newMinLineY,
-      newMaxLineY: newItemsLength
-    };
-  }
-  return {
-    newDeltaY: deltaY,
-    newMinLineY: minLineY,
-    newMaxLineY: maxLineY
-  };
-};
-const dismissItem = state => {
+const removeIndex = async (state, index) => {
   const {
+    fileIconCache,
+    minimumSliderSize,
+    height,
+    headerHeight,
     items,
-    listFocusedIndex,
     fileCount,
     matchCount,
     minLineY,
@@ -2585,7 +2358,7 @@ const dismissItem = state => {
     deltaY,
     itemHeight
   } = state;
-  if (listFocusedIndex === -1) {
+  if (index === -1) {
     return state;
   }
   const {
@@ -2593,26 +2366,50 @@ const dismissItem = state => {
     newFocusedIndex,
     newMatchCount,
     newFileCount
-  } = removeItemFromItems(items, listFocusedIndex, matchCount, fileCount);
+  } = removeItemFromItems(items, index, matchCount, fileCount);
   const message = getStatusMessage(newMatchCount, newFileCount);
   const {
     newMinLineY,
     newMaxLineY,
     newDeltaY
   } = getNewMinMax(newItems.length, minLineY, maxLineY, deltaY, itemHeight);
+  const total = newItems.length;
+  const contentHeight = total * itemHeight;
+  const listHeight = height - headerHeight;
+  const scrollBarHeight = getScrollBarSize$1(height, contentHeight, minimumSliderSize);
+  const finalDeltaY = Math.max(contentHeight - listHeight, 0);
+  const visible = newItems.slice(0, maxLineY);
+  const {
+    icons,
+    newFileIconCache
+  } = await getFileIcons(visible, fileIconCache);
   return {
     ...state,
+    deltaY: newDeltaY,
+    fileCount: newFileCount,
     items: newItems,
+    listItems: newItems,
     listFocusedIndex: newFocusedIndex,
-    message,
     matchCount: newMatchCount,
-    fileCount: newFileCount,
-    minLineY: newMinLineY,
     maxLineY: newMaxLineY,
-    deltaY: newDeltaY
+    message,
+    minLineY: newMinLineY,
+    icons,
+    fileIconCache: newFileIconCache,
+    finalDeltaY,
+    scrollBarHeight
   };
 };
 
+const dismissItem = state => {
+  const {
+    listFocusedIndex,
+    focusedIndex
+  } = state;
+  const actualIndex = listFocusedIndex === -1 ? focusedIndex : listFocusedIndex;
+  return removeIndex(state, actualIndex);
+};
+
 const expandDetails = state => {
   const {
     flags
@@ -2827,6 +2624,10 @@ const getSearchResultKeyBindings = () => {
     key: CtrlCmd | KeyC,
     command: 'Search.copy',
     when: FocusSearchResults
+  }, {
+    key: Delete,
+    command: 'Search.removeCurrent',
+    when: FocusSearchResults
   }];
 };
 
@@ -2834,23 +2635,24 @@ const getKeyBindings = () => {
   return [...getSearchHeaderKeyBindings(), ...getSearchResultKeyBindings()];
 };
 
-const getMenuEntryIds = () => {
-  return [Search$1];
-};
 const getMenuEntries = () => {
   return [{
     id: 'dismiss',
     label: dismiss(),
     flags: None$1,
-    command: /* TODO */''
+    command: 'Search.removeCurrent'
   }, {
     id: 'copyPath',
     label: copyPath(),
     flags: None$1,
-    command: /* TODO */''
+    command: 'Search.copyPath'
   }];
 };
 
+const getMenuEntryIds = () => {
+  return [Search$1];
+};
+
 const handleError = error => {
   console.error(`[text-search-worker] ${error}`);
 };
@@ -2891,100 +2693,6 @@ const handleUpdateError = async (state, update, error) => {
   };
 };
 
-const getIconsCached = (dirents, fileIconCache) => {
-  return dirents.map(dirent => fileIconCache[dirent]);
-};
-
-const getFileName$1 = text => {
-  // TODO make api stricter so that results always have the same shape
-  if (text.startsWith('./')) {
-    return text.slice(2);
-  }
-  return text;
-};
-
-const getFileName = text => {
-  if (text.startsWith('./')) {
-    return text.slice(2);
-  }
-  return text;
-};
-const getMissingDirents = (items, fileIconCache) => {
-  const missingDirents = [];
-  for (const item of items) {
-    const uri = getFileName(item.text);
-    if (!(uri in fileIconCache)) {
-      missingDirents.push(item);
-    }
-  }
-  return missingDirents;
-};
-const toIconRequest = item => {
-  return {
-    type: File$1,
-    name: getFileName(item.text),
-    path: getFileName(item.text)
-  };
-};
-const getMissingIconRequests = (dirents, fileIconCache) => {
-  const missingRequests = getMissingDirents(dirents, fileIconCache);
-  const iconRequests = missingRequests.map(toIconRequest);
-  return iconRequests;
-};
-
-const Directory = 3;
-const DirectoryExpanded = 4;
-
-const getSimpleIconRequestType = direntType => {
-  if (direntType === Directory || direntType === DirectoryExpanded) {
-    return 2;
-  }
-  return 1;
-};
-
-const toSimpleIconRequest = request => {
-  return {
-    name: request.name,
-    type: getSimpleIconRequestType(request.type)
-  };
-};
-
-const requestFileIcons = async requests => {
-  if (requests.length === 0) {
-    return [];
-  }
-  const simpleRequests = requests.map(toSimpleIconRequest);
-  const icons = await getIcons$1(simpleRequests);
-  return icons;
-};
-
-const updateIconCache = (iconCache, missingRequests, newIcons) => {
-  if (missingRequests.length === 0) {
-    return iconCache;
-  }
-  const newFileIconCache = {
-    ...iconCache
-  };
-  for (let i = 0; i < missingRequests.length; i++) {
-    const request = missingRequests[i];
-    const icon = newIcons[i];
-    newFileIconCache[request.path] = icon;
-  }
-  return newFileIconCache;
-};
-
-const getFileIcons = async (items, fileIconCache) => {
-  const missingRequests = getMissingIconRequests(items, fileIconCache);
-  const newIcons = await requestFileIcons(missingRequests);
-  const newFileIconCache = updateIconCache(fileIconCache, missingRequests, newIcons);
-  const paths = items.map(item => getFileName$1(item.text));
-  const icons = getIconsCached(paths, newFileIconCache);
-  return {
-    icons,
-    newFileIconCache
-  };
-};
-
 // TODO optimize this function to return the minimum number
 // of visible items needed, e.g. when not scrolled 5 items with
 // 20px fill 100px but when scrolled 6 items are needed
@@ -3020,18 +2728,6 @@ const getTextSearchResultCounts = results => {
   };
 };
 
-const getScrollBarSize$1 = (size, contentSize, minimumSliderSize) => {
-  if (size >= contentSize) {
-    return 0;
-  }
-  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
-};
-const getScrollBarOffset$1 = (delta, finalDelta, size, scrollBarSize) => {
-  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
-  return scrollBarOffset;
-};
-const getScrollBarY$1 = getScrollBarOffset$1;
-
 const providers = Object.create(null);
 const add = providerMap => {
   Object.assign(providers, providerMap);
@@ -3084,7 +2780,7 @@ const handleUpdateFull = async (state, update) => {
     useRegularExpression: Boolean(flags & UseRegularExpression$2),
     exclude: excludeValue,
     include: includeValue,
-    assetDir: assetDir,
+    assetDir,
     root,
     query: value,
     scheme,
@@ -3112,9 +2808,6 @@ const handleUpdateFull = async (state, update) => {
     icons,
     newFileIconCache
   } = await getFileIcons(visible, fileIconCache);
-
-  // TODO add info message if limit was hit
-
   const limitHitWarning = limitHit ? theResultSetOnlyContainsASubSetOfMatches() : '';
   return {
     ...partialNewState,
@@ -3354,6 +3047,7 @@ const ToggleReplace = 'ToggleReplace';
 const ToggleSearchDetails = 'ToggleSearchDetails';
 const UseExcludeSettings = 'UseExcludeSettings';
 const UseRegularExpression = 'UseRegularExpression';
+const Remove = 'Remove';
 
 const noop = state => {
   return state;
@@ -3391,7 +3085,7 @@ const getReplaceElements = (items, workspacePath, replacement) => {
     } = match;
     if (type === File) {
       changes = [];
-      const fileName = getFileName$1(text);
+      const fileName = getFilePath(text);
       const absolutePath = `${workspacePath}/${fileName}`;
       element = {
         uri: absolutePath,
@@ -3695,7 +3389,7 @@ const launchIconThemeWorker = async () => {
 
 const initializeIconThemeWorker = async () => {
   const rpc = await launchIconThemeWorker();
-  set$3(rpc);
+  set$2(rpc);
 };
 
 const launchSearchProcessElectron = async () => {
@@ -4184,7 +3878,7 @@ const selectIndex = async (state, index) => {
   return fn(state, searchResult, index);
 };
 
-const handleClickAt = async (state, eventX, eventY) => {
+const handleClickAt = async (state, eventX, eventY, name) => {
   const {
     x,
     y,
@@ -4195,6 +3889,10 @@ const handleClickAt = async (state, eventX, eventY) => {
   } = state;
   const topHeight = getTopHeight(flags);
   const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, topHeight, listItems.length);
+  const isRemoveButton = name === Remove;
+  if (isRemoveButton) {
+    return removeIndex(state, index);
+  }
   return selectIndex(state, index);
 };
 
@@ -4364,6 +4062,17 @@ const refresh = state => {
   return handleUpdate(state, {});
 };
 
+const removeCurrent = async state => {
+  // TODO
+  // 1. get focused index
+  // 2. if it is -1, do nothing
+  // 3. get search result at focused index
+  // 4. call removeIndex with state, searchResult, index
+  return {
+    ...state
+  };
+};
+
 const getFocusSelector = focusKey => {
   switch (focusKey) {
     case FocusSearchInput:
@@ -5071,17 +4780,20 @@ const getChildCount = (icon, expanded, badgeText) => {
   return childCount;
 };
 
+const closeIcon = {
+  type: Div,
+  className: CloseMaskIcon,
+  childCount: 0
+};
 const getSearchRemoveVirtualDom = () => {
-  // TODO add title/aria label
+  const title = remove();
   const dom = [{
-    type: Div,
+    type: Button$2,
     className: SearchRemove,
-    childCount: 1
-  }, {
-    type: Div,
-    className: CloseMaskIcon,
-    childCount: 0
-  }];
+    name: Remove,
+    childCount: 1,
+    title
+  }, closeIcon];
   return dom;
 };
 
@@ -5328,7 +5040,7 @@ const renderEventListeners = () => {
     params: ['handleReplaceInput', TargetValue]
   }, {
     name: HandleClick,
-    params: ['handleClickAt', ClientX, ClientY]
+    params: ['handleClickAt', ClientX, ClientY, TargetName]
   }, {
     name: HandleListPointerDown,
     params: ['handleListPointerDown', Button$1]
@@ -5557,26 +5269,29 @@ const viewAsTree = async state => {
 
 const Keyboard = -1;
 
-const show = async (x, y, id, ...args) => {
-  // TODO ask renderer worker to show context menu
-  number(x);
-  number(y);
-  number(id);
-  // TODO
-  await showContextMenu(x, y, id, ...args);
+const show2 = async (uid, menuId, x, y, args) => {
+  await showContextMenu2(uid, menuId, x, y, args);
 };
 
 const handleContextMenuKeyboard = async state => {
   const {
     x,
-    y
+    y,
+    uid
   } = state; // TODO
-  await show(x, y, Search$1);
+  await show2(uid, Search$1, x, y, {
+    menuId: Search$1
+  });
   return state;
 };
 
 const handleContextMenuMouseAt = async (state, x, y) => {
-  await show(x, y, Search$1);
+  const {
+    uid
+  } = state;
+  await show2(uid, Search$1, x, y, {
+    menuId: Search$1
+  });
   return state;
 };
 
@@ -5653,6 +5368,8 @@ const commandMap = {
   'TextSearch.nextHistoryResult': wrapCommand(nextHistoryResult),
   'TextSearch.previousHistoryResult': wrapCommand(previousHistoryResult),
   'TextSearch.refresh': wrapCommand(refresh),
+  'TextSearch.removeCurrent': wrapCommand(removeCurrent),
+  'TextSearch.removeIndex': wrapCommand(removeIndex),
   'TextSearch.replaceAll': wrapCommand(replaceAll),
   'TextSearch.rerender': rerender,
   'TextSearch.selectIndex': wrapCommand(selectIndex),