@lvce-editor/server 0.38.0 → 0.38.1

package/static/{88bf6d7 → f0d21f8}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -1,11 +1,6 @@
 const commands = Object.create(null);
-const registerCommand = (key, fn) => {
-  commands[key] = fn;
-};
 const register = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+  Object.assign(commands, commandMap);
 };
 const getCommand = key => {
   return commands[key];
@@ -30,9 +25,6 @@ const clearSearchResults$1 = state => {
 };
 
 const state$3 = {
-  /**
-   * @type {any}
-   */
   ipc: undefined
 };
 const get$2 = () => {
@@ -86,7 +78,7 @@ const set$1 = (id, fn) => {
 const get$1 = id => {
   return state$1.callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete state$1.callbacks[id];
 };
 const state$2 = {
@@ -119,7 +111,7 @@ const resolve = (id, args) => {
     return;
   }
   fn(args);
-  remove(id);
+  remove$1(id);
 };
 const create$2 = (method, params) => {
   const {
@@ -429,8 +421,11 @@ const states = Object.create(null);
 const get = uid => {
   return states[uid];
 };
-const set = (uid, state) => {
-  states[uid] = state;
+const set = (uid, oldState, newState) => {
+  states[uid] = {
+    oldState,
+    newState
+  };
 };
 
 const create$1 = ({
@@ -465,7 +460,7 @@ const FocusSearchWholeWord = 34;
 const FocusSearchReplaceAll = 35;
 const FocusSearchPreserveCase = 36;
 
-const create = (uid, x, y, width, height, workspacePath) => {
+const create = (uid, x, y, width, height, workspacePath, assetDir) => {
   const state = {
     uid,
     searchResults: [],
@@ -500,138 +495,48 @@ const create = (uid, x, y, width, height, workspacePath) => {
     focus: Empty$1,
     loaded: false,
     message: '',
-    collapsedPaths: []
-  };
-  set(uid, state);
-};
-
-const focusMatchCase$1 = state => {
-  return {
-    ...state,
-    focus: FocusSearchMatchCase
-  };
-};
-
-const focusReplaceValue$1 = state => {
-  return {
-    ...state,
-    focus: FocusSearchReplaceInput
+    collapsedPaths: [],
+    icons: [],
+    assetDir,
+    deltaY: 0,
+    finalDeltaY: 0,
+    focused: false,
+    focusedIndex: -1,
+    handleOffset: 0,
+    focusSource: User
   };
+  set(uid, state, state);
 };
 
-const focusSearchValue$1 = state => {
-  return {
-    ...state,
-    focus: FocusSearchInput
-  };
-};
+// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
 
-const focusSearchValueNext$1 = state => {
-  const {
-    replaceExpanded
-  } = state;
-  if (replaceExpanded) {
-    return focusReplaceValue$1(state);
+const insertInto = (array, start, newItems) => {
+  const originalLength = array.length;
+  const newItemsLength = newItems.length;
+  array.length = originalLength + newItemsLength;
+  // Move the items after the start index, start from the end so that we don't overwrite any value.
+  for (let i = originalLength - 1; i >= start; i--) {
+    array[i + newItemsLength] = array[i];
+  }
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i];
   }
-  return focusMatchCase$1(state);
 };
-
-const CheckBox = 'checkbox';
-const None = 'none';
-const Status = 'status';
-const Tree = 'tree';
-const TreeItem$1 = 'treeitem';
-const ToolBar = 'toolbar';
-
-const Chevron = 'Chevron';
-const CloseMaskIcon = 'MaskIcon MaskIconClose';
-const Empty = '';
-const FileIcon = 'FileIcon';
-const IconButton = 'IconButton';
-const Actions = 'Actions';
-const FocusOutline = 'FocusOutline';
-const Highlight = 'Highlight';
-const HighlightDeleted = 'HighlightDeleted';
-const HighlightInserted = 'HighlightInserted';
-const Label = 'Label';
-const List = 'List';
-const MaskIcon = 'MaskIcon';
-const MaskIconChevronDown = 'MaskIconChevronDown';
-const MaskIconChevronRight = 'MaskIconChevronRight';
-const MultilineInputBox = 'MultilineInputBox';
-const Search$1 = 'Search';
-const SearchField = 'SearchField';
-const SearchFieldButtons = 'SearchFieldButtons';
-const SearchFieldContainer = 'SearchFieldContainer';
-const SearchHeader = 'SearchHeader';
-const SearchHeaderTop = 'SearchHeaderTop';
-const SearchRemove = 'SearchRemove';
-const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
-const SourceControlBadge = 'SourceControlBadge';
-const TreeItem = 'TreeItem';
-const TreeItemActive = 'TreeItemActive';
-const Viewlet = 'Viewlet';
-const ViewletSearchMessage = 'ViewletSearchMessage';
-
-const Button$1 = 1;
-
-const Button = 1;
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-const Ins = 20;
-const Del = 21;
-const TextArea = 62;
-
-const getIconVirtualDom = (icon, type = Div) => {
-  return {
-    type,
-    className: `MaskIcon MaskIcon${icon}`,
-    role: None,
-    childCount: 0
-  };
+const push = (array, newItems) => {
+  insertInto(array, array.length, newItems);
 };
-
-const getActionButtonVirtualDom = action => {
-  const {
-    id,
-    icon,
-    command
-  } = action;
-  return [{
-    type: Button,
-    className: IconButton,
-    title: id,
-    'data-command': command,
-    childCount: 1
-  }, getIconVirtualDom(icon)];
+const isLastIndex = (array, index) => {
+  return index === array.length - 1;
 };
-
-const getActionVirtualDom = action => {
-  switch (action.type) {
-    case Button$1:
-      return getActionButtonVirtualDom(action);
-    default:
-      return [];
-  }
+const lastIndex = array => {
+  return array.length - 1;
 };
-
-const getActionsVirtualDom = actions => {
-  return [{
-    type: Div,
-    className: Actions,
-    role: ToolBar,
-    childCount: actions.length
-  }, ...actions.flatMap(getActionVirtualDom)];
+const toSpliced = (array, index, deleteCount, ...inserted) => {
+  return [...array.slice(0, index), ...inserted, ...array.slice(index + deleteCount)];
+};
+const remove = (array, index, deleteCount) => {
+  return toSpliced(array, index, deleteCount);
 };
-
-const ClearAll = 'ClearAll';
-const CollapseAll = 'CollapseAll';
-const ListFlat = 'ListFlat';
-const NewFile = 'NewFile';
-const Refresh = 'Refresh';
 
 class AssertionError extends Error {
   constructor(message) {
@@ -673,6 +578,12 @@ const number = value => {
     throw new AssertionError('expected value to be of type number');
   }
 };
+const array = value => {
+  const type = getType(value);
+  if (type !== 'array') {
+    throw new AssertionError('expected value to be of type array');
+  }
+};
 const string = value => {
   const type = getType(value);
   if (type !== 'string') {
@@ -738,6 +649,49 @@ const manyResultsInManyFiles = (resultCount, fileResultCount) => {
     PH2: fileResultCount
   });
 };
+const confirmReplaceOneOccurrenceInOneFile = replacement => {
+  return i18nString(UiStrings.ConfirmReplaceOneOccurrenceInOneFile, {
+    PH1: replacement
+  });
+};
+const confirmReplaceOneOccurrenceInOneFileNoValue = () => {
+  return i18nString(UiStrings.ConfirmReplaceOneOccurrenceInOneFileNoValue);
+};
+const confirmReplaceManyOccurrencesInOneFile = (matchCount, replacement) => {
+  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInOneFile, {
+    PH1: matchCount,
+    PH2: replacement
+  });
+};
+const confirmReplaceManyOccurrencesInOneFileNoValue = matchCount => {
+  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInOneFileNoValue, {
+    PH1: matchCount
+  });
+};
+const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replacement) => {
+  number(matchCount);
+  number(fileCount);
+  string(replacement);
+  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFiles, {
+    PH1: matchCount,
+    PH2: fileCount,
+    PH3: replacement
+  });
+};
+const confirmReplaceManyOccurrencesInManyFilesNoValue = (matchCount, fileCount) => {
+  number(matchCount);
+  number(fileCount);
+  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFilesNoValue, {
+    PH1: matchCount,
+    PH2: fileCount
+  });
+};
+const replaceAll$1 = () => {
+  return i18nString(UiStrings.ReplaceAll);
+};
+const replace = () => {
+  return i18nString(UiStrings.Replace);
+};
 const refresh$1 = () => {
   return i18nString(UiStrings.Refresh);
 };
@@ -754,93 +708,370 @@ const collapseAll = () => {
   return i18nString(UiStrings.CollapseAll);
 };
 
-const getActions = () => {
-  return [{
-    type: Button$1,
-    id: refresh$1(),
-    icon: Refresh,
-    command: 'refresh'
-  }, {
-    type: Button$1,
-    id: clearSearchResults(),
-    icon: ClearAll,
-    command: 'clearSearchResults'
-  }, {
-    type: Button$1,
-    id: openNewSearchEditor(),
-    icon: NewFile,
-    command: ''
-  }, {
-    type: Button$1,
-    id: viewAsTree(),
-    icon: ListFlat,
-    command: ''
-  }, {
-    type: Button$1,
-    id: collapseAll(),
-    icon: CollapseAll,
-    command: ''
-  }];
-};
-
-const getFileIcon = () => {
-  return '';
+const getStatusMessage = (resultCount, fileResultCount) => {
+  number(resultCount);
+  number(fileResultCount);
+  if (resultCount === 0) {
+    return noResults();
+  }
+  if (resultCount === 1) {
+    return oneResult();
+  }
+  if (fileResultCount === 1) {
+    return manyResultsInOneFile(resultCount);
+  }
+  return manyResultsInManyFiles(resultCount, fileResultCount);
 };
 
 const File$1 = 1;
 const Match = 2;
 
-// TODO this should be in FileSystem module
-const pathBaseName = path => {
-  return path.slice(path.lastIndexOf('/') + 1);
-};
-const getAbsolutePath = relativePath => {
-  if (relativePath.startsWith('./')) {
-    return `/${relativePath.slice(2)}`; // TODO support windows paths
+const getSetSize = (items, index) => {
+  let setSize = 0;
+  for (let i = index + 1; i < items.length; i++) {
+    if (items[i].type === File$1) {
+      break;
+    }
+    setSize++;
   }
-  return `/${relativePath}`; // TODO support windows paths
+  return setSize;
 };
-
-const getDisplayResult = (result, itemHeight, i, setSize, searchTermLength, replacement, focusedIndex) => {
-  const {
-    type,
-    text,
-    lineNumber,
-    start
-  } = result;
-  const posInSet = i + 1;
-  const top = i * itemHeight;
-  const focused = i === focusedIndex;
-  switch (type) {
-    case File$1:
-      const path = text;
-      const absolutePath = getAbsolutePath(path);
-      const baseName = pathBaseName(path);
+const getRemoveIndicesFile = (items, item, index, matchCount, fileCount) => {
+  const setSize = getSetSize(items, index);
+  return {
+    startIndex: index,
+    removeCount: setSize + 1,
+    newFocusedIndex: index + setSize + 1 < items.length ? index : index - 1,
+    newFileCount: fileCount - 1,
+    newMatchCount: matchCount - setSize
+  };
+};
+const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
+  for (let i = index; i >= 0; i--) {
+    if (items[i].type === File$1) {
+      const setSize = getSetSize(items, i);
+      if (setSize === 1) {
+        return {
+          startIndex: i,
+          removeCount: 2,
+          newFocusedIndex: i - 1,
+          newFileCount: fileCount - 1,
+          newMatchCount: matchCount - 1
+        };
+      }
       return {
-        title: absolutePath,
-        type: File$1,
-        text: baseName,
-        icon: getFileIcon(),
-        posInSet,
-        setSize,
-        top,
-        lineNumber,
-        matchStart: 0,
-        matchLength: 0,
-        replacement: '',
-        depth: 0,
-        matchCount: 0,
-        focused
+        startIndex: index,
+        removeCount: 1,
+        newFocusedIndex: index,
+        newFileCount: fileCount,
+        newMatchCount: matchCount - 1
       };
+    }
+  }
+  throw new Error('could not compute indices to remove');
+};
+const getRemoveIndices = (items, index, matchCount, fileCount) => {
+  const item = items[index];
+  switch (item.type) {
+    case File$1:
+      return getRemoveIndicesFile(items, item, index, matchCount, fileCount);
     case Match:
-      return {
-        title: text,
-        type: Match,
-        text: text,
-        icon: '',
-        posInSet,
-        setSize,
-        top,
+      return getRemoveIndicesMatch(items, index, matchCount, fileCount);
+    default:
+      throw new Error('unknown search result type');
+  }
+};
+const removeItemFromItems = (items, index, matchCount, fileCount) => {
+  const {
+    startIndex,
+    removeCount,
+    newFocusedIndex,
+    newFileCount,
+    newMatchCount
+  } = getRemoveIndices(items, index, matchCount, fileCount);
+  const newItems = remove(items, startIndex, removeCount);
+  return {
+    newItems,
+    newFocusedIndex,
+    newFileCount,
+    newMatchCount
+  };
+};
+const getNewMinMax = (newItemsLength, minLineY, maxLineY, deltaY, itemHeight) => {
+  if (maxLineY > newItemsLength) {
+    const diff = maxLineY - minLineY;
+    const newMinLineY = Math.max(newItemsLength - diff, 0);
+    const newDeltaY = newMinLineY * itemHeight;
+    return {
+      newDeltaY,
+      newMinLineY,
+      newMaxLineY: newItemsLength
+    };
+  }
+  return {
+    newDeltaY: deltaY,
+    newMinLineY: minLineY,
+    newMaxLineY: maxLineY
+  };
+};
+const dismissItem = state => {
+  const {
+    items,
+    listFocusedIndex,
+    fileCount,
+    matchCount,
+    minLineY,
+    maxLineY,
+    deltaY,
+    itemHeight
+  } = state;
+  if (listFocusedIndex === -1) {
+    return state;
+  }
+  const {
+    newItems,
+    newFocusedIndex,
+    newMatchCount,
+    newFileCount
+  } = removeItemFromItems(items, listFocusedIndex, matchCount, fileCount);
+  const message = getStatusMessage(newMatchCount, newFileCount);
+  const {
+    newMinLineY,
+    newMaxLineY,
+    newDeltaY
+  } = getNewMinMax(newItems.length, minLineY, maxLineY, deltaY, itemHeight);
+  return {
+    ...state,
+    items: newItems,
+    listFocusedIndex: newFocusedIndex,
+    message,
+    matchCount: newMatchCount,
+    fileCount: newFileCount,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    deltaY: newDeltaY
+  };
+};
+
+const focusMatchCase$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchMatchCase
+  };
+};
+
+const focusReplaceValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchReplaceInput
+  };
+};
+
+const focusSearchValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchInput
+  };
+};
+
+const focusSearchValueNext = state => {
+  const {
+    replaceExpanded
+  } = state;
+  if (replaceExpanded) {
+    return focusReplaceValue$1(state);
+  }
+  return focusMatchCase$1(state);
+};
+
+const CheckBox = 'checkbox';
+const None = 'none';
+const Status = 'status';
+const Tree = 'tree';
+const TreeItem$1 = 'treeitem';
+const ToolBar = 'toolbar';
+
+const Actions = 'Actions';
+const Badge = 'Badge';
+const Chevron = 'Chevron';
+const CloseMaskIcon = 'MaskIcon MaskIconClose';
+const Empty = '';
+const FileIcon = 'FileIcon';
+const FocusOutline = 'FocusOutline';
+const Grow = 'Grow';
+const Highlight = 'Highlight';
+const HighlightDeleted = 'HighlightDeleted';
+const HighlightInserted = 'HighlightInserted';
+const IconButton = 'IconButton';
+const Label = 'Label';
+const List = 'List';
+const MaskIcon = 'MaskIcon';
+const MaskIconChevronDown = 'MaskIconChevronDown';
+const MaskIconChevronRight = 'MaskIconChevronRight';
+const MultilineInputBox = 'MultilineInputBox';
+const Search$1 = 'Search';
+const SearchField = 'SearchField';
+const SearchFieldButton = 'SearchFieldButton';
+const SearchFieldButtonChecked = 'SearchFieldButtonChecked';
+const SearchFieldButtons = 'SearchFieldButtons';
+const SearchFieldContainer = 'SearchFieldContainer';
+const SearchHeader = 'SearchHeader';
+const SearchHeaderDetails = 'SearchHeaderDetails';
+const SearchHeaderTop = 'SearchHeaderTop';
+const SearchHeaderTopRight = 'SearchHeaderTopRight';
+const SearchRemove = 'SearchRemove';
+const SearchToggleButton = 'SearchToggleButton';
+const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
+const SourceControlBadge = 'SourceControlBadge';
+const TreeItem = 'TreeItem';
+const TreeItemActive = 'TreeItemActive';
+const Viewlet = 'Viewlet';
+const ViewletSearchMessage = 'ViewletSearchMessage';
+
+const Button$1 = 1;
+
+const Button = 1;
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+const Ins = 20;
+const Del = 21;
+const TextArea = 62;
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
+const getIconVirtualDom = (icon, type = Div) => {
+  return {
+    type,
+    className: mergeClassNames(MaskIcon, `MaskIcon${icon}`),
+    role: None,
+    childCount: 0
+  };
+};
+
+const getActionButtonVirtualDom = action => {
+  const {
+    id,
+    icon,
+    command
+  } = action;
+  return [{
+    type: Button,
+    className: IconButton,
+    title: id,
+    'data-command': command,
+    childCount: 1
+  }, getIconVirtualDom(icon)];
+};
+
+const getActionVirtualDom = action => {
+  switch (action.type) {
+    case Button$1:
+      return getActionButtonVirtualDom(action);
+    default:
+      return [];
+  }
+};
+
+const getActionsVirtualDom = actions => {
+  return [{
+    type: Div,
+    className: Actions,
+    role: ToolBar,
+    childCount: actions.length
+  }, ...actions.flatMap(getActionVirtualDom)];
+};
+
+const ClearAll = 'ClearAll';
+const CollapseAll = 'CollapseAll';
+const ListFlat = 'ListFlat';
+const NewFile = 'NewFile';
+const Refresh = 'Refresh';
+
+const getActions = () => {
+  return [{
+    type: Button$1,
+    id: refresh$1(),
+    icon: Refresh,
+    command: 'refresh'
+  }, {
+    type: Button$1,
+    id: clearSearchResults(),
+    icon: ClearAll,
+    command: 'clearSearchResults'
+  }, {
+    type: Button$1,
+    id: openNewSearchEditor(),
+    icon: NewFile,
+    command: ''
+  }, {
+    type: Button$1,
+    id: viewAsTree(),
+    icon: ListFlat,
+    command: ''
+  }, {
+    type: Button$1,
+    id: collapseAll(),
+    icon: CollapseAll,
+    command: ''
+  }];
+};
+
+// TODO this should be in FileSystem module
+const pathBaseName = path => {
+  return path.slice(path.lastIndexOf('/') + 1);
+};
+const getAbsolutePath = relativePath => {
+  if (relativePath.startsWith('./')) {
+    return `/${relativePath.slice(2)}`; // TODO support windows paths
+  }
+  return `/${relativePath}`; // TODO support windows paths
+};
+
+const getDisplayResult = (result, fileIcons, fileIconIndex, itemHeight, i, setSize, searchTermLength, replacement, focusedIndex) => {
+  const {
+    type,
+    text,
+    lineNumber,
+    start
+  } = result;
+  const posInSet = i + 1;
+  const top = i * itemHeight;
+  const focused = i === focusedIndex;
+  switch (type) {
+    case File$1:
+      const path = text;
+      const absolutePath = getAbsolutePath(path);
+      const baseName = pathBaseName(path);
+      return {
+        title: absolutePath,
+        type: File$1,
+        text: baseName,
+        icon: fileIcons[fileIconIndex],
+        posInSet,
+        setSize,
+        top,
+        lineNumber,
+        matchStart: 0,
+        matchLength: 0,
+        replacement: '',
+        depth: 0,
+        matchCount: 0,
+        focused
+      };
+    case Match:
+      return {
+        title: text,
+        type: Match,
+        text: text,
+        icon: '',
+        posInSet,
+        setSize,
+        top,
         lineNumber,
         matchStart: start,
         matchLength: searchTermLength,
@@ -871,7 +1102,7 @@ const getFilteredResults = (results, collapsedPaths) => {
   }
   return filteredResults;
 };
-const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, collapsedPaths, focusedIndex) => {
+const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, collapsedPaths, fileIcons, focusedIndex) => {
   const displayResults = [];
   const filteredResults = getFilteredResults(results, collapsedPaths);
   const setSize = resultCount;
@@ -879,12 +1110,14 @@ const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLine
   let fileResult = {
     matchCount: 0
   };
+  let fileIconIndex = 0;
   for (let i = minLineY; i < maxLineY; i++) {
     const result = filteredResults[i];
-    const displayResult = getDisplayResult(result, itemHeight, i, setSize, searchTermLength, replacement, focusedIndex);
+    const displayResult = getDisplayResult(result, fileIcons, fileIconIndex, itemHeight, i, setSize, searchTermLength, replacement, focusedIndex);
     displayResults.push(displayResult);
     if (result.type === File$1) {
       fileResult = displayResult;
+      fileIconIndex++;
     } else {
       fileResult.matchCount++;
     }
@@ -905,7 +1138,7 @@ const getSearchFieldButtonVirtualDom = button => {
   } = button;
   return [{
     type: Div,
-    className: `SearchFieldButton ${checked ? 'SearchFieldButtonChecked' : ''}`,
+    className: mergeClassNames(SearchFieldButton, checked ? SearchFieldButtonChecked : ''),
     title,
     role: CheckBox,
     ariaChecked: checked,
@@ -913,7 +1146,7 @@ const getSearchFieldButtonVirtualDom = button => {
     childCount: 1
   }, {
     type: Div,
-    className: `MaskIcon ${icon}`,
+    className: mergeClassNames(MaskIcon, icon),
     childCount: 0
   }];
 };
@@ -975,7 +1208,7 @@ const getSearchHeaderVirtualDom = (replaceExpanded, matchCase, matchWholeWord, u
     childCount: 2
   }, {
     type: Button,
-    className: `IconButton SearchToggleButton ${replaceExpanded ? SearchToggleButtonExpanded : ''}`,
+    className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
     title: 'Toggle Replace',
     ariaLabel: 'Toggle Replace',
     ariaExpanded: replaceExpanded,
@@ -983,11 +1216,11 @@ const getSearchHeaderVirtualDom = (replaceExpanded, matchCase, matchWholeWord, u
     'data-command': 'toggleReplace'
   }, {
     type: Div,
-    className: `${MaskIcon} ${replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight}`,
+    className: mergeClassNames(MaskIcon, replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight),
     childCount: 0
   }, {
     type: Div,
-    className: 'SearchHeaderTopRight',
+    className: SearchHeaderTopRight,
     role: None,
     childCount: replaceExpanded ? 2 : 1
   }, ...getSearchFieldVirtualDom('search-value', 'Search', 'handleInput', [{
@@ -1018,10 +1251,11 @@ const getSearchHeaderVirtualDom = (replaceExpanded, matchCase, matchWholeWord, u
     console.log({
       detailsExpanded
     });
+    // @ts-ignore
     dom[0].childCount++;
     dom.push({
       type: Div,
-      className: 'SearchHeaderDetails',
+      className: SearchHeaderDetails,
       childCount: 4
     }, text('files to include'), {
       type: Input,
@@ -1037,7 +1271,7 @@ const getSearchHeaderVirtualDom = (replaceExpanded, matchCase, matchWholeWord, u
 const getBadgeVirtualDom = (className, count) => {
   return [{
     type: Div,
-    className: `Badge ${className}`,
+    className: mergeClassNames(Badge, className),
     childCount: 1
   }, text(`${count}`)];
 };
@@ -1045,7 +1279,7 @@ const getBadgeVirtualDom = (className, count) => {
 const getChevronDownVirtualDom = (extraClassName = '') => {
   return {
     type: Div,
-    className: `${Chevron} MaskIconChevronDown ${extraClassName}`,
+    className: mergeClassNames(Chevron, MaskIconChevronDown, extraClassName),
     childCount: 0
   };
 };
@@ -1075,29 +1309,30 @@ const highlighted = {
   className: Highlight,
   childCount: 1
 };
+const label1 = {
+  type: Div,
+  className: mergeClassNames(Label, Grow),
+  childCount: 1
+};
+const label3 = {
+  ...label1,
+  childCount: 3
+};
+const label4 = {
+  ...label1,
+  childCount: 4
+};
 const getLabelVirtualDom = (displayText, matchLength, matchStart, replacement) => {
-  const dom = [];
-  const label = {
-    type: Div,
-    className: Label + ' Grow',
-    childCount: 1
-  };
-  dom.push(label);
   if (matchLength) {
     const before = displayText.slice(0, matchStart);
     const highlight = displayText.slice(matchStart, matchStart + matchLength);
     const after = displayText.slice(matchStart + matchLength);
     if (replacement) {
-      dom.push(text(before), deleted, text(highlight), inserted, text(replacement), text(after));
-      label.childCount = 4;
-    } else {
-      label.childCount = 3;
-      dom.push(text(before), highlighted, text(highlight), text(after));
+      return [label4, text(before), deleted, text(highlight), inserted, text(replacement), text(after)];
     }
-  } else {
-    dom.push(text(displayText));
+    return [label3, text(before), highlighted, text(highlight), text(after)];
   }
-  return dom;
+  return [label1, text(displayText)];
 };
 
 const PaddingRight = '12px';
@@ -1168,14 +1403,7 @@ const getSearchResultsVirtualDom = visibleItems => {
   return visibleItems.flatMap(getSearchResultVirtualDom);
 };
 
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-
 const getSearchVirtualDom = (visibleItems, replaceExpanded, matchCase, matchWholeWord, useRegularExpression, message, detailsExpanded, focusOutline) => {
-  /**
-   * @type {any[]}
-   */
   const dom = [];
   dom.push({
     type: Div,
@@ -1214,17 +1442,23 @@ const handleIconThemeChange = state => {
   };
 };
 
-const first = () => {
-  return 0;
-};
-const last = items => {
-  return items.length - 1;
-};
-const next = (items, index) => {
-  return (index + 1) % items.length;
+const handleError = error => {
+  console.error(`[text-search-worker] ${error}`);
 };
-const previous = (items, index) => {
-  return index === 0 ? items.length - 1 : index - 1;
+
+const getFileIcons = async files => {
+  // TODO cache file icons
+  const promises = [];
+  for (const file of files) {
+    if (file.type === Match) {
+      continue;
+    }
+    promises.push(invoke$1('IconTheme.getFileIcon', {
+      name: file.text
+    }));
+  }
+  const icons = await Promise.all(promises);
+  return icons;
 };
 
 // TODO optimize this function to return the minimum number
@@ -1234,655 +1468,305 @@ const getNumberOfVisibleItems = (listHeight, itemHeight) => {
   return Math.ceil(listHeight / itemHeight) + 1;
 };
 
-const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) => {
-  const newMinLineY = index;
-  const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
-  const newMaxLineY = Math.min(newMinLineY + fittingItems, itemsLength);
-  const newDeltaY = newMinLineY * itemHeight;
+const getTextSearchResultCounts = results => {
+  let resultCount = 0;
+  let fileCount = 0;
+  for (const result of results) {
+    switch (result.type) {
+      case File$1:
+        fileCount++;
+        break;
+      case Match:
+        resultCount++;
+        break;
+    }
+  }
   return {
-    ...state,
-    focusedIndex: index,
-    minLineY: newMinLineY,
-    maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY
+    fileCount,
+    resultCount
   };
 };
-const focusIndexScrollDown = (state, index, listHeight, itemHeight, itemsLength) => {
-  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;
-  return {
-    ...state,
-    focusedIndex: index,
-    minLineY: newMinLineY,
-    maxLineY: newMaxLineY,
-    focused: true,
-    deltaY: newDeltaY
-  };
+
+const EmptyString = '';
+
+const isEmptyString = string => {
+  return string === EmptyString;
 };
-const focusIndex = (state, index) => {
-  const {
-    itemHeight,
-    minLineY,
-    maxLineY,
-    headerHeight,
-    height,
-    items
-  } = state;
-  const itemsLength = items.length;
-  if (itemsLength === 0) {
-    return state;
+
+const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
+  if (size >= contentSize) {
+    return 0;
   }
-  number(itemHeight);
-  if (index === -1) {
+  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
+};
+const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
+  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
+  return scrollBarOffset;
+};
+const getScrollBarY = getScrollBarOffset;
+const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
+  const halfScrollBarHeight = scrollBarHeight / 2;
+  if (relativeY <= halfScrollBarHeight) {
+    // clicked at top
     return {
-      ...state,
-      focusedIndex: -1,
-      focused: true
+      percent: 0,
+      handleOffset: relativeY
     };
   }
-  const listHeight = height - headerHeight;
-  if (index < minLineY + 1) {
-    return focusIndexScrollUp(state, index, listHeight, itemHeight, itemsLength);
-  }
-  if (index >= maxLineY - 1) {
-    return focusIndexScrollDown(state, index, listHeight, itemHeight, itemsLength);
+  if (relativeY <= height - halfScrollBarHeight) {
+    // clicked in middle
+    return {
+      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
+      handleOffset: halfScrollBarHeight
+    };
   }
+  // clicked at bottom
   return {
-    ...state,
-    focusedIndex: index,
-    focused: true
+    percent: 1,
+    handleOffset: scrollBarHeight - height + relativeY
   };
 };
 
-const focusFirst = state => {
-  const firstIndex = first();
-  return focusIndex(state, firstIndex);
-};
-
-const focusLast = state => {
-  const {
-    items
-  } = state;
-  const lastIndex = last(items);
-  return focusIndex(state, lastIndex);
+const RE_PROTOCOL = /^([a-z-]+):\/\//;
+const getProtocol = uri => {
+  const protocolMatch = uri.match(RE_PROTOCOL);
+  if (protocolMatch) {
+    return protocolMatch[1];
+  }
+  return '';
 };
 
-const focusNext = state => {
-  const {
-    focusedIndex,
-    items
-  } = state;
-  const nextIndex = next(items, focusedIndex);
-  return focusIndex(state, nextIndex);
+const textSearch$5 = async (scheme, root, query) => {
+  string(scheme);
+  string(query);
+  const result = await invoke$1('ExtensionHostTextSearch.executeTextSearchProvider', scheme, query);
+  return result;
 };
 
-// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
-
-const insertInto = (array, start, newItems) => {
-  const originalLength = array.length;
-  const newItemsLength = newItems.length;
-  array.length = originalLength + newItemsLength;
-  // Move the items after the start index, start from the end so that we don't overwrite any value.
-  for (let i = originalLength - 1; i >= start; i--) {
-    array[i + newItemsLength] = array[i];
+const normalizeLine$1 = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice(`Error: `.length);
   }
-  for (let i = 0; i < newItemsLength; i++) {
-    array[i + start] = newItems[i];
+  if (line.startsWith('VError: ')) {
+    return line.slice(`VError: `.length);
   }
+  return line;
 };
-const push = (array, newItems) => {
-  insertInto(array, array.length, newItems);
-};
-const isLastIndex = (array, index) => {
-  return index === array.length - 1;
+const getCombinedMessage$1 = (error, message) => {
+  const stringifiedError = normalizeLine$1(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
 };
-const lastIndex = array => {
-  return array.length - 1;
+const NewLine$2 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
 };
-
-const focusNextPage = state => {
-  const {
-    focusedIndex,
-    items,
-    maxLineY,
-    minLineY
-  } = state;
-  if (isLastIndex(items, focusedIndex)) {
-    return state;
+const mergeStacks$1 = (parent, child) => {
+  if (!child) {
+    return parent;
   }
-  const indexNextPage = Math.min(maxLineY + (maxLineY - minLineY) - 2, lastIndex(items));
-  return focusIndex(state, indexNextPage);
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
 };
-
-const focusPreviousPage = state => {
-  const {
-    focusedIndex,
-    minLineY,
-    maxLineY
-  } = state;
-  if (focusedIndex === 0 || focusedIndex === -1) {
-    return state;
+let VError$1 = class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage$1(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks$1(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
   }
-  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
-  return focusIndex(state, indexPreviousPage);
 };
 
-const focusPrevious = state => {
-  const {
-    focusedIndex,
-    items
-  } = state;
-  if (focusedIndex === 0 || focusedIndex === -1) {
-    return state;
+const getJson = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const json = await response.json();
+    return json;
+  } catch (error) {
+    throw new VError$1(error, `Failed to get json`);
   }
-  const previousIndex = previous(items, focusedIndex);
-  return focusIndex(state, previousIndex);
 };
 
-const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
-  const relativeY = eventY - y + deltaY;
-  const index = Math.floor(relativeY / itemHeight);
-  return index;
-};
+const getText = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const text = await response.text();
+    return text;
+  } catch (error) {
+    throw new VError$1(error, `Failed to get text`);
+  }
+};
 
-const openUri = async (path, focus = true, props = {}) => {
-  await invoke$1(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
+const splitLines$1 = lines => {
+  return lines.split('\n');
 };
 
-const getFileIndex = (items, index) => {
-  for (let i = index; i >= 0; i--) {
-    const item = items[i];
-    if (item.type === File$1) {
-      return i;
+const textSearchInFile$1 = (file, content, query) => {
+  const results = [];
+  const lines = splitLines$1(content);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const index = line.indexOf(query);
+    if (index !== -1) {
+      results.push({
+        type: Match,
+        text: line,
+        start: index,
+        end: index + query.length,
+        lineNumber: i
+      });
     }
   }
-  return -1;
-};
-const selectIndexFile = async (state, searchResult, index) => {
-  const {
-    collapsedPaths
-  } = state;
-  const path = getAbsolutePath(searchResult.text);
-  string(path);
-  return {
-    ...state,
-    collapsedPaths: [...collapsedPaths, path],
-    listFocusedIndex: index,
-    listFocused: true
-  };
-};
-const selectIndexPreview = async (state, searchResult, index) => {
-  const {
-    items
-  } = state;
-  const fileIndex = getFileIndex(items, index);
-  if (fileIndex === -1) {
-    throw new Error('Search result is missing file');
+  if (results.length > 0) {
+    results.unshift({
+      type: File$1,
+      text: file,
+      start: 0,
+      end: 0,
+      lineNumber: 0
+    });
   }
-  const {
-    lineNumber
-  } = searchResult;
-  // console.log({ searchResult })
-  const fileResult = items[fileIndex];
-  const path = getAbsolutePath(fileResult.text);
-  string(path);
-  await openUri(path, true, {
-    selections: new Uint32Array([lineNumber, 0, lineNumber, 0])
-  });
-  return {
-    ...state,
-    listFocusedIndex: index,
-    listFocused: false
-  };
+  return results;
 };
-const selectIndex = async (state, index, isClose) => {
-  if (index === -1) {
-    return {
-      ...state,
-      listFocused: true,
-      listFocusedIndex: -1
-    };
-  }
-  const {
-    items
-  } = state;
-  const searchResult = items[index];
-  switch (searchResult.type) {
-    case File$1:
-      return selectIndexFile(state, searchResult, index);
-    case Match:
-      return selectIndexPreview(state, searchResult, index);
-    default:
-      throw new Error(`unexpected search result type ${searchResult.type}`);
+const textSearch$4 = async (scheme, root, query, options, assetDir) => {
+  string(scheme);
+  string(root);
+  string(query);
+  const fetchUri = `${assetDir}/config/fileMap.json`;
+  const fileList = await getJson(fetchUri);
+  const allResults = [];
+  const relativeRoot = root.slice('fetch://'.length);
+  for (const uri of fileList) {
+    const fetchUri = `${assetDir}${uri}`;
+    const content = await getText(fetchUri);
+    const relativeUri = uri.slice(relativeRoot.length + 1);
+    const results = textSearchInFile$1(relativeUri, content, query);
+    allResults.push(...results);
   }
+  return allResults;
 };
 
-const handleClickAt = async (state, eventX, eventY) => {
-  const {
-    x,
-    y,
-    itemHeight,
-    deltaY
-  } = state;
-  const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight);
-  return selectIndex(state, index);
-};
-
-const handleScrollBarCaptureLost = state => {
-  return {
-    ...state,
-    scrollBarActive: false
-  };
-};
+const Directory = 'directory';
+const File = 'file';
 
-/**
- *
- * @param {number} size
- * @param {number} contentSize
- * @param {number} minimumSliderSize
- * @returns
- */
-const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
-  if (size >= contentSize) {
-    return 0;
+const dirname = (pathSeparator, path) => {
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return path;
   }
-  return Math.max(Math.round(size ** 2 / contentSize), minimumSliderSize);
-};
-const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
-  const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
-  return scrollBarOffset;
+  return path.slice(0, index);
 };
-const getScrollBarY = getScrollBarOffset;
-const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
-  const halfScrollBarHeight = scrollBarHeight / 2;
-  if (relativeY <= halfScrollBarHeight) {
-    // clicked at top
-    return {
-      percent: 0,
-      handleOffset: relativeY
+
+const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);
+}
+const transactionDoneMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener('success', success);
+      request.removeEventListener('error', error);
     };
-  }
-  if (relativeY <= height - halfScrollBarHeight) {
-    // clicked in middle
-    return {
-      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
-      handleOffset: halfScrollBarHeight
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener('success', success);
+    request.addEventListener('error', error);
+  });
+  // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
+  // is because we create many promises from a single IDBRequest.
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  // Early bail if we've already created a done promise for this transaction.
+  if (transactionDoneMap.has(tx)) return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener('complete', complete);
+      tx.removeEventListener('error', error);
+      tx.removeEventListener('abort', error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException('AbortError', 'AbortError'));
+      unlisten();
     };
-  }
-  // clicked at bottom
-  return {
-    percent: 1,
-    handleOffset: scrollBarHeight - height + relativeY
-  };
-};
-
-const clamp = (num, min, max) => {
-  number(num);
-  number(min);
-  number(max);
-  return Math.min(Math.max(num, min), max);
-};
-
-const setDeltaY = (state, value) => {
-  object(state);
-  number(value);
-  const {
-    itemHeight,
-    finalDeltaY,
-    deltaY,
-    height,
-    headerHeight
-  } = state;
-  const listHeight = height - headerHeight;
-  const newDeltaY = clamp(value, 0, finalDeltaY);
-  if (deltaY === newDeltaY) {
-    return state;
-  }
-  // TODO when it only moves by one px, extensions don't need to be rerendered, only negative margin
-  const minLineY = Math.floor(newDeltaY / itemHeight);
-  const maxLineY = minLineY + getNumberOfVisibleItems(listHeight, itemHeight);
-  return {
-    ...state,
-    deltaY: newDeltaY,
-    minLineY,
-    maxLineY
-  };
-};
-
-const handleScrollBarClick = (state, eventY) => {
-  const {
-    y,
-    deltaY,
-    headerHeight,
-    finalDeltaY,
-    scrollBarHeight,
-    height
-  } = state;
-  const contentHeight = height - headerHeight;
-  const relativeY = eventY - y - headerHeight;
-  const currentScrollBarY = getScrollBarY(deltaY, finalDeltaY, contentHeight, scrollBarHeight);
-  const diff = relativeY - currentScrollBarY;
-  if (diff >= 0 && diff < scrollBarHeight) {
-    return {
-      ...state,
-      handleOffset: diff,
-      scrollBarActive: true
-    };
-  }
-  const {
-    percent,
-    handleOffset
-  } = getNewDeltaPercent(contentHeight, scrollBarHeight, relativeY);
-  const newDeltaY = percent * finalDeltaY;
-  return {
-    ...setDeltaY(state, newDeltaY),
-    handleOffset,
-    scrollBarActive: true
-  };
-};
-
-const getNewPercent = (contentHeight, scrollBarHeight, relativeY) => {
-  if (relativeY <= contentHeight - scrollBarHeight / 2) {
-    // clicked in middle
-    return relativeY / (contentHeight - scrollBarHeight);
-  }
-  // clicked at bottom
-  return 1;
-};
-const handleScrollBarMove = (state, eventY) => {
-  const {
-    y,
-    headerHeight,
-    handleOffset,
-    finalDeltaY,
-    height,
-    scrollBarHeight
-  } = state;
-  const relativeY = eventY - y - headerHeight - handleOffset;
-  const contentHeight = height - headerHeight;
-  const newPercent = getNewPercent(contentHeight, scrollBarHeight, relativeY);
-  const newDeltaY = newPercent * finalDeltaY;
-  return setDeltaY(state, newDeltaY);
-};
-
-const handleWheel = (state, deltaMode, deltaY) => {
-  number(deltaMode);
-  number(deltaY);
-  return setDeltaY(state, state.deltaY + deltaY);
-};
-
-const handleError = async (error, notify = true, prefix = '') => {
-  console.error(`[text-search-worker] ${error}`);
-};
-
-const getTextSearchResultCounts = results => {
-  let resultCount = 0;
-  let fileCount = 0;
-  for (const result of results) {
-    switch (result.type) {
-      case File$1:
-        fileCount++;
-        break;
-      case Match:
-        resultCount++;
-        break;
-    }
-  }
-  return {
-    fileCount,
-    resultCount
-  };
-};
-
-const EmptyString = '';
-
-const isEmptyString = string => {
-  return string === EmptyString;
-};
-
-const RE_PROTOCOL = /^([a-z\-]+):\/\//;
-const getProtocol = uri => {
-  const protocolMatch = uri.match(RE_PROTOCOL);
-  if (protocolMatch) {
-    return protocolMatch[1];
-  }
-  return '';
-};
-
-const textSearch$5 = async (scheme, root, query) => {
-  string(scheme);
-  string(query);
-  const result = await invoke$1('ExtensionHostTextSearch.executeTextSearchProvider', scheme, query);
-  return result;
-};
-
-const normalizeLine$1 = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
-  }
-  return line;
-};
-const getCombinedMessage$1 = (error, message) => {
-  const stringifiedError = normalizeLine$1(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-const mergeStacks$1 = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
-let VError$1 = class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage$1(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks$1(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-};
-
-const getJson = async url => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-    const json = await response.json();
-    return json;
-  } catch (error) {
-    throw new VError$1(error, `Failed to get json`);
-  }
-};
-
-const getText = async url => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-    const text = await response.text();
-    return text;
-  } catch (error) {
-    throw new VError$1(error, `Failed to get text`);
-  }
-};
-
-const splitLines$1 = lines => {
-  return lines.split('\n');
-};
-
-const textSearchInFile$1 = (file, content, query) => {
-  const results = [];
-  const lines = splitLines$1(content);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const index = line.indexOf(query);
-    if (index !== -1) {
-      results.push({
-        type: Match,
-        text: line,
-        start: index,
-        end: index + query.length,
-        lineNumber: i
-      });
-    }
-  }
-  if (results.length > 0) {
-    results.unshift({
-      type: File$1,
-      text: file,
-      start: 0,
-      end: 0,
-      lineNumber: 0
-    });
-  }
-  return results;
-};
-const textSearch$4 = async (scheme, root, query, options, assetDir) => {
-  string(scheme);
-  string(root);
-  string(query);
-  const fetchUri = `${assetDir}/config/fileMap.json`;
-  const fileList = await getJson(fetchUri);
-  const allResults = [];
-  const relativeRoot = root.slice('fetch://'.length);
-  for (const uri of fileList) {
-    const fetchUri = `${assetDir}${uri}`;
-    const content = await getText(fetchUri);
-    const relativeUri = uri.slice(relativeRoot.length + 1);
-    const results = textSearchInFile$1(relativeUri, content, query);
-    allResults.push(...results);
-  }
-  return allResults;
-};
-
-const Directory = 'directory';
-const File = 'file';
-
-const dirname = (pathSeparator, path) => {
-  const index = path.lastIndexOf(pathSeparator);
-  if (index === -1) {
-    return path;
-  }
-  return path.slice(0, index);
-};
-
-const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-  return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-  return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);
-}
-const transactionDoneMap = new WeakMap();
-const transformCache = new WeakMap();
-const reverseTransformCache = new WeakMap();
-function promisifyRequest(request) {
-  const promise = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      request.removeEventListener('success', success);
-      request.removeEventListener('error', error);
-    };
-    const success = () => {
-      resolve(wrap(request.result));
-      unlisten();
-    };
-    const error = () => {
-      reject(request.error);
-      unlisten();
-    };
-    request.addEventListener('success', success);
-    request.addEventListener('error', error);
-  });
-  // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
-  // is because we create many promises from a single IDBRequest.
-  reverseTransformCache.set(promise, request);
-  return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-  // Early bail if we've already created a done promise for this transaction.
-  if (transactionDoneMap.has(tx)) return;
-  const done = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      tx.removeEventListener('complete', complete);
-      tx.removeEventListener('error', error);
-      tx.removeEventListener('abort', error);
-    };
-    const complete = () => {
-      resolve();
-      unlisten();
-    };
-    const error = () => {
-      reject(tx.error || new DOMException('AbortError', 'AbortError'));
-      unlisten();
-    };
-    tx.addEventListener('complete', complete);
-    tx.addEventListener('error', error);
-    tx.addEventListener('abort', error);
-  });
-  // Cache it for later retrieval.
-  transactionDoneMap.set(tx, done);
-}
-let idbProxyTraps = {
-  get(target, prop, receiver) {
-    if (target instanceof IDBTransaction) {
-      // Special handling for transaction.done.
-      if (prop === 'done') return transactionDoneMap.get(target);
-      // Make tx.store return the only store in the transaction, or undefined if there are many.
-      if (prop === 'store') {
-        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
-      }
-    }
-    // Else transform whatever we get back.
-    return wrap(target[prop]);
-  },
-  set(target, prop, value) {
-    target[prop] = value;
-    return true;
-  },
-  has(target, prop) {
-    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {
-      return true;
-    }
-    return prop in target;
+    tx.addEventListener('complete', complete);
+    tx.addEventListener('error', error);
+    tx.addEventListener('abort', error);
+  });
+  // Cache it for later retrieval.
+  transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      // Special handling for transaction.done.
+      if (prop === 'done') return transactionDoneMap.get(target);
+      // Make tx.store return the only store in the transaction, or undefined if there are many.
+      if (prop === 'store') {
+        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    // Else transform whatever we get back.
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {
+      return true;
+    }
+    return prop in target;
   }
 };
 function replaceTraps(callback) {
@@ -2040,330 +1924,652 @@ async function* iterate(...args) {
     cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
     advanceResults.delete(proxiedCursor);
   }
-}
-function isIteratorProp(target, prop) {
-  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
-}
-replaceTraps(oldTraps => ({
-  ...oldTraps,
-  get(target, prop, receiver) {
-    if (isIteratorProp(target, prop)) return iterate;
-    return oldTraps.get(target, prop, receiver);
-  },
-  has(target, prop) {
-    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop)) return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+const state = {
+  databases: Object.create(null),
+  eventId: 0,
+  dbVersion: 1,
+  cachedDb: undefined
+};
+
+// TODO high memory usage in idb because of transactionDoneMap
+
+const getHandleDb = async () => {
+  // @ts-ignore
+  const db = await openDB('handle', state.dbVersion, {
+    async upgrade(db) {
+      if (!db.objectStoreNames.contains('file-handles-store')) {
+        await db.createObjectStore('file-handles-store', {});
+      }
+    }
+  });
+  return db;
+};
+const getHandle$1 = async uri => {
+  const handleDb = await getHandleDb();
+  const handle = await handleDb.get('file-handles-store', uri);
+  return handle;
+};
+
+const getHandle = async uri => {
+  try {
+    // TODO retrieve handle from state or from indexeddb
+    // TODO if not found, throw error
+    const handle = await getHandle$1(uri);
+    return handle;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to get handle');
+  }
+};
+
+const getDirectoryHandle = async uri => {
+  const handle = await getHandle(uri);
+  if (handle) {
+    return handle;
+  }
+  const dirname$1 = dirname('/', uri);
+  if (uri === dirname$1) {
+    return undefined;
+  }
+  return getDirectoryHandle(dirname$1);
+};
+
+const NotReadableError = 'NotReadableError';
+
+const isNotReadableError = error => {
+  return error && error.name === NotReadableError;
+};
+
+const getFile = handle => {
+  return handle.getFile();
+};
+
+const textSearchInText = (file, content, query) => {
+  const results = [];
+  const lines = splitLines$1(content);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const index = line.indexOf(query);
+    if (index !== -1) {
+      results.push({
+        type: Match,
+        text: line,
+        start: index,
+        end: index + query.length,
+        lineNumber: i
+      });
+    }
+  }
+  if (results.length > 0) {
+    results.unshift({
+      type: File$1,
+      text: file,
+      start: 0,
+      end: 0,
+      lineNumber: 0
+    });
+  }
+  return results;
+};
+
+const textSearchInFile = async (all, handle, absolutePath, query) => {
+  try {
+    const file = await getFile(handle);
+    const content = await file.text();
+    const results = textSearchInText(absolutePath, content, query);
+    push(all, results);
+  } catch (error) {
+    if (isNotReadableError(error)) {
+      // ignore
+      return;
+    }
+    throw error;
+  }
+};
+
+const textSearchRecursively = async (all, parent, handle, query) => {
+  const childHandles = [];
+  // TODO
+  // await FileSystemHtml.getChildHandles(handle)
+  const promises = [];
+  for (const childHandle of childHandles) {
+    const absolutePath = parent + '/' + childHandle.name;
+    switch (childHandle.kind) {
+      case Directory:
+        promises.push(textSearchRecursively(all, absolutePath, childHandle, query));
+        break;
+      case File:
+        promises.push(textSearchInFile(all, childHandle, absolutePath, query));
+        break;
+    }
+  }
+  await Promise.all(promises);
+};
+const textSearch$3 = async (scheme, root, query) => {
+  string(scheme);
+  string(root);
+  string(query);
+  const relativeRoot = root.slice('html://'.length);
+  const handle = await getDirectoryHandle(relativeRoot);
+  if (!handle) {
+    throw new VError$1(`Folder not found ${relativeRoot}`);
+  }
+  const all = [];
+  await textSearchRecursively(all, '', handle, query);
+  return all;
+};
+
+const getRipGrepArgs = ({
+  threads,
+  isCaseSensitive,
+  searchString,
+  useRegularExpression
+}) => {
+  const ripGrepArgs = ['--hidden', '--no-require-git', '--smart-case', '--stats', '--json'];
+  ripGrepArgs.push('--threads', `${threads}`);
+  if (isCaseSensitive) {
+    ripGrepArgs.push('--case-sensitive');
+  } else {
+    ripGrepArgs.push('--ignore-case');
+  }
+  if (useRegularExpression) {
+    ripGrepArgs.push('--regexp', searchString);
+  } else {
+    ripGrepArgs.push('--fixed-strings');
+    ripGrepArgs.push('--');
+    ripGrepArgs.push(searchString);
   }
-}));
+  ripGrepArgs.push('.');
+  return ripGrepArgs;
+};
 
-const state = {
-  databases: Object.create(null),
-  eventId: 0,
-  dbVersion: 1,
-  cachedDb: undefined
+const invoke = (method, ...params) => {
+  return invoke$1('SearchProcess.invoke', method, ...params);
 };
 
-// TODO high memory usage in idb because of transactionDoneMap
+const textSearch$2 = async (scheme, root, query, options) => {
+  const ripGrepArgs = getRipGrepArgs({
+    ...options,
+    searchString: query
+  });
+  const actualOptions = {
+    ripGrepArgs,
+    searchDir: root
+  };
+  const result = await invoke('TextSearch.search', actualOptions);
+  // TODO api is weird
+  return result.results;
+};
 
-const getHandleDb = async () => {
-  // @ts-ignore
-  const db = await openDB('handle', state.dbVersion, {
-    async upgrade(db, oldVersion) {
-      if (!db.objectStoreNames.contains('file-handles-store')) {
-        // @ts-ignore
-        await db.createObjectStore('file-handles-store', {});
-      }
+const textSearch$1 = (scheme, root, query) => {
+  // TODO ask renderer worker for files
+  const entries = Object.entries({});
+  const results = [];
+  for (const [key, value] of entries) {
+    // @ts-ignore
+    if (value.includes(query)) {
+      results.push([key, [{
+        absoluteOffset: 0,
+        preview: value
+      }]]);
     }
-  });
-  return db;
+  }
+  return results;
 };
-const getHandle$1 = async uri => {
-  const handleDb = await getHandleDb();
-  const handle = await handleDb.get('file-handles-store', uri);
-  return handle;
+
+const getProvider = scheme => {
+  switch (scheme) {
+    case '':
+      return textSearch$2;
+    case 'web':
+      return textSearch$1;
+    case 'fetch':
+      return textSearch$4;
+    case 'html':
+      return textSearch$3;
+    default:
+      return textSearch$5;
+  }
 };
 
-const getHandle = async uri => {
+const textSearch = async (root, query, options, assetDir) => {
+  string(root);
+  string(query);
+  const scheme = getProtocol(root);
+  const provider = getProvider(scheme);
+  const results = await provider(scheme, root, query, options, assetDir);
+  return results;
+};
+
+const handleUpdate = async (state, update) => {
+  const partialNewState = {
+    ...state,
+    ...update
+  };
   try {
-    // TODO retrieve handle from state or from indexeddb
-    // TODO if not found, throw error
-    const handle = await getHandle$1(uri);
-    return handle;
+    const {
+      height,
+      itemHeight,
+      minimumSliderSize,
+      headerHeight,
+      matchCase,
+      value,
+      threads,
+      useRegularExpression
+    } = partialNewState;
+    if (isEmptyString(value)) {
+      return {
+        ...partialNewState,
+        minLineY: 0,
+        maxLineY: 0,
+        deltaY: 0,
+        items: [],
+        matchIndex: 0,
+        matchCount: 0,
+        message: '',
+        loaded: true
+      };
+    }
+    const root = state.workspacePath;
+    const results = await textSearch(root, value, {
+      threads,
+      isCaseSensitive: matchCase,
+      useRegularExpression
+    }, state.assetDir);
+    if (!Array.isArray(results)) {
+      throw new TypeError('results must be of type array');
+    }
+    const {
+      fileCount,
+      resultCount
+    } = getTextSearchResultCounts(results);
+    const message = getStatusMessage(resultCount, fileCount);
+    const total = results.length;
+    const contentHeight = total * itemHeight;
+    const listHeight = height - headerHeight;
+    const scrollBarHeight = getScrollBarSize(height, contentHeight, minimumSliderSize);
+    const numberOfVisible = getNumberOfVisibleItems(listHeight, itemHeight);
+    const maxLineY = Math.min(numberOfVisible, total);
+    const finalDeltaY = Math.max(contentHeight - listHeight, 0);
+    const visible = results.slice(0, maxLineY);
+    const icons = await getFileIcons(visible);
+    return {
+      ...partialNewState,
+      minLineY: 0,
+      deltaY: 0,
+      value,
+      items: results,
+      message,
+      maxLineY: maxLineY,
+      scrollBarHeight,
+      finalDeltaY,
+      threads,
+      fileCount,
+      matchCount: resultCount,
+      loaded: true,
+      icons
+    };
   } catch (error) {
-    throw new VError$1(error, 'Failed to get handle');
+    handleError(error);
+    return {
+      ...partialNewState,
+      message: `${error}`,
+      items: [],
+      matchCount: 0,
+      fileCount: 0,
+      minLineY: 0,
+      maxLineY: 0
+    };
   }
 };
 
-const getDirectoryHandle = async uri => {
-  const handle = await getHandle(uri);
-  if (handle) {
-    return handle;
+const handleInput = (state, value, inputSource = Script) => {
+  return handleUpdate(state, {
+    value,
+    inputSource
+  });
+};
+
+const first = () => {
+  return 0;
+};
+const last = items => {
+  return items.length - 1;
+};
+const next = (items, index) => {
+  return (index + 1) % items.length;
+};
+const previous = (items, index) => {
+  return index === 0 ? items.length - 1 : index - 1;
+};
+
+const focusIndexScrollUp = (state, index, listHeight, itemHeight, itemsLength) => {
+  const newMinLineY = index;
+  const fittingItems = getNumberOfVisibleItems(listHeight, itemHeight);
+  const newMaxLineY = Math.min(newMinLineY + fittingItems, itemsLength);
+  const newDeltaY = newMinLineY * itemHeight;
+  return {
+    ...state,
+    focusedIndex: index,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    focused: true,
+    deltaY: newDeltaY
+  };
+};
+const focusIndexScrollDown = (state, index, listHeight, itemHeight, itemsLength) => {
+  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;
+  return {
+    ...state,
+    focusedIndex: index,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    focused: true,
+    deltaY: newDeltaY
+  };
+};
+const focusIndex = (state, index) => {
+  const {
+    itemHeight,
+    minLineY,
+    maxLineY,
+    headerHeight,
+    height,
+    items
+  } = state;
+  const itemsLength = items.length;
+  if (itemsLength === 0) {
+    return state;
+  }
+  number(itemHeight);
+  if (index === -1) {
+    return {
+      ...state,
+      focusedIndex: -1,
+      focused: true
+    };
+  }
+  const listHeight = height - headerHeight;
+  if (index < minLineY + 1) {
+    return focusIndexScrollUp(state, index, listHeight, itemHeight, itemsLength);
   }
-  const dirname$1 = dirname('/', uri);
-  if (uri === dirname$1) {
-    return undefined;
+  if (index >= maxLineY - 1) {
+    return focusIndexScrollDown(state, index, listHeight, itemHeight, itemsLength);
   }
-  return getDirectoryHandle(dirname$1);
+  return {
+    ...state,
+    focusedIndex: index,
+    focused: true
+  };
 };
 
-const NotReadableError = 'NotReadableError';
-
-const isNotReadableError = error => {
-  return error && error.name === NotReadableError;
+const focusFirst = state => {
+  const firstIndex = first();
+  return focusIndex(state, firstIndex);
 };
 
-const getFile = handle => {
-  return handle.getFile();
+const focusLast = state => {
+  const {
+    items
+  } = state;
+  const lastIndex = last(items);
+  return focusIndex(state, lastIndex);
 };
 
-const textSearchInText = (file, content, query) => {
-  const results = [];
-  const lines = splitLines$1(content);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const index = line.indexOf(query);
-    if (index !== -1) {
-      results.push({
-        type: Match,
-        text: line,
-        start: index,
-        end: index + query.length,
-        lineNumber: i
-      });
-    }
-  }
-  if (results.length > 0) {
-    results.unshift({
-      type: File$1,
-      text: file,
-      start: 0,
-      end: 0,
-      lineNumber: 0
-    });
-  }
-  return results;
+const focusNext = state => {
+  const {
+    focusedIndex,
+    items
+  } = state;
+  const nextIndex = next(items, focusedIndex);
+  return focusIndex(state, nextIndex);
 };
 
-const textSearchInFile = async (all, handle, absolutePath, query) => {
-  try {
-    const file = await getFile(handle);
-    const content = await file.text();
-    const results = textSearchInText(absolutePath, content, query);
-    push(all, results);
-  } catch (error) {
-    if (isNotReadableError(error)) {
-      // ignore
-      return;
-    }
-    throw error;
+const focusNextPage = state => {
+  const {
+    focusedIndex,
+    items,
+    maxLineY,
+    minLineY
+  } = state;
+  if (isLastIndex(items, focusedIndex)) {
+    return state;
   }
+  const indexNextPage = Math.min(maxLineY + (maxLineY - minLineY) - 2, lastIndex(items));
+  return focusIndex(state, indexNextPage);
 };
 
-const textSearchRecursively = async (all, parent, handle, query) => {
-  const childHandles = [];
-  // TODO
-  // await FileSystemHtml.getChildHandles(handle)
-  const promises = [];
-  for (const childHandle of childHandles) {
-    const absolutePath = parent + '/' + childHandle.name;
-    switch (childHandle.kind) {
-      case Directory:
-        promises.push(textSearchRecursively(all, absolutePath, childHandle, query));
-        break;
-      case File:
-        promises.push(textSearchInFile(all, childHandle, absolutePath, query));
-        break;
-    }
-  }
-  await Promise.all(promises);
-};
-const textSearch$3 = async (scheme, root, query) => {
-  string(scheme);
-  string(root);
-  string(query);
-  const relativeRoot = root.slice('html://'.length);
-  const handle = await getDirectoryHandle(relativeRoot);
-  if (!handle) {
-    throw new VError$1(`Folder not found ${relativeRoot}`);
+const focusPreviousPage = state => {
+  const {
+    focusedIndex,
+    minLineY,
+    maxLineY
+  } = state;
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
   }
-  const all = [];
-  await textSearchRecursively(all, '', handle, query);
-  return all;
+  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
+  return focusIndex(state, indexPreviousPage);
 };
 
-const getRipGrepArgs = ({
-  threads,
-  isCaseSensitive,
-  searchString,
-  useRegularExpression
-}) => {
-  const ripGrepArgs = ['--hidden', '--no-require-git', '--smart-case', '--stats', '--json'];
-  ripGrepArgs.push('--threads', `${threads}`);
-  if (isCaseSensitive) {
-    ripGrepArgs.push('--case-sensitive');
-  } else {
-    ripGrepArgs.push('--ignore-case');
-  }
-  if (useRegularExpression) {
-    ripGrepArgs.push('--regexp', searchString);
-  } else {
-    ripGrepArgs.push('--fixed-strings');
-    ripGrepArgs.push('--');
-    ripGrepArgs.push(searchString);
+const focusPrevious = state => {
+  const {
+    focusedIndex,
+    items
+  } = state;
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
   }
-  ripGrepArgs.push('.');
-  return ripGrepArgs;
+  const previousIndex = previous(items, focusedIndex);
+  return focusIndex(state, previousIndex);
 };
 
-const invoke = (method, ...params) => {
-  return invoke$1('SearchProcess.invoke', method, ...params);
+const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
+  const relativeY = eventY - y + deltaY;
+  const index = Math.floor(relativeY / itemHeight);
+  return index;
 };
 
-const textSearch$2 = async (scheme, root, query, options) => {
-  const ripGrepArgs = getRipGrepArgs({
-    ...options,
-    searchString: query
-  });
-  const actualOptions = {
-    ripGrepArgs,
-    searchDir: root
-  };
-  const result = await invoke('TextSearch.search', actualOptions);
-  // TODO api is weird
-  return result.results;
+const openUri = async (path, focus = true, props = {}) => {
+  await invoke$1(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const textSearch$1 = (scheme, root, query) => {
-  // TODO ask renderer worker for files
-  const entries = Object.entries({});
-  const results = [];
-  for (const [key, value] of entries) {
-    // @ts-ignore
-    if (value.includes(query)) {
-      results.push([key, [{
-        absoluteOffset: 0,
-        preview: value
-      }]]);
+const getFileIndex = (items, index) => {
+  for (let i = index; i >= 0; i--) {
+    const item = items[i];
+    if (item.type === File$1) {
+      return i;
     }
   }
-  return results;
+  return -1;
 };
-
-const getProvider = scheme => {
-  switch (scheme) {
-    case '':
-      return textSearch$2;
-    case 'web':
-      return textSearch$1;
-    case 'fetch':
-      return textSearch$4;
-    case 'html':
-      return textSearch$3;
+const selectIndexFile = (state, searchResult, index) => {
+  const {
+    collapsedPaths
+  } = state;
+  const path = getAbsolutePath(searchResult.text);
+  string(path);
+  return {
+    ...state,
+    collapsedPaths: [...collapsedPaths, path],
+    listFocusedIndex: index,
+    listFocused: true
+  };
+};
+const selectIndexPreview = async (state, searchResult, index) => {
+  const {
+    items
+  } = state;
+  const fileIndex = getFileIndex(items, index);
+  if (fileIndex === -1) {
+    throw new Error('Search result is missing file');
+  }
+  const {
+    lineNumber
+  } = searchResult;
+  // console.log({ searchResult })
+  const fileResult = items[fileIndex];
+  const path = getAbsolutePath(fileResult.text);
+  string(path);
+  await openUri(path, true, {
+    selections: new Uint32Array([lineNumber, 0, lineNumber, 0])
+  });
+  return {
+    ...state,
+    listFocusedIndex: index,
+    listFocused: false
+  };
+};
+const selectIndex = async (state, index) => {
+  if (index === -1) {
+    return {
+      ...state,
+      listFocused: true,
+      listFocusedIndex: -1
+    };
+  }
+  const {
+    items
+  } = state;
+  const searchResult = items[index];
+  switch (searchResult.type) {
+    case File$1:
+      return selectIndexFile(state, searchResult, index);
+    case Match:
+      return selectIndexPreview(state, searchResult, index);
     default:
-      return textSearch$5;
+      throw new Error(`unexpected search result type ${searchResult.type}`);
   }
 };
 
-const textSearch = async (root, query, options, assetDir) => {
-  string(root);
-  string(query);
-  const scheme = getProtocol(root);
-  const provider = getProvider(scheme);
-  const results = await provider(scheme, root, query, options, assetDir);
-  return results;
+const handleClickAt = async (state, eventX, eventY) => {
+  const {
+    x,
+    y,
+    itemHeight,
+    deltaY
+  } = state;
+  const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight);
+  return selectIndex(state, index);
+};
+
+const handleScrollBarCaptureLost = state => {
+  return {
+    ...state,
+    scrollBarActive: false
+  };
 };
 
-const getStatusMessage = (resultCount, fileResultCount) => {
-  number(resultCount);
-  number(fileResultCount);
-  if (resultCount === 0) {
-    return noResults();
-  }
-  if (resultCount === 1) {
-    return oneResult();
-  }
-  if (fileResultCount === 1) {
-    return manyResultsInOneFile(resultCount);
-  }
-  return manyResultsInManyFiles(resultCount, fileResultCount);
+const clamp = (num, min, max) => {
+  number(num);
+  number(min);
+  number(max);
+  return Math.min(Math.max(num, min), max);
 };
 
-const handleUpdate = async (state, update) => {
-  const partialNewState = {
+const setDeltaY = (state, value) => {
+  object(state);
+  number(value);
+  const {
+    itemHeight,
+    finalDeltaY,
+    deltaY,
+    height,
+    headerHeight
+  } = state;
+  const listHeight = height - headerHeight;
+  const newDeltaY = clamp(value, 0, finalDeltaY);
+  if (deltaY === newDeltaY) {
+    return state;
+  }
+  // TODO when it only moves by one px, extensions don't need to be rerendered, only negative margin
+  const minLineY = Math.floor(newDeltaY / itemHeight);
+  const maxLineY = minLineY + getNumberOfVisibleItems(listHeight, itemHeight);
+  return {
     ...state,
-    ...update
+    deltaY: newDeltaY,
+    minLineY,
+    maxLineY
   };
-  try {
-    const {
-      height,
-      itemHeight,
-      minimumSliderSize,
-      headerHeight,
-      matchCase,
-      value,
-      threads,
-      useRegularExpression
-    } = partialNewState;
-    if (isEmptyString(value)) {
-      return {
-        ...partialNewState,
-        minLineY: 0,
-        maxLineY: 0,
-        deltaY: 0,
-        items: [],
-        matchIndex: 0,
-        matchCount: 0,
-        message: '',
-        loaded: true
-      };
-    }
-    const root = state.workspacePath;
-    const results = await textSearch(root, value, {
-      threads,
-      isCaseSensitive: matchCase,
-      useRegularExpression
-    }, state.assetDir);
-    if (!Array.isArray(results)) {
-      throw new TypeError('results must be of type array');
-    }
-    const {
-      fileCount,
-      resultCount
-    } = getTextSearchResultCounts(results);
-    const message = getStatusMessage(resultCount, fileCount);
-    const total = results.length;
-    const contentHeight = total * itemHeight;
-    const listHeight = height - headerHeight;
-    const scrollBarHeight = getScrollBarSize(height, contentHeight, minimumSliderSize);
-    const numberOfVisible = getNumberOfVisibleItems(listHeight, itemHeight);
-    const maxLineY = Math.min(numberOfVisible, total);
-    const finalDeltaY = Math.max(contentHeight - listHeight, 0);
-    return {
-      ...partialNewState,
-      minLineY: 0,
-      deltaY: 0,
-      value,
-      items: results,
-      message,
-      maxLineY: maxLineY,
-      scrollBarHeight,
-      finalDeltaY,
-      threads,
-      fileCount,
-      matchCount: resultCount,
-      loaded: true
-    };
-  } catch (error) {
-    handleError(error);
+};
+
+const handleScrollBarClick = (state, eventY) => {
+  const {
+    y,
+    deltaY,
+    headerHeight,
+    finalDeltaY,
+    scrollBarHeight,
+    height
+  } = state;
+  const contentHeight = height - headerHeight;
+  const relativeY = eventY - y - headerHeight;
+  const currentScrollBarY = getScrollBarY(deltaY, finalDeltaY, contentHeight, scrollBarHeight);
+  const diff = relativeY - currentScrollBarY;
+  if (diff >= 0 && diff < scrollBarHeight) {
     return {
-      ...partialNewState,
-      message: `${error}`,
-      items: [],
-      matchCount: 0,
-      fileCount: 0,
-      minLineY: 0,
-      maxLineY: 0
+      ...state,
+      handleOffset: diff,
+      scrollBarActive: true
     };
   }
+  const {
+    percent,
+    handleOffset
+  } = getNewDeltaPercent(contentHeight, scrollBarHeight, relativeY);
+  const newDeltaY = percent * finalDeltaY;
+  return {
+    ...setDeltaY(state, newDeltaY),
+    handleOffset,
+    scrollBarActive: true
+  };
+};
+
+const getNewPercent = (contentHeight, scrollBarHeight, relativeY) => {
+  if (relativeY <= contentHeight - scrollBarHeight / 2) {
+    // clicked in middle
+    return relativeY / (contentHeight - scrollBarHeight);
+  }
+  // clicked at bottom
+  return 1;
+};
+const handleScrollBarMove = (state, eventY) => {
+  const {
+    y,
+    headerHeight,
+    handleOffset,
+    finalDeltaY,
+    height,
+    scrollBarHeight
+  } = state;
+  const relativeY = eventY - y - headerHeight - handleOffset;
+  const contentHeight = height - headerHeight;
+  const newPercent = getNewPercent(contentHeight, scrollBarHeight, relativeY);
+  const newDeltaY = newPercent * finalDeltaY;
+  return setDeltaY(state, newDeltaY);
+};
+
+const handleWheel = (state, deltaMode, deltaY) => {
+  number(deltaMode);
+  number(deltaY);
+  return setDeltaY(state, state.deltaY + deltaY);
 };
 
 const getSavedValue = savedState => {
@@ -2387,8 +2593,7 @@ const getSavedCollapsedPaths = savedState => {
 const getThreads = () => {
   return 1;
 };
-const loadContent = async (uid, savedState) => {
-  const state = get(uid);
+const loadContent = async (state, savedState) => {
   const savedValue = getSavedValue(savedState);
   const savedReplaceExpanded = getSavedReplaceExpanded(savedState);
   const savedCollapsedPaths = getSavedCollapsedPaths(savedState);
@@ -2419,10 +2624,10 @@ const renderItems = {
     return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.replacement === newState.replacement && oldState.replaceExpanded === newState.replaceExpanded && oldState.matchCase === newState.matchCase && oldState.matchWholeWord === newState.matchWholeWord && oldState.useRegularExpression === newState.useRegularExpression && oldState.message === newState.message && oldState.detailsExpanded === newState.detailsExpanded && oldState.loaded === newState.loaded && oldState.collapsedPaths === newState.collapsedPaths && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.listFocused === newState.listFocused;
   },
   apply(oldState, newState) {
-    const displayResults = getDisplayResults(newState.items, newState.itemHeight, newState.fileCount, newState.value, newState.minLineY, newState.maxLineY, newState.replacement, newState.collapsedPaths, newState.focusedIndex);
+    const displayResults = getDisplayResults(newState.items, newState.itemHeight, newState.fileCount, newState.value, newState.minLineY, newState.maxLineY, newState.replacement, newState.collapsedPaths, newState.icons, newState.focusedIndex);
     const focusOutline = newState.listFocused && newState.listFocusedIndex === -1;
     const dom = getSearchVirtualDom(displayResults, newState.replaceExpanded, newState.matchCase, newState.matchWholeWord, newState.useRegularExpression, newState.message, newState.detailsExpanded, focusOutline);
-    return ['Viewlet.setDom2', dom];
+    return ['Viewlet.setDom2', newState.uid, dom];
   }
 };
 const getSelector = focusKey => {
@@ -2443,15 +2648,19 @@ const getSelector = focusKey => {
 };
 const renderFocus = {
   isEqual(oldState, newState) {
-    return oldState.focus === newState.focus;
+    return oldState.focus === newState.focus || newState.focusSource === User;
   },
   apply(newState) {
     const selector = getSelector(newState.focus);
-    return ['setFocus', selector];
+    return ['Viewlet.send', newState.uid, 'setFocus', selector, newState.focusSource];
   }
 };
 const render = [renderItems, renderFocus];
-const doRender = (oldState, newState) => {
+const doRender = uid => {
+  const {
+    oldState,
+    newState
+  } = get(uid);
   const commands = [];
   for (const fn of render) {
     if (!fn.isEqual(oldState, newState)) {
@@ -2461,20 +2670,131 @@ const doRender = (oldState, newState) => {
   return commands;
 };
 
-const focusSearchValue = state => {
+const getReplaceAllConfirmText = (matchCount, fileCount, replacement) => {
+  if (matchCount === 1) {
+    if (replacement) {
+      return confirmReplaceOneOccurrenceInOneFile(replacement);
+    }
+    return confirmReplaceOneOccurrenceInOneFileNoValue();
+  }
+  if (fileCount === 1) {
+    if (replacement) {
+      return confirmReplaceManyOccurrencesInOneFile(matchCount, replacement);
+    }
+    return confirmReplaceManyOccurrencesInOneFileNoValue(matchCount);
+  }
+  if (replacement) {
+    return confirmReplaceManyOccurrencesInManyFiles(matchCount, fileCount, replacement);
+  }
+  return confirmReplaceManyOccurrencesInManyFilesNoValue(matchCount, fileCount);
+};
+
+const replaceAllAndPrompt = async (workspacePath, items, replacement, matchCount, fileCount) => {
+  string(workspacePath);
+  array(items);
+  string(replacement);
+  number(matchCount);
+  number(fileCount);
+  const confirmTitle = replaceAll$1();
+  const confirmAccept = replace();
+  const confirmText = getReplaceAllConfirmText(matchCount, fileCount, replacement);
+  const shouldReplace = await execute('ConfirmPrompt.prompt', confirmText, {
+    title: confirmTitle,
+    confirmMessage: confirmAccept
+  });
+  if (!shouldReplace) {
+    return false;
+  }
+  // TODO
+  // await TextSearchReplaceAll.replaceAll(workspacePath, items, replacement)
+  return true;
+};
+
+const getBulkReplacementEdits = (workspacePath, matches) => {
+  string(workspacePath);
+  array(matches);
+  const files = [];
+  const ranges = [];
+  let currentRanges = [];
+  for (const match of matches) {
+    const {
+      type,
+      text
+    } = match;
+    switch (type) {
+      case File$1:
+        ranges.push(currentRanges.length);
+        push(ranges, currentRanges);
+        const absolutePath = `${workspacePath}/${text.slice(2)}`;
+        files.push(absolutePath); // TODO
+        currentRanges = [];
+        break;
+      case Match:
+        currentRanges.push(match.lineNumber - 1, match.matchStart, match.lineNumber - 1, match.matchStart + match.matchLength);
+        break;
+    }
+  }
+  ranges.push(currentRanges.length);
+  push(ranges, currentRanges);
   return {
-    ...state,
-    focus: FocusSearchInput
+    files,
+    ranges: ranges.slice(1)
   };
 };
-const focusSearchValueNext = state => {
+
+const replaceAll = async (workspacePath, items, replacement) => {
   const {
+    files,
+    ranges
+  } = getBulkReplacementEdits(workspacePath, items);
+  await invoke$1('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+};
+
+const saveState = uid => {
+  const {
+    newState
+  } = get(uid);
+  const {
+    value,
     replaceExpanded
-  } = state;
-  if (replaceExpanded) {
-    return focusReplaceValue(state);
+  } = newState;
+  return {
+    value,
+    replaceExpanded
+  };
+};
+
+const setFocus = async focusKey => {
+  await invoke$1('Focus.setFocus', focusKey);
+};
+
+const getSearchFocusKey = key => {
+  switch (key) {
+    case 'search-value':
+      return FocusSearchInput;
+    case 'search-replace-value':
+      return FocusSearchReplaceInput;
+    case 'Match Case':
+      return FocusSearchMatchCase;
+    case 'Match Whole Word':
+      return FocusSearchWholeWord;
+    case 'Use Regular Expression':
+      return FocusSearchRegex;
+    case 'Replace All':
+      return FocusSearchReplaceAll;
+    case 'Preserve Case':
+      return FocusSearchPreserveCase;
+    default:
+      return Empty$1;
   }
-  return focusMatchCase(state);
+};
+
+const focusSearchValue = state => {
+  return {
+    ...state,
+    focus: FocusSearchInput,
+    focusSource: Script
+  };
 };
 const focusMatchCasePrevious = state => {
   const {
@@ -2494,37 +2814,55 @@ const focusRegexNext = state => {
 const focusReplaceValue = state => {
   return {
     ...state,
-    focus: FocusSearchReplaceInput
+    focus: FocusSearchReplaceInput,
+    focusSource: Script
   };
 };
 const focusMatchCase = state => {
   return {
     ...state,
-    focus: FocusSearchMatchCase
+    focus: FocusSearchMatchCase,
+    focusSource: Script
   };
 };
 const focusPreserveCase = state => {
   return {
     ...state,
-    focus: FocusSearchPreserveCase
+    focus: FocusSearchPreserveCase,
+    focusSource: Script
   };
 };
 const focusMatchWholeWord = state => {
   return {
     ...state,
-    focus: FocusSearchWholeWord
+    focus: FocusSearchWholeWord,
+    focusSource: Script
   };
 };
 const focusRegex = state => {
   return {
     ...state,
-    focus: FocusSearchRegex
+    focus: FocusSearchRegex,
+    focusSource: Script
   };
 };
 const focusReplaceAll = state => {
   return {
     ...state,
-    focus: FocusSearchReplaceAll
+    focus: FocusSearchReplaceAll,
+    focusSource: Script
+  };
+};
+const handleFocusIn = (state, key) => {
+  const focusKey = getSearchFocusKey(key);
+  if (state.focus === focusKey) {
+    return state;
+  }
+  void setFocus(focusKey);
+  return {
+    ...state,
+    focus: focusKey,
+    focusSource: User
   };
 };
 
@@ -2535,6 +2873,16 @@ const submit = state => {
   });
 };
 
+const toggleReplace = state => {
+  const {
+    replaceExpanded
+  } = state;
+  return {
+    ...state,
+    replaceExpanded: !replaceExpanded
+  };
+};
+
 const Keyboard = -1;
 
 const show = async (x, y, id, ...args) => {
@@ -2543,6 +2891,7 @@ const show = async (x, y, id, ...args) => {
   number(y);
   number(id);
   // TODO
+  await invoke$1('ContextMenu.show', x, y, id, ...args);
 };
 
 const Search = 18;
@@ -2568,47 +2917,63 @@ const handleContextMenu = (state, button, x, y) => {
   }
 };
 
+const wrapCommand = fn => {
+  const wrapped = async (uid, ...args) => {
+    const {
+      newState
+    } = get(uid);
+    const newerState = await fn(newState, ...args);
+    set(uid, newState, newerState);
+  };
+  return wrapped;
+};
+
 const commandMap = {
-  'SearchView.focusMatchCase': focusMatchCase$1,
-  'SearchView.focusReplaceValue': focusReplaceValue$1,
-  'SearchView.focusSearchValue': focusSearchValue$1,
-  'SearchView.focusSearchValueNext': focusSearchValueNext$1,
-  'TextSearch.clearSearchResults': clearSearchResults$1,
-  'TextSearch.copy': copy,
+  'TextSearch.clearSearchResults': wrapCommand(clearSearchResults$1),
+  'TextSearch.copy': wrapCommand(copy),
+  'TextSearch.dismissItem': wrapCommand(dismissItem),
+  'TextSearch.focusFirst': wrapCommand(focusFirst),
+  'TextSearch.focusIndex': wrapCommand(focusIndex),
+  'TextSearch.focusLast': wrapCommand(focusLast),
+  'TextSearch.focusMatchCase': wrapCommand(focusMatchCase$1),
+  'TextSearch.focusMatchCasePrevious': wrapCommand(focusMatchCasePrevious),
+  'TextSearch.focusMatchWholeWord': wrapCommand(focusMatchWholeWord),
+  'TextSearch.focusNext': wrapCommand(focusNext),
+  'TextSearch.focusNextPage': wrapCommand(focusNextPage),
+  'TextSearch.focusPreserveCase': wrapCommand(focusPreserveCase),
+  'TextSearch.focusPrevious': wrapCommand(focusPrevious),
+  'TextSearch.focusPreviousPage': wrapCommand(focusPreviousPage),
+  'TextSearch.focusRegex': wrapCommand(focusRegex),
+  'TextSearch.focusRegexNext': wrapCommand(focusRegexNext),
+  'TextSearch.focusReplaceAll': wrapCommand(focusReplaceAll),
+  'TextSearch.focusReplaceValue': wrapCommand(focusReplaceValue$1),
+  'TextSearch.focusReplaceValueNext': wrapCommand(focusReplaceValueNext),
+  'TextSearch.focusSearchValue': wrapCommand(focusSearchValue$1),
+  'TextSearch.focusSearchValueNext': wrapCommand(focusSearchValueNext),
+  'TextSearch.getActions': wrapCommand(getActions),
+  'TextSearch.getActionsVirtualDom': wrapCommand(getActionsVirtualDom),
+  'TextSearch.getSearchDisplayResults': wrapCommand(getDisplayResults),
+  'TextSearch.getVirtualDom': wrapCommand(getSearchVirtualDom),
+  'TextSearch.handleClickAt': wrapCommand(handleClickAt),
+  'TextSearch.handleContextMenu': wrapCommand(handleContextMenu),
+  'TextSearch.handleFocusIn': wrapCommand(handleFocusIn),
+  'TextSearch.handleIconThemeChange': wrapCommand(handleIconThemeChange),
+  'TextSearch.handleInput': wrapCommand(handleInput),
+  'TextSearch.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
+  'TextSearch.handleScrollBarClick': wrapCommand(handleScrollBarClick),
+  'TextSearch.handleScrollBarMove': wrapCommand(handleScrollBarMove),
+  'TextSearch.handleWheel': wrapCommand(handleWheel),
+  'TextSearch.loadContent': wrapCommand(loadContent),
+  'TextSearch.refresh': wrapCommand(refresh),
+  'TextSearch.replaceAllAndPrompt': wrapCommand(replaceAllAndPrompt),
+  'TextSearch.replaceAll': wrapCommand(replaceAll),
+  'TextSearch.submit': wrapCommand(submit),
+  'TextSearch.toggleReplace': wrapCommand(toggleReplace),
+  // not wrapped
   'TextSearch.create': create,
-  'TextSearch.doRender': doRender,
-  'TextSearch.focusFirst': focusFirst,
-  'TextSearch.focusIndex': focusIndex,
-  'TextSearch.focusLast': focusLast,
-  'TextSearch.focusMatchCase': focusMatchCase,
-  'TextSearch.focusMatchCasePrevious': focusMatchCasePrevious,
-  'TextSearch.focusMatchWholeWord': focusMatchWholeWord,
-  'TextSearch.focusNext': focusNext,
-  'TextSearch.focusNextPage': focusNextPage,
-  'TextSearch.focusPreserveCase': focusPreserveCase,
-  'TextSearch.focusPrevious': focusPrevious,
-  'TextSearch.focusPreviousPage': focusPreviousPage,
-  'TextSearch.focusRegex': focusRegex,
-  'TextSearch.focusRegexNext': focusRegexNext,
-  'TextSearch.focusReplaceAll': focusReplaceAll,
-  'TextSearch.focusReplaceValue': focusReplaceValue,
-  'TextSearch.focusReplaceValueNext': focusReplaceValueNext,
-  'TextSearch.focusSearchValue': focusSearchValue,
-  'TextSearch.focusSearchValueNext': focusSearchValueNext,
-  'TextSearch.getActions': getActions,
-  'TextSearch.getActionsVirtualDom': getActionsVirtualDom,
-  'TextSearch.getSearchDisplayResults': getDisplayResults,
-  'TextSearch.getVirtualDom': getSearchVirtualDom,
-  'TextSearch.handleClickAt': handleClickAt,
-  'TextSearch.handleContextMenu': handleContextMenu,
-  'TextSearch.handleIconThemeChange': handleIconThemeChange,
-  'TextSearch.handleScrollBarCaptureLost': handleScrollBarCaptureLost,
-  'TextSearch.handleScrollBarClick': handleScrollBarClick,
-  'TextSearch.handleScrollBarMove': handleScrollBarMove,
-  'TextSearch.handleWheel': handleWheel,
-  'TextSearch.loadContent': loadContent,
-  'TextSearch.refresh': refresh,
-  'TextSearch.submit': submit,
+  'TextSearch.render': doRender,
+  'TextSearch.saveState': saveState,
+  // TODO needed?
   'TextSearch.textSearch': textSearch
 };
 
@@ -2618,7 +2983,7 @@ const requiresSocket = () => {
 const preparePrettyError = error => {
   return error;
 };
-const logError = error => {
+const logError = () => {
   // handled by renderer worker
 };
 const handleMessage = event => {