@lvce-editor/static-server 0.61.11 → 0.61.13

package/static/{7150c6c → 35d9aa1}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -1240,94 +1240,10 @@ const terminate = () => {
   globalThis.close();
 };
 
-const User = 1;
-const Script = 2;
-
-const Empty$1 = 0;
-const FocusIgnoreFiles = 1012;
-const FocusSearch = 1013;
-const FocusSearchExcludeInput = 1008;
-const FocusSearchIncludeInput = 1007;
-const FocusSearchInput = 21;
-const FocusSearchMatchCase = 32;
-const FocusSearchOpenEditors = 1011;
-const FocusSearchPreserveCase = 36;
-const FocusSearchRegex = 33;
-const FocusSearchReplaceAll = 35;
-const FocusSearchReplaceInput = 31;
-const FocusSearchResults = 22;
-const FocusSearchWholeWord = 34;
-const FocusToggleDetails = 1010;
-const FocusToggleReplace = 1020;
-
-const clearSearchResults$1 = state => {
-  return {
-    ...state,
-    value: '',
-    items: [],
-    minLineY: 0,
-    maxLineY: 0,
-    message: '',
-    focus: FocusSearchInput,
-    focusSource: Script,
-    inputSource: Script
-  };
-};
-
-const File$1 = 1;
-const Match = 2;
-
-const getPaths = items => {
-  const paths = [];
-  for (const item of items) {
-    if (item.type === File$1) {
-      paths.push(item.text);
-    }
-  }
-  return paths;
-};
-const collapseAll$1 = async state => {
-  const {
-    items
-  } = state;
-  if (items.length === 0) {
-    return state;
-  }
-  const paths = getPaths(items);
-  return {
-    ...state,
-    collapsedPaths: paths
-  };
-};
-
-const PreserveCase$2 = 1 << 0; // 1
-const UseRegularExpression$2 = 1 << 1; // 2
-const ReplaceExpanded = 1 << 2; // 4
-const MatchWholeWord$2 = 1 << 3; // 8
-const MatchCase$2 = 1 << 4; // 16
-const DetailsExpanded = 1 << 5; // 32
-const OpenEditors = 1 << 6; // 64
-const UseIgnoreFiles = 1 << 7; // 128
-const hasDetailsExpanded = flags => {
-  return (flags & DetailsExpanded) === DetailsExpanded;
-};
-
-const collapseDetails = state => {
-  const {
-    flags
-  } = state;
-  return {
-    ...state,
-    flags: flags & -33,
-    focus: FocusSearchInput,
-    focusSource: Script
-  };
-};
-
 const Alert = 'alert';
 const Button$3 = 'button';
 const CheckBox = 'checkbox';
-const None$1 = 'none';
+const None$2 = 'none';
 const ScrollBar$1 = 'scrollbar';
 const Status = 'status';
 const ToolBar = 'toolbar';
@@ -1338,7 +1254,7 @@ const Actions = 'Actions';
 const Badge = 'Badge';
 const Chevron = 'Chevron';
 const CloseMaskIcon = 'MaskIcon MaskIconClose';
-const Empty = '';
+const Empty$1 = '';
 const FileIcon = 'FileIcon';
 const FocusOutline = 'FocusOutline';
 const Grow = 'Grow';
@@ -1392,7 +1308,7 @@ const Viewlet = 'Viewlet';
 const ViewletSearchMessage = 'ViewletSearchMessage';
 const ViewletSearchMessageIndented = 'ViewletSearchMessageIndented';
 
-const File = 7;
+const File$1 = 7;
 
 const Button$2 = 1;
 const Div = 4;
@@ -1414,6 +1330,10 @@ const TargetValue = 'event.target.value';
 
 const Search$1 = 18;
 
+const None$1 = 0;
+
+const LeftClick = 0;
+
 const Electron = 2;
 const Remote = 3;
 
@@ -1421,122 +1341,438 @@ const DebugWorker = 55;
 const RendererWorker$1 = 1;
 const SearchProcess = 77;
 
-const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$2 = id => {
-  return rpcs[id];
+const FocusElementByName = 'Viewlet.focusElementByName';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetValueByName = 'Viewlet.setValueByName';
+
+const Empty = 0;
+const FocusIgnoreFiles = 1012;
+const FocusSearch = 1013;
+const FocusSearchExcludeInput = 1008;
+const FocusSearchIncludeInput = 1007;
+const FocusSearchInput = 21;
+const FocusSearchMatchCase = 32;
+const FocusSearchOpenEditors = 1011;
+const FocusSearchPreserveCase = 36;
+const FocusSearchRegex = 33;
+const FocusSearchReplaceAll = 35;
+const FocusSearchReplaceInput = 31;
+const FocusSearchResults = 22;
+const FocusSearchWholeWord = 34;
+const FocusToggleDetails = 1010;
+const FocusToggleReplace = 1020;
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
 };
 
-const create$2 = rpcId => {
+const text = data => {
   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();
-    }
+    type: Text,
+    text: data,
+    childCount: 0
   };
 };
 
-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 SetText = 1;
+const SetAttribute = 3;
+const RemoveAttribute = 4;
+const Add = 6;
+const NavigateChild = 7;
+const NavigateParent = 8;
+const RemoveChild = 9;
+const NavigateSibling = 10;
+
+const applyPendingPatches = (patches, pendingPatches, skip) => {
+  for (let k = 0; k < pendingPatches.length - skip; k += 2) {
+    const type = pendingPatches[k];
+    const index = pendingPatches[k + 1];
+    if (type === NavigateParent) {
+      patches.push({
+        type
+      });
+    } else {
+      patches.push({
+        type,
+        index
+      });
+    }
+  }
+  pendingPatches.length = 0;
 };
-const getWebViewSecret = async key => {
-  // @ts-ignore
-  return invoke$2('WebView.getSecret', key);
+
+const isKey = key => {
+  return key !== 'type' && key !== 'childCount';
 };
-const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+
+const getKeys = node => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
 };
-const setFocus = key => {
-  return invoke$2('Focus.setFocus', key);
+
+const getTotalChildCount = (nodes, index) => {
+  let i = index;
+  let pending = 1;
+  while (pending) {
+    const node = nodes[i];
+    pending += node.childCount;
+    pending--;
+    i++;
+  }
+  return i - index;
+};
+
+const diff$1 = (oldNodes, newNodes) => {
+  const patches = [];
+  const pendingPatches = [];
+  let i = 0;
+  let j = 0;
+  let siblingOffset = 0;
+  let maxSiblingOffset = 1;
+  const indexStack = [0, 1];
+  while (i < oldNodes.length && j < newNodes.length) {
+    const oldNode = oldNodes[i];
+    const newNode = newNodes[j];
+    // TODO maybe don't have the current element in indexstack
+    if (siblingOffset === maxSiblingOffset) {
+      indexStack.pop();
+      indexStack.pop();
+      pendingPatches.push(NavigateParent, 0);
+      maxSiblingOffset = indexStack.pop();
+      siblingOffset = indexStack.pop() + 1;
+    }
+    while (siblingOffset === maxSiblingOffset) {
+      pendingPatches.push(NavigateParent, 0);
+      maxSiblingOffset = indexStack.pop();
+      siblingOffset = indexStack.pop() + 1;
+    }
+    if (oldNode.type !== newNode.type) {
+      let skip = 0;
+      if (pendingPatches.length > 0 && pendingPatches.at(-2) === NavigateChild) {
+        skip = 2;
+      }
+      applyPendingPatches(patches, pendingPatches, skip);
+      const oldTotal = getTotalChildCount(oldNodes, i);
+      const newTotal = getTotalChildCount(newNodes, j);
+      patches.push({
+        type: RemoveChild,
+        index: siblingOffset
+      });
+      patches.push({
+        type: Add,
+        nodes: newNodes.slice(j, j + newTotal)
+      });
+      siblingOffset++;
+      i += oldTotal;
+      j += newTotal;
+      continue;
+    }
+    if (oldNode.type === Text && newNode.type === Text) {
+      if (oldNode.text !== newNode.text) {
+        if (siblingOffset !== 0) {
+          pendingPatches.push(NavigateSibling, siblingOffset);
+        }
+        applyPendingPatches(patches, pendingPatches, 0);
+        patches.push({
+          type: SetText,
+          value: newNode.text
+        });
+      }
+      i++;
+      j++;
+      siblingOffset++;
+      continue;
+    }
+    const oldKeys = getKeys(oldNode);
+    const newKeys = getKeys(newNode);
+    let hasAttributeChanges = false;
+    for (const key of newKeys) {
+      if (oldNode[key] !== newNode[key]) {
+        hasAttributeChanges = true;
+        break;
+      }
+    }
+    for (const key of oldKeys) {
+      if (!(key in newNode)) {
+        hasAttributeChanges = true;
+        break;
+      }
+    }
+    if (hasAttributeChanges) {
+      if (siblingOffset > 0) {
+        pendingPatches.push(NavigateSibling, siblingOffset);
+      }
+      applyPendingPatches(patches, pendingPatches, 0);
+      for (const key of newKeys) {
+        if (oldNode[key] !== newNode[key]) {
+          patches.push({
+            type: SetAttribute,
+            key,
+            value: newNode[key]
+          });
+        }
+      }
+      for (const key of oldKeys) {
+        if (!(key in newNode)) {
+          patches.push({
+            type: RemoveAttribute,
+            key
+          });
+        }
+      }
+    }
+    if (oldNode.childCount && newNode.childCount) {
+      maxSiblingOffset = oldNode.childCount;
+      indexStack.push(0, maxSiblingOffset);
+      pendingPatches.push(NavigateChild, 0);
+      i++;
+      j++;
+      continue;
+    }
+    if (oldNode.childCount) {
+      applyPendingPatches(patches, pendingPatches, 0);
+      for (let k = 0; k < oldNode.childCount; k++) {
+        patches.push({
+          type: RemoveChild,
+          index: 0
+        });
+      }
+      i += getTotalChildCount(oldNodes, i);
+      j++;
+      siblingOffset++;
+      continue;
+    }
+    if (newNode.childCount) {
+      applyPendingPatches(patches, pendingPatches, 0);
+      const total = getTotalChildCount(newNodes, j);
+      patches.push({
+        type: Add,
+        nodes: newNodes.slice(j + 1, j + total)
+      });
+      i++;
+      j += total;
+      continue;
+    }
+    i++;
+    j++;
+    siblingOffset++;
+  }
+  while (i < oldNodes.length) {
+    if (indexStack.length !== 2) {
+      patches.push({
+        type: NavigateParent
+      });
+    }
+    patches.push({
+      type: RemoveChild,
+      index: siblingOffset
+    });
+    i += getTotalChildCount(oldNodes, i);
+    indexStack.pop();
+    indexStack.pop();
+  }
+  while (j < newNodes.length) {
+    if (siblingOffset > 0) {
+      patches.push({
+        type: NavigateSibling,
+        index: siblingOffset
+      });
+      siblingOffset = 0;
+    }
+    const count = getTotalChildCount(newNodes, j);
+    patches.push({
+      type: Add,
+      nodes: newNodes.slice(j, j + count)
+    });
+    j += count;
+  }
+  return patches;
+};
+
+const User = 1;
+const Script = 2;
+
+const clearSearchResults$1 = state => {
+  return {
+    ...state,
+    value: '',
+    items: [],
+    minLineY: 0,
+    maxLineY: 0,
+    message: '',
+    focus: FocusSearchInput,
+    focusSource: Script,
+    inputSource: Script
+  };
+};
+
+const File = 1;
+const Match = 2;
+
+const getPaths = items => {
+  const paths = [];
+  for (const item of items) {
+    if (item.type === File) {
+      paths.push(item.text);
+    }
+  }
+  return paths;
+};
+const collapseAll$1 = async state => {
+  const {
+    items
+  } = state;
+  if (items.length === 0) {
+    return state;
+  }
+  const paths = getPaths(items);
+  return {
+    ...state,
+    collapsedPaths: paths
+  };
+};
+
+const PreserveCase$2 = 1 << 0; // 1
+const UseRegularExpression$2 = 1 << 1; // 2
+const ReplaceExpanded = 1 << 2; // 4
+const MatchWholeWord$2 = 1 << 3; // 8
+const MatchCase$2 = 1 << 4; // 16
+const DetailsExpanded = 1 << 5; // 32
+const OpenEditors = 1 << 6; // 64
+const UseIgnoreFiles = 1 << 7; // 128
+const hasDetailsExpanded = flags => {
+  return (flags & DetailsExpanded) === DetailsExpanded;
+};
+
+const collapseDetails = state => {
+  const {
+    flags
+  } = state;
+  return {
+    ...state,
+    flags: flags & -33,
+    focus: FocusSearchInput,
+    focusSource: Script
+  };
+};
+
+const rpcs = Object.create(null);
+const set$3 = (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$3(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get$2(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+
+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);
@@ -1876,7 +2112,8 @@ const {
   set,
   wrapCommand,
   registerCommands,
-  getCommandIds
+  getCommandIds,
+  wrapGetter
 } = create$3();
 
 const List = 1;
@@ -1931,7 +2168,7 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, v
     workspacePath: workspacePath,
     includeValue: '',
     excludeValue: '',
-    focus: Empty$1,
+    focus: Empty,
     loaded: false,
     message: '',
     collapsedPaths: [],
@@ -1990,7 +2227,7 @@ const isEqual$3 = (oldState, newState) => {
 
 const diffType$2 = RenderItems;
 const isEqual$2 = (oldState, newState) => {
-  return oldState.collapsedPaths === newState.collapsedPaths && oldState.deltaY === newState.deltaY && oldState.flags === newState.flags && oldState.focus === newState.focus && oldState.icons === newState.icons && oldState.items === newState.items && oldState.listFocused === newState.listFocused && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.loaded === newState.loaded && oldState.maxLineY === newState.maxLineY && oldState.message === newState.message && oldState.minLineY === newState.minLineY && oldState.replacement === newState.replacement && oldState.searchInputErrorMessage === newState.searchInputErrorMessage;
+  return oldState.collapsedPaths === newState.collapsedPaths && oldState.deltaY === newState.deltaY && oldState.flags === newState.flags && oldState.focus === newState.focus && oldState.icons === newState.icons && oldState.items === newState.items && oldState.listFocused === newState.listFocused && oldState.listFocused === newState.listFocused && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.loaded === newState.loaded && oldState.maxLineY === newState.maxLineY && oldState.message === newState.message && oldState.minLineY === newState.minLineY && oldState.replacement === newState.replacement && oldState.searchInputErrorMessage === newState.searchInputErrorMessage;
 };
 
 const diffType$1 = RenderReplaceValue;
@@ -2006,7 +2243,7 @@ const isEqual = (oldState, newState) => {
 const modules = [isEqual$2, isEqual$5, isEqual$3, isEqual$6, isEqual$1, isEqual, isEqual$4];
 const numbers = [diffType$2, diffType$4, diffType$3, diffType$5, diffType$1, diffType, RenderFocusContext];
 
-const diff$1 = (oldState, newState) => {
+const diff = (oldState, newState) => {
   const diffResult = [];
   for (let i = 0; i < modules.length; i++) {
     const fn = modules[i];
@@ -2022,7 +2259,7 @@ const diff2 = uid => {
     oldState,
     newState
   } = get$1(uid);
-  const diffResult = diff$1(oldState, newState);
+  const diffResult = diff(oldState, newState);
   return diffResult;
 };
 
@@ -2233,7 +2470,7 @@ const getStatusMessage = (resultCount, fileResultCount) => {
 const getSetSize = (items, index) => {
   let setSize = 0;
   for (let i = index + 1; i < items.length; i++) {
-    if (items[i].type === File$1) {
+    if (items[i].type === File) {
       break;
     }
     setSize++;
@@ -2252,7 +2489,7 @@ const getRemoveIndicesFile = (items, item, index, matchCount, fileCount) => {
 };
 const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
   for (let i = index; i >= 0; i--) {
-    if (items[i].type === File$1) {
+    if (items[i].type === File) {
       const setSize = getSetSize(items, i);
       if (setSize === 1) {
         return {
@@ -2277,7 +2514,7 @@ const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
 const getRemoveIndices = (items, index, matchCount, fileCount) => {
   const item = items[index];
   switch (item.type) {
-    case File$1:
+    case File:
       return getRemoveIndicesFile(items, item, index, matchCount, fileCount);
     case Match:
       return getRemoveIndicesMatch(items, index, matchCount, fileCount);
@@ -2407,18 +2644,29 @@ const getNextFocus = (focus, flags) => {
     case FocusSearchExcludeInput:
       return FocusIgnoreFiles;
     case FocusToggleDetails:
-      return FocusSearchIncludeInput;
+      if (flags & DetailsExpanded) {
+        return FocusSearchIncludeInput;
+      }
+      return FocusSearchResults;
+    case FocusIgnoreFiles:
+      return FocusSearchResults;
     default:
       return focus;
   }
 };
 
 const focusNextInput = state => {
-  const nextFocus = getNextFocus(state.focus, state.flags);
+  const {
+    focus,
+    flags
+  } = state;
+  const nextFocus = getNextFocus(focus, flags);
+  const isListFocus = nextFocus === FocusSearchResults;
   return {
     ...state,
     focus: nextFocus,
-    focusSource: Script
+    focusSource: Script,
+    listFocused: isListFocus
   };
 };
 
@@ -2567,6 +2815,23 @@ const getKeyBindings = () => {
   return [...getSearchHeaderKeyBindings(), ...getSearchResultKeyBindings()];
 };
 
+const getMenuEntryIds = () => {
+  return [Search$1];
+};
+const getMenuEntries = () => {
+  return [{
+    id: 'dismiss',
+    label: 'dismiss',
+    flags: None$1,
+    command: /* TODO */''
+  }, {
+    id: 'copyPath',
+    label: 'copyPath',
+    flags: None$1,
+    command: /* TODO */''
+  }];
+};
+
 const handleError = error => {
   console.error(`[text-search-worker] ${error}`);
 };
@@ -2616,10 +2881,10 @@ const getFileName$1 = text => {
 const getFileIcons = async matches => {
   const requests = [];
   for (const item of matches) {
-    if (item.type === File$1) {
+    if (item.type === File) {
       const fileName = getFileName$1(item.text);
       requests.push({
-        type: File,
+        type: File$1,
         name: fileName,
         path: `/${fileName}`
       });
@@ -2651,7 +2916,7 @@ const getTextSearchResultCounts = results => {
   let fileCount = 0;
   for (const result of results) {
     switch (result.type) {
-      case File$1:
+      case File:
         fileCount++;
         break;
       case Match:
@@ -3004,1286 +3269,1151 @@ const applyBulkReplacement = async bulkEdits => {
   await invoke$1('BulkReplacement.applyBulkReplacement', bulkEdits);
 };
 
-const getReplacedMessage = (fileCount, replaceCount, replacement) => {
-  if (replaceCount === 1) {
-    return replacedOneOccurrenceInOneFile(replacement);
-  }
-  if (fileCount === 1) {
-    return replacedManyOccurrencesInOneFile(replaceCount, replacement);
-  }
-  return replacedManyOccurrencesInManyFiles(replaceCount, fileCount, replacement);
-};
-
-const getFileName = text => {
-  // TODO make api stricter so that results always have the same shape
-  if (text.startsWith('./')) {
-    return text.slice(2);
-  }
-  return text;
-};
-
-const getReplaceElements = (items, workspacePath, replacement) => {
-  let element = {
-    uri: '',
-    changes: []
-  };
-  const bulkChanges = [];
-  let changes = [];
-  // TODO simplify code by first matching files with their elements, then creating bulk edits
-  for (const match of items) {
-    const {
-      type,
-      text,
-      lineNumber,
-      end,
-      start
-    } = match;
-    if (type === File$1) {
-      changes = [];
-      const fileName = getFileName(text);
-      const absolutePath = `${workspacePath}/${fileName}`;
-      element = {
-        uri: absolutePath,
-        changes
-      };
-      bulkChanges.push(element);
-    } else {
-      changes.push({
-        text: replacement,
-        startRowIndex: lineNumber - 1,
-        startColumnIndex: start,
-        endRowIndex: lineNumber,
-        endColumnIndex: end
-      });
-    }
-  }
-  return bulkChanges;
-};
-
-const replaceAll = async state => {
-  const {
-    workspacePath,
-    items,
-    replacement,
-    matchCount
-  } = state;
-  const bulkEdits = getReplaceElements(items, workspacePath, replacement);
-  // TODO this function should return an error message if an error occurred during bulk edit
-  await applyBulkReplacement(bulkEdits);
-  const fileCount = bulkEdits.length;
-  const message = getReplacedMessage(fileCount, matchCount, replacement);
-  return {
-    ...state,
-    items: [],
-    listItems: [],
-    minLineY: 0,
-    maxLineY: 0,
-    message
-  };
-};
-
-const toggleDetailsExpanded = state => {
-  if (hasDetailsExpanded(state.flags)) {
-    return collapseDetails(state);
-  }
-  return expandDetails(state);
-};
-
-const toggleSearchFlag = (state, flag) => {
-  return handleUpdate(state, {
-    flags: state.flags ^ flag
-  });
-};
-
-const toggleMatchCase = state => {
-  return toggleSearchFlag(state, MatchCase$2);
-};
-
-const toggleMatchWholeWord = state => {
-  return toggleSearchFlag(state, MatchWholeWord$2);
-};
-
-const toggleOpenEditors = state => {
-  return toggleSearchFlag(state, OpenEditors);
-};
-
-const togglePreserveCase = state => {
-  return toggleSearchFlag(state, PreserveCase$2);
-};
-
-const toggleReplace = state => {
-  return toggleSearchFlag(state, ReplaceExpanded);
-};
-
-const toggleUseIgnoreFiles = state => {
-  return toggleSearchFlag(state, UseIgnoreFiles);
-};
-
-const toggleUseRegularExpression = state => {
-  return toggleSearchFlag(state, UseRegularExpression$2);
-};
-
-const getClickHandler = name => {
-  switch (name) {
-    case MatchCase:
-      return toggleMatchCase;
-    case ToggleReplace:
-      return toggleReplace;
-    case UseRegularExpression:
-      return toggleUseRegularExpression;
-    case ReplaceAll:
-      return replaceAll;
-    case MatchWholeWord:
-      return toggleMatchWholeWord;
-    case PreserveCase:
-      return togglePreserveCase;
-    case ToggleSearchDetails:
-      return toggleDetailsExpanded;
-    case SearchOnlyOpenEditors:
-      return toggleOpenEditors;
-    case UseExcludeSettings:
-      return toggleUseIgnoreFiles;
-    case SearchValue:
-      return focusSearchValue$1;
-    case ReplaceValue:
-      return focusReplaceValue$1;
-    default:
-      return noop;
-  }
-};
-
-const handleHeaderClick = async (state, name) => {
-  const fn = getClickHandler(name);
-  return fn(state);
-};
-
-const handleHeaderContextMenu = async state => {
-  return state;
-};
-
-const handleHeaderFocusIn = state => {
-  return state;
-};
-
-const handleHeaderFocusOut = state => {
-  if (!state.focus) {
-    return state;
-  }
-  return {
-    ...state,
-    focused: false,
-    focus: 0
-  };
-};
-
-const handleIconThemeChange = async state => {
-  const {
-    items,
-    minLineY,
-    maxLineY
-  } = state;
-  const visibleItems = items.slice(minLineY, maxLineY);
-  const icons = await getFileIcons(visibleItems);
-  return {
-    ...state,
-    icons
-  };
-};
-
-const handleIncludeInput = (state, includeValue, inputSource = Script) => {
-  return handleUpdate(state, {
-    includeValue,
-    inputSource
-  });
-};
-
-const handleInput = (state, value, inputSource = Script) => {
-  return handleUpdate(state, {
-    value,
-    inputSource
-  });
-};
-
-const handleReplaceInput = (state, value, inputSource = Script) => {
-  return handleUpdate(state, {
-    replacement: value,
-    inputSource
-  });
-};
-
-const getInputHandler = name => {
-  switch (name) {
-    case SearchValue:
-      return handleInput;
-    case ReplaceValue:
-      return handleReplaceInput;
-    case FilesToExclude:
-      return handleExcludeInput;
-    case FilesToInclude:
-      return handleIncludeInput;
-    default:
-      throw new Error(`unknown input handler: ${name}`);
-  }
-};
-
-const handleInput2 = (state, inputName, value, inputSource = Script) => {
-  const fn = getInputHandler(inputName);
-  return fn(state, value, inputSource);
-};
-
-const handleListBlur = state => {
-  return {
-    ...state,
-    listFocused: false
-  };
-};
-
-const handleSharedInput = (state, name, value, inputSource = Script) => {
-  const fn = getInputHandler(name);
-  return fn(state, value, inputSource);
-};
-
-const launchSearchProcessElectron = async () => {
-  const rpc = await TransferMessagePortRpcParent.create({
-    commandMap: {},
-    send: sendMessagePortToSearchProcess
-  });
-  return rpc;
-};
-
-const launchSearchProcessNode = async () => {
-  const rpc = await WebSocketRpcParent2.create({
-    commandMap: {},
-    // @ts-ignore
-    type: 'search-process'
-  });
-  return rpc;
-};
-
-const initialize = async platform => {
-  if (platform === Electron) {
-    setFactory(launchSearchProcessElectron);
-  } else if (platform === Remote) {
-    setFactory(launchSearchProcessNode);
+const getReplacedMessage = (fileCount, replaceCount, replacement) => {
+  if (replaceCount === 1) {
+    return replacedOneOccurrenceInOneFile(replacement);
   }
-  // TODO
+  if (fileCount === 1) {
+    return replacedManyOccurrencesInOneFile(replaceCount, replacement);
+  }
+  return replacedManyOccurrencesInManyFiles(replaceCount, fileCount, replacement);
 };
 
-// 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
-const getNumberOfVisibleItems = (listHeight, itemHeight) => {
-  return Math.ceil(listHeight / itemHeight) + 1;
-};
-const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
-  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
-  return scrollBarOffset;
-};
-const getScrollBarY = getScrollBarOffset;
-const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
-  const halfScrollBarHeight = scrollBarHeight / 2;
-  if (relativeY <= halfScrollBarHeight) {
-    // clicked at top
-    return {
-      percent: 0,
-      handleOffset: relativeY
-    };
-  }
-  if (relativeY <= height - halfScrollBarHeight) {
-    // clicked in middle
-    return {
-      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
-      handleOffset: halfScrollBarHeight
-    };
+const getFileName = text => {
+  // TODO make api stricter so that results always have the same shape
+  if (text.startsWith('./')) {
+    return text.slice(2);
   }
-  // clicked at bottom
-  return {
-    percent: 1,
-    handleOffset: scrollBarHeight - height + relativeY
-  };
+  return text;
 };
-const focusIndexScrollDown = (state, index, listHeight, itemHeight, itemsLength) => {
-  const {
-    finalDeltaY,
-    height,
-    headerHeight,
-    scrollBarHeight
-  } = state;
-  const newMaxLineY = Math.min(index + 1, itemsLength);
-  const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
-  const newMinLineY = Math.max(newMaxLineY - fittingItems, 0);
-  const newDeltaY = itemsLength < fittingItems ? 0 : newMinLineY * itemHeight - listHeight % itemHeight + itemHeight;
-  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
-  return {
-    ...state,
-    focusedIndex: index,
-    minLineY: newMinLineY,
-    maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY,
-    scrollBarY
+
+const getReplaceElements = (items, workspacePath, replacement) => {
+  let element = {
+    uri: '',
+    changes: []
   };
+  const bulkChanges = [];
+  let changes = [];
+  // TODO simplify code by first matching files with their elements, then creating bulk edits
+  for (const match of items) {
+    const {
+      type,
+      text,
+      lineNumber,
+      end,
+      start
+    } = match;
+    if (type === File) {
+      changes = [];
+      const fileName = getFileName(text);
+      const absolutePath = `${workspacePath}/${fileName}`;
+      element = {
+        uri: absolutePath,
+        changes
+      };
+      bulkChanges.push(element);
+    } else {
+      changes.push({
+        text: replacement,
+        startRowIndex: lineNumber - 1,
+        startColumnIndex: start,
+        endRowIndex: lineNumber,
+        endColumnIndex: end
+      });
+    }
+  }
+  return bulkChanges;
 };
-const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) => {
+
+const replaceAll = async state => {
   const {
-    finalDeltaY,
-    height,
-    headerHeight,
-    scrollBarHeight
+    workspacePath,
+    items,
+    replacement,
+    matchCount
   } = state;
-  const newMinLineY = index;
-  const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
-  const newMaxLineY = Math.min(newMinLineY + fittingItems, itemsLength);
-  const newDeltaY = newMinLineY * itemHeight;
-  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
+  const bulkEdits = getReplaceElements(items, workspacePath, replacement);
+  // TODO this function should return an error message if an error occurred during bulk edit
+  await applyBulkReplacement(bulkEdits);
+  const fileCount = bulkEdits.length;
+  const message = getReplacedMessage(fileCount, matchCount, replacement);
   return {
     ...state,
-    focusedIndex: index,
-    minLineY: newMinLineY,
-    maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY,
-    scrollBarY
+    items: [],
+    listItems: [],
+    minLineY: 0,
+    maxLineY: 0,
+    message
   };
 };
-const focusIndex = (state, index) => {
-  const {
-    itemHeight,
-    minLineY,
-    maxLineY,
-    headerHeight,
-    height,
-    items
-  } = state;
-  const itemsLength = items.length;
-  if (itemsLength === 0) {
-    return state;
-  }
-  number(itemHeight);
-  if (index === -1) {
-    return {
-      ...state,
-      focusedIndex: -1,
-      focused: true
-    };
-  }
-  const listHeight = height - headerHeight;
-  if (index < minLineY + 1) {
-    return focusIndexScrollUp(state, index, listHeight, itemHeight, itemsLength);
-  }
-  if (index >= maxLineY - 1) {
-    return focusIndexScrollDown(state, index, listHeight, itemHeight, itemsLength);
+
+const toggleDetailsExpanded = state => {
+  if (hasDetailsExpanded(state.flags)) {
+    return collapseDetails(state);
   }
-  return {
-    ...state,
-    focusedIndex: index,
-    focused: true
-  };
+  return expandDetails(state);
 };
-const first = () => {
-  return 0;
+
+const toggleSearchFlag = (state, flag) => {
+  return handleUpdate(state, {
+    flags: state.flags ^ flag
+  });
 };
-const last = items => {
-  return items.length - 1;
+
+const toggleMatchCase = state => {
+  return toggleSearchFlag(state, MatchCase$2);
 };
-const next = (items, index) => {
-  return (index + 1) % items.length;
+
+const toggleMatchWholeWord = state => {
+  return toggleSearchFlag(state, MatchWholeWord$2);
 };
-const previous = (items, index) => {
-  return index === 0 ? items.length - 1 : index - 1;
+
+const toggleOpenEditors = state => {
+  return toggleSearchFlag(state, OpenEditors);
 };
-const focusFirst = state => {
-  const firstIndex = first();
-  return focusIndex(state, firstIndex);
+
+const togglePreserveCase = state => {
+  return toggleSearchFlag(state, PreserveCase$2);
 };
-const focusLast = state => {
-  const {
-    items
-  } = state;
-  const lastIndex = last(items);
-  return focusIndex(state, lastIndex);
+
+const toggleReplace = state => {
+  return toggleSearchFlag(state, ReplaceExpanded);
 };
-const focusNext = state => {
-  const {
-    focusedIndex,
-    items
-  } = state;
-  const nextIndex = next(items, focusedIndex);
-  return focusIndex(state, nextIndex);
+
+const toggleUseIgnoreFiles = state => {
+  return toggleSearchFlag(state, UseIgnoreFiles);
 };
 
-// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
+const toggleUseRegularExpression = state => {
+  return toggleSearchFlag(state, UseRegularExpression$2);
+};
 
-const isLastIndex = (array, index) => {
-  return index === array.length - 1;
+const getClickHandler = name => {
+  switch (name) {
+    case MatchCase:
+      return toggleMatchCase;
+    case ToggleReplace:
+      return toggleReplace;
+    case UseRegularExpression:
+      return toggleUseRegularExpression;
+    case ReplaceAll:
+      return replaceAll;
+    case MatchWholeWord:
+      return toggleMatchWholeWord;
+    case PreserveCase:
+      return togglePreserveCase;
+    case ToggleSearchDetails:
+      return toggleDetailsExpanded;
+    case SearchOnlyOpenEditors:
+      return toggleOpenEditors;
+    case UseExcludeSettings:
+      return toggleUseIgnoreFiles;
+    case SearchValue:
+      return focusSearchValue$1;
+    case ReplaceValue:
+      return focusReplaceValue$1;
+    default:
+      return noop;
+  }
+};
+
+const handleHeaderClick = async (state, name) => {
+  const fn = getClickHandler(name);
+  return fn(state);
 };
-const lastIndex = array => {
-  return array.length - 1;
+
+const handleHeaderContextMenu = async state => {
+  return state;
 };
-const focusNextPage = state => {
-  const {
-    focusedIndex,
-    items,
-    maxLineY,
-    minLineY
-  } = state;
-  if (isLastIndex(items, focusedIndex)) {
-    return state;
-  }
-  const indexNextPage = Math.min(maxLineY + (maxLineY - minLineY) - 2, lastIndex(items));
-  return focusIndex(state, indexNextPage);
+
+const handleHeaderFocusIn = state => {
+  return state;
 };
-const focusPrevious = state => {
-  const {
-    focusedIndex,
-    items
-  } = state;
-  if (focusedIndex === 0 || focusedIndex === -1) {
+
+const handleHeaderFocusOut = state => {
+  if (!state.focus) {
     return state;
   }
-  const previousIndex = previous(items, focusedIndex);
-  return focusIndex(state, previousIndex);
+  return {
+    ...state,
+    focused: false,
+    focus: 0
+  };
 };
-const focusPreviousPage = state => {
+
+const handleIconThemeChange = async state => {
   const {
-    focusedIndex,
+    items,
     minLineY,
     maxLineY
   } = state;
-  if (focusedIndex === 0 || focusedIndex === -1) {
-    return state;
-  }
-  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
-  return focusIndex(state, indexPreviousPage);
-};
-const handleScrollBarCaptureLost = state => {
+  const visibleItems = items.slice(minLineY, maxLineY);
+  const icons = await getFileIcons(visibleItems);
   return {
     ...state,
-    scrollBarActive: false
+    icons
   };
 };
-const clamp = (num, min, max) => {
-  return Math.min(Math.max(num, min), max);
-};
-const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
-  if (size >= contentSize) {
-    return 0;
-  }
-  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
+
+const handleIncludeInput = (state, includeValue, inputSource = Script) => {
+  return handleUpdate(state, {
+    includeValue,
+    inputSource
+  });
 };
-const setDeltaY = (state, value) => {
-  object(state);
-  number(value);
-  const {
-    itemHeight,
-    finalDeltaY,
-    deltaY,
-    height,
-    headerHeight,
-    items,
-    minimumSliderSize
-  } = state;
-  const listHeight = height - headerHeight;
-  const newDeltaY = clamp(value, 0, finalDeltaY);
-  if (deltaY === newDeltaY) {
-    return state;
-  }
-  // TODO when it only moves by one px, extensions don't need to be rerendered, only negative margin
-  const minLineY = Math.floor(newDeltaY / itemHeight);
-  const maxLineY = Math.min(minLineY + getNumberOfVisibleItems(listHeight, itemHeight), items.length);
-  // TODO update icons
 
-  const total = items.length;
-  const contentHeight = total * itemHeight;
-  const scrollBarHeight = getScrollBarSize(listHeight, contentHeight, minimumSliderSize);
-  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
-  return {
-    ...state,
-    deltaY: newDeltaY,
-    minLineY,
-    maxLineY,
-    scrollBarY
-  };
+const handleInput = (state, value, inputSource = Script) => {
+  return handleUpdate(state, {
+    value,
+    inputSource
+  });
 };
-const handleScrollBarClick = (state, eventY) => {
-  const {
-    y,
-    deltaY,
-    headerHeight,
-    finalDeltaY,
-    scrollBarHeight,
-    height
-  } = state;
-  const contentHeight = height - headerHeight;
-  const relativeY = eventY - y - headerHeight;
-  const currentScrollBarY = getScrollBarY(deltaY, finalDeltaY, contentHeight, scrollBarHeight);
-  const diff = relativeY - currentScrollBarY;
-  if (diff >= 0 && diff < scrollBarHeight) {
-    return {
-      ...state,
-      handleOffset: diff,
-      scrollBarActive: true
-    };
-  }
-  const {
-    percent,
-    handleOffset
-  } = getNewDeltaPercent(contentHeight, scrollBarHeight, relativeY);
-  const newDeltaY = percent * finalDeltaY;
-  return {
-    ...setDeltaY(state, newDeltaY),
-    handleOffset,
-    scrollBarActive: true
-  };
+
+const handleReplaceInput = (state, value, inputSource = Script) => {
+  return handleUpdate(state, {
+    replacement: value,
+    inputSource
+  });
 };
-const getNewPercent = (contentHeight, scrollBarHeight, relativeY) => {
-  if (relativeY <= contentHeight - scrollBarHeight / 2) {
-    // clicked in middle
-    return relativeY / (contentHeight - scrollBarHeight);
+
+const getInputHandler = name => {
+  switch (name) {
+    case SearchValue:
+      return handleInput;
+    case ReplaceValue:
+      return handleReplaceInput;
+    case FilesToExclude:
+      return handleExcludeInput;
+    case FilesToInclude:
+      return handleIncludeInput;
+    default:
+      throw new Error(`unknown input handler: ${name}`);
   }
-  // clicked at bottom
-  return 1;
 };
-const handleScrollBarMove = (state, eventY) => {
-  const {
-    y,
-    headerHeight,
-    handleOffset,
-    finalDeltaY,
-    height,
-    scrollBarHeight
-  } = state;
-  const relativeY = eventY - y - headerHeight - handleOffset;
-  const contentHeight = height - headerHeight;
-  const newPercent = getNewPercent(contentHeight, scrollBarHeight, relativeY);
-  const newDeltaY = newPercent * finalDeltaY;
-  return setDeltaY(state, newDeltaY);
-};
-const handleWheel = (state, deltaMode, deltaY) => {
-  number(deltaMode);
-  number(deltaY);
-  return setDeltaY(state, state.deltaY + deltaY);
+
+const handleInput2 = (state, inputName, value, inputSource = Script) => {
+  const fn = getInputHandler(inputName);
+  return fn(state, value, inputSource);
 };
 
-const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight, topHeight, itemCount) => {
-  const relativeY = eventY - y - topHeight + deltaY;
-  const index = Math.floor(relativeY / itemHeight);
-  if (index < 0 || index >= itemCount) {
-    return -1;
-  }
-  return index;
+const handleInputBlur = async (state, name) => {
+  return state;
 };
 
-const getTopHeight = flags => {
-  if (flags & ReplaceExpanded && flags & DetailsExpanded) {
-    return 190;
-  }
-  if (flags & DetailsExpanded) {
-    return 158;
-  }
-  if (flags & ReplaceExpanded) {
-    return 93;
+const getSearchFocusKey = key => {
+  switch (key) {
+    case SearchValue:
+      return FocusSearchInput;
+    case ReplaceValue:
+      return FocusSearchReplaceInput;
+    case MatchCase:
+      return FocusSearchMatchCase;
+    case MatchWholeWord:
+      return FocusSearchWholeWord;
+    case UseRegularExpression:
+      return FocusSearchRegex;
+    case ReplaceAll:
+      return FocusSearchReplaceAll;
+    case PreserveCase:
+      return FocusSearchPreserveCase;
+    case ToggleSearchDetails:
+      return FocusToggleDetails;
+    case FilesToInclude:
+      return FocusSearchIncludeInput;
+    case FilesToExclude:
+      return FocusSearchExcludeInput;
+    case SearchOnlyOpenEditors:
+      return FocusSearchOpenEditors;
+    case UseExcludeSettings:
+      return FocusIgnoreFiles;
+    case ToggleReplace:
+      return FocusToggleReplace;
+    default:
+      return Empty;
   }
-  return 61;
 };
 
-const getFilteredResults = (results, collapsedPaths) => {
-  if (collapsedPaths.length === 0) {
-    return results;
-  }
-  const filteredResults = [];
-  let isExcluded = false;
-  for (const result of results) {
-    if (result.type === File$1) {
-      filteredResults.push(result);
-      isExcluded = collapsedPaths.includes(result.text) ? true : false;
-    }
-    if (result.type === Match && !isExcluded) {
-      filteredResults.push(result);
-    }
-  }
-  return filteredResults;
+const handleInputFocus = (state, name) => {
+  const key = getSearchFocusKey(name);
+  return {
+    ...state,
+    listFocused: false,
+    focus: key,
+    focused: true
+  };
 };
 
-const toggleCollapsedPath = (collapsedPaths, path) => {
-  if (collapsedPaths.includes(path)) {
-    const index = collapsedPaths.indexOf(path);
-    return collapsedPaths.toSpliced(index, 1);
-  }
-  return [...collapsedPaths, path];
+const handleListBlur = state => {
+  return {
+    ...state,
+    listFocused: false
+  };
 };
 
-const selectIndexFile = async (state, searchResult, index) => {
+const handleListFocus = async state => {
   const {
-    collapsedPaths,
-    items,
-    itemHeight,
-    headerHeight,
-    height
+    listFocused
   } = state;
-  const path = searchResult.text;
-  const newCollapsedPaths = toggleCollapsedPath(collapsedPaths, path);
-  const filteredResults = getFilteredResults(items, newCollapsedPaths);
-  const icons = await getFileIcons(filteredResults);
-  const total = filteredResults.length;
-  const listHeight = height - headerHeight;
-  const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
-  const maxLineY = Math.min(numberOfVisible, total);
+  if (listFocused) {
+    return state;
+  }
   return {
     ...state,
-    collapsedPaths: newCollapsedPaths,
-    listFocusedIndex: index,
-    listFocused: true,
-    listItems: filteredResults,
-    maxLineY,
-    icons,
-    focus: FocusSearchResults,
-    focusSource: Script
+    listFocused: true
   };
 };
 
-const getFileIndex = (items, index) => {
-  for (let i = index; i >= 0; i--) {
-    const item = items[i];
-    if (item.type === File$1) {
-      return i;
-    }
-  }
-  return -1;
+const handleSharedInput = (state, name, value, inputSource = Script) => {
+  const fn = getInputHandler(name);
+  return fn(state, value, inputSource);
 };
 
-const openUri = async (path, focus = true, props = {}) => {
-  await openUri$1(path, focus, props);
+const launchSearchProcessElectron = async () => {
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: {},
+    send: sendMessagePortToSearchProcess
+  });
+  return rpc;
 };
 
-// TODO this should be in FileSystem module
-const pathBaseName = path => {
-  return path.slice(path.lastIndexOf('/') + 1);
+const launchSearchProcessNode = async () => {
+  const rpc = await WebSocketRpcParent2.create({
+    commandMap: {},
+    // @ts-ignore
+    type: 'search-process'
+  });
+  return rpc;
 };
-const getRelativePath = relativePath => {
-  if (relativePath.startsWith('./')) {
-    return `/${relativePath.slice(2)}`; // TODO support windows paths
+
+const initialize = async platform => {
+  if (platform === Electron) {
+    setFactory(launchSearchProcessElectron);
+  } else if (platform === Remote) {
+    setFactory(launchSearchProcessNode);
   }
-  return `/${relativePath}`; // TODO support windows paths
+  // TODO
 };
 
-const selectIndexPreview = async (state, searchResult, index) => {
+// 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
+const getNumberOfVisibleItems = (listHeight, itemHeight) => {
+  return Math.ceil(listHeight / itemHeight) + 1;
+};
+const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
+  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
+  return scrollBarOffset;
+};
+const getScrollBarY = getScrollBarOffset;
+const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
+  const halfScrollBarHeight = scrollBarHeight / 2;
+  if (relativeY <= halfScrollBarHeight) {
+    // clicked at top
+    return {
+      percent: 0,
+      handleOffset: relativeY
+    };
+  }
+  if (relativeY <= height - halfScrollBarHeight) {
+    // clicked in middle
+    return {
+      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
+      handleOffset: halfScrollBarHeight
+    };
+  }
+  // clicked at bottom
+  return {
+    percent: 1,
+    handleOffset: scrollBarHeight - height + relativeY
+  };
+};
+const focusIndexScrollDown = (state, index, listHeight, itemHeight, itemsLength) => {
   const {
-    items,
-    workspacePath
+    finalDeltaY,
+    height,
+    headerHeight,
+    scrollBarHeight
   } = state;
-  const fileIndex = getFileIndex(items, index);
-  if (fileIndex === -1) {
-    throw new Error('Search result is missing file');
-  }
+  const newMaxLineY = Math.min(index + 1, itemsLength);
+  const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
+  const newMinLineY = Math.max(newMaxLineY - fittingItems, 0);
+  const newDeltaY = itemsLength < fittingItems ? 0 : newMinLineY * itemHeight - listHeight % itemHeight + itemHeight;
+  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
+  return {
+    ...state,
+    focusedIndex: index,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    focused: true,
+    deltaY: newDeltaY,
+    scrollBarY
+  };
+};
+const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) => {
   const {
-    lineNumber
-  } = searchResult;
-  const fileResult = items[fileIndex];
-  const relativePath = getRelativePath(fileResult.text);
-  const absolutePath = `${workspacePath}${relativePath}`;
-  await openUri(absolutePath, true, {
-    selections: new Uint32Array([lineNumber, 0, lineNumber, 0])
-  });
+    finalDeltaY,
+    height,
+    headerHeight,
+    scrollBarHeight
+  } = state;
+  const newMinLineY = index;
+  const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
+  const newMaxLineY = Math.min(newMinLineY + fittingItems, itemsLength);
+  const newDeltaY = newMinLineY * itemHeight;
+  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
     ...state,
-    listFocusedIndex: index,
-    listFocused: false,
-    focus: FocusSearchResults,
-    focusSource: Script
+    focusedIndex: index,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    focused: true,
+    deltaY: newDeltaY,
+    scrollBarY
   };
 };
-
-const getSelectHandler = type => {
-  switch (type) {
-    case File$1:
-      return selectIndexFile;
-    case Match:
-      return selectIndexPreview;
-    default:
-      throw new Error(`unexpected search result type ${type}`);
+const focusIndex = (state, index) => {
+  const {
+    itemHeight,
+    minLineY,
+    maxLineY,
+    headerHeight,
+    height,
+    items
+  } = state;
+  const itemsLength = items.length;
+  if (itemsLength === 0) {
+    return state;
   }
-};
-
-const selectIndex = async (state, index) => {
+  number(itemHeight);
   if (index === -1) {
     return {
       ...state,
-      listFocused: true,
-      listFocusedIndex: -1
+      focusedIndex: -1,
+      focused: true
     };
   }
+  const listHeight = height - headerHeight;
+  if (index < minLineY + 1) {
+    return focusIndexScrollUp(state, index, listHeight, itemHeight, itemsLength);
+  }
+  if (index >= maxLineY - 1) {
+    return focusIndexScrollDown(state, index, listHeight, itemHeight, itemsLength);
+  }
+  return {
+    ...state,
+    focusedIndex: index,
+    focused: true
+  };
+};
+const first = () => {
+  return 0;
+};
+const last = items => {
+  return items.length - 1;
+};
+const next = (items, index) => {
+  return (index + 1) % items.length;
+};
+const previous = (items, index) => {
+  return index === 0 ? items.length - 1 : index - 1;
+};
+const focusFirst = state => {
+  const firstIndex = first();
+  return focusIndex(state, firstIndex);
+};
+const focusLast = state => {
   const {
-    listItems
+    items
   } = state;
-  const searchResult = listItems[index];
-  const fn = getSelectHandler(searchResult.type);
-  return fn(state, searchResult, index);
+  const lastIndex = last(items);
+  return focusIndex(state, lastIndex);
 };
-
-const handleClickAt = async (state, eventX, eventY) => {
+const focusNext = state => {
   const {
-    x,
-    y,
-    itemHeight,
-    deltaY,
-    flags,
-    listItems
+    focusedIndex,
+    items
   } = state;
-  const topHeight = getTopHeight(flags);
-  const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, topHeight, listItems.length);
-  return selectIndex(state, index);
+  const nextIndex = next(items, focusedIndex);
+  return focusIndex(state, nextIndex);
 };
 
-const isString = value => {
-  return typeof value === 'string';
+// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
+
+const isLastIndex = (array, index) => {
+  return index === array.length - 1;
 };
-const getSavedHistory = savedState => {
-  if (savedState && typeof savedState === 'object' && 'history' in savedState && Array.isArray(savedState.history) && savedState.history.every(isString)) {
-    return savedState.history;
+const lastIndex = array => {
+  return array.length - 1;
+};
+const focusNextPage = state => {
+  const {
+    focusedIndex,
+    items,
+    maxLineY,
+    minLineY
+  } = state;
+  if (isLastIndex(items, focusedIndex)) {
+    return state;
   }
-  return [];
+  const indexNextPage = Math.min(maxLineY + (maxLineY - minLineY) - 2, lastIndex(items));
+  return focusIndex(state, indexNextPage);
 };
-
-const getSavedValue = savedState => {
-  if (savedState && typeof savedState === 'object' && 'value' in savedState && typeof savedState.value === 'string') {
-    return savedState.value;
+const focusPrevious = state => {
+  const {
+    focusedIndex,
+    items
+  } = state;
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
   }
-  return '';
+  const previousIndex = previous(items, focusedIndex);
+  return focusIndex(state, previousIndex);
 };
-const getSavedReplacement = savedState => {
-  if (savedState && typeof savedState === 'object' && 'replacement' in savedState && typeof savedState.replacement === 'string') {
-    return savedState.replacement;
+const focusPreviousPage = state => {
+  const {
+    focusedIndex,
+    minLineY,
+    maxLineY
+  } = state;
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
   }
-  return '';
+  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
+  return focusIndex(state, indexPreviousPage);
 };
-const getSavedFlags = savedState => {
-  if (savedState && typeof savedState === 'object' && 'flags' in savedState && typeof savedState.flags === 'number') {
-    return savedState.flags;
-  }
-  return 0;
+const handleScrollBarCaptureLost = state => {
+  return {
+    ...state,
+    scrollBarActive: false
+  };
 };
-const getSavedIncludeValue = savedState => {
-  if (savedState && typeof savedState === 'object' && 'includeValue' in savedState && typeof savedState.includeValue === 'string') {
-    return savedState.includeValue;
-  }
-  return '';
+const clamp = (num, min, max) => {
+  return Math.min(Math.max(num, min), max);
 };
-const getSavedExcludeValue = savedState => {
-  if (savedState && typeof savedState === 'object' && 'excludeValue' in savedState && typeof savedState.excludeValue === 'string') {
-    return savedState.excludeValue;
+const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
+  if (size >= contentSize) {
+    return 0;
   }
-  return '';
+  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
 };
-const getSavedCollapsedPaths = savedState => {
-  if (savedState && typeof savedState === 'object' && 'collapsedPaths' in savedState && Array.isArray(savedState.collapsedPaths) && savedState.collapsedPaths.every(item => typeof item === 'string')) {
-    return savedState.collapsedPaths;
+const setDeltaY = (state, value) => {
+  object(state);
+  number(value);
+  const {
+    itemHeight,
+    finalDeltaY,
+    deltaY,
+    height,
+    headerHeight,
+    items,
+    minimumSliderSize
+  } = state;
+  const listHeight = height - headerHeight;
+  const newDeltaY = clamp(value, 0, finalDeltaY);
+  if (deltaY === newDeltaY) {
+    return state;
   }
-  return [];
-};
+  // TODO when it only moves by one px, extensions don't need to be rerendered, only negative margin
+  const minLineY = Math.floor(newDeltaY / itemHeight);
+  const maxLineY = Math.min(minLineY + getNumberOfVisibleItems(listHeight, itemHeight), items.length);
+  // TODO update icons
 
-const restoreState = savedState => {
+  const total = items.length;
+  const contentHeight = total * itemHeight;
+  const scrollBarHeight = getScrollBarSize(listHeight, contentHeight, minimumSliderSize);
+  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
-    savedValue: getSavedValue(savedState),
-    replacement: getSavedReplacement(savedState),
-    savedCollapsedPaths: getSavedCollapsedPaths(savedState),
-    threads: 1,
-    flags: getSavedFlags(savedState),
-    includeValue: getSavedIncludeValue(savedState),
-    excludeValue: getSavedExcludeValue(savedState),
-    history: getSavedHistory(savedState)
+    ...state,
+    deltaY: newDeltaY,
+    minLineY,
+    maxLineY,
+    scrollBarY
   };
 };
-
-const loadContent = async (state, savedState) => {
+const handleScrollBarClick = (state, eventY) => {
   const {
-    savedValue,
-    savedCollapsedPaths,
-    threads,
-    replacement,
-    flags,
-    includeValue,
-    excludeValue
-  } = restoreState(savedState);
-  if (savedValue) {
-    const result = await handleUpdate(state, {
-      value: savedValue,
-      threads,
-      inputSource: Script,
-      collapsedPaths: savedCollapsedPaths,
-      replacement,
-      flags,
-      includeValue,
-      excludeValue
-    });
+    y,
+    deltaY,
+    headerHeight,
+    finalDeltaY,
+    scrollBarHeight,
+    height
+  } = state;
+  const contentHeight = height - headerHeight;
+  const relativeY = eventY - y - headerHeight;
+  const currentScrollBarY = getScrollBarY(deltaY, finalDeltaY, contentHeight, scrollBarHeight);
+  const diff = relativeY - currentScrollBarY;
+  if (diff >= 0 && diff < scrollBarHeight) {
     return {
-      ...result,
-      loaded: true
+      ...state,
+      handleOffset: diff,
+      scrollBarActive: true
     };
   }
+  const {
+    percent,
+    handleOffset
+  } = getNewDeltaPercent(contentHeight, scrollBarHeight, relativeY);
+  const newDeltaY = percent * finalDeltaY;
   return {
-    ...state,
-    threads,
-    flags,
-    loaded: true
+    ...setDeltaY(state, newDeltaY),
+    handleOffset,
+    scrollBarActive: true
   };
 };
-
-const getNextHistoryData = (history, historyIndex) => {
-  if (historyIndex === -1 || history.length === 0) {
-    return {
-      newValue: '',
-      newHistoryIndex: -1
-    };
+const getNewPercent = (contentHeight, scrollBarHeight, relativeY) => {
+  if (relativeY <= contentHeight - scrollBarHeight / 2) {
+    // clicked in middle
+    return relativeY / (contentHeight - scrollBarHeight);
   }
-  const item = history.at(historyIndex) || '';
-  return {
-    newValue: item,
-    newHistoryIndex: historyIndex + 1
-  };
+  // clicked at bottom
+  return 1;
 };
-
-const nextHistoryResult = async state => {
+const handleScrollBarMove = (state, eventY) => {
   const {
-    history,
-    historyIndex,
-    value
+    y,
+    headerHeight,
+    handleOffset,
+    finalDeltaY,
+    height,
+    scrollBarHeight
   } = state;
-  const {
-    newValue,
-    newHistoryIndex
-  } = getNextHistoryData(history, historyIndex);
-  if (newValue === value) {
-    return state;
-  }
-  return handleUpdate(state, {
-    value: newValue,
-    inputSource: Script,
-    historyIndex: newHistoryIndex
-  });
+  const relativeY = eventY - y - headerHeight - handleOffset;
+  const contentHeight = height - headerHeight;
+  const newPercent = getNewPercent(contentHeight, scrollBarHeight, relativeY);
+  const newDeltaY = newPercent * finalDeltaY;
+  return setDeltaY(state, newDeltaY);
+};
+const handleWheel = (state, deltaMode, deltaY) => {
+  number(deltaMode);
+  number(deltaY);
+  return setDeltaY(state, state.deltaY + deltaY);
 };
 
-const previousHistoryResult = async state => {
-  return {
-    ...state
-  };
+const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight, topHeight, itemCount) => {
+  const relativeY = eventY - y - topHeight + deltaY;
+  const index = Math.floor(relativeY / itemHeight);
+  if (index < 0 || index >= itemCount) {
+    return -1;
+  }
+  return index;
 };
 
-const refresh = state => {
-  return handleUpdate(state, {});
+const getTopHeight = flags => {
+  if (flags & ReplaceExpanded && flags & DetailsExpanded) {
+    return 190;
+  }
+  if (flags & DetailsExpanded) {
+    return 158;
+  }
+  if (flags & ReplaceExpanded) {
+    return 93;
+  }
+  return 61;
 };
 
-const getFocusSelector = focusKey => {
-  switch (focusKey) {
-    case FocusSearchInput:
-      return SearchValue;
-    case FocusSearchReplaceInput:
-      return ReplaceValue;
-    case FocusToggleDetails:
-      return ToggleSearchDetails;
-    case FocusSearchMatchCase:
-      return MatchCase;
-    case FocusSearchPreserveCase:
-      return PreserveCase;
-    case FocusSearchRegex:
-      return UseRegularExpression;
-    case FocusSearchIncludeInput:
-      return FilesToInclude;
-    case FocusSearchExcludeInput:
-      return FilesToExclude;
-    case FocusSearchWholeWord:
-      return MatchWholeWord;
-    case FocusSearchReplaceAll:
-      return ReplaceAll;
-    case FocusSearchOpenEditors:
-      return SearchOnlyOpenEditors;
-    case FocusIgnoreFiles:
-      return UseExcludeSettings;
-    case FocusToggleReplace:
-      return ToggleReplace;
-    default:
-      return '';
+const getFilteredResults = (results, collapsedPaths) => {
+  if (collapsedPaths.length === 0) {
+    return results;
+  }
+  const filteredResults = [];
+  let isExcluded = false;
+  for (const result of results) {
+    if (result.type === File) {
+      filteredResults.push(result);
+      isExcluded = collapsedPaths.includes(result.text) ? true : false;
+    }
+    if (result.type === Match && !isExcluded) {
+      filteredResults.push(result);
+    }
   }
+  return filteredResults;
 };
 
-const renderFocus = (oldState, newState) => {
-  const selector = getFocusSelector(newState.focus);
-  return ['Viewlet.focusElementByName', newState.uid, selector];
+const toggleCollapsedPath = (collapsedPaths, path) => {
+  if (collapsedPaths.includes(path)) {
+    const index = collapsedPaths.indexOf(path);
+    return collapsedPaths.toSpliced(index, 1);
+  }
+  return [...collapsedPaths, path];
 };
 
-const renderFocusContext = (oldState, newState) => {
-  return ['Viewlet.setFocusContext', newState.focus];
+const selectIndexFile = async (state, searchResult, index) => {
+  const {
+    collapsedPaths,
+    items,
+    itemHeight,
+    headerHeight,
+    height
+  } = state;
+  const path = searchResult.text;
+  const newCollapsedPaths = toggleCollapsedPath(collapsedPaths, path);
+  const filteredResults = getFilteredResults(items, newCollapsedPaths);
+  const icons = await getFileIcons(filteredResults);
+  const total = filteredResults.length;
+  const listHeight = height - headerHeight;
+  const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
+  const maxLineY = Math.min(numberOfVisible, total);
+  return {
+    ...state,
+    collapsedPaths: newCollapsedPaths,
+    listFocusedIndex: index,
+    listFocused: true,
+    listItems: filteredResults,
+    maxLineY,
+    icons,
+    focus: FocusSearchResults,
+    focusSource: Script
+  };
 };
 
-const None = 0;
-const Collapsed = 1;
-const Expanded = 2;
-
-const getMatchCount = (results, startIndex) => {
-  for (let i = startIndex + 1; i < results.length; i++) {
-    const result = results[i];
-    if (result.type === File$1) {
-      return i - startIndex - 1;
+const getFileIndex = (items, index) => {
+  for (let i = index; i >= 0; i--) {
+    const item = items[i];
+    if (item.type === File) {
+      return i;
     }
   }
-  return results.length - startIndex - 1;
+  return -1;
 };
 
-const getSearchDisplayResultFile = (results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, originalResults) => {
-  const path = text;
-  const absolutePath = getRelativePath(path);
-  const baseName = pathBaseName(path);
-  const index = originalResults.indexOf(results[i]);
-  const matchCount = getMatchCount(results, index);
-  const expanded = collapsedPaths.includes(path) ? Collapsed : Expanded;
-  const badgeText = `${matchCount}`;
-  return {
-    badgeText,
-    depth: 0,
-    expanded,
-    focused,
-    icon: fileIcons[relativeIndex],
-    matchLength: 0,
-    matchStart: 0,
-    posInSet,
-    replacement: '',
-    setSize,
-    text: baseName,
-    title: absolutePath
-  };
+const openUri = async (path, focus = true, props = {}) => {
+  await openUri$1(path, focus, props);
 };
 
-const getDisplayResultMatch = (setSize, searchTermLength, replacement, text, posInSet, start, focused) => {
+// TODO this should be in FileSystem module
+const pathBaseName = path => {
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+const getRelativePath = relativePath => {
+  if (relativePath.startsWith('./')) {
+    return `/${relativePath.slice(2)}`; // TODO support windows paths
+  }
+  return `/${relativePath}`; // TODO support windows paths
+};
+
+const selectIndexPreview = async (state, searchResult, index) => {
+  const {
+    items,
+    workspacePath
+  } = state;
+  const fileIndex = getFileIndex(items, index);
+  if (fileIndex === -1) {
+    throw new Error('Search result is missing file');
+  }
+  const {
+    lineNumber
+  } = searchResult;
+  const fileResult = items[fileIndex];
+  const relativePath = getRelativePath(fileResult.text);
+  const absolutePath = `${workspacePath}${relativePath}`;
+  await openUri(absolutePath, true, {
+    selections: new Uint32Array([lineNumber, 0, lineNumber, 0])
+  });
   return {
-    badgeText: '',
-    depth: 1,
-    expanded: None,
-    focused,
-    icon: '',
-    matchLength: searchTermLength,
-    matchStart: start,
-    posInSet,
-    replacement,
-    setSize,
-    text: text,
-    title: text.trim()
+    ...state,
+    listFocusedIndex: index,
+    listFocused: false,
+    focus: FocusSearchResults,
+    focusSource: Script
   };
 };
 
-const getDisplayResult = (results, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, minLineY, originalResults) => {
-  const result = results[i];
-  const {
-    type,
-    text,
-    start
-  } = result;
-  const posInSet = i + 1;
-  const focused = i === focusedIndex;
-  const relativeIndex = i - minLineY;
+const getSelectHandler = type => {
   switch (type) {
-    case File$1:
-      return getSearchDisplayResultFile(results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, originalResults);
+    case File:
+      return selectIndexFile;
     case Match:
-      return getDisplayResultMatch(setSize, searchTermLength, replacement, text, posInSet, start, focused);
+      return selectIndexPreview;
     default:
-      throw new Error('unexpected search result type');
+      throw new Error(`unexpected search result type ${type}`);
   }
 };
 
-const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, fileIcons, focusedIndex, collapsedPaths, originalResults) => {
-  const displayResults = [];
-  const setSize = resultCount;
-  const searchTermLength = searchTerm.length;
-  for (let i = minLineY; i < maxLineY; i++) {
-    const displayResult = getDisplayResult(results, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, minLineY, originalResults);
-    displayResults.push(displayResult);
+const selectIndex = async (state, index) => {
+  if (index === -1) {
+    return {
+      ...state,
+      listFocused: true,
+      listFocusedIndex: -1
+    };
   }
-  return displayResults;
+  const {
+    listItems
+  } = state;
+  const searchResult = listItems[index];
+  const fn = getSelectHandler(searchResult.type);
+  return fn(state, searchResult, index);
 };
 
-const createViewModel = state => {
-  // TODO add viewmodel to state, not needing to have separate states and making it easier to compare
-  // visible items in diff
+const handleClickAt = async (state, eventX, eventY) => {
   const {
-    listItems,
+    x,
+    y,
     itemHeight,
-    fileCount,
-    value,
-    minLineY,
-    maxLineY,
-    replacement,
-    icons,
-    listFocusedIndex,
-    collapsedPaths,
-    items,
-    listFocused,
     deltaY,
-    finalDeltaY,
-    height,
-    headerHeight,
     flags,
-    message,
-    searchInputErrorMessage,
-    scrollBarHeight,
-    matchCount,
-    focus
+    listItems
   } = state;
-  const displayResults = getDisplayResults(listItems, itemHeight, fileCount, value, minLineY, maxLineY, replacement, icons, listFocusedIndex, collapsedPaths, items);
-  const focusOutline = listFocused && listFocusedIndex === -1;
-  const scrollBarValue = deltaY / finalDeltaY * 100;
-  const scrollBarY = getScrollBarY$1(deltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
+  const topHeight = getTopHeight(flags);
+  const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, topHeight, listItems.length);
+  return selectIndex(state, index);
+};
+
+const handleListPointerDown = async (state, button) => {
+  if (button !== LeftClick) {
+    return state;
+  }
   return {
-    displayResults,
-    flags,
-    message,
-    focusOutline,
-    searchInputErrorMessage,
-    scrollBarHeight,
-    scrollBarY,
-    scrollBarValue,
-    deltaY,
-    itemHeight,
-    matchCount,
-    focus
+    ...state,
+    listFocused: true
   };
 };
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
+
+const getSavedFocus = savedState => {
+  if (savedState && typeof savedState === 'object' && 'focus' in savedState && typeof savedState.focus === 'number') {
+    return savedState.focus;
+  }
+  return 0;
+};
+const getSavedListFocus = savedState => {
+  if (savedState && typeof savedState === 'object' && 'listFocused' in savedState && typeof savedState.listFocused === 'boolean') {
+    return savedState.listFocused;
+  }
+  return false;
+};
+
+const isString = value => {
+  return typeof value === 'string';
+};
+const getSavedHistory = savedState => {
+  if (savedState && typeof savedState === 'object' && 'history' in savedState && Array.isArray(savedState.history) && savedState.history.every(isString)) {
+    return savedState.history;
+  }
+  return [];
+};
+
+const getSavedValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'value' in savedState && typeof savedState.value === 'string') {
+    return savedState.value;
+  }
+  return '';
+};
+const getSavedReplacement = savedState => {
+  if (savedState && typeof savedState === 'object' && 'replacement' in savedState && typeof savedState.replacement === 'string') {
+    return savedState.replacement;
+  }
+  return '';
+};
+const getSavedFlags = savedState => {
+  if (savedState && typeof savedState === 'object' && 'flags' in savedState && typeof savedState.flags === 'number') {
+    return savedState.flags;
+  }
+  return 0;
+};
+const getSavedIncludeValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'includeValue' in savedState && typeof savedState.includeValue === 'string') {
+    return savedState.includeValue;
+  }
+  return '';
+};
+const getSavedExcludeValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'excludeValue' in savedState && typeof savedState.excludeValue === 'string') {
+    return savedState.excludeValue;
+  }
+  return '';
+};
+const getSavedCollapsedPaths = savedState => {
+  if (savedState && typeof savedState === 'object' && 'collapsedPaths' in savedState && Array.isArray(savedState.collapsedPaths) && savedState.collapsedPaths.every(item => typeof item === 'string')) {
+    return savedState.collapsedPaths;
+  }
+  return [];
 };
 
-const text = data => {
+const restoreState = savedState => {
   return {
-    type: Text,
-    text: data,
-    childCount: 0
+    savedValue: getSavedValue(savedState),
+    replacement: getSavedReplacement(savedState),
+    savedCollapsedPaths: getSavedCollapsedPaths(savedState),
+    threads: 1,
+    flags: getSavedFlags(savedState),
+    includeValue: getSavedIncludeValue(savedState),
+    excludeValue: getSavedExcludeValue(savedState),
+    history: getSavedHistory(savedState),
+    focus: getSavedFocus(savedState),
+    listFocused: getSavedListFocus(savedState)
   };
 };
 
-const SetText = 1;
-const SetAttribute = 3;
-const RemoveAttribute = 4;
-const Add = 6;
-const NavigateChild = 7;
-const NavigateParent = 8;
-const RemoveChild = 9;
-const NavigateSibling = 10;
-
-const applyPendingPatches = (patches, pendingPatches, skip) => {
-  for (let k = 0; k < pendingPatches.length - skip; k += 2) {
-    const type = pendingPatches[k];
-    const index = pendingPatches[k + 1];
-    if (type === NavigateParent) {
-      patches.push({
-        type
-      });
-    } else {
-      patches.push({
-        type,
-        index
-      });
-    }
+const loadContent = async (state, savedState) => {
+  const {
+    savedValue,
+    savedCollapsedPaths,
+    threads,
+    replacement,
+    flags,
+    includeValue,
+    excludeValue
+  } = restoreState(savedState);
+  const update = {
+    value: savedValue,
+    threads,
+    inputSource: Script,
+    collapsedPaths: savedCollapsedPaths,
+    replacement,
+    flags,
+    includeValue,
+    excludeValue,
+    focus: 0 // TODO
+  };
+  if (savedValue) {
+    const result = await handleUpdate(state, update);
+    return {
+      ...result,
+      loaded: true
+    };
   }
-  pendingPatches.length = 0;
-};
-
-const isKey = key => {
-  return key !== 'type' && key !== 'childCount';
-};
-
-const getKeys = node => {
-  const keys = Object.keys(node).filter(isKey);
-  return keys;
+  return {
+    ...state,
+    ...update,
+    threads,
+    flags,
+    loaded: true
+  };
 };
 
-const getTotalChildCount = (nodes, index) => {
-  let i = index;
-  let pending = 1;
-  while (pending) {
-    const node = nodes[i];
-    pending += node.childCount;
-    pending--;
-    i++;
+const getNextHistoryData = (history, historyIndex) => {
+  if (historyIndex === -1 || history.length === 0) {
+    return {
+      newValue: '',
+      newHistoryIndex: -1
+    };
   }
-  return i - index;
+  const item = history.at(historyIndex) || '';
+  return {
+    newValue: item,
+    newHistoryIndex: historyIndex + 1
+  };
 };
 
-const diff = (oldNodes, newNodes) => {
-  const patches = [];
-  const pendingPatches = [];
-  let i = 0;
-  let j = 0;
-  let siblingOffset = 0;
-  let maxSiblingOffset = 1;
-  const indexStack = [0, 1];
-  while (i < oldNodes.length && j < newNodes.length) {
-    const oldNode = oldNodes[i];
-    const newNode = newNodes[j];
-    // TODO maybe don't have the current element in indexstack
-    if (siblingOffset === maxSiblingOffset) {
-      indexStack.pop();
-      indexStack.pop();
-      pendingPatches.push(NavigateParent, 0);
-      maxSiblingOffset = indexStack.pop();
-      siblingOffset = indexStack.pop() + 1;
-    }
-    while (siblingOffset === maxSiblingOffset) {
-      pendingPatches.push(NavigateParent, 0);
-      maxSiblingOffset = indexStack.pop();
-      siblingOffset = indexStack.pop() + 1;
-    }
-    if (oldNode.type !== newNode.type) {
-      let skip = 0;
-      if (pendingPatches.length > 0 && pendingPatches.at(-2) === NavigateChild) {
-        skip = 2;
-      }
-      applyPendingPatches(patches, pendingPatches, skip);
-      const oldTotal = getTotalChildCount(oldNodes, i);
-      const newTotal = getTotalChildCount(newNodes, j);
-      patches.push({
-        type: RemoveChild,
-        index: siblingOffset
-      });
-      patches.push({
-        type: Add,
-        nodes: newNodes.slice(j, j + newTotal)
-      });
-      siblingOffset++;
-      i += oldTotal;
-      j += newTotal;
-      continue;
-    }
-    if (oldNode.type === Text && newNode.type === Text) {
-      if (oldNode.text !== newNode.text) {
-        if (siblingOffset !== 0) {
-          pendingPatches.push(NavigateSibling, siblingOffset);
-        }
-        applyPendingPatches(patches, pendingPatches, 0);
-        patches.push({
-          type: SetText,
-          value: newNode.text
-        });
-      }
-      i++;
-      j++;
-      siblingOffset++;
-      continue;
-    }
-    const oldKeys = getKeys(oldNode);
-    const newKeys = getKeys(newNode);
-    let hasAttributeChanges = false;
-    for (const key of newKeys) {
-      if (oldNode[key] !== newNode[key]) {
-        hasAttributeChanges = true;
-        break;
-      }
-    }
-    for (const key of oldKeys) {
-      if (!(key in newNode)) {
-        hasAttributeChanges = true;
-        break;
-      }
-    }
-    if (hasAttributeChanges) {
-      if (siblingOffset > 0) {
-        pendingPatches.push(NavigateSibling, siblingOffset);
-      }
-      applyPendingPatches(patches, pendingPatches, 0);
-      for (const key of newKeys) {
-        if (oldNode[key] !== newNode[key]) {
-          patches.push({
-            type: SetAttribute,
-            key,
-            value: newNode[key]
-          });
-        }
-      }
-      for (const key of oldKeys) {
-        if (!(key in newNode)) {
-          patches.push({
-            type: RemoveAttribute,
-            key
-          });
-        }
-      }
-    }
-    if (oldNode.childCount && newNode.childCount) {
-      maxSiblingOffset = oldNode.childCount;
-      indexStack.push(0, maxSiblingOffset);
-      pendingPatches.push(NavigateChild, 0);
-      i++;
-      j++;
-      continue;
-    }
-    if (oldNode.childCount) {
-      applyPendingPatches(patches, pendingPatches, 0);
-      for (let k = 0; k < oldNode.childCount; k++) {
-        patches.push({
-          type: RemoveChild,
-          index: 0
-        });
-      }
-      i += getTotalChildCount(oldNodes, i);
-      j++;
-      siblingOffset++;
-      continue;
-    }
-    if (newNode.childCount) {
-      applyPendingPatches(patches, pendingPatches, 0);
-      const total = getTotalChildCount(newNodes, j);
-      patches.push({
-        type: Add,
-        nodes: newNodes.slice(j + 1, j + total)
-      });
-      i++;
-      j += total;
-      continue;
-    }
-    i++;
-    j++;
-    siblingOffset++;
+const nextHistoryResult = async state => {
+  const {
+    history,
+    historyIndex,
+    value
+  } = state;
+  const {
+    newValue,
+    newHistoryIndex
+  } = getNextHistoryData(history, historyIndex);
+  if (newValue === value) {
+    return state;
+  }
+  return handleUpdate(state, {
+    value: newValue,
+    inputSource: Script,
+    historyIndex: newHistoryIndex
+  });
+};
+
+const previousHistoryResult = async state => {
+  return {
+    ...state
+  };
+};
+
+const refresh = state => {
+  return handleUpdate(state, {});
+};
+
+const getFocusSelector = focusKey => {
+  switch (focusKey) {
+    case FocusSearchInput:
+      return SearchValue;
+    case FocusSearchReplaceInput:
+      return ReplaceValue;
+    case FocusToggleDetails:
+      return ToggleSearchDetails;
+    case FocusSearchMatchCase:
+      return MatchCase;
+    case FocusSearchPreserveCase:
+      return PreserveCase;
+    case FocusSearchRegex:
+      return UseRegularExpression;
+    case FocusSearchIncludeInput:
+      return FilesToInclude;
+    case FocusSearchExcludeInput:
+      return FilesToExclude;
+    case FocusSearchWholeWord:
+      return MatchWholeWord;
+    case FocusSearchReplaceAll:
+      return ReplaceAll;
+    case FocusSearchOpenEditors:
+      return SearchOnlyOpenEditors;
+    case FocusIgnoreFiles:
+      return UseExcludeSettings;
+    case FocusToggleReplace:
+      return ToggleReplace;
+    case FocusSearchResults:
+      return '.Tree';
+    default:
+      return '';
   }
-  while (i < oldNodes.length) {
-    if (indexStack.length !== 2) {
-      patches.push({
-        type: NavigateParent
-      });
+};
+
+const renderFocus = (oldState, newState) => {
+  const selector = getFocusSelector(newState.focus);
+  return [FocusElementByName, newState.uid, selector];
+};
+
+const renderFocusContext = (oldState, newState) => {
+  return [SetFocusContext, newState.uid, FocusSearch, newState.focus];
+};
+
+const None = 0;
+const Collapsed = 1;
+const Expanded = 2;
+
+const getMatchCount = (results, startIndex) => {
+  for (let i = startIndex + 1; i < results.length; i++) {
+    const result = results[i];
+    if (result.type === File) {
+      return i - startIndex - 1;
     }
-    patches.push({
-      type: RemoveChild,
-      index: siblingOffset
-    });
-    i += getTotalChildCount(oldNodes, i);
-    indexStack.pop();
-    indexStack.pop();
   }
-  while (j < newNodes.length) {
-    if (siblingOffset > 0) {
-      patches.push({
-        type: NavigateSibling,
-        index: siblingOffset
-      });
-      siblingOffset = 0;
-    }
-    const count = getTotalChildCount(newNodes, j);
-    patches.push({
-      type: Add,
-      nodes: newNodes.slice(j, j + count)
-    });
-    j += count;
+  return results.length - startIndex - 1;
+};
+
+const getSearchDisplayResultFile = (results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, originalResults) => {
+  const path = text;
+  const absolutePath = getRelativePath(path);
+  const baseName = pathBaseName(path);
+  const index = originalResults.indexOf(results[i]);
+  const matchCount = getMatchCount(results, index);
+  const expanded = collapsedPaths.includes(path) ? Collapsed : Expanded;
+  const badgeText = `${matchCount}`;
+  return {
+    badgeText,
+    depth: 0,
+    expanded,
+    focused,
+    icon: fileIcons[relativeIndex],
+    matchLength: 0,
+    matchStart: 0,
+    posInSet,
+    replacement: '',
+    setSize,
+    text: baseName,
+    title: absolutePath
+  };
+};
+
+const getDisplayResultMatch = (setSize, searchTermLength, replacement, text, posInSet, start, focused) => {
+  return {
+    badgeText: '',
+    depth: 1,
+    expanded: None,
+    focused,
+    icon: '',
+    matchLength: searchTermLength,
+    matchStart: start,
+    posInSet,
+    replacement,
+    setSize,
+    text: text,
+    title: text.trim()
+  };
+};
+
+const getDisplayResult = (results, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, minLineY, originalResults) => {
+  const result = results[i];
+  const {
+    type,
+    text,
+    start
+  } = result;
+  const posInSet = i + 1;
+  const focused = i === focusedIndex;
+  const relativeIndex = i - minLineY;
+  switch (type) {
+    case File:
+      return getSearchDisplayResultFile(results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, originalResults);
+    case Match:
+      return getDisplayResultMatch(setSize, searchTermLength, replacement, text, posInSet, start, focused);
+    default:
+      throw new Error('unexpected search result type');
   }
-  return patches;
+};
+
+const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, fileIcons, focusedIndex, collapsedPaths, originalResults) => {
+  // Filter out child items when parent files are collapsed
+  const filteredResults = getFilteredResults(results, collapsedPaths);
+  const displayResults = [];
+  const setSize = resultCount;
+  const searchTermLength = searchTerm.length;
+  const max = Math.min(filteredResults.length, maxLineY);
+  for (let i = minLineY; i < max; i++) {
+    const displayResult = getDisplayResult(filteredResults, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, minLineY, originalResults);
+    displayResults.push(displayResult);
+  }
+  return displayResults;
+};
+
+const createViewModel = state => {
+  // TODO add viewmodel to state, not needing to have separate states and making it easier to compare
+  // visible items in diff
+  const {
+    listItems,
+    itemHeight,
+    fileCount,
+    value,
+    minLineY,
+    maxLineY,
+    replacement,
+    icons,
+    listFocusedIndex,
+    collapsedPaths,
+    items,
+    listFocused,
+    deltaY,
+    finalDeltaY,
+    height,
+    headerHeight,
+    flags,
+    message,
+    searchInputErrorMessage,
+    scrollBarHeight,
+    matchCount,
+    focus
+  } = state;
+  const displayResults = getDisplayResults(listItems, itemHeight, fileCount, value, minLineY, maxLineY, replacement, icons, listFocusedIndex, collapsedPaths, items);
+  const focusOutline = listFocused && listFocusedIndex === -1;
+  const scrollBarValue = deltaY / finalDeltaY * 100;
+  const scrollBarY = getScrollBarY$1(deltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
+  return {
+    displayResults,
+    flags,
+    message,
+    focusOutline,
+    searchInputErrorMessage,
+    scrollBarHeight,
+    scrollBarY,
+    scrollBarValue,
+    deltaY,
+    itemHeight,
+    matchCount,
+    focus
+  };
 };
 
 const HandleClick = 1;
 const HandleContextMenu = 2;
 const HandleHeaderContextMenu = 3;
 const HandleExcludeInput = 4;
-const HandleHeaderClick2 = 5;
+const HandleButtonClick = 5;
 const HandleHeaderFocusIn = 6;
 const HandleHeaderFocusOut = 7;
 const HandleIncludeInput = 8;
-const HandleInput = 9;
 const HandleInput2 = 10;
 const HandleListBlur = 11;
 const HandleListFocus = 12;
@@ -4291,16 +4421,20 @@ const HandleReplaceInput = 13;
 const HandleScrollBarPointerDown = 14;
 const HandleToggleButtonClick = 15;
 const HandleWheel = 16;
+const HandleInputFocus = 17;
+const HandleInputBlur = 18;
+const HandleListPointerDown = 19;
 
 const getSearchDetailsToggleVirtualDom = () => {
   return [{
-    type: Div,
+    type: Button$2,
     className: ToggleDetails,
     role: Button$3,
     tabIndex: 0,
     ariaLabel: toggleSearchDetails(),
     title: toggleSearchDetails(),
     name: ToggleSearchDetails,
+    onClick: HandleButtonClick,
     childCount: 1
   }, {
     type: Div,
@@ -4320,7 +4454,6 @@ const getSearchMessageVirtualDom = (message, indented) => {
     type: Div,
     className: getClassName(indented),
     role: Status,
-    tabIndex: 0,
     childCount: 1
   }, text(message)];
 };
@@ -4421,7 +4554,8 @@ const getSearchFieldButtonVirtualDom = button => {
     ariaChecked,
     disabled,
     tabIndex: 0,
-    childCount: 1
+    childCount: 1,
+    onClick: HandleButtonClick
   }, {
     type: Span,
     className: mergeClassNames(MaskIcon, icon),
@@ -4440,14 +4574,14 @@ const getOutSideButtonsDom = outsideButtons => {
     preNodes: [{
       type: Div,
       className: SearchFieldContainer,
-      role: None$1,
+      role: None$2,
       childCount: 1 + outsideButtons.length
     }],
     postNodes: outsideButtons.flatMap(getSearchFieldButtonVirtualDom)
   };
 };
 
-const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus = '', hasError = false) => {
+const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, hasError = false) => {
   const {
     preNodes,
     postNodes
@@ -4456,7 +4590,7 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
   const dom = [...preNodes, {
     type: Div,
     className: searchFieldClassName,
-    role: None$1,
+    role: None$2,
     childCount: 2
   }, {
     type: TextArea,
@@ -4467,7 +4601,9 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
     placeholder,
     name,
     onInput,
-    onFocus,
+    onFocus: HandleInputFocus,
+    onBlur: HandleInputBlur,
+    onContextMenu: HandleContextMenu,
     childCount: 0
   }, {
     type: Div,
@@ -4591,10 +4727,11 @@ const getSearchToggleVirtualDom = replaceExpanded => {
     className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
     title: toggleReplace$1(),
     ariaLabel: toggleReplace$1(),
+    // TODO compute label only once
     ariaExpanded: Boolean(replaceExpanded),
     childCount: 1,
-    'data-command': 'toggleReplace',
-    name: ToggleReplace
+    name: ToggleReplace,
+    onClick: HandleButtonClick
   }, {
     type: Div,
     className: mergeClassNames(MaskIcon, replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight),
@@ -4611,14 +4748,14 @@ const getSearchHeaderTopVirtualDom = (flags, searchInputErrorMessage, matchCount
   const dom = [{
     type: Div,
     className: SearchHeaderTop,
-    role: None$1,
+    role: None$2,
     childCount: 2
   }, ...getSearchToggleVirtualDom(replaceExpanded), {
     type: Div,
     className: SearchHeaderTopRight,
-    role: None$1,
+    role: None$2,
     childCount: replaceExpanded ? 2 : 1
-  }, ...getSearchFieldVirtualDom(SearchValue, searchPlaceholder, HandleInput2, inputActions.inside, inputActions.outside, '', Boolean(searchInputErrorMessage))];
+  }, ...getSearchFieldVirtualDom(SearchValue, searchPlaceholder, HandleInput2, inputActions.inside, inputActions.outside, Boolean(searchInputErrorMessage))];
   if (flags & ReplaceExpanded) {
     dom.push(...getSearchFieldVirtualDom(ReplaceValue, replacePlaceholder, HandleInput2, replaceActions.inside, replaceActions.outside));
   }
@@ -4628,11 +4765,8 @@ const getSearchHeaderTopVirtualDom = (flags, searchInputErrorMessage, matchCount
 const parentNode = {
   type: Div,
   className: SearchHeader,
-  role: None$1,
+  role: None$2,
   childCount: 3,
-  onClick: HandleHeaderClick2,
-  onFocusIn: HandleHeaderFocusIn,
-  onFocusOut: HandleHeaderFocusOut,
   onContextMenu: HandleHeaderContextMenu
 };
 const getSearchHeaderVirtualDom = (flags, message, searchInputErrorMessage, matchCount, focus, limitHitWarning) => {
@@ -4727,7 +4861,7 @@ const getFileIconVirtualDom = icon => {
     type: Img,
     className: FileIcon,
     src: icon,
-    role: None$1,
+    role: None$2,
     childCount: 0
   };
 };
@@ -4868,7 +5002,7 @@ const getTreeItemsVirtualDom = (visibleItems, deltaY, itemHeight) => {
     onWheel: HandleWheel,
     onContextMenu: HandleContextMenu,
     id: TreeItems,
-    top: `${-pixelOffset}px`
+    top: `${-pixelOffset}px` // TODO use dynamic css instead
   }, ...visibleItems.flatMap(getSearchResultVirtualDom)];
 };
 
@@ -4876,10 +5010,13 @@ const getSearchResultsVirtualDom = (visibleItems, focusOutline, scrollbarHeight,
   const childCount = scrollbarHeight === 0 ? 1 : 2;
   return [{
     type: Div,
-    className: mergeClassNames(Viewlet, List$1, Tree, focusOutline ? FocusOutline : Empty),
+    className: mergeClassNames(Viewlet, List$1, Tree, focusOutline ? FocusOutline : Empty$1),
     role: Tree$1,
     tabIndex: 0,
-    childCount
+    childCount,
+    onBlur: HandleListBlur,
+    onPointerDown: HandleListPointerDown,
+    onFocus: HandleListFocus
   }, ...getTreeItemsVirtualDom(visibleItems, deltaY, itemHeight), ...getScrollBarVirtualDom(scrollbarHeight, scrollBarY, scrollBarValue)];
 };
 
@@ -4896,20 +5033,20 @@ const getSearchVirtualDom = (visibleItems, flags, message, focusOutline, searchI
 const renderItems = (oldState, newState) => {
   const viewModel = createViewModel(newState);
   const dom = getSearchVirtualDom(viewModel.displayResults, viewModel.flags, viewModel.message, viewModel.focusOutline, viewModel.searchInputErrorMessage, viewModel.scrollBarHeight, viewModel.scrollBarY, viewModel.scrollBarValue, viewModel.deltaY, viewModel.itemHeight, viewModel.matchCount, newState.limitHitWarning, viewModel.focus);
-  return ['Viewlet.setDom2', newState.uid, dom];
+  return [SetDom2, newState.uid, dom];
 };
 
 const renderValue = (oldState, newState) => {
-  return ['Viewlet.setValueByName', SearchValue, newState.value];
+  return [SetValueByName, SearchValue, newState.value];
 };
 const renderReplacement = (oldState, newState) => {
-  return ['Viewlet.setValueByName', ReplaceValue, newState.replacement];
+  return [SetValueByName, ReplaceValue, newState.replacement];
 };
 const renderIncludeValue = (oldState, newState) => {
-  return ['Viewlet.setValueByName', FilesToInclude, newState.includeValue];
+  return [SetValueByName, FilesToInclude, newState.includeValue];
 };
 const renderExcludeValue = (oldState, newState) => {
-  return ['Viewlet.setValueByName', FilesToExclude, newState.excludeValue];
+  return [SetValueByName, FilesToExclude, newState.excludeValue];
 };
 
 const getRenderer = diffType => {
@@ -4958,7 +5095,7 @@ const getIconVirtualDom = (icon, type = Div) => {
   return {
     type,
     className: mergeClassNames(MaskIcon, `MaskIcon${icon}`),
-    role: None$1,
+    role: None$2,
     childCount: 0
   };
 };
@@ -5050,12 +5187,12 @@ const renderEventListeners = () => {
   }, {
     name: HandleReplaceInput,
     params: ['handleReplaceInput', TargetValue]
-  }, {
-    name: HandleInput,
-    params: ['handleInput', TargetValue, User]
   }, {
     name: HandleClick,
     params: ['handleClickAt', ClientX, ClientY]
+  }, {
+    name: HandleListPointerDown,
+    params: ['handleListPointerDown', Button$1]
   }, {
     name: HandleToggleButtonClick,
     params: ['handleToggleButtonClick']
@@ -5078,7 +5215,7 @@ const renderEventListeners = () => {
     params: ['handleWheel', DeltaMode, DeltaY],
     passive: true
   }, {
-    name: HandleHeaderClick2,
+    name: HandleButtonClick,
     params: ['handleHeaderClick', TargetName]
   }, {
     name: HandleHeaderFocusIn,
@@ -5089,6 +5226,12 @@ const renderEventListeners = () => {
   }, {
     name: HandleScrollBarPointerDown,
     params: ['handleScrollBarClick', DeltaY]
+  }, {
+    name: HandleInputFocus,
+    params: ['handleInputFocus', TargetName]
+  }, {
+    name: HandleInputBlur,
+    params: ['handleInputBlur', TargetName]
   }];
 };
 
@@ -5109,7 +5252,7 @@ const renderIncremental = uid => {
   } = get$1(uid);
   const oldDom = getDom(oldState);
   const newDom = getDom(newState);
-  const patches = diff(oldDom, newDom);
+  const patches = diff$1(oldDom, newDom);
   return patches;
 };
 
@@ -5163,10 +5306,7 @@ const rerender = state => {
   };
 };
 
-const saveState = uid => {
-  const {
-    newState
-  } = get$1(uid);
+const saveState = state => {
   const {
     value,
     replacement,
@@ -5174,8 +5314,10 @@ const saveState = uid => {
     includeValue,
     excludeValue,
     history,
-    collapsedPaths
-  } = newState;
+    collapsedPaths,
+    focus,
+    listFocused
+  } = state;
   return {
     value,
     replacement,
@@ -5183,7 +5325,9 @@ const saveState = uid => {
     includeValue,
     excludeValue,
     history,
-    collapsedPaths
+    collapsedPaths,
+    focus,
+    listFocused
   };
 };
 
@@ -5195,39 +5339,6 @@ const focusElement = (state, focusKey) => {
   };
 };
 
-const getSearchFocusKey = key => {
-  switch (key) {
-    case SearchValue:
-      return FocusSearchInput;
-    case ReplaceValue:
-      return FocusSearchReplaceInput;
-    case MatchCase:
-      return FocusSearchMatchCase;
-    case MatchWholeWord:
-      return FocusSearchWholeWord;
-    case UseRegularExpression:
-      return FocusSearchRegex;
-    case ReplaceAll:
-      return FocusSearchReplaceAll;
-    case PreserveCase:
-      return FocusSearchPreserveCase;
-    case ToggleSearchDetails:
-      return FocusToggleDetails;
-    case FilesToInclude:
-      return FocusSearchIncludeInput;
-    case FilesToExclude:
-      return FocusSearchExcludeInput;
-    case SearchOnlyOpenEditors:
-      return FocusSearchOpenEditors;
-    case UseExcludeSettings:
-      return FocusIgnoreFiles;
-    case ToggleReplace:
-      return FocusToggleReplace;
-    default:
-      return Empty$1;
-  }
-};
-
 const handleFocusIn = async (state, key) => {
   const focusKey = getSearchFocusKey(key);
   if (state.focus === focusKey) {
@@ -5390,7 +5501,11 @@ const commandMap = {
   'TextSearch.handleIncludeInput': wrapCommand(handleIncludeInput),
   'TextSearch.handleInput': wrapCommand(handleInput),
   'TextSearch.handleInput2': wrapCommand(handleInput2),
+  'TextSearch.handleInputBlur': wrapCommand(handleInputBlur),
+  'TextSearch.handleInputFocus': wrapCommand(handleInputFocus),
   'TextSearch.handleListBlur': wrapCommand(handleListBlur),
+  'TextSearch.handleListFocus': wrapCommand(handleListFocus),
+  'TextSearch.handleListPointerDown': wrapCommand(handleListPointerDown),
   'TextSearch.handleReplaceInput': wrapCommand(handleReplaceInput),
   'TextSearch.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
   'TextSearch.handleScrollBarClick': wrapCommand(handleScrollBarClick),
@@ -5424,9 +5539,11 @@ const commandMap = {
   'TextSearch.renderEventListeners': renderEventListeners,
   'TextSearch.renderIncremental': renderIncremental,
   'TextSearch.restoreState': restoreState,
-  'TextSearch.saveState': saveState,
+  'TextSearch.saveState': wrapGetter(saveState),
   'TextSearch.terminate': terminate,
   'TextSearch.renderActions': renderActions,
+  'TextSearch.getMenuEntryIds': getMenuEntryIds,
+  'TextSearch.getMenuEntries': getMenuEntries,
   // TODO needed?
   'TextSearch.replaceAllAndPrompt': replaceAllAndPrompt,
   'TextSearch.textSearch': textSearch$6