@lvce-editor/server 0.38.8 → 0.39.0

package/static/{04d0891 → 95c7ea1}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -1,32 +1,32 @@
 const Two = '2.0';
-const create$4 = (method, params) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const state$2 = {
+const state$4 = {
   callbacks: Object.create(null)
 };
 const set$1 = (id, fn) => {
-  state$2.callbacks[id] = fn;
+  state$4.callbacks[id] = fn;
 };
 const get$1 = id => {
-  return state$2.callbacks[id];
+  return state$4.callbacks[id];
 };
 const remove$1 = id => {
-  delete state$2.callbacks[id];
+  delete state$4.callbacks[id];
 };
 let id = 0;
-const create$3 = () => {
+const create$3$1 = () => {
   return ++id;
 };
 const warn = (...args) => {
   console.warn(...args);
 };
 const registerPromise = () => {
-  const id = create$3();
+  const id = create$3$1();
   const {
     resolve,
     promise
@@ -47,7 +47,7 @@ const resolve = (id, response) => {
   fn(response);
   remove$1(id);
 };
-const create$2 = (method, params) => {
+const create$2$2 = (method, params) => {
   const {
     id,
     promise
@@ -326,7 +326,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
-  } = create$2(method, params);
+  } = create$2$2(method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -336,13 +336,13 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$2 = (ipc, method, ...params) => {
+const invoke$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -743,6 +743,156 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$1$1,
   wrap: wrap$4
 };
+const Message$1 = 3;
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const create$2$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const event = await eventPromise;
+  // @ts-ignore
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData = getData$1;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    throw new Error('not implemented');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$2 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$2$1,
+  signal,
+  wrap: wrap$2
+};
+const Open = 1;
+const Close = 2;
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError$1(error, 'failed to parse json');
+  }
+};
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close
+  });
+};
+const create$4 = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  // @ts-ignore
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$1 = webSocket => {
+  return new IpcParentWithWebSocket(webSocket);
+};
+const IpcParentWithWebSocket$1 = {
+  __proto__: null,
+  create: create$4,
+  wrap: wrap$1
+};
 
 const createRpc = ipc => {
   const rpc = {
@@ -753,10 +903,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
+      return invoke$3(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     }
   };
   return rpc;
@@ -776,6 +926,44 @@ const handleMessage = event => {
 const handleIpc = ipc => {
   ipc.addEventListener('message', handleMessage);
 };
+const create$2 = async ({
+  commandMap,
+  messagePort,
+  isMessagePortOpen
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const MessagePortRpcParent = {
+  __proto__: null,
+  create: create$2
+};
+const create$1$1 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebSocketRpcParent = {
+  __proto__: null,
+  create: create$1$1
+};
 
 // @ts-ignore
 const listen$1 = async () => {
@@ -784,7 +972,7 @@ const listen$1 = async () => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$1$1 = async ({
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -796,18 +984,25 @@ const create$1$1 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$1$1
+  create: create$3
 };
 
 const Empty$1 = 0;
+const FocusIgnoreFiles = 1012;
+const FocusSearch = 1013;
+const FocusSearchExcludeInput = 1008;
+const FocusSearchIncludeInput = 1007;
 const FocusSearchInput = 21;
-const FocusSearchReplaceInput = 31;
 const FocusSearchMatchCase = 32;
+const FocusSearchOpenEditors = 1011;
+const FocusSearchPreserveCase = 36;
 const FocusSearchRegex = 33;
-const FocusSearchWholeWord = 34;
 const FocusSearchReplaceAll = 35;
-const FocusSearchPreserveCase = 36;
-const FocusSearchIncludeInput = 1007;
+const FocusSearchReplaceInput = 31;
+const FocusSearchResults = 22;
+const FocusSearchWholeWord = 34;
+const FocusToggleDetails = 1010;
+const FocusToggleReplace = 1020;
 
 const User = 1;
 const Script = 2;
@@ -825,16 +1020,21 @@ const clearSearchResults$1 = state => {
   };
 };
 
-const state$1 = {
+const state$3 = {
   rpc: undefined
 };
-const invoke$1 = (method, ...params) => {
-  const rpc = state$1.rpc;
+const invoke$2 = (method, ...params) => {
+  const rpc = state$3.rpc;
   // @ts-ignore
   return rpc.invoke(method, ...params);
 };
+const invokeAndTransfer = (method, ...params) => {
+  const rpc = state$3.rpc;
+  // @ts-ignore
+  return rpc.invokeAndTransfer(method, ...params);
+};
 const setRpc = rpc => {
-  state$1.rpc = rpc;
+  state$3.rpc = rpc;
 };
 
 const copy = async state => {
@@ -846,7 +1046,7 @@ const copy = async state => {
     return state;
   }
   const item = items[listFocusedIndex];
-  await invoke$1('ClipBoard.writeText', item.text);
+  await invoke$2('ClipBoard.writeText', item.text);
   return state;
 };
 
@@ -876,6 +1076,7 @@ const create$1 = ({
     itemHeight,
     headerHeight,
     items: [],
+    listItems: [],
     minimumSliderSize,
     focusedIndex: -1,
     touchOffsetY: 0,
@@ -886,7 +1087,7 @@ const create$1 = ({
   };
 };
 
-const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, value = '', replacement = '') => {
+const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, value = '', replacement = '', platform) => {
   const state = {
     uid,
     searchResults: [],
@@ -925,7 +1126,8 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, v
     focusedIndex: -1,
     handleOffset: 0,
     focusSource: User,
-    flags: 0
+    flags: 0,
+    platform
   };
   set(uid, state, state);
   return state;
@@ -965,59 +1167,6 @@ const fromAsync = async asyncIterable => {
   return children;
 };
 
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const object = value => {
-  const type = getType(value);
-  if (type !== 'object') {
-    throw new AssertionError('expected value to be of type object');
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const array = value => {
-  const type = getType(value);
-  if (type !== 'array') {
-    throw new AssertionError('expected value to be of type array');
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-
 const emptyObject = {};
 const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
 const i18nString = (key, placeholders = emptyObject) => {
@@ -1025,7 +1174,6 @@ const i18nString = (key, placeholders = emptyObject) => {
     return key;
   }
   const replacer = (match, rest) => {
-    // @ts-ignore
     return placeholders[rest];
   };
   return key.replaceAll(RE_PLACEHOLDER, replacer);
@@ -1124,9 +1272,6 @@ const confirmReplaceManyOccurrencesInOneFileNoValue = matchCount => {
   });
 };
 const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replacement) => {
-  number(matchCount);
-  number(fileCount);
-  string(replacement);
   return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFiles, {
     PH1: matchCount,
     PH2: fileCount,
@@ -1134,8 +1279,6 @@ const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replace
   });
 };
 const confirmReplaceManyOccurrencesInManyFilesNoValue = (matchCount, fileCount) => {
-  number(matchCount);
-  number(fileCount);
   return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFilesNoValue, {
     PH1: matchCount,
     PH2: fileCount
@@ -1176,8 +1319,6 @@ const useExcludeSettings = () => {
 };
 
 const getStatusMessage = (resultCount, fileResultCount) => {
-  number(resultCount);
-  number(fileResultCount);
   if (resultCount === 0) {
     return noResults();
   }
@@ -1327,48 +1468,141 @@ const focusMatchCase$1 = state => {
   };
 };
 
-const focusReplaceValue$1 = state => {
-  return {
-    ...state,
-    focus: FocusSearchReplaceInput
-  };
-};
-
-const focusSearchValue$1 = state => {
-  return {
-    ...state,
-    focus: FocusSearchInput
-  };
-};
-
-const PreserveCase = 1 << 0; // 1
-const UseRegularExpression = 1 << 1; // 2
+const PreserveCase$1 = 1 << 0; // 1
+const UseRegularExpression$1 = 1 << 1; // 2
 const ReplaceExpanded = 1 << 2; // 4
-const MatchWholeWord = 1 << 3; // 8
-const MatchCase = 1 << 4; // 16
+const MatchWholeWord$1 = 1 << 3; // 8
+const MatchCase$1 = 1 << 4; // 16
 const DetailsExpanded = 1 << 5; // 32
 const OpenEditors = 1 << 6; // 64
 const UseIgnoreFiles = 1 << 7; // 128
 
 const hasPreserveCase = flags => {
-  return (flags & PreserveCase) === PreserveCase;
+  return (flags & PreserveCase$1) === PreserveCase$1;
 };
 const hasUseRegularExpression = flags => {
-  return (flags & UseRegularExpression) === UseRegularExpression;
+  return (flags & UseRegularExpression$1) === UseRegularExpression$1;
 };
 const hasReplaceExpanded = flags => {
   return (flags & ReplaceExpanded) === ReplaceExpanded;
 };
 const hasMatchWholeWord = flags => {
-  return (flags & MatchWholeWord) === MatchWholeWord;
+  return (flags & MatchWholeWord$1) === MatchWholeWord$1;
 };
 const hasMatchCase = flags => {
-  return (flags & MatchCase) === MatchCase;
+  return (flags & MatchCase$1) === MatchCase$1;
 };
 const hasDetailsExpanded = flags => {
   return (flags & DetailsExpanded) === DetailsExpanded;
 };
 
+const getNextFocus = (focus, flags) => {
+  switch (focus) {
+    case FocusToggleReplace:
+      return FocusSearchInput;
+    case FocusSearchInput:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchReplaceInput;
+      }
+      return FocusSearchMatchCase;
+    case FocusSearchMatchCase:
+      return FocusSearchWholeWord;
+    case FocusSearchWholeWord:
+      return FocusSearchRegex;
+    case FocusSearchRegex:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchPreserveCase;
+      }
+      return FocusToggleDetails;
+    case FocusSearchReplaceInput:
+      return FocusSearchMatchCase;
+    case FocusSearchPreserveCase:
+      return FocusSearchReplaceAll;
+    case FocusSearchReplaceAll:
+      return FocusToggleDetails;
+    case FocusSearchIncludeInput:
+      return FocusSearchOpenEditors;
+    case FocusSearchOpenEditors:
+      return FocusSearchExcludeInput;
+    case FocusSearchExcludeInput:
+      return FocusIgnoreFiles;
+    case FocusToggleDetails:
+      return FocusSearchIncludeInput;
+    default:
+      return focus;
+  }
+};
+
+const focusNextInput = state => {
+  const nextFocus = getNextFocus(state.focus, state.flags);
+  return {
+    ...state,
+    focus: nextFocus,
+    focusSource: Script
+  };
+};
+
+const getPreviousFocus = (focus, flags) => {
+  switch (focus) {
+    case FocusSearchInput:
+      return FocusToggleReplace;
+    case FocusSearchMatchCase:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchReplaceInput;
+      }
+      return FocusSearchInput;
+    case FocusSearchWholeWord:
+      return FocusSearchMatchCase;
+    case FocusSearchRegex:
+      return FocusSearchWholeWord;
+    case FocusSearchPreserveCase:
+      return FocusSearchRegex;
+    case FocusSearchReplaceInput:
+      return FocusSearchInput;
+    case FocusSearchReplaceAll:
+      return FocusSearchPreserveCase;
+    case FocusToggleDetails:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchReplaceAll;
+      }
+      return FocusSearchRegex;
+    case FocusSearchOpenEditors:
+      return FocusSearchIncludeInput;
+    case FocusSearchExcludeInput:
+      return FocusSearchOpenEditors;
+    case FocusIgnoreFiles:
+      return FocusSearchExcludeInput;
+    case FocusSearchIncludeInput:
+      return FocusToggleDetails;
+    default:
+      return focus;
+  }
+};
+
+const focusPreviousInput = state => {
+  const previousFocus = getPreviousFocus(state.focus, state.flags);
+  return {
+    ...state,
+    focus: previousFocus,
+    focusSource: Script
+  };
+};
+
+const focusReplaceValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchReplaceInput,
+    focusSource: Script
+  };
+};
+
+const focusSearchValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchInput
+  };
+};
+
 const focusSearchValueNext = state => {
   if (hasReplaceExpanded(state.flags)) {
     return focusReplaceValue$1(state);
@@ -1491,6 +1725,81 @@ const getActionsVirtualDom = actions => {
   }, ...actions.flatMap(getActionVirtualDom)];
 };
 
+const getFlags = uid => {
+  const {
+    newState
+  } = get(uid);
+  return newState.flags;
+};
+
+const getFocus = uid => {
+  const {
+    newState
+  } = get(uid);
+  return newState.focus;
+};
+
+const Tab = 2;
+const Enter = 3;
+const End = 255;
+const Home = 12;
+const UpArrow = 14;
+const DownArrow = 16;
+const Delete = 18;
+const KeyC = 31;
+
+const CtrlCmd = 1 << 11 >>> 0;
+const Shift = 1 << 10 >>> 0;
+const Alt = 1 << 9 >>> 0;
+
+const getKeyBindings = () => {
+  return [{
+    key: CtrlCmd | Alt | Enter,
+    command: 'Search.replaceAll',
+    when: FocusSearch
+  }, {
+    key: Tab,
+    command: 'Search.focusNextInput',
+    when: FocusSearch
+  }, {
+    key: Shift | Tab,
+    command: 'Search.focusPreviousInput',
+    when: FocusSearch
+  }, {
+    key: DownArrow,
+    command: 'Search.focusNext',
+    when: FocusSearchResults
+  }, {
+    key: UpArrow,
+    command: 'Search.focusPrevious',
+    when: FocusSearchResults
+  }, {
+    key: Delete,
+    command: 'Search.dismissItem',
+    when: FocusSearchResults
+  }, {
+    key: Home,
+    command: 'Search.focusFirst',
+    when: FocusSearchResults
+  }, {
+    key: End,
+    command: 'Search.focusLast',
+    when: FocusSearchResults
+  }, {
+    key: CtrlCmd | KeyC,
+    command: 'Search.copy',
+    when: FocusSearchResults
+  }, {
+    key: Enter,
+    command: 'Search.submit',
+    when: FocusSearchInput
+  }, {
+    key: Enter,
+    command: 'Search.submit',
+    when: FocusSearchReplaceInput
+  }];
+};
+
 const ClearAll = 'ClearAll';
 const CollapseAll = 'CollapseAll';
 const ListFlat = 'ListFlat';
@@ -1590,26 +1899,8 @@ const getDisplayResult = (result, fileIcons, fileIconIndex, itemHeight, i, setSi
   }
 };
 
-const getFilteredResults = (results, collapsedPaths) => {
-  const filteredResults = [];
-  let isExcluded = false;
-  for (const result of results) {
-    if (result.type === File$1) {
-      if (collapsedPaths.includes(result.text)) {
-        isExcluded = true;
-      } else {
-        isExcluded = false;
-      }
-    }
-    if (!isExcluded) {
-      filteredResults.push(result);
-    }
-  }
-  return filteredResults;
-};
-const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, collapsedPaths, fileIcons, focusedIndex) => {
+const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, fileIcons, focusedIndex) => {
   const displayResults = [];
-  const filteredResults = getFilteredResults(results, collapsedPaths);
   const setSize = resultCount;
   const searchTermLength = searchTerm.length;
   let fileResult = {
@@ -1617,7 +1908,7 @@ const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLine
   };
   let fileIconIndex = 0;
   for (let i = minLineY; i < maxLineY; i++) {
-    const result = filteredResults[i];
+    const result = results[i];
     const displayResult = getDisplayResult(result, fileIcons, fileIconIndex, itemHeight, i, setSize, searchTermLength, replacement, focusedIndex);
     displayResults.push(displayResult);
     if (result.type === File$1) {
@@ -1744,18 +2035,34 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
   return dom;
 };
 
-const getSearchHeaderDetailsExpandedVirtualDom = message => {
+const FilesToExclude = 'FilesToExclude';
+const FilesToInclude = 'FilesToInclude';
+const MatchCase = 'MatchCase';
+const MatchWholeWord = 'MatchWholeWord';
+const PreserveCase = 'PreserveCase';
+const ReplaceAll = 'ReplaceAll';
+const ReplaceValue = 'ReplaceValue';
+const SearchOnlyOpenEditors = 'SearchOnlyOpenEditors';
+const SearchValue = 'SearchValue';
+const ToggleReplace = 'ToggleReplace';
+const ToggleSearchDetails = 'ToggleSearchDetails';
+const UseExcludeSettings = 'UseExcludeSettings';
+const UseRegularExpression = 'UseRegularExpression';
+
+const getSearchHeaderDetailsExpandedVirtualDom = (flags, message) => {
   const includeButtons = [{
     icon: MaskIconBook,
     title: searchOnlyOpenEditors(),
     command: 'searchOnlyOpenEditors',
-    checked: false
+    checked: Boolean(flags & OpenEditors),
+    name: SearchOnlyOpenEditors
   }];
   const excludeButtons = [{
     icon: MaskIconExclude,
     title: useExcludeSettings(),
     command: 'toggleUseExcludeSettings',
-    checked: false
+    checked: Boolean(flags & UseIgnoreFiles),
+    name: UseExcludeSettings
   }];
   return [{
     type: Div,
@@ -1769,16 +2076,16 @@ const getSearchHeaderDetailsExpandedVirtualDom = message => {
     type: H4,
     className: SearchHeaderDetailsHeading,
     childCount: 1
-  }, text(filesToInclude()), ...getSearchFieldVirtualDom('files-to-include-value', 'Include', 'handleIncludeInput', includeButtons, []), {
+  }, text(filesToInclude()), ...getSearchFieldVirtualDom(FilesToInclude, 'Include', 'handleIncludeInput', includeButtons, []), {
     type: H4,
     className: SearchHeaderDetailsHeading,
     childCount: 1
-  }, text(filesToExclude()), ...getSearchFieldVirtualDom('files-to-exclude-value', 'Exclude', 'handleExcludeInput', excludeButtons, []), ...getSearchMessageVirtualDom(message)];
+  }, text(filesToExclude()), ...getSearchFieldVirtualDom(FilesToExclude, 'Exclude', 'handleExcludeInput', excludeButtons, []), ...getSearchMessageVirtualDom(message)];
 };
 
 const getSearchHeaderDetailsVirtualDom = (flags, message) => {
   if (flags & DetailsExpanded) {
-    return getSearchHeaderDetailsExpandedVirtualDom(message);
+    return getSearchHeaderDetailsExpandedVirtualDom(flags, message);
   }
   return getSearchHeaderDetailsCollapsedVirtualDom(message);
 };
@@ -1810,28 +2117,33 @@ const getSearchHeaderTopVirtualDom = flags => {
     className: SearchHeaderTopRight,
     role: None,
     childCount: hasReplaceExpanded(flags) ? 2 : 1
-  }, ...getSearchFieldVirtualDom('search-value', 'Search', 'handleInput', [{
+  }, ...getSearchFieldVirtualDom(SearchValue, 'Search', 'handleInput', [{
     icon: MaskIconCaseSensitive,
     checked: hasMatchCase(flags),
-    title: matchCase()
+    title: matchCase(),
+    name: MatchCase
   }, {
     icon: MaskIconWholeWord,
     checked: hasMatchWholeWord(flags),
-    title: matchWholeWord()
+    title: matchWholeWord(),
+    name: MatchWholeWord
   }, {
     icon: MaskIconRegex,
     checked: hasUseRegularExpression(flags),
-    title: useRegularExpression()
+    title: useRegularExpression(),
+    name: UseRegularExpression
   }], [])];
   if (hasReplaceExpanded(flags)) {
-    dom.push(...getSearchFieldVirtualDom('search-replace-value', 'Replace', 'handleReplaceInput', [{
+    dom.push(...getSearchFieldVirtualDom(ReplaceValue, 'Replace', 'handleReplaceInput', [{
       icon: MaskIconPreserveCase,
       checked: hasPreserveCase(flags),
-      title: preserveCase()
+      title: preserveCase(),
+      name: PreserveCase
     }], [{
       icon: MaskIconReplaceAll,
       checked: false,
-      title: replaceAll$1()
+      title: replaceAll$1(),
+      name: ReplaceAll
     }]));
   }
   return dom;
@@ -1867,9 +2179,6 @@ const chevronDownVirtualDom = {
   className: mergeClassNames(Chevron, MaskIconChevronRight),
   childCount: 0
 });
-const getChevronDownVirtualDom = () => {
-  return chevronDownVirtualDom;
-};
 
 const getFileIconVirtualDom = icon => {
   return {
@@ -1966,7 +2275,7 @@ const getSearchResultVirtualDom = rowInfo => {
   dom.push(treeItem);
   if (type === File$1) {
     treeItem.childCount += 2;
-    dom.push(getChevronDownVirtualDom(), getFileIconVirtualDom(icon));
+    dom.push(chevronDownVirtualDom, getFileIconVirtualDom(icon));
   }
   dom.push(...getLabelVirtualDom(displayText, matchLength, matchStart, replacement));
   if (matchCount) {
@@ -2007,6 +2316,10 @@ const getSearchVirtualDom = (visibleItems, flags, message, focusOutline) => {
   return dom;
 };
 
+const handleError = error => {
+  console.error(`[text-search-worker] ${error}`);
+};
+
 const getFileIcons = async files => {
   // TODO cache file icons
   const promises = [];
@@ -2014,7 +2327,7 @@ const getFileIcons = async files => {
     if (file.type === Match) {
       continue;
     }
-    promises.push(invoke$1('IconTheme.getFileIcon', {
+    promises.push(invoke$2('IconTheme.getFileIcon', {
       name: file.text
     }));
   }
@@ -2022,24 +2335,6 @@ const getFileIcons = async files => {
   return icons;
 };
 
-const handleIconThemeChange = async state => {
-  const {
-    items,
-    minLineY,
-    maxLineY
-  } = state;
-  const visibleItems = items.slice(minLineY, maxLineY);
-  const icons = await getFileIcons(visibleItems);
-  return {
-    ...state,
-    icons
-  };
-};
-
-const handleError = error => {
-  console.error(`[text-search-worker] ${error}`);
-};
-
 // 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
@@ -2106,8 +2401,61 @@ const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
   };
 };
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      return 'object';
+    case 'boolean':
+      return 'boolean';
+    default:
+      return 'unknown';
+  }
+};
+const object = value => {
+  const type = getType(value);
+  if (type !== 'object') {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const array = value => {
+  const type = getType(value);
+  if (type !== 'array') {
+    throw new AssertionError('expected value to be of type array');
+  }
+};
+const string = value => {
+  const type = getType(value);
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
 const RE_PROTOCOL = /^([a-z-\d]+):\/\//;
-const getProtocol = uri => {
+const getProtocol$1 = uri => {
   const protocolMatch = uri.match(RE_PROTOCOL);
   if (protocolMatch) {
     return protocolMatch[1];
@@ -2118,7 +2466,7 @@ const getProtocol = uri => {
 const textSearch$5 = async (scheme, root, query) => {
   string(scheme);
   string(query);
-  const result = await invoke$1('ExtensionHostTextSearch.executeTextSearchProvider', scheme, query);
+  const result = await invoke$2('ExtensionHostTextSearch.executeTextSearchProvider', scheme, query);
   return result;
 };
 
@@ -2542,7 +2890,7 @@ replaceTraps(oldTraps => ({
   }
 }));
 
-const state = {
+const state$2 = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -2553,7 +2901,7 @@ const state = {
 
 const getHandleDb = async () => {
   // @ts-ignore
-  const db = await openDB('handle', state.dbVersion, {
+  const db = await openDB('handle', state$2.dbVersion, {
     async upgrade(db) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         await db.createObjectStore('file-handles-store', {});
@@ -2671,11 +3019,101 @@ const getRipGrepArgs = ({
   return ripGrepArgs;
 };
 
-const invoke = (method, ...params) => {
-  return invoke$1('SearchProcess.invoke', method, ...params);
+const Electron = 2;
+const Remote = 3;
+
+const Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
+
+const getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
+};
+
+const getWebSocketUrl = (type, host, locationProtocol) => {
+  const wsProtocol = getWebSocketProtocol(locationProtocol);
+  return `${wsProtocol}//${host}/websocket/${type}`;
+};
+
+const getHost = () => {
+  return location.host;
+};
+const getProtocol = () => {
+  return location.protocol;
+};
+
+const launchSearchProcess = async () => {
+  const host = getHost();
+  const protocol = getProtocol();
+  const wsUrl = getWebSocketUrl('search-process', host, protocol);
+  const webSocket = new WebSocket(wsUrl);
+  const rpc = await WebSocketRpcParent.create({
+    webSocket,
+    commandMap: {}
+  });
+  return rpc;
+};
+
+const state$1 = {
+  rpc: undefined
+};
+const getOrCreate$1 = () => {
+  if (!state$1.rpc) {
+    // @ts-ignore
+    state$1.rpc = launchSearchProcess();
+  }
+  return state$1.rpc;
+};
+
+const invoke$1 = async (method, ...params) => {
+  const rpc = await getOrCreate$1();
+  return rpc.invoke(method, ...params);
+};
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const launchSearchProcessElectron = async () => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const rpcPromise = MessagePortRpcParent.create({
+    messagePort: port2,
+    commandMap: {},
+    isMessagePortOpen: true
+  });
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port1, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+  port2.start();
+  const rpc = await rpcPromise;
+  return rpc;
+};
+
+const state = {
+  rpc: undefined
+};
+const getOrCreate = () => {
+  if (!state.rpc) {
+    // @ts-ignore
+    state.rpc = launchSearchProcessElectron();
+  }
+  return state.rpc;
+};
+
+const invoke = async (method, ...params) => {
+  const rpc = await getOrCreate();
+  return rpc.invoke(method, ...params);
 };
 
-const textSearch$2 = async (scheme, root, query, options) => {
+const textSearch$2 = async (scheme, root, query, options, assetDir, platform) => {
   const ripGrepArgs = getRipGrepArgs({
     ...options,
     searchString: query
@@ -2684,9 +3122,18 @@ const textSearch$2 = async (scheme, root, query, options) => {
     ripGrepArgs,
     searchDir: root
   };
-  const result = await invoke('TextSearch.search', actualOptions);
+  if (platform === Remote) {
+    const result = await invoke$1('TextSearch.search', actualOptions);
+    // TODO api is weird
+    return result.results;
+  }
+  if (platform === Electron) {
+    const result = await invoke('TextSearch.search', actualOptions);
+    return result.results;
+  }
+  const results = await invoke$2('SearchProcess.invoke', 'TextSearch.search', actualOptions);
   // TODO api is weird
-  return result.results;
+  return results.results;
 };
 
 const textSearch$1 = (scheme, root, query) => {
@@ -2720,12 +3167,12 @@ const getProvider = scheme => {
   }
 };
 
-const textSearch = async (root, query, options, assetDir) => {
+const textSearch = async (root, query, options, assetDir, platform) => {
   string(root);
   string(query);
-  const scheme = getProtocol(root);
+  const scheme = getProtocol$1(root);
   const provider = getProvider(scheme);
-  const results = await provider(scheme, root, query, options, assetDir);
+  const results = await provider(scheme, root, query, options, assetDir, platform);
   return results;
 };
 
@@ -2751,6 +3198,7 @@ const handleUpdate = async (state, update) => {
         maxLineY: 0,
         deltaY: 0,
         items: [],
+        listItems: [],
         matchCount: 0,
         message: '',
         loaded: true
@@ -2761,7 +3209,7 @@ const handleUpdate = async (state, update) => {
       threads,
       isCaseSensitive: hasMatchCase(flags),
       useRegularExpression: hasUseRegularExpression(flags)
-    }, state.assetDir);
+    }, state.assetDir, state.platform);
     if (!Array.isArray(results)) {
       throw new TypeError('results must be of type array');
     }
@@ -2785,6 +3233,7 @@ const handleUpdate = async (state, update) => {
       deltaY: 0,
       value,
       items: results,
+      listItems: results,
       message,
       maxLineY: maxLineY,
       scrollBarHeight,
@@ -2801,6 +3250,7 @@ const handleUpdate = async (state, update) => {
       ...partialNewState,
       message: `${error}`,
       items: [],
+      listItems: [],
       matchCount: 0,
       fileCount: 0,
       minLineY: 0,
@@ -2809,23 +3259,49 @@ const handleUpdate = async (state, update) => {
   }
 };
 
-const handleInput = (state, value, inputSource = Script) => {
+const handleExcludeInput = (state, value, inputSource = Script) => {
   return handleUpdate(state, {
-    value,
+    excludeValue: value,
     inputSource
   });
 };
 
-const handleReplaceInput = (state, value, inputSource = Script) => {
+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) => {
+  return {
+    ...state,
+    includeValue,
+    focusSource: User
+  };
+};
+
+const handleInput = (state, value, inputSource = Script) => {
   return handleUpdate(state, {
-    replacement: value,
+    value,
     inputSource
   });
 };
 
-const handleExcludeInput = (state, value, inputSource = Script) => {
+const handleListBlur = state => {
+  return state;
+};
+
+const handleReplaceInput = (state, value, inputSource = Script) => {
   return handleUpdate(state, {
-    excludeValue: value,
+    replacement: value,
     inputSource
   });
 };
@@ -2848,14 +3324,6 @@ const handleSharedInput = (state, name, value, inputSource = Script) => {
   return fn(state, value, inputSource);
 };
 
-const handleIncludeInput = (state, includeValue) => {
-  return {
-    ...state,
-    includeValue,
-    focusSource: User
-  };
-};
-
 const first = () => {
   return 0;
 };
@@ -2993,28 +3461,70 @@ const focusPreviousPage = state => {
   return focusIndex(state, indexPreviousPage);
 };
 
-const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
-  const relativeY = eventY - y + deltaY;
+const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight, topHeight) => {
+  const relativeY = eventY - y - topHeight + deltaY;
   const index = Math.floor(relativeY / itemHeight);
   return index;
 };
 
+const getTopHeight = flags => {
+  if (flags & ReplaceExpanded && flags & DetailsExpanded) {
+    return 190;
+  }
+  if (flags & DetailsExpanded) {
+    return 158;
+  }
+  if (flags & ReplaceExpanded) {
+    return 93;
+  }
+  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) {
+      if (collapsedPaths.includes(result.text)) {
+        isExcluded = true;
+      } else {
+        isExcluded = false;
+      }
+    }
+    if (!isExcluded) {
+      filteredResults.push(result);
+    }
+  }
+  return filteredResults;
+};
+
 const selectIndexFile = (state, searchResult, index) => {
   const {
-    collapsedPaths
+    collapsedPaths,
+    items,
+    maxLineY
   } = state;
   const path = getAbsolutePath(searchResult.text);
   string(path);
+  const pathWithDot = `.${path}`;
+  const newCollapsedPaths = [...collapsedPaths, path, pathWithDot];
+  const filteredResults = getFilteredResults(items, collapsedPaths);
+  const newMaxLineY = Math.min(maxLineY, filteredResults.length);
   return {
     ...state,
-    collapsedPaths: [...collapsedPaths, path],
+    collapsedPaths: newCollapsedPaths,
     listFocusedIndex: index,
-    listFocused: true
+    listFocused: true,
+    listItems: filteredResults,
+    maxLineY: newMaxLineY
   };
 };
 
 const openUri = async (path, focus = true, props = {}) => {
-  await invoke$1(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
+  await invoke$2(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
 const getFileIndex = (items, index) => {
@@ -3037,7 +3547,6 @@ const selectIndexPreview = async (state, searchResult, index) => {
   const {
     lineNumber
   } = searchResult;
-  // console.log({ searchResult })
   const fileResult = items[fileIndex];
   const path = getAbsolutePath(fileResult.text);
   string(path);
@@ -3073,14 +3582,16 @@ const selectIndex = async (state, index) => {
   }
 };
 
-const handleClickAt = async (state, eventX, eventY) => {
+const handleClickAt = (state, eventX, eventY) => {
   const {
     x,
     y,
     itemHeight,
-    deltaY
+    deltaY,
+    flags
   } = state;
-  const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight);
+  const topHeight = getTopHeight(flags);
+  const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, topHeight);
   return selectIndex(state, index);
 };
 
@@ -3231,7 +3742,9 @@ const loadContent = async (state, savedState) => {
     savedCollapsedPaths,
     threads,
     replacement,
-    flags
+    flags,
+    includeValue,
+    excludeValue
   } = restoreState(savedState);
   if (savedValue) {
     return handleUpdate(state, {
@@ -3240,7 +3753,9 @@ const loadContent = async (state, savedState) => {
       inputSource: Script,
       collapsedPaths: savedCollapsedPaths,
       replacement,
-      flags
+      flags,
+      includeValue,
+      excludeValue
     });
   }
   return {
@@ -3255,21 +3770,34 @@ const refresh = state => {
   return handleUpdate(state, {});
 };
 
-// TODO just return name
 const getFocusSelector = focusKey => {
   switch (focusKey) {
     case FocusSearchInput:
-      return '[name="search-value"]';
+      return SearchValue;
     case FocusSearchReplaceInput:
-      return '[name="search-replace-value"]';
+      return ReplaceValue;
+    case FocusToggleDetails:
+      return ToggleSearchDetails;
     case FocusSearchMatchCase:
-      return '[title="Match Case"]';
+      return MatchCase;
     case FocusSearchPreserveCase:
-      return '[title="Preserve Case"]';
+      return PreserveCase;
     case FocusSearchRegex:
-      return '[title="Use Regular Expression"]';
+      return UseRegularExpression;
     case FocusSearchIncludeInput:
-      return '[name="files-to-include-value"]';
+      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 '';
   }
@@ -3280,7 +3808,7 @@ const renderItems = {
     return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.replacement === newState.replacement && oldState.flags === newState.flags && oldState.message === newState.message && oldState.loaded === newState.loaded && oldState.collapsedPaths === newState.collapsedPaths && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.listFocused === newState.listFocused && oldState.icons === newState.icons;
   },
   apply(oldState, newState) {
-    const displayResults = getDisplayResults(newState.items, newState.itemHeight, newState.fileCount, newState.value, newState.minLineY, newState.maxLineY, newState.replacement, newState.collapsedPaths, newState.icons, newState.focusedIndex);
+    const displayResults = getDisplayResults(newState.listItems, newState.itemHeight, newState.fileCount, newState.value, newState.minLineY, newState.maxLineY, newState.replacement, newState.icons, newState.listFocusedIndex);
     const focusOutline = newState.listFocused && newState.listFocusedIndex === -1;
     const dom = getSearchVirtualDom(displayResults, newState.flags, newState.message, focusOutline);
     return ['Viewlet.setDom2', newState.uid, dom];
@@ -3291,8 +3819,8 @@ const renderFocus = {
     return oldState.focus === newState.focus || newState.focusSource === User;
   },
   apply(oldState, newState) {
-    const selector = getFocusSelector(newState.focus);
-    return ['Viewlet.send', newState.uid, 'setFocus', selector, newState.focusSource];
+    const name = newState.focusSource === User ? '' : getFocusSelector(newState.focus);
+    return ['Viewlet.focusElementByName', name];
   }
 };
 const renderValue = {
@@ -3308,10 +3836,29 @@ const renderReplacement = {
     return oldState.replacement === newState.replacement || newState.inputSource === User;
   },
   apply(oldState, newState) {
-    return ['Viewlet.send', newState.uid, 'setValue', newState.replacement, '[name="search-replace-value"]'];
+    const selector = getFocusSelector(FocusSearchReplaceInput);
+    return ['Viewlet.send', newState.uid, 'setValue', newState.replacement, selector];
+  }
+};
+const renderIncludeValue = {
+  isEqual(oldState, newState) {
+    return oldState.includeValue === newState.includeValue || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    const selector = getFocusSelector(FocusSearchIncludeInput);
+    return ['Viewlet.send', newState.uid, 'setValue', newState.includeValue, selector];
+  }
+};
+const renderExcludeValue = {
+  isEqual(oldState, newState) {
+    return oldState.excludeValue === newState.excludeValue || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    const selector = getFocusSelector(FocusSearchExcludeInput);
+    return ['Viewlet.send', newState.uid, 'setValue', newState.excludeValue, selector];
   }
 };
-const render = [renderItems, renderValue, renderReplacement, renderFocus];
+const render = [renderItems, renderValue, renderIncludeValue, renderExcludeValue, renderReplacement, renderFocus];
 const doRender = uid => {
   const {
     oldState,
@@ -3368,7 +3915,7 @@ const replaceAll = async state => {
     files,
     ranges
   } = getBulkReplacementEdits(workspacePath, items);
-  await invoke$1('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  await invoke$2('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
   return state;
 };
 
@@ -3400,7 +3947,7 @@ const replaceAllAndPrompt = async (workspacePath, items, replacement, matchCount
   const confirmTitle = replaceAll$1();
   const confirmAccept = replace();
   const confirmText = getReplaceAllConfirmText(matchCount, fileCount, replacement);
-  const shouldReplace = await invoke$1('ConfirmPrompt.prompt', confirmText, {
+  const shouldReplace = await invoke$2('ConfirmPrompt.prompt', confirmText, {
     title: confirmTitle,
     confirmMessage: confirmAccept
   });
@@ -3441,25 +3988,35 @@ const focusElement = (state, focusKey) => {
 };
 
 const setFocus = async focusKey => {
-  await invoke$1('Focus.setFocus', focusKey);
+  await invoke$2('Focus.setFocus', focusKey);
 };
 
 const getSearchFocusKey = key => {
   switch (key) {
-    case 'search-value':
+    case SearchValue:
       return FocusSearchInput;
-    case 'search-replace-value':
+    case ReplaceValue:
       return FocusSearchReplaceInput;
-    case 'Match Case':
+    case MatchCase:
       return FocusSearchMatchCase;
-    case 'Match Whole Word':
+    case MatchWholeWord:
       return FocusSearchWholeWord;
-    case 'Use Regular Expression':
+    case UseRegularExpression:
       return FocusSearchRegex;
-    case 'Replace All':
+    case ReplaceAll:
       return FocusSearchReplaceAll;
-    case 'Preserve Case':
+    case PreserveCase:
       return FocusSearchPreserveCase;
+    case ToggleSearchDetails:
+      return FocusToggleDetails;
+    case FilesToInclude:
+      return FocusSearchIncludeInput;
+    case FilesToExclude:
+      return FocusSearchExcludeInput;
+    case SearchOnlyOpenEditors:
+      return FocusSearchOpenEditors;
+    case UseExcludeSettings:
+      return FocusIgnoreFiles;
     default:
       return Empty$1;
   }
@@ -3474,12 +4031,18 @@ const focusMatchCasePrevious = state => {
   }
   return focusSearchValue(state);
 };
+const focusReplaceValuePrevious = state => {
+  return focusSearchValue(state);
+};
 const focusReplaceValueNext = state => {
   return focusMatchCase(state);
 };
 const focusRegexNext = state => {
   return focusPreserveCase(state);
 };
+const focusPreserveCasePrevious = state => {
+  return focusRegex(state);
+};
 const focusReplaceValue = state => {
   return focusElement(state, FocusSearchReplaceInput);
 };
@@ -3503,7 +4066,7 @@ const handleFocusIn = (state, key) => {
   if (state.focus === focusKey) {
     return state;
   }
-  void setFocus(focusKey);
+  void setFocus(FocusSearch);
   return {
     ...state,
     focus: focusKey,
@@ -3525,28 +4088,35 @@ const toggleSearchFlag = (state, flag) => {
   };
 };
 
-const toggleDetailsExpanded = state => {
-  const newState = toggleSearchFlag(state, DetailsExpanded);
-  if (hasDetailsExpanded(newState.flags)) {
-    return {
-      ...newState,
-      focus: FocusSearchIncludeInput,
-      focusSource: Script
-    };
-  }
+const collapseDetails = state => {
   return {
-    ...newState,
+    ...toggleSearchFlag(state, DetailsExpanded),
     focus: FocusSearchInput,
     focusSource: Script
   };
 };
 
+const expandDetails = state => {
+  return {
+    ...toggleSearchFlag(state, DetailsExpanded),
+    focus: FocusSearchIncludeInput,
+    focusSource: Script
+  };
+};
+
+const toggleDetailsExpanded = state => {
+  if (hasDetailsExpanded(state.flags)) {
+    return collapseDetails(state);
+  }
+  return expandDetails(state);
+};
+
 const toggleMatchCase = state => {
-  return toggleSearchFlag(state, MatchCase);
+  return toggleSearchFlag(state, MatchCase$1);
 };
 
 const toggleMatchWholeWord = state => {
-  return toggleSearchFlag(state, MatchWholeWord);
+  return toggleSearchFlag(state, MatchWholeWord$1);
 };
 
 const toggleOpenEditors = state => {
@@ -3554,7 +4124,7 @@ const toggleOpenEditors = state => {
 };
 
 const togglePreserveCase = state => {
-  return toggleSearchFlag(state, PreserveCase);
+  return toggleSearchFlag(state, PreserveCase$1);
 };
 
 const toggleReplace = state => {
@@ -3566,7 +4136,7 @@ const toggleUseIgnoreFiles = state => {
 };
 
 const toggleUseRegularExpression = state => {
-  return toggleSearchFlag(state, UseRegularExpression);
+  return toggleSearchFlag(state, UseRegularExpression$1);
 };
 
 const Keyboard = -1;
@@ -3577,7 +4147,7 @@ const show = async (x, y, id, ...args) => {
   number(y);
   number(id);
   // TODO
-  await invoke$1('ContextMenu.show', x, y, id, ...args);
+  await invoke$2('ContextMenu.show', x, y, id, ...args);
 };
 
 const Search = 18;
@@ -3625,15 +4195,19 @@ const commandMap = {
   'TextSearch.focusMatchCasePrevious': wrapCommand(focusMatchCasePrevious),
   'TextSearch.focusMatchWholeWord': wrapCommand(focusMatchWholeWord),
   'TextSearch.focusNext': wrapCommand(focusNext),
+  'TextSearch.focusNextInput': wrapCommand(focusNextInput),
   'TextSearch.focusNextPage': wrapCommand(focusNextPage),
   'TextSearch.focusPreserveCase': wrapCommand(focusPreserveCase),
+  'TextSearch.focusPreserveCasePrevious': wrapCommand(focusPreserveCasePrevious),
   'TextSearch.focusPrevious': wrapCommand(focusPrevious),
+  'TextSearch.focusPreviousInput': wrapCommand(focusPreviousInput),
   'TextSearch.focusPreviousPage': wrapCommand(focusPreviousPage),
   'TextSearch.focusRegex': wrapCommand(focusRegex),
   'TextSearch.focusRegexNext': wrapCommand(focusRegexNext),
   'TextSearch.focusReplaceAll': wrapCommand(focusReplaceAll),
   'TextSearch.focusReplaceValue': wrapCommand(focusReplaceValue$1),
   'TextSearch.focusReplaceValueNext': wrapCommand(focusReplaceValueNext),
+  'TextSearch.focusReplaceValuePrevious': wrapCommand(focusReplaceValuePrevious),
   'TextSearch.focusSearchValue': wrapCommand(focusSearchValue$1),
   'TextSearch.focusSearchValueNext': wrapCommand(focusSearchValueNext),
   'TextSearch.getActions': wrapCommand(getActions),
@@ -3642,17 +4216,19 @@ const commandMap = {
   'TextSearch.getVirtualDom': wrapCommand(getSearchVirtualDom),
   'TextSearch.handleClickAt': wrapCommand(handleClickAt),
   'TextSearch.handleContextMenu': wrapCommand(handleContextMenu),
+  'TextSearch.handleExcludeInput': wrapCommand(handleExcludeInput),
   'TextSearch.handleFocusIn': wrapCommand(handleFocusIn),
   'TextSearch.handleIconThemeChange': wrapCommand(handleIconThemeChange),
+  'TextSearch.handleIncludeInput': wrapCommand(handleIncludeInput),
   'TextSearch.handleInput': wrapCommand(handleInput),
+  'TextSearch.handleListBlur': wrapCommand(handleListBlur),
   'TextSearch.handleReplaceInput': wrapCommand(handleReplaceInput),
-  'TextSearch.handleIncludeInput': wrapCommand(handleIncludeInput),
-  'TextSearch.handleExcludeInput': wrapCommand(handleExcludeInput),
   'TextSearch.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
   'TextSearch.handleScrollBarClick': wrapCommand(handleScrollBarClick),
   'TextSearch.handleScrollBarMove': wrapCommand(handleScrollBarMove),
   'TextSearch.handleSharedInput': wrapCommand(handleSharedInput),
   'TextSearch.handleWheel': wrapCommand(handleWheel),
+  'TextSearch.launchSearchProcess': wrapCommand(launchSearchProcess),
   'TextSearch.loadContent': wrapCommand(loadContent),
   'TextSearch.refresh': wrapCommand(refresh),
   'TextSearch.replaceAll': wrapCommand(replaceAll),
@@ -3668,6 +4244,9 @@ const commandMap = {
   'TextSearch.toggleUseRegularExpression': wrapCommand(toggleUseRegularExpression),
   // not wrapped
   'TextSearch.create': create,
+  'TextSearch.getFlags': getFlags,
+  'TextSearch.getFocus': getFocus,
+  'TextSearch.getKeyBindings': getKeyBindings,
   'TextSearch.render': doRender,
   'TextSearch.saveState': saveState,
   // TODO needed?