@lvce-editor/static-server 0.66.12 → 0.67.2

package/static/6109913/packages/find-widget-worker/dist/findWidgetWorkerMain.js

@@ -1,2849 +0,0 @@
-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$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-const mergeStacks = (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(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 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 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 getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-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 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$1 = lines => {
-  return lines.join(NewLine$1);
-};
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-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$1(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 splitLines$1 = lines => {
-  return lines.split(NewLine$1);
-};
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-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 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 isModuleNotFoundError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
-    return false;
-  }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-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 isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
-};
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
-};
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
-};
-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
-  };
-};
-class IpcError extends VError {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        message,
-        code,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      // @ts-ignore
-      cause.code = code;
-      cause.stack = stack;
-      super(cause, betterMessage);
-    } else {
-      super(betterMessage);
-    }
-    // @ts-ignore
-    this.name = 'IpcError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
-  }
-}
-const readyMessage = 'ready';
-const getData$2 = event => {
-  return event.data;
-};
-const listen$7 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
-};
-const signal$8 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$2(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$f = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
-};
-const listen$6 = async () => {
-  const parentIpcRaw = listen$7();
-  signal$8(parentIpcRaw);
-  const parentIpc = wrap$f(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 {
-  getData(event) {
-    return getData$2(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$e = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
-};
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$6,
-  wrap: wrap$e
-};
-
-const Two = '2.0';
-const create$4 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
-  callbacks[id] = fn;
-};
-const get$2 = id => {
-  return callbacks[id];
-};
-const remove = id => {
-  delete callbacks[id];
-};
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$4(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (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 = '\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 joinLines = lines => {
-  return lines.join(NewLine);
-};
-const splitLines = lines => {
-  return lines.split(NewLine);
-};
-const getCurrentStack = () => {
-  const stackLinesToSkip = 3;
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
-  return currentStack;
-};
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
-};
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
-  }
-  return parentStack;
-};
-const MethodNotFound = -32601;
-const Custom = -32001;
-const restoreJsonRpcError = error => {
-  const currentStack = getCurrentStack();
-  if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
-  }
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + 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 + error.data.stack + NewLine + 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(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 warn = (...args) => {
-  console.warn(...args);
-};
-const resolve = (id, response) => {
-  const fn = get$2(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(response);
-  remove(id);
-};
-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 isAlreadyStack = line => {
-  return line.trim().startsWith('at ');
-};
-const getStack = prettyError => {
-  const stackString = prettyError.stack || '';
-  const newLineIndex = stackString.indexOf('\n');
-  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
-    return stackString.slice(newLineIndex + 1);
-  }
-  return stackString;
-};
-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: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
-      code: prettyError.code,
-      name: prettyError.name
-    }
-  };
-};
-const create$1$1 = (id, error) => {
-  return {
-    jsonrpc: Two,
-    id,
-    error
-  };
-};
-const getErrorResponse = (id, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, 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 getErrorResponseSimple = (id, error) => {
-  return {
-    jsonrpc: Two,
-    id,
-    error: {
-      code: Custom,
-      // @ts-ignore
-      message: error.message,
-      data: error
-    }
-  };
-};
-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) {
-    if (ipc.canUseSimpleErrorResponse) {
-      return getErrorResponseSimple(message.id, error);
-    }
-    return getErrorResponse(message.id, 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.id, 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$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
-  transport.send(message);
-};
-const invoke$2 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
-
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
-const createRpc = ipc => {
-  const rpc = {
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$1(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
-    }
-  };
-  return rpc;
-};
-const requiresSocket = () => {
-  return false;
-};
-const preparePrettyError = error => {
-  return error;
-};
-const logError = () => {
-  // handled by renderer worker
-};
-const handleMessage = event => {
-  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
-};
-const handleIpc = ipc => {
-  if ('addEventListener' in ipc) {
-    ipc.addEventListener('message', handleMessage);
-  } else if ('on' in ipc) {
-    // deprecated
-    ipc.on('message', handleMessage);
-  }
-};
-const listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-const create$3 = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$3
-};
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invoke,
-    invokeAndTransfer: invoke,
-    invocations
-  };
-  return mockRpc;
-};
-
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$2 = () => {
-  const states = Object.create(null);
-  const commandMapRef = {};
-  return {
-    get(uid) {
-      return states[uid];
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
-    },
-    dispose(uid) {
-      delete states[uid];
-    },
-    getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseInt(key);
-      });
-    },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
-          return;
-        }
-        const latest = states[uid];
-        states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        newState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
-    }
-  };
-};
-const terminate = () => {
-  globalThis.close();
-};
-
-const CheckBox = 'checkbox';
-const Group = 'group';
-const None = 'none';
-
-const Button = 1;
-const Div = 4;
-const Text = 12;
-const TextArea = 62;
-
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const TargetName = 'event.target.name';
-
-const Tab = 2;
-const Enter = 3;
-const KeyF = 34;
-const F4 = 60;
-
-const User$1 = 1;
-const Script$1 = 2;
-
-const CtrlCmd = 1 << 11 >>> 0;
-const Shift = 1 << 10 >>> 0;
-const Alt = 1 << 9 >>> 0;
-
-const EditorWorker$1 = 99;
-
-const FocusSelector = 'Viewlet.focusSelector';
-const SetCss = 'Viewlet.setCss';
-const SetFocusContext = 'Viewlet.setFocusContext';
-const SetValueByName = 'Viewlet.setValueByName';
-
-const FocusFindWidget$1 = 16;
-const FocusFindWidgetCloseButton$1 = 48;
-const FocusFindWidgetNextMatchButton = 49;
-const FocusFindWidgetPreviousMatchButton = 50;
-const FocusFindWidgetReplace$1 = 43;
-const FocusFindWidgetReplaceAllButton$1 = 47;
-const FocusFindWidgetReplaceButton = 46;
-const FocusIgnoreFiles = 1012;
-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 FocusSearchWholeWord = 34;
-const FocusToggleDetails = 1010;
-const FocusToggleReplace = 1020;
-
-const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-
-const create$1 = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$3(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
-
-const {
-  invoke: invoke$1,
-  invokeAndTransfer,
-  set: set$2,
-  dispose: dispose$2
-} = create$1(EditorWorker$1);
-const sendMessagePortToExtensionHostWorker = async port => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer(
-  // @ts-ignore
-  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
-};
-// TODO add tests for this
-const activateByEvent = async event => {
-  // @ts-ignore
-  await invoke$1('ActivateByEvent.activateByEvent', event);
-};
-const applyEdit = async (editorUid, changes) => {
-  // @ts-ignore
-  await invoke$1('Editor.applyEdit2', editorUid, changes);
-};
-const applyWorkspaceEdit = async (editorUid, changes) => {
-  // @ts-ignore
-  await invoke$1('Editor.applyWorkspaceEdit', editorUid, changes);
-};
-const closeWidget = async (editorUid, widgetId, widgetName, focusId) => {
-  // @ts-ignore
-  await invoke$1('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
-};
-const getWordAt = async (uid, rowIndex, columnIndex) => {
-  // @ts-ignore
-  const word = await invoke$1('Editor.getWordAt2', uid, rowIndex, columnIndex);
-  return word;
-};
-const getLines$1 = async editorUid => {
-  const lines = await invoke$1('Editor.getLines2', editorUid);
-  return lines;
-};
-const getPositionAtCursor = async parentUid => {
-  const position = await invoke$1('Editor.getPositionAtCursor', parentUid);
-  return position;
-};
-const getOffsetAtCursor = async editorId => {
-  // @ts-ignore
-  return await invoke$1('Editor.getOffsetAtCursor', editorId);
-};
-const getSelections$1 = async editorUid => {
-  const selections = await invoke$1('Editor.getSelections2', editorUid);
-  return selections;
-};
-const getWordAtOffset2 = async editorUid => {
-  return invoke$1('Editor.getWordAtOffset2', editorUid);
-};
-const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
-  return invoke$1('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
-};
-const updateDebugInfo = async info => {
-  await invoke$1('Editor.updateDebugInfo', info);
-};
-const getUri = async editorUid => {
-  // @ts-ignore
-  return invoke$1('Editor.getUri', editorUid);
-};
-const getLanguageId = async editorUid => {
-  // @ts-ignore
-  return invoke$1('Editor.getLanguageId', editorUid);
-};
-const getProblems = async () => {
-  // @ts-ignore
-  return invoke$1('Editor.getProblems');
-};
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$2(mockRpc);
-  return mockRpc;
-};
-
-const EditorWorker = {
-  __proto__: null,
-  activateByEvent,
-  applyEdit,
-  applyWorkspaceEdit,
-  closeWidget,
-  dispose: dispose$2,
-  getLanguageId,
-  getLines: getLines$1,
-  getOffsetAtCursor,
-  getPositionAtCursor,
-  getProblems,
-  getSelections: getSelections$1,
-  getUri,
-  getWordAt,
-  getWordAtOffset2,
-  getWordBefore,
-  invoke: invoke$1,
-  invokeAndTransfer,
-  registerMockRpc,
-  sendMessagePortToExtensionHostWorker,
-  set: set$2,
-  updateDebugInfo
-};
-
-const {
-  invoke,
-  set: set$1} = EditorWorker;
-
-const close$1 = async state => {
-  const {
-    editorUid
-  } = state;
-  // @ts-ignore
-  await invoke('Editor.closeFind2', editorUid);
-  return state;
-};
-
-const {
-  get,
-  set,
-  wrapCommand,
-  dispose: dispose$1,
-  getCommandIds,
-  registerCommands,
-  wrapGetter
-} = create$2();
-
-const User = 1;
-const Script = 2;
-const Unknown = 0;
-
-const create = (uid, x, y, width, height, parentUid) => {
-  const state = {
-    uid,
-    value: '',
-    ariaAnnouncement: '',
-    matches: new Uint32Array(),
-    matchIndex: -1,
-    matchCount: 0,
-    replaceExpanded: false,
-    useRegularExpression: false,
-    matchCase: false,
-    matchWholeWord: false,
-    replacement: '',
-    editorUid: parentUid,
-    x: 0,
-    y: 0,
-    width: 0,
-    height: 0,
-    focused: false,
-    focusSource: Unknown,
-    focus: 0,
-    version: 0,
-    lines: [],
-    selections: [],
-    editorX: x,
-    editorY: y,
-    editorWidth: width,
-    editorHeight: height,
-    inputSource: 0,
-    preserveCase: false,
-    resizerPointerDown: false,
-    minWidth: 400,
-    history: [],
-    inputErrorMessage: '',
-    searchInputHeight: 15,
-    inputLineHeight: 15,
-    inputPaddingTop: 4,
-    inputPaddingBottom: 4,
-    inputBorderWidth: 1,
-    inputGap: 3
-  };
-  set(uid, state, state);
-  return state;
-};
-
-const isEqual$8 = (oldState, newState) => {
-  return oldState.x === newState.x && oldState.y === newState.y && oldState.width === newState.width && oldState.height === newState.height;
-};
-
-const isEqual$7 = (oldState, newState) => {
-  return newState.width === newState.width && oldState.height === newState.height && oldState.x === newState.x && oldState.searchInputHeight === newState.searchInputHeight;
-};
-
-const isEqual$6 = (oldState, newState) => {
-  return oldState.version === newState.version;
-};
-
-const isEqual$5 = (oldState, newState) => {
-  return oldState.focused === newState.focused && oldState.focus === newState.focus;
-};
-
-const isEqual$4 = (oldState, newState) => {
-  return oldState.focused === newState.focused;
-};
-
-const isEqual$3 = (oldState, newState) => {
-  return oldState.inputErrorMessage === newState.inputErrorMessage && oldState.matchCase === newState.matchCase && oldState.matchCount === newState.matchCount && oldState.matchIndex === newState.matchIndex && oldState.matchWholeWord === newState.matchWholeWord && oldState.preserveCase === newState.preserveCase && oldState.replaceExpanded === newState.replaceExpanded && oldState.useRegularExpression === newState.useRegularExpression && oldState.version === newState.version;
-};
-
-const isEqual$2 = (oldState, newState) => {
-  return oldState.version === newState.version;
-};
-
-const isEqual$1 = (oldState, newState) => {
-  return newState.inputSource === User$1 || oldState.replacement === newState.replacement;
-};
-
-const RenderBounds = 8;
-const RenderCss = 10;
-const RenderEventListeners = 11;
-const RenderUid = 12;
-const RenderContent = 13;
-const RenderFocusContext = 14;
-const RenderFocus = 15;
-const RenderValue = 16;
-const RenderReplaceValue = 17;
-
-const isEqual = (oldState, newState) => {
-  return newState.inputSource === User$1 || oldState.value === newState.value;
-};
-
-const modules = [isEqual$6, isEqual$3, isEqual$8, isEqual$2, isEqual$4, isEqual$5, isEqual, isEqual$1, isEqual$7];
-const numbers = [RenderEventListeners, RenderContent, RenderBounds, RenderUid, RenderFocusContext, RenderFocus, RenderValue, RenderReplaceValue, RenderCss];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
-    }
-  }
-  return diffResult;
-};
-
-const diff2 = uid => {
-  const {
-    oldState,
-    newState
-  } = get(uid);
-  const diffResult = diff(oldState, newState);
-  return diffResult;
-};
-
-const dispose = uid => {
-  return dispose$1(uid);
-};
-
-const FocusFindWidgetCloseButton = 48;
-const FocusFindWidgetReplace = 43;
-const FocusFindWidgetReplaceAllButton = 47;
-
-const setFindWidgetFocus = (state, focusKey) => {
-  if (state.focus === focusKey) {
-    return state;
-  }
-  return {
-    ...state,
-    focus: focusKey,
-    focusSource: Script
-  };
-};
-
-const focusCloseButton = state => {
-  return setFindWidgetFocus(state, FocusFindWidgetCloseButton);
-};
-
-const setSelections = async (editorUid, selections) => {
-  // @ts-ignore
-  await invoke('Editor.setSelections2', editorUid, selections);
-};
-
-const focusIndex = async (state, index) => {
-  const {
-    matchIndex,
-    matches,
-    editorUid,
-    value
-  } = state;
-  if (index === matchIndex) {
-    return state;
-  }
-  // // TODO find next match and highlight it
-  const matchRowIndex = matches[index * 2];
-  const matchColumnIndex = matches[index * 2 + 1];
-  const newSelections = new Uint32Array([matchRowIndex, matchColumnIndex, matchRowIndex, matchColumnIndex + value.length]);
-  await setSelections(editorUid, newSelections);
-  return {
-    ...state,
-    matchIndex: index,
-    selections: [...newSelections]
-  };
-};
-const focusFirst = state => {
-  return focusIndex(state, 0);
-};
-const focusLast = state => {
-  const {
-    matchCount
-  } = state;
-  return focusIndex(state, matchCount - 1);
-};
-const focusNext = state => {
-  const {
-    matchIndex,
-    matchCount
-  } = state;
-  if (matchIndex === matchCount - 1) {
-    return focusFirst(state);
-  }
-  return focusIndex(state, matchIndex + 1);
-};
-const focusPrevious = state => {
-  const {
-    matchIndex
-  } = state;
-  if (matchIndex === 0) {
-    return focusLast(state);
-  }
-  return focusIndex(state, matchIndex - 1);
-};
-
-const focusReplace = state => {
-  return setFindWidgetFocus(state, FocusFindWidgetReplace);
-};
-
-const focusReplaceAllButton = state => {
-  return setFindWidgetFocus(state, FocusFindWidgetReplaceAllButton);
-};
-
-const handleBlur = async state => {
-  return {
-    ...state,
-    focus: 0,
-    focused: false
-  };
-};
-
-const escapeRegExpCharacters = value => {
-  // @ts-ignore
-  return RegExp.escape(value);
-};
-
-const buildRegex = (searchString, options) => {
-  const {
-    matchCase,
-    useRegularExpression,
-    matchWholeWord
-  } = options;
-  const flags = matchCase ? 'g' : 'gi';
-  const pattern = useRegularExpression ? searchString : escapeRegExpCharacters(searchString);
-  const wrapped = matchWholeWord ? `\\b(?:${pattern})\\b` : pattern;
-  try {
-    const regex = new RegExp(wrapped, flags);
-    return {
-      regex,
-      error: ''
-    };
-  } catch (error) {
-    return {
-      regex: new RegExp(''),
-      error: `${error}`
-    };
-  }
-};
-
-const findRegexMatches = (lines, regex) => {
-  if (!regex.global) {
-    throw new Error('regex must be global');
-  }
-  const {
-    length
-  } = lines;
-  const matches = [];
-  for (let i = 0; i < length; i++) {
-    const line = lines[i];
-    let lastMatch;
-    do {
-      lastMatch = regex.exec(line);
-      if (!lastMatch) {
-        break;
-      }
-      matches.push(i, lastMatch.index);
-    } while (true);
-  }
-  return new Uint32Array(matches);
-};
-
-const findMatches = (lines, searchString, options) => {
-  if (searchString.length === 0) {
-    return {
-      matches: new Uint32Array([]),
-      error: ''
-    };
-  }
-  const {
-    regex,
-    error
-  } = buildRegex(searchString, options);
-  if (error) {
-    return {
-      matches: new Uint32Array([]),
-      error
-    };
-  }
-  const matches = findRegexMatches(lines, regex);
-  return {
-    matches,
-    error: ''
-  };
-};
-
-const getMatchCount = matches => {
-  return matches.length / 2;
-};
-
-const measureTextHeight = (value, lineHeight) => {
-  if (!value) {
-    return lineHeight;
-  }
-  // TODO for single line width, can use offscreencanvas to measure text width
-  // for multiline text, can ask renderer process to measure text height
-  const lines = value.split('\n');
-  return lines.length * lineHeight;
-};
-
-const measureInputHeight = (value, inputLineHeight, inputPaddingBottom, inputPaddingTop, inputBorderWidth, inputGap, replaceExpanded) => {
-  const textHeight = measureTextHeight(value, inputLineHeight);
-  const inputHeight = textHeight + inputPaddingBottom + inputPaddingTop + inputBorderWidth * 2;
-  const replaceInputHeight = replaceExpanded ? inputHeight : 0; // TODO should be independent of input
-  const actualGap = replaceExpanded ? inputGap : 0;
-  // TODO use variables for margin
-  const height = inputHeight + replaceInputHeight + 5 + actualGap;
-  return {
-    inputHeight,
-    height,
-    replaceInputHeight
-  };
-};
-
-const refresh$1 = (state, value, inputSource) => {
-  const {
-    lines,
-    matchCase,
-    useRegularExpression,
-    matchWholeWord,
-    inputLineHeight,
-    inputPaddingTop,
-    inputPaddingBottom,
-    replaceExpanded,
-    inputBorderWidth,
-    inputGap
-  } = state;
-  const options = {
-    matchCase,
-    useRegularExpression,
-    matchWholeWord
-  };
-  const {
-    matches,
-    error
-  } = findMatches(lines, value, options);
-  const {
-    inputHeight,
-    height
-  } = measureInputHeight(value, inputLineHeight, inputPaddingBottom, inputPaddingTop, inputBorderWidth, inputGap, replaceExpanded);
-  if (error) {
-    return {
-      ...state,
-      inputErrorMessage: error,
-      searchInputHeight: inputHeight,
-      height
-    };
-  }
-  const matchCount = getMatchCount(matches);
-  return {
-    ...state,
-    inputErrorMessage: error,
-    searchInputHeight: inputHeight,
-    inputSource,
-    matchCount,
-    matches,
-    matchIndex: 0,
-    value,
-    height
-  };
-};
-
-const refresh = (state, value = state.value, inputSource = User$1) => {
-  return refresh$1(state, value, inputSource);
-};
-
-const toggleMatchCase = state => {
-  const {
-    matchCase
-  } = state;
-  const newState = {
-    ...state,
-    matchCase: !matchCase
-  };
-  return refresh(newState, newState.value, User$1);
-};
-
-const toggleMatchWholeWord = state => {
-  const {
-    matchWholeWord
-  } = state;
-  const newState = {
-    ...state,
-    matchWholeWord: !matchWholeWord
-  };
-  return refresh(newState, newState.value, User$1);
-};
-
-const togglePreserveCase = state => {
-  const {
-    preserveCase
-  } = state;
-  // TODO update search results
-  return {
-    ...state,
-    preserveCase: !preserveCase
-  };
-};
-
-const toggleUseRegularExpression = state => {
-  const {
-    useRegularExpression
-  } = state;
-  const newState = {
-    ...state,
-    useRegularExpression: !useRegularExpression
-  };
-  return refresh(newState, newState.value, User$1);
-};
-
-const Close$2 = 'Close';
-const FocusNext = 'FocusNext';
-const FocusPrevious = 'FocusPrevious';
-const MatchCase$2 = 'MatchCase';
-const MatchWholeWord$2 = 'MatchWholeWord';
-const PreserveCase$1 = 'PreserveCase';
-const Replace$2 = 'Replace';
-const ReplaceAll$2 = 'ReplaceAll';
-const ReplaceValue = 'replace-value';
-const SearchValue = 'search-value';
-const ToggleReplace$1 = 'ToggleReplace';
-const UseRegularExpression$2 = 'UseRegularExpression';
-
-const applyEdits = async (editorId, edits) => {
-  // @ts-ignore
-  await invoke('Editor.applyDocumentEdits', editorId, edits);
-};
-
-/**
- * Preserves the case pattern of the original text when replacing.
- * Supports uppercase, lowercase, PascalCase, and camelCase patterns.
- */
-const preserveCase$1 = (originalText, replacementText) => {
-  if (originalText.length === 0 || replacementText.length === 0) {
-    return replacementText;
-  }
-
-  // Check if original text is all uppercase
-  if (originalText === originalText.toUpperCase()) {
-    return replacementText.toUpperCase();
-  }
-
-  // Check if original text is all lowercase
-  if (originalText === originalText.toLowerCase()) {
-    return replacementText.toLowerCase();
-  }
-
-  // Check if original text is PascalCase (first letter uppercase, rest lowercase or mixed)
-  if (originalText[0] === originalText[0].toUpperCase()) {
-    // Check if it's pure PascalCase (first uppercase, rest lowercase)
-    const restOfText = originalText.slice(1);
-    if (restOfText === restOfText.toLowerCase()) {
-      return replacementText[0].toUpperCase() + replacementText.slice(1).toLowerCase();
-    }
-    // Mixed case - preserve the pattern as much as possible
-    return replacementText[0].toUpperCase() + replacementText.slice(1).toLowerCase();
-  }
-
-  // Check if original text is camelCase (first letter lowercase, rest mixed)
-  if (originalText[0] === originalText[0].toLowerCase()) {
-    return replacementText[0].toLowerCase() + replacementText.slice(1).toLowerCase();
-  }
-
-  // Default fallback - return replacement as-is
-  return replacementText;
-};
-
-const getEdits = (matches, value, replacement, startIndex, replaceAll, lines, preserveCaseOption = false) => {
-  if (value.length === 0 || matches.length === 0) {
-    return [];
-  }
-  const edits = [];
-  const totalMatches = Math.floor(matches.length / 2);
-  const fromIndex = replaceAll ? 0 : Math.max(0, startIndex);
-  const toIndex = replaceAll ? totalMatches : Math.min(totalMatches, fromIndex + 1);
-  for (let i = fromIndex; i < toIndex; i++) {
-    const rowIndex = matches[i * 2];
-    const startColumnIndex = matches[i * 2 + 1];
-    const endColumnIndex = startColumnIndex + value.length;
-
-    // Get the original text that was matched
-    const originalText = lines[rowIndex].slice(startColumnIndex, endColumnIndex);
-
-    // Apply case preservation if enabled
-    const finalReplacement = preserveCaseOption ? preserveCase$1(originalText, replacement) : replacement;
-
-    // Convert row/column positions to character offsets
-    let startOffset = 0;
-    for (let row = 0; row < rowIndex; row++) {
-      startOffset += lines[row].length + 1; // +1 for newline character
-    }
-    startOffset += startColumnIndex;
-    let endOffset = 0;
-    for (let row = 0; row < rowIndex; row++) {
-      endOffset += lines[row].length + 1; // +1 for newline character
-    }
-    endOffset += endColumnIndex;
-    edits.push({
-      startOffset,
-      endOffset,
-      inserted: finalReplacement,
-      origin: 'find-widget.replace'
-    });
-  }
-  return edits;
-};
-
-const replace$1 = async state => {
-  const {
-    matches,
-    value,
-    replacement,
-    matchIndex,
-    editorUid,
-    lines,
-    preserveCase
-  } = state;
-  const edits = getEdits(matches, value, replacement, matchIndex, false, lines, preserveCase);
-  await applyEdits(editorUid, edits);
-  // TODO ask editor worker to apply edit
-  // TODO ask editor worker for new lines?
-  return {
-    ...state
-  };
-};
-
-const replaceAll$1 = state => {
-  const {
-    matches,
-    value,
-    replacement,
-    editorUid,
-    lines,
-    preserveCase
-  } = state;
-  const edits = getEdits(matches, value, replacement, 0, true, lines, preserveCase);
-  void applyEdits(editorUid, edits);
-  return {
-    ...state
-  };
-};
-
-const getClickHandler = name => {
-  switch (name) {
-    case Replace$2:
-      return replace$1;
-    case ReplaceAll$2:
-      return replaceAll$1;
-    case MatchCase$2:
-      return toggleMatchCase;
-    case MatchWholeWord$2:
-      return toggleMatchWholeWord;
-    case UseRegularExpression$2:
-      return toggleUseRegularExpression;
-    case PreserveCase$1:
-      return togglePreserveCase;
-    default:
-      throw new Error(`unexpected click`);
-  }
-};
-
-const handleClickButton = async (state, name) => {
-  const fn = getClickHandler(name);
-  return fn(state);
-};
-
-const handleClickClose = state => {
-  return close$1(state);
-};
-
-const handleFindWidgetFocus = (state, focusKey) => {
-  if (state.focus === focusKey) {
-    return state;
-  }
-  return {
-    ...state,
-    focus: focusKey,
-    focusSource: User
-  };
-};
-
-const handleReplaceFocus = state => {
-  return handleFindWidgetFocus(state, FocusFindWidgetReplace);
-};
-
-const handleResizerPointerDown = async (state, eventX, eventY) => {
-  return {
-    ...state,
-    resizerPointerDown: true
-  };
-};
-
-const getNewCoordinates = (oldWidth, oldX, eventX, minWidth) => {
-  const oldXEnd = oldX + oldWidth;
-  const newWidth = Math.max(oldXEnd - eventX, minWidth);
-  return {
-    newWidth,
-    newX: eventX
-  };
-};
-const handleResizerPointerMove = async (state, eventX, eventY) => {
-  const {
-    width,
-    x,
-    resizerPointerDown,
-    minWidth
-  } = state;
-  if (!resizerPointerDown) {
-    return state;
-  }
-  const {
-    newWidth,
-    newX
-  } = getNewCoordinates(width, x, eventX, minWidth);
-  return {
-    ...state,
-    x: newX,
-    width: newWidth
-  };
-};
-
-const handleResizerPointerUp = async (state, eventX, eventY) => {
-  return {
-    ...state,
-    resizerPointerDown: false
-  };
-};
-
-const toggleReplace$1 = state => {
-  const {
-    replaceExpanded,
-    value,
-    inputLineHeight,
-    inputPaddingBottom,
-    inputPaddingTop,
-    inputBorderWidth,
-    inputGap
-  } = state;
-  const newExpanded = !replaceExpanded;
-  const {
-    height
-  } = measureInputHeight(value, inputLineHeight, inputPaddingBottom, inputPaddingTop, inputBorderWidth, inputGap, newExpanded);
-  return {
-    ...state,
-    replaceExpanded: newExpanded,
-    height
-  };
-};
-
-const focusElement = (state, whenExpression) => {
-  return {
-    ...state,
-    focus: whenExpression,
-    focusSource: Script$1
-  };
-};
-
-const getNextFocus = (focus, replaceExpanded) => {
-  switch (focus) {
-    case FocusToggleReplace:
-      return FocusSearchInput;
-    case FocusSearchInput:
-      if (replaceExpanded) {
-        return FocusSearchReplaceInput;
-      }
-      return FocusSearchMatchCase;
-    case FocusSearchMatchCase:
-      return FocusSearchWholeWord;
-    case FocusSearchWholeWord:
-      return FocusSearchRegex;
-    case FocusSearchRegex:
-      if (replaceExpanded) {
-        return FocusSearchPreserveCase;
-      }
-      return FocusFindWidgetCloseButton$1;
-    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 focusNextElement = state => {
-  const {
-    focus,
-    replaceExpanded
-  } = state;
-  const nextFocus = getNextFocus(focus, replaceExpanded);
-  return focusElement(state, nextFocus);
-};
-
-const getPreviousFocus = (focus, replaceExpanded) => {
-  switch (focus) {
-    case FocusSearchInput:
-      return FocusToggleReplace;
-    case FocusSearchMatchCase:
-      if (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 (replaceExpanded) {
-        return FocusSearchReplaceAll;
-      }
-      return FocusSearchRegex;
-    case FocusSearchOpenEditors:
-      return FocusSearchIncludeInput;
-    case FocusSearchExcludeInput:
-      return FocusSearchOpenEditors;
-    case FocusIgnoreFiles:
-      return FocusSearchExcludeInput;
-    case FocusSearchIncludeInput:
-      return FocusToggleDetails;
-    case FocusFindWidgetCloseButton$1:
-      return FocusSearchRegex;
-    default:
-      return focus;
-  }
-};
-
-const focusPreviousElement = state => {
-  const {
-    focus,
-    replaceExpanded
-  } = state;
-  const previousFocus = getPreviousFocus(focus, replaceExpanded);
-  return focusElement(state, previousFocus);
-};
-
-const getKeyBindings = () => {
-  return [{
-    key: Enter,
-    command: 'FindWidget.focusNext',
-    when: FocusFindWidget$1
-  }, {
-    key: CtrlCmd | KeyF,
-    command: 'FindWidget.preventDefaultBrowserFind',
-    when: FocusFindWidget$1
-  }, {
-    key: Shift | F4,
-    command: 'FindWidget.focusPrevious',
-    when: FocusFindWidget$1
-  }, {
-    key: F4,
-    command: 'FindWidget.focusNext',
-    when: FocusFindWidget$1
-  }, {
-    key: Shift | Tab,
-    command: 'FindWidget.focusToggleReplace',
-    when: FocusFindWidget$1
-  }, {
-    key: Tab,
-    command: 'FindWidget.focusReplace',
-    when: FocusFindWidget$1
-  }, {
-    key: Tab,
-    command: 'FindWidget.focusPreviousMatchButton',
-    when: FocusFindWidgetReplace$1
-  }, {
-    key: Alt | CtrlCmd | Enter,
-    command: 'FindWidget.replaceAll',
-    when: FocusFindWidgetReplace$1
-  }, {
-    key: Tab,
-    command: 'FindWidget.focusNextMatchButton',
-    when: FocusFindWidgetPreviousMatchButton
-  }, {
-    key: Shift | Tab,
-    command: 'FindWidget.focusReplace',
-    when: FocusFindWidgetPreviousMatchButton
-  }, {
-    key: Shift | Tab,
-    command: 'FindWidget.focusPreviousMatchButton',
-    when: FocusFindWidgetNextMatchButton
-  }, {
-    key: Tab,
-    command: 'FindWidget.focusCloseButton',
-    when: FocusFindWidgetNextMatchButton
-  }, {
-    key: Shift | Tab,
-    command: 'FindWidget.focusNextMatchButton',
-    when: FocusFindWidgetCloseButton$1
-  }, {
-    key: Tab,
-    command: 'FindWidget.focusReplaceButton',
-    when: FocusFindWidgetCloseButton$1
-  }, {
-    key: Shift | Tab,
-    command: 'FindWidget.focusFind',
-    when: FocusFindWidgetReplace$1
-  }, {
-    key: Tab,
-    command: 'FindWidget.focusReplaceAllButton',
-    when: FocusFindWidgetReplaceButton
-  }, {
-    key: Shift | Tab,
-    command: 'FindWidget.focusCloseButton',
-    when: FocusFindWidgetReplaceButton
-  }, {
-    key: Shift | Tab,
-    command: 'FindWidget.focusReplaceButton',
-    when: FocusFindWidgetReplaceAllButton$1
-  }];
-};
-
-const handleInput = (state, value, inputSource = User$1) => {
-  return refresh(state, value, inputSource);
-};
-
-const handleReplaceInput = (state, value, inputSource = User$1) => {
-  return {
-    ...state,
-    replacement: value,
-    inputSource
-  };
-};
-
-const regexFlags = 'gi';
-const getSearchRegex = searchString => {
-  const escaped = escapeRegExpCharacters(searchString);
-  return new RegExp(escaped, regexFlags);
-};
-
-const findMatchesCaseInsensitive = (lines, searchString) => {
-  if (searchString.length === 0) {
-    return new Uint32Array([]);
-  }
-  const regex = getSearchRegex(searchString);
-  return findRegexMatches(lines, regex);
-};
-
-const getFindWidgetPosition = (editorX, editorY, editorWidth) => {
-  const width = 300;
-  const height = 30;
-  const paddingTop = 10;
-  const paddingRight = 20;
-  const x = editorX + editorWidth - width - paddingRight;
-  const y = editorY + paddingTop;
-  return {
-    y,
-    x,
-    width,
-    height
-  };
-};
-
-const getLines = async editorUid => {
-  // @ts-ignore
-  const lines = await invoke('Editor.getLines2', editorUid);
-  // @ts-ignore
-  return lines;
-};
-
-const getSelectedText = (lines, selections) => {
-  const startRowIndex = selections[0];
-  const startColumnIndex = selections[1];
-  const endColumnIndex = selections[3];
-  const line = lines[startRowIndex];
-  const value = line.slice(startColumnIndex, endColumnIndex);
-  return value;
-};
-
-const getSelections = async editorUid => {
-  // @ts-ignore
-  const selections = await invoke('Editor.getSelections2', editorUid);
-  // @ts-ignore
-  return selections;
-};
-
-const getSavedValue = savedState => {
-  if (savedState && savedState.value) {
-    return savedState.value;
-  }
-  return '';
-};
-const getSavedReplacement = savedState => {
-  if (savedState && savedState.replacement) {
-    return savedState.replacement;
-  }
-  return '';
-};
-const restoreState = savedState => {
-  const value = getSavedValue(savedState);
-  const replacement = getSavedReplacement(savedState);
-  return {
-    value,
-    replacement
-  };
-};
-
-const loadContent = async (state, savedState) => {
-  const {
-    editorUid,
-    editorWidth,
-    editorX,
-    editorY,
-    inputLineHeight,
-    inputPaddingBottom,
-    inputPaddingTop,
-    replaceExpanded,
-    inputBorderWidth,
-    inputGap
-  } = state;
-  const {
-    replacement,
-    value
-  } = restoreState(savedState);
-  const lines = await getLines(editorUid);
-  const selections = await getSelections(editorUid);
-  const {
-    x,
-    y,
-    width
-  } = getFindWidgetPosition(editorX, editorY, editorWidth);
-  if (lines.length === 0) {
-    return state;
-  }
-  const actualValue = value || getSelectedText(lines, selections);
-  const matches = findMatchesCaseInsensitive(lines, actualValue);
-  const matchCount = getMatchCount(matches);
-  const {
-    inputHeight,
-    height
-  } = measureInputHeight(value, inputLineHeight, inputPaddingBottom, inputPaddingTop, inputBorderWidth, inputGap, replaceExpanded);
-  return {
-    ...state,
-    focus: FocusSearchInput,
-    focused: true,
-    height,
-    inputSource: Script$1,
-    lines,
-    matchCount,
-    matches,
-    matchIndex: 0,
-    replacement,
-    searchInputHeight: inputHeight,
-    selections,
-    value: actualValue,
-    version: 1,
-    width,
-    x,
-    y
-  };
-};
-
-const preventDefaultBrowserFind = state => {
-  return state;
-};
-
-const SetBounds = 'Viewlet.setBounds';
-const SetDom2 = 'Viewlet.setDom2';
-const SetUid = 'Viewlet.setUid';
-const SetEventListeners = 'Viewlet.registerEventListeners';
-
-const renderBounds = (oldState, newState) => {
-  const {
-    x,
-    y,
-    width,
-    height,
-    uid
-  } = newState;
-  return [SetBounds, uid, x, y, width, height];
-};
-
-const HandleBlur = 'handleBlur';
-const HandleClickButton = 'handleClickButton';
-const HandleClickClose = 'handleClickClose';
-const HandleClickNextMatch = 'handleClickNextMatch';
-const HandleClickPreviousMatch = 'handleClickPreviousMatch';
-const HandleClickReplace = 'handleClickReplace';
-const HandleClickReplaceAll = 'handleClickReplaceAll';
-const HandleClickToggleReplace = 'handleClickToggleReplace';
-const HandleFocus = 'handleFocus';
-const HandleFocusNext = 'handleFocusNext';
-const HandleFocusPrevious = 'handleFocusPrevious';
-const HandleInput = 'handleInput';
-const HandleReplaceFocus = 'handleReplaceFocus';
-const HandleReplaceInput = 'handleReplaceInput';
-const HandleResizerPointerDown = 'handleResizerPointerDown';
-const HandleResizerPointerMove = 'handleResizerPointerMove';
-const HandleResizerPointerUp = 'handleResizerPointerUp';
-const HandleToggleReplaceFocus = 'handleToggleReplaceFocus';
-
-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);
-};
-
-const MatchOf = '{PH1} of {PH2}';
-const NoResults = 'No Results';
-const PreserveCase = 'Preserve Case';
-const Close$1 = 'Close';
-const PreviousMatch = 'Previous Match';
-const NextMatch = 'Next Match';
-const Find$1 = 'Find';
-const Replace$1 = 'Replace';
-const ReplaceAll$1 = 'Replace All';
-const MatchCase$1 = 'Match Case';
-const MatchWholeWord$1 = 'Match Whole Word';
-const UseRegularExpression$1 = 'Use Regular Expression';
-const ToggleReplace = 'Toggle Replace';
-
-const noResults = () => {
-  return i18nString(NoResults);
-};
-const preserveCase = () => {
-  return i18nString(PreserveCase);
-};
-const matchOf = (matchIndex, matchCount) => {
-  return i18nString(MatchOf, {
-    PH1: matchIndex,
-    PH2: matchCount
-  });
-};
-const previousMatch = () => {
-  return i18nString(PreviousMatch);
-};
-const nextMatch = () => {
-  return i18nString(NextMatch);
-};
-const close = () => {
-  return i18nString(Close$1);
-};
-const find = () => {
-  return i18nString(Find$1);
-};
-const replace = () => {
-  return i18nString(Replace$1);
-};
-const replaceAll = () => {
-  return i18nString(ReplaceAll$1);
-};
-const matchCase = () => {
-  return i18nString(MatchCase$1);
-};
-const matchWholeWord = () => {
-  return i18nString(MatchWholeWord$1);
-};
-const useRegularExpression = () => {
-  return i18nString(UseRegularExpression$1);
-};
-const toggleReplace = () => {
-  return i18nString(ToggleReplace);
-};
-
-const MatchCase = 'CaseSensitive';
-const UseRegularExpression = 'Regex';
-const MatchWholeWord = 'WholeWord';
-const ArrowDown = 'ArrowDown';
-const ArrowUp = 'ArrowUp';
-const Close = 'Close';
-const Replace = 'Replace';
-const ReplaceAll = 'ReplaceAll';
-
-const getFindWidgetButtons = (findButtonsEnabled, replaceButtonsEnabled, matchCase$1, matchWholeWord$1, useRegularExpression$1, preserveCase$1) => {
-  const findFieldButtons = [{
-    checked: matchCase$1,
-    icon: MatchCase,
-    title: matchCase(),
-    name: MatchCase$2,
-    onClick: HandleClickButton
-  }, {
-    checked: matchWholeWord$1,
-    icon: MatchWholeWord,
-    title: matchWholeWord(),
-    name: MatchWholeWord$2,
-    onClick: HandleClickButton
-  }, {
-    checked: useRegularExpression$1,
-    icon: UseRegularExpression,
-    title: useRegularExpression(),
-    name: UseRegularExpression$2,
-    onClick: HandleClickButton
-  }];
-  const replaceFieldButtons = [{
-    checked: preserveCase$1,
-    icon: 'PreserveCase',
-    title: preserveCase(),
-    name: PreserveCase$1,
-    onClick: HandleClickButton
-  }];
-  const findButtons = [{
-    label: previousMatch(),
-    icon: ArrowUp,
-    disabled: !findButtonsEnabled,
-    onClick: HandleClickPreviousMatch,
-    name: FocusPrevious
-  }, {
-    label: nextMatch(),
-    icon: ArrowDown,
-    disabled: !findButtonsEnabled,
-    onClick: HandleClickNextMatch,
-    name: FocusNext
-  }, {
-    label: close(),
-    icon: Close,
-    disabled: false,
-    onClick: HandleClickClose,
-    name: Close$2
-  }];
-  const replaceButtons = [{
-    label: replace(),
-    icon: Replace,
-    disabled: !replaceButtonsEnabled,
-    onClick: HandleClickButton,
-    name: Replace$2
-  }, {
-    label: replaceAll(),
-    icon: ReplaceAll,
-    disabled: !replaceButtonsEnabled,
-    onClick: HandleClickButton,
-    name: ReplaceAll$2
-  }];
-  return {
-    findButtons,
-    findFieldButtons,
-    replaceButtons,
-    replaceFieldButtons
-  };
-};
-
-const getFindWidgetButtonsEnabled = (matchCount, value) => {
-  const findButtonsEnabled = matchCount > 0;
-  const replaceButtonsEnabled = value.length > 0;
-  return {
-    findButtonsEnabled,
-    replaceButtonsEnabled
-  };
-};
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-
-const text = data => {
-  return {
-    type: Text,
-    text: data,
-    childCount: 0
-  };
-};
-
-const FindWidget = 'FindWidget';
-const FindWidgetFind = 'FindWidgetFind';
-const FindWidgetMatchCount = 'FindWidgetMatchCount';
-const FindWidgetMatchCountEmpty = 'FindWidgetMatchCountEmpty';
-const FindWidgetReplace = 'FindWidgetReplace';
-const FindWidgetRight = 'FindWidgetRight';
-const IconButton = 'IconButton';
-const IconButtonDisabled = 'IconButtonDisabled';
-const MaskIcon = 'MaskIcon';
-const MaskIconChevronDown = 'MaskIconChevronDown';
-const MaskIconChevronRight = 'MaskIconChevronRight';
-const MultilineInputBox = 'MultilineInputBox';
-const Resizer = 'Resizer';
-const ResizerHighlight = 'ResizerHighlight';
-const SearchField = 'SearchField';
-const SearchFieldButton = 'SearchFieldButton';
-const SearchFieldButtonChecked = 'SearchFieldButtonChecked';
-const SearchFieldButtons = 'SearchFieldButtons';
-const SearchFieldError = 'SearchFieldError';
-const SearchFieldFocused = 'SearchFieldFocused';
-const SearchToggleButton = 'SearchToggleButton';
-const SearchToggleButtonExpanded = 'SearchToggleButtonExpanded';
-const Viewlet = 'Viewlet';
-const ViewletFind = 'ViewletFind';
-const ViewletFindWidget = 'ViewletFindWidget';
-
-const getIconVirtualDom = (icon, type = Div) => {
-  return {
-    type,
-    className: `${MaskIcon} MaskIcon${icon}`,
-    role: None,
-    childCount: 0
-  };
-};
-
-const getIconButtonVirtualDom = iconButton => {
-  const {
-    label,
-    icon,
-    disabled,
-    name,
-    onClick
-  } = iconButton;
-  let className = IconButton;
-  if (disabled) {
-    className += ' ' + IconButtonDisabled;
-  }
-  return [{
-    type: Button,
-    className,
-    title: label,
-    ariaLabel: label,
-    childCount: 1,
-    disabled: disabled ? true : undefined,
-    onClick,
-    name
-  }, getIconVirtualDom(icon)];
-};
-
-const emptyMatches = mergeClassNames(FindWidgetMatchCount, FindWidgetMatchCountEmpty);
-const getFindMatchCountClassName = (matchCount, hasValue) => {
-  if (hasValue && matchCount === 0) {
-    return emptyMatches;
-  }
-  return FindWidgetMatchCount;
-};
-
-const getMatchCountVirtualDom = (matchCountText, matchCount, hasValue) => {
-  return [{
-    type: Div,
-    className: getFindMatchCountClassName(matchCount, hasValue),
-    childCount: 1
-  }, text(matchCountText)];
-};
-
-const checkedClassName = mergeClassNames(SearchFieldButton, SearchFieldButtonChecked);
-const unCheckedClassName = SearchFieldButton;
-const getSearchFieldButtonVirtualDom = button => {
-  const {
-    icon,
-    checked,
-    title,
-    name,
-    onClick
-  } = button;
-  return [{
-    type: Button,
-    ariaChecked: checked,
-    className: checked ? checkedClassName : unCheckedClassName,
-    name,
-    role: CheckBox,
-    tabIndex: 0,
-    title,
-    childCount: 1,
-    onClick
-  }, {
-    type: Div,
-    className: mergeClassNames(MaskIcon, `MaskIcon${icon}`),
-    childCount: 0
-  }];
-};
-
-const getSearchFieldVirtualDom = (name, placeholder, onInput, insideButtons, outsideButtons, onFocus, extraClassName) => {
-  const dom = [{
-    type: Div,
-    className: mergeClassNames(SearchField, extraClassName),
-    role: None,
-    childCount: 2
-  }, {
-    type: TextArea,
-    className: MultilineInputBox,
-    spellcheck: false,
-    autocapitalize: 'off',
-    autocorrect: 'off',
-    placeholder,
-    name,
-    onInput,
-    onFocus,
-    childCount: 0
-  }, {
-    type: Div,
-    className: SearchFieldButtons,
-    childCount: insideButtons.length
-  }, ...insideButtons.flatMap(getSearchFieldButtonVirtualDom)];
-  if (outsideButtons.length > 0) {
-    throw new Error('outsideButtons are deprecated');
-  }
-  return dom;
-};
-
-const getExtraClassName = (hasError, inputFocused) => {
-  if (hasError) {
-    return SearchFieldError;
-  }
-  if (inputFocused) {
-    return SearchFieldFocused;
-  }
-  return '';
-};
-const getFindWidgetFindVirtualDom = (matchCountText, buttons, fieldButtons, matchCount, hasValue, hasError, inputFocused) => {
-  const extraClassName = getExtraClassName(hasError, inputFocused);
-  return [{
-    type: Div,
-    className: FindWidgetFind,
-    childCount: 2
-  }, ...getSearchFieldVirtualDom(SearchValue, find(), HandleInput, fieldButtons, [], HandleFocus, extraClassName), {
-    type: Div,
-    className: 'FindWidgetActions',
-    childCount: 1 + buttons.length
-  }, ...getMatchCountVirtualDom(matchCountText, matchCount, hasValue), ...buttons.flatMap(getIconButtonVirtualDom)];
-};
-
-const getFindWidgetReplaceVirtualDom = (replaceExpanded, replaceButtons, replaceFieldButtons, replaceInputFocused) => {
-  if (!replaceExpanded) {
-    return [];
-  }
-  const extraClassName = replaceInputFocused ? SearchFieldFocused : '';
-  return [{
-    type: Div,
-    className: FindWidgetReplace,
-    childCount: 1 + replaceButtons.length
-  }, ...getSearchFieldVirtualDom(ReplaceValue, replace(), HandleReplaceInput, [], [], HandleReplaceFocus, extraClassName), ...replaceButtons.flatMap(getIconButtonVirtualDom)];
-};
-
-const getResizerVirtualDom = () => {
-  return [{
-    type: Div,
-    className: Resizer,
-    childCount: 1,
-    onPointerDown: HandleResizerPointerDown
-  }, {
-    type: Div,
-    className: ResizerHighlight,
-    childCount: 0
-  }];
-};
-
-const getSearchToggleButtonVirtualDom = (replaceExpanded, onClick = '') => {
-  const title = toggleReplace();
-  return [{
-    type: Button,
-    className: mergeClassNames(IconButton, SearchToggleButton, replaceExpanded ? SearchToggleButtonExpanded : ''),
-    title,
-    ariaLabel: title,
-    ariaExpanded: replaceExpanded,
-    name: ToggleReplace$1,
-    childCount: 1,
-    'data-command': 'toggleReplace',
-    onClick,
-    onFocus: HandleToggleReplaceFocus
-  }, {
-    type: Div,
-    className: mergeClassNames(MaskIcon, replaceExpanded ? MaskIconChevronDown : MaskIconChevronRight),
-    childCount: 0
-  }];
-};
-
-const parentNode = {
-  type: Div,
-  className: mergeClassNames(Viewlet, ViewletFind, ViewletFindWidget, FindWidget),
-  childCount: 3,
-  role: Group
-};
-const getFindWidgetVirtualDom = (matchCountText, replaceExpanded, findButtons, findFieldButtons, replaceButtons, replaceFieldButtons, matchCount, value, hasError, inputFocused, replaceInputFocused) => {
-  return [parentNode, ...getResizerVirtualDom(), ...getSearchToggleButtonVirtualDom(replaceExpanded, 'handleClickToggleReplace'), {
-    type: Div,
-    className: FindWidgetRight,
-    childCount: replaceExpanded ? 2 : 1
-  }, ...getFindWidgetFindVirtualDom(matchCountText, findButtons, findFieldButtons, matchCount, Boolean(value), hasError, inputFocused), ...getFindWidgetReplaceVirtualDom(replaceExpanded, replaceButtons, replaceFieldButtons, replaceInputFocused)];
-};
-
-const getMatchCountText = (matchIndex, matchCount) => {
-  if (matchCount === 0) {
-    return noResults();
-  }
-  return matchOf(matchIndex + 1, matchCount);
-};
-
-const renderContent = (oldState, newState) => {
-  const {
-    focus,
-    uid,
-    matchCount,
-    value,
-    replaceExpanded,
-    matchCase,
-    matchWholeWord,
-    useRegularExpression,
-    preserveCase,
-    inputErrorMessage
-  } = newState;
-  const matchCountText = getMatchCountText(newState.matchIndex, newState.matchCount);
-  const {
-    findButtonsEnabled,
-    replaceButtonsEnabled
-  } = getFindWidgetButtonsEnabled(matchCount, value);
-  const {
-    findButtons,
-    replaceButtons,
-    findFieldButtons,
-    replaceFieldButtons
-  } = getFindWidgetButtons(findButtonsEnabled, replaceButtonsEnabled, matchCase, matchWholeWord, useRegularExpression, preserveCase);
-  const hasError = Boolean(inputErrorMessage);
-  const inputFocused = focus === FocusSearchInput;
-  const replaceInputFocused = focus === FocusSearchReplaceInput;
-  const dom = getFindWidgetVirtualDom(matchCountText, replaceExpanded, findButtons, findFieldButtons, replaceButtons, replaceFieldButtons, matchCount, value, hasError, inputFocused, replaceInputFocused);
-  return [SetDom2, uid, dom];
-};
-
-const renderCss = (oldState, newState) => {
-  const {
-    uid,
-    width,
-    height,
-    x,
-    y,
-    searchInputHeight: inputHeight
-  } = newState;
-  const css = `:root {
-  --FindWidgetWidth: ${width}px;
-  --FindWidgetHeight: ${height}px;
-  --FindWidgetX: ${x}px;
-  --FindWidgetY: ${y}px;
-  --FindWidgetInputHeight: ${inputHeight}px;
-}`;
-  return [SetCss, uid, css];
-};
-
-const getEventListeners = (uid, widgetId) => {
-  return [{
-    name: HandleInput,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleInput', 0, widgetId, 'event.target.value']
-  }, {
-    name: HandleClickClose,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickClose', 0, widgetId]
-  }, {
-    name: HandleClickPreviousMatch,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.focusPrevious', 0, widgetId]
-  }, {
-    name: HandleClickNextMatch,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.focusNext', 0, widgetId]
-  }, {
-    name: HandleClickReplace,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplace', 0, widgetId]
-  }, {
-    name: HandleClickReplace,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplaceAll', 0, widgetId]
-  }, {
-    name: HandleClickToggleReplace,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.toggleReplace', 0, widgetId]
-  }, {
-    name: HandleBlur,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleBlur', 0, widgetId]
-  }, {
-    name: HandleReplaceInput,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleReplaceInput', 0, widgetId]
-  }, {
-    name: HandleReplaceFocus,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleReplaceFocus', 0, widgetId]
-  }, {
-    name: HandleFocusPrevious,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleFocusPrevious', 0, widgetId]
-  }, {
-    name: HandleFocusNext,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleFocusNext', 0, widgetId]
-  }, {
-    name: HandleClickReplaceAll,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickReplaceAll', 0, widgetId]
-  }, {
-    name: HandleClickButton,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleClickButton', 0, widgetId, TargetName]
-  }, {
-    name: HandleResizerPointerDown,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleResizerPointerDown', 0, widgetId, ClientX, ClientY],
-    trackPointerEvents: [HandleResizerPointerMove, HandleResizerPointerUp]
-  }, {
-    name: HandleResizerPointerMove,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleResizerPointerMove', 0, widgetId, ClientX, ClientY]
-  }, {
-    name: HandleResizerPointerUp,
-    params: ['executeWidgetCommand', 'FindWidget', 'FindWidget.handleResizerPointerUp', 0, widgetId, ClientX, ClientY]
-  }];
-};
-
-const Find = 5;
-
-const renderEventListeners = state => {
-  const {
-    uid
-  } = state;
-  const eventListeners = getEventListeners(uid, Find);
-  return [SetEventListeners, uid, eventListeners];
-};
-
-const getFocusSelector = focusKey => {
-  switch (focusKey) {
-    case FocusSearchInput:
-      return SearchValue;
-    case FocusSearchReplaceInput:
-      return ReplaceValue;
-    case FocusSearchMatchCase:
-      return MatchCase$2;
-    case FocusSearchPreserveCase:
-      return PreserveCase$1;
-    case FocusSearchRegex:
-      return UseRegularExpression$2;
-    case FocusSearchWholeWord:
-      return MatchWholeWord$2;
-    case FocusSearchReplaceAll:
-      return ReplaceAll$2;
-    case FocusToggleReplace:
-      return ToggleReplace$1;
-    case FocusFindWidgetCloseButton$1:
-      return Close$2;
-    default:
-      return '';
-  }
-};
-
-const renderFocus = (oldState, newState) => {
-  const {
-    uid,
-    focus
-  } = newState;
-  const name = getFocusSelector(focus);
-  const selector = `[name="${name}"]`;
-  return [FocusSelector, uid, selector];
-};
-
-const FocusFindWidget = 16;
-
-const renderFocusContext = (oldState, newState) => {
-  return [/* method */SetFocusContext, FocusFindWidget];
-};
-
-const renderReplaceValue = (oldState, newState) => {
-  const {
-    uid,
-    replacement
-  } = newState;
-  return [SetValueByName, uid, ReplaceValue, replacement];
-};
-
-const renderUid = (oldState, newState) => {
-  const {
-    uid,
-    editorUid
-  } = newState;
-  return [SetUid, uid, editorUid];
-};
-
-const renderValue = (oldState, newState) => {
-  const {
-    uid,
-    value
-  } = newState;
-  return [SetValueByName, uid, SearchValue, value];
-};
-
-const getRenderer = diffType => {
-  switch (diffType) {
-    case RenderContent:
-      return renderContent;
-    case RenderBounds:
-      return renderBounds;
-    case RenderEventListeners:
-      return renderEventListeners;
-    case RenderUid:
-      return renderUid;
-    case RenderFocusContext:
-      return renderFocusContext;
-    case RenderFocus:
-      return renderFocus;
-    case RenderValue:
-      return renderValue;
-    case RenderReplaceValue:
-      return renderReplaceValue;
-    case RenderCss:
-      return renderCss;
-    default:
-      throw new Error('unknown renderer');
-  }
-};
-
-const applyRender = (oldState, newState, diffResult) => {
-  const commands = [];
-  for (const item of diffResult) {
-    const fn = getRenderer(item);
-    commands.push(fn(oldState, newState));
-  }
-  return commands;
-};
-
-const render2 = (uid, diffResult) => {
-  const {
-    oldState,
-    newState
-  } = get(uid);
-  set(uid, newState, newState);
-  const commands = applyRender(oldState, newState, diffResult);
-  return commands;
-};
-
-const resize = async (state, dimensions) => {
-  return state;
-};
-
-const saveState = state => {
-  const {
-    width,
-    value,
-    replacement,
-    matchCase,
-    matchWholeWord,
-    useRegularExpression,
-    replaceExpanded
-  } = state;
-  return {
-    width,
-    value,
-    replacement,
-    matchCase,
-    matchWholeWord,
-    useRegularExpression,
-    replaceExpanded
-  };
-};
-
-const commandMap = {
-  'FindWidget.create': create,
-  'FindWidget.diff2': diff2,
-  'FindWidget.close': wrapCommand(close$1),
-  'FindWidget.dispose': dispose,
-  'FindWidget.focusCloseButton': wrapCommand(focusCloseButton),
-  'FindWidget.focusElement': wrapCommand(focusElement),
-  'FindWidget.focusFirst': wrapCommand(focusFirst),
-  'FindWidget.focusIndex': wrapCommand(focusIndex),
-  'FindWidget.focusLast': wrapCommand(focusLast),
-  'FindWidget.focusNext': wrapCommand(focusNext),
-  'FindWidget.focusNextElement': wrapCommand(focusNextElement),
-  'FindWidget.focusPrevious': wrapCommand(focusPrevious),
-  'FindWidget.focusPreviousElement': wrapCommand(focusPreviousElement),
-  'FindWidget.focusReplace': wrapCommand(focusReplace),
-  'FindWidget.focusReplaceAllButton': wrapCommand(focusReplaceAllButton),
-  'FindWidget.getCommandIds': getCommandIds,
-  'FindWidget.getKeyBindings': getKeyBindings,
-  'FindWidget.handleBlur': wrapCommand(handleBlur),
-  'FindWidget.handleClickButton': wrapCommand(handleClickButton),
-  'FindWidget.handleClickClose': wrapCommand(handleClickClose),
-  'FindWidget.handleInput': wrapCommand(handleInput),
-  'FindWidget.handleReplaceFocus': wrapCommand(handleReplaceFocus),
-  'FindWidget.handleReplaceInput': wrapCommand(handleReplaceInput),
-  'FindWidget.handleResizerPointerDown': wrapCommand(handleResizerPointerDown),
-  'FindWidget.handleResizerPointerMove': wrapCommand(handleResizerPointerMove),
-  'FindWidget.handleResizerPointerUp': wrapCommand(handleResizerPointerUp),
-  'FindWidget.loadContent': wrapCommand(loadContent),
-  'FindWidget.preventDefaultBrowserFind': wrapCommand(preventDefaultBrowserFind),
-  'FindWidget.render2': render2,
-  'FindWidget.replace': wrapCommand(replace$1),
-  'FindWidget.replaceAll': wrapCommand(replaceAll$1),
-  'FindWidget.resize': wrapCommand(resize),
-  'FindWidget.saveState': wrapGetter(saveState),
-  'FindWidget.terminate': terminate,
-  'FindWidget.toggleMatchCase': wrapCommand(toggleMatchCase),
-  'FindWidget.toggleReplace': wrapCommand(toggleReplace$1),
-  'FindWidget.toggleUseRegularExpression': wrapCommand(toggleUseRegularExpression),
-  'FindWidget.togglePreserveCase': wrapCommand(togglePreserveCase),
-  'FindWidget.toggleMatchWholeWord': wrapCommand(toggleMatchWholeWord)
-};
-
-const listen = async () => {
-  registerCommands(commandMap);
-  const rpc = await WebWorkerRpcClient.create({
-    commandMap: commandMap
-  });
-  set$1(rpc);
-};
-
-const main = async () => {
-  await listen();
-};
-
-main();