@lvce-editor/server 0.38.7 → 0.38.9

package/static/{8a029a2 → f3cf31a}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -799,6 +799,26 @@ const WebWorkerRpcClient = {
   create: create$1$1
 };
 
+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 User = 1;
+const Script = 2;
+
 const clearSearchResults$1 = state => {
   return {
     ...state,
@@ -806,7 +826,9 @@ const clearSearchResults$1 = state => {
     items: [],
     minLineY: 0,
     maxLineY: 0,
-    message: ''
+    message: '',
+    focus: FocusSearchInput,
+    focusSource: Script
   };
 };
 
@@ -835,9 +857,6 @@ const copy = async state => {
   return state;
 };
 
-const User = 1;
-const Script = 2;
-
 const minimumSliderSize = 20;
 
 const states = Object.create(null);
@@ -874,22 +893,13 @@ const create$1 = ({
   };
 };
 
-const Empty$1 = 0;
-const FocusSearchInput = 21;
-const FocusSearchReplaceInput = 31;
-const FocusSearchMatchCase = 32;
-const FocusSearchRegex = 33;
-const FocusSearchWholeWord = 34;
-const FocusSearchReplaceAll = 35;
-const FocusSearchPreserveCase = 36;
-
-const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight) => {
+const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, value = '', replacement = '') => {
   const state = {
     uid,
     searchResults: [],
     stats: {},
     searchId: -1,
-    value: '',
+    value,
     disposed: false,
     fileCount: 0,
     x,
@@ -902,11 +912,7 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight) =
       headerHeight: 61 // TODO
     }),
     threads: 0,
-    replaceExpanded: false,
-    useRegularExpression: false,
-    matchCase: false,
-    matchWholeWord: false,
-    replacement: '',
+    replacement,
     matchCount: 0,
     listFocused: false,
     listFocusedIndex: -1,
@@ -914,7 +920,6 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight) =
     workspacePath: workspacePath,
     includeValue: '',
     excludeValue: '',
-    detailsExpanded: false,
     focus: Empty$1,
     loaded: false,
     message: '',
@@ -927,7 +932,7 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight) =
     focusedIndex: -1,
     handleOffset: 0,
     focusSource: User,
-    preserveCase: false
+    flags: 0
   };
   set(uid, state, state);
   return state;
@@ -967,59 +972,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) => {
@@ -1064,7 +1016,12 @@ const UiStrings = {
   ReplacedOneOccurrenceInOneFile: "Replaced 1 occurrence across 1 file with '{PH1}'",
   ToggleReplace: 'Toggle Replace',
   UseRegularExpression: 'Use Regular Expression',
-  ViewAsTree: 'View as Tree'
+  ViewAsTree: 'View as Tree',
+  FilesToInclude: 'Files to Include',
+  FilesToExclude: 'Files to Exclude',
+  ToggleSearchDetails: 'Toggle Search Details',
+  SearchOnlyOpenEditors: 'Search Only Open Editors',
+  UseExcludeSettings: 'Use Exclude Settings'
 };
 const noResults = () => {
   return i18nString(UiStrings.NoResults);
@@ -1084,6 +1041,9 @@ const preserveCase = () => {
 const matchWholeWord = () => {
   return i18nString(UiStrings.MatchWholeWord);
 };
+const toggleSearchDetails = () => {
+  return i18nString(UiStrings.ToggleSearchDetails);
+};
 const useRegularExpression = () => {
   return i18nString(UiStrings.UseRegularExpression);
 };
@@ -1118,9 +1078,6 @@ const confirmReplaceManyOccurrencesInOneFileNoValue = matchCount => {
   });
 };
 const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replacement) => {
-  number(matchCount);
-  number(fileCount);
-  string(replacement);
   return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFiles, {
     PH1: matchCount,
     PH2: fileCount,
@@ -1128,8 +1085,6 @@ const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replace
   });
 };
 const confirmReplaceManyOccurrencesInManyFilesNoValue = (matchCount, fileCount) => {
-  number(matchCount);
-  number(fileCount);
   return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFilesNoValue, {
     PH1: matchCount,
     PH2: fileCount
@@ -1156,10 +1111,20 @@ const viewAsTree = () => {
 const collapseAll = () => {
   return i18nString(UiStrings.CollapseAll);
 };
+const filesToInclude = () => {
+  return i18nString(UiStrings.FilesToInclude);
+};
+const filesToExclude = () => {
+  return i18nString(UiStrings.FilesToExclude);
+};
+const searchOnlyOpenEditors = () => {
+  return i18nString(UiStrings.SearchOnlyOpenEditors);
+};
+const useExcludeSettings = () => {
+  return i18nString(UiStrings.UseExcludeSettings);
+};
 
 const getStatusMessage = (resultCount, fileResultCount) => {
-  number(resultCount);
-  number(fileResultCount);
   if (resultCount === 0) {
     return noResults();
   }
@@ -1309,10 +1274,131 @@ const focusMatchCase$1 = state => {
   };
 };
 
+const PreserveCase = 1 << 0; // 1
+const UseRegularExpression = 1 << 1; // 2
+const ReplaceExpanded = 1 << 2; // 4
+const MatchWholeWord = 1 << 3; // 8
+const MatchCase = 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;
+};
+const hasUseRegularExpression = flags => {
+  return (flags & UseRegularExpression) === UseRegularExpression;
+};
+const hasReplaceExpanded = flags => {
+  return (flags & ReplaceExpanded) === ReplaceExpanded;
+};
+const hasMatchWholeWord = flags => {
+  return (flags & MatchWholeWord) === MatchWholeWord;
+};
+const hasMatchCase = flags => {
+  return (flags & MatchCase) === MatchCase;
+};
+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
+    focus: FocusSearchReplaceInput,
+    focusSource: Script
   };
 };
 
@@ -1324,10 +1410,7 @@ const focusSearchValue$1 = state => {
 };
 
 const focusSearchValueNext = state => {
-  const {
-    replaceExpanded
-  } = state;
-  if (replaceExpanded) {
+  if (hasReplaceExpanded(state.flags)) {
     return focusReplaceValue$1(state);
   }
   return focusMatchCase$1(state);
@@ -1339,6 +1422,7 @@ const Status = 'status';
 const Tree = 'tree';
 const TreeItem$1 = 'treeitem';
 const ToolBar = 'toolbar';
+const Button$2 = 'button';
 
 const Actions = 'Actions';
 const Badge = 'Badge';
@@ -1355,9 +1439,12 @@ const IconButton = 'IconButton';
 const Label = 'Label';
 const List = 'List';
 const MaskIcon = 'MaskIcon';
+const MaskIconBook = 'MaskIconBook';
 const MaskIconCaseSensitive = 'MaskIconCaseSensitive';
 const MaskIconChevronDown = 'MaskIconChevronDown';
 const MaskIconChevronRight = 'MaskIconChevronRight';
+const MaskIconEllipsis = 'MaskIconEllipsis';
+const MaskIconExclude = 'MaskIconExclude';
 const MaskIconPreserveCase = 'MaskIconPreserveCase';
 const MaskIconRegex = 'MaskIconRegex';
 const MaskIconReplaceAll = 'MaskIconReplaceAll';
@@ -1371,12 +1458,16 @@ const SearchFieldButtons = 'SearchFieldButtons';
 const SearchFieldContainer = 'SearchFieldContainer';
 const SearchHeader = 'SearchHeader';
 const SearchHeaderDetails = 'SearchHeaderDetails';
+const SearchHeaderDetailsExpanded = 'SearchHeaderDetailsExpanded';
+const SearchHeaderDetailsExpandedTop = 'SearchHeaderDetailsExpandedTop';
+const SearchHeaderDetailsHeading = 'SearchHeaderDetailsHeading';
 const SearchHeaderTop = 'SearchHeaderTop';
 const SearchHeaderTopRight = 'SearchHeaderTopRight';
 const SearchRemove = 'SearchRemove';
 const SearchToggleButton = 'SearchToggleButton';
 const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
 const SourceControlBadge = 'SourceControlBadge';
+const ToggleDetails = 'ToggleDetails';
 const TreeItem = 'TreeItem';
 const TreeItemActive = 'TreeItemActive';
 const Viewlet = 'Viewlet';
@@ -1385,13 +1476,13 @@ const ViewletSearchMessage = 'ViewletSearchMessage';
 const Button$1 = 1;
 
 const Button = 1;
+const Del = 21;
 const Div = 4;
-const Input = 6;
-const Span = 8;
-const Text = 12;
+const H4 = 24;
 const Img = 17;
 const Ins = 20;
-const Del = 21;
+const Span = 8;
+const Text = 12;
 const TextArea = 62;
 
 const mergeClassNames = (...classNames) => {
@@ -1440,6 +1531,67 @@ const getActionsVirtualDom = actions => {
   }, ...actions.flatMap(getActionVirtualDom)];
 };
 
+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';
@@ -1584,6 +1736,48 @@ const HandleHeaderClick = 'handleHeaderClick';
 const HandleHeaderFocusIn = 'handleHeaderFocusIn';
 const HandleListBlur = 'handleListBlur';
 
+const getSearchDetailsToggleVirtualDom = () => {
+  return [{
+    type: Div,
+    className: ToggleDetails,
+    role: Button$2,
+    tabIndex: 0,
+    ariaLabel: toggleSearchDetails(),
+    title: toggleSearchDetails(),
+    childCount: 1
+  }, {
+    type: Div,
+    className: mergeClassNames(MaskIcon, MaskIconEllipsis),
+    childCount: 0
+  }];
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const getSearchMessageVirtualDom = message => {
+  return [{
+    type: Div,
+    className: ViewletSearchMessage,
+    role: Status,
+    tabIndex: 0,
+    childCount: 1
+  }, text(message)];
+};
+
+const getSearchHeaderDetailsCollapsedVirtualDom = message => {
+  return [{
+    type: Div,
+    className: SearchHeaderDetails,
+    childCount: 2
+  }, ...getSearchMessageVirtualDom(message), ...getSearchDetailsToggleVirtualDom()];
+};
+
 const getSearchFieldButtonVirtualDom = button => {
   const {
     icon,
@@ -1651,61 +1845,89 @@ const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, out
   return dom;
 };
 
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
-};
-
-const getSearchHeaderVirtualDom = (replaceExpanded, matchCase$1, matchWholeWord$1, useRegularExpression$1, detailsExpanded) => {
-  const dom = [{
+const getSearchHeaderDetailsExpandedVirtualDom = (flags, message) => {
+  const includeButtons = [{
+    icon: MaskIconBook,
+    title: searchOnlyOpenEditors(),
+    command: 'searchOnlyOpenEditors',
+    checked: Boolean(flags & OpenEditors)
+  }];
+  const excludeButtons = [{
+    icon: MaskIconExclude,
+    title: useExcludeSettings(),
+    command: 'toggleUseExcludeSettings',
+    checked: Boolean(flags & UseIgnoreFiles)
+  }];
+  return [{
     type: Div,
-    className: SearchHeader,
-    role: None,
-    childCount: 2,
-    onClick: HandleHeaderClick,
-    onFocusIn: HandleHeaderFocusIn
+    className: SearchHeaderDetailsExpanded,
+    childCount: 5
   }, {
     type: Div,
-    className: SearchHeaderTop,
-    role: None,
+    className: SearchHeaderDetailsExpandedTop,
     childCount: 2
-  }, {
+  }, ...getSearchDetailsToggleVirtualDom(), {
+    type: H4,
+    className: SearchHeaderDetailsHeading,
+    childCount: 1
+  }, text(filesToInclude()), ...getSearchFieldVirtualDom('files-to-include-value', 'Include', 'handleIncludeInput', includeButtons, []), {
+    type: H4,
+    className: SearchHeaderDetailsHeading,
+    childCount: 1
+  }, text(filesToExclude()), ...getSearchFieldVirtualDom('files-to-exclude-value', 'Exclude', 'handleExcludeInput', excludeButtons, []), ...getSearchMessageVirtualDom(message)];
+};
+
+const getSearchHeaderDetailsVirtualDom = (flags, message) => {
+  if (flags & DetailsExpanded) {
+    return getSearchHeaderDetailsExpandedVirtualDom(flags, message);
+  }
+  return getSearchHeaderDetailsCollapsedVirtualDom(message);
+};
+
+const getSearchToggleVirtualDom = flags => {
+  return [{
     type: Button,
-    className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
+    className: mergeClassNames(IconButton, SearchToggleButton, hasReplaceExpanded(flags) ? SearchToggleButtonExpanded : ''),
     title: toggleReplace$1(),
     ariaLabel: toggleReplace$1(),
-    ariaExpanded: replaceExpanded,
+    ariaExpanded: hasReplaceExpanded(flags),
     childCount: 1,
     'data-command': 'toggleReplace'
   }, {
     type: Div,
-    className: mergeClassNames(MaskIcon, replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight),
+    className: mergeClassNames(MaskIcon, hasReplaceExpanded(flags) ? MaskIconChevronDown : MaskIconChevronRight),
     childCount: 0
-  }, {
+  }];
+};
+
+const getSearchHeaderTopVirtualDom = flags => {
+  const dom = [{
+    type: Div,
+    className: SearchHeaderTop,
+    role: None,
+    childCount: 2
+  }, ...getSearchToggleVirtualDom(flags), {
     type: Div,
     className: SearchHeaderTopRight,
     role: None,
-    childCount: replaceExpanded ? 2 : 1
+    childCount: hasReplaceExpanded(flags) ? 2 : 1
   }, ...getSearchFieldVirtualDom('search-value', 'Search', 'handleInput', [{
     icon: MaskIconCaseSensitive,
-    checked: matchCase$1,
+    checked: hasMatchCase(flags),
     title: matchCase()
   }, {
     icon: MaskIconWholeWord,
-    checked: matchWholeWord$1,
+    checked: hasMatchWholeWord(flags),
     title: matchWholeWord()
   }, {
     icon: MaskIconRegex,
-    checked: useRegularExpression$1,
+    checked: hasUseRegularExpression(flags),
     title: useRegularExpression()
   }], [])];
-  if (replaceExpanded) {
+  if (hasReplaceExpanded(flags)) {
     dom.push(...getSearchFieldVirtualDom('search-replace-value', 'Replace', 'handleReplaceInput', [{
       icon: MaskIconPreserveCase,
-      checked: false,
+      checked: hasPreserveCase(flags),
       title: preserveCase()
     }], [{
       icon: MaskIconReplaceAll,
@@ -1713,24 +1935,18 @@ const getSearchHeaderVirtualDom = (replaceExpanded, matchCase$1, matchWholeWord$
       title: replaceAll$1()
     }]));
   }
-  if (detailsExpanded) {
-    console.log({
-      detailsExpanded
-    });
-    // @ts-ignore
-    dom[0].childCount++;
-    dom.push({
-      type: Div,
-      className: SearchHeaderDetails,
-      childCount: 4
-    }, text('files to include'), {
-      type: Input,
-      childCount: 0
-    }, text('files to exclude'), {
-      type: Input,
-      childCount: 0
-    });
-  }
+  return dom;
+};
+
+const getSearchHeaderVirtualDom = (flags, message) => {
+  const dom = [{
+    type: Div,
+    className: SearchHeader,
+    role: None,
+    childCount: 2,
+    onClick: HandleHeaderClick,
+    onFocusIn: HandleHeaderFocusIn
+  }, ...getSearchHeaderTopVirtualDom(flags), ...getSearchHeaderDetailsVirtualDom(flags, message)];
   return dom;
 };
 
@@ -1752,9 +1968,6 @@ const chevronDownVirtualDom = {
   className: mergeClassNames(Chevron, MaskIconChevronRight),
   childCount: 0
 });
-const getChevronDownVirtualDom = () => {
-  return chevronDownVirtualDom;
-};
 
 const getFileIconVirtualDom = icon => {
   return {
@@ -1851,7 +2064,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) {
@@ -1871,22 +2084,8 @@ const getSearchResultVirtualDom = rowInfo => {
   return dom;
 };
 
-const getSearchResultsVirtualDom = visibleItems => {
-  return visibleItems.flatMap(getSearchResultVirtualDom);
-};
-
-const getSearchVirtualDom = (visibleItems, replaceExpanded, matchCase, matchWholeWord, useRegularExpression, message, detailsExpanded, focusOutline) => {
-  const dom = [{
-    type: Div,
-    className: mergeClassNames(Viewlet, Search$1),
-    childCount: 2
-  }, ...getSearchHeaderVirtualDom(replaceExpanded, matchCase, matchWholeWord, useRegularExpression, detailsExpanded), {
-    type: Div,
-    className: ViewletSearchMessage,
-    role: Status,
-    tabIndex: 0,
-    childCount: 1
-  }, text(message), {
+const getSearchResultsVirtualDom = (visibleItems, focusOutline) => {
+  return [{
     type: Div,
     className: mergeClassNames(Viewlet, List, focusOutline ? FocusOutline : Empty),
     role: Tree,
@@ -1894,19 +2093,16 @@ const getSearchVirtualDom = (visibleItems, replaceExpanded, matchCase, matchWhol
     childCount: visibleItems.length,
     onClick: HandleClick,
     onBlur: HandleListBlur
-  }, ...getSearchResultsVirtualDom(visibleItems)];
-  return dom;
+  }, ...visibleItems.flatMap(getSearchResultVirtualDom)];
 };
 
-const handleIconThemeChange = state => {
-  const {
-    items
-  } = state;
-  const newItems = [...items];
-  return {
-    ...state,
-    items: newItems
-  };
+const getSearchVirtualDom = (visibleItems, flags, message, focusOutline) => {
+  const dom = [{
+    type: Div,
+    className: mergeClassNames(Viewlet, Search$1),
+    childCount: 2
+  }, ...getSearchHeaderVirtualDom(flags, message), ...getSearchResultsVirtualDom(visibleItems, focusOutline)];
+  return dom;
 };
 
 const handleError = error => {
@@ -1994,6 +2190,59 @@ 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 protocolMatch = uri.match(RE_PROTOCOL);
@@ -2628,10 +2877,9 @@ const handleUpdate = async (state, update) => {
       itemHeight,
       minimumSliderSize,
       headerHeight,
-      matchCase,
+      flags,
       value,
-      threads,
-      useRegularExpression
+      threads
     } = partialNewState;
     if (isEmptyString(value)) {
       return {
@@ -2640,7 +2888,6 @@ const handleUpdate = async (state, update) => {
         maxLineY: 0,
         deltaY: 0,
         items: [],
-        matchIndex: 0,
         matchCount: 0,
         message: '',
         loaded: true
@@ -2649,8 +2896,8 @@ const handleUpdate = async (state, update) => {
     const root = state.workspacePath;
     const results = await textSearch(root, value, {
       threads,
-      isCaseSensitive: matchCase,
-      useRegularExpression
+      isCaseSensitive: hasMatchCase(flags),
+      useRegularExpression: hasUseRegularExpression(flags)
     }, state.assetDir);
     if (!Array.isArray(results)) {
       throw new TypeError('results must be of type array');
@@ -2699,6 +2946,35 @@ const handleUpdate = async (state, update) => {
   }
 };
 
+const handleExcludeInput = (state, value, inputSource = Script) => {
+  return handleUpdate(state, {
+    excludeValue: value,
+    inputSource
+  });
+};
+
+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, {
     value,
@@ -2713,6 +2989,24 @@ const handleReplaceInput = (state, value, inputSource = Script) => {
   });
 };
 
+const getInputHandler = name => {
+  switch (name) {
+    case 'search-value':
+      return handleInput;
+    case 'replacement-value':
+      return handleReplaceInput;
+    case 'files-to-exclude-value':
+      return handleExcludeInput;
+    default:
+      throw new Error(`unknown input handler: ${name}`);
+  }
+};
+
+const handleSharedInput = (state, name, value, inputSource = Script) => {
+  const fn = getInputHandler(name);
+  return fn(state, value, inputSource);
+};
+
 const first = () => {
   return 0;
 };
@@ -2825,29 +3119,29 @@ const focusNextPage = state => {
   return focusIndex(state, indexNextPage);
 };
 
-const focusPreviousPage = state => {
+const focusPrevious = state => {
   const {
     focusedIndex,
-    minLineY,
-    maxLineY
+    items
   } = state;
   if (focusedIndex === 0 || focusedIndex === -1) {
     return state;
   }
-  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
-  return focusIndex(state, indexPreviousPage);
+  const previousIndex = previous(items, focusedIndex);
+  return focusIndex(state, previousIndex);
 };
 
-const focusPrevious = state => {
+const focusPreviousPage = state => {
   const {
     focusedIndex,
-    items
+    minLineY,
+    maxLineY
   } = state;
   if (focusedIndex === 0 || focusedIndex === -1) {
     return state;
   }
-  const previousIndex = previous(items, focusedIndex);
-  return focusIndex(state, previousIndex);
+  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
+  return focusIndex(state, indexPreviousPage);
 };
 
 const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
@@ -2856,19 +3150,6 @@ const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
   return index;
 };
 
-const openUri = async (path, focus = true, props = {}) => {
-  await invoke$1(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
-};
-
-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 selectIndexFile = (state, searchResult, index) => {
   const {
     collapsedPaths
@@ -2882,6 +3163,20 @@ const selectIndexFile = (state, searchResult, index) => {
     listFocused: true
   };
 };
+
+const openUri = async (path, focus = true, props = {}) => {
+  await invoke$1(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
+};
+
+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 selectIndexPreview = async (state, searchResult, index) => {
   const {
     items
@@ -2906,6 +3201,7 @@ const selectIndexPreview = async (state, searchResult, index) => {
     listFocused: false
   };
 };
+
 const selectIndex = async (state, index) => {
   if (index === -1) {
     return {
@@ -2947,9 +3243,6 @@ const handleScrollBarCaptureLost = state => {
 };
 
 const clamp = (num, min, max) => {
-  number(num);
-  number(min);
-  number(max);
   return Math.min(Math.max(num, min), max);
 };
 
@@ -3047,31 +3340,39 @@ const getSavedValue = savedState => {
   }
   return '';
 };
-const getSavedReplaceExpanded = savedState => {
-  if (savedState && typeof savedState === 'object' && 'replaceExpanded' in savedState && typeof savedState.replaceExpanded === 'boolean') {
-    return savedState.replaceExpanded;
+const getSavedReplacement = savedState => {
+  if (savedState && typeof savedState === 'object' && 'replacement' in savedState && typeof savedState.replacement === 'string') {
+    return savedState.replacement;
   }
-  return false;
+  return '';
 };
-const getSavedCollapsedPaths = savedState => {
-  if (savedState && typeof savedState === 'object' && 'collapsedPaths' in savedState && Array.isArray(savedState.collapsedPaths) && savedState.collapsedPaths.every(path => typeof path === 'string')) {
-    return savedState.collapsedPaths;
+const getSavedFlags = savedState => {
+  if (savedState && typeof savedState === 'object' && 'flags' in savedState && typeof savedState.flags === 'number') {
+    return savedState.flags;
   }
-  return [];
+  return 0;
 };
-const getThreads = () => {
-  return 1;
+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 restoreState = savedState => {
-  const savedValue = getSavedValue(savedState);
-  const savedReplaceExpanded = getSavedReplaceExpanded(savedState);
-  const savedCollapsedPaths = getSavedCollapsedPaths(savedState);
-  const threads = getThreads();
   return {
-    savedCollapsedPaths,
-    savedReplaceExpanded,
-    savedValue,
-    threads
+    savedValue: getSavedValue(savedState),
+    replacement: getSavedReplacement(savedState),
+    savedCollapsedPaths: [],
+    threads: 1,
+    flags: getSavedFlags(savedState),
+    includeValue: getSavedIncludeValue(savedState),
+    excludeValue: getSavedExcludeValue(savedState)
   };
 };
 
@@ -3079,22 +3380,28 @@ const loadContent = async (state, savedState) => {
   const {
     savedValue,
     savedCollapsedPaths,
-    savedReplaceExpanded,
-    threads
+    threads,
+    replacement,
+    flags,
+    includeValue,
+    excludeValue
   } = restoreState(savedState);
   if (savedValue) {
     return handleUpdate(state, {
       value: savedValue,
       threads,
-      replaceExpanded: savedReplaceExpanded,
       inputSource: Script,
-      collapsedPaths: savedCollapsedPaths
+      collapsedPaths: savedCollapsedPaths,
+      replacement,
+      flags,
+      includeValue,
+      excludeValue
     });
   }
   return {
     ...state,
     threads,
-    replaceExpanded: savedReplaceExpanded,
+    flags,
     loaded: true
   };
 };
@@ -3103,43 +3410,96 @@ const refresh = state => {
   return handleUpdate(state, {});
 };
 
-const renderItems = {
-  isEqual(oldState, newState) {
-    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.replacement === newState.replacement && oldState.replaceExpanded === newState.replaceExpanded && oldState.matchCase === newState.matchCase && oldState.matchWholeWord === newState.matchWholeWord && oldState.useRegularExpression === newState.useRegularExpression && oldState.message === newState.message && oldState.detailsExpanded === newState.detailsExpanded && oldState.loaded === newState.loaded && oldState.collapsedPaths === newState.collapsedPaths && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.listFocused === newState.listFocused;
-  },
-  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 focusOutline = newState.listFocused && newState.listFocusedIndex === -1;
-    const dom = getSearchVirtualDom(displayResults, newState.replaceExpanded, newState.matchCase, newState.matchWholeWord, newState.useRegularExpression, newState.message, newState.detailsExpanded, focusOutline);
-    return ['Viewlet.setDom2', newState.uid, dom];
-  }
-};
-const getSelector = focusKey => {
+// TODO just return name
+const getFocusSelector = focusKey => {
   switch (focusKey) {
     case FocusSearchInput:
       return '[name="search-value"]';
     case FocusSearchReplaceInput:
       return '[name="search-replace-value"]';
+    case FocusToggleDetails:
+      return '[title="Toggle Search Details"]';
     case FocusSearchMatchCase:
       return '[title="Match Case"]';
     case FocusSearchPreserveCase:
       return '[title="Preserve Case"]';
     case FocusSearchRegex:
       return '[title="Use Regular Expression"]';
+    case FocusSearchIncludeInput:
+      return '[name="files-to-include-value"]';
+    case FocusSearchExcludeInput:
+      return '[name="files-to-exclude-value"]';
+    case FocusSearchWholeWord:
+      return '[title="Match Whole Word"]';
+    case FocusSearchReplaceAll:
+      return '[title="Replace All"]';
+    case FocusSearchOpenEditors:
+      return '[title="Search Only Open Editors"]';
+    case FocusIgnoreFiles:
+      return '[title="Use Exclude Settings"]';
+    case FocusToggleReplace:
+      return '[aria-label="Toggle Replace"]';
     default:
       return '';
   }
 };
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    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 focusOutline = newState.listFocused && newState.listFocusedIndex === -1;
+    const dom = getSearchVirtualDom(displayResults, newState.flags, newState.message, focusOutline);
+    return ['Viewlet.setDom2', newState.uid, dom];
+  }
+};
 const renderFocus = {
   isEqual(oldState, newState) {
     return oldState.focus === newState.focus || newState.focusSource === User;
   },
-  apply(newState) {
-    const selector = getSelector(newState.focus);
+  apply(oldState, newState) {
+    const selector = getFocusSelector(newState.focus);
     return ['Viewlet.send', newState.uid, 'setFocus', selector, newState.focusSource];
   }
 };
-const render = [renderItems, renderFocus];
+const renderValue = {
+  isEqual(oldState, newState) {
+    return oldState.value === newState.value || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    return ['Viewlet.send', newState.uid, 'setValue', newState.value, '[name="search-value"]'];
+  }
+};
+const renderReplacement = {
+  isEqual(oldState, newState) {
+    return oldState.replacement === newState.replacement || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    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, renderIncludeValue, renderExcludeValue, renderReplacement, renderFocus];
 const doRender = uid => {
   const {
     oldState,
@@ -3246,11 +3606,17 @@ const saveState = uid => {
   } = get(uid);
   const {
     value,
-    replaceExpanded
+    replacement,
+    flags,
+    includeValue,
+    excludeValue
   } = newState;
   return {
     value,
-    replaceExpanded
+    replacement,
+    flags,
+    includeValue,
+    excludeValue
   };
 };
 
@@ -3282,6 +3648,16 @@ const getSearchFocusKey = key => {
       return FocusSearchReplaceAll;
     case 'Preserve Case':
       return FocusSearchPreserveCase;
+    case 'Toggle Search Details':
+      return FocusToggleDetails;
+    case 'files-to-include-value':
+      return FocusSearchIncludeInput;
+    case 'files-to-exclude-value':
+      return FocusSearchExcludeInput;
+    case 'Search Only Open Editors':
+      return FocusSearchOpenEditors;
+    case 'Use Exclude Settings':
+      return FocusIgnoreFiles;
     default:
       return Empty$1;
   }
@@ -3291,20 +3667,23 @@ const focusSearchValue = state => {
   return focusElement(state, FocusSearchInput);
 };
 const focusMatchCasePrevious = state => {
-  const {
-    replaceExpanded
-  } = state;
-  if (replaceExpanded) {
+  if (hasReplaceExpanded(state.flags)) {
     return focusReplaceValue(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);
 };
@@ -3328,7 +3707,7 @@ const handleFocusIn = (state, key) => {
   if (state.focus === focusKey) {
     return state;
   }
-  void setFocus(focusKey);
+  void setFocus(FocusSearch);
   return {
     ...state,
     focus: focusKey,
@@ -3343,54 +3722,62 @@ const submit = state => {
   });
 };
 
-const toggleMatchCase = state => {
-  const {
-    matchCase
-  } = state;
+const toggleSearchFlag = (state, flag) => {
   return {
     ...state,
-    matchCase: !matchCase
+    flags: state.flags ^ flag
   };
 };
 
-const toggleMatchWholeWord = state => {
-  const {
-    matchWholeWord
-  } = state;
+const collapseDetails = state => {
   return {
-    ...state,
-    matchWholeWord: !matchWholeWord
+    ...toggleSearchFlag(state, DetailsExpanded),
+    focus: FocusSearchInput,
+    focusSource: Script
   };
 };
 
-const togglePreserveCase = state => {
-  const {
-    preserveCase
-  } = state;
+const expandDetails = state => {
   return {
-    ...state,
-    preserveCase: !preserveCase
+    ...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);
+};
+
+const toggleMatchWholeWord = state => {
+  return toggleSearchFlag(state, MatchWholeWord);
+};
+
+const toggleOpenEditors = state => {
+  return toggleSearchFlag(state, OpenEditors);
+};
+
+const togglePreserveCase = state => {
+  return toggleSearchFlag(state, PreserveCase);
+};
+
 const toggleReplace = state => {
-  const {
-    replaceExpanded
-  } = state;
-  return {
-    ...state,
-    replaceExpanded: !replaceExpanded
-  };
+  return toggleSearchFlag(state, ReplaceExpanded);
+};
+
+const toggleUseIgnoreFiles = state => {
+  return toggleSearchFlag(state, UseIgnoreFiles);
 };
 
 const toggleUseRegularExpression = state => {
-  const {
-    useRegularExpression
-  } = state;
-  return {
-    ...state,
-    useRegularExpression: !useRegularExpression
-  };
+  return toggleSearchFlag(state, UseRegularExpression);
 };
 
 const Keyboard = -1;
@@ -3449,15 +3836,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),
@@ -3466,13 +3857,16 @@ 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.handleReplaceInput': wrapCommand(handleReplaceInput),
   'TextSearch.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
   'TextSearch.handleScrollBarClick': wrapCommand(handleScrollBarClick),
   'TextSearch.handleScrollBarMove': wrapCommand(handleScrollBarMove),
+  'TextSearch.handleSharedInput': wrapCommand(handleSharedInput),
   'TextSearch.handleWheel': wrapCommand(handleWheel),
   'TextSearch.loadContent': wrapCommand(loadContent),
   'TextSearch.refresh': wrapCommand(refresh),
@@ -3481,13 +3875,17 @@ const commandMap = {
   'TextSearch.submit': wrapCommand(submit),
   'TextSearch.toggleMatchCase': wrapCommand(toggleMatchCase),
   'TextSearch.toggleMatchWholeWord': wrapCommand(toggleMatchWholeWord),
+  'TextSearch.toggleOpenEditors': wrapCommand(toggleOpenEditors),
   'TextSearch.togglePreserveCase': wrapCommand(togglePreserveCase),
   'TextSearch.toggleReplace': wrapCommand(toggleReplace),
+  'TextSearch.toggleSearchDetails': wrapCommand(toggleDetailsExpanded),
+  'TextSearch.toggleUseIgnoreFiles': wrapCommand(toggleUseIgnoreFiles),
   'TextSearch.toggleUseRegularExpression': wrapCommand(toggleUseRegularExpression),
   // not wrapped
   'TextSearch.create': create,
   'TextSearch.render': doRender,
   'TextSearch.saveState': saveState,
+  'TextSearch.getKeyBindings': getKeyBindings,
   // TODO needed?
   'TextSearch.textSearch': textSearch
 };