@lvce-editor/static-server 0.78.0 → 0.79.1

package/static/5a230ea/packages/test-worker/dist/testWorkerMain.js

@@ -1,4707 +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;
-    }
-  }
-}
-
-let AssertionError$1 = class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-};
-const Object$1 = 1;
-const Number$1 = 2;
-const Array$1 = 3;
-const String$1 = 4;
-const Boolean$1 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown = 8;
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return Number$1;
-    case 'function':
-      return Function;
-    case 'string':
-      return String$1;
-    case 'object':
-      if (value === null) {
-        return Null;
-      }
-      if (Array.isArray(value)) {
-        return Array$1;
-      }
-      return Object$1;
-    case 'boolean':
-      return Boolean$1;
-    default:
-      return Unknown;
-  }
-};
-const object = value => {
-  const type = getType(value);
-  if (type !== Object$1) {
-    throw new AssertionError$1('expected value to be of type object');
-  }
-};
-const string$1 = value => {
-  const type = getType(value);
-  if (type !== String$1) {
-    throw new AssertionError$1('expected value to be of type string');
-  }
-};
-
-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 {
-    code: ERR_MODULE_NOT_FOUND,
-    message
-  };
-};
-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 {
-    code: E_INCOMPATIBLE_NATIVE_MODULE,
-    message: `Incompatible native node module: ${message}`
-  };
-};
-const getModuleSyntaxError = () => {
-  return {
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
-    message: `ES Modules are 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 {
-    code: '',
-    message: actualMessage,
-    stack: rest
-  };
-};
-class IpcError extends VError {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        code,
-        message,
-        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 {
-    promise,
-    resolve
-  } = 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({
-      id: firstMessage.id,
-      jsonrpc: '2.0',
-      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 = {
-  listen: listen$6,
-  wrap: wrap$e
-};
-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 {
-    promise,
-    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({
-        event,
-        type
-      });
-    };
-    addListener(eventEmitter, event, listener);
-    listenerMap[event] = listener;
-  }
-  return promise;
-};
-const Message$1 = 3;
-const create$5$1 = async ({
-  isMessagePortOpen,
-  messagePort
-}) => {
-  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,
-    type
-  } = await eventPromise;
-  if (type !== Message$1) {
-    throw new IpcError('Failed to wait for ipc message');
-  }
-  if (event.data !== readyMessage) {
-    throw new IpcError('unexpected first message');
-  }
-  return messagePort;
-};
-const signal$1 = messagePort => {
-  messagePort.start();
-};
-class IpcParentWithMessagePort extends Ipc {
-  getData = getData$2;
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    this._rawIpc.close();
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-  }
-  onClose(callback) {}
-}
-const wrap$5 = messagePort => {
-  return new IpcParentWithMessagePort(messagePort);
-};
-const IpcParentWithMessagePort$1 = {
-  create: create$5$1,
-  signal: signal$1,
-  wrap: wrap$5
-};
-
-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$2 = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
-const Two$1 = '2.0';
-const callbacks$1 = Object.create(null);
-const get$2 = id => {
-  return callbacks$1[id];
-};
-const remove$2 = id => {
-  delete callbacks$1[id];
-};
-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 ReferenceError$1:
-        return ReferenceError;
-      case SyntaxError$1:
-        return SyntaxError;
-      case TypeError$1:
-        return TypeError;
-      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$1 = (id, response) => {
-  const fn = get$2(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(response);
-  remove$2(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,
-      data: error.stack,
-      message: error.message
-    };
-  }
-  return {
-    code: Custom,
-    data: {
-      code: prettyError.code,
-      codeFrame: prettyError.codeFrame,
-      name: prettyError.name,
-      stack: getStack(prettyError),
-      type: getErrorType(prettyError)
-    },
-    message: prettyError.message
-  };
-};
-const create$1$1 = (id, error) => {
-  return {
-    error,
-    id,
-    jsonrpc: Two$1
-  };
-};
-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$9 = (message, result) => {
-  return {
-    id: message.id,
-    jsonrpc: Two$1,
-    result: result ?? null
-  };
-};
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
-};
-const getErrorResponseSimple = (id, error) => {
-  return {
-    error: {
-      code: Custom,
-      data: error,
-      // @ts-ignore
-      message: error.message
-    },
-    id,
-    jsonrpc: Two$1
-  };
-};
-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$1;
-
-// 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 {
-      execute: options.execute,
-      ipc: options.ipc,
-      logError: options.logError || defaultLogError,
-      message: options.message,
-      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket,
-      resolve: options.resolve || defaultResolve
-    };
-  }
-  return {
-    execute: args[2],
-    ipc: args[0],
-    logError: args[5],
-    message: args[1],
-    preparePrettyError: args[4],
-    requiresSocket: args[6],
-    resolve: args[3]
-  };
-};
-const handleJsonRpcMessage = async (...args) => {
-  const options = normalizeParams(args);
-  const {
-    execute,
-    ipc,
-    logError,
-    message,
-    preparePrettyError,
-    requiresSocket,
-    resolve
-  } = 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 Two = '2.0';
-
-const create$8 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-
-const create$7 = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two,
-    method,
-    params
-  };
-  return message;
-};
-
-let id = 0;
-const create$6 = () => {
-  return ++id;
-};
-
-const registerPromise = map => {
-  const id = create$6();
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  map[id] = resolve;
-  return {
-    id,
-    promise
-  };
-};
-
-const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
-  const {
-    id,
-    promise
-  } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const createRpc = ipc => {
-  const callbacks = Object.create(null);
-  ipc._resolve = (id, response) => {
-    const fn = callbacks[id];
-    if (!fn) {
-      console.warn(`callback ${id} may already be disposed`);
-      return;
-    }
-    fn(response);
-    delete callbacks[id];
-  };
-  const rpc = {
-    async dispose() {
-      await ipc?.dispose();
-    },
-    invoke(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, false);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeHelper(callbacks, ipc, method, params, true);
-    },
-    // @ts-ignore
-    ipc,
-    /**
-     * @deprecated
-     */
-    send(method, ...params) {
-      const message = create$8(method, params);
-      ipc.send(message);
-    }
-  };
-  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$2;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._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$5 = async ({
-  commandMap,
-  isMessagePortOpen = true,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
-};
-
-const create$4 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$5({
-    commandMap,
-    isMessagePortOpen,
-    messagePort: port2
-  });
-};
-
-const createSharedLazyRpc = factory => {
-  let rpcPromise;
-  const getOrCreate = () => {
-    if (!rpcPromise) {
-      rpcPromise = factory();
-    }
-    return rpcPromise;
-  };
-  return {
-    async dispose() {
-      const rpc = await getOrCreate();
-      await rpc.dispose();
-    },
-    async invoke(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invoke(method, ...params);
-    },
-    async invokeAndTransfer(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    async send(method, ...params) {
-      const rpc = await getOrCreate();
-      rpc.send(method, ...params);
-    }
-  };
-};
-
-const create$3 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  return createSharedLazyRpc(() => {
-    return create$4({
-      commandMap,
-      isMessagePortOpen,
-      send
-    });
-  });
-};
-
-const create$2 = async ({
-  commandMap,
-  isMessagePortOpen,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-
-const create$1 = 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 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 = {
-    invocations,
-    invoke,
-    invokeAndTransfer: invoke
-  };
-  return mockRpc;
-};
-
-const rpcs = Object.create(null);
-const set$4 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-const remove$1 = id => {
-  delete rpcs[id];
-};
-
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create = rpcId => {
-  return {
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
-    },
-    // @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);
-    },
-    registerMockRpc(commandMap) {
-      const mockRpc = createMockRpc({
-        commandMap
-      });
-      set$4(rpcId, mockRpc);
-      // @ts-ignore
-      mockRpc[Symbol.dispose] = () => {
-        remove$1(rpcId);
-      };
-      // @ts-ignore
-      return mockRpc;
-    },
-    set(rpc) {
-      set$4(rpcId, rpc);
-    }
-  };
-};
-
-const Directory = 3;
-
-const Script$1 = 2;
-
-const Web = 1;
-const Remote = 3;
-
-const EditorWorker = 99;
-const OpenerWorker = 4561;
-const RendererWorker = 1;
-const TestWorker = 9001;
-
-const {
-  invoke: invoke$2,
-  set: set$3
-} = create(EditorWorker);
-
-const {
-  invoke: invoke$1,
-  set: set$2
-} = create(OpenerWorker);
-
-const {
-  invoke,
-  invokeAndTransfer,
-  set: set$1
-} = create(RendererWorker);
-const sendMessagePortToEditorWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
-};
-const sendMessagePortToOpenerWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
-};
-const readFile$1 = async uri => {
-  return invoke('FileSystem.readFile', uri);
-};
-const getPreference = async key => {
-  return await invoke('Preferences.get', key);
-};
-
-const send$1 = async port => {
-  await sendMessagePortToEditorWorker(port, TestWorker);
-};
-const initializeEditorWorker = async () => {
-  const rpc = await create$3({
-    commandMap: {},
-    send: send$1
-  });
-  set$3(rpc);
-};
-
-const send = async port => {
-  await sendMessagePortToOpenerWorker(port, TestWorker);
-};
-const initializeOpenerWorker = async () => {
-  const rpc = await create$3({
-    commandMap: {},
-    send
-  });
-  set$2(rpc);
-};
-
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-
-const webViews = Object.create(null);
-const set = (id, webView) => {
-  webViews[id] = webView;
-};
-const get = id => {
-  return webViews[id];
-};
-
-const getLocatorInvoke = locator => {
-  if (locator.webViewId) {
-    const module = get(locator.webViewId);
-    return module.invoke;
-  }
-  return invoke;
-};
-
-const locatorInvoke = async (locator, method, ...params) => {
-  object(locator);
-  string$1(method);
-  const invoke = getLocatorInvoke(locator);
-  return invoke(method, ...params);
-};
-
-const printLocator = locator => {
-  if (locator._nth !== -1) {
-    return `${locator._selector}:nth(${locator._nth})`;
-  }
-  if (locator._hasText) {
-    return `${locator._selector} "${locator._hasText}"`;
-  }
-  return `${locator._selector}`;
-};
-
-const toBeVisible = locator => {
-  return `expected selector to be visible ${locator._selector}`;
-};
-const toHaveValue = (locator, {
-  value
-}) => {
-  return `expected selector ${locator._selector} to have value ${value}`;
-};
-const toHaveText = async (locator, options) => {
-  const locatorString = printLocator(locator);
-  const {
-    actual,
-    wasFound
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveText', locator, options);
-  const {
-    text
-  } = options;
-  if (!wasFound) {
-    return `expected selector ${locatorString} to have text "${text}" element was not found`;
-  }
-  return `expected selector ${locatorString} to have text "${text}" but was "${actual}"`;
-};
-const toContainText = async (locator, options) => {
-  const locatorString = printLocator(locator);
-  const {
-    actual,
-    wasFound
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toContainText', locator, options);
-  const {
-    text
-  } = options;
-  if (!wasFound) {
-    return `expected selector ${locatorString} to contain text "${text}" element was not found`;
-  }
-  return `expected selector ${locatorString} to contain text "${text}" but was "${actual}"`;
-};
-const toHaveAttribute = async (locator, options) => {
-  const locatorString = printLocator(locator);
-  const {
-    actual,
-    wasFound
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveAttribute', locator, options);
-  const {
-    key,
-    value
-  } = options;
-  if (!wasFound) {
-    return `expected ${locatorString} to have attribute ${key} ${value} but element was not found`;
-  }
-  return `expected ${locatorString} to have attribute ${key} ${value} but was ${actual}`;
-};
-const toHaveCount = async (locator, {
-  count
-}) => {
-  const locatorString = printLocator(locator);
-  const {
-    actual
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveCount', locator);
-  return `expected ${locatorString} to have count ${count} but was ${actual}`;
-};
-const toBeFocused = async locator => {
-  const locatorString = printLocator(locator);
-  const {
-    actual
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toBeFocused', locator);
-  return `expected ${locatorString} to be focused but active element is ${actual}`;
-};
-const toHaveClass = async (locator, options) => {
-  const locatorString = printLocator(locator);
-  const {
-    wasFound
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveClass', locator, options);
-  const {
-    className
-  } = options;
-  if (!wasFound) {
-    return `expected ${locatorString} to have class ${className} but element was not found`;
-  }
-  return `expected ${locatorString} to have class ${className}`;
-};
-const toHaveId = async (locator, options) => {
-  const {
-    actual,
-    wasFound
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveId', locator, options);
-  const locatorString = printLocator(locator);
-  const {
-    id
-  } = options;
-  if (!wasFound) {
-    return `expected ${locatorString} to have id ${id} but element was not found`;
-  }
-  return `expected ${locatorString} to have id ${id} but was ${actual}`;
-};
-const toBeHidden = locator => {
-  const locatorString = printLocator(locator);
-  return `expected ${locatorString} to be hidden`;
-};
-const toHaveCss = async (locator, options) => {
-  const {
-    actual,
-    wasFound
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveCss', locator, options);
-  const locatorString = printLocator(locator);
-  const {
-    key,
-    value
-  } = options;
-  if (!wasFound) {
-    return `expected ${locatorString} to have css ${key} ${value} but element was not found`;
-  }
-  return `expected ${locatorString} to have css ${key} ${value} but was ${actual}`;
-};
-const toHaveJSProperty = async (locator, options) => {
-  const {
-    actual,
-    wasFound
-  } = await locatorInvoke(locator, 'TestFrameWork.checkConditionError', 'toHaveJSProperty', locator, options);
-  const locatorString = printLocator(locator);
-  const {
-    key,
-    value
-  } = options;
-  if (!wasFound) {
-    return `expected ${locatorString} to have js property ${key} ${value} but element was not found`;
-  }
-  return `expected ${locatorString} to have js property ${key} ${value} but was ${actual}`;
-};
-
-const getFunction = fnName => {
-  switch (fnName) {
-    case 'toBeFocused':
-      return toBeFocused;
-    case 'toBeHidden':
-      return toBeHidden;
-    case 'toBeVisible':
-      return toBeVisible;
-    case 'toContainText':
-      return toContainText;
-    case 'toHaveAttribute':
-      return toHaveAttribute;
-    case 'toHaveClass':
-      return toHaveClass;
-    case 'toHaveCount':
-      return toHaveCount;
-    case 'toHaveCss':
-      return toHaveCss;
-    case 'toHaveId':
-      return toHaveId;
-    case 'toHaveJSProperty':
-      return toHaveJSProperty;
-    case 'toHaveText':
-      return toHaveText;
-    case 'toHaveValue':
-      return toHaveValue;
-    default:
-      throw new Error(`unexpected function name ${fnName}`);
-  }
-};
-
-const string = (value, message) => {
-  if (typeof value !== 'string') {
-    throw new TypeError(message);
-  }
-};
-const number = (value, message) => {
-  if (typeof value !== 'number' || Number.isNaN(value)) {
-    throw new TypeError(message);
-  }
-};
-
-const expect$1 = locator => {
-  return new Expect(locator);
-};
-class Expect {
-  negated = false;
-  constructor(locator, negated = false) {
-    this.locator = locator;
-    this.negated = negated;
-  }
-  async checkSingleElementCondition(fnName, options) {
-    // TODO add rpcId property to locator instead
-    const result = await locatorInvoke(this.locator, 'TestFrameWork.checkSingleElementCondition', this.locator, fnName, options);
-    if (result && result.error) {
-      const fn = getFunction(fnName);
-      const errorInfo = await fn(this.locator, options);
-      throw new AssertionError(errorInfo);
-    }
-  }
-  async checkMultiElementCondition(fnName, options) {
-    const result = await locatorInvoke(this.locator, 'TestFrameWork.checkMultiElementCondition', this.locator, fnName, options);
-    if (result && result.error) {
-      const fn = getFunction(fnName);
-      const errorInfo = await fn(this.locator, options);
-      throw new AssertionError(errorInfo);
-    }
-  }
-  async toBeVisible() {
-    if (this.negated) {
-      throw new Error('use toBeHidden instead of not.toBeVisible');
-    }
-    return this.checkSingleElementCondition('toBeVisible', {});
-  }
-  async toHaveText(text) {
-    string(text, 'text must be of type string');
-    return this.checkSingleElementCondition('toHaveText', {
-      text
-    });
-  }
-  async toContainText(text) {
-    string(text, 'text must be of type string');
-    return this.checkSingleElementCondition('toContainText', {
-      text
-    });
-  }
-  async toHaveValue(value) {
-    string(value, 'value must be of type string');
-    return this.checkSingleElementCondition('toHaveValue', {
-      value
-    });
-  }
-  async toBeFocused() {
-    return this.checkSingleElementCondition('toBeFocused');
-  }
-  async toHaveCSS(key, value) {
-    return this.checkSingleElementCondition('toHaveCss', {
-      key,
-      value
-    });
-  }
-  async toHaveAttribute(key, value) {
-    string(key, 'key must be of type string');
-    return this.checkSingleElementCondition('toHaveAttribute', {
-      key,
-      value
-    });
-  }
-  async toHaveJSProperty(key, value) {
-    string(key, 'key must be of type string');
-    return this.checkSingleElementCondition('toHaveJSProperty', {
-      key,
-      value
-    });
-  }
-  async toHaveClass(className) {
-    string(className, 'className must be of type string');
-    return this.checkSingleElementCondition('toHaveClass', {
-      className
-    });
-  }
-  async toHaveId(id) {
-    string(id, 'id must be of type string');
-    return this.checkSingleElementCondition('toHaveId', {
-      id
-    });
-  }
-  async toHaveCount(count) {
-    number(count, 'count must be of type number');
-    return this.checkMultiElementCondition('toHaveCount', {
-      count
-    });
-  }
-  async toBeHidden() {
-    return this.checkMultiElementCondition('toBeHidden', {});
-  }
-  get not() {
-    return new Expect(this.locator, !this.negated);
-  }
-}
-
-const Expect$1 = {
-  expect: expect$1
-};
-
-const nameAnonymousFunction = (fn, name) => {
-  Object.defineProperty(fn, 'name', {
-    value: name
-  });
-};
-
-// @ts-nocheck
-
-const state = {
-  mockRpcs: Object.create(null),
-  /**
-   * @type {any[]}
-   */
-  pendingTests: []
-};
-const addTest = (name, fn) => {
-  state.pendingTests.push({
-    fn,
-    name
-  });
-};
-const setMockRpc = mockRpc => {
-  object(mockRpc);
-  string$1(mockRpc.name);
-  state.mockRpcs[mockRpc.name] = mockRpc;
-};
-
-const performAction = async (locator, action, options) => {
-  const invoke = getLocatorInvoke(locator);
-  return invoke('TestFrameWork.performAction', locator, action, options);
-};
-
-const toButtonNumber = buttonType => {
-  switch (buttonType) {
-    case 'left':
-      return 0;
-    case 'middle':
-      return 1;
-    case 'right':
-      return 2;
-    default:
-      throw new Error(`unsupported button type: ${buttonType}`);
-  }
-};
-
-class Locator {
-  constructor(selector, {
-    hasText = '',
-    nth = -1
-  } = {}) {
-    this._selector = selector;
-    this._nth = nth;
-    this._hasText = hasText;
-  }
-  async click({
-    button = 'left'
-  } = {}) {
-    const options = {
-      bubbles: true,
-      button: toButtonNumber(button),
-      cancable: true,
-      detail: 1
-    };
-    return performAction(this, 'click', options);
-  }
-  async hover() {
-    const options = {
-      bubbles: true,
-      cancable: true
-    };
-    return performAction(this, 'hover', options);
-  }
-  first() {
-    return new Locator(this._selector, {
-      nth: 0
-    });
-  }
-  locator(subSelector) {
-    if (this._nth !== -1) {
-      return new Locator(`${this._selector}:nth-of-type(${this._nth + 1}) ${subSelector}`);
-    }
-    return new Locator(`${this._selector} ${subSelector}`);
-  }
-  nth(nth) {
-    return new Locator(this._selector, {
-      nth
-    });
-  }
-  async type(text) {
-    const options = {
-      text
-    };
-    return performAction(this, 'type', options);
-  }
-  async dispatchEvent(type, init) {
-    return performAction(this, 'dispatchEvent', {
-      init,
-      type
-    });
-  }
-}
-
-const createLocator = (selector, options = {}) => {
-  return new Locator(selector, options);
-};
-
-const getTmpDir$1 = async () => {
-  return 'memfs://';
-};
-const test = async (name, fn) => {
-  nameAnonymousFunction(fn, `test/${name}`);
-  addTest(name, fn);
-};
-const skipTest = async id => {
-  const state = 'skip';
-  const background = 'yellow';
-  const text = `test skipped ${id}`;
-  await invoke('TestFrameWork.showOverlay', state, background, text);
-};
-const {
-  expect
-} = Expect$1;
-
-const show$7 = async () => {
-  return invoke('About.showAbout');
-};
-const handleClickOk = async () => {
-  return invoke('About.handleClickOk');
-};
-const handleClickClose$1 = async () => {
-  return invoke('About.handleClickClose');
-};
-const handleClickCopy = async () => {
-  return invoke('About.handleClickCopy');
-};
-const focusNext$9 = async () => {
-  return invoke('About.focusNext');
-};
-const focusPrevious$8 = async () => {
-  return invoke('About.focusPrevious');
-};
-
-const About = {
-  focusNext: focusNext$9,
-  focusPrevious: focusPrevious$8,
-  handleClickClose: handleClickClose$1,
-  handleClickCopy,
-  handleClickOk,
-  show: show$7
-};
-
-const focus$2 = async () => {
-  await invoke('ActivityBar.focus');
-};
-const toggleActivityBarItem = async id => {
-  await invoke('ActivityBar.toggleActivityBarItem', id);
-};
-const focusFirst$7 = async () => {
-  await invoke('ActivityBar.focusFirst');
-};
-const setAccountEnabled = async enabled => {
-  await invoke('ActivityBar.setAccountEnabled', enabled);
-};
-const focusLast$6 = async () => {
-  await invoke('ActivityBar.focusLast');
-};
-const focusNext$8 = async () => {
-  await invoke('ActivityBar.focusNext');
-};
-const focusPrevious$7 = async () => {
-  await invoke('ActivityBar.focusPrevious');
-};
-const handleClick$4 = async index => {
-  await invoke('ActivityBar.handleClick', index);
-};
-const handleContextMenu$5 = async () => {
-  await invoke('ActivityBar.handleContextMenu');
-};
-const setUpdateState = async config => {
-  await invoke('ActivityBar.setUpdateState', config);
-};
-const selectCurrent = async () => {
-  await invoke('ActivityBar.selectCurrent');
-};
-const handleClickSettings$1 = async (x, y) => {
-  await invoke('ActivityBar.handleClickSettings', x, y);
-};
-
-const ActivityBar = {
-  focus: focus$2,
-  focusFirst: focusFirst$7,
-  focusLast: focusLast$6,
-  focusNext: focusNext$8,
-  focusPrevious: focusPrevious$7,
-  handleClick: handleClick$4,
-  handleClickSettings: handleClickSettings$1,
-  handleContextMenu: handleContextMenu$5,
-  selectCurrent,
-  setAccountEnabled,
-  setUpdateState,
-  toggleActivityBarItem
-};
-
-const execute$1 = async (id, ...args) => {
-  return invoke(id, ...args);
-};
-
-const Command = {
-  execute: execute$1
-};
-
-const setReasoningPickerEnabled = async enabled => {
-  await invoke('Chat.setReasoningPickerEnabled', enabled);
-};
-const setReasoningEffort = async effort => {
-  await invoke('Chat.setReasoningEffort', effort);
-};
-const handleChatListContextMenu = async (eventX, eventY) => {
-  await invoke('Chat.handleChatListContextMenu', eventX, eventY);
-};
-const setBackendUrl = async url => {
-  await invoke('Chat.setBackendUrl', url);
-};
-const handleClickBack = async () => {
-  await invoke('Chat.handleClickBack');
-};
-const setNewChatModelPickerEnabled = async enabled => {
-  await invoke('Chat.setNewChatModelPickerEnabled', enabled);
-};
-const openAgentModePicker = async () => {
-  await invoke('Chat.openAgentModePicker');
-};
-const handleClickSettings = async () => {
-  await invoke('Chat.handleClickSettings');
-};
-const selectIndex$7 = async index => {
-  await invoke('Chat.selectIndex', index);
-};
-const handleClickClose = async () => {
-  await invoke('Chat.handleClickClose');
-};
-const handleClickNew = async () => {
-  await invoke('Chat.handleClickNew');
-};
-const enterNewLine = async () => {
-  await invoke('Chat.enterNewLine');
-};
-const setScrollDownButtonEnabled = async enabled => {
-  await invoke('Chat.setScrollDownButtonEnabled', enabled);
-};
-const show$6 = async () => {
-  await invoke('Layout.showSecondarySideBar');
-  await invoke('Chat.reset');
-};
-const getSelectedSessionId = async () => {
-  return invoke('Chat.getSelectedSessionId');
-};
-const handleInput$8 = async text => {
-  await invoke('Chat.handleInput', 'composer', text, 'script');
-};
-const handleDropFiles = async file => {
-  await execute$1('Chat.handleDropFiles', 'composer-drop-target', [file]);
-};
-const showComposerAttachmentPreviewOverlay = async attachmentId => {
-  await execute$1('Chat.showComposerAttachmentPreviewOverlay', attachmentId);
-};
-const handleClickSessionDebug = async () => {
-  await execute$1('Chat.handleClickSessionDebug');
-};
-const handleChatHeaderContextMenu = async () => {
-  await execute$1('Chat.handleChatHeaderContextMenu', 0, 0);
-};
-const reset = async () => {
-  await invoke('Chat.reset');
-};
-const handleMessagesScroll = async (id, x, y) => {
-  await invoke('Chat.handleMessagesScroll', id, x, y);
-};
-const mockOpenApiStreamFinish = async () => {
-  await invoke('Chat.mockOpenApiStreamFinish');
-};
-const mockOpenApiStreamPushChunk = async chunk => {
-  await invoke('Chat.mockOpenApiStreamPushChunk', chunk);
-};
-const openMockSession = async (sessionId, messages) => {
-  await invoke('Chat.openMockSession', sessionId, messages);
-};
-const registerMockResponse = async options => {
-  await invoke('Chat.registerMockResponse', options);
-};
-const handleSubmit = async () => {
-  await invoke('Chat.handleSubmit');
-};
-const setStreamingEnabled = async enabled => {
-  await invoke('Chat.setStreamingEnabled', enabled);
-};
-const useMockApi = async () => {
-  await invoke('Chat.useMockApi', true);
-};
-const openGitBranchPicker = async () => {
-  await invoke('Chat.openGitBranchPicker');
-};
-const closeGitBranchPicker = async () => {
-  await invoke('Chat.closeGitBranchPicker');
-};
-const setAuthEnabled = async enabled => {
-  await invoke('Chat.setAuthEnabled', enabled);
-};
-const mockBackendAuthResponse = async response => {
-  await invoke('Chat.mockBackendAuthResponse', response);
-};
-const mockOpenApiRequestGetAll = async () => {
-  return invoke('Chat.mockOpenApiRequestGetAll');
-};
-const rerender = async () => {
-  await invoke('Chat.rerender');
-};
-const setSearchEnabled = async enabled => {
-  await invoke('Chat.setSearchEnabled', enabled);
-};
-const mockOpenApiRequestReset = async () => {
-  await invoke('Chat.mockOpenApiRequestReset');
-};
-const mockOpenApiStreamReset = async () => {
-  await invoke('Chat.mockOpenApiStreamReset');
-};
-const openModelPicker = async () => {
-  await invoke('Chat.openModelPicker');
-};
-const handleClickDelete = async () => {
-  await invoke('Chat.handleClickDelete');
-};
-const handleContextMenuChatImageAttachment = async (id, x, y) => {
-  await invoke('Chat.handleContextMenuChatImageAttachment', id, x, y);
-};
-const setAddContextButtonEnabled = async enabled => {
-  await invoke('Chat.setAddContextButtonEnabled', enabled);
-};
-const deleteSessionAtIndex = async index => {
-  await invoke('Chat.deleteSessionAtIndex', index);
-};
-const handleModelChange = async modelId => {
-  await invoke('Chat.handleModelChange', modelId);
-};
-const handleModelInputBlur = async () => {
-  await execute$1('Chat.handleModelInputBlur');
-};
-const handleInputPaste$1 = async () => {
-  await invoke('Chat.handleInputPaste');
-};
-const setQuestionToolEnabled = async enabled => {
-  await invoke('Chat.setQuestionToolEnabled', enabled);
-};
-const handleInputCopy$1 = async () => {
-  await invoke('Chat.handleInputCopy');
-};
-const handleClickFileName = async fileName => {
-  await invoke('Chat.handleClickFileName', fileName);
-};
-const handleInputCut$1 = async () => {
-  await invoke('Chat.handleInputCut');
-};
-const clearInput$1 = async () => {
-  await execute$1('Chat.clearInput');
-};
-const handleProjectListContextMenu = async (id, x, y) => {
-  await execute$1('Chat.handleProjectListContextMenu', id, x, y);
-};
-const mockOpenAiResponse = async options => {
-  return invoke('Chat.mockOpenAiResponse', options);
-};
-const handleInputFocus = async () => {
-  return execute$1('Chat.handleInputFocus', 'chat-list');
-};
-const getAuthState = async () => {
-  return invoke('Chat.getAuthState');
-};
-const handleAgentModeChange = async newAgentMode => {
-  return invoke('Chat.handleAgentModeChange', newAgentMode);
-};
-
-const Chat = {
-  clearInput: clearInput$1,
-  closeGitBranchPicker,
-  deleteSessionAtIndex,
-  enterNewLine,
-  getAuthState,
-  getSelectedSessionId,
-  handleAgentModeChange,
-  handleChatHeaderContextMenu,
-  handleChatListContextMenu,
-  handleClickBack,
-  handleClickClose,
-  handleClickDelete,
-  handleClickFileName,
-  handleClickNew,
-  handleClickSessionDebug,
-  handleClickSettings,
-  handleContextMenuChatImageAttachment,
-  handleDropFiles,
-  handleInput: handleInput$8,
-  handleInputCopy: handleInputCopy$1,
-  handleInputCut: handleInputCut$1,
-  handleInputFocus,
-  handleInputPaste: handleInputPaste$1,
-  handleMessagesScroll,
-  handleModelChange,
-  handleModelInputBlur,
-  handleProjectListContextMenu,
-  handleSubmit,
-  mockBackendAuthResponse,
-  mockOpenAiResponse,
-  mockOpenApiRequestGetAll,
-  mockOpenApiRequestReset,
-  mockOpenApiStreamFinish,
-  mockOpenApiStreamPushChunk,
-  mockOpenApiStreamReset,
-  openAgentModePicker,
-  openGitBranchPicker,
-  openMockSession,
-  openModelPicker,
-  registerMockResponse,
-  rerender,
-  reset,
-  selectIndex: selectIndex$7,
-  setAddContextButtonEnabled,
-  setAuthEnabled,
-  setBackendUrl,
-  setNewChatModelPickerEnabled,
-  setQuestionToolEnabled,
-  setReasoningEffort,
-  setReasoningPickerEnabled,
-  setScrollDownButtonEnabled,
-  setSearchEnabled,
-  setStreamingEnabled,
-  show: show$6,
-  showComposerAttachmentPreviewOverlay,
-  useMockApi
-};
-
-const open$9 = async sessionId => {
-  await invoke('Main.openUri', `chat-debug://${sessionId}`);
-};
-const setEvents = async events => {
-  await invoke('ChatDebug.setEvents', events);
-};
-const setIndexedDbSupportForTest = async supported => {
-  await invoke('ChatDebug.setIndexedDbSupportForTest', supported);
-};
-const resetIndexedDbSupportForTest = async () => {
-  await invoke('ChatDebug.setIndexedDbSupportForTest');
-};
-const selectEventRow = async index => {
-  await invoke('ChatDebug.handleEventRowClick', String(index));
-};
-const handleInput$7 = async (name, value, checked) => {
-  await invoke('ChatDebug.handleInput', name, value, checked);
-};
-const useDevtoolsLayout = async () => {
-  await handleInput$7('useDevtoolsLayout', '', true);
-};
-const setFilter = async value => {
-  await handleInput$7('filter', value, false);
-};
-const setEventCategoryFilter = async value => {
-  await handleInput$7('eventCategoryFilter', value, false);
-};
-const setTimelineRangePreset = async value => {
-  await handleInput$7('timelineRangePreset', value, false);
-};
-const setShowInputEvents = async enabled => {
-  await handleInput$7('showInputEvents', '', enabled);
-};
-const setShowResponsePartEvents = async enabled => {
-  await handleInput$7('showResponsePartEvents', '', enabled);
-};
-const setShowEventStreamFinishedEvents = async enabled => {
-  await handleInput$7('showEventStreamFinishedEvents', '', enabled);
-};
-const closeDetails = async () => {
-  await handleInput$7('closeDetails', 'close', false);
-};
-const openTabPreview = async () => {
-  await invoke('ChatDebug.handleInput', 'detailTab', 'preview', false);
-};
-const openTabResponse = async () => {
-  await invoke('ChatDebug.handleInput', 'detailTab', 'response', false);
-};
-const openTabTiming = async () => {
-  await invoke('ChatDebug.handleInput', 'detailTab', 'timing', false);
-};
-const setSessionId = async sessionId => {
-  await invoke('ChatDebug.setSessionId', sessionId);
-};
-
-const ChatDebug = {
-  closeDetails,
-  handleInput: handleInput$7,
-  open: open$9,
-  openTabPreview,
-  openTabResponse,
-  openTabTiming,
-  resetIndexedDbSupportForTest,
-  selectEventRow,
-  setEventCategoryFilter,
-  setEvents,
-  setFilter,
-  setIndexedDbSupportForTest,
-  setSessionId,
-  setShowEventStreamFinishedEvents,
-  setShowInputEvents,
-  setShowResponsePartEvents,
-  setTimelineRangePreset,
-  useDevtoolsLayout
-};
-
-const readNativeFiles = async () => {
-  await invoke('ClipBoard.readNativeFiles');
-};
-const writeNativeFiles = async uris => {
-  await invoke('ClipBoard.writeNativeFiles', uris);
-};
-const enableMemoryClipBoard = async () => {
-  await invoke('ClipBoard.enableMemoryClipBoard');
-};
-const disableMemoryClipBoard = async () => {
-  await invoke('ClipBoard.disableMemoryClipBoard');
-};
-const matchesExpectedText$1 = (actualText, expectedText) => {
-  if (typeof expectedText === 'string') {
-    return actualText === expectedText;
-  }
-  return expectedText.test(actualText);
-};
-const shouldHaveText$1 = async expectedText => {
-  const actualText = await invoke('ClipBoard.readMemoryText');
-  if (!matchesExpectedText$1(actualText, expectedText)) {
-    throw new AssertionError(`expected clipboard to have text "${expectedText}" but was "${actualText}"`);
-  }
-};
-const writeText = async text => {
-  await invoke('ClipBoard.writeText', text);
-};
-
-const ClipBoard = {
-  disableMemoryClipBoard,
-  enableMemoryClipBoard,
-  readNativeFiles,
-  shouldHaveText: shouldHaveText$1,
-  writeNativeFiles,
-  writeText
-};
-
-const setRelativeX = async x => {
-  await invoke('ColorPicker.setRelativeX', x);
-};
-
-const ColorPicker = {
-  setRelativeX
-};
-
-const selectItem$1 = async text => {
-  await invoke('Menu.selectItem', text);
-};
-
-const ContextMenu = {
-  selectItem: selectItem$1
-};
-
-const openIframeInspector = async () => {
-  return invoke('Developer.openIframeInspector');
-};
-const openCacheFolder = async () => {
-  return invoke('Developer.openCacheFolder');
-};
-const openConfigFolder = async () => {
-  return invoke('Developer.openConfigFolder');
-};
-const openLogsFolder = async () => {
-  return invoke('Developer.openLogsFolder');
-};
-const openProcessExplorer = async () => {
-  return invoke('Developer.openProcessExplorer');
-};
-const reloadColorTheme = async () => {
-  return invoke('Developer.reloadColorTheme');
-};
-const reloadIconTheme = async () => {
-  return invoke('Developer.reloadIconTheme');
-};
-const toggleDeveloperTools = async () => {
-  return invoke('Developer.toggleDeveloperTools');
-};
-
-const Developer = {
-  openCacheFolder,
-  openConfigFolder,
-  openIframeInspector,
-  openLogsFolder,
-  openProcessExplorer,
-  reloadColorTheme,
-  reloadIconTheme,
-  toggleDeveloperTools
-};
-
-const createId = () => {
-  return Math.random();
-};
-
-const mocks = Object.create(null);
-const registerMock = fn => {
-  const id = createId();
-  mocks[id] = fn;
-  return id;
-};
-const executeMock$1 = (id, ...args) => {
-  const fn = mocks[id];
-  return fn(...args);
-};
-
-const showSaveFilePicker = async () => {
-  await invoke('FilePicker.showSaveFilePicker');
-};
-const mockSaveFilePicker = async fn => {
-  const id = registerMock(fn);
-  await invoke('FilePicker.mockSaveFilePicker', id);
-};
-const mockConfirm = async fn => {
-  const id = registerMock(fn);
-  await invoke('ConfirmPrompt.mock', id);
-};
-const executeMock = (id, ...args) => {
-  return executeMock$1(id, ...args);
-};
-
-const Dialog = {
-  executeMock,
-  mockConfirm,
-  mockSaveFilePicker,
-  showSaveFilePicker
-};
-
-const isDiagnosticEqual = (actual, expected) => {
-  return actual.rowIndex === expected.rowIndex && actual.columnIndex === expected.columnIndex && actual.endRowIndex === expected.endRowIndex && actual.endColumnIndex === expected.endColumnIndex && actual.message === expected.message && actual.type === expected.type;
-};
-
-const areDiagnosticsEqual = (actual, expected) => {
-  if (actual.length !== expected.length) {
-    return false;
-  }
-  for (let i = 0; i < actual.length; i++) {
-    if (!isDiagnosticEqual(actual[i], expected[i])) {
-      return false;
-    }
-  }
-  return true;
-};
-
-const areSelectionsEqual = (a, b) => {
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
-};
-
-const getEditorKey = async () => {
-  const keys = await invoke$2('Editor.getKeys');
-  if (keys.length === 0) {
-    throw new Error(`no editor found`);
-  }
-  const key = keys.at(-1);
-  const numeric = Number.parseFloat(key);
-  return numeric;
-};
-
-const Script = 2;
-
-const update$1 = settings => {
-  return invoke('Preferences.update', settings);
-};
-const enableDiagnostics$1 = () => {
-  return invoke('Preferences.update', {
-    'editor.diagnostics': true
-  });
-};
-const disableDiagnostics$1 = () => {
-  return invoke('Preferences.update', {
-    'editor.diagnostics': false
-  });
-};
-
-const Settings = {
-  disableDiagnostics: disableDiagnostics$1,
-  enableDiagnostics: enableDiagnostics$1,
-  update: update$1
-};
-
-const setCursor = async (rowIndex, columnIndex) => {
-  await invoke('Editor.cursorSet', rowIndex, columnIndex);
-};
-const cancelSelection = async () => {
-  await invoke('Editor.cancelSelection');
-};
-const openCompletion = async () => {
-  await invoke('Editor.openCompletion');
-};
-const closeCompletion = async () => {
-  await invoke('EditorCompletion.close');
-};
-const openEditorContextMenu = async () => {
-  await invoke('Editor.handleContextMenu', 0, 0);
-};
-const invokeTabCompletion = async () => {
-  await invoke('Editor.tabCompletion');
-};
-const executeTabCompletion = async () => {
-  await invoke('Editor.tabCompletion');
-};
-const invokeBraceCompletion = async text => {
-  await invoke('Editor.braceCompletion', text);
-};
-const cursorCharacterRight = async () => {
-  await invoke('Editor.cursorCharacterRight');
-};
-const cursorCharacterLeft = async () => {
-  await invoke('Editor.cursorCharacterLeft');
-};
-const copyLineDown = async () => {
-  await invoke('Editor.copyLineDown');
-};
-const cursorDown = async () => {
-  await invoke('Editor.cursorDown');
-};
-const selectDown$1 = async () => {
-  await invoke('Editor.selectDown');
-};
-const selectLine = async () => {
-  await invoke('Editor.selectLine');
-};
-const selectAllLeft = async () => {
-  await invoke('Editor.selectAllLeft');
-};
-const selectionGrow = async () => {
-  await invoke('Editor.selectionGrow');
-};
-const selectAllRight = async () => {
-  await invoke('Editor.selectAllRight');
-};
-const selectAllOccurrences = async () => {
-  await invoke('Editor.selectAllOccurrences');
-};
-const selectUp$1 = async () => {
-  await invoke('Editor.selectUp');
-};
-const cursorUp = async () => {
-  await invoke('Editor.cursorUp');
-};
-const cursorWordLeft = async () => {
-  await invoke('Editor.cursorWordLeft');
-};
-const setText = async text => {
-  await invoke('Editor.setText', text);
-};
-const deleteAll = async () => {
-  await invoke('Editor.deleteAll');
-};
-const selectCharacterLeft = async () => {
-  await invoke('Editor.selectCharacterLeft');
-};
-const selectCharacterRight = async () => {
-  await invoke('Editor.selectCharacterRight');
-};
-const deleteCharacterLeft = async () => {
-  await invoke('Editor.deleteCharacterLeft');
-};
-const deleteWordPartRight = async () => {
-  await invoke('Editor.deleteWordPartRight');
-};
-const deleteWordRight = async () => {
-  await invoke('Editor.deleteWordRight');
-};
-const deleteWordPartLeft = async () => {
-  await invoke('Editor.deleteWordPartLeft');
-};
-const deleteWordLeft = async () => {
-  await invoke('Editor.deleteWordLeft');
-};
-const deleteHorizontalRight = async () => {
-  await invoke('Editor.deleteHorizontalRight');
-};
-const deleteCharacterRight = async () => {
-  await invoke('Editor.deleteCharacterRight');
-};
-const cursorWordRight = async () => {
-  await invoke('Editor.cursorWordRight');
-};
-const goToDefinition = async () => {
-  await invoke('Editor.goToDefinition');
-};
-const openHover = async () => {
-  await invoke('Editor.showHover2');
-};
-const goToTypeDefinition = async () => {
-  await invoke('Editor.goToTypeDefinition');
-};
-const type = async text => {
-  await invoke('Editor.type', text);
-};
-const findAllReferences = async () => {
-  await invoke('SideBar.show', 'References', /* focus */true);
-};
-const findAllImplementations = async () => {
-  await invoke('SideBar.show', 'Implementations', /* focus */true);
-};
-const setSelections = async selections => {
-  await invoke('Editor.setSelections', selections);
-};
-const selectNextOccurrence = async () => {
-  await invoke('Editor.selectNextOccurrence');
-};
-const selectPreviousOccurrence = async () => {
-  await invoke('Editor.selectPreviousOccurrence');
-};
-const openFindWidget = async () => {
-  await invoke('Editor.openFind');
-};
-const setDeltaY$1 = async deltaY => {
-  await invoke('Editor.setDeltaY', deltaY);
-};
-const format = async () => {
-  await invoke('Editor.format');
-};
-const unIndent = async () => {
-  await invoke('Editor.unIndent');
-};
-const insertLineBreak = async () => {
-  await invoke('Editor.insertLineBreak');
-};
-const openSourceActions = async () => {
-  await invoke('Editor.showSourceActions2');
-};
-const sourceActionsSelectCurrent = async () => {
-  await invoke('EditorSourceActions.selectCurrent');
-};
-const openCompletionDetails = async () => {
-  await invoke('EditorCompletion.openDetails');
-};
-const closeCompletionDetails = async () => {
-  await invoke('EditorCompletion.closeDetails');
-};
-const toggleCompletionDetails = async () => {
-  await invoke('EditorCompletion.toggleDetails');
-};
-const organizeImports = async () => {
-  await invoke('Editor.organizeImports');
-};
-const addAllMissingImports = async () => {
-  await invoke('Editor.addAllMissingImports');
-};
-const sortImports = async () => {
-  await invoke('Editor.sortImports');
-};
-const toggleLineComment = async () => {
-  await invoke('Editor.toggleLineComment');
-};
-const toggleBlockComment = async () => {
-  await invoke('Editor.toggleBlockComment');
-};
-const selectAll$1 = async () => {
-  await invoke('Editor.toggleBlockComment');
-};
-const openColorPicker = async () => {
-  await invoke('Editor.openColorPicker');
-};
-const openFind = async () => {
-  await invoke('Editor.openFind2');
-};
-const deleteAllLeft = async () => {
-  await invoke('Editor.deleteAllLeft');
-};
-const deleteAllRight = async () => {
-  await invoke('Editor.deleteAllRight');
-};
-const cursorWordPartLeft = async () => {
-  await invoke('Editor.cursorWordPartLeft');
-};
-const cursorWordPartRight = async () => {
-  await invoke('Editor.cursorWordPartRight');
-};
-const cursorEnd = async () => {
-  await invoke('Editor.cursorEnd');
-};
-const cursorHome = async () => {
-  await invoke('Editor.cursorHome');
-};
-const copyLineUp = async () => {
-  await invoke('Editor.copyLineUp');
-};
-const copy$1 = async () => {
-  await invoke('Editor.copy');
-};
-const closeColorPicker = async () => {
-  await invoke('Editor.closeColorPicker');
-};
-const openContextMenu$1 = async () => {
-  const button = 0;
-  const x = 0;
-  const y = 0;
-  await invoke('Editor.contextMenu', button, x, y);
-};
-const getText = async () => {
-  return invoke('Editor.getText');
-};
-const rename$1 = async () => {
-  await invoke('Editor.rename');
-};
-const showHover = async () => {
-  await invoke('Editor.showHover2');
-};
-const openRename = async () => {
-  await invoke('Editor.openRename');
-};
-const rename2 = async newName => {
-  await openRename();
-  await invoke('EditorRename.handleInput', newName, Script);
-  await invoke('EditorRename.accept');
-};
-const growSelection = async () => {
-  await invoke('Editor.selectionGrow');
-};
-const getSelections = async () => {
-  const key = await getEditorKey();
-  return invoke$2('Editor.getSelections', key);
-};
-const shouldHaveText = async expectedText => {
-  const key = await getEditorKey();
-  const text = await invoke$2('Editor.getText', key);
-  if (text !== expectedText) {
-    throw new Error(`Expected editor to have text ${expectedText} but was ${text}`);
-  }
-};
-const areTokensEqual = (actual, expected) => {
-  if (actual.length !== expected.length) {
-    return false;
-  }
-  for (let i = 0; i < actual.length; i++) {
-    const actualRow = actual[i];
-    const expectedRow = expected[i];
-    if (actualRow.length !== expectedRow.length) {
-      return false;
-    }
-    for (let j = 0; j < actualRow.length; j++) {
-      if (actualRow[j] !== expectedRow[j]) {
-        return false;
-      }
-    }
-  }
-  return true;
-};
-const shouldHaveTokens = async expectedTokens => {
-  const key = await getEditorKey();
-  const text = await invoke$2('Editor.getTokens', key);
-  if (!areTokensEqual(text, expectedTokens)) {
-    const stringifiedActual = JSON.stringify(text);
-    const stringifiedExpected = JSON.stringify(expectedTokens);
-    throw new Error(`Expected editor to have tokens ${stringifiedExpected} but was ${stringifiedActual}`);
-  }
-};
-const shouldHaveSelections = async expectedSelections => {
-  const key = await getEditorKey();
-  const selections = await invoke$2('Editor.getSelections', key);
-  if (!areSelectionsEqual(selections, expectedSelections)) {
-    throw new Error(`Expected editor to have selections ${expectedSelections} but was ${selections}`);
-  }
-};
-const undo = async () => {
-  await invoke$2('Editor.undo');
-};
-const redo = async () => {
-  await invoke$2('Editor.redo');
-};
-const shouldHaveDiagnostics = async expectedDiagnostics => {
-  const key = await getEditorKey();
-  const diagnostics = await invoke$2('Editor.getDiagnostics', key);
-  if (!areDiagnosticsEqual(diagnostics, expectedDiagnostics)) {
-    const stringifiedActual = JSON.stringify(diagnostics);
-    const stringifiedExpected = JSON.stringify(expectedDiagnostics);
-    throw new Error(`Expected editor to have diagnostics ${stringifiedExpected} but was ${stringifiedActual}`);
-  }
-};
-const enableCompletionsOnType = async () => {
-  await update$1({
-    'editor.completionsOnType': true
-  });
-};
-const disableCompletionsOnType = async () => {
-  await update$1({
-    'editor.completionsOnType': false
-  });
-};
-const enableDiagnostics = async () => {
-  await update$1({
-    'editor.diagnostics': true
-  });
-};
-const disableDiagnostics = async () => {
-  await update$1({
-    'editor.diagnostics': false
-  });
-};
-
-const Editor = {
-  addAllMissingImports,
-  cancelSelection,
-  closeColorPicker,
-  closeCompletion,
-  closeCompletionDetails,
-  copy: copy$1,
-  copyLineDown,
-  copyLineUp,
-  cursorCharacterLeft,
-  cursorCharacterRight,
-  cursorDown,
-  cursorEnd,
-  cursorHome,
-  cursorUp,
-  cursorWordLeft,
-  cursorWordPartLeft,
-  cursorWordPartRight,
-  cursorWordRight,
-  deleteAll,
-  deleteAllLeft,
-  deleteAllRight,
-  deleteCharacterLeft,
-  deleteCharacterRight,
-  deleteHorizontalRight,
-  deleteWordLeft,
-  deleteWordPartLeft,
-  deleteWordPartRight,
-  deleteWordRight,
-  disableCompletionsOnType,
-  disableDiagnostics,
-  enableCompletionsOnType,
-  enableDiagnostics,
-  executeTabCompletion,
-  findAllImplementations,
-  findAllReferences,
-  format,
-  getSelections,
-  getText,
-  goToDefinition,
-  goToTypeDefinition,
-  growSelection,
-  insertLineBreak,
-  invokeBraceCompletion,
-  invokeTabCompletion,
-  openColorPicker,
-  openCompletion,
-  openCompletionDetails,
-  openContextMenu: openContextMenu$1,
-  openEditorContextMenu,
-  openFind,
-  openFindWidget,
-  openHover,
-  openRename,
-  openSourceActions,
-  organizeImports,
-  redo,
-  rename: rename$1,
-  rename2,
-  selectAll: selectAll$1,
-  selectAllLeft,
-  selectAllOccurrences,
-  selectAllRight,
-  selectCharacterLeft,
-  selectCharacterRight,
-  selectDown: selectDown$1,
-  selectLine,
-  selectNextOccurrence,
-  selectPreviousOccurrence,
-  selectUp: selectUp$1,
-  selectionGrow,
-  setCursor,
-  setDeltaY: setDeltaY$1,
-  setSelections,
-  setText,
-  shouldHaveDiagnostics,
-  shouldHaveSelections,
-  shouldHaveText,
-  shouldHaveTokens,
-  showHover,
-  sortImports,
-  sourceActionsSelectCurrent,
-  toggleBlockComment,
-  toggleCompletionDetails,
-  toggleLineComment,
-  type,
-  unIndent,
-  undo
-};
-
-const selectIndex$6 = async index => {
-  await invoke('EditorCompletion.selectIndex', index);
-};
-const selectCurrentIndex$2 = async () => {
-  await invoke('EditorCompletion.selectCurrentIndex');
-};
-const close$2 = async () => {
-  await invoke('EditorCompletion.close');
-};
-const handleWheel$2 = async (deltaMode, deltaY) => {
-  await invoke('EditorCompletion.handleWheel', deltaMode, deltaY);
-};
-const handlePointerdown = async (clientX, clientY) => {
-  await invoke('EditorCompletion.handlePointerdown', clientX, clientY);
-};
-
-const EditorCompletion = {
-  close: close$2,
-  handlePointerdown,
-  handleWheel: handleWheel$2,
-  selectCurrentIndex: selectCurrentIndex$2,
-  selectIndex: selectIndex$6
-};
-
-const show$5 = async () => {
-  await invoke('Editor.showHover2');
-};
-const close$1 = async () => {
-  await invoke('EditorHover.close');
-};
-
-const EditorHover = {
-  close: close$1,
-  show: show$5
-};
-
-const handleInput$6 = async value => {
-  await invoke('EditorRename.handleInput', value, Script);
-};
-const accept = async () => {
-  await invoke('EditorRename.accept');
-};
-const cancel = async () => {
-  await invoke('EditorRename.cancel');
-};
-
-const EditorRename = {
-  accept,
-  cancel,
-  handleInput: handleInput$6
-};
-
-const selectIndex$5 = async index => {
-  await invoke('EditorSourceAction.selectIndex', index);
-};
-const selectCurrentIndex$1 = async () => {
-  await invoke('EditorSourceAction.selectCurrentIndex');
-};
-
-const EditorSourceAction = {
-  selectCurrentIndex: selectCurrentIndex$1,
-  selectIndex: selectIndex$5
-};
-
-const openContextMenu = async index => {
-  await invoke('Explorer.handleContextMenuKeyboard', index);
-};
-const handleDragLeave = async () => {
-  await invoke('Explorer.handleDragLeave');
-};
-const handleBlur = async () => {
-  await invoke('Explorer.handleBlur');
-};
-const handleEscape = async () => {
-  await invoke('Explorer.handleEscape');
-};
-const handleDropIndex = async (fileHandles, files, paths, index) => {
-  await invoke('Explorer.handleDropIndex', fileHandles, files, paths, index);
-};
-const handleInputBlur = async () => {
-  await invoke('Explorer.handleInputBlur');
-};
-const focus$1 = async () => {
-  await invoke('Explorer.focusIndex', -1);
-};
-const setDeltaY = async deltaY => {
-  await invoke('Explorer.setDeltaY', deltaY);
-};
-const focusNext$7 = async () => {
-  await invoke('Explorer.focusNext');
-};
-const selectUp = async () => {
-  await invoke('Explorer.selectUp');
-};
-const handleDragOverIndex = async index => {
-  await invoke('Explorer.handleDragOverIndex', index);
-};
-const selectDown = async () => {
-  await invoke('Explorer.selectDown');
-};
-const collapseAll$2 = async () => {
-  await invoke('Explorer.collapseAll');
-};
-const refresh$1 = async () => {
-  await invoke('Explorer.refresh');
-};
-const focusIndex$5 = async index => {
-  await invoke('Explorer.focusIndex', index);
-};
-const clickCurrent = async () => {
-  await invoke('Explorer.handleClickCurrent');
-};
-const handleArrowLeft$1 = async () => {
-  await invoke('Explorer.handleArrowLeft');
-};
-const focusLast$5 = async () => {
-  await invoke('Explorer.focusLast');
-};
-const focusFirst$6 = async () => {
-  await invoke('Explorer.focusFirst');
-};
-const removeDirent = async () => {
-  await invoke('Explorer.removeDirent');
-};
-const expandRecursively = async () => {
-  await invoke('Explorer.expandRecursively');
-};
-const newFile = async () => {
-  await invoke('Explorer.newFile');
-};
-const newFolder = async () => {
-  await invoke('Explorer.newFolder');
-};
-const copyPath$2 = async () => {
-  await invoke('Explorer.copyPath');
-};
-const copyRelativePath$1 = async () => {
-  await invoke('Explorer.copyRelativePath');
-};
-const handleClick$3 = async index => {
-  await invoke('Explorer.handleClick', index);
-};
-const handleClickAt$2 = async (preventDefault, button, ctrlKey, shiftKey, x, y) => {
-  await invoke('Explorer.handleClickAt', preventDefault, button, ctrlKey, shiftKey, x, y);
-};
-const handleDrop = async (x, y, fileIds, fileList) => {
-  await invoke('Explorer.handleDrop', x, y, fileIds, fileIds);
-};
-const rename = async () => {
-  await invoke('Explorer.renameDirent');
-};
-const selectAll = async () => {
-  await invoke('Explorer.selectAll');
-};
-const renameDirent = async () => {
-  await invoke('Explorer.renameDirent');
-};
-const cancelEdit = async () => {
-  await invoke('Explorer.cancelEdit');
-};
-const acceptEdit = async () => {
-  await invoke('Explorer.acceptEdit');
-};
-const updateEditingValue = async value => {
-  await invoke('Explorer.updateEditingValue', value);
-};
-const expandAll = async () => {
-  await invoke('Explorer.expandAll');
-};
-const handleDragOver = async (x, y) => {
-  await invoke('Explorer.handleDragOver', x, y);
-};
-const handleCut = async () => {
-  await invoke('Explorer.handleCut');
-};
-const handleCopy = async () => {
-  await invoke('Explorer.handleCopy');
-};
-const handlePaste = async () => {
-  await invoke('Explorer.handlePaste');
-};
-const selectIndices = async indices => {
-  await invoke('Explorer.selectIndices', indices);
-};
-const toggleIndividualSelection = async index => {
-  await invoke('Explorer.toggleIndividualSelection', index);
-};
-
-const Explorer = {
-  acceptEdit,
-  cancelEdit,
-  clickCurrent,
-  collapseAll: collapseAll$2,
-  copyPath: copyPath$2,
-  copyRelativePath: copyRelativePath$1,
-  expandAll,
-  expandRecursively,
-  focus: focus$1,
-  focusFirst: focusFirst$6,
-  focusIndex: focusIndex$5,
-  focusLast: focusLast$5,
-  focusNext: focusNext$7,
-  handleArrowLeft: handleArrowLeft$1,
-  handleBlur,
-  handleClick: handleClick$3,
-  handleClickAt: handleClickAt$2,
-  handleCopy,
-  handleCut,
-  handleDragLeave,
-  handleDragOver,
-  handleDragOverIndex,
-  handleDrop,
-  handleDropIndex,
-  handleEscape,
-  handleInputBlur,
-  handlePaste,
-  newFile,
-  newFolder,
-  openContextMenu,
-  refresh: refresh$1,
-  removeDirent,
-  rename,
-  renameDirent,
-  selectAll,
-  selectDown,
-  selectIndices,
-  selectUp,
-  setDeltaY,
-  toggleIndividualSelection,
-  updateEditingValue
-};
-
-const addWebExtension = async relativePath => {
-  // TODO compute absolutePath
-  const absolutePath = relativePath;
-  await invoke('ExtensionMeta.addWebExtension', absolutePath);
-};
-const addNodeExtension = async relativePath => {
-  // TODO compute absolutePath
-  const absolutePath = relativePath;
-  await invoke('ExtensionMeta.addNodeExtension', absolutePath);
-};
-
-const Extension = {
-  addNodeExtension,
-  addWebExtension
-};
-
-const handleClickCategory = async categoryId => {
-  await invoke('ExtensionDetail.handleClickCategory', categoryId);
-};
-const handleReadmeContextMenu = async (x, y, nodeName, href) => {
-  await invoke('ExtensionDetail.handleReadmeContextMenu', x, y, nodeName, href);
-};
-const copyReadmeLink = async href => {
-  await invoke('ExtensionDetail.copyReadmeLink', href);
-};
-const handleClickEnable = async () => {
-  await invoke('ExtensionDetail.handleClickEnable');
-};
-const handleClickDisable = async () => {
-  await invoke('ExtensionDetail.handleClickDisable');
-};
-const handleClickSetColorTheme = async () => {
-  await invoke('ExtensionDetail.handleClickSetColorTheme');
-};
-const selectFeature = name => {
-  return invoke('ExtensionDetail.selectFeature', name);
-};
-const selectTab$2 = name => {
-  return invoke('ExtensionDetail.selectTab', name);
-};
-const selectDetails = async () => {
-  await selectTab$2('Details');
-};
-const selectFeatures = async () => {
-  await selectTab$2('Features');
-};
-const selectChangelog = async () => {
-  await selectTab$2('Changelog');
-};
-const focusNextTab = async () => {
-  await invoke('ExtensionDetail.focusNextTab');
-};
-const focusPreviousTab = async () => {
-  await invoke('ExtensionDetail.focusPreviousTab');
-};
-const open$8 = extensionId => {
-  const uri = `extension-detail://${extensionId}`;
-  return invoke('Main.openUri', uri);
-};
-const handleClickUninstall = () => {
-  return invoke('ExtensionDetail.handleClickUninstall');
-};
-const handleImageContextMenu = () => {
-  return invoke('ExtensionDetail.handleImageContextMenu');
-};
-const openFeature = featureName => {
-  return invoke('ExtensionDetail.handleFeaturesClick', featureName);
-};
-const openThemes = async () => {
-  await openFeature('Theme');
-};
-const openCommands = async () => {
-  await openFeature('Commands');
-};
-const openWebViews = async () => {
-  await openFeature('WebView');
-};
-const openRuntimeStatus = async () => {
-  await openFeature('RuntimeStatus');
-};
-const openJsonValidation = async () => {
-  await openFeature('JsonValidation');
-};
-const openSettings = async () => {
-  await openFeature('Settings');
-};
-const handleScroll$1 = async scrollTop => {
-  return invoke('ExtensionDetail.handleScroll', scrollTop);
-};
-const hideSizeLink = async () => {
-  return invoke('ExtensionDetail.hideSizeLink');
-};
-const handleTabFocus = async tabName => {
-  return invoke('ExtensionDetail.handleTabFocus', tabName);
-};
-
-const ExtensionDetail = {
-  copyReadmeLink,
-  focusNextTab,
-  focusPreviousTab,
-  handleClickCategory,
-  handleClickDisable,
-  handleClickEnable,
-  handleClickSetColorTheme,
-  handleClickUninstall,
-  handleImageContextMenu,
-  handleReadmeContextMenu,
-  handleScroll: handleScroll$1,
-  handleTabFocus,
-  hideSizeLink,
-  open: open$8,
-  openCommands,
-  openFeature,
-  openJsonValidation,
-  openRuntimeStatus,
-  openSettings,
-  openThemes,
-  openWebViews,
-  selectChangelog,
-  selectDetails,
-  selectFeature,
-  selectFeatures,
-  selectTab: selectTab$2
-};
-
-const open$7 = async id => {
-  await invoke('SideBar.openViewlet', id);
-};
-const hide = async () => {
-  await invoke('Layout.hideSideBar');
-};
-
-const SideBar = {
-  hide,
-  open: open$7
-};
-
-const open$6 = async () => {
-  await open$7('Extensions');
-};
-const handleInput$5 = async value => {
-  await invoke('Extensions.handleInput', value, Script$1);
-};
-const handleClick$2 = async index => {
-  await invoke('Extensions.handleClick', index);
-};
-const handleClickFilter = async () => {
-  await invoke('Extensions.handleClickFilter');
-};
-const handleContextMenu$4 = async (button, x, y) => {
-  await invoke('Extensions.handleContextMenu', button, x, y);
-};
-const copyExtensionInfo = async () => {
-  await invoke('Extensions.copyExtensionInfo');
-};
-const copyExtensionId = async () => {
-  await invoke('Extensions.copyExtensionId');
-};
-const clearSearchResults$1 = async () => {
-  await invoke('Extensions.clearSearchResults');
-};
-
-const ExtensionSearch = {
-  clearSearchResults: clearSearchResults$1,
-  copyExtensionId,
-  copyExtensionInfo,
-  handleClick: handleClick$2,
-  handleClickFilter,
-  handleContextMenu: handleContextMenu$4,
-  handleInput: handleInput$5,
-  open: open$6
-};
-
-const Memfs = 'memfs';
-
-const toFileUrl = url => {
-  const urlObject = new URL(url);
-  const pathName = urlObject.pathname;
-  if (!pathName.startsWith('/remote')) {
-    throw new Error(`url must start with /remote`);
-  }
-  const rest = pathName.slice('/remote'.length);
-  return `file://${rest}`;
-};
-
-const getDirents = async fileUrl => {
-  const allDirents = [];
-  const dirents = await invoke('FileSystem.readDirWithFileTypes', fileUrl);
-  for (const dirent of dirents) {
-    if (dirent.type === Directory) {
-      const subDirents = await getDirents(`${fileUrl}/${dirent.name}`);
-      allDirents.push(...subDirents);
-    } else {
-      allDirents.push(`${fileUrl}/${dirent.name}`);
-    }
-  }
-  return allDirents;
-};
-const getFileMapNode = async url => {
-  const fileUrl = toFileUrl(url);
-  const allFiles = await getDirents(fileUrl);
-  const fileMap = Object.create(null);
-  await Promise.all(allFiles.map(async filePath => {
-    const content = await readFile$1(filePath);
-    const relativePaths = filePath.slice(fileUrl.length + 1);
-    fileMap[relativePaths] = content;
-  }));
-  return fileMap;
-};
-
-const isObject = value => {
-  return value !== null && typeof value === 'object' && !Array.isArray(value);
-};
-const isValidFileMap = value => {
-  if (!isObject(value)) {
-    return false;
-  }
-  for (const key in value) {
-    if (typeof value[key] !== 'string') {
-      return false;
-    }
-  }
-  return true;
-};
-
-const loadFileMap = async fileMapUrl => {
-  try {
-    const response = await fetch(fileMapUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to load filemap.json: ${response.status} ${response.statusText}`);
-    }
-    const parsedJson = await response.json();
-    if (!isValidFileMap(parsedJson)) {
-      throw new Error('Invalid file map format: expected an object with string values');
-    }
-    return parsedJson;
-  } catch (error) {
-    throw new VError(error, `Failed to load file map from ${fileMapUrl}`);
-  }
-};
-
-const getFileMapWeb = async url => {
-  const fileMapUrl = `${url}/fileMap.json`;
-  const fileMap = await loadFileMap(fileMapUrl);
-  return fileMap;
-};
-
-const loadFixtureToMemFs = async fileMap => {
-  for (const [path, content] of Object.entries(fileMap)) {
-    const memfsPath = `memfs:///fixture/${path}`;
-    await invoke('FileSystem.writeFile', memfsPath, content);
-  }
-  return `memfs:///fixture`;
-};
-
-const Slash$1 = '/';
-
-const Character = {
-  Slash: Slash$1
-};
-
-const {
-  Slash
-} = Character;
-
-const stringifyJson = data => {
-  return JSON.stringify(data, null, 2) + '\n';
-};
-
-const writeFile = async (uri, content) => {
-  await invoke('FileSystem.writeFile', uri, content);
-};
-const writeJson = async (uri, data) => {
-  const content = stringifyJson(data);
-  await writeFile(uri, content);
-};
-const readFile = async uri => {
-  return invoke('FileSystem.readFile', uri);
-};
-const addFileHandle = async file => {
-  return invoke('FileSystem.addFileHandle', file);
-};
-const mkdir = async uri => {
-  return invoke('FileSystem.mkdir', uri);
-};
-const setFiles = async files => {
-  // TODO maybe have a method to send all the files to file system worker directly
-  await Promise.all(files.map(file => {
-    return writeFile(file.uri, file.content);
-  }));
-};
-const readDir = async uri => {
-  return invoke('FileSystem.readDirWithFileTypes', uri);
-};
-const remove = async uri => {
-  await invoke('FileSystem.remove', uri);
-};
-const getTmpDir = async ({
-  scheme = Memfs
-} = {}) => {
-  switch (scheme) {
-    case Memfs:
-      return 'memfs:///workspace';
-    default:
-      return invoke('PlatformPaths.getTmpDir');
-  }
-};
-const chmod = async (uri, permissions) => {
-  await invoke('FileSystem.chmod', uri, permissions);
-};
-const createExecutable = async content => {
-  const tmpDir = await getTmpDir({
-    scheme: 'file'
-  });
-  const nodePath = await invoke('PlatformPaths.getNodePath');
-  const gitPath = `${tmpDir}/git`;
-  await writeFile(gitPath, `#!${nodePath}
-  ${content}`);
-  await chmod(gitPath, '755');
-  return gitPath;
-};
-const createExecutableFrom = async uri => {
-  const testPath = await invoke('PlatformPaths.getTestPath');
-  const absolutePath = testPath + Slash + uri;
-  const content = await invoke('Ajax.getText', absolutePath);
-  return createExecutable(content);
-};
-const getOpfsRoot = async () => {
-  return navigator.storage.getDirectory();
-};
-const createDroppedFileHandle = async () => {
-  const directory = await getOpfsRoot();
-  const fileHandle = await directory.getFileHandle('dropped-file.txt', {
-    create: true
-  });
-  const file = await fileHandle.getFile();
-  const id = await invoke('FileSystemHandle.addFileHandle', fileHandle);
-  return {
-    file,
-    id
-  };
-};
-const loadFixture = async (platform, url) => {
-  if (typeof url !== 'string') {
-    throw new TypeError(`fixture url must be of type string`);
-  }
-  const fn = platform === Web ? getFileMapWeb : getFileMapNode;
-  const fileMap = await fn(url);
-  const filePath = await loadFixtureToMemFs(fileMap);
-  return filePath;
-};
-
-const FileSystem = {
-  addFileHandle,
-  chmod,
-  createDroppedFileHandle,
-  createExecutable,
-  createExecutableFrom,
-  getOpfsRoot,
-  getTmpDir,
-  loadFixture,
-  mkdir,
-  readDir,
-  readFile,
-  remove,
-  setFiles,
-  writeFile,
-  writeJson
-};
-
-const focusNext$6 = async () => {
-  await invoke('FindWidget.focusNext');
-};
-const focusPrevious$6 = async () => {
-  await invoke('FindWidget.focusPrevious');
-};
-const close = async () => {
-  await invoke('FindWidget.close');
-};
-const setReplaceValue$1 = async value => {
-  await invoke('FindWidget.handleReplaceInput', value, Script);
-};
-const setValue$2 = async value => {
-  await invoke('FindWidget.handleInput', value, Script);
-};
-const toggleReplace$1 = async () => {
-  await invoke('FindWidget.toggleReplace');
-};
-const toggleMatchCase$1 = async () => {
-  await invoke('FindWidget.toggleMatchCase');
-};
-const toggleMatchWholeWord$1 = async () => {
-  await invoke('FindWidget.toggleMatchWholeWord');
-};
-const togglePreserveCase$1 = async () => {
-  await invoke('FindWidget.togglePreserveCase');
-};
-const toggleUseRegularExpression$1 = async () => {
-  await invoke('FindWidget.toggleUseRegularExpression');
-};
-const replace = async () => {
-  await invoke('FindWidget.replace');
-};
-const replaceAll$1 = async () => {
-  await invoke('FindWidget.replaceAll');
-};
-const focusElement = async whenExpression => {
-  await invoke('FindWidget.focusElement', whenExpression);
-};
-const focusNextElement = async () => {
-  await invoke('FindWidget.focusNextElement');
-};
-const focusPreviousElement = async () => {
-  await invoke('FindWidget.focusPreviousElement');
-};
-
-const FindWidget = {
-  close,
-  focusElement,
-  focusNext: focusNext$6,
-  focusNextElement,
-  focusPrevious: focusPrevious$6,
-  focusPreviousElement,
-  replace,
-  replaceAll: replaceAll$1,
-  setReplaceValue: setReplaceValue$1,
-  setValue: setValue$2,
-  toggleMatchCase: toggleMatchCase$1,
-  toggleMatchWholeWord: toggleMatchWholeWord$1,
-  togglePreserveCase: togglePreserveCase$1,
-  toggleReplace: toggleReplace$1,
-  toggleUseRegularExpression: toggleUseRegularExpression$1
-};
-
-const setIconTheme = async id => {
-  await invoke('IconTheme.setIconTheme', id);
-};
-
-const IconTheme = {
-  setIconTheme
-};
-
-const selectIndex$4 = async index => {
-  return invoke('IframeInspector.selectIndex', index);
-};
-const focusNext$5 = async () => {
-  return invoke('IframeInspector.focusNext');
-};
-const focusPrevious$5 = async () => {
-  return invoke('IframeInspector.focusPrevious');
-};
-const focusFirst$5 = async () => {
-  return invoke('IframeInspector.focusFirst');
-};
-const focusLast$4 = async () => {
-  return invoke('IframeInspector.focusLast');
-};
-
-const IframeInspector = {
-  focusFirst: focusFirst$5,
-  focusLast: focusLast$4,
-  focusNext: focusNext$5,
-  focusPrevious: focusPrevious$5,
-  selectIndex: selectIndex$4
-};
-
-const open$5 = async () => {
-  await invoke('Main.openUri', 'app://keybindings');
-};
-const handleInput$4 = value => {
-  return invoke('KeyBindings.handleInput', value);
-};
-const handleClick$1 = (x, y) => {
-  return invoke('KeyBindings.handleClick', x, y);
-};
-const handleWheel$1 = (deltaMode, deltaY) => {
-  return invoke('KeyBindings.handleWheel', deltaMode, deltaY);
-};
-const handleDoubleClick = (x, y) => {
-  return invoke('KeyBindings.handleDoubleClick', x, y);
-};
-const focusNext$4 = () => {
-  return invoke('KeyBindings.focusNext');
-};
-const focusPrevious$4 = () => {
-  return invoke('KeyBindings.focusPrevious');
-};
-const focusFirst$4 = () => {
-  return invoke('KeyBindings.focusFirst');
-};
-const focusIndex$4 = index => {
-  return invoke('KeyBindings.focusIndex', index);
-};
-const focusLast$3 = () => {
-  return invoke('KeyBindings.focusLast');
-};
-const toggleRecordingKeys = () => {
-  return invoke('KeyBindings.toggleRecordingKeys');
-};
-const startRecordingKeys = () => {
-  return invoke('KeyBindings.startRecordingKeys');
-};
-const clearInput = () => {
-  return invoke('KeyBindings.clearInput');
-};
-const sortByPrecedence = () => {
-  return invoke('KeyBindings.sortByPrecedence');
-};
-const stopRecordingKeys = () => {
-  return invoke('KeyBindings.stopRecordingKeys');
-};
-const handleContextMenu$3 = (button, x, y) => {
-  return invoke('KeyBindings.handleContextMenu', button, x, y);
-};
-const copyCommandId = () => {
-  return invoke('KeyBindings.copyCommandId');
-};
-const copyCommandTitle = () => {
-  return invoke('KeyBindings.copyCommandTitle');
-};
-const addKeyBinding = () => {
-  return invoke('KeyBindings.addKeyBinding');
-};
-const removeKeyBinding = () => {
-  return invoke('KeyBindings.removeKeyBinding');
-};
-const changeWhenExpression = () => {
-  return invoke('KeyBindings.changeWhenExpression');
-};
-const showSameKeyBindings = () => {
-  return invoke('KeyBindings.showSameKeyBindings');
-};
-const resetKeyBinding = () => {
-  return invoke('KeyBindings.resetKeyBinding');
-};
-
-const KeyBindingsEditor = {
-  addKeyBinding,
-  changeWhenExpression,
-  clearInput,
-  copyCommandId,
-  copyCommandTitle,
-  focusFirst: focusFirst$4,
-  focusIndex: focusIndex$4,
-  focusLast: focusLast$3,
-  focusNext: focusNext$4,
-  focusPrevious: focusPrevious$4,
-  handleClick: handleClick$1,
-  handleContextMenu: handleContextMenu$3,
-  handleDoubleClick,
-  handleInput: handleInput$4,
-  handleWheel: handleWheel$1,
-  open: open$5,
-  removeKeyBinding,
-  resetKeyBinding,
-  showSameKeyBindings,
-  sortByPrecedence,
-  startRecordingKeys,
-  stopRecordingKeys,
-  toggleRecordingKeys
-};
-
-const Control = 'Control';
-const Space = 'Space';
-const Alt = 'Alt';
-
-const getKeyOptions = rawKey => {
-  if (rawKey.includes('+')) {
-    const parts = rawKey.split('+');
-    let ctrlKey = false;
-    let altKey = false;
-    let key = '';
-    for (const part of parts) {
-      switch (part) {
-        case Alt:
-          altKey = true;
-          break;
-        case Control:
-          ctrlKey = true;
-          break;
-        case Space:
-          key = ' ';
-          break;
-        default:
-          key = part;
-          break;
-      }
-    }
-    return {
-      altKey,
-      ctrlKey,
-      key
-    };
-  }
-  return {
-    altKey: false,
-    ctrlKey: false,
-    key: rawKey
-  };
-};
-
-const press = async key => {
-  const keyOptions = getKeyOptions(key);
-  const options = {
-    bubbles: true,
-    cancelable: true,
-    ...keyOptions
-  };
-  await invoke('TestFrameWork.performKeyBoardAction', 'press', options);
-};
-
-const KeyBoard = {
-  press
-};
-
-const showSideBar = async () => {
-  await execute$1('Layout.showSideBar');
-};
-const handleWorkspaceRefresh = async () => {
-  await invoke('Layout.handleWorkspaceRefresh');
-};
-
-const Layout = {
-  handleWorkspaceRefresh,
-  showSideBar
-};
-
-const open$4 = async () => {
-  await invoke('Main.openUri', 'language-models:///1');
-};
-const handleFilterInput$2 = async value => {
-  await invoke('LanguageModels.handleFilterInput', value);
-};
-const clearFilterInput = async () => {
-  await invoke('LanguageModels.clearFilterInput');
-};
-const addModel = async () => {
-  await invoke('LanguageModels.addModel');
-};
-const removeModel = async id => {
-  await invoke('LanguageModels.removeModel', id);
-};
-
-const LanguageModels = {
-  addModel,
-  clearFilterInput,
-  handleFilterInput: handleFilterInput$2,
-  open: open$4,
-  removeModel
-};
-
-const openUri = async uri => {
-  await invoke('Main.openUri', uri);
-};
-const splitRight = async () => {
-  await invoke('Main.splitRight');
-};
-const splitDown = async () => {
-  await invoke('Main.splitDown');
-};
-const openKeyBindings = async () => {
-  await invoke('Main.openKeyBindings');
-};
-const handleClickTogglePreview = async () => {
-  await invoke('Main.handleClickTogglePreview');
-};
-const closeAllEditors = async () => {
-  await invoke('Main.closeAllEditors');
-};
-const closeTabsLeft = async () => {
-  await invoke('Main.closeTabsLeft');
-};
-const handleModifiedStatusChange = async (uri, newStatus) => {
-  await invoke('Main.handleModifiedStatusChange', uri, newStatus);
-};
-const closeTabsRight = async () => {
-  await invoke('Main.closeTabsRight');
-};
-const selectTab$1 = async (groupIndex, tabIndex) => {
-  await invoke('Main.selectTab', groupIndex, tabIndex);
-};
-const closeOthers = async () => {
-  await invoke('Main.closeOthers');
-};
-const closeActiveEditor = async () => {
-  await invoke('Main.closeActiveEditor');
-};
-const save = async () => {
-  await invoke('Main.save');
-};
-const saveAll = async () => {
-  await invoke('Main.saveAll');
-};
-const focusFirst$3 = async () => {
-  await invoke('Main.focusFirst');
-};
-const focusNext$3 = async () => {
-  await invoke('Main.focusNext');
-};
-const focusPrevious$3 = async () => {
-  await invoke('Main.focusPrevious');
-};
-const focusLast$2 = async () => {
-  await invoke('Main.focusLast');
-};
-const handleTabContextMenu = async (button, x, y) => {
-  await invoke('Main.handleTabContextMenu', button, x, y);
-};
-const copyPath$1 = async () => {
-  await invoke('Main.copyPath');
-};
-const copyRelativePath = async () => {
-  await invoke('Main.copyRelativePath');
-};
-
-const Main = {
-  closeActiveEditor,
-  closeAllEditors,
-  closeOthers,
-  closeTabsLeft,
-  closeTabsRight,
-  copyPath: copyPath$1,
-  copyRelativePath,
-  focusFirst: focusFirst$3,
-  focusLast: focusLast$2,
-  focusNext: focusNext$3,
-  focusPrevious: focusPrevious$3,
-  handleClickTogglePreview,
-  handleModifiedStatusChange,
-  handleTabContextMenu,
-  openKeyBindings,
-  openUri,
-  save,
-  saveAll,
-  selectTab: selectTab$1,
-  splitDown,
-  splitRight
-};
-
-const enableMemoryOpener = async () => {
-  await invoke$1('Open.enableMemoryOpener');
-};
-const disableMemoryOpener = async () => {
-  await invoke$1('Open.disableMemoryOpener');
-};
-const matchesExpectedText = (actualText, expectedText) => {
-  if (typeof expectedText === 'string') {
-    return actualText === expectedText;
-  }
-  return expectedText.test(actualText);
-};
-const shouldHaveUrl = async expectedText => {
-  const actualText = await invoke$1('Open.readOpenedUrl');
-  if (!matchesExpectedText(actualText, expectedText)) {
-    throw new AssertionError(`expected opened url to be "${expectedText}" but was "${actualText}"`);
-  }
-};
-
-const Open = {
-  disableMemoryOpener,
-  enableMemoryOpener,
-  shouldHaveUrl
-};
-
-const open$3 = async id => {
-  await invoke('Layout.showPanel', id);
-};
-const openProblems = async () => {
-  await open$3('Problems');
-  await invoke('Panel.selectIndex', 0);
-};
-
-const Panel = {
-  open: open$3,
-  openProblems
-};
-
-const show$4 = async () => {
-  await open$3('Output');
-  await invoke('Panel.selectIndex', 1);
-};
-const handleFilterInput$1 = async text => {
-  await invoke('Output.handleFilterInput', text, Script);
-};
-const selectChannel = async channelId => {
-  await invoke('Output.selectChannel', channelId);
-};
-const clear$2 = async () => {
-  await invoke('Output.clear');
-};
-const saveAs = async () => {
-  await invoke('Output.saveAs');
-};
-
-const Output = {
-  clear: clear$2,
-  handleFilterInput: handleFilterInput$1,
-  saveAs,
-  selectChannel,
-  show: show$4
-};
-
-const getIsFirefox = () => {
-  if (typeof navigator === 'undefined') {
-    return false;
-  }
-  if (
-  // @ts-expect-error
-  navigator.userAgentData?.brands) {
-    // @ts-expect-error
-    return navigator.userAgentData.brands.includes('Firefox');
-  }
-  return navigator.userAgent.toLowerCase().includes('firefox');
-};
-
-const getNodePath$1 = () => {
-  return invoke(/* Platform.getNodePath */'Platform.getNodePath');
-};
-
-const getNodePath = () => {
-  return getNodePath$1();
-};
-const isFirefox = () => {
-  return getIsFirefox();
-};
-
-const Platform = {
-  getNodePath,
-  isFirefox
-};
-
-const open$2 = async uri => {
-  await invoke('Layout.showPreview', uri);
-};
-const handleClick = async hdId => {
-  await invoke('Preview.handleClick', hdId);
-};
-const handleInput$3 = async (hdId, value) => {
-  await invoke('Preview.handleInput', hdId, value);
-};
-const handleMouseDown = async (hdId, clientX, clientY) => {
-  await invoke('Preview.handleMouseDown', hdId, clientX, clientY);
-};
-const handleMouseUp = async (hdId, value, clientX, clientY) => {
-  await invoke('Preview.handleMouseUp', hdId, value, clientX, clientY);
-};
-const handleMouseMove = async (hdId, value, clientX, clientY) => {
-  await invoke('Preview.handleMouseMove', hdId, value, clientX, clientY);
-};
-const handleKeyDown = async (hdId, key, code) => {
-  await invoke('Preview.handleKeyDown', hdId, key, code);
-};
-const setUri = async uri => {
-  await invoke('Preview.setUri', uri);
-};
-
-/**
- * @deprecated use waitForMutation instead
- */
-const waitForClick = async () => {
-  await invoke('Preview.waitForClick');
-};
-const waitForMutation = async () => {
-  await invoke('Preview.waitForMutation');
-};
-
-const Preview = {
-  handleClick,
-  handleInput: handleInput$3,
-  handleKeyDown,
-  handleMouseDown,
-  handleMouseMove,
-  handleMouseUp,
-  open: open$2,
-  setUri,
-  waitForClick,
-  waitForMutation
-};
-
-const show$3 = async () => {
-  await invoke('Panel.selectIndex', 0);
-};
-const handleFilterInput = async text => {
-  await invoke('Problems.handleFilterInput', text, Script);
-};
-const copyMessage = async () => {
-  await invoke('Problems.copyMessage');
-};
-const focusIndex$3 = async index => {
-  await invoke('Problems.focusIndex', index);
-};
-const handleArrowLeft = async () => {
-  await invoke('Problems.handleArrowLeft');
-};
-const handleArrowRight = async () => {
-  await invoke('Problems.handleArrowRight');
-};
-const handleClickAt$1 = async (x, y) => {
-  await invoke('Problems.handleClickAt', x, y);
-};
-const handleIconThemeChange = async () => {
-  await invoke('Problems.handleIconThemeChange');
-};
-const viewAsList = async () => {
-  await invoke('Problems.viewAsList');
-};
-const viewAsTable = async () => {
-  await invoke('Problems.viewAsTable');
-};
-
-const Problems = {
-  copyMessage,
-  focusIndex: focusIndex$3,
-  handleArrowLeft,
-  handleArrowRight,
-  handleClickAt: handleClickAt$1,
-  handleFilterInput,
-  handleIconThemeChange,
-  show: show$3,
-  viewAsList,
-  viewAsTable
-};
-
-const callbacks = Object.create(null);
-const registerCallbackCommand = async commandId => {
-  const id = createId();
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  callbacks[id] = resolve;
-  await invoke(`Test.registerTestCommand`, commandId);
-  return {
-    promise
-  };
-};
-
-const QuickPick$1 = 'QuickPick';
-
-const open$1 = async () => {
-  await invoke('Viewlet.openWidget', QuickPick$1, 'everything');
-};
-const handleInput$2 = async value => {
-  await invoke('QuickPick.handleInput', value, 0);
-};
-const handleClickAt = async (x, y) => {
-  await invoke('QuickPick.handleClickAt', x, y);
-};
-const setValue$1 = async value => {
-  await invoke('QuickPick.setValue', value);
-};
-const focusNext$2 = async () => {
-  await invoke('QuickPick.focusNext');
-};
-const focusFirst$2 = async () => {
-  await invoke('QuickPick.focusFirst');
-};
-const focusLast$1 = async () => {
-  await invoke('QuickPick.focusLast');
-};
-const focusIndex$2 = async index => {
-  await invoke('QuickPick.focusIndex', index);
-};
-const focusPrevious$2 = async () => {
-  await invoke('QuickPick.focusPrevious');
-};
-const selectItem = async label => {
-  await invoke('QuickPick.selectItem', label);
-};
-const selectIndex$3 = async index => {
-  await invoke('QuickPick.selectIndex', index);
-};
-const selectCurrentIndex = async () => {
-  await invoke('QuickPick.selectCurrentIndex');
-};
-const executeCommand = async label => {
-  await invoke('QuickPick.showCommands');
-  await invoke('QuickPick.handleInput', label, 0);
-  await invoke('QuickPick.selectItem', label);
-};
-const selectItem2 = async ({
-  callbackCommand,
-  label
-}) => {
-  const {
-    promise
-  } = await registerCallbackCommand(callbackCommand);
-
-  // @ts-ignore
-  invoke('QuickPick.selectItem', label);
-  await promise;
-};
-
-const QuickPick = {
-  executeCommand,
-  focusFirst: focusFirst$2,
-  focusIndex: focusIndex$2,
-  focusLast: focusLast$1,
-  focusNext: focusNext$2,
-  focusPrevious: focusPrevious$2,
-  handleClickAt,
-  handleInput: handleInput$2,
-  open: open$1,
-  selectCurrentIndex,
-  selectIndex: selectIndex$3,
-  selectItem,
-  selectItem2,
-  setValue: setValue$1
-};
-
-const clear$1 = async () => {
-  return invoke('References.clear');
-};
-const collapseAll$1 = async () => {
-  return invoke('References.collapseAll');
-};
-const refresh = async () => {
-  return invoke('References.refresh');
-};
-
-const References = {
-  clear: clear$1,
-  collapseAll: collapseAll$1,
-  refresh
-};
-
-const show$2 = async () => {
-  await open$7('Run And Debug');
-};
-const handleClickSectionBreakPoints = async () => {
-  await invoke('Run And Debug.handleClickSectionBreakPoints');
-};
-const handleClickSectionWatch = async () => {
-  await invoke('Run And Debug.handleClickSectionWatch');
-};
-const addWatchExpression = async expression => {
-  await invoke('Run And Debug.addWatchExpression', expression);
-};
-const handleWatchValueChange = async () => {
-  await invoke('Run And Debug.handleWatchValueChange');
-};
-const acceptWatchExpressionEdit = async () => {
-  await invoke('Run And Debug.acceptWatchExpressionEdit');
-};
-const selectIndex$2 = async index => {
-  await invoke('Run And Debug.selectIndex', index);
-};
-const setPauseOnExceptions = async value => {
-  await invoke('Run And Debug.setPauseOnExceptions', value);
-};
-const handleRename = async () => {
-  await invoke('Run And Debug.handleRename');
-};
-const handleSpace = async () => {
-  await invoke('Run And Debug.handleSpace');
-};
-
-const RunAndDebug = {
-  acceptWatchExpressionEdit,
-  addWatchExpression,
-  handleClickSectionBreakPoints,
-  handleClickSectionWatch,
-  handleRename,
-  handleSpace,
-  handleWatchValueChange,
-  selectIndex: selectIndex$2,
-  setPauseOnExceptions,
-  show: show$2
-};
-
-const setValue = async value => {
-  await invoke('Search.handleInput', value, Script);
-};
-const setReplaceValue = async value => {
-  await invoke('Search.handleReplaceInput', value, Script);
-};
-const setExcludeValue = async value => {
-  await invoke('Search.handleExcludeInput', value, Script);
-};
-const replaceAll = async () => {
-  await invoke('Search.replaceAll');
-};
-const setIncludeValue = async value => {
-  await invoke('Search.handleIncludeInput', value, Script);
-};
-const clearSearchResults = async () => {
-  await invoke('Search.clearSearchResults');
-};
-const openDetails = async () => {
-  await invoke('Search.openDetails');
-};
-const collapseDetails = async () => {
-  await invoke('Search.collapseDetails');
-};
-const dismissItem = async () => {
-  await invoke('Search.dismissItem');
-};
-const focusFirst$1 = async () => {
-  await invoke('Search.focusFirst');
-};
-const focusIndex$1 = async index => {
-  await invoke('Search.focusIndex', index);
-};
-const selectIndex$1 = async index => {
-  await invoke('Search.selectIndex', index);
-};
-const focusNext$1 = async () => {
-  await invoke('Search.focusNext');
-};
-const handleWheel = async (deltaMode, deltaY) => {
-  await invoke('Search.handleWheel', deltaMode, deltaY);
-};
-const focusNextPage = async () => {
-  await invoke('Search.focusPage');
-};
-const focusPreviousPage = async () => {
-  await invoke('Search.focusPreviousPage');
-};
-const focusPrevious$1 = async () => {
-  await invoke('Search.focusPrevious');
-};
-const toggleSearchDetails = async () => {
-  await invoke('Search.toggleSearchDetails');
-};
-const toggleMatchCase = async () => {
-  await invoke('Search.toggleMatchCase');
-};
-const toggleMatchWholeWord = async () => {
-  await invoke('Search.toggleMatchWholeWord');
-};
-const togglePreserveCase = async () => {
-  await invoke('Search.togglePreserveCase');
-};
-const toggleUseRegularExpression = async () => {
-  await invoke('Search.toggleUseRegularExpression');
-};
-const toggleReplace = async () => {
-  await invoke('Search.toggleReplace');
-};
-const open = async () => {
-  await invoke('SideBar.openViewlet', 'Search');
-};
-const setLimit = async limit => {
-  await invoke('Search.setLimit', limit);
-};
-const handleListBlur = async () => {
-  await invoke('Search.handleListBlur');
-};
-const collapseAll = async () => {
-  await invoke('Search.collapseAll');
-};
-const copy = async () => {
-  await invoke('Search.copy');
-};
-const copyPath = async () => {
-  await invoke('Search.copyPath');
-};
-const handleInputCut = async name => {
-  await invoke('Search.handleInputCut', name);
-};
-const handleInputPaste = async name => {
-  await invoke('Search.handleInputPaste', name);
-};
-const handleInputCopy = async name => {
-  await invoke('Search.handleInputCopy', name);
-};
-const handleInputSelectionChange = async (name, start, end) => {
-  await invoke('Search.handleInputSelectionChange', name, start, end);
-};
-const handleInputContextMenu = async (name, button, x, y) => {
-  await invoke('Search.handleInputConextMenu', name, button, x, y);
-};
-const handleContextMenu$2 = async (button, x, y) => {
-  await invoke('Search.handleContextMenu', button, x, y);
-};
-const enableRenderFolderPaths = async () => {
-  await invoke('Search.enableRenderFolderPaths');
-};
-const disableRenderFolderPaths = async () => {
-  await invoke('Search.disableRenderFolderPaths');
-};
-
-const Search = {
-  clearSearchResults,
-  collapseAll,
-  collapseDetails,
-  copy,
-  copyPath,
-  disableRenderFolderPaths,
-  dismissItem,
-  enableRenderFolderPaths,
-  focusFirst: focusFirst$1,
-  focusIndex: focusIndex$1,
-  focusNext: focusNext$1,
-  focusNextPage,
-  focusPrevious: focusPrevious$1,
-  focusPreviousPage,
-  handleContextMenu: handleContextMenu$2,
-  handleInputContextMenu,
-  handleInputCopy,
-  handleInputCut,
-  handleInputPaste,
-  handleInputSelectionChange,
-  handleListBlur,
-  handleWheel,
-  open,
-  openDetails,
-  replaceAll,
-  selectIndex: selectIndex$1,
-  setExcludeValue,
-  setIncludeValue,
-  setLimit,
-  setReplaceValue,
-  setValue,
-  toggleMatchCase,
-  toggleMatchWholeWord,
-  togglePreserveCase,
-  toggleReplace,
-  toggleSearchDetails,
-  toggleUseRegularExpression
-};
-
-const show$1 = async () => {
-  return invoke('Main.openUri', 'settings://');
-};
-const handleInput$1 = async searchValue => {
-  return invoke('Settings.handleInput', searchValue, Script);
-};
-const usePreviousSearchValue = async () => {
-  return invoke('Settings.usePreviousSearchValue');
-};
-const useNextSearchValue = async () => {
-  return invoke('Settings.useNextSearchValue');
-};
-const clear = async searchValue => {
-  return invoke('Settings.clear', searchValue, Script);
-};
-const clearHistory = async () => {
-  return invoke('Settings.clearHistory');
-};
-const selectTab = async tabId => {
-  return invoke('Settings.handleClickTab', tabId);
-};
-const selectWorkspace = async () => {
-  await selectTab('workspace');
-};
-const selectTextEditor = async () => {
-  await selectTab('text-editor');
-};
-const selectExtensions = async () => {
-  await selectTab('extensions');
-};
-const selectWindow = async () => {
-  await selectTab('window');
-};
-const handleScroll = async scrollTop => {
-  await invoke('Settings.handleScroll', scrollTop, Script);
-};
-const handleClickFilterButton = async (x, y) => {
-  await invoke('Settings.handleClickFilterButton', x, y);
-};
-
-const SettingsView = {
-  clear,
-  clearHistory,
-  handleClickFilterButton,
-  handleInput: handleInput$1,
-  handleScroll,
-  selectExtensions,
-  selectTab,
-  selectTextEditor,
-  selectWindow,
-  selectWorkspace,
-  show: show$1,
-  useNextSearchValue,
-  usePreviousSearchValue
-};
-
-const selectIndex = async index => {
-  await invoke('Source Control.selectIndex', index);
-};
-const acceptInput = async () => {
-  await invoke('Source Control.acceptInput');
-};
-const handleInput = async text => {
-  await invoke('Source Control.handleInput', text, Script$1);
-};
-const handleClickSourceControlButtons = async (index, name) => {
-  await invoke('Source Control.handleClickSourceControlButtons', index, name);
-};
-const handleContextMenu$1 = async (button, x, y) => {
-  await invoke('Source Control.handleContextMenu', button, x, y);
-};
-const show = async () => {
-  await open$7('Source Control');
-};
-
-const SourceControl = {
-  acceptInput,
-  handleClickSourceControlButtons,
-  handleContextMenu: handleContextMenu$1,
-  handleInput,
-  selectIndex,
-  show
-};
-
-const update = async () => {
-  await invoke('StatusBar.updateStatusBarItems');
-};
-
-const StatusBar = {
-  update
-};
-
-const closeMenu = async () => {
-  await invoke('TitleBar.closeMenu');
-};
-const focus = async () => {
-  await invoke('TitleBar.focus');
-};
-const focusFirst = async () => {
-  await invoke('TitleBar.focusFirst');
-};
-const setTitleTemplate = async template => {
-  await invoke('TitleBar.setTitleTemplate', template);
-};
-const focusIndex = async index => {
-  await invoke('TitleBar.focusIndex', index);
-};
-const focusLast = async () => {
-  await invoke('TitleBar.focusLast');
-};
-const focusNext = async () => {
-  await invoke('TitleBar.focusNext');
-};
-const focusPrevious = async () => {
-  await invoke('TitleBar.focusPrevious');
-};
-const handleKeyArrowDown = async () => {
-  await invoke('TitleBar.handleKeyArrowDown');
-};
-const handleKeyArrowLeft = async () => {
-  await invoke('TitleBar.handleKeyArrowLeft');
-};
-const handleKeyArrowRight = async () => {
-  await invoke('TitleBar.handleKeyArrowRight');
-};
-const handleKeyArrowUp = async () => {
-  await invoke('TitleBar.handleKeyArrowUp');
-};
-const handleKeyEnd = async () => {
-  await invoke('TitleBar.handleKeyEnd');
-};
-const handleKeyHome = async () => {
-  await invoke('TitleBar.handleKeyHome');
-};
-const handleKeySpace = async () => {
-  await invoke('TitleBar.handleKeySpace');
-};
-const handleKeyEscape = async () => {
-  await invoke('TitleBar.handleKeyEscape');
-};
-const toggleIndex = async index => {
-  await invoke('TitleBar.toggleIndex', index);
-};
-const toggleMenu = async () => {
-  await invoke('TitleBar.toggleMenu');
-};
-const handleContextMenu = async (button, x, y) => {
-  await invoke('TitleBar.handleContextMenu', button, x, y);
-};
-
-const TitleBarMenuBar = {
-  closeMenu,
-  focus,
-  focusFirst,
-  focusIndex,
-  focusLast,
-  focusNext,
-  focusPrevious,
-  handleContextMenu,
-  handleKeyArrowDown,
-  handleKeyArrowLeft,
-  handleKeyArrowRight,
-  handleKeyArrowUp,
-  handleKeyEnd,
-  handleKeyEscape,
-  handleKeyHome,
-  handleKeySpace,
-  setTitleTemplate,
-  toggleIndex,
-  toggleMenu
-};
-
-let url = '';
-const setUrl = newUrl => {
-  url = newUrl;
-};
-const resolve = relativePath => {
-  return new URL(relativePath, url).toString();
-};
-
-const Url = {
-  resolve,
-  setUrl
-};
-
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-// TODO ask webview worker directly
-const getWebViewInfo = async webViewId => {
-  const info = await invoke('WebView.getWebViewInfo2', webViewId);
-  return info;
-};
-
-const setWebViewPort = async (uid, port, origin, portType) => {
-  await invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
-};
-
-const transferWebViewPort = async (webViewId, port) => {
-  const info = await getWebViewInfo(webViewId);
-  const portType = 'test';
-  await setWebViewPort(info.uid, port, info.origin, portType);
-};
-
-const waitForFirstEventEvent = async port => {
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  port.onmessage = resolve;
-  const firstEvent = await promise;
-  return firstEvent;
-};
-
-const createPortRpc = async webViewId => {
-  // TODO use transforpemssageportrpc
-  const {
-    port1,
-    port2
-  } = getPortTuple();
-  const firstEventPromise = waitForFirstEventEvent(port1);
-  // TODO ask extension host worker about webview uid
-  await transferWebViewPort(webViewId, port2);
-  const firstEvent = await firstEventPromise;
-  if (firstEvent.data !== 'ready') {
-    throw new Error('unexpected first message');
-  }
-  const rpc = await create$2({
-    commandMap: {},
-    isMessagePortOpen: true,
-    messagePort: port1
-  });
-  return rpc;
-};
-
-const fromId = async webViewId => {
-  const rpc = await createPortRpc(webViewId);
-  set(webViewId, rpc);
-  return {
-    locator(selector, options) {
-      const baseLocator = createLocator(selector, options);
-
-      // @ts-ignore
-      baseLocator.webViewId = webViewId;
-      return baseLocator;
-    }
-  };
-};
-
-const WebView = {
-  fromId
-};
-
-const setPath = async path => {
-  await invoke('Workspace.setPath', path);
-};
-const openTmpDir = async () => {
-  const tmpDir = await getTmpDir();
-  await setPath(tmpDir);
-  return tmpDir;
-};
-
-const Workspace = {
-  openTmpDir,
-  setPath
-};
-
-const load = async url => {
-  await invoke('Audio.load', url);
-};
-const play = async url => {
-  await invoke('Audio.play', url);
-};
-const pause = async () => {
-  await invoke('Audio.pause');
-};
-
-const Audio = {
-  load,
-  pause,
-  play
-};
-
-const createApi = (platform, assetDir) => {
-  return {
-    About,
-    ActivityBar,
-    Audio,
-    BaseUrl: {
-      getBaseUrl() {
-        return assetDir;
-      }
-    },
-    Chat,
-    ChatDebug,
-    ClipBoard,
-    ColorPicker,
-    Command,
-    ContextMenu,
-    Developer,
-    Dialog,
-    Editor,
-    EditorCompletion,
-    EditorHover,
-    EditorRename,
-    EditorSourceAction,
-    expect,
-    Explorer,
-    Extension,
-    ExtensionDetail,
-    ExtensionSearch,
-    FileSystem: {
-      ...FileSystem,
-      loadFixture(url) {
-        return loadFixture(platform, url);
-      }
-    },
-    FindWidget,
-    getTmpDir: getTmpDir$1,
-    // TODO maybe deprecate this or move to file system
-    IconTheme,
-    IframeInspector,
-    KeyBindingsEditor,
-    KeyBoard,
-    LanguageModels,
-    Layout,
-    Locator: createLocator,
-    Main,
-    Open,
-    Output,
-    Panel,
-    Platform,
-    Preview,
-    Problems,
-    QuickPick,
-    References,
-    RunAndDebug,
-    Search,
-    Settings,
-    SettingsView,
-    SideBar,
-    SourceControl,
-    StatusBar,
-    test,
-    TitleBarMenuBar,
-    Url,
-    WebView,
-    Workspace
-  };
-};
-
-const callFunction = async (fn, args) => {
-  try {
-    await fn(args);
-    return undefined;
-  } catch (error) {
-    return error;
-  }
-};
-
-const formatDuration = duration => {
-  return duration.toFixed(2) + 'ms';
-};
-
-const Fail = 'fail';
-const Pass = 'pass';
-
-const executeTest2 = async (name, fn, globals, timestampGenerator) => {
-  const getTimestamp = timestampGenerator;
-  const start = getTimestamp();
-  const error = await callFunction(fn, globals);
-  const end = getTimestamp();
-  const duration = end - start;
-  const formattedDuration = formatDuration(duration);
-  if (error) {
-    return {
-      background: 'red',
-      duration,
-      end,
-      error,
-      formattedDuration,
-      name,
-      start,
-      text: `test failed: ${error}`,
-      type: Fail
-    };
-  }
-  return {
-    background: 'green',
-    duration,
-    end,
-    error: undefined,
-    formattedDuration,
-    name,
-    start,
-    text: `test passed in ${formattedDuration}`,
-    type: Pass
-  };
-};
-
-const printError = error => {
-  if (error && error.constructor.name === 'AssertionError') {
-    console.error(error.message);
-  } else {
-    console.error(error);
-  }
-};
-
-const printTestError = async error => {
-  // TODO ask error worker to add codeframe
-  printError(error);
-};
-
-const now = () => {
-  return performance.now();
-};
-
-const executeTest = async (name, fn, globals = {}) => {
-  const {
-    background,
-    error,
-    formattedDuration,
-    text,
-    type
-  } = await executeTest2(name, fn, globals, now);
-  if (error) {
-    await printTestError(error);
-  } else {
-    // eslint-disable-next-line no-console
-    console.info(`PASS ${name} in ${formattedDuration}`);
-  }
-  await invoke('TestFrameWork.showOverlay', type, background, text);
-};
-
-const hotReloadEnabled = async () => {
-  const preference = await getPreference('E2eTest.hotReload');
-  return Boolean(preference);
-};
-
-const importScript = async url => {
-  try {
-    return await import(url);
-  } catch (error) {
-    throw error;
-    // TODO
-    // const actualErrorMessage = await TryToGetactualImportErrorMessage.tryToGetActualImportErrorMessage(url, error)
-    // throw new Error(actualErrorMessage)
-  }
-};
-
-const importTest = async url => {
-  try {
-    return await importScript(url);
-  } catch (error) {
-    throw new VError(error, 'Failed to import test');
-  }
-};
-
-let items = [];
-const push = item => {
-  items = [...items, item];
-};
-const maybeLast = () => {
-  return items.at(-1);
-};
-
-const getFileUri = href => {
-  const rest = href.slice('/remote'.length);
-  const fileUrl = `file://${rest}`;
-  return fileUrl;
-};
-
-const watchForHotReload = async (platform, href) => {
-  if (platform !== Remote) {
-    return;
-  }
-  if (!href.startsWith('/remote')) {
-    return;
-  }
-  const fileUrl = getFileUri(href);
-  const callbackCommand = 'FileWatcher.handleEvent';
-  await invoke('FileWatcher.watchFile', TestWorker, callbackCommand, fileUrl);
-};
-
-// TODO move this into three steps:
-// 1. import test module
-// 2. execute test
-// 3. print out results
-const execute = async (href, platform, assetDir) => {
-  push({
-    assetDir,
-    inProgress: true,
-    platform,
-    url: href
-  });
-  const globals = createApi(platform, assetDir);
-  // TODO
-  // 0. wait for page to be ready
-  // 1. get script to import from renderer process (url or from html)
-  const scriptUrl = href;
-  setUrl(scriptUrl); // TODO avoid side effect
-  // 2. import that script
-  const module = await importTest(scriptUrl);
-  const {
-    mockRpc,
-    name,
-    skip,
-    test
-  } = module;
-  if (mockRpc) {
-    setMockRpc(mockRpc);
-  }
-  if (test) {
-    if (skip) {
-      await skipTest(name);
-    } else {
-      await executeTest(name, test, globals);
-    }
-  }
-  // TODO maybe setup file watcher earlier, to not miss events?
-
-  push({
-    assetDir,
-    inProgress: false,
-    platform,
-    url: href
-  });
-  // TODO if file watcher was previously added, don't need to add one
-  try {
-    if (await hotReloadEnabled()) {
-      await watchForHotReload(platform, href);
-    }
-  } catch {
-    // ignore
-  }
-};
-
-const doHotReload = async (url, platform, assetDir) => {
-  // eslint-disable-next-line no-console
-  console.clear();
-  await execute(url, platform, assetDir);
-};
-
-const createUrlWithQueryParameter = (url, locationHref, time) => {
-  const parsedUrl = new URL(url, locationHref);
-  parsedUrl.searchParams.set('time', `${time}`);
-  const string = parsedUrl.toString();
-  return string;
-};
-
-const emptyHotReloadArgs = {
-  assetDir: '',
-  platform: 0,
-  shouldHotReload: false,
-  url: ''
-};
-
-const getHotReloadArgs = (latestItem, locationHref, time) => {
-  if (!latestItem) {
-    return emptyHotReloadArgs;
-  }
-  const {
-    assetDir,
-    inProgress,
-    platform,
-    url
-  } = latestItem;
-  if (inProgress) {
-    return emptyHotReloadArgs;
-  }
-  const withQueryParameter = createUrlWithQueryParameter(url, locationHref, time);
-  return {
-    assetDir,
-    platform,
-    shouldHotReload: true,
-    url: withQueryParameter
-  };
-};
-
-const hotReloadTest = async (lastItem, locationHref, time) => {
-  const {
-    assetDir,
-    platform,
-    shouldHotReload,
-    url
-  } = getHotReloadArgs(lastItem, locationHref, time);
-  if (!shouldHotReload) {
-    return;
-  }
-  await doHotReload(url, platform, assetDir);
-};
-
-const handleFileWatcherEvent = async event => {
-  const locationHref = location.href;
-  const time = Date.now();
-  const lastItem = maybeLast();
-  await hotReloadTest(lastItem, locationHref, time);
-};
-
-const commandMap = {
-  'FileWatcher.handleEvent': handleFileWatcherEvent,
-  'Test.execute': execute,
-  'Test.executeMock': executeMock
-};
-
-const initializeRendererWorker = async () => {
-  const rpc = await create$1({
-    commandMap: commandMap
-  });
-  set$1(rpc);
-};
-
-const listen = async () => {
-  await Promise.all([initializeRendererWorker(), initializeEditorWorker(), initializeOpenerWorker()]);
-};
-
-const main = async () => {
-  await listen();
-};
-
-main();