@lvce-editor/static-server 0.91.23 → 0.91.25

package/static/{49c5721 → 48ec708}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -54,64 +54,52 @@ class VError extends Error {
   }
 }
 
-class AssertionError extends Error {
+let AssertionError$1 = class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-}
-const Object$1 = 1;
-const Number$1 = 2;
-const Array$1 = 3;
-const String = 4;
-const Boolean$1 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown = 8;
-const getType = value => {
+};
+const Object$1$1 = 1;
+const Number$2 = 2;
+const Array$1$1 = 3;
+const String$2 = 4;
+const Boolean$2 = 5;
+const Function$1 = 6;
+const Null$1 = 7;
+const Unknown$1 = 8;
+const getType$1 = value => {
   switch (typeof value) {
     case 'number':
-      return Number$1;
+      return Number$2;
     case 'function':
-      return Function;
+      return Function$1;
     case 'string':
-      return String;
+      return String$2;
     case 'object':
       if (value === null) {
-        return Null;
+        return Null$1;
       }
       if (Array.isArray(value)) {
-        return Array$1;
+        return Array$1$1;
       }
-      return Object$1;
+      return Object$1$1;
     case 'boolean':
-      return Boolean$1;
+      return Boolean$2;
     default:
-      return Unknown;
+      return Unknown$1;
   }
 };
 const object = value => {
-  const type = getType(value);
-  if (type !== Object$1) {
-    throw new AssertionError('expected value to be of type object');
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== Number$1) {
-    throw new AssertionError('expected value to be of type number');
+  const type = getType$1(value);
+  if (type !== Object$1$1) {
+    throw new AssertionError$1('expected value to be of type object');
   }
 };
-const array = value => {
-  const type = getType(value);
-  if (type !== Array$1) {
-    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 number$1 = value => {
+  const type = getType$1(value);
+  if (type !== Number$2) {
+    throw new AssertionError$1('expected value to be of type number');
   }
 };
 
@@ -157,7 +145,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -311,7 +298,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -1186,9 +1180,14 @@ const create$7 = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const rawIpc = await IpcParentWithWebSocket$1.create({
-    webSocket
-  });
+  let rawIpc;
+  try {
+    rawIpc = await IpcParentWithWebSocket$1.create({
+      webSocket
+    });
+  } catch (error) {
+    throw new VError(error, 'Failed to create rpc connection');
+  }
   const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
@@ -1301,10 +1300,299 @@ const create$3 = rpcId => {
   };
 };
 
+const Alert = 'alert';
+const Button$3 = 'button';
+const CheckBox = 'checkbox';
+const None$2 = 'none';
+const ScrollBar$1 = 'scrollbar';
+const Status = 'status';
+const ToolBar = 'toolbar';
+const Tree$1 = 'tree';
+const TreeItem$1 = 'treeitem';
+
+const Actions = 'Actions';
+const Badge = 'Badge';
+const Chevron = 'Chevron';
+const CloseMaskIcon = 'MaskIcon MaskIconClose';
+const Empty$1 = '';
+const FileIcon = 'FileIcon';
+const FocusOutline = 'FocusOutline';
+const Grow = 'Grow';
+const Highlight = 'Highlight';
+const HighlightDeleted = 'HighlightDeleted';
+const HighlightInserted = 'HighlightInserted';
+const IconButton = 'IconButton';
+const IconButtonDisabled = 'IconButtonDisabled';
+const Label$1 = 'Label';
+const List$1 = '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';
+const MaskIconWholeWord = 'MaskIconWholeWord';
+const MultilineInputBox = 'MultilineInputBox';
+const ScrollBar = 'ScrollBar';
+const ScrollBarThumb = 'ScrollBarThumb';
+const ScrollBarVertical = 'ScrollBarVertical';
+const Search$3 = 'Search';
+const SearchField = 'SearchField';
+const SearchFieldButton = 'SearchFieldButton';
+const SearchFieldButtonChecked = 'SearchFieldButtonChecked';
+const SearchFieldButtonDisabled = 'SearchFieldButtonDisabled';
+const SearchFieldButtons = 'SearchFieldButtons';
+const SearchFieldContainer = 'SearchFieldContainer';
+const SearchFieldError = 'SearchFieldError';
+const SearchHeader = 'SearchHeader';
+const SearchHeaderDetails = 'SearchHeaderDetails';
+const SearchHeaderDetailsExpanded = 'SearchHeaderDetailsExpanded';
+const SearchHeaderDetailsExpandedTop = 'SearchHeaderDetailsExpandedTop';
+const SearchHeaderDetailsHeading = 'SearchHeaderDetailsHeading';
+const SearchHeaderTop = 'SearchHeaderTop';
+const SearchHeaderTopRight = 'SearchHeaderTopRight';
+const SearchInputError = 'SearchInputError';
+const SearchRemove = 'SearchRemove';
+const SearchToggleButton = 'SearchToggleButton';
+const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
+const SourceControlBadge = 'SourceControlBadge';
+const ToggleDetails = 'ToggleDetails';
+const Tree = 'Tree';
+const TreeItem = 'TreeItem';
+const TreeItemActive = 'TreeItemActive';
+const TreeItems$1 = 'TreeItems';
+const Viewlet = 'Viewlet';
+const ViewletSearchMessage = 'ViewletSearchMessage';
+const ViewletSearchMessageIndented = 'ViewletSearchMessageIndented';
+
+const File$2 = 7;
+
+const Audio = 0;
+const Button$2 = 1;
+const Col = 2;
+const ColGroup = 3;
+const Div = 4;
+const H1 = 5;
+const Input = 6;
+const Kbd = 7;
+const Span = 8;
+const Table = 9;
+const TBody = 10;
+const Td = 11;
+const Text = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const I = 16;
+const Img = 17;
+const Root = 0;
+const Ins = 20;
+const Del = 21;
+const H2 = 22;
+const H3 = 23;
+const H4 = 24;
+const H5 = 25;
+const H6 = 26;
+const Article = 27;
+const Aside = 28;
+const Footer = 29;
+const Header = 30;
+const Nav = 40;
+const Section = 41;
+const Search$2 = 42;
+const Dd = 43;
+const Dl = 44;
+const Figcaption = 45;
+const Figure = 46;
+const Hr = 47;
+const Li = 48;
+const Ol = 49;
+const P = 50;
+const Pre = 51;
+const A = 53;
+const Abbr = 54;
+const Br = 55;
+const Cite = 56;
+const Data = 57;
+const Time = 58;
+const Tfoot = 59;
+const Ul = 60;
+const Video = 61;
+const TextArea = 62;
+const Select = 63;
+const Option = 64;
+const Code = 65;
+const Label = 66;
+const Dt = 67;
+const Iframe = 68;
+const Main = 69;
+const Strong = 70;
+const Em = 71;
+const Style = 72;
+const Html = 73;
+const Head = 74;
+const Title = 75;
+const Meta = 76;
+const Canvas = 77;
+const Form = 78;
+const BlockQuote = 79;
+const Quote = 80;
+const Circle = 81;
+const Defs = 82;
+const Ellipse = 83;
+const G = 84;
+const Line = 85;
+const Path = 86;
+const Polygon = 87;
+const Polyline = 88;
+const Rect = 89;
+const Svg = 90;
+const Use = 91;
+const Reference = 100;
+
+const VirtualDomElements = {
+  __proto__: null,
+  A,
+  Abbr,
+  Article,
+  Aside,
+  Audio,
+  BlockQuote,
+  Br,
+  Button: Button$2,
+  Canvas,
+  Circle,
+  Cite,
+  Code,
+  Col,
+  ColGroup,
+  Data,
+  Dd,
+  Defs,
+  Del,
+  Div,
+  Dl,
+  Dt,
+  Ellipse,
+  Em,
+  Figcaption,
+  Figure,
+  Footer,
+  Form,
+  G,
+  H1,
+  H2,
+  H3,
+  H4,
+  H5,
+  H6,
+  Head,
+  Header,
+  Hr,
+  Html,
+  I,
+  Iframe,
+  Img,
+  Input,
+  Ins,
+  Kbd,
+  Label,
+  Li,
+  Line,
+  Main,
+  Meta,
+  Nav,
+  Ol,
+  Option,
+  P,
+  Path,
+  Polygon,
+  Polyline,
+  Pre,
+  Quote,
+  Rect,
+  Reference,
+  Root,
+  Search: Search$2,
+  Section,
+  Select,
+  Span,
+  Strong,
+  Style,
+  Svg,
+  TBody,
+  THead,
+  Table,
+  Td,
+  Text,
+  TextArea,
+  Tfoot,
+  Th,
+  Time,
+  Title,
+  Tr,
+  Ul,
+  Use,
+  Video
+};
+
+const Button$1 = 'event.button';
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const DeltaMode = 'event.deltaMode';
+const DeltaY = 'event.deltaY';
+const TargetName = 'event.target.name';
+const TargetSelectionEnd = 'event.target.selectionEnd';
+const TargetSelectionStart = 'event.target.selectionStart';
+const TargetValue = 'event.target.value';
+
+const Script$1 = 2;
+
+const Search$1 = 18;
+const InputContextMenu = 91;
+
+const Separator = 1;
+const None$1 = 0;
+
+const LeftClick = 0;
+
+const Electron = 2;
+const Remote = 3;
+
 const IconThemeWorker = 7009;
 const RendererWorker = 1;
 const SearchProcess = 77;
 
+const File$1 = 1;
+const Match$1 = 2;
+
+const FocusElementByName = 'Viewlet.focusElementByName';
+const SetCss = 'Viewlet.setCss';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetValueByName = 'Viewlet.setValueByName';
+const SetPatches = 'Viewlet.setPatches';
+
+const Empty = 0;
+const FocusIgnoreFiles = 1012;
+const FocusSearch = 1013;
+const FocusSearchExcludeInput = 1008;
+const FocusSearchIncludeInput = 1007;
+const FocusSearchInput = 21;
+const FocusSearchMatchCase = 32;
+const FocusSearchOpenEditors = 1011;
+const FocusSearchPreserveCase = 36;
+const FocusSearchRegex = 33;
+const FocusSearchReplaceAll = 35;
+const FocusSearchReplaceInput = 31;
+const FocusSearchResults = 22;
+const FocusSearchWholeWord = 34;
+const FocusToggleDetails = 1010;
+const FocusToggleReplace = 1020;
+
 const {
   invoke: invoke$2,
   set: set$3
@@ -1314,6 +1602,61 @@ const getIcons = async iconRequests => {
   return invoke$2('IconTheme.getIcons', iconRequests);
 };
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String$1 = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String$1;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const array = value => {
+  const type = getType(value);
+  if (type !== Array$1) {
+    throw new AssertionError('expected value to be of type array');
+  }
+};
+const string = value => {
+  const type = getType(value);
+  if (type !== String$1) {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
 const {
   invoke: invoke$1,
   invokeAndTransfer,
@@ -1356,29 +1699,87 @@ const toCommandId = key => {
   return key.slice(dotIndex + 1);
 };
 const create$2 = () => {
+  const commandQueues = new Map();
+  const generations = Object.create(null);
   const states = Object.create(null);
   const commandMapRef = {};
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
   return {
     clear() {
+      commandQueues.clear();
       for (const key of Object.keys(states)) {
         delete states[key];
       }
     },
     diff(uid, modules, numbers) {
       const {
-        newState,
-        oldState
+        oldState,
+        scheduledState
       } = states[uid];
       const diffResult = [];
       for (let i = 0; i < modules.length; i++) {
         const fn = modules[i];
-        if (!fn(oldState, newState)) {
+        if (!fn(oldState, scheduledState)) {
           diffResult.push(numbers[i]);
         }
       }
       return diffResult;
     },
     dispose(uid) {
+      commandQueues.delete(uid);
       delete states[uid];
     },
     get(uid) {
@@ -1390,21 +1791,33 @@ const create$2 = () => {
       return ids;
     },
     getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseFloat(key);
-      });
+      return Object.keys(states).map(Number);
     },
     registerCommands(commandMap) {
       Object.assign(commandMapRef, commandMap);
     },
-    set(uid, oldState, newState) {
+    set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
       states[uid] = {
         newState,
-        oldState
+        oldState,
+        scheduledState: scheduledState ?? newState
       };
     },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -1413,6 +1826,9 @@ const create$2 = () => {
         if (oldState === newerState || newState === newerState) {
           return;
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -1420,7 +1836,8 @@ const create$2 = () => {
         };
         states[uid] = {
           newState: latestNew,
-          oldState: latestOld.oldState
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
         };
       };
       return wrapped;
@@ -1436,6 +1853,7 @@ const create$2 = () => {
     },
     wrapLoadContent(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -1450,6 +1868,11 @@ const create$2 = () => {
             error
           };
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -1457,13 +1880,59 @@ const create$2 = () => {
         };
         states[uid] = {
           newState: latestNew,
-          oldState: latestOld.oldState
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
         };
         return {
           error
         };
       };
       return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
     }
   };
 };
@@ -1471,137 +1940,6 @@ const terminate = () => {
   globalThis.close();
 };
 
-const Alert = 'alert';
-const Button$3 = 'button';
-const CheckBox = 'checkbox';
-const None$2 = 'none';
-const ScrollBar$1 = 'scrollbar';
-const Status = 'status';
-const ToolBar = 'toolbar';
-const Tree$1 = 'tree';
-const TreeItem$1 = 'treeitem';
-
-const Actions = 'Actions';
-const Badge = 'Badge';
-const Chevron = 'Chevron';
-const CloseMaskIcon = 'MaskIcon MaskIconClose';
-const Empty$1 = '';
-const FileIcon = 'FileIcon';
-const FocusOutline = 'FocusOutline';
-const Grow = 'Grow';
-const Highlight = 'Highlight';
-const HighlightDeleted = 'HighlightDeleted';
-const HighlightInserted = 'HighlightInserted';
-const IconButton = 'IconButton';
-const IconButtonDisabled = 'IconButtonDisabled';
-const Label = 'Label';
-const List$1 = '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';
-const MaskIconWholeWord = 'MaskIconWholeWord';
-const MultilineInputBox = 'MultilineInputBox';
-const ScrollBar = 'ScrollBar';
-const ScrollBarThumb = 'ScrollBarThumb';
-const ScrollBarVertical = 'ScrollBarVertical';
-const Search$2 = 'Search';
-const SearchField = 'SearchField';
-const SearchFieldButton = 'SearchFieldButton';
-const SearchFieldButtonChecked = 'SearchFieldButtonChecked';
-const SearchFieldButtonDisabled = 'SearchFieldButtonDisabled';
-const SearchFieldButtons = 'SearchFieldButtons';
-const SearchFieldContainer = 'SearchFieldContainer';
-const SearchFieldError = 'SearchFieldError';
-const SearchHeader = 'SearchHeader';
-const SearchHeaderDetails = 'SearchHeaderDetails';
-const SearchHeaderDetailsExpanded = 'SearchHeaderDetailsExpanded';
-const SearchHeaderDetailsExpandedTop = 'SearchHeaderDetailsExpandedTop';
-const SearchHeaderDetailsHeading = 'SearchHeaderDetailsHeading';
-const SearchHeaderTop = 'SearchHeaderTop';
-const SearchHeaderTopRight = 'SearchHeaderTopRight';
-const SearchInputError = 'SearchInputError';
-const SearchRemove = 'SearchRemove';
-const SearchToggleButton = 'SearchToggleButton';
-const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
-const SourceControlBadge = 'SourceControlBadge';
-const ToggleDetails = 'ToggleDetails';
-const Tree = 'Tree';
-const TreeItem = 'TreeItem';
-const TreeItemActive = 'TreeItemActive';
-const TreeItems$1 = 'TreeItems';
-const Viewlet = 'Viewlet';
-const ViewletSearchMessage = 'ViewletSearchMessage';
-const ViewletSearchMessageIndented = 'ViewletSearchMessageIndented';
-
-const File$2 = 7;
-
-const Button$2 = 1;
-const Div = 4;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-const Ins = 20;
-const Del = 21;
-const H4 = 24;
-const TextArea = 62;
-const Reference = 100;
-
-const Button$1 = 'event.button';
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const DeltaMode = 'event.deltaMode';
-const DeltaY = 'event.deltaY';
-const TargetName = 'event.target.name';
-const TargetSelectionEnd = 'event.target.selectionEnd';
-const TargetSelectionStart = 'event.target.selectionStart';
-const TargetValue = 'event.target.value';
-
-const Script$1 = 2;
-
-const Search$1 = 18;
-const InputContextMenu = 91;
-
-const Separator = 1;
-const None$1 = 0;
-
-const LeftClick = 0;
-
-const Electron = 2;
-const Remote = 3;
-
-const File$1 = 1;
-const Match$1 = 2;
-
-const FocusElementByName = 'Viewlet.focusElementByName';
-const SetCss = 'Viewlet.setCss';
-const SetFocusContext = 'Viewlet.setFocusContext';
-const SetValueByName = 'Viewlet.setValueByName';
-const SetPatches = 'Viewlet.setPatches';
-
-const Empty = 0;
-const FocusIgnoreFiles = 1012;
-const FocusSearch = 1013;
-const FocusSearchExcludeInput = 1008;
-const FocusSearchIncludeInput = 1007;
-const FocusSearchInput = 21;
-const FocusSearchMatchCase = 32;
-const FocusSearchOpenEditors = 1011;
-const FocusSearchPreserveCase = 36;
-const FocusSearchRegex = 33;
-const FocusSearchReplaceAll = 35;
-const FocusSearchReplaceInput = 31;
-const FocusSearchResults = 22;
-const FocusSearchWholeWord = 34;
-const FocusToggleDetails = 1010;
-const FocusToggleReplace = 1020;
-
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
@@ -1614,6 +1952,8 @@ const text = data => {
   };
 };
 
+new Set(Object.values(VirtualDomElements));
+
 const SetText = 1;
 const Replace$1 = 2;
 const SetAttribute = 3;
@@ -1685,12 +2025,12 @@ const getChildrenWithCount = (nodes, startIndex, childCount) => {
 };
 
 const compareNodes = (oldNode, newNode) => {
-  const patches = [];
   // Check if node type changed - return null to signal incompatible nodes
   // (caller should handle this with a Replace operation)
   if (oldNode.type !== newNode.type) {
     return null;
   }
+  const patches = [];
   // Handle reference nodes - special handling for uid changes
   if (oldNode.type === Reference) {
     if (oldNode.uid !== newNode.uid) {
@@ -1726,7 +2066,7 @@ const compareNodes = (oldNode, newNode) => {
   }
   // Check for removed attributes
   for (const key of oldKeys) {
-    if (!(key in newNode)) {
+    if (!Object.hasOwn(newNode, key)) {
       patches.push({
         type: RemoveAttribute,
         key
@@ -1744,11 +2084,78 @@ const treeToArray = node => {
   return result;
 };
 
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    patches.push({
+      type: NavigateChild,
+      index
+    });
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    patches.push({
+      type: NavigateSibling,
+      index
+    });
+  }
+  return index;
+};
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+  }
+  return -1;
+};
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace$1,
+    nodes: treeToArray(newNode)
+  });
+};
+const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex;
+  }
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+  return nextChildIndex;
+};
+const diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
 const diffChildren = (oldChildren, newChildren, patches) => {
   const maxLength = Math.max(oldChildren.length, newChildren.length);
-  // Track where we are: -1 means at parent, >= 0 means at child index
   let currentChildIndex = -1;
-  // Collect indices of children to remove (we'll add these patches at the end in reverse order)
   const indicesToRemove = [];
   for (let i = 0; i < maxLength; i++) {
     const oldNode = oldChildren[i];
@@ -1757,88 +2164,17 @@ const diffChildren = (oldChildren, newChildren, patches) => {
       continue;
     }
     if (!oldNode) {
-      // Add new node - we should be at the parent
-      if (currentChildIndex >= 0) {
-        // Navigate back to parent
-        patches.push({
-          type: NavigateParent
-        });
-        currentChildIndex = -1;
-      }
-      // Flatten the entire subtree so renderInternal can handle it
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Add,
-        nodes: flatNodes
-      });
-    } else if (newNode) {
-      // Compare nodes to see if we need any patches
-      const nodePatches = compareNodes(oldNode.node, newNode.node);
-      // If nodePatches is null, the node types are incompatible - need to replace
-      if (nodePatches === null) {
-        // Navigate to this child
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Replace the entire subtree
-        const flatNodes = treeToArray(newNode);
-        patches.push({
-          type: Replace$1,
-          nodes: flatNodes
-        });
-        // After replace, we're at the new element (same position)
-        continue;
-      }
-      // Check if we need to recurse into children
-      const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
-      // Only navigate to this element if we need to do something
-      if (nodePatches.length > 0 || hasChildrenToCompare) {
-        // Navigate to this child if not already there
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Apply node patches (these apply to the current element, not children)
-        if (nodePatches.length > 0) {
-          patches.push(...nodePatches);
-        }
-        // Compare children recursively
-        if (hasChildrenToCompare) {
-          diffChildren(oldNode.children, newNode.children, patches);
-        }
-      }
-    } else {
-      // Remove old node - collect the index for later removal
-      indicesToRemove.push(i);
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
     }
+    if (!newNode) {
+      indicesToRemove.push(i);
+      continue;
+    }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
   }
-  // Navigate back to parent if we ended at a child
-  if (currentChildIndex >= 0) {
-    patches.push({
-      type: NavigateParent
-    });
-  }
-  // Add remove patches in reverse order (highest index first)
-  // This ensures indices remain valid as we remove
+  navigateToParent(patches, currentChildIndex);
   for (let j = indicesToRemove.length - 1; j >= 0; j--) {
     patches.push({
       type: RemoveChild,
@@ -1847,47 +2183,22 @@ const diffChildren = (oldChildren, newChildren, patches) => {
   }
 };
 const diffTrees = (oldTree, newTree, patches, path) => {
-  // At the root level (path.length === 0), we're already AT the element
-  // So we compare the root node directly, then compare its children
   if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
-    const oldNode = oldTree[0];
-    const newNode = newTree[0];
-    // Compare root nodes
-    const nodePatches = compareNodes(oldNode.node, newNode.node);
-    // If nodePatches is null, the root node types are incompatible - need to replace
-    if (nodePatches === null) {
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Replace$1,
-        nodes: flatNodes
-      });
-      return;
-    }
-    if (nodePatches.length > 0) {
-      patches.push(...nodePatches);
-    }
-    // Compare children
-    if (oldNode.children.length > 0 || newNode.children.length > 0) {
-      diffChildren(oldNode.children, newNode.children, patches);
-    }
-  } else {
-    // Non-root level or multiple root elements - use the regular comparison
-    diffChildren(oldTree, newTree, patches);
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
   }
+  diffChildren(oldTree, newTree, patches);
 };
 
 const removeTrailingNavigationPatches = patches => {
-  // Find the last non-navigation patch
-  let lastNonNavigationIndex = -1;
-  for (let i = patches.length - 1; i >= 0; i--) {
-    const patch = patches[i];
+  while (patches.length > 0) {
+    const patch = patches.at(-1);
     if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
-      lastNonNavigationIndex = i;
       break;
     }
+    patches.pop();
   }
-  // Return patches up to and including the last non-navigation patch
-  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+  return patches;
 };
 
 const diffTree = (oldNodes, newNodes) => {
@@ -2033,51 +2344,6 @@ const getFileIcons = async (items, fileIconCache) => {
   };
 };
 
-// TODO optimize this function to return the minimum number
-// of visible items needed, e.g. when not scrolled 5 items with
-// 20px fill 100px but when scrolled 6 items are needed
-const getNumberOfVisibleItems$1 = (listHeight, itemHeight) => {
-  return Math.ceil(listHeight / itemHeight) + 1;
-};
-
-const getPaths = items => {
-  const paths = [];
-  for (const item of items) {
-    if (item.type === File) {
-      paths.push(item.text);
-    }
-  }
-  return paths;
-};
-const collapseAll$1 = async state => {
-  const {
-    fileIconCache,
-    headerHeight,
-    height,
-    itemHeight,
-    items
-  } = state;
-  if (items.length === 0) {
-    return state;
-  }
-  const paths = getPaths(items);
-  const total = items.length;
-  const listHeight = height - headerHeight;
-  const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
-  const maxLineY = Math.min(numberOfVisible, total);
-  const visible = items.slice(0, maxLineY);
-  const {
-    icons,
-    newFileIconCache
-  } = await getFileIcons(visible, fileIconCache);
-  return {
-    ...state,
-    collapsedPaths: paths,
-    fileIconCache: newFileIconCache,
-    icons
-  };
-};
-
 const getFilteredResults = (results, collapsedPaths) => {
   if (collapsedPaths.length === 0) {
     return results;
@@ -2096,6 +2362,13 @@ const getFilteredResults = (results, collapsedPaths) => {
   return filteredResults;
 };
 
+// TODO optimize this function to return the minimum number
+// of visible items needed, e.g. when not scrolled 5 items with
+// 20px fill 100px but when scrolled 6 items are needed
+const getNumberOfVisibleItems$1 = (listHeight, itemHeight) => {
+  return Math.ceil(listHeight / itemHeight) + 1;
+};
+
 const applyCollapsedPaths = async (state, collapsedPaths, listFocusedIndex) => {
   const {
     fileIconCache,
@@ -2127,6 +2400,27 @@ const applyCollapsedPaths = async (state, collapsedPaths, listFocusedIndex) => {
   };
 };
 
+const getPaths = items => {
+  const paths = [];
+  for (const item of items) {
+    if (item.type === File) {
+      paths.push(item.text);
+    }
+  }
+  return paths;
+};
+const collapseAll$1 = async state => {
+  const {
+    items,
+    listFocusedIndex
+  } = state;
+  if (items.length === 0) {
+    return state;
+  }
+  const paths = getPaths(items);
+  return applyCollapsedPaths(state, paths, listFocusedIndex);
+};
+
 const collapseCurrent = async state => {
   const {
     collapsedPaths,
@@ -2298,6 +2592,7 @@ const {
   getCommandIds,
   registerCommands,
   set,
+  wrapAsyncCommand,
   wrapCommand,
   wrapGetter
 } = create$2();
@@ -2591,15 +2886,15 @@ const getScrollBarOffset$1 = (delta, finalDelta, size, scrollBarSize) => {
 const getScrollBarY$1 = getScrollBarOffset$1;
 
 const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
 const i18nString = (key, placeholders = emptyObject) => {
   if (placeholders === emptyObject) {
     return key;
   }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
+  let result = key;
+  for (const [placeholder, replacement] of Object.entries(placeholders)) {
+    result = result.split(`{${placeholder}}`).join(String(replacement));
+  }
+  return result;
 };
 
 const ClearSearchResults = 'Clear Search Results';
@@ -2633,6 +2928,9 @@ const PreserveCase$1 = 'Preserve Case';
 const Refresh$2 = 'Refresh';
 const Replace = 'Replace';
 const ReplaceAll$1 = 'Replace All';
+const ReplacingManyOccurrencesInManyFiles = 'Replacing {PH1} occurrences across {PH2} files…';
+const ReplacingManyOccurrencesInOneFile = 'Replacing {PH1} occurrences across 1 file…';
+const ReplacingOneOccurrenceInOneFile = 'Replacing 1 occurrence across 1 file…';
 const ReplacedManyOccurrencesInManyFiles = "Replaced {PH1} occurrences across {PH2} files with '{PH3}'";
 const ReplacedOneOccurrenceInOneFile = "Replaced 1 occurrence across 1 file with '{PH1}'";
 const ReplaceForHistory = 'Replace (⇅ for history)';
@@ -2734,6 +3032,20 @@ const replacedManyOccurrencesInManyFiles = (matchCount, fileCount, replacement)
     PH3: replacement
   });
 };
+const replacingOneOccurrenceInOneFile = () => {
+  return i18nString(ReplacingOneOccurrenceInOneFile);
+};
+const replacingManyOccurrencesInOneFile = matchCount => {
+  return i18nString(ReplacingManyOccurrencesInOneFile, {
+    PH1: matchCount
+  });
+};
+const replacingManyOccurrencesInManyFiles = (matchCount, fileCount) => {
+  return i18nString(ReplacingManyOccurrencesInManyFiles, {
+    PH1: matchCount,
+    PH2: fileCount
+  });
+};
 const replaceAll$1 = () => {
   return i18nString(ReplaceAll$1);
 };
@@ -3032,7 +3344,11 @@ const getPreviousFocus = (focus, flags) => {
 };
 
 const focusPreviousInput = state => {
-  const previousFocus = getPreviousFocus(state.focus, state.flags);
+  const {
+    flags,
+    focus
+  } = state;
+  const previousFocus = getPreviousFocus(focus, flags);
   return {
     ...state,
     focus: previousFocus,
@@ -3056,7 +3372,10 @@ const focusSearchValue$1 = async state => {
 };
 
 const focusSearchValueNext = state => {
-  if (state.flags & ReplaceExpanded) {
+  const {
+    flags
+  } = state;
+  if (flags & ReplaceExpanded) {
     return focusReplaceValue$1(state);
   }
   return focusMatchCase$1(state);
@@ -3302,11 +3621,32 @@ const openUri = async (path, focus = true, props = {}) => {
 };
 
 const openSearchEditor = async state => {
-  const uri = `search-editor://${state.uid}-${globalThis.crypto.randomUUID()}/Search`;
+  const {
+    uid
+  } = state;
+  const uri = `search-editor://${uid}-${globalThis.crypto.randomUUID()}/Search`;
   await openUri(uri);
   return state;
 };
 
+const getSearchExcludes = async (fallback = []) => {
+  try {
+    const value = await invoke$1('Preferences.get', 'search.exclude');
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+      return [];
+    }
+    const excludes = [];
+    for (const [pattern, enabled] of Object.entries(value)) {
+      if (enabled === true) {
+        excludes.push(pattern);
+      }
+    }
+    return excludes;
+  } catch {
+    return fallback;
+  }
+};
+
 const handleError = error => {
   console.error(`[text-search-worker] ${error}`);
 };
@@ -3426,6 +3766,9 @@ const textSearch$6 = async (root, query, options, assetDir, platform, searchId,
 };
 
 const handleUpdateFull = async (state, update) => {
+  const {
+    workspacePath
+  } = state;
   const partialNewState = {
     ...state,
     ...update
@@ -3447,7 +3790,7 @@ const handleUpdateFull = async (state, update) => {
     value,
     width
   } = partialNewState;
-  const root = state.workspacePath;
+  const root = workspacePath;
   const scheme = getProtocol(root);
   const isFileSearch = scheme === '' || scheme === 'file';
   const shouldUsePullBasedSearch = usePullBasedSearch && isFileSearch;
@@ -3533,7 +3876,14 @@ const getRipGrepArgs = ({
   const excludePatternsFromDefaults = defaultExcludes?.filter(Boolean) || [];
   const uniqueExcludePatterns = [...new Set([...excludePatternsFromDefaults, ...excludePatternsFromValue])];
   for (const excludePattern of uniqueExcludePatterns) {
-    ripGrepArgs.push('--glob', `!**/${excludePattern}/**`);
+    if (excludePattern.includes('*')) {
+      ripGrepArgs.push('--glob', `!${excludePattern}`);
+      if (!excludePattern.endsWith('/**')) {
+        ripGrepArgs.push('--glob', `!${excludePattern}/**`);
+      }
+    } else {
+      ripGrepArgs.push('--glob', `!**/${excludePattern}/**`);
+    }
   }
   if (isCaseSensitive) {
     ripGrepArgs.push('--case-sensitive');
@@ -3607,6 +3957,9 @@ const textSearchIncremental = async (root, query, options, assetDir, platform, s
 };
 
 const handleUpdateIncremental = async (state, update) => {
+  const {
+    workspacePath
+  } = state;
   const partialNewState = {
     ...state,
     ...update
@@ -3623,7 +3976,7 @@ const handleUpdateIncremental = async (state, update) => {
     usePullBasedSearch,
     value
   } = partialNewState;
-  const root = state.workspacePath;
+  const root = workspacePath;
   const scheme = getProtocol(root);
   const searchId = crypto.randomUUID(); // TODO try to avoid side effect
   const latest1 = get$1(uid);
@@ -3658,6 +4011,10 @@ const getsearchid = () => {
   return crypto.randomUUID();
 };
 const handleUpdatePullBased = async (state, update) => {
+  const {
+    uid: previousUid,
+    workspacePath
+  } = state;
   const searchId = getsearchid();
   const partialNewState = {
     ...state,
@@ -3668,7 +4025,7 @@ const handleUpdatePullBased = async (state, update) => {
     searchId,
     searchResults: []
   };
-  set(state.uid, state, partialNewState);
+  set(previousUid, state, partialNewState);
   const {
     assetDir,
     excludeValue,
@@ -3682,7 +4039,7 @@ const handleUpdatePullBased = async (state, update) => {
     value,
     width
   } = partialNewState;
-  const root = state.workspacePath;
+  const root = workspacePath;
   const scheme = getProtocol(root);
   const isFileSearch = scheme === '' || scheme === 'file';
   const shouldUsePullBasedSearch = usePullBasedSearch && isFileSearch;
@@ -3796,8 +4153,14 @@ const handleUpdate = async (state, update) => {
   }
 };
 
-const refresh = state => {
-  return handleUpdate(state, {});
+const refresh = async state => {
+  const {
+    defaultExcludes: currentDefaultExcludes
+  } = state;
+  const defaultExcludes = await getSearchExcludes(currentDefaultExcludes);
+  return handleUpdate(state, {
+    defaultExcludes
+  });
 };
 
 const viewAsTree = async state => {
@@ -3879,6 +4242,16 @@ const getReplaceElements = (items, workspacePath, replacement) => {
   return bulkChanges;
 };
 
+const getReplacingMessage = (fileCount, replaceCount) => {
+  if (replaceCount === 1) {
+    return replacingOneOccurrenceInOneFile();
+  }
+  if (fileCount === 1) {
+    return replacingManyOccurrencesInOneFile(replaceCount);
+  }
+  return replacingManyOccurrencesInManyFiles(replaceCount, fileCount);
+};
+
 const getActualIndex = state => {
   const {
     focusedIndex,
@@ -3921,6 +4294,7 @@ const replaceAllInFocusedFile = async (state, fileIndex) => {
     height,
     itemHeight,
     items,
+    matchCount: totalMatchCount,
     maxLineY,
     minimumSliderSize,
     minLineY,
@@ -3940,7 +4314,7 @@ const replaceAllInFocusedFile = async (state, fileIndex) => {
     newFocusedIndex,
     newItems,
     newMatchCount
-  } = removeItemFromItems(items, fileIndex, state.matchCount, fileCount);
+  } = removeItemFromItems(items, fileIndex, totalMatchCount, fileCount);
   const {
     newDeltaY,
     newMaxLineY,
@@ -4000,17 +4374,42 @@ const replaceAll = async state => {
     minLineY: 0
   };
 };
+const replaceAllWithProgress = async context => {
+  const state = context.getState();
+  const {
+    fileCount: totalFileCount,
+    matchCount: totalMatchCount
+  } = state;
+  const actualIndex = getActualIndex(state);
+  const fileIndex = getFileIndex$1(state, actualIndex);
+  const fileCount = fileIndex === -1 ? totalFileCount : 1;
+  const matchCount = fileIndex === -1 ? totalMatchCount : Math.max(getFileItems(state, fileIndex).length - 1, 0);
+  const message = getReplacingMessage(fileCount, matchCount);
+  await context.updateState(latestState => ({
+    ...latestState,
+    message
+  }));
+  await invoke$1('Search.rerender');
+  const updatedState = await replaceAll(context.getState());
+  await context.updateState(() => updatedState);
+};
 
 const toggleDetailsExpanded = state => {
-  if (hasDetailsExpanded(state.flags)) {
+  const {
+    flags
+  } = state;
+  if (hasDetailsExpanded(flags)) {
     return collapseDetails(state);
   }
   return expandDetails(state);
 };
 
 const toggleSearchFlag = (state, flag) => {
+  const {
+    flags
+  } = state;
   return handleUpdate(state, {
-    flags: state.flags ^ flag
+    flags: flags ^ flag
   });
 };
 
@@ -4057,7 +4456,10 @@ const expandReplace = state => {
 };
 
 const toggleReplace = async state => {
-  if (hasReplaceExpanded(state.flags)) {
+  const {
+    flags
+  } = state;
+  if (hasReplaceExpanded(flags)) {
     return collapseReplace(state);
   }
   return expandReplace(state);
@@ -4115,7 +4517,10 @@ const handleHeaderFocusIn = state => {
 };
 
 const handleHeaderFocusOut = state => {
-  if (!state.focus) {
+  const {
+    focus
+  } = state;
+  if (!focus) {
     return state;
   }
   return {
@@ -4204,15 +4609,21 @@ const handleInputContextMenu = async (state, name, button, x, y) => {
 };
 
 const getCurrentValue = (state, name) => {
+  const {
+    excludeValue,
+    includeValue,
+    replacement,
+    value
+  } = state;
   switch (name) {
     case FilesToExclude:
-      return state.excludeValue;
+      return excludeValue;
     case FilesToInclude:
-      return state.includeValue;
+      return includeValue;
     case ReplaceValue:
-      return state.replacement;
+      return replacement;
     case SearchValue:
-      return state.value;
+      return value;
     default:
       return '';
   }
@@ -4636,51 +5047,51 @@ const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
   if (relativeY <= halfScrollBarHeight) {
     // clicked at top
     return {
-      percent: 0,
-      handleOffset: relativeY
+      handleOffset: relativeY,
+      percent: 0
     };
   }
   if (relativeY <= height - halfScrollBarHeight) {
     // clicked in middle
     return {
-      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
-      handleOffset: halfScrollBarHeight
+      handleOffset: halfScrollBarHeight,
+      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight)
     };
   }
   // clicked at bottom
   return {
-    percent: 1,
-    handleOffset: scrollBarHeight - height + relativeY
+    handleOffset: scrollBarHeight - height + relativeY,
+    percent: 1
   };
 };
 const focusIndexScrollDown = (state, index, listHeight, itemHeight, itemsLength) => {
   const {
     finalDeltaY,
-    height,
     headerHeight,
+    height,
     scrollBarHeight
   } = state;
-  const newMaxLineY = Math.min(index + 1, itemsLength);
   const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
-  const newMinLineY = Math.max(newMaxLineY - fittingItems, 0);
-  const newDeltaY = itemsLength < fittingItems ? 0 : newMinLineY * itemHeight - listHeight % itemHeight + itemHeight;
+  const newDeltaY = Math.min(Math.max((index + 1) * itemHeight - listHeight, 0), finalDeltaY);
+  const newMinLineY = Math.floor(newDeltaY / itemHeight);
+  const newMaxLineY = Math.min(newMinLineY + fittingItems, itemsLength);
   const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
     ...state,
+    deltaY: newDeltaY,
+    focused: true,
     focusedIndex: index,
     listFocusedIndex: index,
-    minLineY: newMinLineY,
     maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY,
+    minLineY: newMinLineY,
     scrollBarY
   };
 };
 const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) => {
   const {
     finalDeltaY,
-    height,
     headerHeight,
+    height,
     scrollBarHeight
   } = state;
   const newMinLineY = index;
@@ -4690,35 +5101,35 @@ const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) =
   const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
     ...state,
+    deltaY: newDeltaY,
+    focused: true,
     focusedIndex: index,
     listFocusedIndex: index,
-    minLineY: newMinLineY,
     maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY,
+    minLineY: newMinLineY,
     scrollBarY
   };
 };
 const focusIndex = (state, index) => {
   const {
-    itemHeight,
-    minLineY,
-    maxLineY,
     headerHeight,
     height,
-    items
+    itemHeight,
+    items,
+    maxLineY,
+    minLineY
   } = state;
   const itemsLength = items.length;
   if (itemsLength === 0) {
     return state;
   }
-  number(itemHeight);
+  number$1(itemHeight);
   if (index === -1) {
     return {
       ...state,
+      focused: true,
       focusedIndex: -1,
-      listFocusedIndex: -1,
-      focused: true
+      listFocusedIndex: -1
     };
   }
   const listHeight = height - headerHeight;
@@ -4730,9 +5141,9 @@ const focusIndex = (state, index) => {
   }
   return {
     ...state,
+    focused: true,
     focusedIndex: index,
-    listFocusedIndex: index,
-    focused: true
+    listFocusedIndex: index
   };
 };
 const first = () => {
@@ -4745,7 +5156,7 @@ const next = (items, index) => {
   return (index + 1) % items.length;
 };
 const previous = (items, index) => {
-  return index === 0 ? items.length - 1 : index - 1;
+  return (index === 0 ? items.length : index) - 1;
 };
 const focusFirst = state => {
   const firstIndex = first();
@@ -4802,8 +5213,8 @@ const focusPrevious = state => {
 const focusPreviousPage = state => {
   const {
     focusedIndex,
-    minLineY,
-    maxLineY
+    maxLineY,
+    minLineY
   } = state;
   if (focusedIndex === 0 || focusedIndex === -1) {
     return state;
@@ -4828,13 +5239,13 @@ const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
 };
 const setDeltaY = (state, value) => {
   object(state);
-  number(value);
+  number$1(value);
   const {
-    itemHeight,
-    finalDeltaY,
     deltaY,
-    height,
+    finalDeltaY,
     headerHeight,
+    height,
+    itemHeight,
     items,
     minimumSliderSize
   } = state;
@@ -4855,19 +5266,19 @@ const setDeltaY = (state, value) => {
   return {
     ...state,
     deltaY: newDeltaY,
-    minLineY,
     maxLineY,
+    minLineY,
     scrollBarY
   };
 };
 const handleScrollBarClick = (state, eventY) => {
   const {
-    y,
     deltaY,
-    headerHeight,
     finalDeltaY,
+    headerHeight,
+    height,
     scrollBarHeight,
-    height
+    y
   } = state;
   const contentHeight = height - headerHeight;
   const relativeY = eventY - y - headerHeight;
@@ -4881,8 +5292,8 @@ const handleScrollBarClick = (state, eventY) => {
     };
   }
   const {
-    percent,
-    handleOffset
+    handleOffset,
+    percent
   } = getNewDeltaPercent(contentHeight, scrollBarHeight, relativeY);
   const newDeltaY = percent * finalDeltaY;
   return {
@@ -4901,12 +5312,12 @@ const getNewPercent = (contentHeight, scrollBarHeight, relativeY) => {
 };
 const handleScrollBarMove = (state, eventY) => {
   const {
-    y,
-    headerHeight,
-    handleOffset,
     finalDeltaY,
+    handleOffset,
+    headerHeight,
     height,
-    scrollBarHeight
+    scrollBarHeight,
+    y
   } = state;
   const relativeY = eventY - y - headerHeight - handleOffset;
   const contentHeight = height - headerHeight;
@@ -4915,8 +5326,8 @@ const handleScrollBarMove = (state, eventY) => {
   return setDeltaY(state, newDeltaY);
 };
 const handleWheel = (state, deltaMode, deltaY) => {
-  number(deltaMode);
-  number(deltaY);
+  number$1(deltaMode);
+  number$1(deltaY);
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
@@ -4977,21 +5388,26 @@ const getRelativeFolderPath = relativePath => {
 
 const selectIndexPreview = async (state, searchResult, index) => {
   const {
-    items,
+    listItems,
     workspacePath
   } = state;
-  const fileIndex = getFileIndex(items, index);
+  const fileIndex = getFileIndex(listItems, index);
   if (fileIndex === -1) {
     throw new Error('Search result is missing file');
   }
   const {
-    lineNumber
+    end,
+    endColumnIndex = end,
+    lineNumber,
+    rowIndex = lineNumber,
+    start,
+    startColumnIndex = start
   } = searchResult;
-  const fileResult = items[fileIndex];
+  const fileResult = listItems[fileIndex];
   const relativePath = getRelativePath(fileResult.text);
   const absolutePath = `${workspacePath}${relativePath}`;
   await openUri(absolutePath, true, {
-    selections: new Uint32Array([lineNumber, 0, lineNumber, 0])
+    selections: new Uint32Array([rowIndex, startColumnIndex, rowIndex, endColumnIndex])
   });
   return {
     ...state,
@@ -5147,6 +5563,10 @@ const restoreState = savedState => {
 };
 
 const loadContent = async (state, savedState) => {
+  const {
+    limitHitWarning,
+    width
+  } = state;
   const {
     excludeValue,
     flags,
@@ -5157,7 +5577,7 @@ const loadContent = async (state, savedState) => {
     threads
   } = restoreState(savedState);
   const usePullBasedSearch = await getUsePullBasedSearch();
-  const warningHeight = await getSearchWarningMessageHeight(state.limitHitWarning, state.width);
+  const warningHeight = await getSearchWarningMessageHeight(limitHitWarning, width);
   const headerHeight = getTopHeight(flags) + warningHeight;
   const update = {
     collapsedPaths: savedCollapsedPaths,
@@ -5531,6 +5951,8 @@ const HandleInputContextMenu = 20;
 const HandleInputSelectionChange = 21;
 const HandleActionClick = 22;
 
+const Focusable = 0;
+
 const getSearchDetailsToggleVirtualDom = () => {
   return [{
     ariaLabel: toggleSearchDetails(),
@@ -5539,7 +5961,7 @@ const getSearchDetailsToggleVirtualDom = () => {
     name: ToggleSearchDetails,
     onClick: HandleButtonClick,
     role: Button$3,
-    tabIndex: 0,
+    tabIndex: Focusable,
     title: toggleSearchDetails(),
     type: Button$2
   }, {
@@ -5607,10 +6029,6 @@ const getInputActionsInclude = flags => {
   };
 };
 
-const getSearchFieldButtonClassName = flag => {
-  return mergeClassNames(SearchFieldButton, flag === CheckBoxEnabled ? SearchFieldButtonChecked : '', flag === ButtonDisabled ? SearchFieldButtonDisabled : '');
-};
-
 // TODO maybe move logic to viewmodel, which returns ariaChecked 1 | 2 | 3
 const getAriaChecked = flag => {
   switch (flag) {
@@ -5623,6 +6041,15 @@ const getAriaChecked = flag => {
   }
 };
 
+const getDisabled = flag => {
+  switch (flag) {
+    case ButtonDisabled:
+      return true;
+    default:
+      return undefined;
+  }
+};
+
 // TODO have have separate renderers for checkbox and button elements
 const getRole = flag => {
   switch (flag) {
@@ -5633,14 +6060,11 @@ const getRole = flag => {
       return undefined;
   }
 };
-const getDisabled = flag => {
-  switch (flag) {
-    case ButtonDisabled:
-      return true;
-    default:
-      return undefined;
-  }
+
+const getSearchFieldButtonClassName = flag => {
+  return mergeClassNames(SearchFieldButton, flag === CheckBoxEnabled ? SearchFieldButtonChecked : '', flag === ButtonDisabled ? SearchFieldButtonDisabled : '');
 };
+
 const getSearchFieldButtonVirtualDom = button => {
   const {
     flag,
@@ -5659,7 +6083,7 @@ const getSearchFieldButtonVirtualDom = button => {
     name,
     onClick: HandleButtonClick,
     role,
-    tabIndex: 0,
+    tabIndex: Focusable,
     title,
     type: Button$2
   }, {
@@ -5687,12 +6111,18 @@ const getOutSideButtonsDom = outsideButtons => {
   };
 };
 
+const getSearchFieldClassName = hasError => {
+  if (hasError) {
+    return mergeClassNames(SearchField, SearchFieldError);
+  }
+  return SearchField;
+};
 const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, hasError = false) => {
   const {
     postNodes,
     preNodes
   } = getOutSideButtonsDom(outsideButtons);
-  const searchFieldClassName = hasError ? mergeClassNames(SearchField, SearchFieldError) : SearchField;
+  const searchFieldClassName = getSearchFieldClassName(hasError);
   const dom = [...preNodes, {
     childCount: 2,
     className: searchFieldClassName,
@@ -5907,7 +6337,7 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarY, scrollBarValue) =>
     type: Div
   }, {
     childCount: 0,
-    className: `${ScrollBarThumb} ScrollBarThumbTop-${roundedScrollBarY}`,
+    className: mergeClassNames(ScrollBarThumb, `ScrollBarThumbTop-${roundedScrollBarY}`),
     height: scrollBarHeight,
     type: Div
   }];
@@ -5994,7 +6424,7 @@ const highlighted = {
 };
 const label1 = {
   childCount: 1,
-  className: mergeClassNames(Label, Grow),
+  className: mergeClassNames(Label$1, Grow),
   type: Div
 };
 const label3 = {
@@ -6078,7 +6508,6 @@ const getSearchResultVirtualDom = rowInfo => {
   const className = `${getSearchResultClassName(focused)} Indent-${indent} IndentRight-${PaddingRight}`;
   const childCount = getChildCount(icon, expanded, badgeText);
   const dom = [{
-    ariaDescription: '',
     ariaExpanded: getAriaExpanded(expanded),
     ariaLabel: title,
     ariaLevel: depth,
@@ -6098,12 +6527,13 @@ const getTreeItemsVirtualDom = (visibleItems, deltaY, itemHeight) => {
   const treeItemsTop = Math.round(-pixelOffset);
   return [{
     childCount: visibleItems.length,
-    className: `${TreeItems$1} TreeItemsTop-${treeItemsTop}`,
+    className: mergeClassNames(TreeItems$1, `TreeItemsTop-${treeItemsTop}`),
     id: TreeItems,
     onBlur: HandleListBlur,
     onClick: HandleClick,
     onContextMenu: HandleListContextMenu,
     onWheel: HandleWheel,
+    role: None$2,
     type: Div
   }, ...visibleItems.flatMap(getSearchResultVirtualDom)];
 };
@@ -6115,7 +6545,7 @@ const getSearchResultsVirtualDom = (visibleItems, focusOutline, scrollbarHeight,
     className: mergeClassNames(Viewlet, List$1, Tree, focusOutline ? FocusOutline : Empty$1),
     onBlur: HandleListBlur,
     role: Tree$1,
-    tabIndex: 0,
+    tabIndex: Focusable,
     type: Div
     // TODO renable this when dom diffing is supported
     // onPointerDown: HandleListPointerDown,
@@ -6123,7 +6553,7 @@ const getSearchResultsVirtualDom = (visibleItems, focusOutline, scrollbarHeight,
   }, ...getTreeItemsVirtualDom(visibleItems, deltaY, itemHeight), ...getScrollBarVirtualDom(scrollbarHeight, scrollBarY, scrollBarValue)];
 };
 
-const className = mergeClassNames(Viewlet, Search$2);
+const className = mergeClassNames(Viewlet, Search$3);
 const getSearchVirtualDom = (visibleItems, flags, message, focusOutline, searchInputErrorMessage, scrollBarHeight, scrollBarY, scrollBarValue, deltaY, itemHeight, matchCount, limitHitWarning, focus = 0, initial = false) => {
   if (initial) {
     return [];
@@ -6499,7 +6929,10 @@ const focusSearchValue = state => {
   return focusElement(state, FocusSearchInput);
 };
 const focusMatchCasePrevious = state => {
-  if (state.flags & ReplaceExpanded) {
+  const {
+    flags
+  } = state;
+  if (flags & ReplaceExpanded) {
     return focusReplaceValue(state);
   }
   return focusSearchValue(state);
@@ -6548,11 +6981,15 @@ const getNewHistory = (history, newValue) => {
   return cutHistory;
 };
 const submit = state => {
-  const newHistory = getNewHistory(state.history, state.value);
+  const {
+    history,
+    value
+  } = state;
+  const newHistory = getNewHistory(history, value);
   return handleUpdate(state, {
     history: newHistory,
     inputSource: User,
-    value: state.value
+    value
   });
 };
 
@@ -6702,7 +7139,7 @@ const commandMap = {
   'TextSearch.renderActions': wrapGetter(renderActions),
   'TextSearch.renderEventListeners': renderEventListeners,
   'TextSearch.renderIncremental': renderIncremental,
-  'TextSearch.replaceAll': wrapCommand(replaceAll),
+  'TextSearch.replaceAll': wrapAsyncCommand(replaceAllWithProgress),
   // TODO needed?
   'TextSearch.replaceAllAndPrompt': replaceAllAndPrompt,
   'TextSearch.replaceAllInFile': wrapCommand(replaceAllInFile),