@lvce-editor/server 0.37.12 → 0.38.0

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

@@ -18,424 +18,628 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
-const FocusSearchInput = 21;
-const FocusSearchReplaceInput = 31;
-const FocusSearchMatchCase = 32;
-const FocusSearchRegex = 33;
-const FocusSearchWholeWord = 34;
-const FocusSearchReplaceAll = 35;
-const FocusSearchPreserveCase = 36;
-
-const focusMatchCase$1 = state => {
+const clearSearchResults$1 = state => {
   return {
     ...state,
-    focus: FocusSearchMatchCase
+    value: '',
+    items: [],
+    minLineY: 0,
+    maxLineY: 0,
+    message: ''
   };
 };
 
-const focusReplaceValue$1 = state => {
-  return {
-    ...state,
-    focus: FocusSearchReplaceInput
-  };
+const state$3 = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined
 };
-
-const focusSearchValue$1 = state => {
-  return {
-    ...state,
-    focus: FocusSearchInput
-  };
+const get$2 = () => {
+  return state$3.ipc;
+};
+const set$2 = ipc => {
+  state$3.ipc = ipc;
 };
 
-const focusSearchValueNext$1 = state => {
-  const {
-    replaceExpanded
-  } = state;
-  if (replaceExpanded) {
-    return focusReplaceValue$1(state);
+const Two = '2.0';
+let AssertionError$1 = class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
   }
-  return focusMatchCase$1(state);
 };
-
-const CheckBox = 'checkbox';
-const None = 'none';
-const Status = 'status';
-const Tree = 'tree';
-const TreeItem$1 = 'treeitem';
-
-const Chevron = 'Chevron';
-const CloseMaskIcon = 'MaskIcon MaskIconClose';
-const Empty = '';
-const FileIcon = 'FileIcon';
-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 = '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 HandleClick = 'handleClick';
-const HandleHeaderClick = 'handleHeaderClick';
-const HandleHeaderFocusIn = 'handleHeaderFocusIn';
-const HandleListBlur = 'handleListBlur';
-
-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 getSearchFieldButtonVirtualDom = button => {
-  const {
-    icon,
-    checked,
-    title
-  } = button;
-  return [{
-    type: Div,
-    className: `SearchFieldButton ${checked ? 'SearchFieldButtonChecked' : ''}`,
-    title,
-    role: CheckBox,
-    ariaChecked: checked,
-    tabIndex: 0,
-    childCount: 1
-  }, {
-    type: Div,
-    className: `MaskIcon ${icon}`,
-    childCount: 0
-  }];
+const getType$1 = value => {
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      return 'object';
+    case 'boolean':
+      return 'boolean';
+    default:
+      return 'unknown';
+  }
 };
-
-const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus = '') => {
-  const dom = [{
-    type: Div,
-    className: SearchField,
-    role: None,
-    childCount: 2
-  }, {
-    type: TextArea,
-    className: MultilineInputBox,
-    spellcheck: false,
-    autocapitalize: 'off',
-    autocorrect: 'off',
-    placeholder,
-    name,
-    onInput,
-    onFocus,
-    childCount: 0
-  }, {
-    type: Div,
-    className: SearchFieldButtons,
-    childCount: insideButtons.length
-  }, ...insideButtons.flatMap(getSearchFieldButtonVirtualDom)];
-  if (outsideButtons.length > 0) {
-    dom.unshift({
-      type: Div,
-      className: SearchFieldContainer,
-      role: None,
-      childCount: 1 + outsideButtons.length
-    });
-    dom.push(...outsideButtons.flatMap(getSearchFieldButtonVirtualDom));
+const number$1 = value => {
+  const type = getType$1(value);
+  if (type !== 'number') {
+    throw new AssertionError$1('expected value to be of type number');
   }
-  return dom;
 };
-
-const text = data => {
+const state$1 = {
+  callbacks: Object.create(null)
+};
+const set$1 = (id, fn) => {
+  state$1.callbacks[id] = fn;
+};
+const get$1 = id => {
+  return state$1.callbacks[id];
+};
+const remove = id => {
+  delete state$1.callbacks[id];
+};
+const state$2 = {
+  id: 0
+};
+const create$3 = () => {
+  return ++state$2.id;
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const registerPromise = () => {
+  const id = create$3();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set$1(id, resolve);
   return {
-    type: Text,
-    text: data,
-    childCount: 0
+    id,
+    promise
   };
 };
-
-const getSearchHeaderVirtualDom = (replaceExpanded, matchCase, matchWholeWord, useRegularExpression, detailsExpanded) => {
-  const dom = [{
-    type: Div,
-    className: SearchHeader,
-    role: None,
-    childCount: 2,
-    onClick: HandleHeaderClick,
-    onFocusIn: HandleHeaderFocusIn
-  }, {
-    type: Div,
-    className: SearchHeaderTop,
-    role: None,
-    childCount: 2
-  }, {
-    type: Button,
-    className: `IconButton SearchToggleButton ${replaceExpanded ? SearchToggleButtonExpanded : ''}`,
-    title: 'Toggle Replace',
-    ariaLabel: 'Toggle Replace',
-    ariaExpanded: replaceExpanded,
-    childCount: 1,
-    'data-command': 'toggleReplace'
-  }, {
-    type: Div,
-    className: `${MaskIcon} ${replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight}`,
-    childCount: 0
-  }, {
-    type: Div,
-    className: 'SearchHeaderTopRight',
-    role: None,
-    childCount: replaceExpanded ? 2 : 1
-  }, ...getSearchFieldVirtualDom('search-value', 'Search', 'handleInput', [{
-    icon: 'MaskIconCaseSensitive',
-    checked: matchCase,
-    title: 'Match Case'
-  }, {
-    icon: 'MaskIconWholeWord',
-    checked: matchWholeWord,
-    title: 'Match Whole Word'
-  }, {
-    icon: 'MaskIconRegex',
-    checked: useRegularExpression,
-    title: 'Use Regular Expression'
-  }], [])];
-  if (replaceExpanded) {
-    dom.push(...getSearchFieldVirtualDom('search-replace-value', 'Replace', 'handleReplaceInput', [{
-      icon: 'MaskIconPreserveCase',
-      checked: false,
-      title: 'Preserve Case'
-    }], [{
-      icon: 'MaskIconReplaceAll',
-      checked: false,
-      title: 'Replace All'
-    }]));
+const resolve = (id, args) => {
+  number$1(id);
+  const fn = get$1(id);
+  if (!fn) {
+    console.log(args);
+    warn(`callback ${id} may already be disposed`);
+    return;
   }
-  if (detailsExpanded) {
-    console.log({
-      detailsExpanded
-    });
-    dom[0].childCount++;
-    dom.push({
-      type: Div,
-      className: 'SearchHeaderDetails',
-      childCount: 4
-    }, text('files to include'), {
-      type: Input,
-      childCount: 0
-    }, text('files to exclude'), {
-      type: Input,
-      childCount: 0
-    });
+  fn(args);
+  remove(id);
+};
+const create$2 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
   }
-  return dom;
+}
+const NewLine$3 = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
 };
-
-const getBadgeVirtualDom = (className, count) => {
-  return [{
-    type: Div,
-    className: `Badge ${className}`,
-    childCount: 1
-  }, text(`${count}`)];
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
 };
-
-const getChevronDownVirtualDom = (extraClassName = '') => {
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$3 + parentStack;
+  }
+  return parentStack;
+};
+const joinLines$1 = lines => {
+  return lines.join(NewLine$3);
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const splitLines$2 = lines => {
+  return lines.split(NewLine$3);
+};
+const restoreJsonRpcError = error => {
+  if (error && error instanceof Error) {
+    return error;
+  }
+  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine$3 + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$3 + error.data.stack + NewLine$3 + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex$2(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      message: error.message,
+      data: error.stack
+    };
+  }
   return {
-    type: Div,
-    className: `${Chevron} MaskIconChevronDown ${extraClassName}`,
-    childCount: 0
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: prettyError.stack,
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
   };
 };
-
-const getFileIconVirtualDom = icon => {
+const create$1$1 = (message, error) => {
   return {
-    type: Img,
-    className: FileIcon,
-    src: icon,
-    role: None,
-    childCount: 0
+    jsonrpc: Two,
+    id: message.id,
+    error
   };
 };
+const getErrorResponse = (message, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(message, errorProperty);
+};
+const create$4 = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$4(message, resultProperty);
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    return getErrorResponse(message, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+const handleJsonRpcMessage = async (...args) => {
+  let message;
+  let ipc;
+  let execute;
+  let preparePrettyError;
+  let logError;
+  let resolve;
+  let requiresSocket;
+  if (args.length === 1) {
+    const arg = args[0];
+    message = arg.message;
+    ipc = arg.ipc;
+    execute = arg.execute;
+    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
+    logError = arg.logError || defaultLogError;
+    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
+    resolve = arg.resolve || defaultResolve;
+  } else {
+    ipc = args[0];
+    message = args[1];
+    execute = args[2];
+    resolve = args[3];
+    preparePrettyError = args[4];
+    logError = args[5];
+    requiresSocket = args[6];
+  }
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+const invoke$2 = async (ipc, method, ...params) => {
+  const {
+    message,
+    promise
+  } = create$2(method, params);
+  ipc.send(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
 
-const File$1 = 1;
-const Match = 2;
+const invoke$1 = (method, ...params) => {
+  const ipc = get$2();
+  return invoke$2(ipc, method, ...params);
+};
+const listen$2 = ipc => {
+  set$2(ipc);
+};
 
-const PaddingRight = '12px';
+const copy = async state => {
+  const {
+    items,
+    listFocusedIndex
+  } = state;
+  if (listFocusedIndex === -1) {
+    return state;
+  }
+  const item = items[listFocusedIndex];
+  await invoke$1('ClipBoard.writeText', item.text);
+  return state;
+};
 
-const deleted = {
-  type: Del,
-  className: HighlightDeleted,
-  childCount: 1
+const ListItem = 22;
+
+const User = 1;
+const Script = 2;
+
+const minimumSliderSize = 20;
+
+const states = Object.create(null);
+const get = uid => {
+  return states[uid];
 };
-const inserted = {
-  type: Ins,
-  className: HighlightInserted,
-  childCount: 1
+const set = (uid, state) => {
+  states[uid] = state;
 };
-const highlighted = {
-  type: Span,
-  className: Highlight,
-  childCount: 1
+
+const create$1 = ({
+  itemHeight,
+  headerHeight = 0,
+  minimumSliderSize = 20
+}) => {
+  return {
+    deltaY: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    finalDeltaY: 0,
+    itemHeight,
+    headerHeight,
+    items: [],
+    minimumSliderSize,
+    focusedIndex: -1,
+    touchOffsetY: 0,
+    touchTimeStamp: 0,
+    touchDifference: 0,
+    scrollBarHeight: 0,
+    scrollBarActive: false
+  };
 };
-const getLabelVirtualDom = (displayText, matchLength, matchStart, replacement) => {
-  const dom = [];
-  const label = {
-    type: Div,
-    className: Label + ' Grow',
-    childCount: 1
+
+const Empty$1 = 0;
+const FocusSearchInput = 21;
+const FocusSearchReplaceInput = 31;
+const FocusSearchMatchCase = 32;
+const FocusSearchRegex = 33;
+const FocusSearchWholeWord = 34;
+const FocusSearchReplaceAll = 35;
+const FocusSearchPreserveCase = 36;
+
+const create = (uid, x, y, width, height, workspacePath) => {
+  const state = {
+    uid,
+    searchResults: [],
+    stats: {},
+    searchId: -1,
+    value: '',
+    disposed: false,
+    fileCount: 0,
+    x,
+    y,
+    width,
+    height,
+    ...create$1({
+      itemHeight: ListItem,
+      minimumSliderSize: minimumSliderSize,
+      headerHeight: 61 // TODO
+    }),
+    threads: 0,
+    replaceExpanded: false,
+    useRegularExpression: false,
+    matchCase: false,
+    matchWholeWord: false,
+    replacement: '',
+    matchCount: 0,
+    listFocused: false,
+    listFocusedIndex: -1,
+    inputSource: User,
+    workspacePath: workspacePath,
+    includeValue: '',
+    excludeValue: '',
+    detailsExpanded: false,
+    focus: Empty$1,
+    loaded: false,
+    message: '',
+    collapsedPaths: []
   };
-  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));
-    }
-  } else {
-    dom.push(text(displayText));
-  }
-  return dom;
+  set(uid, state);
 };
-const renderRow = rowInfo => {
-  // @ts-ignore
-  const {
-    top,
-    type,
-    matchStart,
-    matchLength,
-    text: displayText,
-    title,
-    icon,
-    setSize,
-    posInSet,
-    depth,
-    replacement,
-    matchCount,
-    focused
-  } = rowInfo;
-  const treeItem = {
-    type: Div,
-    role: TreeItem$1,
-    className: TreeItem,
-    title,
-    ariaSetSize: setSize,
-    ariaLevel: depth,
-    ariaPosInSet: posInSet,
-    ariaLabel: title,
-    ariaDescription: '',
-    childCount: 1,
-    paddingLeft: `${Number(depth) + 1}rem`,
-    // TODO use classname and dynamic css
-    paddingRight: PaddingRight
+
+const focusMatchCase$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchMatchCase
   };
-  if (focused) {
-    treeItem.className += ' ' + TreeItemActive;
-  }
-  switch (type) {
-    case File$1:
-      treeItem.ariaExpanded = 'true';
-      break;
-  }
-  const dom = [];
-  dom.push(treeItem);
-  if (type === File$1) {
-    treeItem.childCount += 2;
-    dom.push(getChevronDownVirtualDom(), getFileIconVirtualDom(icon));
-  }
-  dom.push(...getLabelVirtualDom(displayText, matchLength, matchStart, replacement));
-  if (matchCount) {
-    treeItem.childCount++;
-    dom.push(...getBadgeVirtualDom(SourceControlBadge, matchCount));
+};
+
+const focusReplaceValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchReplaceInput
+  };
+};
+
+const focusSearchValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchInput
+  };
+};
+
+const focusSearchValueNext$1 = state => {
+  const {
+    replaceExpanded
+  } = state;
+  if (replaceExpanded) {
+    return focusReplaceValue$1(state);
   }
-  treeItem.childCount++;
-  dom.push({
-    type: Div,
-    className: SearchRemove,
-    childCount: 1
-  }, {
-    type: Div,
-    className: CloseMaskIcon,
+  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
-  });
-  return dom;
+  };
 };
-const getSearchResultsVirtualDom = visibleItems => {
-  return visibleItems.flatMap(renderRow);
+
+const getActionButtonVirtualDom = action => {
+  const {
+    id,
+    icon,
+    command
+  } = action;
+  return [{
+    type: Button,
+    className: IconButton,
+    title: id,
+    'data-command': command,
+    childCount: 1
+  }, getIconVirtualDom(icon)];
 };
 
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
+const getActionVirtualDom = action => {
+  switch (action.type) {
+    case Button$1:
+      return getActionButtonVirtualDom(action);
+    default:
+      return [];
+  }
 };
 
-const getSearchVirtualDom = (visibleItems, replaceExpanded, matchCase, matchWholeWord, useRegularExpression, message, detailsExpanded, focusOutline) => {
-  /**
-   * @type {any[]}
-   */
-  const dom = [];
-  dom.push({
-    type: Div,
-    className: mergeClassNames(Viewlet, Search),
-    childCount: 2
-  });
-  dom.push(...getSearchHeaderVirtualDom(replaceExpanded, matchCase, matchWholeWord, useRegularExpression, detailsExpanded));
-  dom.push({
-    type: Div,
-    className: ViewletSearchMessage,
-    role: Status,
-    tabIndex: 0,
-    childCount: 1
-  }, text(message));
-  dom.push({
+const getActionsVirtualDom = actions => {
+  return [{
     type: Div,
-    className: mergeClassNames(Viewlet, List, focusOutline ? FocusOutline : Empty),
-    role: Tree,
-    tabIndex: 0,
-    childCount: visibleItems.length,
-    onClick: HandleClick,
-    onBlur: HandleListBlur
-  });
-  dom.push(...getSearchResultsVirtualDom(visibleItems));
-  return dom;
+    className: Actions,
+    role: ToolBar,
+    childCount: actions.length
+  }, ...actions.flatMap(getActionVirtualDom)];
 };
 
-const state$3 = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined
-};
-const get$1 = () => {
-  return state$3.ipc;
-};
-const set$1 = ipc => {
-  state$3.ipc = ipc;
-};
+const ClearAll = 'ClearAll';
+const CollapseAll = 'CollapseAll';
+const ListFlat = 'ListFlat';
+const NewFile = 'NewFile';
+const Refresh = 'Refresh';
 
-const Two = '2.0';
-let AssertionError$1 = class AssertionError extends Error {
+class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-};
-const getType$1 = value => {
+}
+const getType = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -457,440 +661,986 @@ const getType$1 = value => {
       return 'unknown';
   }
 };
+const object = value => {
+  const type = getType(value);
+  if (type !== 'object') {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
 const number = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'number') {
-    throw new AssertionError$1('expected value to be of type number');
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const string = value => {
+  const type = getType(value);
+  if (type !== 'string') {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    // @ts-ignore
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  NoResults: 'No results found',
+  Oneresult: '1 result in 1 file',
+  ManyResultsInOneFile: '{PH1} results in 1 file',
+  ManyResultsInManyFiles: '{PH1} results in {PH2} files',
+  ReplaceAll: 'Replace All',
+  Replace: 'Replace',
+  ConfirmReplaceAll: 'Replace All?',
+  ConfirmReplaceOneOccurrenceInOneFile: "Replace 1 occurrence across 1 file with '{PH1}'",
+  ConfirmReplaceOneOccurrenceInOneFileNoValue: 'Replace 1 occurrence across 1 file',
+  ConfirmReplaceManyOccurrencesInOneFile: "Replace {PH1} occurrences across 1 file with '{PH2}'",
+  ConfirmReplaceManyOccurrencesInOneFileNoValue: 'Replace {PH1} occurrences across 1 file',
+  ConfirmReplaceManyOccurrencesInManyFiles: "Replace {PH1} occurrences across {PH2} files with '{PH3}'",
+  ConfirmReplaceManyOccurrencesInManyFilesNoValue: 'Replace {PH1} occurrences across {PH2} files',
+  ReplacedOneOccurrenceInOneFile: "Replaced 1 occurrence across 1 file with '{PH1}'",
+  ReplacedManyOccurrencesInOneFile: "Replaced {PH1} occurrences across 1 file with '{PH2}'",
+  ReplacedManyOccurrencesInManyFiles: "Replaced {PH1} occurrences across {PH2} files with '{PH3}'",
+  CopyPath: 'Copy Path',
+  Dismiss: 'Dismiss',
+  Refresh: 'Refresh',
+  ClearSearchResults: 'Clear Search Results',
+  OpenNewSearchEditor: 'Open New Search Editor',
+  ViewAsTree: 'View as Tree',
+  CollapseAll: 'Collapse All'
+};
+const noResults = () => {
+  return i18nString(UiStrings.NoResults);
+};
+const oneResult = () => {
+  return i18nString(UiStrings.Oneresult);
+};
+const manyResultsInOneFile = resultCount => {
+  return i18nString(UiStrings.ManyResultsInOneFile, {
+    PH1: resultCount
+  });
+};
+const manyResultsInManyFiles = (resultCount, fileResultCount) => {
+  return i18nString(UiStrings.ManyResultsInManyFiles, {
+    PH1: resultCount,
+    PH2: fileResultCount
+  });
+};
+const refresh$1 = () => {
+  return i18nString(UiStrings.Refresh);
+};
+const clearSearchResults = () => {
+  return i18nString(UiStrings.ClearSearchResults);
+};
+const openNewSearchEditor = () => {
+  return i18nString(UiStrings.OpenNewSearchEditor);
+};
+const viewAsTree = () => {
+  return i18nString(UiStrings.ViewAsTree);
+};
+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 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
+  }
+  return `/${relativePath}`; // TODO support windows paths
+};
+
+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);
+      return {
+        title: absolutePath,
+        type: File$1,
+        text: baseName,
+        icon: getFileIcon(),
+        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,
+        replacement,
+        depth: 1,
+        matchCount: 0,
+        focused
+      };
+    default:
+      throw new Error('unexpected search result type');
+  }
+};
+
+const getFilteredResults = (results, collapsedPaths) => {
+  const filteredResults = [];
+  let isExcluded = false;
+  for (const result of results) {
+    if (result.type === File$1) {
+      if (collapsedPaths.includes(result.text)) {
+        isExcluded = true;
+      } else {
+        isExcluded = false;
+      }
+    }
+    if (!isExcluded) {
+      filteredResults.push(result);
+    }
+  }
+  return filteredResults;
+};
+const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, collapsedPaths, focusedIndex) => {
+  const displayResults = [];
+  const filteredResults = getFilteredResults(results, collapsedPaths);
+  const setSize = resultCount;
+  const searchTermLength = searchTerm.length;
+  let fileResult = {
+    matchCount: 0
+  };
+  for (let i = minLineY; i < maxLineY; i++) {
+    const result = filteredResults[i];
+    const displayResult = getDisplayResult(result, itemHeight, i, setSize, searchTermLength, replacement, focusedIndex);
+    displayResults.push(displayResult);
+    if (result.type === File$1) {
+      fileResult = displayResult;
+    } else {
+      fileResult.matchCount++;
+    }
+  }
+  return displayResults;
+};
+
+const HandleClick = 'handleClick';
+const HandleHeaderClick = 'handleHeaderClick';
+const HandleHeaderFocusIn = 'handleHeaderFocusIn';
+const HandleListBlur = 'handleListBlur';
+
+const getSearchFieldButtonVirtualDom = button => {
+  const {
+    icon,
+    checked,
+    title
+  } = button;
+  return [{
+    type: Div,
+    className: `SearchFieldButton ${checked ? 'SearchFieldButtonChecked' : ''}`,
+    title,
+    role: CheckBox,
+    ariaChecked: checked,
+    tabIndex: 0,
+    childCount: 1
+  }, {
+    type: Div,
+    className: `MaskIcon ${icon}`,
+    childCount: 0
+  }];
+};
+
+const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus = '') => {
+  const dom = [{
+    type: Div,
+    className: SearchField,
+    role: None,
+    childCount: 2
+  }, {
+    type: TextArea,
+    className: MultilineInputBox,
+    spellcheck: false,
+    autocapitalize: 'off',
+    autocorrect: 'off',
+    placeholder,
+    name,
+    onInput,
+    onFocus,
+    childCount: 0
+  }, {
+    type: Div,
+    className: SearchFieldButtons,
+    childCount: insideButtons.length
+  }, ...insideButtons.flatMap(getSearchFieldButtonVirtualDom)];
+  if (outsideButtons.length > 0) {
+    dom.unshift({
+      type: Div,
+      className: SearchFieldContainer,
+      role: None,
+      childCount: 1 + outsideButtons.length
+    });
+    dom.push(...outsideButtons.flatMap(getSearchFieldButtonVirtualDom));
+  }
+  return dom;
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const getSearchHeaderVirtualDom = (replaceExpanded, matchCase, matchWholeWord, useRegularExpression, detailsExpanded) => {
+  const dom = [{
+    type: Div,
+    className: SearchHeader,
+    role: None,
+    childCount: 2,
+    onClick: HandleHeaderClick,
+    onFocusIn: HandleHeaderFocusIn
+  }, {
+    type: Div,
+    className: SearchHeaderTop,
+    role: None,
+    childCount: 2
+  }, {
+    type: Button,
+    className: `IconButton SearchToggleButton ${replaceExpanded ? SearchToggleButtonExpanded : ''}`,
+    title: 'Toggle Replace',
+    ariaLabel: 'Toggle Replace',
+    ariaExpanded: replaceExpanded,
+    childCount: 1,
+    'data-command': 'toggleReplace'
+  }, {
+    type: Div,
+    className: `${MaskIcon} ${replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight}`,
+    childCount: 0
+  }, {
+    type: Div,
+    className: 'SearchHeaderTopRight',
+    role: None,
+    childCount: replaceExpanded ? 2 : 1
+  }, ...getSearchFieldVirtualDom('search-value', 'Search', 'handleInput', [{
+    icon: 'MaskIconCaseSensitive',
+    checked: matchCase,
+    title: 'Match Case'
+  }, {
+    icon: 'MaskIconWholeWord',
+    checked: matchWholeWord,
+    title: 'Match Whole Word'
+  }, {
+    icon: 'MaskIconRegex',
+    checked: useRegularExpression,
+    title: 'Use Regular Expression'
+  }], [])];
+  if (replaceExpanded) {
+    dom.push(...getSearchFieldVirtualDom('search-replace-value', 'Replace', 'handleReplaceInput', [{
+      icon: 'MaskIconPreserveCase',
+      checked: false,
+      title: 'Preserve Case'
+    }], [{
+      icon: 'MaskIconReplaceAll',
+      checked: false,
+      title: 'Replace All'
+    }]));
+  }
+  if (detailsExpanded) {
+    console.log({
+      detailsExpanded
+    });
+    dom[0].childCount++;
+    dom.push({
+      type: Div,
+      className: 'SearchHeaderDetails',
+      childCount: 4
+    }, text('files to include'), {
+      type: Input,
+      childCount: 0
+    }, text('files to exclude'), {
+      type: Input,
+      childCount: 0
+    });
   }
+  return dom;
 };
-const state$1 = {
-  callbacks: Object.create(null)
-};
-const set = (id, fn) => {
-  state$1.callbacks[id] = fn;
-};
-const get = id => {
-  return state$1.callbacks[id];
-};
-const remove = id => {
-  delete state$1.callbacks[id];
-};
-const state$2 = {
-  id: 0
-};
-const create$3 = () => {
-  return ++state$2.id;
-};
-const warn = (...args) => {
-  console.warn(...args);
+
+const getBadgeVirtualDom = (className, count) => {
+  return [{
+    type: Div,
+    className: `Badge ${className}`,
+    childCount: 1
+  }, text(`${count}`)];
 };
-const registerPromise = () => {
-  const id = create$3();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set(id, resolve);
+
+const getChevronDownVirtualDom = (extraClassName = '') => {
   return {
-    id,
-    promise
+    type: Div,
+    className: `${Chevron} MaskIconChevronDown ${extraClassName}`,
+    childCount: 0
   };
 };
-const resolve = (id, args) => {
-  number(id);
-  const fn = get(id);
-  if (!fn) {
-    console.log(args);
-    warn(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(args);
-  remove(id);
-};
-const create$2 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
+
+const getFileIconVirtualDom = icon => {
   return {
-    message,
-    promise
+    type: Img,
+    className: FileIcon,
+    src: icon,
+    role: None,
+    childCount: 0
   };
 };
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
-  }
-}
-const NewLine$3 = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case DomException:
-        return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case ReferenceError$1:
-        return ReferenceError;
-      default:
-        return Error;
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
-  }
-  return Error;
-};
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
-  }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      error.name = name;
-    }
-    return error;
-  }
-  return new ErrorConstructor(message);
-};
-const getNewLineIndex$2 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$3, startIndex);
-};
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$3 + parentStack;
-  }
-  return parentStack;
+
+const deleted = {
+  type: Del,
+  className: HighlightDeleted,
+  childCount: 1
 };
-const joinLines$1 = lines => {
-  return lines.join(NewLine$3);
+const inserted = {
+  type: Ins,
+  className: HighlightInserted,
+  childCount: 1
 };
-const MethodNotFound = -32601;
-const Custom = -32001;
-const splitLines$2 = lines => {
-  return lines.split(NewLine$3);
+const highlighted = {
+  type: Span,
+  className: Highlight,
+  childCount: 1
 };
-const restoreJsonRpcError = error => {
-  if (error && error instanceof Error) {
-    return error;
-  }
-  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$3 + currentStack;
-    return restoredError;
-  }
-  if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine$3 + error.data.stack + NewLine$3 + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
+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 {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex$2(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
+      label.childCount = 3;
+      dom.push(text(before), highlighted, text(highlight), text(after));
     }
-    return restoredError;
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
+  } else {
+    dom.push(text(displayText));
   }
-  return new Error(`JsonRpc Error: ${error}`);
+  return dom;
 };
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
+
+const PaddingRight = '12px';
+
+const getSearchResultVirtualDom = rowInfo => {
+  const {
+    type,
+    matchStart,
+    matchLength,
+    text: displayText,
+    title,
+    icon,
+    setSize,
+    posInSet,
+    depth,
+    replacement,
+    matchCount,
+    focused
+  } = rowInfo;
+  const treeItem = {
+    type: Div,
+    role: TreeItem$1,
+    className: TreeItem,
+    title,
+    ariaSetSize: setSize,
+    ariaLevel: depth,
+    ariaPosInSet: posInSet,
+    ariaLabel: title,
+    ariaDescription: '',
+    childCount: 1,
+    paddingLeft: `${Number(depth) + 1}rem`,
+    // TODO use classname and dynamic css
+    paddingRight: PaddingRight
+  };
+  if (focused) {
+    treeItem.className += ' ' + TreeItemActive;
   }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
+  switch (type) {
+    case File$1:
+      treeItem.ariaExpanded = 'true';
+      break;
   }
-  throw new JsonRpcError('unexpected response message');
-};
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getErrorType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
+  const dom = [];
+  dom.push(treeItem);
+  if (type === File$1) {
+    treeItem.childCount += 2;
+    dom.push(getChevronDownVirtualDom(), getFileIconVirtualDom(icon));
   }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
+  dom.push(...getLabelVirtualDom(displayText, matchLength, matchStart, replacement));
+  if (matchCount) {
+    treeItem.childCount++;
+    dom.push(...getBadgeVirtualDom(SourceControlBadge, matchCount));
   }
-  return undefined;
+  treeItem.childCount++;
+  dom.push({
+    type: Div,
+    className: SearchRemove,
+    childCount: 1
+  }, {
+    type: Div,
+    className: CloseMaskIcon,
+    childCount: 0
+  });
+  return dom;
 };
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      message: error.message,
-      data: error.stack
-    };
-  }
-  return {
-    code: Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
-      code: prettyError.code,
-      name: prettyError.name
-    }
-  };
+
+const getSearchResultsVirtualDom = visibleItems => {
+  return visibleItems.flatMap(getSearchResultVirtualDom);
 };
-const create$1 = (message, error) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error
-  };
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(message, errorProperty);
+
+const getSearchVirtualDom = (visibleItems, replaceExpanded, matchCase, matchWholeWord, useRegularExpression, message, detailsExpanded, focusOutline) => {
+  /**
+   * @type {any[]}
+   */
+  const dom = [];
+  dom.push({
+    type: Div,
+    className: mergeClassNames(Viewlet, Search$1),
+    childCount: 2
+  });
+  dom.push(...getSearchHeaderVirtualDom(replaceExpanded, matchCase, matchWholeWord, useRegularExpression, detailsExpanded));
+  dom.push({
+    type: Div,
+    className: ViewletSearchMessage,
+    role: Status,
+    tabIndex: 0,
+    childCount: 1
+  }, text(message));
+  dom.push({
+    type: Div,
+    className: mergeClassNames(Viewlet, List, focusOutline ? FocusOutline : Empty),
+    role: Tree,
+    tabIndex: 0,
+    childCount: visibleItems.length,
+    onClick: HandleClick,
+    onBlur: HandleListBlur
+  });
+  dom.push(...getSearchResultsVirtualDom(visibleItems));
+  return dom;
 };
-const create = (message, result) => {
+
+const handleIconThemeChange = state => {
+  const {
+    items
+  } = state;
+  const newItems = [...items];
   return {
-    jsonrpc: Two,
-    id: message.id,
-    result: result ?? null
+    ...state,
+    items: newItems
   };
 };
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create(message, resultProperty);
+
+const first = () => {
+  return 0;
 };
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
-  try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
-  }
+const last = items => {
+  return items.length - 1;
 };
-const defaultPreparePrettyError = error => {
-  return error;
+const next = (items, index) => {
+  return (index + 1) % items.length;
 };
-const defaultLogError = () => {
-  // ignore
+const previous = (items, index) => {
+  return index === 0 ? items.length - 1 : index - 1;
 };
-const defaultRequiresSocket = () => {
-  return false;
+
+// TODO optimize this function to return the minimum number
+// of visible items needed, e.g. when not scrolled 5 items with
+// 20px fill 100px but when scrolled 6 items are needed
+const getNumberOfVisibleItems = (listHeight, itemHeight) => {
+  return Math.ceil(listHeight / itemHeight) + 1;
 };
-const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
-  if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+
+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;
   }
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
+  number(itemHeight);
+  if (index === -1) {
+    return {
+      ...state,
+      focusedIndex: -1,
+      focused: true
+    };
   }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-    return;
+  const listHeight = height - headerHeight;
+  if (index < minLineY + 1) {
+    return focusIndexScrollUp(state, index, listHeight, itemHeight, itemsLength);
   }
-  throw new JsonRpcError('unexpected message');
+  if (index >= maxLineY - 1) {
+    return focusIndexScrollDown(state, index, listHeight, itemHeight, itemsLength);
+  }
+  return {
+    ...state,
+    focusedIndex: index,
+    focused: true
+  };
 };
-const invoke$2 = async (ipc, method, ...params) => {
+
+const focusFirst = state => {
+  const firstIndex = first();
+  return focusIndex(state, firstIndex);
+};
+
+const focusLast = state => {
   const {
-    message,
-    promise
-  } = create$2(method, params);
-  ipc.send(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+    items
+  } = state;
+  const lastIndex = last(items);
+  return focusIndex(state, lastIndex);
 };
 
-const invoke$1 = (method, ...params) => {
-  const ipc = get$1();
-  return invoke$2(ipc, method, ...params);
+const focusNext = state => {
+  const {
+    focusedIndex,
+    items
+  } = state;
+  const nextIndex = next(items, focusedIndex);
+  return focusIndex(state, nextIndex);
 };
-const listen$2 = ipc => {
-  set$1(ipc);
+
+// 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];
+  }
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i];
+  }
+};
+const push = (array, newItems) => {
+  insertInto(array, array.length, newItems);
+};
+const isLastIndex = (array, index) => {
+  return index === array.length - 1;
+};
+const lastIndex = array => {
+  return array.length - 1;
 };
 
-const focusSearchValue = state => {
-  return {
-    ...state,
-    focus: FocusSearchInput
-  };
+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 focusSearchValueNext = state => {
+
+const focusPreviousPage = state => {
   const {
-    replaceExpanded
+    focusedIndex,
+    minLineY,
+    maxLineY
   } = state;
-  if (replaceExpanded) {
-    return focusReplaceValue(state);
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
   }
-  return focusMatchCase(state);
+  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
+  return focusIndex(state, indexPreviousPage);
 };
-const focusMatchCasePrevious = state => {
+
+const focusPrevious = state => {
   const {
-    replaceExpanded
+    focusedIndex,
+    items
   } = state;
-  if (replaceExpanded) {
-    return focusReplaceValue(state);
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
   }
-  return focusSearchValue(state);
+  const previousIndex = previous(items, focusedIndex);
+  return focusIndex(state, previousIndex);
 };
-const focusReplaceValueNext = state => {
-  return focusMatchCase(state);
+
+const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight) => {
+  const relativeY = eventY - y + deltaY;
+  const index = Math.floor(relativeY / itemHeight);
+  return index;
 };
-const focusRegexNext = state => {
-  return focusPreserveCase(state);
+
+const openUri = async (path, focus = true, props = {}) => {
+  await invoke$1(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
-const focusReplaceValue = state => {
-  return {
-    ...state,
-    focus: FocusSearchReplaceInput
-  };
+
+const getFileIndex = (items, index) => {
+  for (let i = index; i >= 0; i--) {
+    const item = items[i];
+    if (item.type === File$1) {
+      return i;
+    }
+  }
+  return -1;
 };
-const focusMatchCase = state => {
+const selectIndexFile = async (state, searchResult, index) => {
+  const {
+    collapsedPaths
+  } = state;
+  const path = getAbsolutePath(searchResult.text);
+  string(path);
   return {
     ...state,
-    focus: FocusSearchMatchCase
+    collapsedPaths: [...collapsedPaths, path],
+    listFocusedIndex: index,
+    listFocused: true
   };
 };
-const focusPreserveCase = state => {
+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,
-    focus: FocusSearchPreserveCase
+    listFocusedIndex: index,
+    listFocused: false
   };
 };
-const focusMatchWholeWord = state => {
+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 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,
-    focus: FocusSearchWholeWord
+    scrollBarActive: false
   };
 };
-const focusRegex = state => {
+
+/**
+ *
+ * @param {number} size
+ * @param {number} contentSize
+ * @param {number} minimumSliderSize
+ * @returns
+ */
+const getScrollBarSize = (size, contentSize, minimumSliderSize) => {
+  if (size >= contentSize) {
+    return 0;
+  }
+  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 {
+      percent: 0,
+      handleOffset: relativeY
+    };
+  }
+  if (relativeY <= height - halfScrollBarHeight) {
+    // clicked in middle
+    return {
+      percent: (relativeY - halfScrollBarHeight) / (height - scrollBarHeight),
+      handleOffset: halfScrollBarHeight
+    };
+  }
+  // clicked at bottom
   return {
-    ...state,
-    focus: FocusSearchRegex
+    percent: 1,
+    handleOffset: scrollBarHeight - height + relativeY
   };
 };
-const focusReplaceAll = state => {
+
+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,
-    focus: FocusSearchReplaceAll
+    deltaY: newDeltaY,
+    minLineY,
+    maxLineY
   };
 };
 
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
+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 getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
+  const {
+    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 string = value => {
-  const type = getType(value);
-  if (type !== 'string') {
-    throw new AssertionError('expected value to be of type string');
+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\-]+):\/\//;
@@ -1355,35 +2105,12 @@ const getDirectoryHandle = async uri => {
   return getDirectoryHandle(dirname$1);
 };
 
-// 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];
-  }
-  for (let i = 0; i < newItemsLength; i++) {
-    array[i + start] = newItems[i];
-  }
-};
-const push = (array, newItems) => {
-  insertInto(array, array.length, newItems);
-};
-
 const NotReadableError = 'NotReadableError';
 
 const isNotReadableError = error => {
   return error && error.name === NotReadableError;
 };
 
-/**
- *
- * @param {FileSystemFileHandle} handle
- * @returns
- */
 const getFile = handle => {
   return handle.getFile();
 };
@@ -1456,7 +2183,6 @@ const textSearch$3 = async (scheme, root, query) => {
   const relativeRoot = root.slice('html://'.length);
   const handle = await getDirectoryHandle(relativeRoot);
   if (!handle) {
-    // @ts-ignore
     throw new VError$1(`Folder not found ${relativeRoot}`);
   }
   const all = [];
@@ -1546,15 +2272,322 @@ const textSearch = async (root, query, options, assetDir) => {
   return results;
 };
 
+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 handleUpdate = async (state, update) => {
+  const partialNewState = {
+    ...state,
+    ...update
+  };
+  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);
+    return {
+      ...partialNewState,
+      message: `${error}`,
+      items: [],
+      matchCount: 0,
+      fileCount: 0,
+      minLineY: 0,
+      maxLineY: 0
+    };
+  }
+};
+
+const getSavedValue = savedState => {
+  if (savedState && savedState.value) {
+    return savedState.value;
+  }
+  return '';
+};
+const getSavedReplaceExpanded = savedState => {
+  if (savedState && 'replaceExpanded' in savedState) {
+    return savedState.replaceExpanded;
+  }
+  return false;
+};
+const getSavedCollapsedPaths = savedState => {
+  if (savedState && 'collapsedPaths' in savedState && Array.isArray(savedState.collapsedPaths) && savedState.collapsedPaths.every(path => typeof path === 'string')) {
+    return savedState.collapsedPaths;
+  }
+  return [];
+};
+const getThreads = () => {
+  return 1;
+};
+const loadContent = async (uid, savedState) => {
+  const state = get(uid);
+  const savedValue = getSavedValue(savedState);
+  const savedReplaceExpanded = getSavedReplaceExpanded(savedState);
+  const savedCollapsedPaths = getSavedCollapsedPaths(savedState);
+  const threads = getThreads();
+  if (savedValue) {
+    return handleUpdate(state, {
+      value: savedValue,
+      threads,
+      replaceExpanded: savedReplaceExpanded,
+      inputSource: Script,
+      collapsedPaths: savedCollapsedPaths
+    });
+  }
+  return {
+    ...state,
+    threads,
+    replaceExpanded: savedReplaceExpanded,
+    loaded: true
+  };
+};
+
+const refresh = state => {
+  return handleUpdate(state, {});
+};
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.replacement === newState.replacement && oldState.replaceExpanded === newState.replaceExpanded && oldState.matchCase === newState.matchCase && oldState.matchWholeWord === newState.matchWholeWord && oldState.useRegularExpression === newState.useRegularExpression && oldState.message === newState.message && oldState.detailsExpanded === newState.detailsExpanded && oldState.loaded === newState.loaded && oldState.collapsedPaths === newState.collapsedPaths && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.listFocused === newState.listFocused;
+  },
+  apply(oldState, newState) {
+    const displayResults = getDisplayResults(newState.items, newState.itemHeight, newState.fileCount, newState.value, newState.minLineY, newState.maxLineY, newState.replacement, newState.collapsedPaths, newState.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];
+  }
+};
+const getSelector = focusKey => {
+  switch (focusKey) {
+    case FocusSearchInput:
+      return '[name="search-value"]';
+    case FocusSearchReplaceInput:
+      return '[name="search-replace-value"]';
+    case FocusSearchMatchCase:
+      return '[title="Match Case"]';
+    case FocusSearchPreserveCase:
+      return '[title="Preserve Case"]';
+    case FocusSearchRegex:
+      return '[title="Use Regular Expression"]';
+    default:
+      return '';
+  }
+};
+const renderFocus = {
+  isEqual(oldState, newState) {
+    return oldState.focus === newState.focus;
+  },
+  apply(newState) {
+    const selector = getSelector(newState.focus);
+    return ['setFocus', selector];
+  }
+};
+const render = [renderItems, renderFocus];
+const doRender = (oldState, newState) => {
+  const commands = [];
+  for (const fn of render) {
+    if (!fn.isEqual(oldState, newState)) {
+      commands.push(fn.apply(oldState, newState));
+    }
+  }
+  return commands;
+};
+
+const focusSearchValue = state => {
+  return {
+    ...state,
+    focus: FocusSearchInput
+  };
+};
+const focusSearchValueNext = state => {
+  const {
+    replaceExpanded
+  } = state;
+  if (replaceExpanded) {
+    return focusReplaceValue(state);
+  }
+  return focusMatchCase(state);
+};
+const focusMatchCasePrevious = state => {
+  const {
+    replaceExpanded
+  } = state;
+  if (replaceExpanded) {
+    return focusReplaceValue(state);
+  }
+  return focusSearchValue(state);
+};
+const focusReplaceValueNext = state => {
+  return focusMatchCase(state);
+};
+const focusRegexNext = state => {
+  return focusPreserveCase(state);
+};
+const focusReplaceValue = state => {
+  return {
+    ...state,
+    focus: FocusSearchReplaceInput
+  };
+};
+const focusMatchCase = state => {
+  return {
+    ...state,
+    focus: FocusSearchMatchCase
+  };
+};
+const focusPreserveCase = state => {
+  return {
+    ...state,
+    focus: FocusSearchPreserveCase
+  };
+};
+const focusMatchWholeWord = state => {
+  return {
+    ...state,
+    focus: FocusSearchWholeWord
+  };
+};
+const focusRegex = state => {
+  return {
+    ...state,
+    focus: FocusSearchRegex
+  };
+};
+const focusReplaceAll = state => {
+  return {
+    ...state,
+    focus: FocusSearchReplaceAll
+  };
+};
+
+const submit = state => {
+  return handleUpdate(state, {
+    value: state.value,
+    inputSource: User
+  });
+};
+
+const Keyboard = -1;
+
+const show = async (x, y, id, ...args) => {
+  // TODO ask renderer worker to show context menu
+  number(x);
+  number(y);
+  number(id);
+  // TODO
+};
+
+const Search = 18;
+
+const handleContextMenuKeyboard = async state => {
+  const x = state.x; // TODO
+  const y = state.y; // TODO
+  await show(x, y, Search);
+  return state;
+};
+
+const handleContextMenuMouseAt = async (state, x, y) => {
+  await show(x, y, Search);
+  return state;
+};
+
+const handleContextMenu = (state, button, x, y) => {
+  switch (button) {
+    case Keyboard:
+      return handleContextMenuKeyboard(state);
+    default:
+      return handleContextMenuMouseAt(state, x, y);
+  }
+};
+
 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.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,
@@ -1562,7 +2595,20 @@ const commandMap = {
   '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.textSearch': textSearch
 };