@lvce-editor/static-server 0.40.0

package/static/c76328b/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -0,0 +1,4272 @@
+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$3 = '\n';
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
+};
+const mergeStacks$1 = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$2(parent);
+  const childNewLineIndex = getNewLineIndex$2(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;
+    }
+  }
+};
+
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+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 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(value);
+  if (type !== 'number') {
+    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') {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
+const Two = '2.0';
+const create$4 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const state$4 = {
+  callbacks: Object.create(null)
+};
+const set$1 = (id, fn) => {
+  state$4.callbacks[id] = fn;
+};
+const get$1 = id => {
+  return state$4.callbacks[id];
+};
+const remove$1 = id => {
+  delete state$4.callbacks[id];
+};
+let id = 0;
+const create$3$1 = () => {
+  return ++id;
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const registerPromise = () => {
+  const id = create$3$1();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set$1(id, resolve);
+  return {
+    id,
+    promise
+  };
+};
+const resolve = (id, response) => {
+  const fn = get$1(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove$1(id);
+};
+const create$2$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';
+  }
+}
+const NewLine$2 = '\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$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$2 + parentStack;
+  }
+  return parentStack;
+};
+const joinLines$1 = lines => {
+  return lines.join(NewLine$2);
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const splitLines$2 = lines => {
+  return lines.split(NewLine$2);
+};
+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$2 + 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$2 + error.data.stack + NewLine$2 + 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$1(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 {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: prettyError.stack,
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1$2 = (message, error) => {
+  return {
+    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$2(message, errorProperty);
+};
+const create$6 = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$6(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;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
+  }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  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 invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2$2(method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const send = (transport, method, ...params) => {
+  const message = create$4(method, params);
+  transport.send(message);
+};
+const invoke$3 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
+};
+
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
+  }
+  return fn(...args);
+};
+
+const getData$1 = event => {
+  return event.data;
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const readyMessage = 'ready';
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const listen$2 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$2 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$5 = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const NewLine$1 = '\n';
+const joinLines = lines => {
+  return lines.join(NewLine$1);
+};
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$1(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    message,
+    code: ERR_MODULE_NOT_FOUND
+  };
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$1(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$1(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    message: `${actualMessage}`,
+    code: '',
+    stack: rest
+  };
+};
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine = '\n';
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex(parent);
+  const childNewLineIndex = getNewLineIndex(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        message,
+        code,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
+}
+const withResolvers = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
+};
+const listen$1$1 = async () => {
+  const parentIpcRaw = listen$2();
+  signal$2(parentIpcRaw);
+  const parentIpc = wrap$5(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    parentIpc.send({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null
+    });
+    parentIpc.dispose();
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
+    }
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$4 = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
+};
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$1$1,
+  wrap: wrap$4
+};
+const Message$1 = 3;
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const create$2$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const event = await eventPromise;
+  // @ts-ignore
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData = getData$1;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    throw new Error('not implemented');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$2 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$2$1,
+  signal,
+  wrap: wrap$2
+};
+const Open = 1;
+const Close = 2;
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
+  }
+};
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close
+  });
+};
+const create$3 = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  // @ts-ignore
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$1 = webSocket => {
+  return new IpcParentWithWebSocket(webSocket);
+};
+const IpcParentWithWebSocket$1 = {
+  __proto__: null,
+  create: create$3,
+  wrap: wrap$1
+};
+
+const createRpc = ipc => {
+  const rpc = {
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      send(ipc, method, ...params);
+    },
+    invoke(method, ...params) {
+      return invoke$3(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer$1(ipc, method, ...params);
+    }
+  };
+  return rpc;
+};
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const handleMessage = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError, logError, requiresSocket);
+};
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+const create$5 = async ({
+  commandMap,
+  messagePort,
+  isMessagePortOpen
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const MessagePortRpcParent = {
+  __proto__: null,
+  create: create$5
+};
+const create$1$1 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebSocketRpcParent = {
+  __proto__: null,
+  create: create$1$1
+};
+const create$2 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebWorkerRpcClient = {
+  __proto__: null,
+  create: create$2
+};
+
+const Empty$1 = 0;
+const FocusIgnoreFiles = 1012;
+const FocusSearch = 1013;
+const FocusSearchExcludeInput = 1008;
+const FocusSearchIncludeInput = 1007;
+const FocusSearchInput = 21;
+const FocusSearchMatchCase = 32;
+const FocusSearchOpenEditors = 1011;
+const FocusSearchPreserveCase = 36;
+const FocusSearchRegex = 33;
+const FocusSearchReplaceAll = 35;
+const FocusSearchReplaceInput = 31;
+const FocusSearchResults = 22;
+const FocusSearchWholeWord = 34;
+const FocusToggleDetails = 1010;
+const FocusToggleReplace = 1020;
+
+const User = 1;
+const Script = 2;
+
+const clearSearchResults$1 = state => {
+  return {
+    ...state,
+    value: '',
+    items: [],
+    minLineY: 0,
+    maxLineY: 0,
+    message: '',
+    focus: FocusSearchInput,
+    focusSource: Script
+  };
+};
+
+const state$3 = {
+  rpc: undefined
+};
+const invoke$2 = (method, ...params) => {
+  const rpc = state$3.rpc;
+  // @ts-ignore
+  return rpc.invoke(method, ...params);
+};
+const invokeAndTransfer = (method, ...params) => {
+  const rpc = state$3.rpc;
+  // @ts-ignore
+  return rpc.invokeAndTransfer(method, ...params);
+};
+const setRpc = rpc => {
+  state$3.rpc = rpc;
+};
+
+const copy = async state => {
+  const {
+    items,
+    listFocusedIndex
+  } = state;
+  if (listFocusedIndex === -1) {
+    return state;
+  }
+  const item = items[listFocusedIndex];
+  await invoke$2('ClipBoard.writeText', item.text);
+  return state;
+};
+
+const minimumSliderSize = 20;
+
+const states = Object.create(null);
+const get = uid => {
+  return states[uid];
+};
+const set = (uid, oldState, newState) => {
+  states[uid] = {
+    oldState,
+    newState
+  };
+};
+
+const create$1 = ({
+  itemHeight,
+  headerHeight = 0,
+  minimumSliderSize = 20
+}) => {
+  return {
+    deltaY: 0,
+    minLineY: 0,
+    maxLineY: 0,
+    finalDeltaY: 0,
+    itemHeight,
+    headerHeight,
+    items: [],
+    listItems: [],
+    minimumSliderSize,
+    focusedIndex: -1,
+    touchOffsetY: 0,
+    touchTimeStamp: 0,
+    touchDifference: 0,
+    scrollBarHeight: 0,
+    scrollBarActive: false
+  };
+};
+
+const create = (uid, x, y, width, height, workspacePath, assetDir, itemHeight, value = '', replacement = '', platform) => {
+  const state = {
+    uid,
+    searchResults: [],
+    stats: {},
+    searchId: -1,
+    value,
+    disposed: false,
+    fileCount: 0,
+    x,
+    y,
+    width,
+    height,
+    ...create$1({
+      itemHeight: itemHeight || 22,
+      minimumSliderSize: minimumSliderSize,
+      headerHeight: 61 // TODO
+    }),
+    threads: 0,
+    replacement,
+    matchCount: 0,
+    listFocused: false,
+    listFocusedIndex: -1,
+    inputSource: User,
+    workspacePath: workspacePath,
+    includeValue: '',
+    excludeValue: '',
+    focus: Empty$1,
+    loaded: false,
+    message: '',
+    collapsedPaths: [],
+    icons: [],
+    assetDir,
+    deltaY: 0,
+    finalDeltaY: 0,
+    focused: false,
+    focusedIndex: -1,
+    handleOffset: 0,
+    focusSource: User,
+    flags: 0,
+    platform
+  };
+  set(uid, state, state);
+  return state;
+};
+
+// 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 remove = (array, index, deleteCount) => {
+  return array.toSpliced(index, deleteCount);
+};
+const fromAsync = async asyncIterable => {
+  const children = [];
+  for await (const value of asyncIterable) {
+    children.push(value);
+  }
+  return children;
+};
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  ClearSearchResults: 'Clear Search Results',
+  CollapseAll: 'Collapse All',
+  ConfirmReplaceAll: 'Replace All?',
+  ConfirmReplaceManyOccurrencesInManyFiles: "Replace {PH1} occurrences across {PH2} files with '{PH3}'",
+  ConfirmReplaceManyOccurrencesInManyFilesNoValue: 'Replace {PH1} occurrences across {PH2} files',
+  ConfirmReplaceManyOccurrencesInOneFile: "Replace {PH1} occurrences across 1 file with '{PH2}'",
+  ConfirmReplaceManyOccurrencesInOneFileNoValue: 'Replace {PH1} occurrences across 1 file',
+  ConfirmReplaceOneOccurrenceInOneFile: "Replace 1 occurrence across 1 file with '{PH1}'",
+  ConfirmReplaceOneOccurrenceInOneFileNoValue: 'Replace 1 occurrence across 1 file',
+  CopyPath: 'Copy Path',
+  Dismiss: 'Dismiss',
+  ManyResultsInManyFiles: '{PH1} results in {PH2} files',
+  ManyResultsInOneFile: '{PH1} results in 1 file',
+  MatchCase: 'Match Case',
+  MatchWholeWord: 'Match Whole Word',
+  NoResults: 'No results found',
+  Oneresult: '1 result in 1 file',
+  OpenNewSearchEditor: 'Open New Search Editor',
+  PreserveCase: 'Preserve Case',
+  Refresh: 'Refresh',
+  Replace: 'Replace',
+  ReplaceAll: 'Replace All',
+  ReplacedManyOccurrencesInManyFiles: "Replaced {PH1} occurrences across {PH2} files with '{PH3}'",
+  ReplacedManyOccurrencesInOneFile: "Replaced {PH1} occurrences across 1 file with '{PH2}'",
+  ReplacedOneOccurrenceInOneFile: "Replaced 1 occurrence across 1 file with '{PH1}'",
+  ToggleReplace: 'Toggle Replace',
+  UseRegularExpression: 'Use Regular Expression',
+  ViewAsTree: 'View as Tree',
+  FilesToInclude: 'Files to Include',
+  FilesToExclude: 'Files to Exclude',
+  ToggleSearchDetails: 'Toggle Search Details',
+  SearchOnlyOpenEditors: 'Search Only Open Editors',
+  UseExcludeSettings: 'Use Exclude Settings'
+};
+const noResults = () => {
+  return i18nString(UiStrings.NoResults);
+};
+const oneResult = () => {
+  return i18nString(UiStrings.Oneresult);
+};
+const toggleReplace$1 = () => {
+  return i18nString(UiStrings.ToggleReplace);
+};
+const matchCase = () => {
+  return i18nString(UiStrings.MatchCase);
+};
+const preserveCase = () => {
+  return i18nString(UiStrings.PreserveCase);
+};
+const matchWholeWord = () => {
+  return i18nString(UiStrings.MatchWholeWord);
+};
+const toggleSearchDetails = () => {
+  return i18nString(UiStrings.ToggleSearchDetails);
+};
+const useRegularExpression = () => {
+  return i18nString(UiStrings.UseRegularExpression);
+};
+const manyResultsInOneFile = resultCount => {
+  return i18nString(UiStrings.ManyResultsInOneFile, {
+    PH1: resultCount
+  });
+};
+const manyResultsInManyFiles = (resultCount, fileResultCount) => {
+  return i18nString(UiStrings.ManyResultsInManyFiles, {
+    PH1: resultCount,
+    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) => {
+  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFiles, {
+    PH1: matchCount,
+    PH2: fileCount,
+    PH3: replacement
+  });
+};
+const confirmReplaceManyOccurrencesInManyFilesNoValue = (matchCount, 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);
+};
+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 filesToInclude = () => {
+  return i18nString(UiStrings.FilesToInclude);
+};
+const filesToExclude = () => {
+  return i18nString(UiStrings.FilesToExclude);
+};
+const searchOnlyOpenEditors = () => {
+  return i18nString(UiStrings.SearchOnlyOpenEditors);
+};
+const useExcludeSettings = () => {
+  return i18nString(UiStrings.UseExcludeSettings);
+};
+
+const getStatusMessage = (resultCount, 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;
+
+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 setSize;
+};
+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 {
+        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 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 PreserveCase$1 = 1 << 0; // 1
+const UseRegularExpression$1 = 1 << 1; // 2
+const ReplaceExpanded = 1 << 2; // 4
+const MatchWholeWord$1 = 1 << 3; // 8
+const MatchCase$1 = 1 << 4; // 16
+const DetailsExpanded = 1 << 5; // 32
+const OpenEditors = 1 << 6; // 64
+const UseIgnoreFiles = 1 << 7; // 128
+
+const hasPreserveCase = flags => {
+  return (flags & PreserveCase$1) === PreserveCase$1;
+};
+const hasUseRegularExpression = flags => {
+  return (flags & UseRegularExpression$1) === UseRegularExpression$1;
+};
+const hasReplaceExpanded = flags => {
+  return (flags & ReplaceExpanded) === ReplaceExpanded;
+};
+const hasMatchWholeWord = flags => {
+  return (flags & MatchWholeWord$1) === MatchWholeWord$1;
+};
+const hasMatchCase = flags => {
+  return (flags & MatchCase$1) === MatchCase$1;
+};
+const hasDetailsExpanded = flags => {
+  return (flags & DetailsExpanded) === DetailsExpanded;
+};
+
+const getNextFocus = (focus, flags) => {
+  switch (focus) {
+    case FocusToggleReplace:
+      return FocusSearchInput;
+    case FocusSearchInput:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchReplaceInput;
+      }
+      return FocusSearchMatchCase;
+    case FocusSearchMatchCase:
+      return FocusSearchWholeWord;
+    case FocusSearchWholeWord:
+      return FocusSearchRegex;
+    case FocusSearchRegex:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchPreserveCase;
+      }
+      return FocusToggleDetails;
+    case FocusSearchReplaceInput:
+      return FocusSearchMatchCase;
+    case FocusSearchPreserveCase:
+      return FocusSearchReplaceAll;
+    case FocusSearchReplaceAll:
+      return FocusToggleDetails;
+    case FocusSearchIncludeInput:
+      return FocusSearchOpenEditors;
+    case FocusSearchOpenEditors:
+      return FocusSearchExcludeInput;
+    case FocusSearchExcludeInput:
+      return FocusIgnoreFiles;
+    case FocusToggleDetails:
+      return FocusSearchIncludeInput;
+    default:
+      return focus;
+  }
+};
+
+const focusNextInput = state => {
+  const nextFocus = getNextFocus(state.focus, state.flags);
+  return {
+    ...state,
+    focus: nextFocus,
+    focusSource: Script
+  };
+};
+
+const getPreviousFocus = (focus, flags) => {
+  switch (focus) {
+    case FocusSearchInput:
+      return FocusToggleReplace;
+    case FocusSearchMatchCase:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchReplaceInput;
+      }
+      return FocusSearchInput;
+    case FocusSearchWholeWord:
+      return FocusSearchMatchCase;
+    case FocusSearchRegex:
+      return FocusSearchWholeWord;
+    case FocusSearchPreserveCase:
+      return FocusSearchRegex;
+    case FocusSearchReplaceInput:
+      return FocusSearchInput;
+    case FocusSearchReplaceAll:
+      return FocusSearchPreserveCase;
+    case FocusToggleDetails:
+      if (flags & ReplaceExpanded) {
+        return FocusSearchReplaceAll;
+      }
+      return FocusSearchRegex;
+    case FocusSearchOpenEditors:
+      return FocusSearchIncludeInput;
+    case FocusSearchExcludeInput:
+      return FocusSearchOpenEditors;
+    case FocusIgnoreFiles:
+      return FocusSearchExcludeInput;
+    case FocusSearchIncludeInput:
+      return FocusToggleDetails;
+    default:
+      return focus;
+  }
+};
+
+const focusPreviousInput = state => {
+  const previousFocus = getPreviousFocus(state.focus, state.flags);
+  return {
+    ...state,
+    focus: previousFocus,
+    focusSource: Script
+  };
+};
+
+const focusReplaceValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchReplaceInput,
+    focusSource: Script
+  };
+};
+
+const focusSearchValue$1 = state => {
+  return {
+    ...state,
+    focus: FocusSearchInput
+  };
+};
+
+const focusSearchValueNext = state => {
+  if (hasReplaceExpanded(state.flags)) {
+    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 Button$2 = 'button';
+
+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 MaskIconBook = 'MaskIconBook';
+const MaskIconCaseSensitive = 'MaskIconCaseSensitive';
+const MaskIconChevronDown = 'MaskIconChevronDown';
+const MaskIconChevronRight = 'MaskIconChevronRight';
+const MaskIconEllipsis = 'MaskIconEllipsis';
+const MaskIconExclude = 'MaskIconExclude';
+const MaskIconPreserveCase = 'MaskIconPreserveCase';
+const MaskIconRegex = 'MaskIconRegex';
+const MaskIconReplaceAll = 'MaskIconReplaceAll';
+const MaskIconWholeWord = 'MaskIconWholeWord';
+const MultilineInputBox = 'MultilineInputBox';
+const 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 SearchHeaderDetailsExpanded = 'SearchHeaderDetailsExpanded';
+const SearchHeaderDetailsExpandedTop = 'SearchHeaderDetailsExpandedTop';
+const SearchHeaderDetailsHeading = 'SearchHeaderDetailsHeading';
+const SearchHeaderTop = 'SearchHeaderTop';
+const SearchHeaderTopRight = 'SearchHeaderTopRight';
+const SearchRemove = 'SearchRemove';
+const SearchToggleButton = 'SearchToggleButton';
+const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
+const SourceControlBadge = 'SourceControlBadge';
+const ToggleDetails = 'ToggleDetails';
+const TreeItem = 'TreeItem';
+const TreeItemActive = 'TreeItemActive';
+const Viewlet = 'Viewlet';
+const ViewletSearchMessage = 'ViewletSearchMessage';
+
+const Button$1 = 1;
+
+const Button = 1;
+const Del = 21;
+const Div = 4;
+const H4 = 24;
+const Img = 17;
+const Ins = 20;
+const Span = 8;
+const Text = 12;
+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 getFlags = uid => {
+  const {
+    newState
+  } = get(uid);
+  return newState.flags;
+};
+
+const getFocus = uid => {
+  const {
+    newState
+  } = get(uid);
+  return newState.focus;
+};
+
+const Tab = 2;
+const Enter = 3;
+const End = 255;
+const Home = 12;
+const UpArrow = 14;
+const DownArrow = 16;
+const Delete = 18;
+const KeyC = 31;
+
+const CtrlCmd = 1 << 11 >>> 0;
+const Shift = 1 << 10 >>> 0;
+const Alt = 1 << 9 >>> 0;
+
+const getKeyBindings = () => {
+  return [{
+    key: CtrlCmd | Alt | Enter,
+    command: 'Search.replaceAll',
+    when: FocusSearch
+  }, {
+    key: Tab,
+    command: 'Search.focusNextInput',
+    when: FocusSearch
+  }, {
+    key: Shift | Tab,
+    command: 'Search.focusPreviousInput',
+    when: FocusSearch
+  }, {
+    key: DownArrow,
+    command: 'Search.focusNext',
+    when: FocusSearchResults
+  }, {
+    key: UpArrow,
+    command: 'Search.focusPrevious',
+    when: FocusSearchResults
+  }, {
+    key: Delete,
+    command: 'Search.dismissItem',
+    when: FocusSearchResults
+  }, {
+    key: Home,
+    command: 'Search.focusFirst',
+    when: FocusSearchResults
+  }, {
+    key: End,
+    command: 'Search.focusLast',
+    when: FocusSearchResults
+  }, {
+    key: CtrlCmd | KeyC,
+    command: 'Search.copy',
+    when: FocusSearchResults
+  }, {
+    key: Enter,
+    command: 'Search.submit',
+    when: FocusSearchInput
+  }, {
+    key: Enter,
+    command: 'Search.submit',
+    when: FocusSearchReplaceInput
+  }];
+};
+
+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,
+        replacement,
+        depth: 1,
+        matchCount: 0,
+        focused
+      };
+    default:
+      throw new Error('unexpected search result type');
+  }
+};
+
+const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLineY, maxLineY, replacement, fileIcons, focusedIndex) => {
+  const displayResults = [];
+  const setSize = resultCount;
+  const searchTermLength = searchTerm.length;
+  let fileResult = {
+    matchCount: 0
+  };
+  let fileIconIndex = 0;
+  for (let i = minLineY; i < maxLineY; i++) {
+    const result = results[i];
+    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++;
+    }
+  }
+  return displayResults;
+};
+
+const HandleClick = 'handleClick';
+const HandleHeaderClick = 'handleHeaderClick';
+const HandleHeaderFocusIn = 'handleHeaderFocusIn';
+const HandleListBlur = 'handleListBlur';
+
+const getSearchDetailsToggleVirtualDom = () => {
+  return [{
+    type: Div,
+    className: ToggleDetails,
+    role: Button$2,
+    tabIndex: 0,
+    ariaLabel: toggleSearchDetails(),
+    title: toggleSearchDetails(),
+    childCount: 1
+  }, {
+    type: Div,
+    className: mergeClassNames(MaskIcon, MaskIconEllipsis),
+    childCount: 0
+  }];
+};
+
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
+
+const getSearchMessageVirtualDom = message => {
+  return [{
+    type: Div,
+    className: ViewletSearchMessage,
+    role: Status,
+    tabIndex: 0,
+    childCount: 1
+  }, text(message)];
+};
+
+const getSearchHeaderDetailsCollapsedVirtualDom = message => {
+  return [{
+    type: Div,
+    className: SearchHeaderDetails,
+    childCount: 2
+  }, ...getSearchMessageVirtualDom(message), ...getSearchDetailsToggleVirtualDom()];
+};
+
+const getSearchFieldButtonVirtualDom = button => {
+  const {
+    icon,
+    checked,
+    title
+  } = button;
+  return [{
+    type: Div,
+    className: mergeClassNames(SearchFieldButton, checked ? SearchFieldButtonChecked : ''),
+    title,
+    role: CheckBox,
+    ariaChecked: checked,
+    tabIndex: 0,
+    childCount: 1
+  }, {
+    type: Div,
+    className: mergeClassNames(MaskIcon, icon),
+    childCount: 0
+  }];
+};
+
+const getOutSideButtonsDom = outsideButtons => {
+  if (outsideButtons.length === 0) {
+    return {
+      preNodes: [],
+      postNodes: []
+    };
+  }
+  return {
+    preNodes: [{
+      type: Div,
+      className: SearchFieldContainer,
+      role: None,
+      childCount: 1 + outsideButtons.length
+    }],
+    postNodes: outsideButtons.flatMap(getSearchFieldButtonVirtualDom)
+  };
+};
+const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus = '') => {
+  const {
+    preNodes,
+    postNodes
+  } = getOutSideButtonsDom(outsideButtons);
+  const dom = [...preNodes, {
+    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), ...postNodes];
+  return dom;
+};
+
+const FilesToExclude = 'FilesToExclude';
+const FilesToInclude = 'FilesToInclude';
+const MatchCase = 'MatchCase';
+const MatchWholeWord = 'MatchWholeWord';
+const PreserveCase = 'PreserveCase';
+const ReplaceAll = 'ReplaceAll';
+const ReplaceValue = 'ReplaceValue';
+const SearchOnlyOpenEditors = 'SearchOnlyOpenEditors';
+const SearchValue = 'SearchValue';
+const ToggleReplace = 'ToggleReplace';
+const ToggleSearchDetails = 'ToggleSearchDetails';
+const UseExcludeSettings = 'UseExcludeSettings';
+const UseRegularExpression = 'UseRegularExpression';
+
+const getSearchHeaderDetailsExpandedVirtualDom = (flags, message) => {
+  const includeButtons = [{
+    icon: MaskIconBook,
+    title: searchOnlyOpenEditors(),
+    command: 'searchOnlyOpenEditors',
+    checked: Boolean(flags & OpenEditors),
+    name: SearchOnlyOpenEditors
+  }];
+  const excludeButtons = [{
+    icon: MaskIconExclude,
+    title: useExcludeSettings(),
+    command: 'toggleUseExcludeSettings',
+    checked: Boolean(flags & UseIgnoreFiles),
+    name: UseExcludeSettings
+  }];
+  return [{
+    type: Div,
+    className: SearchHeaderDetailsExpanded,
+    childCount: 5
+  }, {
+    type: Div,
+    className: SearchHeaderDetailsExpandedTop,
+    childCount: 2
+  }, ...getSearchDetailsToggleVirtualDom(), {
+    type: H4,
+    className: SearchHeaderDetailsHeading,
+    childCount: 1
+  }, text(filesToInclude()), ...getSearchFieldVirtualDom(FilesToInclude, 'Include', 'handleIncludeInput', includeButtons, []), {
+    type: H4,
+    className: SearchHeaderDetailsHeading,
+    childCount: 1
+  }, text(filesToExclude()), ...getSearchFieldVirtualDom(FilesToExclude, 'Exclude', 'handleExcludeInput', excludeButtons, []), ...getSearchMessageVirtualDom(message)];
+};
+
+const getSearchHeaderDetailsVirtualDom = (flags, message) => {
+  if (flags & DetailsExpanded) {
+    return getSearchHeaderDetailsExpandedVirtualDom(flags, message);
+  }
+  return getSearchHeaderDetailsCollapsedVirtualDom(message);
+};
+
+const getSearchToggleVirtualDom = flags => {
+  return [{
+    type: Button,
+    className: mergeClassNames(IconButton, SearchToggleButton, hasReplaceExpanded(flags) ? SearchToggleButtonExpanded : ''),
+    title: toggleReplace$1(),
+    ariaLabel: toggleReplace$1(),
+    ariaExpanded: hasReplaceExpanded(flags),
+    childCount: 1,
+    'data-command': 'toggleReplace'
+  }, {
+    type: Div,
+    className: mergeClassNames(MaskIcon, hasReplaceExpanded(flags) ? MaskIconChevronDown : MaskIconChevronRight),
+    childCount: 0
+  }];
+};
+
+const getSearchHeaderTopVirtualDom = flags => {
+  const dom = [{
+    type: Div,
+    className: SearchHeaderTop,
+    role: None,
+    childCount: 2
+  }, ...getSearchToggleVirtualDom(flags), {
+    type: Div,
+    className: SearchHeaderTopRight,
+    role: None,
+    childCount: hasReplaceExpanded(flags) ? 2 : 1
+  }, ...getSearchFieldVirtualDom(SearchValue, 'Search', 'handleInput', [{
+    icon: MaskIconCaseSensitive,
+    checked: hasMatchCase(flags),
+    title: matchCase(),
+    name: MatchCase
+  }, {
+    icon: MaskIconWholeWord,
+    checked: hasMatchWholeWord(flags),
+    title: matchWholeWord(),
+    name: MatchWholeWord
+  }, {
+    icon: MaskIconRegex,
+    checked: hasUseRegularExpression(flags),
+    title: useRegularExpression(),
+    name: UseRegularExpression
+  }], [])];
+  if (hasReplaceExpanded(flags)) {
+    dom.push(...getSearchFieldVirtualDom(ReplaceValue, 'Replace', 'handleReplaceInput', [{
+      icon: MaskIconPreserveCase,
+      checked: hasPreserveCase(flags),
+      title: preserveCase(),
+      name: PreserveCase
+    }], [{
+      icon: MaskIconReplaceAll,
+      checked: false,
+      title: replaceAll$1(),
+      name: ReplaceAll
+    }]));
+  }
+  return dom;
+};
+
+const getSearchHeaderVirtualDom = (flags, message) => {
+  const dom = [{
+    type: Div,
+    className: SearchHeader,
+    role: None,
+    childCount: 2,
+    onClick: HandleHeaderClick,
+    onFocusIn: HandleHeaderFocusIn
+  }, ...getSearchHeaderTopVirtualDom(flags), ...getSearchHeaderDetailsVirtualDom(flags, message)];
+  return dom;
+};
+
+const getBadgeVirtualDom = (className, count) => {
+  return [{
+    type: Div,
+    className: mergeClassNames(Badge, className),
+    childCount: 1
+  }, text(`${count}`)];
+};
+
+const chevronDownVirtualDom = {
+  type: Div,
+  className: mergeClassNames(Chevron, MaskIconChevronDown),
+  childCount: 0
+};
+({
+  type: Div,
+  className: mergeClassNames(Chevron, MaskIconChevronRight),
+  childCount: 0
+});
+
+const getFileIconVirtualDom = icon => {
+  return {
+    type: Img,
+    className: FileIcon,
+    src: icon,
+    role: None,
+    childCount: 0
+  };
+};
+
+const deleted = {
+  type: Del,
+  className: HighlightDeleted,
+  childCount: 1
+};
+const inserted = {
+  type: Ins,
+  className: HighlightInserted,
+  childCount: 1
+};
+const highlighted = {
+  type: Span,
+  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) => {
+  if (matchLength) {
+    const before = displayText.slice(0, matchStart);
+    const highlight = displayText.slice(matchStart, matchStart + matchLength);
+    const after = displayText.slice(matchStart + matchLength);
+    if (replacement) {
+      return [label4, text(before), deleted, text(highlight), inserted, text(replacement), text(after)];
+    }
+    return [label3, text(before), highlighted, text(highlight), text(after)];
+  }
+  return [label1, text(displayText)];
+};
+
+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;
+  }
+  switch (type) {
+    case File$1:
+      treeItem.ariaExpanded = 'true';
+      break;
+  }
+  const dom = [];
+  dom.push(treeItem);
+  if (type === File$1) {
+    treeItem.childCount += 2;
+    dom.push(chevronDownVirtualDom, getFileIconVirtualDom(icon));
+  }
+  dom.push(...getLabelVirtualDom(displayText, matchLength, matchStart, replacement));
+  if (matchCount) {
+    treeItem.childCount++;
+    dom.push(...getBadgeVirtualDom(SourceControlBadge, matchCount));
+  }
+  treeItem.childCount++;
+  dom.push({
+    type: Div,
+    className: SearchRemove,
+    childCount: 1
+  }, {
+    type: Div,
+    className: CloseMaskIcon,
+    childCount: 0
+  });
+  return dom;
+};
+
+const getSearchResultsVirtualDom = (visibleItems, focusOutline) => {
+  return [{
+    type: Div,
+    className: mergeClassNames(Viewlet, List, focusOutline ? FocusOutline : Empty),
+    role: Tree,
+    tabIndex: 0,
+    childCount: visibleItems.length,
+    onClick: HandleClick,
+    onBlur: HandleListBlur
+  }, ...visibleItems.flatMap(getSearchResultVirtualDom)];
+};
+
+const getSearchVirtualDom = (visibleItems, flags, message, focusOutline) => {
+  const dom = [{
+    type: Div,
+    className: mergeClassNames(Viewlet, Search$1),
+    childCount: 2
+  }, ...getSearchHeaderVirtualDom(flags, message), ...getSearchResultsVirtualDom(visibleItems, focusOutline)];
+  return dom;
+};
+
+const handleError = error => {
+  console.error(`[text-search-worker] ${error}`);
+};
+
+const getFileIcons = async files => {
+  // TODO cache file icons
+  const promises = [];
+  for (const file of files) {
+    if (file.type === Match) {
+      continue;
+    }
+    promises.push(invoke$2('IconTheme.getFileIcon', {
+      name: file.text
+    }));
+  }
+  const icons = await Promise.all(promises);
+  return icons;
+};
+
+// 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 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 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 {
+    percent: 1,
+    handleOffset: scrollBarHeight - height + relativeY
+  };
+};
+
+const RE_PROTOCOL = /^([a-z-\d]+):\/\//;
+const getProtocol$1 = 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$2('ExtensionHostTextSearch.executeTextSearchProvider', scheme, query);
+  return result;
+};
+
+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 = lines => {
+  return lines.split('\n');
+};
+
+const textSearchInText = (file, content, query) => {
+  const results = [];
+  const lines = splitLines(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 = textSearchInText(relativeUri, content, query);
+    allResults.push(...results);
+  }
+  return allResults;
+};
+
+class FileNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'FileNotFoundError';
+  }
+}
+
+const Directory = 'directory';
+const File = 'file';
+
+const getChildHandles$1 = async handle => {
+  object(handle);
+  // @ts-ignore
+  const childHandles = handle.values();
+  const handles = await fromAsync(childHandles);
+  return handles;
+};
+
+const getChildHandles = async handle => {
+  try {
+    return await getChildHandles$1(handle);
+  } catch (error) {
+    throw new VError$1(error, 'failed to get child handles');
+  }
+};
+
+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;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  // Due to expected object equality (which is enforced by the caching in `wrap`), we
+  // only create one new func per func.
+  // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+  // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+  // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+  // with real promises, so each advance methods returns a new promise for the cursor object, or
+  // undefined if the end of the cursor has been reached.
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function (...args) {
+      // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+      // the original object.
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function (...args) {
+    // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+    // the original object.
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === 'function') return wrapFunction(value);
+  // This doesn't return, it just creates a 'done' promise for the transaction,
+  // which is later returned for transaction.done (see idbObjectHandler).
+  if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
+  // Return the same value back if we're not going to transform it.
+  return value;
+}
+function wrap(value) {
+  // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+  // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+  if (value instanceof IDBRequest) return promisifyRequest(value);
+  // If we've already transformed this value before, reuse the transformed value.
+  // This is faster, but it also provides object equality.
+  if (transformCache.has(value)) return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  // Not all types are transformed.
+  // These may be primitive types, so they can't be WeakMap keys.
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+const unwrap = value => reverseTransformCache.get(value);
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, {
+  blocked,
+  upgrade,
+  blocking,
+  terminated
+} = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener('upgradeneeded', event => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener('blocked', event => blocked(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    event.oldVersion, event.newVersion, event));
+  }
+  openPromise.then(db => {
+    if (terminated) db.addEventListener('close', () => terminated());
+    if (blocking) {
+      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {});
+  return openPromise;
+}
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {
+    return;
+  }
+  if (cachedMethods.get(prop)) return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, '');
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+    return;
+  }
+  const method = async function (storeName, ...args) {
+    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+    let target = tx.store;
+    if (useIndex) target = target.index(args.shift());
+    // Must reject if op rejects.
+    // If it's a write operation, must reject if tx.done rejects.
+    // Must reject with op rejection first.
+    // Must resolve with op value.
+    // Must handle both promises (no unhandled rejections)
+    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop)) return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function (...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  // tslint:disable-next-line:no-this-assignment
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor) return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  // Map this double-proxy back to the original, so other cursor methods work.
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    // If one of the advancing methods was not called, call continue().
+    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);
+  }
+}));
+
+const state$2 = {
+  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$2.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 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 = await 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:
+        // @ts-ignore
+        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 FileNotFoundError(`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 Electron = 2;
+const Remote = 3;
+
+const Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
+
+const getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
+};
+
+const getWebSocketUrl = (type, host, locationProtocol) => {
+  const wsProtocol = getWebSocketProtocol(locationProtocol);
+  return `${wsProtocol}//${host}/websocket/${type}`;
+};
+
+const getHost = () => {
+  return location.host;
+};
+const getProtocol = () => {
+  return location.protocol;
+};
+
+const launchSearchProcess = async () => {
+  const host = getHost();
+  const protocol = getProtocol();
+  const wsUrl = getWebSocketUrl('search-process', host, protocol);
+  const webSocket = new WebSocket(wsUrl);
+  const rpc = await WebSocketRpcParent.create({
+    webSocket,
+    commandMap: {}
+  });
+  return rpc;
+};
+
+const state$1 = {
+  rpc: undefined
+};
+const getOrCreate$1 = () => {
+  if (!state$1.rpc) {
+    // @ts-ignore
+    state$1.rpc = launchSearchProcess();
+  }
+  return state$1.rpc;
+};
+
+const invoke$1 = async (method, ...params) => {
+  const rpc = await getOrCreate$1();
+  return rpc.invoke(method, ...params);
+};
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const launchSearchProcessElectron = async () => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const rpcPromise = MessagePortRpcParent.create({
+    messagePort: port2,
+    commandMap: {},
+    isMessagePortOpen: true
+  });
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port1, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+  port2.start();
+  const rpc = await rpcPromise;
+  return rpc;
+};
+
+const state = {
+  rpc: undefined
+};
+const getOrCreate = () => {
+  if (!state.rpc) {
+    // @ts-ignore
+    state.rpc = launchSearchProcessElectron();
+  }
+  return state.rpc;
+};
+
+const invoke = async (method, ...params) => {
+  const rpc = await getOrCreate();
+  return rpc.invoke(method, ...params);
+};
+
+const textSearch$2 = async (scheme, root, query, options, assetDir, platform) => {
+  const ripGrepArgs = getRipGrepArgs({
+    ...options,
+    searchString: query
+  });
+  const actualOptions = {
+    ripGrepArgs,
+    searchDir: root
+  };
+  if (platform === Remote) {
+    const result = await invoke$1('TextSearch.search', actualOptions);
+    // TODO api is weird
+    return result.results;
+  }
+  if (platform === Electron) {
+    const result = await invoke('TextSearch.search', actualOptions);
+    return result.results;
+  }
+  const results = await invoke$2('SearchProcess.invoke', 'TextSearch.search', actualOptions);
+  // TODO api is weird
+  return results.results;
+};
+
+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 results;
+};
+
+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 textSearch = async (root, query, options, assetDir, platform) => {
+  string(root);
+  string(query);
+  const scheme = getProtocol$1(root);
+  const provider = getProvider(scheme);
+  const results = await provider(scheme, root, query, options, assetDir, platform);
+  return results;
+};
+
+const handleUpdate = async (state, update) => {
+  const partialNewState = {
+    ...state,
+    ...update
+  };
+  try {
+    const {
+      height,
+      itemHeight,
+      minimumSliderSize,
+      headerHeight,
+      flags,
+      value,
+      threads
+    } = partialNewState;
+    if (isEmptyString(value)) {
+      return {
+        ...partialNewState,
+        minLineY: 0,
+        maxLineY: 0,
+        deltaY: 0,
+        items: [],
+        listItems: [],
+        matchCount: 0,
+        message: '',
+        loaded: true
+      };
+    }
+    const root = state.workspacePath;
+    const results = await textSearch(root, value, {
+      threads,
+      isCaseSensitive: hasMatchCase(flags),
+      useRegularExpression: hasUseRegularExpression(flags)
+    }, state.assetDir, state.platform);
+    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,
+      listItems: results,
+      message,
+      maxLineY: maxLineY,
+      scrollBarHeight,
+      finalDeltaY,
+      threads,
+      fileCount,
+      matchCount: resultCount,
+      loaded: true,
+      icons
+    };
+  } catch (error) {
+    handleError(error);
+    return {
+      ...partialNewState,
+      message: `${error}`,
+      items: [],
+      listItems: [],
+      matchCount: 0,
+      fileCount: 0,
+      minLineY: 0,
+      maxLineY: 0
+    };
+  }
+};
+
+const handleExcludeInput = (state, value, inputSource = Script) => {
+  return handleUpdate(state, {
+    excludeValue: value,
+    inputSource
+  });
+};
+
+const handleIconThemeChange = async state => {
+  const {
+    items,
+    minLineY,
+    maxLineY
+  } = state;
+  const visibleItems = items.slice(minLineY, maxLineY);
+  const icons = await getFileIcons(visibleItems);
+  return {
+    ...state,
+    icons
+  };
+};
+
+const handleIncludeInput = (state, includeValue) => {
+  return {
+    ...state,
+    includeValue,
+    focusSource: User
+  };
+};
+
+const handleInput = (state, value, inputSource = Script) => {
+  return handleUpdate(state, {
+    value,
+    inputSource
+  });
+};
+
+const handleListBlur = state => {
+  return state;
+};
+
+const handleReplaceInput = (state, value, inputSource = Script) => {
+  return handleUpdate(state, {
+    replacement: value,
+    inputSource
+  });
+};
+
+const getInputHandler = name => {
+  switch (name) {
+    case 'search-value':
+      return handleInput;
+    case 'replacement-value':
+      return handleReplaceInput;
+    case 'files-to-exclude-value':
+      return handleExcludeInput;
+    default:
+      throw new Error(`unknown input handler: ${name}`);
+  }
+};
+
+const handleSharedInput = (state, name, value, inputSource = Script) => {
+  const fn = getInputHandler(name);
+  return fn(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);
+  }
+  if (index >= maxLineY - 1) {
+    return focusIndexScrollDown(state, index, listHeight, itemHeight, itemsLength);
+  }
+  return {
+    ...state,
+    focusedIndex: index,
+    focused: true
+  };
+};
+
+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 focusNext = state => {
+  const {
+    focusedIndex,
+    items
+  } = state;
+  const nextIndex = next(items, focusedIndex);
+  return focusIndex(state, nextIndex);
+};
+
+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 focusPrevious = state => {
+  const {
+    focusedIndex,
+    items
+  } = state;
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
+  }
+  const previousIndex = previous(items, focusedIndex);
+  return focusIndex(state, previousIndex);
+};
+
+const focusPreviousPage = state => {
+  const {
+    focusedIndex,
+    minLineY,
+    maxLineY
+  } = state;
+  if (focusedIndex === 0 || focusedIndex === -1) {
+    return state;
+  }
+  const indexPreviousPage = Math.max(minLineY - (maxLineY - minLineY) + 1, 0);
+  return focusIndex(state, indexPreviousPage);
+};
+
+const getListIndex = (eventX, eventY, x, y, deltaY, itemHeight, topHeight) => {
+  const relativeY = eventY - y - topHeight + deltaY;
+  const index = Math.floor(relativeY / itemHeight);
+  return index;
+};
+
+const getTopHeight = flags => {
+  if (flags & ReplaceExpanded && flags & DetailsExpanded) {
+    return 190;
+  }
+  if (flags & DetailsExpanded) {
+    return 158;
+  }
+  if (flags & ReplaceExpanded) {
+    return 93;
+  }
+  return 61;
+};
+
+const getFilteredResults = (results, collapsedPaths) => {
+  if (collapsedPaths.length === 0) {
+    return results;
+  }
+  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 selectIndexFile = (state, searchResult, index) => {
+  const {
+    collapsedPaths,
+    items,
+    maxLineY
+  } = state;
+  const path = getAbsolutePath(searchResult.text);
+  string(path);
+  const pathWithDot = `.${path}`;
+  const newCollapsedPaths = [...collapsedPaths, path, pathWithDot];
+  const filteredResults = getFilteredResults(items, collapsedPaths);
+  const newMaxLineY = Math.min(maxLineY, filteredResults.length);
+  return {
+    ...state,
+    collapsedPaths: newCollapsedPaths,
+    listFocusedIndex: index,
+    listFocused: true,
+    listItems: filteredResults,
+    maxLineY: newMaxLineY
+  };
+};
+
+const openUri = async (path, focus = true, props = {}) => {
+  await invoke$2(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
+};
+
+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 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;
+  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:
+      throw new Error(`unexpected search result type ${searchResult.type}`);
+  }
+};
+
+const handleClickAt = (state, eventX, eventY) => {
+  const {
+    x,
+    y,
+    itemHeight,
+    deltaY,
+    flags
+  } = state;
+  const topHeight = getTopHeight(flags);
+  const index = getListIndex(eventX, eventY, x, y, deltaY, itemHeight, topHeight);
+  return selectIndex(state, index);
+};
+
+const handleScrollBarCaptureLost = state => {
+  return {
+    ...state,
+    scrollBarActive: false
+  };
+};
+
+const clamp = (num, min, 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 getSavedValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'value' in savedState && typeof savedState.value === 'string') {
+    return savedState.value;
+  }
+  return '';
+};
+const getSavedReplacement = savedState => {
+  if (savedState && typeof savedState === 'object' && 'replacement' in savedState && typeof savedState.replacement === 'string') {
+    return savedState.replacement;
+  }
+  return '';
+};
+const getSavedFlags = savedState => {
+  if (savedState && typeof savedState === 'object' && 'flags' in savedState && typeof savedState.flags === 'number') {
+    return savedState.flags;
+  }
+  return 0;
+};
+const getSavedIncludeValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'includeValue' in savedState && typeof savedState.includeValue === 'string') {
+    return savedState.includeValue;
+  }
+  return '';
+};
+const getSavedExcludeValue = savedState => {
+  if (savedState && typeof savedState === 'object' && 'excludeValue' in savedState && typeof savedState.excludeValue === 'string') {
+    return savedState.excludeValue;
+  }
+  return '';
+};
+const restoreState = savedState => {
+  return {
+    savedValue: getSavedValue(savedState),
+    replacement: getSavedReplacement(savedState),
+    savedCollapsedPaths: [],
+    threads: 1,
+    flags: getSavedFlags(savedState),
+    includeValue: getSavedIncludeValue(savedState),
+    excludeValue: getSavedExcludeValue(savedState)
+  };
+};
+
+const loadContent = async (state, savedState) => {
+  const {
+    savedValue,
+    savedCollapsedPaths,
+    threads,
+    replacement,
+    flags,
+    includeValue,
+    excludeValue
+  } = restoreState(savedState);
+  if (savedValue) {
+    return handleUpdate(state, {
+      value: savedValue,
+      threads,
+      inputSource: Script,
+      collapsedPaths: savedCollapsedPaths,
+      replacement,
+      flags,
+      includeValue,
+      excludeValue
+    });
+  }
+  return {
+    ...state,
+    threads,
+    flags,
+    loaded: true
+  };
+};
+
+const refresh = state => {
+  return handleUpdate(state, {});
+};
+
+const getFocusSelector = focusKey => {
+  switch (focusKey) {
+    case FocusSearchInput:
+      return SearchValue;
+    case FocusSearchReplaceInput:
+      return ReplaceValue;
+    case FocusToggleDetails:
+      return ToggleSearchDetails;
+    case FocusSearchMatchCase:
+      return MatchCase;
+    case FocusSearchPreserveCase:
+      return PreserveCase;
+    case FocusSearchRegex:
+      return UseRegularExpression;
+    case FocusSearchIncludeInput:
+      return FilesToInclude;
+    case FocusSearchExcludeInput:
+      return FilesToExclude;
+    case FocusSearchWholeWord:
+      return MatchWholeWord;
+    case FocusSearchReplaceAll:
+      return ReplaceAll;
+    case FocusSearchOpenEditors:
+      return SearchOnlyOpenEditors;
+    case FocusIgnoreFiles:
+      return UseExcludeSettings;
+    case FocusToggleReplace:
+      return ToggleReplace;
+    default:
+      return '';
+  }
+};
+
+const renderItems = {
+  isEqual(oldState, newState) {
+    return oldState.items === newState.items && oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY && oldState.replacement === newState.replacement && oldState.flags === newState.flags && oldState.message === newState.message && oldState.loaded === newState.loaded && oldState.collapsedPaths === newState.collapsedPaths && oldState.listFocusedIndex === newState.listFocusedIndex && oldState.listFocused === newState.listFocused && oldState.icons === newState.icons;
+  },
+  apply(oldState, newState) {
+    const displayResults = getDisplayResults(newState.listItems, newState.itemHeight, newState.fileCount, newState.value, newState.minLineY, newState.maxLineY, newState.replacement, newState.icons, newState.listFocusedIndex);
+    const focusOutline = newState.listFocused && newState.listFocusedIndex === -1;
+    const dom = getSearchVirtualDom(displayResults, newState.flags, newState.message, focusOutline);
+    return ['Viewlet.setDom2', newState.uid, dom];
+  }
+};
+const renderFocus = {
+  isEqual(oldState, newState) {
+    return oldState.focus === newState.focus || newState.focusSource === User;
+  },
+  apply(oldState, newState) {
+    const name = newState.focusSource === User ? '' : getFocusSelector(newState.focus);
+    return ['Viewlet.focusElementByName', name];
+  }
+};
+const renderValue = {
+  isEqual(oldState, newState) {
+    return oldState.value === newState.value || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    return ['Viewlet.send', newState.uid, 'setValue', newState.value, '[name="search-value"]'];
+  }
+};
+const renderReplacement = {
+  isEqual(oldState, newState) {
+    return oldState.replacement === newState.replacement || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    const selector = getFocusSelector(FocusSearchReplaceInput);
+    return ['Viewlet.send', newState.uid, 'setValue', newState.replacement, selector];
+  }
+};
+const renderIncludeValue = {
+  isEqual(oldState, newState) {
+    return oldState.includeValue === newState.includeValue || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    const selector = getFocusSelector(FocusSearchIncludeInput);
+    return ['Viewlet.send', newState.uid, 'setValue', newState.includeValue, selector];
+  }
+};
+const renderExcludeValue = {
+  isEqual(oldState, newState) {
+    return oldState.excludeValue === newState.excludeValue || newState.inputSource === User;
+  },
+  apply(oldState, newState) {
+    const selector = getFocusSelector(FocusSearchExcludeInput);
+    return ['Viewlet.send', newState.uid, 'setValue', newState.excludeValue, selector];
+  }
+};
+const render = [renderItems, renderValue, renderIncludeValue, renderExcludeValue, renderReplacement, renderFocus];
+const doRender = uid => {
+  const {
+    oldState,
+    newState
+  } = get(uid);
+  const commands = [];
+  for (const fn of render) {
+    if (!fn.isEqual(oldState, newState)) {
+      commands.push(fn.apply(oldState, newState));
+    }
+  }
+  return commands;
+};
+
+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);
+        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 {
+    files,
+    ranges: ranges.slice(1)
+  };
+};
+
+const replaceAll = async state => {
+  const {
+    workspacePath,
+    items,
+    replacement
+  } = state;
+  const {
+    files,
+    ranges
+  } = getBulkReplacementEdits(workspacePath, items);
+  await invoke$2('BulkReplacement.applyBulkReplacement', files, ranges, replacement);
+  return 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 invoke$2('ConfirmPrompt.prompt', confirmText, {
+    title: confirmTitle,
+    confirmMessage: confirmAccept
+  });
+  if (!shouldReplace) {
+    return false;
+  }
+  // TODO
+  // await TextSearchReplaceAll.replaceAll(workspacePath, items, replacement)
+  return true;
+};
+
+const saveState = uid => {
+  const {
+    newState
+  } = get(uid);
+  const {
+    value,
+    replacement,
+    flags,
+    includeValue,
+    excludeValue
+  } = newState;
+  return {
+    value,
+    replacement,
+    flags,
+    includeValue,
+    excludeValue
+  };
+};
+
+const focusElement = (state, focusKey) => {
+  return {
+    ...state,
+    focus: focusKey,
+    focusSource: Script
+  };
+};
+
+const setFocus = async focusKey => {
+  await invoke$2('Focus.setFocus', focusKey);
+};
+
+const getSearchFocusKey = key => {
+  switch (key) {
+    case SearchValue:
+      return FocusSearchInput;
+    case ReplaceValue:
+      return FocusSearchReplaceInput;
+    case MatchCase:
+      return FocusSearchMatchCase;
+    case MatchWholeWord:
+      return FocusSearchWholeWord;
+    case UseRegularExpression:
+      return FocusSearchRegex;
+    case ReplaceAll:
+      return FocusSearchReplaceAll;
+    case PreserveCase:
+      return FocusSearchPreserveCase;
+    case ToggleSearchDetails:
+      return FocusToggleDetails;
+    case FilesToInclude:
+      return FocusSearchIncludeInput;
+    case FilesToExclude:
+      return FocusSearchExcludeInput;
+    case SearchOnlyOpenEditors:
+      return FocusSearchOpenEditors;
+    case UseExcludeSettings:
+      return FocusIgnoreFiles;
+    default:
+      return Empty$1;
+  }
+};
+
+const focusSearchValue = state => {
+  return focusElement(state, FocusSearchInput);
+};
+const focusMatchCasePrevious = state => {
+  if (hasReplaceExpanded(state.flags)) {
+    return focusReplaceValue(state);
+  }
+  return focusSearchValue(state);
+};
+const focusReplaceValuePrevious = state => {
+  return focusSearchValue(state);
+};
+const focusReplaceValueNext = state => {
+  return focusMatchCase(state);
+};
+const focusRegexNext = state => {
+  return focusPreserveCase(state);
+};
+const focusPreserveCasePrevious = state => {
+  return focusRegex(state);
+};
+const focusReplaceValue = state => {
+  return focusElement(state, FocusSearchReplaceInput);
+};
+const focusMatchCase = state => {
+  return focusElement(state, FocusSearchMatchCase);
+};
+const focusPreserveCase = state => {
+  return focusElement(state, FocusSearchPreserveCase);
+};
+const focusMatchWholeWord = state => {
+  return focusElement(state, FocusSearchWholeWord);
+};
+const focusRegex = state => {
+  return focusElement(state, FocusSearchRegex);
+};
+const focusReplaceAll = state => {
+  return focusElement(state, FocusSearchReplaceAll);
+};
+const handleFocusIn = (state, key) => {
+  const focusKey = getSearchFocusKey(key);
+  if (state.focus === focusKey) {
+    return state;
+  }
+  void setFocus(FocusSearch);
+  return {
+    ...state,
+    focus: focusKey,
+    focusSource: User
+  };
+};
+
+const submit = state => {
+  return handleUpdate(state, {
+    value: state.value,
+    inputSource: User
+  });
+};
+
+const toggleSearchFlag = (state, flag) => {
+  return {
+    ...state,
+    flags: state.flags ^ flag
+  };
+};
+
+const collapseDetails = state => {
+  return {
+    ...toggleSearchFlag(state, DetailsExpanded),
+    focus: FocusSearchInput,
+    focusSource: Script
+  };
+};
+
+const expandDetails = state => {
+  return {
+    ...toggleSearchFlag(state, DetailsExpanded),
+    focus: FocusSearchIncludeInput,
+    focusSource: Script
+  };
+};
+
+const toggleDetailsExpanded = state => {
+  if (hasDetailsExpanded(state.flags)) {
+    return collapseDetails(state);
+  }
+  return expandDetails(state);
+};
+
+const toggleMatchCase = state => {
+  return toggleSearchFlag(state, MatchCase$1);
+};
+
+const toggleMatchWholeWord = state => {
+  return toggleSearchFlag(state, MatchWholeWord$1);
+};
+
+const toggleOpenEditors = state => {
+  return toggleSearchFlag(state, OpenEditors);
+};
+
+const togglePreserveCase = state => {
+  return toggleSearchFlag(state, PreserveCase$1);
+};
+
+const toggleReplace = state => {
+  return toggleSearchFlag(state, ReplaceExpanded);
+};
+
+const toggleUseIgnoreFiles = state => {
+  return toggleSearchFlag(state, UseIgnoreFiles);
+};
+
+const toggleUseRegularExpression = state => {
+  return toggleSearchFlag(state, UseRegularExpression$1);
+};
+
+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
+  await invoke$2('ContextMenu.show', x, y, id, ...args);
+};
+
+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 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 = {
+  '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.focusNextInput': wrapCommand(focusNextInput),
+  'TextSearch.focusNextPage': wrapCommand(focusNextPage),
+  'TextSearch.focusPreserveCase': wrapCommand(focusPreserveCase),
+  'TextSearch.focusPreserveCasePrevious': wrapCommand(focusPreserveCasePrevious),
+  'TextSearch.focusPrevious': wrapCommand(focusPrevious),
+  'TextSearch.focusPreviousInput': wrapCommand(focusPreviousInput),
+  '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.focusReplaceValuePrevious': wrapCommand(focusReplaceValuePrevious),
+  '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.handleExcludeInput': wrapCommand(handleExcludeInput),
+  'TextSearch.handleFocusIn': wrapCommand(handleFocusIn),
+  'TextSearch.handleIconThemeChange': wrapCommand(handleIconThemeChange),
+  'TextSearch.handleIncludeInput': wrapCommand(handleIncludeInput),
+  'TextSearch.handleInput': wrapCommand(handleInput),
+  'TextSearch.handleListBlur': wrapCommand(handleListBlur),
+  'TextSearch.handleReplaceInput': wrapCommand(handleReplaceInput),
+  'TextSearch.handleScrollBarCaptureLost': wrapCommand(handleScrollBarCaptureLost),
+  'TextSearch.handleScrollBarClick': wrapCommand(handleScrollBarClick),
+  'TextSearch.handleScrollBarMove': wrapCommand(handleScrollBarMove),
+  'TextSearch.handleSharedInput': wrapCommand(handleSharedInput),
+  'TextSearch.handleWheel': wrapCommand(handleWheel),
+  'TextSearch.launchSearchProcess': wrapCommand(launchSearchProcess),
+  'TextSearch.loadContent': wrapCommand(loadContent),
+  'TextSearch.refresh': wrapCommand(refresh),
+  'TextSearch.replaceAll': wrapCommand(replaceAll),
+  'TextSearch.replaceAllAndPrompt': wrapCommand(replaceAllAndPrompt),
+  'TextSearch.submit': wrapCommand(submit),
+  'TextSearch.toggleMatchCase': wrapCommand(toggleMatchCase),
+  'TextSearch.toggleMatchWholeWord': wrapCommand(toggleMatchWholeWord),
+  'TextSearch.toggleOpenEditors': wrapCommand(toggleOpenEditors),
+  'TextSearch.togglePreserveCase': wrapCommand(togglePreserveCase),
+  'TextSearch.toggleReplace': wrapCommand(toggleReplace),
+  'TextSearch.toggleSearchDetails': wrapCommand(toggleDetailsExpanded),
+  'TextSearch.toggleUseIgnoreFiles': wrapCommand(toggleUseIgnoreFiles),
+  'TextSearch.toggleUseRegularExpression': wrapCommand(toggleUseRegularExpression),
+  // not wrapped
+  'TextSearch.create': create,
+  'TextSearch.getFlags': getFlags,
+  'TextSearch.getFocus': getFocus,
+  'TextSearch.getKeyBindings': getKeyBindings,
+  'TextSearch.render': doRender,
+  'TextSearch.saveState': saveState,
+  // TODO needed?
+  'TextSearch.textSearch': textSearch
+};
+
+const listen = async () => {
+  const rpc = await WebWorkerRpcClient.create({
+    commandMap: commandMap
+  });
+  setRpc(rpc);
+};
+
+const main = async () => {
+  await listen();
+};
+
+main();