@lvce-editor/static-server 0.69.0 → 0.69.2

package/static/{eb102f6 → 5f26f20}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -1327,6 +1327,9 @@ const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
+const handleWorkspaceRefresh = async () => {
+  return invoke$1('Layout.handleWorkspaceRefresh');
+};
 const sendMessagePortToSearchProcess = async port => {
   await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
 };
@@ -1684,10 +1687,13 @@ const clearSearchResults$1 = state => {
     focusSource: Script,
     inputSource: Script,
     items: [],
+    limitHit: false,
+    limitHitWarning: '',
     maxLineY: 0,
     message: '',
     minLineY: 0,
     replacement: '',
+    searchInputErrorMessage: '',
     value: ''
   };
 };
@@ -1747,8 +1753,8 @@ const collapseDetails = state => {
 
 const copy$1 = async state => {
   const {
-    items,
-    focusedIndex
+    focusedIndex,
+    items
   } = state;
   if (focusedIndex === -1) {
     return state;
@@ -1760,8 +1766,8 @@ const copy$1 = async state => {
 
 const copyPath$1 = async state => {
   const {
-    items,
     focusedIndex,
+    items,
     listFocusedIndex
   } = state;
   const actualIndex = focusedIndex === -1 ? listFocusedIndex : focusedIndex;
@@ -1777,111 +1783,112 @@ const minimumSliderSize = 20;
 
 const {
   get: get$1,
+  getCommandIds,
+  registerCommands,
   set,
   wrapCommand,
-  registerCommands,
-  getCommandIds,
   wrapGetter
 } = create$2();
 
 const List = 1;
 
 const create$1 = ({
-  itemHeight,
   headerHeight = 0,
+  itemHeight,
   minimumSliderSize = 20
 }) => {
   return {
     deltaY: 0,
-    minLineY: 0,
-    maxLineY: 0,
     finalDeltaY: 0,
-    itemHeight,
+    focusedIndex: -1,
     headerHeight,
+    itemHeight,
     items: [],
     listItems: [],
+    maxLineY: 0,
     minimumSliderSize,
-    focusedIndex: -1,
-    touchOffsetY: 0,
-    touchTimeStamp: 0,
-    touchDifference: 0,
+    minLineY: 0,
+    scrollBarActive: false,
     scrollBarHeight: 0,
-    scrollBarActive: false
+    touchDifference: 0,
+    touchOffsetY: 0,
+    touchTimeStamp: 0
   };
 };
 
 const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, value = '', replacement = '', platform) => {
   const state = {
-    uid,
+    disposed: false,
+    fileCount: 0,
+    height,
     searchResults: [],
     stats: {},
+    uid,
     value,
-    disposed: false,
-    fileCount: 0,
+    width,
     x,
     y,
-    width,
-    height,
     ...create$1({
+      headerHeight: 61,
+      // TODO
       itemHeight: itemHeight || 22,
-      minimumSliderSize: minimumSliderSize,
-      headerHeight: 61 // TODO
+      minimumSliderSize: minimumSliderSize
     }),
-    threads: 0,
-    replacement,
-    matchCount: 0,
-    listFocused: false,
-    listFocusedIndex: -1,
-    inputSource: User,
-    workspacePath: workspacePath,
-    includeValue: '',
-    excludeValue: '',
-    focus: Empty,
-    loaded: false,
-    message: '',
-    collapsedPaths: [],
-    icons: [],
     assetDir,
+    collapsedPaths: [],
     deltaY: 0,
+    excludeValue: '',
+    fileIconCache: {},
     finalDeltaY: 0,
+    flags: 0,
+    focus: Empty,
     focused: false,
     focusedIndex: -1,
-    handleOffset: 0,
     focusSource: User,
-    flags: 0,
-    platform,
-    searchInputErrorMessage: '',
+    handleOffset: 0,
     history: [],
     historyIndex: -1,
-    viewMode: List,
+    icons: [],
+    includeValue: '',
     incrementalSearch: false,
-    searchId: '',
-    useChevrons: true,
-    useFileIcons: true,
+    inputSource: User,
+    limit: 20_000,
     limitHit: false,
     limitHitWarning: '',
-    limit: 20_000,
-    fileIconCache: {},
-    removeButtonWidth: 20,
+    listFocused: false,
+    listFocusedIndex: -1,
+    loaded: false,
+    matchCount: 0,
+    message: '',
+    platform,
     removeButtonRight: 0,
+    removeButtonWidth: 20,
+    replacement,
+    searchId: '',
+    searchInputErrorMessage: '',
     selections: {
-      SearchValue: {
-        start: 0,
-        end: 0
-      },
-      ReplaceValue: {
-        start: 0,
-        end: 0
-      },
       FilesToExclude: {
-        start: 0,
-        end: 0
+        end: 0,
+        start: 0
       },
       FilesToInclude: {
-        start: 0,
-        end: 0
+        end: 0,
+        start: 0
+      },
+      ReplaceValue: {
+        end: 0,
+        start: 0
+      },
+      SearchValue: {
+        end: 0,
+        start: 0
       }
-    }
+    },
+    threads: 0,
+    useChevrons: true,
+    useFileIcons: true,
+    viewMode: List,
+    workspacePath: workspacePath
   };
   set(uid, state, state);
   return state;
@@ -1946,8 +1953,8 @@ const diff = (oldState, newState) => {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get$1(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
@@ -1998,9 +2005,9 @@ const toIconRequest = item => {
   const filePath = getFilePath(item.text);
   const fileName = getFileName(filePath);
   return {
-    type: File$2,
     name: fileName,
-    path: filePath
+    path: filePath,
+    type: File$2
   };
 };
 const getMissingIconRequests = (dirents, fileIconCache) => {
@@ -2068,14 +2075,14 @@ const getNewMinMax = (newItemsLength, minLineY, maxLineY, deltaY, itemHeight) =>
     const newDeltaY = newMinLineY * itemHeight;
     return {
       newDeltaY,
-      newMinLineY,
-      newMaxLineY: newItemsLength
+      newMaxLineY: newItemsLength,
+      newMinLineY
     };
   }
   return {
     newDeltaY: deltaY,
-    newMinLineY: minLineY,
-    newMaxLineY: maxLineY
+    newMaxLineY: maxLineY,
+    newMinLineY: minLineY
   };
 };
 
@@ -2098,11 +2105,11 @@ const getSetSize = (items, index) => {
 const getRemoveIndicesFile = (items, item, index, matchCount, fileCount) => {
   const setSize = getSetSize(items, index);
   return {
-    startIndex: index,
-    removeCount: setSize + 1,
-    newFocusedIndex: index + setSize + 1 < items.length ? index : index - 1,
     newFileCount: fileCount - 1,
-    newMatchCount: matchCount - setSize
+    newFocusedIndex: index + setSize + 1 < items.length ? index : index - 1,
+    newMatchCount: matchCount - setSize,
+    removeCount: setSize + 1,
+    startIndex: index
   };
 };
 const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
@@ -2111,19 +2118,19 @@ const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
       const setSize = getSetSize(items, i);
       if (setSize === 1) {
         return {
-          startIndex: i,
-          removeCount: 2,
-          newFocusedIndex: i - 1,
           newFileCount: fileCount - 1,
-          newMatchCount: matchCount - 1
+          newFocusedIndex: i - 1,
+          newMatchCount: matchCount - 1,
+          removeCount: 2,
+          startIndex: i
         };
       }
       return {
-        startIndex: index,
-        removeCount: 1,
-        newFocusedIndex: index,
         newFileCount: fileCount,
-        newMatchCount: matchCount - 1
+        newFocusedIndex: index,
+        newMatchCount: matchCount - 1,
+        removeCount: 1,
+        startIndex: index
       };
     }
   }
@@ -2142,17 +2149,17 @@ const getRemoveIndices = (items, index, matchCount, fileCount) => {
 };
 const removeItemFromItems = (items, index, matchCount, fileCount) => {
   const {
-    startIndex,
-    removeCount,
-    newFocusedIndex,
     newFileCount,
-    newMatchCount
+    newFocusedIndex,
+    newMatchCount,
+    removeCount,
+    startIndex
   } = getRemoveIndices(items, index, matchCount, fileCount);
   const newItems = remove$1(items, startIndex, removeCount);
   return {
-    newItems,
-    newFocusedIndex,
     newFileCount,
+    newFocusedIndex,
+    newItems,
     newMatchCount
   };
 };
@@ -2401,32 +2408,32 @@ const getStatusMessage = (resultCount, fileResultCount) => {
 
 const removeIndex = async (state, index) => {
   const {
+    deltaY,
+    fileCount,
     fileIconCache,
-    minimumSliderSize,
-    height,
     headerHeight,
+    height,
+    itemHeight,
     items,
-    fileCount,
     matchCount,
-    minLineY,
     maxLineY,
-    deltaY,
-    itemHeight
+    minimumSliderSize,
+    minLineY
   } = state;
   if (index === -1) {
     return state;
   }
   const {
-    newItems,
+    newFileCount,
     newFocusedIndex,
-    newMatchCount,
-    newFileCount
+    newItems,
+    newMatchCount
   } = removeItemFromItems(items, index, matchCount, fileCount);
   const message = getStatusMessage(newMatchCount, newFileCount);
   const {
-    newMinLineY,
+    newDeltaY,
     newMaxLineY,
-    newDeltaY
+    newMinLineY
   } = getNewMinMax(newItems.length, minLineY, maxLineY, deltaY, itemHeight);
   const total = newItems.length;
   const contentHeight = total * itemHeight;
@@ -2442,24 +2449,24 @@ const removeIndex = async (state, index) => {
     ...state,
     deltaY: newDeltaY,
     fileCount: newFileCount,
+    fileIconCache: newFileIconCache,
+    finalDeltaY,
+    icons,
     items: newItems,
-    listItems: newItems,
     listFocusedIndex: newFocusedIndex,
+    listItems: newItems,
     matchCount: newMatchCount,
     maxLineY: newMaxLineY,
     message,
     minLineY: newMinLineY,
-    icons,
-    fileIconCache: newFileIconCache,
-    finalDeltaY,
     scrollBarHeight
   };
 };
 
 const dismissItem = state => {
   const {
-    listFocusedIndex,
-    focusedIndex
+    focusedIndex,
+    listFocusedIndex
   } = state;
   const actualIndex = listFocusedIndex === -1 ? focusedIndex : listFocusedIndex;
   return removeIndex(state, actualIndex);
@@ -2486,8 +2493,12 @@ const focusMatchCase$1 = state => {
 
 const getNextFocus = (focus, flags) => {
   switch (focus) {
-    case FocusToggleReplace:
-      return FocusSearchInput;
+    case FocusIgnoreFiles:
+      return FocusSearchResults;
+    case FocusSearchExcludeInput:
+      return FocusIgnoreFiles;
+    case FocusSearchIncludeInput:
+      return FocusSearchOpenEditors;
     case FocusSearchInput:
       if (flags & ReplaceExpanded) {
         return FocusSearchReplaceInput;
@@ -2495,32 +2506,28 @@ const getNextFocus = (focus, flags) => {
       return FocusSearchMatchCase;
     case FocusSearchMatchCase:
       return FocusSearchWholeWord;
-    case FocusSearchWholeWord:
-      return FocusSearchRegex;
+    case FocusSearchOpenEditors:
+      return FocusSearchExcludeInput;
+    case FocusSearchPreserveCase:
+      return FocusSearchReplaceAll;
     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 FocusSearchReplaceInput:
+      return FocusSearchMatchCase;
+    case FocusSearchWholeWord:
+      return FocusSearchRegex;
     case FocusToggleDetails:
       if (flags & DetailsExpanded) {
         return FocusSearchIncludeInput;
       }
       return FocusSearchResults;
-    case FocusIgnoreFiles:
-      return FocusSearchResults;
+    case FocusToggleReplace:
+      return FocusSearchInput;
     default:
       return focus;
   }
@@ -2528,8 +2535,8 @@ const getNextFocus = (focus, flags) => {
 
 const focusNextInput = state => {
   const {
-    focus,
-    flags
+    flags,
+    focus
   } = state;
   const nextFocus = getNextFocus(focus, flags);
   const isListFocus = nextFocus === FocusSearchResults;
@@ -2543,6 +2550,12 @@ const focusNextInput = state => {
 
 const getPreviousFocus = (focus, flags) => {
   switch (focus) {
+    case FocusIgnoreFiles:
+      return FocusSearchExcludeInput;
+    case FocusSearchExcludeInput:
+      return FocusSearchOpenEditors;
+    case FocusSearchIncludeInput:
+      return FocusToggleDetails;
     case FocusSearchInput:
       return FocusToggleReplace;
     case FocusSearchMatchCase:
@@ -2550,29 +2563,23 @@ const getPreviousFocus = (focus, flags) => {
         return FocusSearchReplaceInput;
       }
       return FocusSearchInput;
-    case FocusSearchWholeWord:
-      return FocusSearchMatchCase;
-    case FocusSearchRegex:
-      return FocusSearchWholeWord;
+    case FocusSearchOpenEditors:
+      return FocusSearchIncludeInput;
     case FocusSearchPreserveCase:
       return FocusSearchRegex;
-    case FocusSearchReplaceInput:
-      return FocusSearchInput;
+    case FocusSearchRegex:
+      return FocusSearchWholeWord;
     case FocusSearchReplaceAll:
       return FocusSearchPreserveCase;
+    case FocusSearchReplaceInput:
+      return FocusSearchInput;
+    case FocusSearchWholeWord:
+      return FocusSearchMatchCase;
     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;
   }
@@ -2624,64 +2631,64 @@ const Alt = 1 << 9 >>> 0;
 
 const getSearchHeaderKeyBindings = () => {
   return [{
-    key: CtrlCmd | Alt | Enter,
     command: 'Search.replaceAll',
+    key: CtrlCmd | Alt | Enter,
     when: FocusSearch
   }, {
-    key: Tab,
     command: 'Search.focusNextInput',
+    key: Tab,
     when: FocusSearch
   }, {
-    key: Shift | Tab,
     command: 'Search.focusPreviousInput',
+    key: Shift | Tab,
     when: FocusSearch
   }, {
-    key: UpArrow,
     command: 'Search.previousHistoryResult',
+    key: UpArrow,
     when: FocusSearchInput
   }, {
-    key: DownArrow,
     command: 'Search.nextHistoryResult',
+    key: DownArrow,
     when: FocusSearchInput
   }, {
-    key: Enter,
     command: 'Search.submit',
+    key: Enter,
     when: FocusSearchInput
   }, {
-    key: Enter,
     command: 'Search.submit',
+    key: Enter,
     when: FocusSearchReplaceInput
   }];
 };
 
 const getSearchResultKeyBindings = () => {
   return [{
-    key: DownArrow,
     command: 'Search.focusNext',
+    key: DownArrow,
     when: FocusSearchResults
   }, {
-    key: UpArrow,
     command: 'Search.focusPrevious',
+    key: UpArrow,
     when: FocusSearchResults
   }, {
-    key: Delete,
     command: 'Search.dismissItem',
+    key: Delete,
     when: FocusSearchResults
   }, {
-    key: Home,
     command: 'Search.focusFirst',
+    key: Home,
     when: FocusSearchResults
   }, {
-    key: End,
     command: 'Search.focusLast',
+    key: End,
     when: FocusSearchResults
   }, {
-    key: CtrlCmd | KeyC,
     command: 'Search.copy',
+    key: CtrlCmd | KeyC,
     when: FocusSearchResults
   }, {
-    key: Delete,
     command: 'Search.removeCurrent',
+    key: Delete,
     when: FocusSearchResults
   }];
 };
@@ -2691,10 +2698,10 @@ const getKeyBindings = () => {
 };
 
 const menuEntrySeparator = {
-  id: 'separator',
-  label: '',
+  command: '',
   flags: Separator,
-  command: ''
+  id: 'separator',
+  label: ''
 };
 
 const getMenuEntriesInput = options => {
@@ -2705,77 +2712,77 @@ const getMenuEntriesInput = options => {
     return [];
   }
   return [{
-    id: 'cut',
-    label: cut(),
-    flags: None$1,
+    args: [inputName],
     command: 'Search.handleInputCut',
-    args: [inputName]
-  }, {
-    id: 'copy',
-    label: copy(),
     flags: None$1,
-    command: 'Search.handleInputCopy',
-    args: [inputName]
+    id: 'cut',
+    label: cut()
   }, {
-    id: 'paste',
-    label: paste(),
+    args: [inputName],
+    command: 'Search.handleInputCopy',
     flags: None$1,
+    id: 'copy',
+    label: copy()
+  }, {
+    args: [inputName],
     command: 'Search.handleInputPaste',
-    args: [inputName]
-  }, menuEntrySeparator, {
-    id: 'selectAll',
-    label: selectAll(),
     flags: None$1,
+    id: 'paste',
+    label: paste()
+  }, menuEntrySeparator, {
+    args: [inputName],
     command: 'Search.handleInputSelectAll',
-    args: [inputName]
+    flags: None$1,
+    id: 'selectAll',
+    label: selectAll()
   }];
 };
 
 const getMenuEntriesFile = (state, props) => {
   return [{
-    id: 'replaceAll',
-    label: replaceAll$1(),
+    command: 'Search.replaceAll',
     flags: None$1,
-    command: 'Search.replaceAll'
+    id: 'replaceAll',
+    label: replaceAll$1()
   }, {
-    id: 'dismiss',
-    label: dismiss(),
+    command: 'Search.removeCurrent',
     flags: None$1,
-    command: 'Search.removeCurrent'
+    id: 'dismiss',
+    label: dismiss()
   }, {
-    id: 'copy',
-    label: copy(),
+    command: 'Search.copy',
     flags: None$1,
-    command: 'Search.copy'
+    id: 'copy',
+    label: copy()
   }, {
-    id: 'copyPath',
-    label: copyPath(),
+    command: 'Search.copyPath',
     flags: None$1,
-    command: 'Search.copyPath'
+    id: 'copyPath',
+    label: copyPath()
   }, {
-    id: 'copyAll',
-    label: copyAll(),
+    command: 'Search.copyAll',
     flags: None$1,
-    command: 'Search.copyAll'
+    id: 'copyAll',
+    label: copyAll()
   }];
 };
 
 const getMenuEntriesMatch = (state, props) => {
   return [{
-    id: 'dismiss',
-    label: dismiss(),
+    command: 'Search.removeCurrent',
     flags: None$1,
-    command: 'Search.removeCurrent'
+    id: 'dismiss',
+    label: dismiss()
   }, {
-    id: 'copy',
-    label: copy(),
+    command: 'Search.copy',
     flags: None$1,
-    command: 'Search.copy'
+    id: 'copy',
+    label: copy()
   }, {
-    id: 'copyAll',
-    label: copyAll(),
+    command: 'Search.copyAll',
     flags: None$1,
-    command: 'Search.copyAll'
+    id: 'copyAll',
+    label: copyAll()
   }];
 };
 
@@ -2851,14 +2858,14 @@ const handleUpdateEmpty = (state, update) => {
   };
   return {
     ...partialNewState,
-    minLineY: 0,
-    maxLineY: 0,
     deltaY: 0,
     items: [],
     listItems: [],
+    loaded: true,
     matchCount: 0,
+    maxLineY: 0,
     message: '',
-    loaded: true,
+    minLineY: 0,
     searchInputErrorMessage: ''
   };
 };
@@ -2870,13 +2877,13 @@ const handleUpdateError = async (state, update, error) => {
   };
   return {
     ...partialNewState,
-    message: `${error}`,
+    fileCount: 0,
     items: [],
     listItems: [],
     matchCount: 0,
-    fileCount: 0,
-    minLineY: 0,
-    maxLineY: 0
+    maxLineY: 0,
+    message: `${error}`,
+    minLineY: 0
   };
 };
 
@@ -2942,38 +2949,38 @@ const handleUpdateFull = async (state, update) => {
     ...update
   };
   const {
+    assetDir,
+    excludeValue,
+    fileIconCache,
+    flags,
+    headerHeight,
     height,
+    includeValue,
     itemHeight,
+    limit,
     minimumSliderSize,
-    headerHeight,
-    flags,
-    value,
-    threads,
-    includeValue,
-    excludeValue,
-    assetDir,
     platform,
-    limit,
-    fileIconCache
+    threads,
+    value
   } = partialNewState;
   const root = state.workspacePath;
   const scheme = getProtocol(root);
   const {
-    results,
-    limitHit
+    limitHit,
+    results
   } = await textSearch$6(root, value, {
-    threads,
-    isCaseSensitive: Boolean(flags & MatchCase$2),
-    useRegularExpression: Boolean(flags & UseRegularExpression$2),
+    assetDir,
     exclude: excludeValue,
+    flags,
     include: includeValue,
-    assetDir,
-    root,
+    isCaseSensitive: Boolean(flags & MatchCase$2),
+    limit,
+    matchWholeWord: Boolean(flags & MatchWholeWord$2),
     query: value,
+    root,
     scheme,
-    flags,
-    matchWholeWord: Boolean(flags & MatchWholeWord$2),
-    limit
+    threads,
+    useRegularExpression: Boolean(flags & UseRegularExpression$2)
   }, assetDir, platform);
   if (!Array.isArray(results)) {
     throw new TypeError('results must be of type array');
@@ -2998,6 +3005,7 @@ const handleUpdateFull = async (state, update) => {
   const limitHitWarning = limitHit ? theResultSetOnlyContainsASubSetOfMatches() : '';
   return {
     ...partialNewState,
+    collapsedPaths: [],
     deltaY: 0,
     fileCount,
     fileIconCache: newFileIconCache,
@@ -3015,15 +3023,14 @@ const handleUpdateFull = async (state, update) => {
     scrollBarHeight,
     searchInputErrorMessage: '',
     threads,
-    value,
-    collapsedPaths: []
+    value
   };
 };
 
 const getRipGrepArgs = ({
-  threads,
   isCaseSensitive,
   searchString,
+  threads,
   useRegularExpression
 }) => {
   const ripGrepArgs = ['--hidden', '--no-require-git', '--smart-case', '--stats', '--json', '--threads', `${threads}`];
@@ -3050,8 +3057,8 @@ const {
 
 const waitForNextFrame = async () => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   requestAnimationFrame(resolve);
   await promise;
@@ -3065,9 +3072,9 @@ const textSearchIncremental = async (root, query, options, assetDir, platform, s
     searchString: query
   });
   const actualOptions = {
+    id: searchId,
     ripGrepArgs,
-    searchDir: root,
-    id: searchId
+    searchDir: root
   };
   const resultPromise = invoke('TextSearch.searchIncremental', actualOptions);
   for (let i = 0; i < 100; i++) {
@@ -3076,10 +3083,10 @@ const textSearchIncremental = async (root, query, options, assetDir, platform, s
       newState
     } = latest;
     const {
-      minLineY,
-      height,
       headerHeight,
-      itemHeight
+      height,
+      itemHeight,
+      minLineY
     } = newState;
     const listHeight = height - headerHeight;
     const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
@@ -3092,8 +3099,8 @@ const textSearchIncremental = async (root, query, options, assetDir, platform, s
       ...latest2.newState,
       items: visible,
       listItems: visible,
-      minLineY: 0,
-      maxLineY: visible.length
+      maxLineY: visible.length,
+      minLineY: 0
     };
     set(uid, latest2.oldState, updatedState2);
     // @ts-ignore
@@ -3109,15 +3116,15 @@ const handleUpdateIncremental = async (state, update) => {
     ...update
   };
   const {
+    assetDir,
+    excludeValue,
     flags,
-    value,
-    threads,
     includeValue,
-    excludeValue,
     limit,
+    platform,
+    threads,
     uid,
-    assetDir,
-    platform
+    value
   } = partialNewState;
   const root = state.workspacePath;
   const scheme = getProtocol(root);
@@ -3132,18 +3139,18 @@ const handleUpdateIncremental = async (state, update) => {
 
   // TODO await promise?
   void textSearchIncremental(root, value, {
-    threads,
-    isCaseSensitive: Boolean(flags & MatchCase$2),
-    useRegularExpression: Boolean(flags & UseRegularExpression$2),
+    assetDir: assetDir,
     exclude: excludeValue,
+    flags,
     include: includeValue,
-    assetDir: assetDir,
-    root,
+    isCaseSensitive: Boolean(flags & MatchCase$2),
+    limit,
+    matchWholeWord: Boolean(flags & MatchWholeWord$2),
     query: value,
+    root,
     scheme,
-    flags,
-    matchWholeWord: Boolean(flags & MatchWholeWord$2),
-    limit
+    threads,
+    useRegularExpression: Boolean(flags & UseRegularExpression$2)
   }, assetDir, platform, searchId, uid);
   return state;
 };
@@ -3229,12 +3236,12 @@ const handleActionClick = async (state, name) => {
       return clearSearchResults$1(state);
     case CollapseAll$1:
       return collapseAll$1(state);
-    case ViewAsTree:
-      return viewAsTree(state);
-    case Refresh$1:
-      return refresh(state);
     case OpenSearchEditor:
       return openSearchEditor(state);
+    case Refresh$1:
+      return refresh(state);
+    case ViewAsTree:
+      return viewAsTree(state);
     default:
       return state;
   }
@@ -3267,36 +3274,36 @@ const getReplacedMessage = (fileCount, replaceCount, replacement) => {
 
 const getReplaceElements = (items, workspacePath, replacement) => {
   let element = {
-    uri: '',
-    changes: []
+    changes: [],
+    uri: ''
   };
   const bulkChanges = [];
   let changes = [];
   // TODO simplify code by first matching files with their elements, then creating bulk edits
   for (const match of items) {
     const {
-      type,
-      text,
-      lineNumber,
       end,
-      start
+      lineNumber,
+      start,
+      text,
+      type
     } = match;
     if (type === File) {
       changes = [];
       const fileName = getFilePath(text);
       const absolutePath = `${workspacePath}/${fileName}`;
       element = {
-        uri: absolutePath,
-        changes
+        changes,
+        uri: absolutePath
       };
       bulkChanges.push(element);
     } else {
       changes.push({
-        text: replacement,
-        startRowIndex: lineNumber - 1,
-        startColumnIndex: start,
+        endColumnIndex: end,
         endRowIndex: lineNumber,
-        endColumnIndex: end
+        startColumnIndex: start,
+        startRowIndex: lineNumber - 1,
+        text: replacement
       });
     }
   }
@@ -3305,23 +3312,24 @@ const getReplaceElements = (items, workspacePath, replacement) => {
 
 const replaceAll = async state => {
   const {
-    workspacePath,
     items,
+    matchCount,
     replacement,
-    matchCount
+    workspacePath
   } = state;
   const bulkEdits = getReplaceElements(items, workspacePath, replacement);
   // TODO this function should return an error message if an error occurred during bulk edit
   await applyBulkReplacement(bulkEdits);
+  await handleWorkspaceRefresh();
   const fileCount = bulkEdits.length;
   const message = getReplacedMessage(fileCount, matchCount, replacement);
   return {
     ...state,
     items: [],
     listItems: [],
-    minLineY: 0,
     maxLineY: 0,
-    message
+    message,
+    minLineY: 0
   };
 };
 
@@ -3393,26 +3401,26 @@ const getClickHandler = name => {
   switch (name) {
     case MatchCase:
       return toggleMatchCase;
-    case ToggleReplace:
-      return toggleReplace;
-    case UseRegularExpression:
-      return toggleUseRegularExpression;
-    case ReplaceAll:
-      return replaceAll;
     case MatchWholeWord:
       return toggleMatchWholeWord;
     case PreserveCase:
       return togglePreserveCase;
-    case ToggleSearchDetails:
-      return toggleDetailsExpanded;
+    case ReplaceAll:
+      return replaceAll;
+    case ReplaceValue:
+      return focusReplaceValue$1;
     case SearchOnlyOpenEditors:
       return toggleOpenEditors;
-    case UseExcludeSettings:
-      return toggleUseIgnoreFiles;
     case SearchValue:
       return focusSearchValue$1;
-    case ReplaceValue:
-      return focusReplaceValue$1;
+    case ToggleReplace:
+      return toggleReplace;
+    case ToggleSearchDetails:
+      return toggleDetailsExpanded;
+    case UseExcludeSettings:
+      return toggleUseIgnoreFiles;
+    case UseRegularExpression:
+      return toggleUseRegularExpression;
     default:
       return noop;
   }
@@ -3437,16 +3445,16 @@ const handleHeaderFocusOut = state => {
   }
   return {
     ...state,
-    focused: false,
-    focus: 0
+    focus: 0,
+    focused: false
   };
 };
 
 const handleIconThemeChange = async state => {
   const {
     items,
-    minLineY,
-    maxLineY
+    maxLineY,
+    minLineY
   } = state;
   const visibleItems = items.slice(minLineY, maxLineY);
   const {
@@ -3455,8 +3463,8 @@ const handleIconThemeChange = async state => {
   } = await getFileIcons(visibleItems, {});
   return {
     ...state,
-    icons,
-    fileIconCache: newFileIconCache
+    fileIconCache: newFileIconCache,
+    icons
   };
 };
 
@@ -3469,28 +3477,28 @@ const handleIncludeInput = (state, includeValue, inputSource = Script) => {
 
 const handleInput = (state, value, inputSource = Script) => {
   return handleUpdate(state, {
-    value,
-    inputSource
+    inputSource,
+    value
   });
 };
 
 const handleReplaceInput = (state, value, inputSource = Script) => {
   return handleUpdate(state, {
-    replacement: value,
-    inputSource
+    inputSource,
+    replacement: value
   });
 };
 
 const getInputHandler = name => {
   switch (name) {
-    case SearchValue:
-      return handleInput;
-    case ReplaceValue:
-      return handleReplaceInput;
     case FilesToExclude:
       return handleExcludeInput;
     case FilesToInclude:
       return handleIncludeInput;
+    case ReplaceValue:
+      return handleReplaceInput;
+    case SearchValue:
+      return handleInput;
     default:
       throw new Error(`unknown input handler: ${name}`);
   }
@@ -3514,8 +3522,8 @@ const handleInputContextMenu = async (state, name, button, x, y) => {
     uid
   } = state;
   await show2(uid, InputContextMenu, x, y, {
-    menuId: InputContextMenu,
-    inputName: name
+    inputName: name,
+    menuId: InputContextMenu
   });
   return state;
 };
@@ -3529,14 +3537,14 @@ const readText = async () => {
 
 const getCurrentValue = (state, name) => {
   switch (name) {
-    case SearchValue:
-      return state.value;
     case FilesToExclude:
       return state.excludeValue;
     case FilesToInclude:
       return state.includeValue;
     case ReplaceValue:
       return state.replacement;
+    case SearchValue:
+      return state.value;
     default:
       return '';
   }
@@ -3555,8 +3563,8 @@ const getNewSelections = (selections, name, newValue) => {
     return selections;
   }
   const {
-    start,
-    end
+    end,
+    start
   } = old;
   const newSelection = newValue.length;
   if (start === newSelection && end === newSelection) {
@@ -3565,8 +3573,8 @@ const getNewSelections = (selections, name, newValue) => {
   return {
     ...selections,
     [name]: {
-      start: newSelection,
-      end: newSelection
+      end: newSelection,
+      start: newSelection
     }
   };
 };
@@ -3576,33 +3584,33 @@ const updateValue = (state, name, newValue) => {
   } = state;
   const newSelections = getNewSelections(selections, name, newValue);
   switch (name) {
-    case SearchValue:
+    case FilesToExclude:
       return {
         ...state,
-        value: newValue,
+        excludeValue: newValue,
         inputSource: Script$1,
         selections: newSelections
       };
-    case ReplaceValue:
+    case FilesToInclude:
       return {
         ...state,
-        replacement: newValue,
+        includeValue: newValue,
         inputSource: Script$1,
         selections: newSelections
       };
-    case FilesToInclude:
+    case ReplaceValue:
       return {
         ...state,
-        includeValue: newValue,
         inputSource: Script$1,
+        replacement: newValue,
         selections: newSelections
       };
-    case FilesToExclude:
+    case SearchValue:
       return {
         ...state,
-        excludeValue: newValue,
         inputSource: Script$1,
-        selections: newSelections
+        selections: newSelections,
+        value: newValue
       };
     default:
       return state;
@@ -3621,8 +3629,8 @@ const handleInputPaste = async (state, name) => {
   }
   const selection = selections[name];
   const {
-    start,
-    end
+    end,
+    start
   } = selection;
   const currentText = getCurrentValue(state, name);
   const insertedText = await readText();
@@ -3639,8 +3647,8 @@ const handleInputCopy = async (state, name) => {
   }
   const selection = selections[name];
   const {
-    start,
-    end
+    end,
+    start
   } = selection;
   const currentText = getCurrentValue(state, name);
   const toCopy = currentText.slice(start, end);
@@ -3653,8 +3661,8 @@ const getNewTextCut = (currentText, selectionStart, selectionEnd) => {
   const middle = currentText.slice(selectionStart, selectionEnd);
   const post = currentText.slice(selectionEnd);
   return {
-    newText: pre + post,
-    cutText: middle
+    cutText: middle,
+    newText: pre + post
   };
 };
 
@@ -3667,13 +3675,13 @@ const handleInputCut = async (state, name) => {
   }
   const selection = selections[name];
   const {
-    start,
-    end
+    end,
+    start
   } = selection;
   const currentText = getCurrentValue(state, name);
   const {
-    newText,
-    cutText
+    cutText,
+    newText
   } = getNewTextCut(currentText, start, end);
   await writeText(cutText);
   return updateValue(state, name, newText);
@@ -3681,32 +3689,32 @@ const handleInputCut = async (state, name) => {
 
 const getSearchFocusKey = key => {
   switch (key) {
-    case SearchValue:
-      return FocusSearchInput;
-    case ReplaceValue:
-      return FocusSearchReplaceInput;
+    case FilesToExclude:
+      return FocusSearchExcludeInput;
+    case FilesToInclude:
+      return FocusSearchIncludeInput;
     case MatchCase:
       return FocusSearchMatchCase;
     case MatchWholeWord:
       return FocusSearchWholeWord;
-    case UseRegularExpression:
-      return FocusSearchRegex;
-    case ReplaceAll:
-      return FocusSearchReplaceAll;
     case PreserveCase:
       return FocusSearchPreserveCase;
-    case ToggleSearchDetails:
-      return FocusToggleDetails;
-    case FilesToInclude:
-      return FocusSearchIncludeInput;
-    case FilesToExclude:
-      return FocusSearchExcludeInput;
+    case ReplaceAll:
+      return FocusSearchReplaceAll;
+    case ReplaceValue:
+      return FocusSearchReplaceInput;
     case SearchOnlyOpenEditors:
       return FocusSearchOpenEditors;
-    case UseExcludeSettings:
-      return FocusIgnoreFiles;
+    case SearchValue:
+      return FocusSearchInput;
     case ToggleReplace:
       return FocusToggleReplace;
+    case ToggleSearchDetails:
+      return FocusToggleDetails;
+    case UseExcludeSettings:
+      return FocusIgnoreFiles;
+    case UseRegularExpression:
+      return FocusSearchRegex;
     default:
       return Empty;
   }
@@ -3716,9 +3724,9 @@ const handleInputFocus = (state, name) => {
   const key = getSearchFocusKey(name);
   return {
     ...state,
-    listFocused: false,
     focus: key,
-    focused: true
+    focused: true,
+    listFocused: false
   };
 };
 
@@ -3736,8 +3744,8 @@ const handleInputSelectionChange = async (state, name, selectionStart, selection
     return state;
   }
   const {
-    start,
-    end
+    end,
+    start
   } = old;
   if (start === selectionStart && end === selectionEnd) {
     return state;
@@ -3747,8 +3755,8 @@ const handleInputSelectionChange = async (state, name, selectionStart, selection
     selections: {
       ...selections,
       [name]: {
-        start: selectionStart,
-        end: selectionEnd
+        end: selectionEnd,
+        start: selectionStart
       }
     }
   };
@@ -4176,11 +4184,11 @@ const toggleCollapsedPath = (collapsedPaths, path) => {
 const selectIndexFile = async (state, searchResult, index) => {
   const {
     collapsedPaths,
-    items,
-    itemHeight,
+    fileIconCache,
     headerHeight,
     height,
-    fileIconCache
+    itemHeight,
+    items
   } = state;
   const path = searchResult.text;
   const newCollapsedPaths = toggleCollapsedPath(collapsedPaths, path);
@@ -4252,10 +4260,10 @@ const selectIndexPreview = async (state, searchResult, index) => {
   });
   return {
     ...state,
-    listFocusedIndex: index,
-    listFocused: false,
     focus: FocusSearchResults,
-    focusSource: Script
+    focusSource: Script,
+    listFocused: false,
+    listFocusedIndex: index
   };
 };
 
@@ -4288,12 +4296,12 @@ const selectIndex = async (state, index) => {
 
 const handleClickAt = async (state, eventX, eventY, name) => {
   const {
-    x,
-    y,
-    itemHeight,
     deltaY,
     flags,
-    listItems
+    itemHeight,
+    listItems,
+    x,
+    y
   } = state;
   const topHeight = getTopHeight(flags);
   const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, topHeight, listItems.length);
@@ -4379,39 +4387,40 @@ const getSavedCollapsedPaths = savedState => {
 
 const restoreState = savedState => {
   return {
-    savedValue: getSavedValue(savedState),
-    replacement: getSavedReplacement(savedState),
-    savedCollapsedPaths: getSavedCollapsedPaths(savedState),
-    threads: 1,
-    flags: getSavedFlags(savedState),
-    includeValue: getSavedIncludeValue(savedState),
     excludeValue: getSavedExcludeValue(savedState),
-    history: getSavedHistory(savedState),
+    flags: getSavedFlags(savedState),
     focus: getSavedFocus(savedState),
-    listFocused: getSavedListFocus(savedState)
+    history: getSavedHistory(savedState),
+    includeValue: getSavedIncludeValue(savedState),
+    listFocused: getSavedListFocus(savedState),
+    replacement: getSavedReplacement(savedState),
+    savedCollapsedPaths: getSavedCollapsedPaths(savedState),
+    savedValue: getSavedValue(savedState),
+    threads: 1
   };
 };
 
 const loadContent = async (state, savedState) => {
   const {
-    savedValue,
-    savedCollapsedPaths,
-    threads,
-    replacement,
+    excludeValue,
     flags,
     includeValue,
-    excludeValue
+    replacement,
+    savedCollapsedPaths,
+    savedValue,
+    threads
   } = restoreState(savedState);
   const update = {
-    value: savedValue,
-    threads,
-    inputSource: Script,
     collapsedPaths: savedCollapsedPaths,
-    replacement,
+    excludeValue,
     flags,
+    focus: 0,
+    // TODO
     includeValue,
-    excludeValue,
-    focus: 0 // TODO
+    inputSource: Script,
+    replacement,
+    threads,
+    value: savedValue
   };
   if (savedValue) {
     const result = await handleUpdate(state, update);
@@ -4423,23 +4432,23 @@ const loadContent = async (state, savedState) => {
   return {
     ...state,
     ...update,
-    threads,
     flags,
-    loaded: true
+    loaded: true,
+    threads
   };
 };
 
 const getNextHistoryData = (history, historyIndex) => {
   if (historyIndex === -1 || history.length === 0) {
     return {
-      newValue: '',
-      newHistoryIndex: -1
+      newHistoryIndex: -1,
+      newValue: ''
     };
   }
   const item = history.at(historyIndex) || '';
   return {
-    newValue: item,
-    newHistoryIndex: historyIndex + 1
+    newHistoryIndex: historyIndex + 1,
+    newValue: item
   };
 };
 
@@ -4450,16 +4459,16 @@ const nextHistoryResult = async state => {
     value
   } = state;
   const {
-    newValue,
-    newHistoryIndex
+    newHistoryIndex,
+    newValue
   } = getNextHistoryData(history, historyIndex);
   if (newValue === value) {
     return state;
   }
   return handleUpdate(state, {
-    value: newValue,
+    historyIndex: newHistoryIndex,
     inputSource: Script,
-    historyIndex: newHistoryIndex
+    value: newValue
   });
 };
 
@@ -4483,34 +4492,34 @@ const removeCurrent = async state => {
 
 const getFocusSelector = focusKey => {
   switch (focusKey) {
+    case FocusIgnoreFiles:
+      return UseExcludeSettings;
+    case FocusSearchExcludeInput:
+      return FilesToExclude;
+    case FocusSearchIncludeInput:
+      return FilesToInclude;
     case FocusSearchInput:
       return SearchValue;
-    case FocusSearchReplaceInput:
-      return ReplaceValue;
-    case FocusToggleDetails:
-      return ToggleSearchDetails;
     case FocusSearchMatchCase:
       return MatchCase;
+    case FocusSearchOpenEditors:
+      return SearchOnlyOpenEditors;
     case FocusSearchPreserveCase:
       return PreserveCase;
     case FocusSearchRegex:
       return UseRegularExpression;
-    case FocusSearchIncludeInput:
-      return FilesToInclude;
-    case FocusSearchExcludeInput:
-      return FilesToExclude;
-    case FocusSearchWholeWord:
-      return MatchWholeWord;
     case FocusSearchReplaceAll:
       return ReplaceAll;
-    case FocusSearchOpenEditors:
-      return SearchOnlyOpenEditors;
-    case FocusIgnoreFiles:
-      return UseExcludeSettings;
-    case FocusToggleReplace:
-      return ToggleReplace;
+    case FocusSearchReplaceInput:
+      return ReplaceValue;
     case FocusSearchResults:
       return '.Tree';
+    case FocusSearchWholeWord:
+      return MatchWholeWord;
+    case FocusToggleDetails:
+      return ToggleSearchDetails;
+    case FocusToggleReplace:
+      return ToggleReplace;
     default:
       return '';
   }
@@ -4583,9 +4592,9 @@ const getDisplayResultMatch = (setSize, searchTermLength, replacement, text, pos
 const getDisplayResult = (results, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, minLineY, originalResults) => {
   const result = results[i];
   const {
-    type,
+    start,
     text,
-    start
+    type
   } = result;
   const posInSet = i + 1;
   const focused = i === focusedIndex;
@@ -4617,46 +4626,46 @@ const createViewModel = state => {
   // TODO add viewmodel to state, not needing to have separate states and making it easier to compare
   // visible items in diff
   const {
-    listItems,
-    itemHeight,
-    fileCount,
-    value,
-    minLineY,
-    maxLineY,
-    replacement,
-    icons,
-    listFocusedIndex,
     collapsedPaths,
-    items,
-    listFocused,
     deltaY,
+    fileCount,
     finalDeltaY,
-    height,
-    headerHeight,
     flags,
+    focus,
+    headerHeight,
+    height,
+    icons,
+    itemHeight,
+    items,
+    listFocused,
+    listFocusedIndex,
+    listItems,
+    matchCount,
+    maxLineY,
     message,
-    searchInputErrorMessage,
+    minLineY,
+    replacement,
     scrollBarHeight,
-    matchCount,
-    focus
+    searchInputErrorMessage,
+    value
   } = state;
   const displayResults = getDisplayResults(listItems, itemHeight, fileCount, value, minLineY, maxLineY, replacement, icons, listFocusedIndex, collapsedPaths, items);
   const focusOutline = listFocused && listFocusedIndex === -1;
   const scrollBarValue = deltaY / finalDeltaY * 100;
   const scrollBarY = getScrollBarY$1(deltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
+    deltaY,
     displayResults,
     flags,
-    message,
+    focus,
     focusOutline,
-    searchInputErrorMessage,
-    scrollBarHeight,
-    scrollBarY,
-    scrollBarValue,
-    deltaY,
     itemHeight,
     matchCount,
-    focus
+    message,
+    scrollBarHeight,
+    scrollBarValue,
+    scrollBarY,
+    searchInputErrorMessage
   };
 };
 
@@ -4684,19 +4693,19 @@ const HandleActionClick = 22;
 
 const getSearchDetailsToggleVirtualDom = () => {
   return [{
-    type: Button$2,
+    ariaLabel: toggleSearchDetails(),
+    childCount: 1,
     className: ToggleDetails,
+    name: ToggleSearchDetails,
+    onClick: HandleButtonClick,
     role: Button$3,
     tabIndex: 0,
-    ariaLabel: toggleSearchDetails(),
     title: toggleSearchDetails(),
-    name: ToggleSearchDetails,
-    onClick: HandleButtonClick,
-    childCount: 1
+    type: Button$2
   }, {
-    type: Div,
+    childCount: 0,
     className: mergeClassNames(MaskIcon, MaskIconEllipsis),
-    childCount: 0
+    type: Div
   }];
 };
 
@@ -4708,18 +4717,18 @@ const getClassName$1 = indented => {
 };
 const getSearchMessageVirtualDom = (message, indented) => {
   return [{
-    type: Div,
+    childCount: 1,
     className: getClassName$1(indented),
     role: Status,
-    childCount: 1
+    type: Div
   }, text(message)];
 };
 
 const getSearchHeaderDetailsCollapsedVirtualDom = message => {
   return [{
-    type: Div,
+    childCount: 2,
     className: SearchHeaderDetails,
-    childCount: 2
+    type: Div
   }, ...getSearchMessageVirtualDom(message, true), ...getSearchDetailsToggleVirtualDom()];
 };
 
@@ -4730,11 +4739,11 @@ const ButtonDisabled = 3;
 
 const getInputActionsExclude = flags => {
   const inside = [{
-    icon: MaskIconExclude,
-    title: useExcludeSettings(),
     command: 'toggleUseExcludeSettings',
     flag: flags & UseIgnoreFiles ? CheckBoxEnabled : CheckBoxDisabled,
-    name: UseExcludeSettings
+    icon: MaskIconExclude,
+    name: UseExcludeSettings,
+    title: useExcludeSettings()
   }];
   const outside = [];
   return {
@@ -4745,11 +4754,11 @@ const getInputActionsExclude = flags => {
 
 const getInputActionsInclude = flags => {
   const inside = [{
-    icon: MaskIconBook,
-    title: searchOnlyOpenEditors(),
     command: 'searchOnlyOpenEditors',
     flag: flags & OpenEditors ? CheckBoxEnabled : CheckBoxDisabled,
-    name: SearchOnlyOpenEditors
+    icon: MaskIconBook,
+    name: SearchOnlyOpenEditors,
+    title: searchOnlyOpenEditors()
   }];
   const outside = [];
   return {
@@ -4765,10 +4774,10 @@ const getSearchFieldButtonClassName = flag => {
 // TODO maybe move logic to viewmodel, which returns ariaChecked 1 | 2 | 3
 const getAriaChecked = flag => {
   switch (flag) {
-    case CheckBoxEnabled:
-      return true;
     case CheckBoxDisabled:
       return false;
+    case CheckBoxEnabled:
+      return true;
     default:
       return undefined;
   }
@@ -4777,8 +4786,8 @@ const getAriaChecked = flag => {
 // TODO have have separate renderers for checkbox and button elements
 const getRole = flag => {
   switch (flag) {
-    case CheckBoxEnabled:
     case CheckBoxDisabled:
+    case CheckBoxEnabled:
       return CheckBox;
     default:
       return undefined;
@@ -4794,79 +4803,79 @@ const getDisabled = flag => {
 };
 const getSearchFieldButtonVirtualDom = button => {
   const {
+    flag,
     icon,
-    title,
     name,
-    flag
+    title
   } = button;
   const ariaChecked = getAriaChecked(flag);
   const role = getRole(flag);
   const disabled = getDisabled(flag);
   return [{
-    type: Button$2,
+    ariaChecked,
+    childCount: 1,
     className: getSearchFieldButtonClassName(flag),
+    disabled,
     name,
-    title,
+    onClick: HandleButtonClick,
     role,
-    ariaChecked,
-    disabled,
     tabIndex: 0,
-    childCount: 1,
-    onClick: HandleButtonClick
+    title,
+    type: Button$2
   }, {
-    type: Span,
+    childCount: 0,
     className: mergeClassNames(MaskIcon, icon),
-    childCount: 0
+    type: Span
   }];
 };
 
 const getOutSideButtonsDom = outsideButtons => {
   if (outsideButtons.length === 0) {
     return {
-      preNodes: [],
-      postNodes: []
+      postNodes: [],
+      preNodes: []
     };
   }
   return {
+    postNodes: outsideButtons.flatMap(getSearchFieldButtonVirtualDom),
     preNodes: [{
-      type: Div,
+      childCount: 1 + outsideButtons.length,
       className: SearchFieldContainer,
       role: None$2,
-      childCount: 1 + outsideButtons.length
-    }],
-    postNodes: outsideButtons.flatMap(getSearchFieldButtonVirtualDom)
+      type: Div
+    }]
   };
 };
 
 const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, hasError = false) => {
   const {
-    preNodes,
-    postNodes
+    postNodes,
+    preNodes
   } = getOutSideButtonsDom(outsideButtons);
   const searchFieldClassName = hasError ? mergeClassNames(SearchField, SearchFieldError) : SearchField;
   const dom = [...preNodes, {
-    type: Div,
+    childCount: 2,
     className: searchFieldClassName,
     role: None$2,
-    childCount: 2
+    type: Div
   }, {
-    type: TextArea,
-    className: MultilineInputBox,
-    spellcheck: false,
     autocapitalize: 'off',
     autocorrect: 'off',
-    placeholder,
+    childCount: 0,
+    className: MultilineInputBox,
     name,
-    onInput,
-    onFocus: HandleInputFocus,
     onBlur: HandleInputBlur,
     onContextMenu: HandleInputContextMenu,
+    onFocus: HandleInputFocus,
+    onInput,
     onSelectionChange: HandleInputSelectionChange,
-    childCount: 0
+    placeholder,
+    spellcheck: false,
+    type: TextArea
   }, {
-    type: Div,
+    childCount: insideButtons.length,
     className: SearchFieldButtons,
-    childCount: insideButtons.length
+    type: Div
   }, ...insideButtons.flatMap(getSearchFieldButtonVirtualDom), ...postNodes];
   return dom;
 };
@@ -4877,21 +4886,21 @@ const getSearchHeaderDetailsExpandedVirtualDom = (flags, message) => {
   const includePlaceholder = include();
   const excludePlaceholder = exclude();
   return [{
-    type: Div,
+    childCount: 5,
     className: SearchHeaderDetailsExpanded,
-    childCount: 5
+    type: Div
   }, {
-    type: Div,
+    childCount: 2,
     className: SearchHeaderDetailsExpandedTop,
-    childCount: 2
+    type: Div
   }, ...getSearchDetailsToggleVirtualDom(), {
-    type: H4,
+    childCount: 1,
     className: SearchHeaderDetailsHeading,
-    childCount: 1
+    type: H4
   }, text(filesToInclude()), ...getSearchFieldVirtualDom(FilesToInclude, includePlaceholder, HandleInput2, includeButtons.inside, includeButtons.outside), {
-    type: H4,
+    childCount: 1,
     className: SearchHeaderDetailsHeading,
-    childCount: 1
+    type: H4
   }, text(filesToExclude()), ...getSearchFieldVirtualDom(FilesToExclude, excludePlaceholder, HandleInput2, excludeButtons.inside, excludeButtons.outside), ...getSearchMessageVirtualDom(message, false)];
 };
 
@@ -4908,14 +4917,14 @@ const getSearchHeaderLimitHitVirtualDom = limitHitWarning => {
   if (!limitHitWarning) {
     // TODO remove unused dom node
     return [{
-      type: Div,
-      childCount: 0
+      childCount: 0,
+      type: Div
     }];
   }
   const dom = [{
-    type: Div,
+    childCount: 1,
     className: SearchWarningMessage,
-    childCount: 1
+    type: Div
   },
   // TODO warning triangle here
   text(limitHitWarning)];
@@ -4924,20 +4933,20 @@ const getSearchHeaderLimitHitVirtualDom = limitHitWarning => {
 
 const getInputActionsInput = flags => {
   const inside = [{
-    icon: MaskIconCaseSensitive,
     flag: flags & MatchCase$2 ? CheckBoxEnabled : CheckBoxDisabled,
-    title: matchCase(),
-    name: MatchCase
+    icon: MaskIconCaseSensitive,
+    name: MatchCase,
+    title: matchCase()
   }, {
-    icon: MaskIconWholeWord,
     flag: flags & MatchWholeWord$2 ? CheckBoxEnabled : CheckBoxDisabled,
-    title: matchWholeWord(),
-    name: MatchWholeWord
+    icon: MaskIconWholeWord,
+    name: MatchWholeWord,
+    title: matchWholeWord()
   }, {
-    icon: MaskIconRegex,
     flag: flags & UseRegularExpression$2 ? CheckBoxEnabled : CheckBoxDisabled,
-    title: useRegularExpression(),
-    name: UseRegularExpression
+    icon: MaskIconRegex,
+    name: UseRegularExpression,
+    title: useRegularExpression()
   }];
   const outside = [];
   return {
@@ -4948,16 +4957,16 @@ const getInputActionsInput = flags => {
 
 const getInputActionsReplace = (flags, matchCount) => {
   const inside = [{
-    icon: MaskIconPreserveCase,
     flag: flags & PreserveCase$2 ? CheckBoxEnabled : CheckBoxDisabled,
-    title: preserveCase(),
-    name: PreserveCase
+    icon: MaskIconPreserveCase,
+    name: PreserveCase,
+    title: preserveCase()
   }];
   const outside = [{
-    icon: MaskIconReplaceAll,
     flag: matchCount === 0 ? ButtonDisabled : ButtonEnabled,
-    title: replaceAll$1(),
-    name: ReplaceAll
+    icon: MaskIconReplaceAll,
+    name: ReplaceAll,
+    title: replaceAll$1()
   }];
   return {
     inside,
@@ -4981,19 +4990,19 @@ const getSearchPlaceholder = focus => {
 
 const getSearchToggleVirtualDom = replaceExpanded => {
   return [{
-    type: Button$2,
-    className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
-    title: toggleReplace$1(),
+    ariaExpanded: Boolean(replaceExpanded),
     ariaLabel: toggleReplace$1(),
     // TODO compute label only once
-    ariaExpanded: Boolean(replaceExpanded),
     childCount: 1,
+    className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
     name: ToggleReplace,
-    onClick: HandleButtonClick
+    onClick: HandleButtonClick,
+    title: toggleReplace$1(),
+    type: Button$2
   }, {
-    type: Div,
+    childCount: 0,
     className: mergeClassNames(MaskIcon, replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight),
-    childCount: 0
+    type: Div
   }];
 };
 
@@ -5004,15 +5013,15 @@ const getSearchHeaderTopVirtualDom = (flags, searchInputErrorMessage, matchCount
   const replacePlaceholder = getReplacePlaceholder(focus);
   const replaceExpanded = flags & ReplaceExpanded;
   const dom = [{
-    type: Div,
+    childCount: 2,
     className: SearchHeaderTop,
     role: None$2,
-    childCount: 2
+    type: Div
   }, ...getSearchToggleVirtualDom(replaceExpanded), {
-    type: Div,
+    childCount: replaceExpanded ? 2 : 1,
     className: SearchHeaderTopRight,
     role: None$2,
-    childCount: replaceExpanded ? 2 : 1
+    type: Div
   }, ...getSearchFieldVirtualDom(SearchValue, searchPlaceholder, HandleInput2, inputActions.inside, inputActions.outside, Boolean(searchInputErrorMessage))];
   if (flags & ReplaceExpanded) {
     dom.push(...getSearchFieldVirtualDom(ReplaceValue, replacePlaceholder, HandleInput2, replaceActions.inside, replaceActions.outside));
@@ -5021,11 +5030,11 @@ const getSearchHeaderTopVirtualDom = (flags, searchInputErrorMessage, matchCount
 };
 
 const parentNode = {
-  type: Div,
+  childCount: 3,
   className: SearchHeader,
+  onContextMenu: HandleHeaderContextMenu,
   role: None$2,
-  childCount: 3,
-  onContextMenu: HandleHeaderContextMenu
+  type: Div
 };
 const getSearchHeaderVirtualDom = (flags, message, searchInputErrorMessage, matchCount, focus, limitHitWarning) => {
   const dom = [parentNode, ...getSearchHeaderTopVirtualDom(flags, searchInputErrorMessage, matchCount, focus), ...getSearchHeaderDetailsVirtualDom(flags, message), ...getSearchHeaderLimitHitVirtualDom(limitHitWarning)];
@@ -5037,10 +5046,10 @@ const getSearchInputErrorVirtualDom = errorMessage => {
     return [];
   }
   return [{
-    type: Div,
+    childCount: 1,
     className: SearchInputError,
     role: Alert,
-    childCount: 1
+    type: Div
   }, text(errorMessage)];
 };
 
@@ -5051,19 +5060,19 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarY, scrollBarValue) =>
     return [];
   }
   return [{
-    type: Div,
-    className: mergeClassNames(ScrollBar, ScrollBarVertical),
+    ariaControls: TreeItems,
+    ariaValueNow: scrollBarValue,
     childCount: 1,
+    className: mergeClassNames(ScrollBar, ScrollBarVertical),
     onPointerDown: HandleScrollBarPointerDown,
     role: ScrollBar$1,
-    ariaControls: TreeItems,
-    ariaValueNow: scrollBarValue
+    type: Div
   }, {
-    type: Div,
+    childCount: 0,
     className: ScrollBarThumb,
     height: scrollBarHeight,
     translate: `0 ${scrollBarY}px`,
-    childCount: 0
+    type: Div
   }];
 };
 
@@ -5081,9 +5090,9 @@ const getAriaExpanded = expanded => {
 };
 
 const badge = {
-  type: Div,
+  childCount: 1,
   className: mergeClassNames(Badge, SourceControlBadge),
-  childCount: 1
+  type: Div
 };
 const getBadgeVirtualDom = badgeText => {
   if (!badgeText) {
@@ -5093,22 +5102,22 @@ const getBadgeVirtualDom = badgeText => {
 };
 
 const chevronDownVirtualDom = {
-  type: Div,
+  childCount: 0,
   className: mergeClassNames(Chevron, MaskIconChevronDown),
-  childCount: 0
+  type: Div
 };
 const chevronRightVirtualDom = {
-  type: Div,
+  childCount: 0,
   className: mergeClassNames(Chevron, MaskIconChevronRight),
-  childCount: 0
+  type: Div
 };
 
 const getChevronVirtualDom = expanded => {
   switch (expanded) {
-    case Expanded:
-      return [chevronDownVirtualDom];
     case Collapsed:
       return [chevronRightVirtualDom];
+    case Expanded:
+      return [chevronDownVirtualDom];
     default:
       return [];
   }
@@ -5116,11 +5125,11 @@ const getChevronVirtualDom = expanded => {
 
 const getFileIconVirtualDom = icon => {
   return {
-    type: Img,
+    childCount: 0,
     className: FileIcon,
-    src: icon,
     role: None$2,
-    childCount: 0
+    src: icon,
+    type: Img
   };
 };
 
@@ -5132,24 +5141,24 @@ const getIconsVirtualDom = icon => {
 };
 
 const deleted = {
-  type: Del,
+  childCount: 1,
   className: HighlightDeleted,
-  childCount: 1
+  type: Del
 };
 const inserted = {
-  type: Ins,
+  childCount: 1,
   className: HighlightInserted,
-  childCount: 1
+  type: Ins
 };
 const highlighted = {
-  type: Span,
+  childCount: 1,
   className: Highlight,
-  childCount: 1
+  type: Span
 };
 const label1 = {
-  type: Div,
+  childCount: 1,
   className: mergeClassNames(Label, Grow),
-  childCount: 1
+  type: Div
 };
 const label3 = {
   ...label1,
@@ -5193,18 +5202,18 @@ const getChildCount = (icon, expanded, badgeText) => {
 };
 
 const closeIcon = {
-  type: Div,
+  childCount: 0,
   className: CloseMaskIcon,
-  childCount: 0
+  type: Div
 };
 const getSearchRemoveVirtualDom = () => {
   const title = remove();
   const dom = [{
-    type: Button$2,
+    childCount: 1,
     className: SearchRemove,
     name: Remove,
-    childCount: 1,
-    title
+    title,
+    type: Button$2
   }, closeIcon];
   return dom;
 };
@@ -5220,34 +5229,34 @@ const PaddingRight = '12px';
 
 const getSearchResultVirtualDom = rowInfo => {
   const {
-    matchStart,
-    matchLength,
-    text: displayText,
-    title,
+    badgeText,
+    depth,
+    expanded,
+    focused,
     icon,
-    setSize,
+    matchLength,
+    matchStart,
     posInSet,
-    depth,
     replacement,
-    focused,
-    expanded,
-    badgeText
+    setSize,
+    text: displayText,
+    title
   } = rowInfo;
   const childCount = getChildCount(icon, expanded, badgeText);
   const dom = [{
-    type: Div,
-    role: TreeItem$1,
-    className: getSearchResultClassName(focused),
-    title,
-    ariaSetSize: setSize,
+    ariaDescription: '',
+    ariaExpanded: getAriaExpanded(expanded),
+    ariaLabel: title,
     ariaLevel: depth,
     ariaPosInSet: posInSet,
-    ariaLabel: title,
-    ariaDescription: '',
+    ariaSetSize: setSize,
     childCount,
+    className: getSearchResultClassName(focused),
     paddingLeft: getPaddingLeft(depth),
     paddingRight: PaddingRight,
-    ariaExpanded: getAriaExpanded(expanded)
+    role: TreeItem$1,
+    title,
+    type: Div
   }, ...getChevronVirtualDom(expanded), ...getIconsVirtualDom(icon), ...getLabelVirtualDom(displayText, matchLength, matchStart, replacement), ...getBadgeVirtualDom(badgeText), ...getSearchRemoveVirtualDom()];
   return dom;
 };
@@ -5255,27 +5264,28 @@ const getSearchResultVirtualDom = rowInfo => {
 const getTreeItemsVirtualDom = (visibleItems, deltaY, itemHeight) => {
   const pixelOffset = deltaY % itemHeight;
   return [{
-    type: Div,
-    className: TreeItems$1,
     childCount: visibleItems.length,
-    onClick: HandleClick,
+    className: TreeItems$1,
+    id: TreeItems,
     onBlur: HandleListBlur,
-    onWheel: HandleWheel,
+    onClick: HandleClick,
     onContextMenu: HandleListContextMenu,
-    id: TreeItems,
-    top: `${-pixelOffset}px` // TODO use dynamic css instead
+    onWheel: HandleWheel,
+    top: `${-pixelOffset}px`,
+    // TODO use dynamic css instead
+    type: Div
   }, ...visibleItems.flatMap(getSearchResultVirtualDom)];
 };
 
 const getSearchResultsVirtualDom = (visibleItems, focusOutline, scrollbarHeight, scrollBarY, scrollBarValue, deltaY, itemHeight) => {
   const childCount = scrollbarHeight === 0 ? 1 : 2;
   return [{
-    type: Div,
+    childCount,
     className: mergeClassNames(Viewlet, List$1, Tree, focusOutline ? FocusOutline : Empty$1),
+    onBlur: HandleListBlur,
     role: Tree$1,
     tabIndex: 0,
-    childCount,
-    onBlur: HandleListBlur
+    type: Div
     // TODO renable this when dom diffing is supported
     // onPointerDown: HandleListPointerDown,
     // onFocus: HandleListFocus,
@@ -5287,9 +5297,9 @@ const getSearchVirtualDom = (visibleItems, flags, message, focusOutline, searchI
   const errorDom = getSearchInputErrorVirtualDom(searchInputErrorMessage);
   const childCount = 2 + (errorDom.length > 0 ? 1 : 0);
   return [{
-    type: Div,
+    childCount,
     className,
-    childCount
+    type: Div
   }, ...getSearchHeaderVirtualDom(flags, message, searchInputErrorMessage, matchCount, focus, limitHitWarning), ...errorDom, ...getSearchResultsVirtualDom(visibleItems, focusOutline, scrollBarHeight, scrollBarY, scrollBarValue, deltaY, itemHeight)];
 };
 
@@ -5321,22 +5331,22 @@ const renderExcludeValue = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
-    case RenderValue:
-      return renderValue;
+    case RenderExcludeValue:
+      return renderExcludeValue;
     case RenderFocus:
       return renderFocus;
-    case RenderReplaceValue:
-      return renderReplacement;
+    case RenderFocusContext:
+      return renderFocusContext;
     case RenderIncludeValue:
       return renderIncludeValue;
-    case RenderExcludeValue:
-      return renderExcludeValue;
     case RenderItems:
       return renderItems;
-    case RenderFocusContext:
-      return renderFocusContext;
+    case RenderReplaceValue:
+      return renderReplacement;
     case RenderSelections:
       return renderSelections;
+    case RenderValue:
+      return renderValue;
     default:
       throw new Error('unknown renderer');
   }
@@ -5353,8 +5363,8 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get$1(uid);
   set(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
@@ -5365,10 +5375,10 @@ const Button = 1;
 
 const getIconVirtualDom = (icon, type = Div) => {
   return {
-    type,
+    childCount: 0,
     className: mergeClassNames(MaskIcon, `MaskIcon${icon}`),
     role: None$2,
-    childCount: 0
+    type
   };
 };
 
@@ -5380,18 +5390,18 @@ const getClassName = enabled => {
 };
 const getActionButtonVirtualDom = action => {
   const {
-    id,
+    enabled,
     icon,
-    label,
-    enabled
+    id,
+    label
   } = action;
   const className = getClassName(enabled);
   return [{
-    type: Button$2,
+    childCount: 1,
     className,
-    title: label,
     name: id,
-    childCount: 1
+    title: label,
+    type: Button$2
   }, getIconVirtualDom(icon)];
 };
 
@@ -5406,11 +5416,11 @@ const getActionVirtualDom = action => {
 
 const getActionsVirtualDom = actions => {
   return [{
-    type: Div,
+    childCount: actions.length,
     className: Actions,
+    onClick: HandleActionClick,
     role: ToolBar,
-    childCount: actions.length,
-    onClick: HandleActionClick
+    type: Div
   }, ...actions.flatMap(getActionVirtualDom)];
 };
 
@@ -5422,45 +5432,45 @@ const Refresh = 'Refresh';
 
 const getActions = state => {
   const {
-    value,
-    replacement
+    replacement,
+    value
   } = state;
   const bothEmpty = value === '' && replacement === '';
   return [{
-    type: Button,
-    label: refresh$1(),
+    command: 'refresh',
+    enabled: true,
     icon: Refresh,
     id: Refresh$1,
-    command: 'refresh',
-    enabled: true
+    label: refresh$1(),
+    type: Button
   }, {
-    type: Button,
-    label: clearSearchResults(),
-    icon: ClearAll,
     command: 'clearSearchResults',
+    enabled: !bothEmpty,
+    icon: ClearAll,
     id: ClearAll$1,
-    enabled: !bothEmpty
+    label: clearSearchResults(),
+    type: Button
   }, {
-    type: Button,
-    label: openNewSearchEditor(),
-    icon: NewFile,
     command: '',
+    enabled: true,
+    icon: NewFile,
     id: OpenSearchEditor,
-    enabled: true
+    label: openNewSearchEditor(),
+    type: Button
   }, {
-    type: Button,
-    label: viewAsTree$1(),
-    icon: ListFlat,
     command: '',
+    enabled: true,
+    icon: ListFlat,
     id: ViewAsTree,
-    enabled: true
+    label: viewAsTree$1(),
+    type: Button
   }, {
-    type: Button,
-    label: collapseAll(),
-    icon: CollapseAll,
     command: '',
+    enabled: true,
+    icon: CollapseAll,
     id: CollapseAll$1,
-    enabled: true
+    label: collapseAll(),
+    type: Button
   }];
 };
 
@@ -5541,23 +5551,14 @@ const renderEventListeners = () => {
   }];
 };
 
-const getDom = state => {
-  const displayResults = getDisplayResults(state.listItems, state.itemHeight, state.fileCount, state.value, state.minLineY, state.maxLineY, state.replacement, state.icons, state.listFocusedIndex, state.collapsedPaths, state.items);
-  const focusOutline = state.listFocused && state.listFocusedIndex === -1;
-  const scrollBarValue = state.deltaY / state.finalDeltaY * 100;
-  const scrollBarY = getScrollBarY$1(state.deltaY, state.finalDeltaY, state.height - state.headerHeight, state.scrollBarHeight);
-  const dom = getSearchVirtualDom(displayResults, state.flags, state.message, focusOutline, state.searchInputErrorMessage, state.scrollBarHeight, scrollBarY, scrollBarValue, state.deltaY, state.itemHeight, state.matchCount, state.limitHitWarning, state.focus);
-  return dom;
-};
-
 // TODO cache rendered dom so that it can be used for dom diffing
 const renderIncremental = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get$1(uid);
-  const oldDom = getDom(oldState);
-  const newDom = getDom(newState);
+  const oldDom = renderItems(oldState, oldState);
+  const newDom = renderItems(newState, newState);
   const patches = diff$1(oldDom, newDom);
   return patches;
 };
@@ -5595,8 +5596,8 @@ const replaceAllAndPrompt = async (workspacePath, items, replacement, matchCount
   const confirmAccept = replace();
   const confirmText = getReplaceAllConfirmText(matchCount, fileCount, replacement);
   const shouldReplace = await prompt(confirmText, {
-    title: confirmTitle,
-    confirmMessage: confirmAccept
+    confirmMessage: confirmAccept,
+    title: confirmTitle
   });
   if (!shouldReplace) {
     return false;
@@ -5621,26 +5622,26 @@ const rerender = state => {
 
 const saveState = state => {
   const {
-    value,
-    replacement,
-    flags,
-    includeValue,
-    excludeValue,
-    history,
     collapsedPaths,
+    excludeValue,
+    flags,
     focus,
-    listFocused
+    history,
+    includeValue,
+    listFocused,
+    replacement,
+    value
   } = state;
   return {
-    value,
-    replacement,
-    flags,
-    includeValue,
-    excludeValue,
-    history,
     collapsedPaths,
+    excludeValue,
+    flags,
     focus,
-    listFocused
+    history,
+    includeValue,
+    listFocused,
+    replacement,
+    value
   };
 };
 
@@ -5719,9 +5720,9 @@ const getNewHistory = (history, newValue) => {
 const submit = state => {
   const newHistory = getNewHistory(state.history, state.value);
   return handleUpdate(state, {
-    value: state.value,
+    history: newHistory,
     inputSource: User,
-    history: newHistory
+    value: state.value
   });
 };
 
@@ -5729,41 +5730,42 @@ const Keyboard = -1;
 
 const handleContextMenuKeyboard = async state => {
   const {
+    uid,
     x,
-    y,
-    uid
+    y
   } = state; // TODO
   await show2(uid, Search$1, x, y, {
-    menuId: Search$1,
-    index: 0 // TODO pass proper index
+    index: 0,
+    // TODO pass proper index
+    menuId: Search$1
   });
   return state;
 };
 
 const handleContextMenuMouseAt = async (state, eventX, eventY) => {
   const {
-    uid,
-    x,
-    y,
-    itemHeight,
     deltaY,
     flags,
-    listItems
+    itemHeight,
+    listItems,
+    uid,
+    x,
+    y
   } = state;
   const topHeight = getTopHeight(flags);
   const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, topHeight, listItems.length);
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get$1(uid);
   set(uid, oldState, {
     ...newState,
-    listFocusedIndex: index,
-    focusedIndex: index
+    focusedIndex: index,
+    listFocusedIndex: index
   });
   await show2(uid, Search$1, x, y, {
-    menuId: Search$1,
-    index
+    index,
+    menuId: Search$1
   });
   return state;
 };
@@ -5789,6 +5791,7 @@ const commandMap = {
   'TextSearch.collapseDetails': wrapCommand(collapseDetails),
   'TextSearch.copy': wrapCommand(copy$1),
   'TextSearch.copyPath': wrapCommand(copyPath$1),
+  'TextSearch.create': create,
   'TextSearch.diff2': diff2,
   'TextSearch.dismissItem': wrapCommand(dismissItem),
   'TextSearch.expandDetails': wrapCommand(expandDetails),
@@ -5814,7 +5817,10 @@ const commandMap = {
   'TextSearch.focusReplaceValuePrevious': wrapCommand(focusReplaceValuePrevious),
   'TextSearch.focusSearchValue': wrapCommand(focusSearchValue$1),
   'TextSearch.focusSearchValueNext': wrapCommand(focusSearchValueNext),
+  'TextSearch.getCommandIds': getCommandIds,
+  'TextSearch.getKeyBindings': getKeyBindings,
   'TextSearch.getMenuEntries': wrapGetter(getMenuEntries),
+  'TextSearch.getMenuEntryIds': getMenuEntryIds,
   'TextSearch.handleActionClick': wrapCommand(handleActionClick),
   'TextSearch.handleClickAt': wrapCommand(handleClickAt),
   'TextSearch.handleContextMenu': wrapCommand(handleContextMenu),
@@ -5845,6 +5851,8 @@ const commandMap = {
   'TextSearch.handleScrollBarMove': wrapCommand(handleScrollBarMove),
   'TextSearch.handleSharedInput': wrapCommand(handleSharedInput),
   'TextSearch.handleWheel': wrapCommand(handleWheel),
+  // not wrapped
+  'TextSearch.initialize': initialize,
   'TextSearch.loadContent': wrapCommand(loadContent),
   'TextSearch.nextHistoryResult': wrapCommand(nextHistoryResult),
   'TextSearch.openSearchEditor': wrapCommand(openSearchEditor),
@@ -5852,12 +5860,22 @@ const commandMap = {
   'TextSearch.refresh': wrapCommand(refresh),
   'TextSearch.removeCurrent': wrapCommand(removeCurrent),
   'TextSearch.removeIndex': wrapCommand(removeIndex),
+  'TextSearch.render2': render2,
+  'TextSearch.renderActions': wrapGetter(renderActions),
+  'TextSearch.renderEventListeners': renderEventListeners,
+  'TextSearch.renderIncremental': renderIncremental,
   'TextSearch.replaceAll': wrapCommand(replaceAll),
+  // TODO needed?
+  'TextSearch.replaceAllAndPrompt': replaceAllAndPrompt,
   'TextSearch.replaceAllInFile': wrapCommand(replaceAllInFile),
   'TextSearch.rerender': rerender,
+  'TextSearch.restoreState': restoreState,
+  'TextSearch.saveState': wrapGetter(saveState),
   'TextSearch.selectIndex': wrapCommand(selectIndex),
   'TextSearch.setLimit': wrapCommand(setLimit),
   'TextSearch.submit': wrapCommand(submit),
+  'TextSearch.terminate': terminate,
+  'TextSearch.textSearch': textSearch$6,
   'TextSearch.toggleMatchCase': wrapCommand(toggleMatchCase),
   'TextSearch.toggleMatchWholeWord': wrapCommand(toggleMatchWholeWord),
   'TextSearch.toggleOpenEditors': wrapCommand(toggleOpenEditors),
@@ -5866,23 +5884,7 @@ const commandMap = {
   'TextSearch.toggleSearchDetails': wrapCommand(toggleDetailsExpanded),
   'TextSearch.toggleUseIgnoreFiles': wrapCommand(toggleUseIgnoreFiles),
   'TextSearch.toggleUseRegularExpression': wrapCommand(toggleUseRegularExpression),
-  'TextSearch.viewAsTree': wrapCommand(viewAsTree),
-  // not wrapped
-  'TextSearch.initialize': initialize,
-  'TextSearch.create': create,
-  'TextSearch.getCommandIds': getCommandIds,
-  'TextSearch.getKeyBindings': getKeyBindings,
-  'TextSearch.render2': render2,
-  'TextSearch.renderEventListeners': renderEventListeners,
-  'TextSearch.renderIncremental': renderIncremental,
-  'TextSearch.restoreState': restoreState,
-  'TextSearch.saveState': wrapGetter(saveState),
-  'TextSearch.renderActions': wrapGetter(renderActions),
-  'TextSearch.terminate': terminate,
-  'TextSearch.getMenuEntryIds': getMenuEntryIds,
-  // TODO needed?
-  'TextSearch.replaceAllAndPrompt': replaceAllAndPrompt,
-  'TextSearch.textSearch': textSearch$6
+  'TextSearch.viewAsTree': wrapCommand(viewAsTree)
 };
 
 const textSearch$5 = async (scheme, root, query) => {
@@ -5890,24 +5892,24 @@ const textSearch$5 = async (scheme, root, query) => {
   string(query);
   const results = await invoke$1('ExtensionHostTextSearch.executeTextSearchProvider', scheme, query);
   return {
-    results,
-    limitHit: false
+    limitHit: false,
+    results
   };
 };
 
 const textSearch$4 = async (scheme, root, query, options, assetDir) => {
   const results = await invoke$1('ExtensionHostTextSearch.textSearchFetch', scheme, root, query, options, assetDir);
   return {
-    results,
-    limitHit: false
+    limitHit: false,
+    results
   };
 };
 
 const textSearch$3 = async (scheme, root, query) => {
   const results = await invoke$1('ExtensionHostTextSearch.textSearchHtml', scheme, root, query);
   return {
-    results,
-    limitHit: false
+    limitHit: false,
+    results
   };
 };
 
@@ -5922,8 +5924,8 @@ const textSearch$2 = async (scheme, root, query, options, assetDir) => {
   } catch {
     const results = await invoke$1('ExtensionHostTextSearch.textSearchMemory', scheme, root, query, options, assetDir);
     return {
-      results,
-      limitHit: false
+      limitHit: false,
+      results
     };
   }
 };
@@ -5940,16 +5942,16 @@ const textSearch$1 = async (scheme, root, query, options, assetDir, platform) =>
   if (platform === Remote || platform === Electron) {
     const result = await invoke('TextSearch.search', actualOptions);
     return {
-      results: result.results,
-      limitHit: result.limitHit
+      limitHit: result.limitHit,
+      results: result.results
     };
   }
   // TODO always create search process messageport rpc to have one api, in web can send the messageport to renderer worker
   const result = await invoke$1('SearchProcess.invoke', 'TextSearch.search', actualOptions);
   // TODO api is weird
   return {
-    results: result.results,
-    limitHit: result.limitHit
+    limitHit: result.limitHit,
+    results: result.results
   };
 };
 
@@ -5967,20 +5969,20 @@ const textSearch = async (scheme, root, query) => {
     }
   }
   return {
-    results,
-    limitHit: false
+    limitHit: false,
+    results
   };
 };
 
 const textSearchProviderMap = {
   '': textSearch$1,
   // TODO deprecate/remove workspaces without scheme
-  file: textSearch$1,
-  web: textSearch,
+  default: textSearch$5,
   fetch: textSearch$4,
+  file: textSearch$1,
   html: textSearch$3,
   memfs: textSearch$2,
-  default: textSearch$5
+  web: textSearch
 };
 
 const listen = async () => {