@lvce-editor/static-server 0.73.2 → 0.73.4

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

@@ -546,7 +546,7 @@ const waitForWebSocketToBeOpen = webSocket => {
     open: Open
   });
 };
-const create$6 = async ({
+const create$f = async ({
   webSocket
 }) => {
   const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
@@ -583,10 +583,31 @@ const wrap = webSocket => {
 };
 const IpcParentWithWebSocket$1 = {
   __proto__: null,
-  create: create$6,
+  create: create$f,
   wrap
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const get$3 = id => {
@@ -788,7 +809,7 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$2 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
     jsonrpc: Two$1,
     id,
@@ -799,9 +820,9 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$2(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$e = (message, result) => {
   return {
     jsonrpc: Two$1,
     id: message.id,
@@ -810,7 +831,7 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$e(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -902,36 +923,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$s = (method, params) => {
+
+const create$d = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+
+const create$c = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -940,15 +942,14 @@ const create$r = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$q = () => {
+const create$b = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$b();
   const {
     promise,
     resolve
@@ -966,7 +967,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$c(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1002,12 +1003,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$d(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -1022,6 +1024,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -1030,6 +1033,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -1039,8 +1043,6 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-/* eslint-disable @typescript-eslint/no-misused-promises */
-
 const createSharedLazyRpc = factory => {
   let rpcPromise;
   const getOrCreate = () => {
@@ -1068,40 +1070,42 @@ const createSharedLazyRpc = factory => {
     }
   };
 };
-const create$i = async ({
+
+const create$a = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$2$1({
+    return create$5({
       commandMap,
       isMessagePortOpen,
       send
     });
   });
 };
-const LazyTransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$i
-};
+
 const Https = 'https:';
 const Ws = 'ws:';
 const Wss = 'wss:';
+
 const getWebSocketProtocol = locationProtocol => {
   return locationProtocol === Https ? Wss : Ws;
 };
+
 const getWebSocketUrl = (type, host, locationProtocol) => {
   const wsProtocol = getWebSocketProtocol(locationProtocol);
   return `${wsProtocol}//${host}/websocket/${type}`;
 };
+
 const getHost = () => {
   return location.host;
 };
 const getProtocol$1 = () => {
   return location.protocol;
 };
-const create$h = async ({
+
+const create$9 = async ({
   commandMap,
   webSocket
 }) => {
@@ -1115,7 +1119,8 @@ const create$h = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const create$g = async ({
+
+const create$8 = async ({
   commandMap,
   type
 }) => {
@@ -1123,28 +1128,26 @@ const create$g = async ({
   const protocol = getProtocol$1();
   const wsUrl = getWebSocketUrl(type, host, protocol);
   const webSocket = new WebSocket(wsUrl);
-  const rpc = await create$h({
+  const rpc = await create$9({
     commandMap,
     webSocket
   });
   return rpc;
 };
-const create$f = async ({
+
+const create$7 = async ({
   commandMap,
   type
 }) => {
   return createSharedLazyRpc(() => {
-    return create$g({
+    return create$8({
       commandMap,
       type
     });
   });
 };
-const LazyWebSocketRpcParent2 = {
-  __proto__: null,
-  create: create$f
-};
-const create$4 = async ({
+
+const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1161,7 +1164,8 @@ const create$4 = async ({
   messagePort.start();
   return rpc;
 };
-const create$2$1 = async ({
+
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1171,17 +1175,14 @@ const create$2$1 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$4({
+  return create$6({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$2$1
-};
-const create$1$1 = async ({
+
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1191,29 +1192,6 @@ const create$1$1 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$1$1
-};
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invocations,
-    invoke,
-    invokeAndTransfer: invoke
-  };
-  return mockRpc;
-};
 
 const Alert = 'alert';
 const Button$3 = 'button';
@@ -1295,6 +1273,7 @@ const Ins = 20;
 const Del = 21;
 const H4 = 24;
 const TextArea = 62;
+const Reference = 100;
 
 const Button$1 = 'event.button';
 const ClientX = 'event.clientX';
@@ -1327,9 +1306,10 @@ const File$1 = 1;
 const Match$1 = 2;
 
 const FocusElementByName = 'Viewlet.focusElementByName';
-const SetDom2 = 'Viewlet.setDom2';
+const SetCss = 'Viewlet.setCss';
 const SetFocusContext = 'Viewlet.setFocusContext';
 const SetValueByName = 'Viewlet.setValueByName';
+const SetPatches = 'Viewlet.setPatches';
 
 const Empty = 0;
 const FocusIgnoreFiles = 1012;
@@ -1348,6 +1328,26 @@ const FocusSearchWholeWord = 34;
 const FocusToggleDetails = 1010;
 const FocusToggleReplace = 1020;
 
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke,
+    invokeAndTransfer: invoke
+  };
+  return mockRpc;
+};
+
 const rpcs = Object.create(null);
 const set$4 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1415,12 +1415,10 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(menuId);
   number(x);
   number(y);
-  // @ts-ignore
   await invoke$1('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
-  // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
 };
 const handleWorkspaceRefresh = async () => {
@@ -1432,6 +1430,9 @@ const sendMessagePortToSearchProcess = async port => {
 const writeClipBoardText = async text => {
   await invoke$1('ClipBoard.writeText', /* text */text);
 };
+const getPreference = async key => {
+  return await invoke$1('Preferences.get', key);
+};
 const openUri$1 = async (uri, focus, options) => {
   await invoke$1('Main.openUri', uri, focus, options);
 };
@@ -1449,42 +1450,68 @@ const create$2 = () => {
   const states = Object.create(null);
   const commandMapRef = {};
   return {
-    get(uid) {
-      return states[uid];
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
     },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
     },
     dispose(uid) {
       delete states[uid];
     },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
     getKeys() {
       return Object.keys(states).map(key => {
         return Number.parseInt(key);
       });
     },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
     },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
-          oldState,
-          newState
+          newState,
+          oldState
         } = states[uid];
         const newerState = await fn(newState, ...args);
         if (oldState === newerState || newState === newerState) {
           return;
         }
-        const latest = states[uid];
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
         states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
+          newState: latestNew,
+          oldState: latestOld.oldState
         };
       };
       return wrapped;
@@ -1497,28 +1524,6 @@ const create$2 = () => {
         return fn(newState, ...args);
       };
       return wrapped;
-    },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        newState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
     }
   };
 };
@@ -1547,6 +1552,7 @@ const NavigateChild = 7;
 const NavigateParent = 8;
 const RemoveChild = 9;
 const NavigateSibling = 10;
+const SetReferenceNodeUid = 11;
 
 const isKey = key => {
   return key !== 'type' && key !== 'childCount';
@@ -1614,6 +1620,16 @@ const compareNodes = (oldNode, newNode) => {
   if (oldNode.type !== newNode.type) {
     return null;
   }
+  // Handle reference nodes - special handling for uid changes
+  if (oldNode.type === Reference) {
+    if (oldNode.uid !== newNode.uid) {
+      patches.push({
+        type: SetReferenceNodeUid,
+        uid: newNode.uid
+      });
+    }
+    return patches;
+  }
   // Handle text nodes
   if (oldNode.type === Text && newNode.type === Text) {
     if (oldNode.text !== newNode.text) {
@@ -2006,6 +2022,9 @@ const hasReplaceExpanded = flags => {
 const hasDetailsExpanded = flags => {
   return (flags & DetailsExpanded) === DetailsExpanded;
 };
+const hasUseIgnoreFiles = flags => {
+  return (flags & UseIgnoreFiles) === UseIgnoreFiles;
+};
 
 const collapseDetails = state => {
   const {
@@ -2047,6 +2066,9 @@ const copyPath$1 = async state => {
   return state;
 };
 
+const defaultExcludes = ['.git', 'node_modules'];
+defaultExcludes.join(',');
+
 const minimumSliderSize = 20;
 
 const {
@@ -2105,11 +2127,12 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, v
     }),
     assetDir,
     collapsedPaths: [],
+    defaultExcludes: defaultExcludes,
     deltaY: 0,
     excludeValue: '',
     fileIconCache: {},
     finalDeltaY: 0,
-    flags: 0,
+    flags: UseIgnoreFiles,
     focus: Empty,
     focused: false,
     focusedIndex: -1,
@@ -2156,6 +2179,8 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, v
     threads: 0,
     useChevrons: true,
     useFileIcons: true,
+    usePullBasedSearch: false,
+    // TODO enable
     viewMode: List,
     workspacePath: workspacePath
   };
@@ -2163,7 +2188,10 @@ const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, v
   return state;
 };
 
-const RenderItems = 1;
+const isEqual$7 = (oldState, newState) => {
+  return oldState.deltaY === newState.deltaY && oldState.finalDeltaY === newState.finalDeltaY && oldState.height === newState.height && oldState.headerHeight === newState.headerHeight && oldState.itemHeight === newState.itemHeight && oldState.items === newState.items;
+};
+
 const RenderFocus = 2;
 const RenderValue = 3;
 const RenderReplaceValue = 4;
@@ -2172,6 +2200,7 @@ const RenderExcludeValue = 6;
 const RenderFocusContext = 7;
 const RenderSelections = 8;
 const RenderIncremental = 9;
+const RenderCss = 10;
 
 const isEqual$6 = (oldState, newState) => {
   return oldState.excludeValue === newState.excludeValue || newState.inputSource === User;
@@ -2190,7 +2219,7 @@ const isEqual$3 = (oldState, newState) => {
 };
 
 const isEqual$2 = (oldState, newState) => {
-  return oldState.collapsedPaths === newState.collapsedPaths && oldState.deltaY === newState.deltaY && oldState.flags === newState.flags && oldState.focus === newState.focus && oldState.icons === newState.icons && oldState.items === newState.items && oldState.listFocused === newState.listFocused && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.loaded === newState.loaded && oldState.maxLineY === newState.maxLineY && oldState.message === newState.message && oldState.minLineY === newState.minLineY && oldState.replacement === newState.replacement && oldState.searchInputErrorMessage === newState.searchInputErrorMessage;
+  return oldState.collapsedPaths === newState.collapsedPaths && oldState.deltaY === newState.deltaY && oldState.flags === newState.flags && oldState.focus === newState.focus && oldState.icons === newState.icons && oldState.items === newState.items && oldState.listFocused === newState.listFocused && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.loaded === newState.loaded && oldState.maxLineY === newState.maxLineY && oldState.message === newState.message && oldState.minLineY === newState.minLineY && oldState.renderFolderPaths === newState.renderFolderPaths && oldState.replacement === newState.replacement && oldState.searchInputErrorMessage === newState.searchInputErrorMessage;
 };
 
 const isEqual$1 = (oldState, newState) => {
@@ -2201,8 +2230,8 @@ const isEqual = (oldState, newState) => {
   return oldState.value === newState.value || newState.inputSource === User;
 };
 
-const modules = [isEqual$2, isEqual$5, isEqual$3, isEqual$6, isEqual$1, isEqual, isEqual$4];
-const numbers = [RenderIncremental, RenderFocus, RenderIncludeValue, RenderExcludeValue, RenderReplaceValue, RenderValue, RenderFocusContext];
+const modules = [isEqual$2, isEqual$5, isEqual$3, isEqual$6, isEqual$1, isEqual, isEqual$4, isEqual$7];
+const numbers = [RenderIncremental, RenderFocus, RenderIncludeValue, RenderExcludeValue, RenderReplaceValue, RenderValue, RenderFocusContext, RenderCss];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -2224,6 +2253,13 @@ const diff2 = uid => {
   return diffResult;
 };
 
+const disableRenderFolderPaths = state => {
+  return {
+    ...state,
+    renderFolderPaths: false
+  };
+};
+
 const getNewMinMax = (newItemsLength, minLineY, maxLineY, deltaY, itemHeight) => {
   if (maxLineY > newItemsLength) {
     const diff = maxLineY - minLineY;
@@ -2628,6 +2664,13 @@ const dismissItem = state => {
   return removeIndex(state, actualIndex);
 };
 
+const enableRenderFolderPaths = state => {
+  return {
+    ...state,
+    renderFolderPaths: true
+  };
+};
+
 const expandDetails = state => {
   const {
     flags
@@ -3083,12 +3126,12 @@ const getTextSearchProvider = scheme => {
   return get(scheme);
 };
 
-const textSearch$6 = async (root, query, options, assetDir, platform) => {
+const textSearch$6 = async (root, query, options, assetDir, platform, searchId, uid) => {
   string(root);
   string(query);
   const scheme = getProtocol(root);
   const provider = getTextSearchProvider(scheme);
-  const results = await provider(scheme, root, query, options, assetDir, platform);
+  const results = await provider(scheme, root, query, options, assetDir, platform, searchId, uid);
   return results;
 };
 
@@ -3110,15 +3153,21 @@ const handleUpdateFull = async (state, update) => {
     minimumSliderSize,
     platform,
     threads,
+    uid,
+    usePullBasedSearch,
     value
   } = partialNewState;
   const root = state.workspacePath;
   const scheme = getProtocol(root);
+  const isFileSearch = scheme === '' || scheme === 'file';
+  const shouldUsePullBasedSearch = Boolean(usePullBasedSearch) && isFileSearch;
+  const searchId = shouldUsePullBasedSearch ? crypto.randomUUID() : '';
   const {
     limitHit,
     results
   } = await textSearch$6(root, value, {
     assetDir,
+    defaultExcludes: hasUseIgnoreFiles(flags) ? partialNewState.defaultExcludes : [],
     exclude: excludeValue,
     flags,
     include: includeValue,
@@ -3129,8 +3178,9 @@ const handleUpdateFull = async (state, update) => {
     root,
     scheme,
     threads,
+    usePullBasedSearch: shouldUsePullBasedSearch,
     useRegularExpression: Boolean(flags & UseRegularExpression$2)
-  }, assetDir, platform);
+  }, assetDir, platform, searchId, uid);
   if (!Array.isArray(results)) {
     throw new TypeError('results must be of type array');
   }
@@ -3170,6 +3220,7 @@ const handleUpdateFull = async (state, update) => {
     message,
     minLineY: 0,
     scrollBarHeight,
+    searchId,
     searchInputErrorMessage: '',
     threads,
     value
@@ -3177,12 +3228,20 @@ const handleUpdateFull = async (state, update) => {
 };
 
 const getRipGrepArgs = ({
+  defaultExcludes,
+  exclude,
   isCaseSensitive,
   searchString,
   threads,
   useRegularExpression
 }) => {
   const ripGrepArgs = ['--hidden', '--no-require-git', '--smart-case', '--stats', '--json', '--threads', `${threads}`];
+  const excludePatternsFromValue = exclude ? exclude.split(',').map(part => part.trim()).filter(Boolean) : [];
+  const excludePatternsFromDefaults = defaultExcludes?.filter(Boolean) || [];
+  const uniqueExcludePatterns = [...new Set([...excludePatternsFromDefaults, ...excludePatternsFromValue])];
+  for (const excludePattern of uniqueExcludePatterns) {
+    ripGrepArgs.push('--glob', `!**/${excludePattern}/**`);
+  }
   if (isCaseSensitive) {
     ripGrepArgs.push('--case-sensitive');
   } else {
@@ -3268,6 +3327,7 @@ const handleUpdateIncremental = async (state, update) => {
     platform,
     threads,
     uid,
+    usePullBasedSearch,
     value
   } = partialNewState;
   const root = state.workspacePath;
@@ -3284,6 +3344,7 @@ const handleUpdateIncremental = async (state, update) => {
   // TODO await promise?
   void textSearchIncremental(root, value, {
     assetDir: assetDir,
+    defaultExcludes: hasUseIgnoreFiles(flags) ? partialNewState.defaultExcludes : [],
     exclude: excludeValue,
     flags,
     include: includeValue,
@@ -3294,11 +3355,76 @@ const handleUpdateIncremental = async (state, update) => {
     root,
     scheme,
     threads,
+    usePullBasedSearch: usePullBasedSearch || false,
     useRegularExpression: Boolean(flags & UseRegularExpression$2)
   }, assetDir, platform, searchId, uid);
   return state;
 };
 
+const handleUpdatePullBased = async (state, update) => {
+  const searchId = crypto.randomUUID();
+  const partialNewState = {
+    ...state,
+    ...update,
+    items: [],
+    listItems: [],
+    message: '',
+    searchId,
+    searchResults: []
+  };
+  set(state.uid, state, partialNewState);
+  const {
+    assetDir,
+    excludeValue,
+    flags,
+    includeValue,
+    limit,
+    platform,
+    threads,
+    uid,
+    usePullBasedSearch,
+    value
+  } = partialNewState;
+  const root = state.workspacePath;
+  const scheme = getProtocol(root);
+  const isFileSearch = scheme === '' || scheme === 'file';
+  const shouldUsePullBasedSearch = Boolean(usePullBasedSearch) && isFileSearch;
+  const {
+    limitHit
+  } = await textSearch$6(root, value, {
+    assetDir,
+    defaultExcludes: hasUseIgnoreFiles(flags) ? partialNewState.defaultExcludes : [],
+    exclude: excludeValue,
+    flags,
+    include: includeValue,
+    isCaseSensitive: Boolean(flags & MatchCase$2),
+    limit,
+    matchWholeWord: Boolean(flags & MatchWholeWord$2),
+    query: value,
+    root,
+    scheme,
+    threads,
+    usePullBasedSearch: shouldUsePullBasedSearch,
+    useRegularExpression: Boolean(flags & UseRegularExpression$2)
+  }, assetDir, platform, searchId, uid);
+  const latest = get$1(uid);
+  if (!latest) {
+    return state;
+  }
+  const limitHitWarning = limitHit ? theResultSetOnlyContainsASubSetOfMatches() : '';
+  const {
+    fileCount,
+    resultCount
+  } = getTextSearchResultCounts(latest.newState.items);
+  const message = getStatusMessage(resultCount, fileCount);
+  return {
+    ...latest.newState,
+    limitHit,
+    limitHitWarning,
+    message
+  };
+};
+
 const handleUpdateValidationError = (state, update, searchInputErrorMessage) => {
   const partialNewState = {
     ...state,
@@ -3338,7 +3464,8 @@ const validateSearchInput = (value, flags) => {
 
 const handleUpdate = async (state, update) => {
   const {
-    incrementalSearch
+    incrementalSearch,
+    usePullBasedSearch
   } = state;
   const partialNewState = {
     ...state,
@@ -3359,6 +3486,9 @@ const handleUpdate = async (state, update) => {
     if (incrementalSearch) {
       return await handleUpdateIncremental(state, update);
     }
+    if (usePullBasedSearch) {
+      return await handleUpdatePullBased(state, update);
+    }
     return await handleUpdateFull(state, update);
   } catch (error) {
     handleError(error);
@@ -3542,6 +3672,7 @@ const toggleUseRegularExpression = state => {
 };
 
 const getClickHandler = name => {
+  // TODO maybe add a click handler to each button instead
   switch (name) {
     case MatchCase:
       return toggleMatchCase;
@@ -3926,17 +4057,134 @@ const handleListFocus = async state => {
   };
 };
 
+const handlePullResultsFound = async (state, resultSearchId) => {
+  const {
+    fileIconCache,
+    headerHeight,
+    height,
+    itemHeight,
+    listItems,
+    minimumSliderSize,
+    platform,
+    searchId,
+    uid
+  } = state;
+  if (searchId !== resultSearchId) {
+    return state;
+  }
+  const result = platform === Remote || platform === Electron ? await invoke('TextSearch.getPullResults', searchId) : await invoke$1('SearchProcess.invoke', 'TextSearch.getPullResults', searchId);
+  const newResults = result;
+  const allResults = [...listItems, ...newResults];
+  const {
+    fileCount,
+    resultCount
+  } = getTextSearchResultCounts(allResults);
+  const message = getStatusMessage(resultCount, fileCount);
+  const total = allResults.length;
+  const contentHeight = total * itemHeight;
+  const listHeight = height - headerHeight;
+  const scrollBarHeight = getScrollBarSize$1(height, contentHeight, minimumSliderSize);
+  const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
+  const maxLineY = Math.min(numberOfVisible, total);
+  const finalDeltaY = Math.max(contentHeight - listHeight, 0);
+  const visible = allResults.slice(0, maxLineY);
+  const {
+    icons,
+    newFileIconCache
+  } = await getFileIcons(visible, fileIconCache);
+  const latest = get$1(uid);
+  const updatedState = {
+    ...latest.newState,
+    fileCount,
+    fileIconCache: newFileIconCache,
+    finalDeltaY,
+    icons,
+    items: allResults,
+    listItems: allResults,
+    loaded: true,
+    matchCount: resultCount,
+    maxLineY,
+    message,
+    minLineY: 0,
+    scrollBarHeight
+  };
+  const oldState = latest ? latest.oldState : state;
+  set(uid, oldState, updatedState);
+  await invoke$1('Search.rerender');
+  return state;
+};
+
+const clamp$1 = (num, min, max) => {
+  return Math.min(Math.max(num, min), max);
+};
+
+const handleResize = async (state, x, y, width, height) => {
+  const {
+    deltaY,
+    fileIconCache,
+    headerHeight,
+    itemHeight,
+    listItems,
+    minimumSliderSize
+  } = state;
+  const total = listItems.length;
+  const contentHeight = total * itemHeight;
+  const listHeight = height - headerHeight;
+  const scrollBarHeight = getScrollBarSize$1(height, contentHeight, minimumSliderSize);
+  const finalDeltaY = Math.max(contentHeight - listHeight, 0);
+  const newDeltaY = clamp$1(deltaY, 0, finalDeltaY);
+  const minLineY = Math.floor(newDeltaY / itemHeight);
+  const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
+  const maxLineY = Math.min(minLineY + numberOfVisible, total);
+  const visibleItems = listItems.slice(minLineY, maxLineY);
+  const {
+    icons,
+    newFileIconCache
+  } = await getFileIcons(visibleItems, fileIconCache);
+  const scrollBarY = finalDeltaY === 0 ? 0 : getScrollBarY$1(newDeltaY, finalDeltaY, listHeight, scrollBarHeight);
+  return {
+    ...state,
+    deltaY: newDeltaY,
+    fileIconCache: newFileIconCache,
+    finalDeltaY,
+    height,
+    icons,
+    maxLineY,
+    minLineY,
+    scrollBarHeight,
+    scrollBarY,
+    width,
+    x,
+    y
+  };
+};
+
 const handleSharedInput = (state, name, value, inputSource = Script) => {
   const fn = getInputHandler(name);
   return fn(state, value, inputSource);
 };
 
+const handleWorkspaceChange = state => {
+  return {
+    ...state,
+    deltaY: 0,
+    items: [],
+    listItems: [],
+    matchCount: 0,
+    maxLineY: 0,
+    message: '',
+    minLineY: 0,
+    replacement: '',
+    value: ''
+  };
+};
+
 const send = async port => {
   await sendMessagePortToIconThemeWorker(port, 0);
 };
 const launchIconThemeWorker = async () => {
   // TODO connect to icon theme worker
-  const rpc = await TransferMessagePortRpcParent.create({
+  const rpc = await create$5({
     commandMap: {},
     send
   });
@@ -3949,7 +4197,7 @@ const initializeIconThemeWorker = async () => {
 };
 
 const launchSearchProcessElectron = async () => {
-  const rpc = await LazyTransferMessagePortRpcParent.create({
+  const rpc = await create$a({
     commandMap: {},
     send: sendMessagePortToSearchProcess
   });
@@ -3957,7 +4205,7 @@ const launchSearchProcessElectron = async () => {
 };
 
 const launchSearchProcessNode = async () => {
-  const rpc = await LazyWebSocketRpcParent2.create({
+  const rpc = await create$7({
     commandMap: {},
     // @ts-ignore
     type: 'search-process'
@@ -4385,6 +4633,14 @@ const getRelativePath = relativePath => {
   }
   return `/${relativePath}`; // TODO support windows paths
 };
+const getRelativeFolderPath = relativePath => {
+  const normalized = relativePath.startsWith('./') ? relativePath.slice(2) : relativePath;
+  const slashIndex = normalized.lastIndexOf('/');
+  if (slashIndex === -1) {
+    return '';
+  }
+  return normalized.slice(0, slashIndex);
+};
 
 const selectIndexPreview = async (state, searchResult, index) => {
   const {
@@ -4471,14 +4727,29 @@ const handleListPointerDown = async (state, button, name) => {
   };
 };
 
+const getUsePullBasedSearch = async () => {
+  try {
+    return Boolean(await getPreference('Search.usePullBasedSearch'));
+  } catch {
+    return false;
+  }
+};
+
+const hasProperty = (object, key) => {
+  if (!object || typeof object !== 'object' || !(key in object)) {
+    return false;
+  }
+  return true;
+};
+
 const getSavedFocus = savedState => {
-  if (savedState && typeof savedState === 'object' && 'focus' in savedState && typeof savedState.focus === 'number') {
+  if (hasProperty(savedState, 'focus') && typeof savedState.focus === 'number') {
     return savedState.focus;
   }
   return 0;
 };
 const getSavedListFocus = savedState => {
-  if (savedState && typeof savedState === 'object' && 'listFocused' in savedState && typeof savedState.listFocused === 'boolean') {
+  if (hasProperty(savedState, 'listFocused') && typeof savedState.listFocused === 'boolean') {
     return savedState.listFocused;
   }
   return false;
@@ -4488,44 +4759,44 @@ const isString = value => {
   return typeof value === 'string';
 };
 const getSavedHistory = savedState => {
-  if (savedState && typeof savedState === 'object' && 'history' in savedState && Array.isArray(savedState.history) && savedState.history.every(isString)) {
+  if (hasProperty(savedState, 'history') && Array.isArray(savedState.history) && savedState.history.every(isString)) {
     return savedState.history;
   }
   return [];
 };
 
 const getSavedValue = savedState => {
-  if (savedState && typeof savedState === 'object' && 'value' in savedState && typeof savedState.value === 'string') {
+  if (hasProperty(savedState, 'value') && typeof savedState.value === 'string') {
     return savedState.value;
   }
   return '';
 };
 const getSavedReplacement = savedState => {
-  if (savedState && typeof savedState === 'object' && 'replacement' in savedState && typeof savedState.replacement === 'string') {
+  if (hasProperty(savedState, 'replacement') && typeof savedState.replacement === 'string') {
     return savedState.replacement;
   }
   return '';
 };
 const getSavedFlags = savedState => {
-  if (savedState && typeof savedState === 'object' && 'flags' in savedState && typeof savedState.flags === 'number') {
+  if (hasProperty(savedState, 'flags') && typeof savedState.flags === 'number') {
     return savedState.flags;
   }
-  return 0;
+  return UseIgnoreFiles;
 };
 const getSavedIncludeValue = savedState => {
-  if (savedState && typeof savedState === 'object' && 'includeValue' in savedState && typeof savedState.includeValue === 'string') {
+  if (hasProperty(savedState, 'includeValue') && typeof savedState.includeValue === 'string') {
     return savedState.includeValue;
   }
   return '';
 };
 const getSavedExcludeValue = savedState => {
-  if (savedState && typeof savedState === 'object' && 'excludeValue' in savedState && typeof savedState.excludeValue === 'string') {
+  if (hasProperty(savedState, 'excludeValue') && typeof savedState.excludeValue === 'string') {
     return savedState.excludeValue;
   }
   return '';
 };
 const getSavedCollapsedPaths = savedState => {
-  if (savedState && typeof savedState === 'object' && 'collapsedPaths' in savedState && Array.isArray(savedState.collapsedPaths) && savedState.collapsedPaths.every(item => typeof item === 'string')) {
+  if (hasProperty(savedState, 'collapsedPaths') && Array.isArray(savedState.collapsedPaths) && savedState.collapsedPaths.every(item => typeof item === 'string')) {
     return savedState.collapsedPaths;
   }
   return [];
@@ -4556,6 +4827,7 @@ const loadContent = async (state, savedState) => {
     savedValue,
     threads
   } = restoreState(savedState);
+  const usePullBasedSearch = await getUsePullBasedSearch();
   const update = {
     collapsedPaths: savedCollapsedPaths,
     excludeValue,
@@ -4566,10 +4838,14 @@ const loadContent = async (state, savedState) => {
     inputSource: Script,
     replacement,
     threads,
+    usePullBasedSearch,
     value: savedValue
   };
   if (savedValue) {
-    const result = await handleUpdate(state, update);
+    const result = await handleUpdate({
+      ...state,
+      usePullBasedSearch
+    }, update);
     return {
       ...result,
       initial: false,
@@ -4582,7 +4858,8 @@ const loadContent = async (state, savedState) => {
     flags,
     initial: false,
     loaded: true,
-    threads
+    threads,
+    usePullBasedSearch
   };
 };
 
@@ -4638,50 +4915,6 @@ const removeCurrent = async state => {
   return removeIndex(state, actualIndex);
 };
 
-const getFocusSelector = focusKey => {
-  switch (focusKey) {
-    case FocusIgnoreFiles:
-      return UseExcludeSettings;
-    case FocusSearchExcludeInput:
-      return FilesToExclude;
-    case FocusSearchIncludeInput:
-      return FilesToInclude;
-    case FocusSearchInput:
-      return SearchValue;
-    case FocusSearchMatchCase:
-      return MatchCase;
-    case FocusSearchOpenEditors:
-      return SearchOnlyOpenEditors;
-    case FocusSearchPreserveCase:
-      return PreserveCase;
-    case FocusSearchRegex:
-      return UseRegularExpression;
-    case FocusSearchReplaceAll:
-      return ReplaceAll;
-    case FocusSearchReplaceInput:
-      return ReplaceValue;
-    case FocusSearchResults:
-      return '.Tree';
-    case FocusSearchWholeWord:
-      return MatchWholeWord;
-    case FocusToggleDetails:
-      return ToggleSearchDetails;
-    case FocusToggleReplace:
-      return ToggleReplace;
-    default:
-      return '';
-  }
-};
-
-const renderFocus = (oldState, newState) => {
-  const selector = getFocusSelector(newState.focus);
-  return [FocusElementByName, newState.uid, selector];
-};
-
-const renderFocusContext = (oldState, newState) => {
-  return [SetFocusContext, newState.uid, FocusSearch, newState.focus];
-};
-
 const None = 0;
 const Collapsed = 1;
 const Expanded = 2;
@@ -4696,37 +4929,51 @@ const getMatchCount = (results, startIndex) => {
   return results.length - startIndex - 1;
 };
 
-const getSearchDisplayResultFile = (results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, originalResults) => {
+const defaultIndent = 12;
+const baseIndent = 16;
+const getTreeItemIndent = depth => {
+  return baseIndent + depth * defaultIndent;
+};
+
+const getSearchDisplayResultFile = (results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, renderFolderPaths, originalResults) => {
   const path = text;
   const absolutePath = getRelativePath(path);
   const baseName = pathBaseName(path);
+  const relativeFolderPath = getRelativeFolderPath(path);
+  const displayText = renderFolderPaths && relativeFolderPath ? `${baseName} — ${relativeFolderPath}` : baseName;
   const index = originalResults.indexOf(results[i]);
   const matchCount = getMatchCount(originalResults, index);
   const expanded = collapsedPaths.includes(path) ? Collapsed : Expanded;
   const badgeText = `${matchCount}`;
+  const depth = 0;
+  const indent = getTreeItemIndent(depth);
   return {
     badgeText,
-    depth: 0,
+    depth,
     expanded,
     focused,
     icon: fileIcons[relativeIndex],
+    indent,
     matchLength: 0,
     matchStart: 0,
     posInSet,
     replacement: '',
     setSize,
-    text: baseName,
+    text: displayText,
     title: absolutePath
   };
 };
 
 const getDisplayResultMatch = (setSize, searchTermLength, replacement, text, posInSet, start, focused) => {
+  const depth = 1;
+  const indent = getTreeItemIndent(depth);
   return {
     badgeText: '',
-    depth: 1,
+    depth,
     expanded: None,
     focused,
     icon: '',
+    indent,
     matchLength: searchTermLength,
     matchStart: start,
     posInSet,
@@ -4737,7 +4984,7 @@ const getDisplayResultMatch = (setSize, searchTermLength, replacement, text, pos
   };
 };
 
-const getDisplayResult = (results, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, minLineY, originalResults) => {
+const getDisplayResult = (results, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, renderFolderPaths, minLineY, originalResults) => {
   const result = results[i];
   const {
     start,
@@ -4749,7 +4996,7 @@ const getDisplayResult = (results, fileIcons, i, setSize, searchTermLength, repl
   const relativeIndex = i - minLineY;
   switch (type) {
     case File:
-      return getSearchDisplayResultFile(results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, originalResults);
+      return getSearchDisplayResultFile(results, fileIcons, i, setSize, collapsedPaths, text, posInSet, relativeIndex, focused, renderFolderPaths, originalResults);
     case Match:
       return getDisplayResultMatch(setSize, searchTermLength, replacement, text, posInSet, start, focused);
     default:
@@ -4757,14 +5004,14 @@ const getDisplayResult = (results, fileIcons, i, setSize, searchTermLength, repl
   }
 };
 
-const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, fileIcons, focusedIndex, collapsedPaths, originalResults) => {
+const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, fileIcons, focusedIndex, collapsedPaths, renderFolderPaths, originalResults) => {
   const filteredResults = getFilteredResults(results, collapsedPaths);
   const displayResults = [];
   const setSize = resultCount;
   const searchTermLength = searchTerm.length;
   const max = Math.min(filteredResults.length, maxLineY);
   for (let i = minLineY; i < max; i++) {
-    const displayResult = getDisplayResult(filteredResults, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, minLineY, originalResults);
+    const displayResult = getDisplayResult(filteredResults, fileIcons, i, setSize, searchTermLength, replacement, focusedIndex, collapsedPaths, renderFolderPaths, minLineY, originalResults);
     displayResults.push(displayResult);
   }
   return displayResults;
@@ -4792,12 +5039,13 @@ const createViewModel = state => {
     maxLineY,
     message,
     minLineY,
+    renderFolderPaths,
     replacement,
     scrollBarHeight,
     searchInputErrorMessage,
     value
   } = state;
-  const displayResults = getDisplayResults(listItems, itemHeight, fileCount, value, minLineY, maxLineY, replacement, icons, listFocusedIndex, collapsedPaths, items);
+  const displayResults = getDisplayResults(listItems, itemHeight, fileCount, value, minLineY, maxLineY, replacement, icons, listFocusedIndex, collapsedPaths, renderFolderPaths || false, items);
   const focusOutline = listFocused && listFocusedIndex === -1;
   const scrollBarValue = deltaY / finalDeltaY * 100;
   const scrollBarY = getScrollBarY$1(deltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
@@ -4817,6 +5065,118 @@ const createViewModel = state => {
   };
 };
 
+const getIndentRule = indent => {
+  return `.Indent-${indent} {
+  padding-left: ${indent}px;
+}`;
+};
+const getIndentRightRule = indentRight => {
+  return `.IndentRight-${indentRight} {
+  padding-right: ${indentRight}px;
+}`;
+};
+const getTreeItemsTopRule = treeItemsTop => {
+  const roundedTreeItemsTop = Math.round(treeItemsTop);
+  return `.TreeItemsTop-${roundedTreeItemsTop} {
+  top: ${roundedTreeItemsTop}px;
+}`;
+};
+const getScrollBarThumbTopRule = scrollBarY => {
+  const roundedScrollBarY = Math.round(scrollBarY);
+  return `.ScrollBarThumbTop-${roundedScrollBarY} {
+  transform: translateY(${roundedScrollBarY}px);
+}`;
+};
+const getCss = (top, uniqueIndents, uniqueIndentRights, scrollBarHeight, scrollBarY, treeItemsTop, headerHeight = 0) => {
+  const rules = [`.Search {
+  --ScrollBarHeight: ${scrollBarHeight}px;
+  --ScrollBarTop: ${scrollBarY}px;
+  --TreeItemsTop: ${top}px;
+}
+
+.SearchHeader {
+  contain: strict;
+  height: ${headerHeight}px;
+}
+  `, ...uniqueIndents.map(getIndentRule), ...uniqueIndentRights.map(getIndentRightRule), getTreeItemsTopRule(treeItemsTop), getScrollBarThumbTopRule(scrollBarY)];
+  return rules.join('\n');
+};
+
+const getUnique = items => {
+  const seens = [];
+  for (const item of items) {
+    if (!seens.includes(item)) {
+      seens.push(item);
+    }
+  }
+  return seens;
+};
+
+const getUniqueIndents = indents => {
+  const uniqueIndents = getUnique(indents);
+  return uniqueIndents;
+};
+
+const PaddingRight = 12;
+
+const renderCss = (oldState, newState) => {
+  const {
+    headerHeight,
+    uid
+  } = newState;
+  const viewModel = createViewModel(newState);
+  const indents = viewModel.displayResults.map(item => item.indent);
+  const uniqueIndents = getUniqueIndents(indents);
+  const uniqueIndentRights = [PaddingRight];
+  const treeItemsTop = viewModel.itemHeight === 0 ? 0 : Math.round(-(viewModel.deltaY % viewModel.itemHeight));
+  const css = getCss(0, uniqueIndents, uniqueIndentRights, viewModel.scrollBarHeight, viewModel.scrollBarY, treeItemsTop, headerHeight);
+  return [SetCss, uid, css];
+};
+
+const getFocusSelector = focusKey => {
+  switch (focusKey) {
+    case FocusIgnoreFiles:
+      return UseExcludeSettings;
+    case FocusSearchExcludeInput:
+      return FilesToExclude;
+    case FocusSearchIncludeInput:
+      return FilesToInclude;
+    case FocusSearchInput:
+      return SearchValue;
+    case FocusSearchMatchCase:
+      return MatchCase;
+    case FocusSearchOpenEditors:
+      return SearchOnlyOpenEditors;
+    case FocusSearchPreserveCase:
+      return PreserveCase;
+    case FocusSearchRegex:
+      return UseRegularExpression;
+    case FocusSearchReplaceAll:
+      return ReplaceAll;
+    case FocusSearchReplaceInput:
+      return ReplaceValue;
+    case FocusSearchResults:
+      return '.Tree';
+    case FocusSearchWholeWord:
+      return MatchWholeWord;
+    case FocusToggleDetails:
+      return ToggleSearchDetails;
+    case FocusToggleReplace:
+      return ToggleReplace;
+    default:
+      return '';
+  }
+};
+
+const renderFocus = (oldState, newState) => {
+  const selector = getFocusSelector(newState.focus);
+  return [FocusElementByName, newState.uid, selector];
+};
+
+const renderFocusContext = (oldState, newState) => {
+  return [SetFocusContext, newState.uid, FocusSearch, newState.focus];
+};
+
 const HandleClick = 1;
 const HandleListContextMenu = 2;
 const HandleHeaderContextMenu = 3;
@@ -4843,7 +5203,7 @@ const getSearchDetailsToggleVirtualDom = () => {
   return [{
     ariaLabel: toggleSearchDetails(),
     childCount: 1,
-    className: ToggleDetails,
+    className: mergeClassNames(ToggleDetails, IconButton),
     name: ToggleSearchDetails,
     onClick: HandleButtonClick,
     role: Button$3,
@@ -5207,6 +5567,7 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarY, scrollBarValue) =>
   if (scrollBarHeight === 0) {
     return [];
   }
+  const roundedScrollBarY = Math.round(scrollBarY);
   return [{
     ariaControls: TreeItems,
     ariaValueNow: scrollBarValue,
@@ -5217,9 +5578,8 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarY, scrollBarValue) =>
     type: Div
   }, {
     childCount: 0,
-    className: ScrollBarThumb,
+    className: `${ScrollBarThumb} ScrollBarThumbTop-${roundedScrollBarY}`,
     height: scrollBarHeight,
-    translate: `0 ${scrollBarY}px`,
     type: Div
   }];
 };
@@ -5322,17 +5682,14 @@ const getLabelVirtualDom = (displayText, matchLength, matchStart, replacement) =
     const highlight = displayText.slice(matchStart, matchStart + matchLength);
     const after = displayText.slice(matchStart + matchLength);
     if (replacement) {
-      return [label4, text(before), deleted, text(highlight), inserted, text(replacement), text(after)];
+      const replacementPreview = replacement.split(/\r\n|\r|\n/, 1)[0];
+      return [label4, text(before), deleted, text(highlight), inserted, text(replacementPreview), text(after)];
     }
     return [label3, text(before), highlighted, text(highlight), text(after)];
   }
   return [label1, text(displayText)];
 };
 
-const getPaddingLeft = depth => {
-  return `${Number(depth) + 1}rem`; // TODO use classname and dynamic css
-};
-
 const getChildCount = (icon, expanded, badgeText) => {
   let childCount = 0;
   if (expanded) {
@@ -5373,8 +5730,6 @@ const getSearchResultClassName = focused => {
   return TreeItem;
 };
 
-const PaddingRight = '12px';
-
 const getSearchResultVirtualDom = rowInfo => {
   const {
     badgeText,
@@ -5382,6 +5737,7 @@ const getSearchResultVirtualDom = rowInfo => {
     expanded,
     focused,
     icon,
+    indent,
     matchLength,
     matchStart,
     posInSet,
@@ -5390,6 +5746,7 @@ const getSearchResultVirtualDom = rowInfo => {
     text: displayText,
     title
   } = rowInfo;
+  const className = `${getSearchResultClassName(focused)} Indent-${indent} IndentRight-${PaddingRight}`;
   const childCount = getChildCount(icon, expanded, badgeText);
   const dom = [{
     ariaDescription: '',
@@ -5399,9 +5756,7 @@ const getSearchResultVirtualDom = rowInfo => {
     ariaPosInSet: posInSet,
     ariaSetSize: setSize,
     childCount,
-    className: getSearchResultClassName(focused),
-    paddingLeft: getPaddingLeft(depth),
-    paddingRight: PaddingRight,
+    className,
     role: TreeItem$1,
     title,
     type: Div
@@ -5410,17 +5765,16 @@ const getSearchResultVirtualDom = rowInfo => {
 };
 
 const getTreeItemsVirtualDom = (visibleItems, deltaY, itemHeight) => {
-  const pixelOffset = deltaY % itemHeight;
+  const pixelOffset = itemHeight === 0 ? 0 : deltaY % itemHeight;
+  const treeItemsTop = Math.round(-pixelOffset);
   return [{
     childCount: visibleItems.length,
-    className: TreeItems$1,
+    className: `${TreeItems$1} TreeItemsTop-${treeItemsTop}`,
     id: TreeItems,
     onBlur: HandleListBlur,
     onClick: HandleClick,
     onContextMenu: HandleListContextMenu,
     onWheel: HandleWheel,
-    top: `${-pixelOffset}px`,
-    // TODO use dynamic css instead
     type: Div
   }, ...visibleItems.flatMap(getSearchResultVirtualDom)];
 };
@@ -5454,18 +5808,18 @@ const getSearchVirtualDom = (visibleItems, flags, message, focusOutline, searchI
   }, ...getSearchHeaderVirtualDom(flags, message, searchInputErrorMessage, matchCount, focus, limitHitWarning), ...errorDom, ...getSearchResultsVirtualDom(visibleItems, focusOutline, scrollBarHeight, scrollBarY, scrollBarValue, deltaY, itemHeight)];
 };
 
-const renderItems = (oldState, newState) => {
+const getDom = newState => {
   const viewModel = createViewModel(newState);
   const dom = getSearchVirtualDom(viewModel.displayResults, viewModel.flags, viewModel.message, viewModel.focusOutline, viewModel.searchInputErrorMessage, viewModel.scrollBarHeight, viewModel.scrollBarY, viewModel.scrollBarValue, viewModel.deltaY, viewModel.itemHeight, viewModel.matchCount, newState.limitHitWarning, viewModel.focus, newState.initial);
-  return [SetDom2, newState.uid, dom];
+  return dom;
 };
 
 // TODO cache rendered dom so that it can be used for dom diffing
 const renderIncremental = (oldState, newState) => {
-  const oldDom = renderItems(oldState, oldState)[2];
-  const newDom = renderItems(newState, newState)[2];
+  const oldDom = getDom(oldState);
+  const newDom = getDom(newState);
   const patches = diffTree(oldDom, newDom);
-  return ['Viewlet.setPatches', newState.uid, patches];
+  return [SetPatches, newState.uid, patches];
 };
 
 const renderSelections = (oldState, newState) => {
@@ -5490,6 +5844,8 @@ const renderExcludeValue = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
+    case RenderCss:
+      return renderCss;
     case RenderExcludeValue:
       return renderExcludeValue;
     case RenderFocus:
@@ -5500,8 +5856,6 @@ const getRenderer = diffType => {
       return renderIncludeValue;
     case RenderIncremental:
       return renderIncremental;
-    case RenderItems:
-      return renderItems;
     case RenderReplaceValue:
       return renderReplacement;
     case RenderSelections:
@@ -5803,8 +6157,11 @@ const focusElement = (state, focusKey) => {
 };
 
 const handleFocusIn = async (state, key) => {
+  const {
+    focus
+  } = state;
   const focusKey = getSearchFocusKey(key);
-  if (state.focus === focusKey) {
+  if (focus === focusKey) {
     return state;
   }
   return {
@@ -5942,7 +6299,9 @@ const commandMap = {
   'TextSearch.copyPath': wrapCommand(copyPath$1),
   'TextSearch.create': create,
   'TextSearch.diff2': diff2,
+  'TextSearch.disableRenderFolderPaths': wrapCommand(disableRenderFolderPaths),
   'TextSearch.dismissItem': wrapCommand(dismissItem),
+  'TextSearch.enableRenderFolderPaths': wrapCommand(enableRenderFolderPaths),
   'TextSearch.expandDetails': wrapCommand(expandDetails),
   'TextSearch.focusFirst': wrapCommand(focusFirst),
   'TextSearch.focusIndex': wrapCommand(focusIndex),
@@ -5994,12 +6353,15 @@ const commandMap = {
   'TextSearch.handleListBlur': wrapCommand(handleListBlur),
   'TextSearch.handleListFocus': wrapCommand(handleListFocus),
   'TextSearch.handleListPointerDown': wrapCommand(handleListPointerDown),
+  'TextSearch.handlePullResultsFound': wrapCommand(handlePullResultsFound),
   'TextSearch.handleReplaceInput': wrapCommand(handleReplaceInput),
+  'TextSearch.handleResize': wrapCommand(handleResize),
   'TextSearch.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
   'TextSearch.handleScrollBarClick': wrapCommand(handleScrollBarClick),
   'TextSearch.handleScrollBarMove': wrapCommand(handleScrollBarMove),
   'TextSearch.handleSharedInput': wrapCommand(handleSharedInput),
   'TextSearch.handleWheel': wrapCommand(handleWheel),
+  'TextSearch.handleWorkspaceChange': wrapCommand(handleWorkspaceChange),
   // not wrapped
   'TextSearch.initialize': initialize,
   'TextSearch.loadContent': wrapCommand(loadContent),
@@ -6079,11 +6441,28 @@ const textSearch$2 = async (scheme, root, query, options, assetDir) => {
   }
 };
 
-const textSearch$1 = async (scheme, root, query, options, assetDir, platform) => {
+const textSearch$1 = async (scheme, root, query, options, assetDir, platform, searchId, uid) => {
   const ripGrepArgs = getRipGrepArgs({
     ...options,
     searchString: query
   });
+  if (options.usePullBasedSearch && searchId && (scheme === '' || scheme === 'file')) {
+    const pullSearchOptions = {
+      ripGrepArgs,
+      searchDir: root,
+      searchId,
+      uid
+    };
+    if (platform === Remote || platform === Electron) {
+      await invoke('TextSearch.searchPull', pullSearchOptions);
+    } else {
+      await invoke$1('SearchProcess.invoke', 'TextSearch.searchPull', pullSearchOptions);
+    }
+    return {
+      limitHit: false,
+      results: []
+    };
+  }
   const actualOptions = {
     ripGrepArgs,
     searchDir: root
@@ -6137,7 +6516,7 @@ const textSearchProviderMap = {
 const listen = async () => {
   registerCommands(commandMap);
   add(textSearchProviderMap);
-  const rpc = await WebWorkerRpcClient.create({
+  const rpc = await create$4({
     commandMap: commandMap
   });
   set$2(rpc);