@lvce-editor/server 0.39.0 → 0.40.1

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

@@ -1,4267 +0,0 @@
-const Two = '2.0';
-const create$4$1 = (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$3 = '\n';
-const DomException = 'DOMException';
-const ReferenceError$1 = 'ReferenceError';
-const SyntaxError$1 = 'SyntaxError';
-const TypeError$1 = 'TypeError';
-const getErrorConstructor = (message, type) => {
-  if (type) {
-    switch (type) {
-      case DomException:
-        return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case ReferenceError$1:
-        return ReferenceError;
-      default:
-        return Error;
-    }
-  }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
-  }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
-  }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
-  }
-  return Error;
-};
-const constructError = (message, type, name) => {
-  const ErrorConstructor = getErrorConstructor(message, type);
-  if (ErrorConstructor === DOMException && name) {
-    return new ErrorConstructor(message, name);
-  }
-  if (ErrorConstructor === Error) {
-    const error = new Error(message);
-    if (name && name !== 'VError') {
-      error.name = name;
-    }
-    return error;
-  }
-  return new ErrorConstructor(message);
-};
-const getNewLineIndex$2 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$3, startIndex);
-};
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$3 + parentStack;
-  }
-  return parentStack;
-};
-const joinLines$1 = lines => {
-  return lines.join(NewLine$3);
-};
-const MethodNotFound = -32601;
-const Custom = -32001;
-const splitLines$2 = lines => {
-  return lines.split(NewLine$3);
-};
-const restoreJsonRpcError = error => {
-  if (error && error instanceof Error) {
-    return error;
-  }
-  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$3 + currentStack;
-    return restoredError;
-  }
-  if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine$3 + error.data.stack + NewLine$3 + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex$2(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
-  }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
-};
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
-  }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
-  }
-  throw new JsonRpcError('unexpected response message');
-};
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getErrorType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
-  }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
-  }
-  return undefined;
-};
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      message: error.message,
-      data: error.stack
-    };
-  }
-  return {
-    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$5 = (message, result) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    result: result ?? null
-  };
-};
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$5(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$1(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$1 = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
-  }
-  return line;
-};
-const getCombinedMessage$1 = (error, message) => {
-  const stringifiedError = normalizeLine$1(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-const mergeStacks$1 = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
-let VError$1 = class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage$1(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks$1(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-};
-class IpcError extends VError$1 {
-  // @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$1(error, 'failed to parse json');
-  }
-};
-const waitForWebSocketToBeOpen = webSocket => {
-  return getFirstEvent(webSocket, {
-    open: Open,
-    close: Close
-  });
-};
-const create$4 = 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$4,
-  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 => {
-  ipc.addEventListener('message', handleMessage);
-};
-const create$2 = 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$2
-};
-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
-};
-
-// @ts-ignore
-const listen$1 = async () => {
-  const module = IpcChildWithModuleWorkerAndMessagePort$1;
-  const rawIpc = await module.listen();
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-const create$3 = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1();
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$3
-};
-
-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
-  };
-};
-
-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 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 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;
-    }
-  }
-}
-
-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(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(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(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(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();