@lvce-editor/static-server 0.71.19 → 0.71.21

package/static/9f15f2a/packages/test-worker/dist/testWorkerMain.js

@@ -0,0 +1,4133 @@
+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 = 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;
+    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) {
+    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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
+
+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 TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
+  }
+  return parentStack;
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const restoreJsonRpcError = error => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === 'string') {
+      error.stack = error.stack + NewLine + currentStack;
+    }
+    return error;
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        // @ts-ignore
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        // @ts-ignore
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
+        const indexNewLine = getNewLineIndex(lowerStack);
+        const parentStack = getParentStack(error);
+        // @ts-ignore
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        // @ts-ignore
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError('unexpected response message');
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const resolve$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,
+      message: error.message,
+      data: error.stack
+    };
+  }
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: getStack(prettyError),
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1 = (id, error) => {
+  return {
+    jsonrpc: Two$1,
+    id,
+    error
+  };
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1(id, errorProperty);
+};
+const create$4 = (message, result) => {
+  return {
+    jsonrpc: Two$1,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$4(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    jsonrpc: Two$1,
+    id,
+    error: {
+      code: Custom,
+      // @ts-ignore
+      message: error.message,
+      data: error
+    }
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve$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 {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
+  }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+
+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 = '2.0';
+const create$t = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$s = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$r = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$r();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$s(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$t(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;
+};
+
+/* eslint-disable @typescript-eslint/no-misused-promises */
+
+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$j = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  return createSharedLazyRpc(() => {
+    return create$3({
+      commandMap,
+      isMessagePortOpen,
+      send
+    });
+  });
+};
+const LazyTransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$j
+};
+const create$e = 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 MessagePortRpcParent = {
+  __proto__: null,
+  create: create$e
+};
+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$3 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
+const create$2 = async ({
+  commandMap
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebWorkerRpcClient = {
+  __proto__: null,
+  create: create$2
+};
+const 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 Directory = 3;
+
+const Script$1 = 2;
+
+const Web = 1;
+const Remote = 3;
+
+const EditorWorker = 99;
+const RendererWorker = 1;
+const TestWorker = 9001;
+
+const rpcs = Object.create(null);
+const set$3 = (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$3(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove$1(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
+    set(rpc) {
+      set$3(rpcId, rpc);
+    }
+  };
+};
+
+const {
+  invoke: invoke$1,
+  set: set$2
+} = create(EditorWorker);
+
+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 readFile$1 = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
+const getPreference = async key => {
+  return await invoke('Preferences.get', key);
+};
+
+const send = async port => {
+  await sendMessagePortToEditorWorker(port, TestWorker);
+};
+const initializeEditorWorker = async () => {
+  const rpc = await LazyTransferMessagePortRpcParent.create({
+    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 = {
+  __proto__: null,
+  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$6 = async () => {
+  return invoke('About.showAbout');
+};
+const handleClickOk = async () => {
+  return invoke('About.handleClickOk');
+};
+const handleClickClose = 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 = {
+  __proto__: null,
+  focusNext: focusNext$9,
+  focusPrevious: focusPrevious$8,
+  handleClickClose,
+  handleClickCopy,
+  handleClickOk,
+  show: show$6
+};
+
+const focus$2 = async () => {
+  await invoke('ActivityBar.focus');
+};
+const focusFirst$7 = async () => {
+  await invoke('ActivityBar.focusFirst');
+};
+const setAccountEnabled = async enabled => {
+  await invoke('ActivityBar.setAccountEnabled');
+};
+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$3 = async index => {
+  await invoke('ActivityBar.handleClick', index);
+};
+const handleContextMenu$5 = async () => {
+  await invoke('ActivityBar.handleContextMenu');
+};
+const selectCurrent = async () => {
+  await invoke('ActivityBar.selectCurrent');
+};
+
+const ActivityBar = {
+  __proto__: null,
+  focus: focus$2,
+  focusFirst: focusFirst$7,
+  focusLast: focusLast$6,
+  focusNext: focusNext$8,
+  focusPrevious: focusPrevious$7,
+  handleClick: handleClick$3,
+  handleContextMenu: handleContextMenu$5,
+  selectCurrent,
+  setAccountEnabled
+};
+
+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 = (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(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 = {
+  __proto__: null,
+  disableMemoryClipBoard,
+  enableMemoryClipBoard,
+  readNativeFiles,
+  shouldHaveText: shouldHaveText$1,
+  writeNativeFiles,
+  writeText
+};
+
+const setRelativeX = async x => {
+  await invoke('ColorPicker.setRelativeX', x);
+};
+
+const ColorPicker = {
+  __proto__: null,
+  setRelativeX
+};
+
+const execute$1 = async (id, ...args) => {
+  return invoke(id, ...args);
+};
+
+const Command = {
+  __proto__: null,
+  execute: execute$1
+};
+
+const selectItem$1 = async text => {
+  await invoke('Menu.selectItem', text);
+};
+
+const ContextMenu = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  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$1('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 = {
+  __proto__: null,
+  disableDiagnostics: disableDiagnostics$1,
+  enableDiagnostics: enableDiagnostics$1,
+  update: update$1
+};
+
+const setCursor = async (rowIndex, columnIndex) => {
+  await invoke('Editor.cursorSet', rowIndex, columnIndex);
+};
+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 cursorUp = async () => {
+  await invoke('Editor.cursorUp');
+};
+const cursorWordLeft = async () => {
+  await invoke('Editor.cursorWordLeft');
+};
+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 openFindWidget = async () => {
+  await invoke('Editor.openFind');
+};
+const setDeltaY = async deltaY => {
+  await invoke('Editor.setDeltaY', deltaY);
+};
+const format = async () => {
+  await invoke('Editor.format');
+};
+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$1('Editor.getSelections', key);
+};
+const shouldHaveText = async expectedText => {
+  const key = await getEditorKey();
+  const text = await invoke$1('Editor.getText', key);
+  if (text !== expectedText) {
+    throw new Error(`Expected editor to have text ${expectedText} but was ${text}`);
+  }
+};
+const shouldHaveSelections = async expectedSelections => {
+  const key = await getEditorKey();
+  const selections = await invoke$1('Editor.getSelections', key);
+  if (!areSelectionsEqual(selections, expectedSelections)) {
+    throw new Error(`Expected editor to have selections ${expectedSelections} but was ${selections}`);
+  }
+};
+const undo = async () => {
+  await invoke$1('Editor.undo');
+};
+const redo = async () => {
+  await invoke$1('Editor.redo');
+};
+const shouldHaveDiagnostics = async expectedDiagnostics => {
+  const key = await getEditorKey();
+  const diagnostics = await invoke$1('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 = {
+  __proto__: null,
+  addAllMissingImports,
+  closeColorPicker,
+  closeCompletion,
+  closeCompletionDetails,
+  copy: copy$1,
+  copyLineDown,
+  copyLineUp,
+  cursorCharacterLeft,
+  cursorCharacterRight,
+  cursorDown,
+  cursorEnd,
+  cursorHome,
+  cursorUp,
+  cursorWordLeft,
+  cursorWordPartLeft,
+  cursorWordPartRight,
+  cursorWordRight,
+  deleteAllLeft,
+  deleteAllRight,
+  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,
+  setCursor,
+  setDeltaY,
+  setSelections,
+  shouldHaveDiagnostics,
+  shouldHaveSelections,
+  shouldHaveText,
+  showHover,
+  sortImports,
+  sourceActionsSelectCurrent,
+  toggleBlockComment,
+  toggleCompletionDetails,
+  toggleLineComment,
+  type,
+  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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  close: close$1,
+  show: show$5
+};
+
+const handleInput$5 = async value => {
+  await invoke('EditorRename.handleInput', value, Script);
+};
+const accept = async () => {
+  await invoke('EditorRename.accept');
+};
+const cancel = async () => {
+  await invoke('EditorRename.cancel');
+};
+
+const EditorRename = {
+  __proto__: null,
+  accept,
+  cancel,
+  handleInput: handleInput$5
+};
+
+const selectIndex$5 = async index => {
+  await invoke('EditorSourceAction.selectIndex', index);
+};
+const selectCurrentIndex$1 = async () => {
+  await invoke('EditorSourceAction.selectCurrentIndex');
+};
+
+const EditorSourceAction = {
+  __proto__: null,
+  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 handleInputBlur = async () => {
+  await invoke('Explorer.handleInputBlur');
+};
+const focus$1 = async () => {
+  await invoke('Explorer.focusIndex', -1);
+};
+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$2 = 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 = {
+  __proto__: null,
+  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$2,
+  handleClickAt: handleClickAt$2,
+  handleCopy,
+  handleCut,
+  handleDragLeave,
+  handleDragOver,
+  handleDragOverIndex,
+  handleDrop,
+  handleEscape,
+  handleInputBlur,
+  handlePaste,
+  newFile,
+  newFolder,
+  openContextMenu,
+  refresh: refresh$1,
+  removeDirent,
+  rename,
+  renameDirent,
+  selectAll,
+  selectDown,
+  selectIndices,
+  selectUp,
+  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 = {
+  __proto__: null,
+  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$6 = 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 = {
+  __proto__: null,
+  copyReadmeLink,
+  focusNextTab,
+  focusPreviousTab,
+  handleClickCategory,
+  handleClickDisable,
+  handleClickEnable,
+  handleClickSetColorTheme,
+  handleClickUninstall,
+  handleImageContextMenu,
+  handleReadmeContextMenu,
+  handleScroll: handleScroll$1,
+  handleTabFocus,
+  hideSizeLink,
+  open: open$6,
+  openCommands,
+  openFeature,
+  openJsonValidation,
+  openRuntimeStatus,
+  openSettings,
+  openThemes,
+  openWebViews,
+  selectChangelog,
+  selectDetails,
+  selectFeature,
+  selectFeatures,
+  selectTab: selectTab$2
+};
+
+const open$5 = async id => {
+  await invoke('SideBar.openViewlet', id);
+};
+const hide = async () => {
+  await invoke('Layout.hideSideBar');
+};
+
+const SideBar = {
+  __proto__: null,
+  hide,
+  open: open$5
+};
+
+const open$4 = async () => {
+  await open$5('Extensions');
+};
+const handleInput$4 = async value => {
+  await invoke('Extensions.handleInput', value, Script$1);
+};
+const handleClick$1 = 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 = {
+  __proto__: null,
+  clearSearchResults: clearSearchResults$1,
+  copyExtensionId,
+  copyExtensionInfo,
+  handleClick: handleClick$1,
+  handleClickFilter,
+  handleContextMenu: handleContextMenu$4,
+  handleInput: handleInput$4,
+  open: open$4
+};
+
+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);
+  for (const filePath of allFiles) {
+    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 = {
+  __proto__: null,
+  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 => {
+  await invoke('FileSystem.addFileHandle', file);
+};
+const mkdir = async uri => {
+  await 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 createDroppedFileHandle = async () => {
+  const directory = await navigator.storage.getDirectory();
+  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 = {
+  __proto__: null,
+  addFileHandle,
+  chmod,
+  createDroppedFileHandle,
+  createExecutable,
+  createExecutableFrom,
+  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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  focusFirst: focusFirst$5,
+  focusLast: focusLast$4,
+  focusNext: focusNext$5,
+  focusPrevious: focusPrevious$5,
+  selectIndex: selectIndex$4
+};
+
+const open$3 = async () => {
+  await invoke('Main.openUri', 'app://keybindings');
+};
+const handleInput$3 = value => {
+  return invoke('KeyBindings.handleInput', value);
+};
+const handleClick = (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 = {
+  __proto__: null,
+  addKeyBinding,
+  changeWhenExpression,
+  clearInput,
+  copyCommandId,
+  copyCommandTitle,
+  focusFirst: focusFirst$4,
+  focusIndex: focusIndex$4,
+  focusLast: focusLast$3,
+  focusNext: focusNext$4,
+  focusPrevious: focusPrevious$4,
+  handleClick,
+  handleContextMenu: handleContextMenu$3,
+  handleDoubleClick,
+  handleInput: handleInput$3,
+  handleWheel: handleWheel$1,
+  open: open$3,
+  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 = {
+  __proto__: null,
+  press
+};
+
+const openUri = async uri => {
+  await invoke('Main.openUri', uri);
+};
+const splitRight = async () => {
+  await invoke('Main.splitRight');
+};
+const openKeyBindings = async () => {
+  await invoke('Main.openKeyBindings');
+};
+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 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 = {
+  __proto__: null,
+  closeActiveEditor,
+  closeAllEditors,
+  closeOthers,
+  closeTabsLeft,
+  closeTabsRight,
+  copyPath: copyPath$1,
+  copyRelativePath,
+  focusFirst: focusFirst$3,
+  focusLast: focusLast$2,
+  focusNext: focusNext$3,
+  focusPrevious: focusPrevious$3,
+  handleModifiedStatusChange,
+  handleTabContextMenu,
+  openKeyBindings,
+  openUri,
+  save,
+  selectTab: selectTab$1,
+  splitRight
+};
+
+const open$2 = async id => {
+  await invoke('Layout.showPanel', id);
+};
+const openProblems = async () => {
+  await open$2('Problems');
+  await invoke('Panel.selectIndex', 0);
+};
+
+const Panel = {
+  __proto__: null,
+  open: open$2,
+  openProblems
+};
+
+const show$4 = async () => {
+  await open$2('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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  getNodePath,
+  isFirefox
+};
+
+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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  clear: clear$1,
+  collapseAll: collapseAll$1,
+  refresh
+};
+
+const show$2 = async () => {
+  await open$5('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 = {
+  __proto__: null,
+  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 Search = {
+  __proto__: null,
+  clearSearchResults,
+  collapseAll,
+  collapseDetails,
+  copy,
+  copyPath,
+  dismissItem,
+  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 = {
+  __proto__: null,
+  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$5('Source Control');
+};
+
+const SourceControl = {
+  __proto__: null,
+  acceptInput,
+  handleClickSourceControlButtons,
+  handleContextMenu: handleContextMenu$1,
+  handleInput,
+  selectIndex,
+  show
+};
+
+const update = async () => {
+  await invoke('StatusBar.updateStatusBarItems');
+};
+
+const StatusBar = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  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 = {
+  __proto__: null,
+  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 MessagePortRpcParent.create({
+    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 = {
+  __proto__: null,
+  fromId
+};
+
+const setPath = async path => {
+  await invoke('Workspace.setPath', path);
+};
+const openTmpDir = async () => {
+  const tmpDir = await getTmpDir();
+  await setPath(tmpDir);
+  return tmpDir;
+};
+
+const Workspace = {
+  __proto__: null,
+  openTmpDir,
+  setPath
+};
+
+const createApi = (platform, assetDir) => {
+  return {
+    About,
+    ActivityBar,
+    BaseUrl: {
+      getBaseUrl() {
+        return assetDir;
+      }
+    },
+    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,
+    Locator: createLocator,
+    Main,
+    Output,
+    Panel,
+    Platform,
+    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);
+  if (module.mockRpc) {
+    setMockRpc(module.mockRpc);
+  }
+  if (module.test) {
+    if (module.skip) {
+      await skipTest(module.name);
+    } else {
+      await executeTest(module.name, module.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 WebWorkerRpcClient.create({
+    commandMap: commandMap
+  });
+  set$1(rpc);
+};
+
+const listen = async () => {
+  await Promise.all([initializeRendererWorker(), initializeEditorWorker()]);
+};
+
+const main = async () => {
+  await listen();
+};
+
+main();