@lvce-editor/extension-host-worker 2.1.0 → 2.2.0

package/dist/extensionHostWorkerMain.js

@@ -303,7 +303,7 @@ const syncIncremental = (textDocumentId, changes) => {
   textDocument.text = before + syntheticChange.inserted + after;
   runListenersSafe(getDidChangeListeners(), textDocument, syntheticChanges);
 };
-const get$6 = textDocumentId => {
+const get$5 = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
 };
@@ -330,62 +330,6 @@ class NoProviderFoundError extends Error {
   }
 }
 
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
-  }
-  return line;
-};
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
-};
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
-};
-class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-}
-
 const getType = value => {
   switch (typeof value) {
     case 'number':
@@ -479,6 +423,62 @@ const validate = (item, schema) => {
   return undefined;
 };
 
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine$2 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+
 const RE_UPPERCASE_LETTER = /[A-Z]/g;
 const RE_PROPERTY = /item\..*must be of type/;
 const spaceOut = camelCaseWord => {
@@ -535,7 +535,7 @@ const registerMethod = ({
 }) => {
   context[`execute${name}Provider`] = async function (textDocumentId, ...params) {
     try {
-      const textDocument = get$6(textDocumentId);
+      const textDocument = get$5(textDocumentId);
       if (!textDocument) {
         throw new Error(`textDocument with id ${textDocumentId} not found`);
       }
@@ -564,14 +564,14 @@ const registerMethod = ({
           // @ts-ignore
           throw new VError(`Failed to execute ${spacedOutName} provider: VError: ${camelCaseName}Provider.${methodName} is not a function`);
         }
-        const message = actualError.name === 'Error' ? `${actualError.message}` : `${actualError.name}: ${actualError.message}`;
+        const message = actualError.name === 'Error' ? actualError.message : `${actualError.name}: ${actualError.message}`;
         actualError.message = `Failed to execute ${spacedOutName} provider: ${message}`;
       }
       throw actualError;
     }
   };
 };
-const create$9 = ({
+const create$a = ({
   name,
   resultShape,
   executeKey = '',
@@ -617,13 +617,13 @@ const Array$1 = 'array';
 const Boolean = 'boolean';
 const Number = 'number';
 const Object$1 = 'object';
-const String = 'string';
+const String$1 = 'string';
 
 const {
   registerBraceCompletionProvider,
   executeBraceCompletionProvider,
   reset: reset$9
-} = create$9({
+} = create$a({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -633,7 +633,7 @@ const {
 const {
   registerClosingTagProvider,
   executeClosingTagProvider
-} = create$9({
+} = create$a({
   name: 'ClosingTag',
   returnUndefinedWhenNoProviderFound: true,
   resultShape: {
@@ -645,7 +645,7 @@ const {
 const {
   registerCodeActionProvider,
   executeCodeActionProvider
-} = create$9({
+} = create$a({
   name: 'CodeAction',
   resultShape: {
     type: Array$1,
@@ -670,7 +670,7 @@ const executeOrganizeImports = async uid => {
   if (!organizeImportsAction) {
     return [];
   }
-  const textDocument = get$6(uid);
+  const textDocument = get$5(uid);
   const edits = await organizeImportsAction.execute(textDocument);
   return edits;
 };
@@ -728,7 +728,7 @@ const {
   registerCompletionProvider,
   executeCompletionProvider,
   executeresolveCompletionItemProvider
-} = create$9({
+} = create$a({
   name: 'Completion',
   resultShape: {
     type: Array$1,
@@ -758,1224 +758,1213 @@ const setConfigurations = preferences => {
   state$8.configuration = preferences;
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
-  callbacks[id] = fn;
+const state$7 = {
+  rpc: undefined
 };
-const get$5 = id => {
-  return callbacks[id];
+const invoke$1 = (method, ...params) => {
+  const rpc = state$7.rpc;
+  return rpc.invoke(method, ...params);
 };
-const remove = id => {
-  delete callbacks[id];
+const send$1 = (method, ...params) => {
+  const rpc = state$7.rpc;
+  return rpc.send(method, ...params);
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
+const invokeAndTransfer$1 = (method, ...params) => {
+  const rpc = state$7.rpc;
+  return rpc.invokeAndTransfer(method, ...params);
 };
-const warn = (...args) => {
-  console.warn(...args);
+const setRpc = rpc => {
+  state$7.rpc = rpc;
 };
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$5(id, resolve);
-  return {
-    id,
-    promise
-  };
+
+const state$6 = {
+  debugProviderMap: Object.create(null)
 };
-const resolve = (id, response) => {
-  const fn = get$5(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
+const getDebugProvider = id => {
+  const provider = state$6.debugProviderMap[id];
+  if (!provider) {
+    // @ts-ignore
+    throw new VError(`no debug provider "${id}" found`);
   }
-  fn(response);
-  remove(id);
+  return provider;
 };
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
+const registerDebugProvider = debugProvider => {
+  if (!debugProvider.id) {
+    throw new Error('Failed to register debug system provider: missing id');
+  }
+  state$6.debugProviderMap[debugProvider.id] = debugProvider;
 };
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
+const start = async (protocol, path) => {
+  try {
+    const handlePaused = params => {
+      console.log('send paused', params);
+      send$1('Debug.paused', params);
+    };
+    const handleResumed = () => {
+      send$1('Debug.resumed');
+    };
+    const handleScriptParsed = parsedScript => {
+      send$1('Debug.scriptParsed', parsedScript);
+    };
+    const provider = getDebugProvider(protocol);
+    await provider.start({
+      handlePaused,
+      handleResumed,
+      handleScriptParsed
+    }, path);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-}
-const NewLine$1 = '\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;
-    }
+};
+const listProcesses = async (protocol, path) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    const processes = await provider.listProcesses(path);
+    array(processes);
+    return processes;
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-  if (message.startsWith('TypeError: ')) {
-    return TypeError;
+};
+const resume = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.resume();
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-  if (message.startsWith('SyntaxError: ')) {
-    return SyntaxError;
+};
+const pause = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.pause();
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-  if (message.startsWith('ReferenceError: ')) {
-    return ReferenceError;
+};
+const stepInto = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepInto();
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-  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;
+const stepOut = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepOut();
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-  return new ErrorConstructor(message);
-};
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
 };
-const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || '';
-  if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$1 + parentStack;
+const stepOver = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepOver();
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-  return parentStack;
 };
-const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
+const setPauseOnException = async (protocol, value) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.setPauseOnExceptions(value);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
+  }
 };
-const MethodNotFound = -32601;
-const Custom = -32001;
-const splitLines$2 = lines => {
-  return lines.split(NewLine$1);
+const getProperties = async (protocol, objectId) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.getProperties(objectId);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
+  }
 };
-const restoreJsonRpcError = error => {
-  if (error && error instanceof Error) {
-    return error;
+const evaluate = async (protocol, expression, callFrameId) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.evaluate(expression, callFrameId);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute debug provider');
   }
-  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$1 + currentStack;
-    return restoredError;
+};
+const setPauseOnExceptions = async (protocol, value) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.setPauseOnExceptions(value);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute setPauseOnExceptions');
   }
-  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$1 + error.data.stack + NewLine$1 + 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;
+};
+
+const {
+  registerDefinitionProvider,
+  executeDefinitionProvider,
+  reset: reset$8
+} = create$a({
+  name: 'Definition',
+  resultShape: {
+    allowUndefined: true,
+    type: Object$1,
+    properties: {
+      uri: {
+        type: String$1
+      },
+      startOffset: {
+        type: Number
+      },
+      endOffset: {
+        type: Number
       }
     }
-    return restoredError;
   }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
+});
+
+const {
+  registerDiagnosticProvider,
+  executeDiagnosticProvider
+} = create$a({
+  name: 'Diagnostic',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
+    }
   }
-  return new Error(`JsonRpc Error: ${error}`);
+});
+
+const showInformationMessage = message => {
+  string(message);
+  const result = invoke$1('ExtensionHostDialog.showInformationMessage', message);
+  return result;
 };
-const unwrapJsonRpcResult = responseMessage => {
-  if ('error' in responseMessage) {
-    const restoredError = restoreJsonRpcError(responseMessage.error);
-    throw restoredError;
-  }
-  if ('result' in responseMessage) {
-    return responseMessage.result;
+
+const env = {};
+
+const exec = async (command, args, options) => {
+  throw new DepecratedError(`vscode.exec is deprecated, use createNodeRpc instead`);
+};
+
+const fileSystemProviderMap = Object.create(null);
+const get$4 = protocol => {
+  const provider = fileSystemProviderMap[protocol];
+  if (!provider) {
+    // @ts-ignore
+    throw new VError(`no file system provider for protocol "${protocol}" found`);
   }
-  throw new JsonRpcError('unexpected response message');
+  return provider;
 };
-const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
-const getErrorType = prettyError => {
-  if (prettyError && prettyError.type) {
-    return prettyError.type;
+const set$4 = (id, provider) => {
+  if (!id) {
+    throw new Error('Failed to register file system provider: missing id');
   }
-  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
-    return prettyError.constructor.name;
+  fileSystemProviderMap[id] = provider;
+};
+
+const registerFileSystemProvider = fileSystemProvider => {
+  if (!fileSystemProvider.id) {
+    throw new Error('Failed to register file system provider: missing id');
   }
-  return undefined;
+  set$4(fileSystemProvider.id, fileSystemProvider);
 };
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound,
-      message: error.message,
-      data: error.stack
-    };
+const readDirWithFileTypes = async (protocol, path) => {
+  try {
+    const provider = get$4(protocol);
+    return await provider.readDirWithFileTypes(path);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute file system provider');
   }
-  return {
-    code: Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
-      code: prettyError.code,
-      name: prettyError.name
-    }
-  };
 };
-const create$1$1 = (message, error) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error
-  };
+const readFile = async (protocol, path) => {
+  try {
+    const provider = get$4(protocol);
+    return await provider.readFile(path);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute file system provider');
+  }
 };
-const getErrorResponse = (message, error, preparePrettyError, logError) => {
-  const prettyError = preparePrettyError(error);
-  logError(error, prettyError);
-  const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(message, errorProperty);
+const readFileExternal = async path => {
+  // TODO when file is local,
+  // don't ask renderer worker
+  // instead read file directly from shared process
+  // this avoid parsing the potentially large message
+  // and improve performance by not blocking the renderer worker
+  // when reading / writing large files
+  const content = await invoke$1('FileSystem.readFile', path);
+  return content;
 };
-const create$8 = (message, result) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    result: result ?? null
-  };
+const readDirWithFileTypesExternal = async path => {
+  // TODO when file is local,
+  // don't ask renderer worker
+  // instead read file directly from shared process
+  // this avoid parsing the potentially large message
+  // and improve performance by not blocking the renderer worker
+  // when reading / writing large files
+  const content = await invoke$1('FileSystem.readDirWithFileTypes', path);
+  return content;
 };
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$8(message, resultProperty);
+const writeFile = async (protocol, uri, content) => {
+  try {
+    const provider = get$4(protocol);
+    return await provider.writeFile(uri, content);
+  } catch (error) {
+    throw new VError(error, 'Failed to execute file system provider');
+  }
 };
-const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+const getPathSeparator = protocol => {
   try {
-    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
+    const provider = get$4(protocol);
+    return provider.pathSeparator;
   } catch (error) {
-    return getErrorResponse(message, error, preparePrettyError, logError);
+    throw new VError(error, 'Failed to execute file system provider');
   }
 };
-const defaultPreparePrettyError = error => {
-  return error;
-};
-const defaultLogError = () => {
-  // ignore
-};
-const defaultRequiresSocket = () => {
-  return false;
+
+const {
+  registerFormattingProvider,
+  executeFormattingProvider,
+  reset: reset$7
+} = create$a({
+  name: 'Formatting',
+  executeKey: 'format',
+  resultShape: {
+    allowUndefined: true,
+    type: Array$1,
+    items: {
+      type: Object$1,
+      properties: {
+        startOffset: {
+          type: Number
+        },
+        endOffset: {
+          type: Number
+        },
+        inserted: {
+          type: String$1
+        }
+      }
+    }
+  }
+});
+
+const getOffset = (textDocument, position) => {
+  let offset = 0;
+  let rowIndex = 0;
+  while (rowIndex++ < position.rowIndex) {
+    const newLineIndex = textDocument.text.indexOf('\n', offset);
+    offset = newLineIndex + 1;
+  }
+  offset += position.columnIndex;
+  return offset;
 };
-const defaultResolve = resolve;
 
-// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
-const normalizeParams = args => {
-  if (args.length === 1) {
-    const options = args[0];
-    return {
-      ipc: options.ipc,
-      message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
-      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
-    };
+const getPosition = (textDocument, offset) => {
+  let index = 0;
+  let rowIndex = 0;
+  let newLineIndex = 0;
+  const text = textDocument.text;
+  while (index < offset) {
+    newLineIndex = text.indexOf('\n', index);
+    if (newLineIndex === -1) {
+      break;
+    }
+    const newIndex = newLineIndex + 1;
+    if (newIndex > offset) {
+      break;
+    }
+    index = newIndex;
+    rowIndex++;
   }
+  const columnIndex = offset - index;
   return {
-    ipc: args[0],
-    message: args[1],
-    execute: args[2],
-    resolve: args[3],
-    preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    rowIndex,
+    columnIndex
   };
 };
-const handleJsonRpcMessage = async (...args) => {
-  const options = normalizeParams(args);
-  const {
-    message,
-    ipc,
-    execute,
-    resolve,
-    preparePrettyError,
-    logError,
-    requiresSocket
-  } = options;
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
+
+const {
+  registerHoverProvider,
+  executeHoverProvider,
+  reset: reset$6
+} = create$a({
+  name: 'Hover',
+  resultShape: {
+    allowUndefined: true,
+    type: Object$1,
+    properties: {}
+  }
+});
+
+const {
+  registerImplementationProvider,
+  executeImplementationProvider,
+  reset: reset$5
+} = create$a({
+  name: 'Implementation',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
     }
-    resolve(message.id, message);
-    return;
   }
-  if ('method' in message) {
-    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
-    return;
+});
+
+const WebSocket$1 = 5;
+const ElectronMessagePort = 6;
+const ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1 = 7;
+
+const getModule$3 = method => {
+  switch (method) {
+    case WebSocket$1:
+      return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
+    case ElectronMessagePort:
+      return Promise.resolve().then(function () { return IpcParentWithNode; });
+    case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
+      return Promise.resolve().then(function () { return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug; });
+    default:
+      throw new Error('unexpected ipc type');
   }
-  throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
+
+const create$9 = async ({
+  method,
+  ...options
+}) => {
+  try {
+    const module = await getModule$3(method);
+    // @ts-ignore
+    const rawIpc = await module.create(options);
+    // @ts-ignore
+    const ipc = module.wrap(rawIpc);
+    return ipc;
+  } catch (error) {
+    throw new VError(error, `Failed to create ipc`);
   }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send$1 = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$1 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
 };
 
-const commands = Object.create(null);
-const register$1 = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new Error(`command not found ${command}`);
+const JsonRpc = 1;
+
+const getModule$2 = method => {
+  switch (method) {
+    case JsonRpc:
+      return Promise.resolve().then(function () { return RpcParentWithJsonRpc; });
+    default:
+      throw new Error('unexpected rpc type');
   }
-  return fn(...args);
 };
 
-const requiresSocket$1 = () => {
-  return false;
-};
-const preparePrettyError$1 = error => {
-  return error;
+const create$8 = async ({
+  method,
+  ...options
+}) => {
+  const module = await getModule$2(method);
+  // @ts-ignore
+  const rpc = module.create(options);
+  return rpc;
 };
-const logError$1 = error => {
-  // handled by renderer worker
+
+const defaultExecute$1 = () => {
+  throw new Error('not implemented');
 };
-const handleMessage = event => {
-  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$1, logError$1, requiresSocket$1);
+const createNodeRpc = async ({
+  path,
+  execute = defaultExecute$1,
+  name = ''
+}) => {
+  try {
+    string(path);
+    fn(execute);
+    const ipc = await create$9({
+      method: ElectronMessagePort,
+      type: 'extension-host-helper-process',
+      name
+    });
+    const rpc = await create$8({
+      ipc,
+      method: JsonRpc,
+      execute
+    });
+    await rpc.invoke('LoadFile.loadFile', path);
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create node rpc`);
+  }
 };
 
-const handleIpc = ipc => {
-  ipc.addEventListener('message', handleMessage);
+const confirm = message => {
+  string(message);
+  const result = invoke$1('ConfirmPrompt.prompt', message);
+  return result;
 };
 
-const state$7 = {
-  /**
-   * @type {any}
-   */
-  ipc: undefined
-};
-const get$4 = () => {
-  return state$7.ipc;
-};
-const set$4 = ipc => {
-  state$7.ipc = ipc;
-};
+const ExtensionHostQuickPickShow = 'ExtensionHostQuickPick.show';
 
-const send = (method, ...params) => {
-  const ipc = get$4();
-  send$1(ipc, method, ...params);
-};
-const invoke = (method, ...params) => {
-  const ipc = get$4();
-  return invoke$1(ipc, method, ...params);
-};
-const invokeAndTransfer = (method, ...params) => {
-  const ipc = get$4();
-  return invokeAndTransfer$1(ipc, method, ...params);
-};
-const listen$1 = ipc => {
-  handleIpc(ipc);
-  set$4(ipc);
+const showQuickPick = async ({
+  getPicks,
+  toPick
+}) => {
+  const rawPicks = await getPicks();
+  const picks = rawPicks.map(toPick);
+  return invoke$1(ExtensionHostQuickPickShow, picks);
 };
 
-const state$6 = {
-  debugProviderMap: Object.create(null)
+const {
+  registerReferenceProvider,
+  executeReferenceProvider,
+  executefileReferenceProvider,
+  reset: reset$4
+} = create$a({
+  name: 'Reference',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
+    }
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'fileReference',
+    methodName: 'provideFileReferences',
+    resultShape: {
+      type: Array$1,
+      items: {
+        type: Object$1
+      }
+    }
+  }]
+});
+
+const {
+  registerRenameProvider,
+  executeRenameProvider,
+  executeprepareRenameProvider,
+  reset: reset$3
+} = create$a({
+  name: 'Rename',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'prepareRename',
+    methodName: 'prepareRename',
+    resultShape: {
+      type: Object$1,
+      allowUndefined: true
+    }
+  }]
+});
+
+const getExtensionHostSubWorkerUrl = () => {
+  return new URL('../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js', import.meta.url).toString();
 };
-const getDebugProvider = id => {
-  const provider = state$6.debugProviderMap[id];
-  if (!provider) {
-    // @ts-ignore
-    throw new VError(`no debug provider "${id}" found`);
-  }
-  return provider;
+const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
+
+const set$3 = async (url, contentSecurityPolicy) => {
+  const pathName = new URL(url).pathname;
+  await invoke$1('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
 };
-const registerDebugProvider = debugProvider => {
-  if (!debugProvider.id) {
-    throw new Error('Failed to register debug system provider: missing id');
-  }
-  state$6.debugProviderMap[debugProvider.id] = debugProvider;
+
+const rpcs$1 = Object.create(null);
+const add$1 = (id, rpc) => {
+  rpcs$1[id] = rpc;
 };
-const start = async (protocol, path) => {
-  try {
-    const handlePaused = params => {
-      console.log('send paused', params);
-      send('Debug.paused', params);
-    };
-    const handleResumed = () => {
-      send('Debug.resumed');
-    };
-    const handleScriptParsed = parsedScript => {
-      send('Debug.scriptParsed', parsedScript);
-    };
-    const provider = getDebugProvider(protocol);
-    await provider.start({
-      handlePaused,
-      handleResumed,
-      handleScriptParsed
-    }, path);
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
-  }
+const get$3 = id => {
+  return rpcs$1[id];
 };
-const listProcesses = async (protocol, path) => {
-  try {
-    const provider = getDebugProvider(protocol);
-    const processes = await provider.listProcesses(path);
-    array(processes);
-    return processes;
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
-  }
+
+const registry = Object.create(null);
+const rpcs = Object.create(null);
+const register$1 = (id, execute) => {
+  registry[id] = execute;
 };
-const resume = async protocol => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.resume();
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
-  }
+const acquire = id => {
+  const fn = registry[id];
+  delete registry[id];
+  return fn;
 };
-const pause = async protocol => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.pause();
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
-  }
+const get$2 = id => {
+  return rpcs[id];
 };
-const stepInto = async protocol => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.stepInto();
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
-  }
+const set$2 = (id, rpc) => {
+  rpcs[id] = rpc;
 };
-const stepOut = async protocol => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.stepOut();
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
+
+const createRpcWithId$1 = async id => {
+  const fn = acquire(id);
+  const info = get$3(id);
+  if (!info) {
+    throw new Error(`rpc with id ${id} not found`);
   }
+  const ipc = await create$9({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url: extensionHostSubWorkerUrl,
+    name: info.name
+  });
+  const newRpc = await create$8({
+    ipc,
+    method: JsonRpc,
+    execute: fn
+  });
+  await newRpc.invoke('LoadFile.loadFile', info.url);
+  set$2(id, newRpc);
+  return newRpc;
 };
-const stepOver = async protocol => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.stepOver();
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
+
+const getOrCreateRpc = async id => {
+  const rpc = get$2(id);
+  if (!rpc) {
+    set$2(id, createRpcWithId$1(id));
   }
+  return get$2(id);
 };
-const setPauseOnException = async (protocol, value) => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.setPauseOnExceptions(value);
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
-  }
+const createRpcWithId = ({
+  id,
+  execute
+}) => {
+  string(id);
+  register$1(id, execute);
+  const lazyRpc = {
+    async invoke(method, ...params) {
+      const rpc = await getOrCreateRpc(id);
+      return rpc.invoke(method, ...params);
+    }
+  };
+  return lazyRpc;
 };
-const getProperties = async (protocol, objectId) => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.getProperties(objectId);
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
-  }
+
+const defaultExecute = () => {
+  throw new Error('not implemented');
 };
-const evaluate = async (protocol, expression, callFrameId) => {
-  try {
-    const provider = getDebugProvider(protocol);
-    return await provider.evaluate(expression, callFrameId);
-  } catch (error) {
-    throw new VError(error, 'Failed to execute debug provider');
+
+/**
+ *
+ * @deprecated
+ */
+const createLegacyRpc = async ({
+  url,
+  name,
+  execute = defaultExecute,
+  contentSecurityPolicy
+}) => {
+  string(url);
+  string(name);
+  fn(execute);
+  if (contentSecurityPolicy) {
+    await set$3(url, contentSecurityPolicy);
   }
+  const ipc = await create$9({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url: extensionHostSubWorkerUrl,
+    name
+  });
+  const rpc = await create$8({
+    ipc,
+    method: JsonRpc,
+    execute
+  });
+  await rpc.invoke('LoadFile.loadFile', url);
+  return rpc;
 };
-const setPauseOnExceptions = async (protocol, value) => {
+const createRpc$1 = ({
+  id,
+  url,
+  name,
+  execute = defaultExecute,
+  contentSecurityPolicy
+}) => {
   try {
-    const provider = getDebugProvider(protocol);
-    return await provider.setPauseOnExceptions(value);
+    if (id) {
+      string(id);
+      return createRpcWithId({
+        id,
+        execute
+      });
+    }
+    return createLegacyRpc({
+      url,
+      name,
+      execute,
+      contentSecurityPolicy
+    });
   } catch (error) {
-    throw new VError(error, 'Failed to execute setPauseOnExceptions');
+    throw new VError(error, `Failed to create webworker rpc`);
   }
 };
 
 const {
-  registerDefinitionProvider,
-  executeDefinitionProvider,
-  reset: reset$8
-} = create$9({
-  name: 'Definition',
+  registerSelectionProvider,
+  executeSelectionProvider,
+  reset: reset$2
+} = create$a({
+  name: 'Selection',
   resultShape: {
     allowUndefined: true,
-    type: Object$1,
-    properties: {
-      uri: {
-        type: String
-      },
-      startOffset: {
-        type: Number
-      },
-      endOffset: {
-        type: Number
-      }
-    }
-  }
-});
-
-const {
-  registerDiagnosticProvider,
-  executeDiagnosticProvider
-} = create$9({
-  name: 'Diagnostic',
-  resultShape: {
     type: Array$1,
     items: {
-      type: Object$1
+      type: 'number'
     }
   }
 });
 
-const showInformationMessage = message => {
-  string(message);
-  const result = invoke('ExtensionHostDialog.showInformationMessage', message);
-  return result;
+const state$5 = {
+  providers: Object.create(null)
 };
-
-const env = {};
-
-const exec = async (command, args, options) => {
-  throw new DepecratedError(`vscode.exec is deprecated, use createNodeRpc instead`);
+const registerSourceControlProvider = provider => {
+  state$5.providers[provider.id] = provider;
 };
-
-const fileSystemProviderMap = Object.create(null);
-const get$3 = protocol => {
-  const provider = fileSystemProviderMap[protocol];
+const getFilesFromProvider = provider => {
+  return provider.getChangedFiles();
+};
+const getChangedFiles = async providerId => {
+  const provider = state$5.providers[providerId];
   if (!provider) {
-    // @ts-ignore
-    throw new VError(`no file system provider for protocol "${protocol}" found`);
+    throw new Error('no source control provider found');
   }
-  return provider;
+  const changedFiles = await getFilesFromProvider(provider);
+  const flattenedChangedFiles = changedFiles;
+  return flattenedChangedFiles;
 };
-const set$3 = (id, provider) => {
-  if (!id) {
-    throw new Error('Failed to register file system provider: missing id');
+const getFileBefore = async (providerId, uri) => {
+  string(providerId);
+  string(uri);
+  const provider = state$5.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
   }
-  fileSystemProviderMap[id] = provider;
+  return provider.getFileBefore(uri);
 };
-
-const registerFileSystemProvider = fileSystemProvider => {
-  if (!fileSystemProvider.id) {
-    throw new Error('Failed to register file system provider: missing id');
+const getGroupsFromProvider = async (provider, cwd) => {
+  if (provider.getGroups) {
+    return provider.getGroups(cwd);
+  }
+  if (provider.getChangedFiles) {
+    const files = await provider.getChangedFiles();
+    const groups = [{
+      id: 'changes',
+      label: 'Changes',
+      items: files
+    }];
+    return groups;
   }
-  set$3(fileSystemProvider.id, fileSystemProvider);
+  throw new Error('source control provider is missing required function getGroups');
 };
-const readDirWithFileTypes = async (protocol, path) => {
-  try {
-    const provider = get$3(protocol);
-    return await provider.readDirWithFileTypes(path);
-  } catch (error) {
-    throw new VError(error, 'Failed to execute file system provider');
+const getGroups = async (providerId, cwd) => {
+  const provider = state$5.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
   }
+  const groups = await getGroupsFromProvider(provider, cwd);
+  return groups;
 };
-const readFile = async (protocol, path) => {
-  try {
-    const provider = get$3(protocol);
-    return await provider.readFile(path);
-  } catch (error) {
-    throw new VError(error, 'Failed to execute file system provider');
+const acceptInput = async (providerId, value) => {
+  const provider = state$5.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
   }
+  await provider.acceptInput(value);
 };
-const readFileExternal = async path => {
-  // TODO when file is local,
-  // don't ask renderer worker
-  // instead read file directly from shared process
-  // this avoid parsing the potentially large message
-  // and improve performance by not blocking the renderer worker
-  // when reading / writing large files
-  const content = await invoke('FileSystem.readFile', path);
-  return content;
+const add = async path => {
+  const provider = Object.values(state$5.providers)[0];
+  if (!provider) {
+    return;
+  }
+  // @ts-ignore
+  await provider.add(path);
 };
-const readDirWithFileTypesExternal = async path => {
-  // TODO when file is local,
-  // don't ask renderer worker
-  // instead read file directly from shared process
-  // this avoid parsing the potentially large message
-  // and improve performance by not blocking the renderer worker
-  // when reading / writing large files
-  const content = await invoke('FileSystem.readDirWithFileTypes', path);
-  return content;
+const discard = async path => {
+  const provider = Object.values(state$5.providers)[0];
+  if (!provider) {
+    return;
+  }
+  // @ts-ignore
+  await provider.discard(path);
 };
-const writeFile = async (protocol, uri, content) => {
+const getEnabledProviderIds = async (scheme, root) => {
+  string(scheme);
+  string(root);
+  const providers = Object.values(state$5.providers);
+  const enabledIds = [];
+  for (const provider of providers) {
+    // @ts-ignore
+    if (typeof provider.isActive !== 'function') {
+      continue;
+    }
+    // @ts-ignore
+    const isActive = await provider.isActive(scheme, root);
+    if (isActive) {
+      // @ts-ignore
+      enabledIds.push(provider.id);
+    }
+  }
+  return enabledIds;
+};
+
+const {
+  registerTabCompletionProvider,
+  executeTabCompletionProvider,
+  reset: reset$1
+} = create$a({
+  name: 'TabCompletion',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  }
+});
+
+const state$4 = {
+  textSearchProviders: Object.create(null)
+};
+const registerTextSearchProvider = textSearchProvider => {
   try {
-    const provider = get$3(protocol);
-    return await provider.writeFile(uri, content);
+    if (!textSearchProvider) {
+      throw new Error('textSearchProvider is not defined');
+    }
+    if (!textSearchProvider.scheme) {
+      throw new Error('textSearchProvider is missing scheme');
+    }
+    state$4.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
   } catch (error) {
-    throw new VError(error, 'Failed to execute file system provider');
+    throw new VError(error, 'Failed to register text search provider');
   }
 };
-const getPathSeparator = protocol => {
+const executeTextSearchProvider = async (scheme, query) => {
   try {
-    const provider = get$3(protocol);
-    return provider.pathSeparator;
+    const textSearchProvider = state$4.textSearchProviders[scheme];
+    if (!textSearchProvider) {
+      throw new Error(`No text search provider for ${scheme} found`);
+    }
+    const results = await textSearchProvider.provideTextSearchResults(query);
+    return results;
   } catch (error) {
-    throw new VError(error, 'Failed to execute file system provider');
+    throw new VError(error, 'Failed to execute text search provider');
   }
 };
 
 const {
-  registerFormattingProvider,
-  executeFormattingProvider,
-  reset: reset$7
-} = create$9({
-  name: 'Formatting',
-  executeKey: 'format',
+  registerTypeDefinitionProvider,
+  executeTypeDefinitionProvider,
+  reset
+} = create$a({
+  name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
-    type: Array$1,
-    items: {
-      type: Object$1,
-      properties: {
-        startOffset: {
-          type: Number
-        },
-        endOffset: {
-          type: Number
-        },
-        inserted: {
-          type: String
-        }
+    type: Object$1,
+    properties: {
+      uri: {
+        type: String$1
+      },
+      startOffset: {
+        type: Number
+      },
+      endOffset: {
+        type: Number
       }
     }
   }
 });
 
-const getOffset = (textDocument, position) => {
-  let offset = 0;
-  let rowIndex = 0;
-  while (rowIndex++ < position.rowIndex) {
-    const newLineIndex = textDocument.text.indexOf('\n', offset);
-    offset = newLineIndex + 1;
+const RE_PROTOCOL = /^([a-z\-]+):\/\//;
+const getProtocol = uri => {
+  const protocolMatch = uri.match(RE_PROTOCOL);
+  if (protocolMatch) {
+    return protocolMatch[1];
   }
-  offset += position.columnIndex;
-  return offset;
+  return '';
 };
 
-const getPosition = (textDocument, offset) => {
-  let index = 0;
-  let rowIndex = 0;
-  let newLineIndex = 0;
-  const text = textDocument.text;
-  while (index < offset) {
-    newLineIndex = text.indexOf('\n', index);
-    if (newLineIndex === -1) {
-      break;
-    }
-    const newIndex = newLineIndex + 1;
-    if (newIndex > offset) {
-      break;
-    }
-    index = newIndex;
-    rowIndex++;
-  }
-  const columnIndex = offset - index;
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
   return {
-    rowIndex,
-    columnIndex
+    port1,
+    port2
   };
 };
 
-const {
-  registerHoverProvider,
-  executeHoverProvider,
-  reset: reset$6
-} = create$9({
-  name: 'Hover',
-  resultShape: {
-    allowUndefined: true,
-    type: Object$1,
-    properties: {}
+const Two = '2.0';
+const create$4$1 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const callbacks = Object.create(null);
+const set$1 = (id, fn) => {
+  callbacks[id] = fn;
+};
+const get$1 = id => {
+  return callbacks[id];
+};
+const remove = id => {
+  delete callbacks[id];
+};
+let id = 0;
+const create$3$1 = () => {
+  return ++id;
+};
+const registerPromise = () => {
+  const id = create$3$1();
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  set$1(id, resolve);
+  return {
+    id,
+    promise
+  };
+};
+const create$2$1 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
   }
-});
-
-const {
-  registerImplementationProvider,
-  executeImplementationProvider,
-  reset: reset$5
-} = create$9({
-  name: 'Implementation',
-  resultShape: {
-    type: Array$1,
-    items: {
-      type: Object$1
+}
+const NewLine$1 = '\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;
     }
   }
-});
-
-const WebSocket$1 = 5;
-const ElectronMessagePort = 6;
-const ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1 = 7;
-
-const getModule$3 = method => {
-  switch (method) {
-    case WebSocket$1:
-      return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
-    case ElectronMessagePort:
-      return Promise.resolve().then(function () { return IpcParentWithNode; });
-    case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
-      return Promise.resolve().then(function () { return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug; });
-    default:
-      throw new Error('unexpected ipc type');
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
   }
-};
-
-const create$7 = async ({
-  method,
-  ...options
-}) => {
-  try {
-    const module = await getModule$3(method);
-    // @ts-ignore
-    const rawIpc = await module.create(options);
-    // @ts-ignore
-    const ipc = module.wrap(rawIpc);
-    return ipc;
-  } catch (error) {
-    throw new VError(error, `Failed to create ipc`);
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
   }
-};
-
-const JsonRpc = 1;
-
-const getModule$2 = method => {
-  switch (method) {
-    case JsonRpc:
-      return Promise.resolve().then(function () { return RpcParentWithJsonRpc; });
-    default:
-      throw new Error('unexpected rpc type');
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
   }
+  return Error;
 };
-
-const create$6 = async ({
-  method,
-  ...options
-}) => {
-  const module = await getModule$2(method);
-  // @ts-ignore
-  const rpc = module.create(options);
-  return rpc;
+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 defaultExecute$1 = () => {
-  throw new Error('not implemented');
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$1, startIndex);
 };
-const createNodeRpc = async ({
-  path,
-  execute = defaultExecute$1,
-  name = ''
-}) => {
-  try {
-    string(path);
-    fn(execute);
-    const ipc = await create$7({
-      method: ElectronMessagePort,
-      type: 'extension-host-helper-process',
-      name
-    });
-    const rpc = await create$6({
-      ipc,
-      method: JsonRpc,
-      execute
-    });
-    await rpc.invoke('LoadFile.loadFile', path);
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create node rpc`);
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine$1 + parentStack;
   }
+  return parentStack;
 };
-
-const confirm = message => {
-  string(message);
-  const result = invoke('ConfirmPrompt.prompt', message);
-  return result;
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
 };
-
-const ExtensionHostQuickPickShow = 'ExtensionHostQuickPick.show';
-
-const showQuickPick = async ({
-  getPicks,
-  toPick
-}) => {
-  const rawPicks = await getPicks();
-  const picks = rawPicks.map(toPick);
-  return invoke(ExtensionHostQuickPickShow, picks);
+const MethodNotFound = -32601;
+const Custom = -32001;
+const splitLines$2 = lines => {
+  return lines.split(NewLine$1);
 };
-
-const {
-  registerReferenceProvider,
-  executeReferenceProvider,
-  executefileReferenceProvider,
-  reset: reset$4
-} = create$9({
-  name: 'Reference',
-  resultShape: {
-    type: Array$1,
-    items: {
-      type: Object$1
-    }
-  },
-  additionalMethodNames: [
-  // @ts-ignore
-  {
-    name: 'fileReference',
-    methodName: 'provideFileReferences',
-    resultShape: {
-      type: Array$1,
-      items: {
-        type: Object$1
+const restoreJsonRpcError = error => {
+  if (error && error instanceof Error) {
+    return error;
+  }
+  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine$1 + 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$1 + error.data.stack + NewLine$1 + 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;
       }
     }
-  }]
-});
-
-const {
-  registerRenameProvider,
-  executeRenameProvider,
-  executeprepareRenameProvider,
-  reset: reset$3
-} = create$9({
-  name: 'Rename',
-  resultShape: {
-    type: Object$1,
-    allowUndefined: true
-  },
-  additionalMethodNames: [
-  // @ts-ignore
-  {
-    name: 'prepareRename',
-    methodName: 'prepareRename',
-    resultShape: {
-      type: Object$1,
-      allowUndefined: true
-    }
-  }]
-});
-
-const getExtensionHostSubWorkerUrl = () => {
-  return new URL('../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js', import.meta.url).toString();
-};
-const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
-
-const set$2 = async (url, contentSecurityPolicy) => {
-  const pathName = new URL(url).pathname;
-  await invoke('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
-};
-
-const rpcs$1 = Object.create(null);
-const add$1 = (id, rpc) => {
-  rpcs$1[id] = rpc;
-};
-const get$2 = id => {
-  return rpcs$1[id];
-};
-
-const registry = Object.create(null);
-const rpcs = Object.create(null);
-const register = (id, execute) => {
-  registry[id] = execute;
-};
-const acquire = id => {
-  const fn = registry[id];
-  delete registry[id];
-  return fn;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-const set$1 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-
-const createRpcWithId$1 = async id => {
-  const fn = acquire(id);
-  const info = get$2(id);
-  if (!info) {
-    throw new Error(`rpc with id ${id} not found`);
+    return restoredError;
   }
-  const ipc = await create$7({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url: extensionHostSubWorkerUrl,
-    name: info.name
-  });
-  const newRpc = await create$6({
-    ipc,
-    method: JsonRpc,
-    execute: fn
-  });
-  await newRpc.invoke('LoadFile.loadFile', info.url);
-  set$1(id, newRpc);
-  return newRpc;
-};
-
-const getOrCreateRpc = async id => {
-  const rpc = get$1(id);
-  if (!rpc) {
-    set$1(id, createRpcWithId$1(id));
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`);
   }
-  return get$1(id);
+  return new Error(`JsonRpc Error: ${error}`);
 };
-const createRpcWithId = ({
-  id,
-  execute
-}) => {
-  string(id);
-  register(id, execute);
-  const lazyRpc = {
-    async invoke(method, ...params) {
-      const rpc = await getOrCreateRpc(id);
-      return rpc.invoke(method, ...params);
-    }
-  };
-  return lazyRpc;
+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 defaultExecute = () => {
-  throw new Error('not implemented');
+const warn = (...args) => {
+  console.warn(...args);
 };
-
-/**
- *
- * @deprecated
- */
-const createLegacyRpc = async ({
-  url,
-  name,
-  execute = defaultExecute,
-  contentSecurityPolicy
-}) => {
-  string(url);
-  string(name);
-  fn(execute);
-  if (contentSecurityPolicy) {
-    await set$2(url, contentSecurityPolicy);
+const resolve = (id, response) => {
+  const fn = get$1(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
   }
-  const ipc = await create$7({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    url: extensionHostSubWorkerUrl,
-    name
-  });
-  const rpc = await create$6({
-    ipc,
-    method: JsonRpc,
-    execute
-  });
-  await rpc.invoke('LoadFile.loadFile', url);
-  return rpc;
+  fn(response);
+  remove(id);
 };
-const createRpc = ({
-  id,
-  url,
-  name,
-  execute = defaultExecute,
-  contentSecurityPolicy
-}) => {
-  try {
-    if (id) {
-      string(id);
-      return createRpcWithId({
-        id,
-        execute
-      });
-    }
-    return createLegacyRpc({
-      url,
-      name,
-      execute,
-      contentSecurityPolicy
-    });
-  } catch (error) {
-    throw new VError(error, `Failed to create webworker rpc`);
+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 {
-  registerSelectionProvider,
-  executeSelectionProvider,
-  reset: reset$2
-} = create$9({
-  name: 'Selection',
-  resultShape: {
-    allowUndefined: true,
-    type: Array$1,
-    items: {
-      type: 'number'
-    }
+const getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      message: error.message,
+      data: error.stack
+    };
   }
-});
-
-const state$5 = {
-  providers: Object.create(null)
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: prettyError.stack,
+      codeFrame: prettyError.codeFrame,
+      type: getErrorType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1$1 = (message, error) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error
+  };
 };
-const registerSourceControlProvider = provider => {
-  state$5.providers[provider.id] = provider;
+const getErrorResponse = (message, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(message, errorProperty);
 };
-const getFilesFromProvider = provider => {
-  return provider.getChangedFiles();
+const create$7 = (message, result) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    result: result ?? null
+  };
 };
-const getChangedFiles = async providerId => {
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
-  }
-  const changedFiles = await getFilesFromProvider(provider);
-  const flattenedChangedFiles = changedFiles;
-  return flattenedChangedFiles;
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$7(message, resultProperty);
 };
-const getFileBefore = async (providerId, uri) => {
-  string(providerId);
-  string(uri);
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    return getErrorResponse(message, error, preparePrettyError, logError);
   }
-  return provider.getFileBefore(uri);
 };
-const getGroupsFromProvider = async (provider, cwd) => {
-  if (provider.getGroups) {
-    return provider.getGroups(cwd);
-  }
-  if (provider.getChangedFiles) {
-    const files = await provider.getChangedFiles();
-    const groups = [{
-      id: 'changes',
-      label: 'Changes',
-      items: files
-    }];
-    return groups;
-  }
-  throw new Error('source control provider is missing required function getGroups');
+const defaultPreparePrettyError = error => {
+  return error;
 };
-const getGroups = async (providerId, cwd) => {
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
-  }
-  const groups = await getGroupsFromProvider(provider, cwd);
-  return groups;
+const defaultLogError = () => {
+  // ignore
 };
-const acceptInput = async (providerId, value) => {
-  const provider = state$5.providers[providerId];
-  if (!provider) {
-    throw new Error('no source control provider found');
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
   }
-  await provider.acceptInput(value);
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
 };
-const add = async path => {
-  const provider = Object.values(state$5.providers)[0];
-  if (!provider) {
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
     return;
   }
-  // @ts-ignore
-  await provider.add(path);
-};
-const discard = async path => {
-  const provider = Object.values(state$5.providers)[0];
-  if (!provider) {
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
     return;
   }
-  // @ts-ignore
-  await provider.discard(path);
+  throw new JsonRpcError('unexpected message');
 };
-const getEnabledProviderIds = async (scheme, root) => {
-  string(scheme);
-  string(root);
-  const providers = Object.values(state$5.providers);
-  const enabledIds = [];
-  for (const provider of providers) {
-    // @ts-ignore
-    if (typeof provider.isActive !== 'function') {
-      continue;
-    }
-    // @ts-ignore
-    const isActive = await provider.isActive(scheme, root);
-    if (isActive) {
-      // @ts-ignore
-      enabledIds.push(provider.id);
-    }
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
   }
-  return enabledIds;
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
 };
-
-const {
-  registerTabCompletionProvider,
-  executeTabCompletionProvider,
-  reset: reset$1
-} = create$9({
-  name: 'TabCompletion',
-  resultShape: {
-    type: Object$1,
-    allowUndefined: true
-  }
-});
-
-const state$4 = {
-  textSearchProviders: Object.create(null)
+const send = (transport, method, ...params) => {
+  const message = create$4$1(method, params);
+  transport.send(message);
 };
-const registerTextSearchProvider = textSearchProvider => {
-  try {
-    if (!textSearchProvider) {
-      throw new Error('textSearchProvider is not defined');
-    }
-    if (!textSearchProvider.scheme) {
-      throw new Error('textSearchProvider is missing scheme');
-    }
-    state$4.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
-  } catch (error) {
-    throw new VError(error, 'Failed to register text search provider');
-  }
+const invoke = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
 };
-const executeTextSearchProvider = async (scheme, query) => {
-  try {
-    const textSearchProvider = state$4.textSearchProviders[scheme];
-    if (!textSearchProvider) {
-      throw new Error(`No text search provider for ${scheme} found`);
-    }
-    const results = await textSearchProvider.provideTextSearchResults(query);
-    return results;
-  } catch (error) {
-    throw new VError(error, 'Failed to execute text search provider');
-  }
+const invokeAndTransfer = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
 };
 
-const {
-  registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider,
-  reset
-} = create$9({
-  name: 'TypeDefinition',
-  resultShape: {
-    allowUndefined: true,
-    type: Object$1,
-    properties: {
-      uri: {
-        type: String
-      },
-      startOffset: {
-        type: Number
-      },
-      endOffset: {
-        type: Number
-      }
-    }
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new Error(`command not found ${command}`);
   }
-});
+  return fn(...args);
+};
 
-const RE_PROTOCOL = /^([a-z\-]+):\/\//;
-const getProtocol = uri => {
-  const protocolMatch = uri.match(RE_PROTOCOL);
-  if (protocolMatch) {
-    return protocolMatch[1];
-  }
-  return '';
+const requiresSocket$2 = () => {
+  return false;
+};
+const preparePrettyError$2 = error => {
+  return error;
+};
+const logError$2 = error => {
+  // handled by renderer worker
+};
+const handleMessage$1 = event => {
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$2, logError$2, requiresSocket$2);
 };
 
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
+const handleIpc$1 = ipc => {
+  ipc.addEventListener('message', handleMessage$1);
 };
 
 const createWebViewIpc = async webView => {
@@ -1991,7 +1980,7 @@ const createWebViewIpc = async webView => {
     port2.onmessage = resolve;
   });
   const portType = 'test';
-  await invokeAndTransfer('WebView.setPort', uid, port1, origin, portType);
+  await invokeAndTransfer$1('WebView.setPort', uid, port1, origin, portType);
   const event = await promise;
   // @ts-ignore
   if (event.data !== 'ready') {
@@ -2016,7 +2005,7 @@ const createWebViewIpc = async webView => {
   };
   // TODO maybe don't send a message port only to get object url?
   // TODO dispose ipc to avoid memory leak
-  handleIpc(ipc);
+  handleIpc$1(ipc);
   return ipc;
 };
 
@@ -2050,8 +2039,8 @@ const getRemoteUrlForWebView = async (uri, options = {}) => {
   if (!webView) {
     throw new Error(`webview ${options.webViewId} not found`);
   }
-  const [ipc, blob] = await Promise.all([createWebViewIpc(webView), invoke('FileSystem.getBlob', uri)]);
-  const objectUrl = await invoke$1(ipc, 'createObjectUrl', blob);
+  const [ipc, blob] = await Promise.all([createWebViewIpc(webView), invoke$1('FileSystem.getBlob', uri)]);
+  const objectUrl = await invoke(ipc, 'createObjectUrl', blob);
   return objectUrl;
 };
 
@@ -2081,18 +2070,26 @@ const getPlatform = () => {
 const platform = getPlatform(); // TODO tree-shake this out in production
 
 const getRemoteUrl = async (uri, options = {}) => {
+  // TODO uri should always have protocol
+  // then ask file system provider for remote url, for example disk file system provider or html file system provider
   const protocol = getProtocol(uri);
   if (platform === Remote && !protocol) {
+    if (uri.startsWith('/')) {
+      return `/remote${uri}`;
+    }
     return `/remote/${uri}`;
   }
   if (platform === Electron && !protocol) {
+    if (uri.startsWith('/')) {
+      return `/remote${uri}`;
+    }
     return `/remote/${uri}`;
   }
   if (options.webViewId) {
     return getRemoteUrlForWebView(uri, options);
   }
   if (uri.startsWith('html://')) {
-    const url = await invoke('Blob.getSrc', uri);
+    const url = await invoke$1('Blob.getSrc', uri);
     return url;
   }
   throw new Error(`unsupported platform for remote url`);
@@ -2202,7 +2199,7 @@ const createWorker = async ({
   string(method);
   string(url);
   string(name);
-  const ipc = create$7({
+  const ipc = create$9({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url,
     name
@@ -2290,7 +2287,7 @@ const api = {
   registerHoverProvider: registerHoverProvider,
   executeHoverProvider: executeHoverProvider,
   // Rpc
-  createRpc: createRpc,
+  createRpc: createRpc$1,
   createNodeRpc: createNodeRpc,
   // Implementation
   registerImplementationProvider: registerImplementationProvider,
@@ -2333,967 +2330,1094 @@ const api = {
   getWorkspaceFolder: getWorkspaceFolder
 };
 
-const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
-const ClosingTagExecuteClosingTagProvider = 'ExtensionHostClosingTag.executeClosingTagProvider';
-const CommandExecute = 'ExtensionHostCommand.executeCommand';
-const CompletionExecute = 'ExtensionHostCompletion.execute';
-const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
-const DefinitionExecuteDefinitionProvider = 'ExtensionHostDefinition.executeDefinitionProvider';
-const DiagnosticExecuteDiagnosticProvider = 'ExtensionHost.executeDiagnosticProvider';
-const ExtensionActivate = 'ExtensionHostExtension.activate';
-const FileSystemGetPathSeparator = 'ExtensionHostFileSystem.getPathSeparator';
-const FileSystemReadDirWithFileTypes = 'ExtensionHostFileSystem.readDirWithFileTypes';
-const FileSystemReadFile = 'ExtensionHostFileSystem.readFile';
-const FileSystemWriteFile = 'ExtensionHostFileSystem.writeFile';
-const FormattingExecuteFormmattingProvider = 'ExtensionHostFormatting.executeFormattingProvider';
-const HoverExecute = 'ExtensionHostHover.execute';
-const ImplementationExecuteImplementationProvider = 'ExtensionHostImplementation.executeImplementationProvider';
-const MockExec = 'ExtensionHostMockExec.mockExec';
-const MockRpc = 'ExtensionHostMockRpc.mockRpc';
-const OrganizeImportsExecute = 'ExtensionHostOrganizeImports.execute';
-const ReferenceExecuteFileReferenceProvider = 'ExtensionHostReference.executeFileReferenceProvider';
-const ReferenceExecuteReferenceProvider = 'ExtensionHostReference.executeReferenceProvider';
-const SourceControlAcceptInput = 'ExtensionHostSourceControl.acceptInput';
-const SourceControlAdd = 'ExtensionHostSourceControl.add';
-const SourceControlDiscard = 'ExtensionHostSourceControl.discard';
-const SourceControlGetChangedFiles = 'ExtensionHost.sourceControlGetChangedFiles';
-const SourceControlGetEnabledProviderIds = 'ExtensionHostSourceControl.getEnabledProviderIds';
-const SourceControlGetFileBefore = 'ExtensionHostSourceControl.GetFileBefore';
-const SourceControlGetGroups = 'ExtensionHostSourceControl.getGroups';
-const StatusBarGetStatusBarItems = 'ExtensionHost.getStatusBarItems';
-const StatusBarRegisterChangeListener = 'ExtensionHostStatusBar.registerChangeListener';
-const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompletionProvider';
-const TextDocumentSetLanguageId = 'ExtensionHostTextDocument.setLanguageId';
-const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
-const TextDocumentSyncIncremental = 'ExtensionHostTextDocument.syncIncremental';
-const TextSearchExecuteTextSearchProvider = 'ExtensionHostTextSearch.executeTextSearchProvider';
-const TypeDefinitionExecuteTypeDefinitionProvider = 'ExtensionHostTypeDefinition.executeTypeDefinitionProvider';
-const WorkspaceSetPath = 'Workspace.setWorkspacePath';
-const SelectionExecuteSelectionProvider = 'ExtensionHostSelection.executeSelectionProvider';
-const ConfigurationSetConfiguration = 'ExtensionHostConfiguration.setConfiguration';
+const handleError = async error => {
+  console.error(error);
+};
 
-const create$5 = () => {
+/**
+ * @param {ErrorEvent} event
+ */
+const handleUnhandledError = async event => {
+  try {
+    event.preventDefault();
+    await handleError(event.error);
+  } catch {
+    console.error(event.error);
+  }
+};
+
+const processName = `extension host worker`;
+
+const getOutput = error => {
+  const errorMessage = error && error.message ? error.message : String(error);
+  const prefix = `[${processName}] Unhandled Rejection: ${errorMessage}`;
+  if (error && error.stack) {
+    return `${prefix}\n${error.stack}`;
+  }
+  return prefix;
+};
+const handleUnhandledRejection = event => {
+  if (event instanceof PromiseRejectionEvent) {
+    event.preventDefault();
+    const output = getOutput(event.reason);
+    console.error(output);
+    return;
+  }
+  const output = getOutput(event);
+  console.error(output);
+};
+
+const state$2 = {
+  /**
+   * @type {any[]}
+   */
+  errors: []
+};
+const addError = error => {
+  // @ts-ignore
+  state$2.errors.push(error);
+};
+const hasRecentErrors = () => {
+  return state$2.errors.length > 0;
+};
+const getRecentError = () => {
+};
+
+const handleContentSecurityPolicyViolation = event => {
+  const {
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
+  } = event;
+  addError({
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
+  });
+};
+
+const setStackTraceLimit = (errorConstructor, value) => {
+  if (errorConstructor.stackTraceLimit && errorConstructor.stackTraceLimit < value) {
+    errorConstructor.stackTraceLimit = value;
+  }
+};
+
+const setup = ({
+  global,
+  errorConstructor
+}) => {
+  setStackTraceLimit(errorConstructor, 20);
+  global.onerror ||= handleUnhandledError;
+  global.onunhandledrejection ||= handleUnhandledRejection;
+  if ('SecurityPolicyViolationEvent' in self) {
+    global.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
+  }
+  // @ts-ignore
+  global.vscode = api;
+};
+
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const 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 = '\n';
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines$1 = lines => {
+  return lines.split(NewLine);
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$1(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    message,
+    code: ERR_MODULE_NOT_FOUND
+  };
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$1(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
   return {
-    finished: false
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
   };
 };
-const cancel = token => {
-  token.finished = true;
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$1(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    message: `${actualMessage}`,
+    code: '',
+    stack: rest
+  };
 };
-const isCanceled = token => {
-  return token.finished;
+let IpcError$1 = class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        message,
+        code,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
 };
-
-const baseName = path => {
-  const slashIndex = path.lastIndexOf('/');
-  return path.slice(slashIndex + 1);
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
 };
-const getExtensionId = extension => {
-  if (extension && extension.id) {
-    return extension.id;
+const listen$8 = ({
+  port
+}) => {
+  return port;
+};
+const signal$8 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
   }
-  if (extension && extension.path) {
-    return baseName(extension.path);
+  getData(event) {
+    return getData$2(event);
   }
-  return '<unknown>';
-};
-
-const getUrlPrefix = extensionPath => {
-  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
-    return extensionPath;
+  send(message) {
+    this._rawIpc.postMessage(message);
   }
-  if (platform === Web) {
-    return extensionPath;
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
   }
-  if (extensionPath.startsWith('/')) {
-    return `/remote${extensionPath}`;
+  dispose() {
+    // ignore
   }
-  return `/remote/${extensionPath}`;
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$f = port => {
+  return new IpcChildWithMessagePort(port);
 };
-
-const handleRpcInfos = extension => {
-  try {
-    if (!extension) {
-      return;
-    }
-    const rpcs = extension.rpc;
-    const urlPrefix = getUrlPrefix(extension.path);
-    if (!rpcs) {
-      return;
-    }
-    if (!Array.isArray(rpcs)) {
-      return;
-    }
-    for (const rpc of rpcs) {
-      rpc.url = `${urlPrefix}/${rpc.url}`;
-      add$1(rpc.id, rpc);
-    }
-  } catch (error) {
-    console.warn(`Failed to handle extension rpcs: ${error}`);
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$8,
+  signal: signal$8,
+  wrap: wrap$f
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
   }
+  return globalThis;
 };
-
-class ContentSecurityPolicyError extends Error {
-  constructor(violatedDirective, sourceFile, lineNumber, columnNumber) {
-    super(`Content Security Policy Violation: ${violatedDirective}`);
-    this.name = 'ContentSecurityPolicyError';
-    if (sourceFile) {
-      this.stack = `Content Security Policy Violation
-    at ${sourceFile}:${lineNumber}:${columnNumber}`;
-    } else {
-      this.stack = `Content Security Policy Violation
-    at <unknown>`;
-    }
+const signal$7 = 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 state$2 = {
-  /**
-   * @type {any[]}
-   */
-  errors: []
+const wrap$e = global => {
+  return new IpcChildWithModuleWorker(global);
 };
-const addError = error => {
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$7,
+  wrap: wrap$e
+};
+const withResolvers$1 = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers$1();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
   // @ts-ignore
-  state$2.errors.push(error);
+  return event.data;
 };
-const hasRecentErrors = () => {
-  return state$2.errors.length > 0;
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$7(parentIpcRaw);
+  const parentIpc = wrap$e(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError$1('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    parentIpc.send({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null
+    });
+    parentIpc.dispose();
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$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$d = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
-const getRecentError = () => {
-  return state$2.errors.at(-1);
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$6,
+  wrap: wrap$d
 };
 
-const isImportErrorChrome = error => {
-  return error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module');
+const createRpc = ipc => {
+  const rpc = {
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      send(ipc, method, ...params);
+    },
+    invoke(method, ...params) {
+      return invoke(ipc, method, ...params);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeAndTransfer(ipc, method, ...params);
+    }
+  };
+  return rpc;
 };
-
-const isImportErrorFirefox = error => {
-  return error && error instanceof TypeError && error.message === 'error loading dynamically imported module';
+const requiresSocket$1 = () => {
+  return false;
 };
-
-const isSyntaxError = error => {
-  return error instanceof SyntaxError;
+const preparePrettyError$1 = error => {
+  return error;
 };
-
-const isImportError = error => {
-  return isImportErrorChrome(error) || isImportErrorFirefox(error) || isSyntaxError(error);
+const logError$1 = () => {
+  // handled by renderer worker
 };
-
-const sleep = duration => {
-  const promiseCallback = (resolve, reject) => {
-    setTimeout(resolve, duration);
-  };
-  return new Promise(promiseCallback);
+const handleMessage = event => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket$1;
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$1, logError$1, actualRequiresSocket);
 };
-
-const NotFound = 404;
-
-const RE_LINE_COLUMN = /(.*)(?:\(\d+\:\d+\))/;
-const getBabelErrorMessage = message => {
-  const match = message.match(RE_LINE_COLUMN);
-  if (match) {
-    return match[1].trim();
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
   }
-  return message;
 };
-class BabelParseError extends SyntaxError {
-  constructor(url, error) {
-    const message = getBabelErrorMessage(error.message);
-    super(message);
-    this.name = 'BabelParseError';
-    // @ts-ignore
-    const line = error.loc.line;
-    // @ts-ignore
-    const column = error.loc.column + 1;
-    this.stack = `${message}
-  at ${url}:${line}:${column}`;
-  }
-}
-
-const getAssetDir = () => {
-  // @ts-ignore
-  if (typeof ASSET_DIR !== 'undefined') {
-    // @ts-ignore
-    return ASSET_DIR;
-  }
-  if (platform === Electron) {
-    return '../../../../..';
+const listen$1 = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
   }
-  return '';
-};
-const assetDir = getAssetDir();
-
-const loadBabelParser = () => {
-  const url = `${assetDir}/js/babel-parser.js`;
-  return import(url);
+  const ipc = module.wrap(rawIpc);
+  return ipc;
 };
-
-const parse = async (code, options) => {
-  const BabelParse = await loadBabelParser();
-  return BabelParse.parse(code, options);
+const create$6 = 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 Module = 'module';
-
-const getLineAndColumn = (text, start, end) => {
-  let index = -1;
-  let line = 0;
-  const column = 0;
-  while ((index = text.indexOf('\n', index + 1)) !== -1) {
-    line++;
-    if (index >= start) {
-      break;
-    }
-  }
-  return {
-    line,
-    column
-  };
+const WebWorkerRpcClient = {
+  __proto__: null,
+  create: create$6
 };
 
-class DependencyNotFoundError extends Error {
-  constructor(code, start, end, dependencyRelativePath, dependencyUrl, sourceUrl) {
-    super(`Module not found "${dependencyRelativePath}"`);
-    const {
-      line,
-      column
-    } = getLineAndColumn(code, start);
-    this.stack = `${this.message}
-    at Module (${sourceUrl}:${line}:${column})`;
-  }
-}
-
-const ArrowFunctionExpression = 'ArrowFunctionExpression';
-const AwaitExpression = 'AwaitExpression';
-const BlockStatement = 'BlockStatement';
-const CallExpression = 'CallExpression';
-const ExportAllDeclaration = 'ExportAllDeclaration';
-const ExportNamedDeclaration = 'ExportNamedDeclaration';
-const ExpressionStatement = 'ExpressionStatement';
-const File$1 = 'File';
-const Import = 'Import';
-const ImportDeclaration = 'ImportDeclaration';
-const Program = 'Program';
-const StringLiteral = 'StringLiteral';
-const VariableDeclaration = 'VariableDeclaration';
-const VariableDeclarator = 'VariableDeclarator';
-
-const walk = (node, visitor) => {
-  if (!node) {
-    return;
-  }
-  if (Array.isArray(node)) {
-    for (const item of node) {
-      walk(item, visitor);
-    }
-    return;
-  }
-  visitor(node);
-  switch (node.type) {
-    case File$1:
-      walk(node.program, visitor);
-      break;
-    case Program:
-      walk(node.body, visitor);
-      break;
-    case ExportNamedDeclaration:
-      walk(node.declaration, visitor);
-      break;
-    case VariableDeclaration:
-      walk(node.declarations, visitor);
-      break;
-    case VariableDeclarator:
-      walk(node.init, visitor);
-      break;
-    case ArrowFunctionExpression:
-      walk(node.body, visitor);
-      break;
-    case BlockStatement:
-      walk(node.body, visitor);
-      break;
-    case ExpressionStatement:
-      walk(node.expression, visitor);
-      break;
-    case AwaitExpression:
-      walk(node.argument, visitor);
-      break;
-    case CallExpression:
-      walk(node.callee, visitor);
-      break;
-  }
-};
-const getBabelAstDependencies = (code, ast) => {
-  const {
-    program
-  } = ast;
-  const {
-    body
-  } = program;
-  const dependencies = [];
-  for (const node of body) {
-    if (node.type === ImportDeclaration || node.type === ExportAllDeclaration) {
-      const relativePath = node.source.extra.rawValue;
-      const start = node.source.start;
-      const end = node.source.end;
-      // @ts-ignore
-      dependencies.push({
-        relativePath,
-        code,
-        start,
-        end
-      });
-    } else if (node.type === VariableDeclaration && node.declarations && node.declarations[0] && node.declarations[0].type === VariableDeclarator && node.declarations[0].init && node.declarations[0].init.type === AwaitExpression && node.declarations[0].init.argument && node.declarations[0].init.argument.type === CallExpression && node.declarations[0].init.argument.callee && node.declarations[0].init.argument.callee.type === Import && node.declarations[0].init.argument.arguments && node.declarations[0].init.argument.arguments[0] && node.declarations[0].init.argument.arguments[0].type === StringLiteral) {
-      const relativePath = node.declarations[0].init.argument.arguments[0].extra.rawValue;
-      const start = node.declarations[0].init.argument.arguments[0].start;
-      const end = node.declarations[0].init.argument.arguments[0].end;
-      // @ts-ignore
-      dependencies.push({
-        relativePath,
-        code,
-        start,
-        end
-      });
-    }
-  }
-  const visitor = node => {
-    if (node && node.type === CallExpression && node.callee && node.callee.type === Import && node.arguments && node.arguments[0] && node.arguments[0].type === StringLiteral) {
-      const relativePath = node.arguments[0].extra.rawValue;
-      const start = node.arguments[0].start;
-      const end = node.arguments[0].end;
-      // @ts-ignore
-      dependencies.push({
-        relativePath,
-        code,
-        start,
-        end
-      });
-    }
+const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
+const ClosingTagExecuteClosingTagProvider = 'ExtensionHostClosingTag.executeClosingTagProvider';
+const CommandExecute = 'ExtensionHostCommand.executeCommand';
+const CompletionExecute = 'ExtensionHostCompletion.execute';
+const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
+const DefinitionExecuteDefinitionProvider = 'ExtensionHostDefinition.executeDefinitionProvider';
+const DiagnosticExecuteDiagnosticProvider = 'ExtensionHost.executeDiagnosticProvider';
+const ExtensionActivate = 'ExtensionHostExtension.activate';
+const FileSystemGetPathSeparator = 'ExtensionHostFileSystem.getPathSeparator';
+const FileSystemReadDirWithFileTypes = 'ExtensionHostFileSystem.readDirWithFileTypes';
+const FileSystemReadFile = 'ExtensionHostFileSystem.readFile';
+const FileSystemWriteFile = 'ExtensionHostFileSystem.writeFile';
+const FormattingExecuteFormmattingProvider = 'ExtensionHostFormatting.executeFormattingProvider';
+const HoverExecute = 'ExtensionHostHover.execute';
+const ImplementationExecuteImplementationProvider = 'ExtensionHostImplementation.executeImplementationProvider';
+const MockExec = 'ExtensionHostMockExec.mockExec';
+const MockRpc = 'ExtensionHostMockRpc.mockRpc';
+const OrganizeImportsExecute = 'ExtensionHostOrganizeImports.execute';
+const ReferenceExecuteFileReferenceProvider = 'ExtensionHostReference.executeFileReferenceProvider';
+const ReferenceExecuteReferenceProvider = 'ExtensionHostReference.executeReferenceProvider';
+const SourceControlAcceptInput = 'ExtensionHostSourceControl.acceptInput';
+const SourceControlAdd = 'ExtensionHostSourceControl.add';
+const SourceControlDiscard = 'ExtensionHostSourceControl.discard';
+const SourceControlGetChangedFiles = 'ExtensionHost.sourceControlGetChangedFiles';
+const SourceControlGetEnabledProviderIds = 'ExtensionHostSourceControl.getEnabledProviderIds';
+const SourceControlGetFileBefore = 'ExtensionHostSourceControl.GetFileBefore';
+const SourceControlGetGroups = 'ExtensionHostSourceControl.getGroups';
+const StatusBarGetStatusBarItems = 'ExtensionHost.getStatusBarItems';
+const StatusBarRegisterChangeListener = 'ExtensionHostStatusBar.registerChangeListener';
+const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompletionProvider';
+const TextDocumentSetLanguageId = 'ExtensionHostTextDocument.setLanguageId';
+const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
+const TextDocumentSyncIncremental = 'ExtensionHostTextDocument.syncIncremental';
+const TextSearchExecuteTextSearchProvider = 'ExtensionHostTextSearch.executeTextSearchProvider';
+const TypeDefinitionExecuteTypeDefinitionProvider = 'ExtensionHostTypeDefinition.executeTypeDefinitionProvider';
+const WorkspaceSetPath = 'Workspace.setWorkspacePath';
+const SelectionExecuteSelectionProvider = 'ExtensionHostSelection.executeSelectionProvider';
+const ConfigurationSetConfiguration = 'ExtensionHostConfiguration.setConfiguration';
+
+const create$5 = () => {
+  return {
+    finished: false
   };
-  walk(ast, visitor);
-  return dependencies;
 };
-
-const isBabelError = error => {
-  // @ts-ignore
-  return isSyntaxError(error) && error.code === BABEL_PARSER_SYNTAX_ERROR;
+const cancel = token => {
+  token.finished = true;
 };
-
-const getOrigin = () => {
-  return location.origin;
+const isCanceled = token => {
+  return token.finished;
 };
 
-const getAbsoluteUrl = (relativePath, sourceUrl) => {
-  if (sourceUrl.startsWith('/')) {
-    const origin = getOrigin();
-    const absoluteSourceUrl = new URL(sourceUrl, origin).toString();
-    return new URL(relativePath, absoluteSourceUrl).toString();
-  }
-  return new URL(relativePath, sourceUrl).toString();
+const baseName = path => {
+  const slashIndex = path.lastIndexOf('/');
+  return path.slice(slashIndex + 1);
 };
-
-const isExternal = url => {
-  if (url.startsWith('/')) {
-    return false;
-  }
-  if (url.startsWith(location.protocol)) {
-    return false;
+const getExtensionId = extension => {
+  if (extension && extension.id) {
+    return extension.id;
   }
-  return true;
-};
-const getErrorInDependencies = async (url, dependencies, seenUrls) => {
-  for (const dependency of dependencies) {
-    const dependencyUrl = getAbsoluteUrl(dependency.relativePath, url);
-    if (isExternal(dependencyUrl) || seenUrls.includes(dependencyUrl)) {
-      continue;
-    }
-    seenUrls.push(dependencyUrl);
-    // let dependencyResponse
-    // try {
-    const dependencyResponse = await fetch(dependencyUrl);
-    // } catch (error) {}
-    if (dependencyResponse.ok) {
-      await tryToGetActualErrorMessage(null, dependencyUrl, dependencyResponse, seenUrls);
-    } else {
-      switch (dependencyResponse.status) {
-        case NotFound:
-          throw new DependencyNotFoundError(dependency.code, dependency.start, dependency.end, dependency.relativePath, dependencyUrl, url);
-        // return `Failed to import ${url}: ${error}`
-      }
-    }
+  if (extension && extension.path) {
+    return baseName(extension.path);
   }
+  return '<unknown>';
 };
 
-/**
- *
- * @param {string} url
- * @param {Response} response
- * @returns
- */
-const tryToGetActualErrorMessage = async (error, url, response, seenUrls = []) => {
-  let text;
-  try {
-    text = await response.text();
-  } catch (error) {
-    return `Failed to import ${url}: Unknown Network Error`;
-  }
-  let ast;
-  try {
-    ast = await parse(text, {
-      sourceType: Module
-    });
-  } catch (error) {
-    if (isBabelError(error)) {
-      throw new BabelParseError(url, error);
-    }
-    throw error;
+const getUrlPrefix = extensionPath => {
+  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
+    return extensionPath;
   }
-  const dependencies = getBabelAstDependencies(text, ast);
-  await getErrorInDependencies(url, dependencies, seenUrls);
-  if (hasRecentErrors()) {
-    const recentError = getRecentError();
-    // @ts-ignore
-    throw new ContentSecurityPolicyError(recentError.violatedDirective, recentError.sourceFile, recentError.lineNumber, recentError.columnNumber);
+  if (platform === Web) {
+    return extensionPath;
   }
-  const contentType = response.headers.get('Content-Type');
-  if (url.endsWith('.ts') && contentType === null) {
-    return `Failed to import ${url}: Missing Content-Type header for javascript`;
+  if (extensionPath.startsWith('/')) {
+    return `/remote${extensionPath}`;
   }
-  return `Failed to import ${url}: Unknown Network Error`;
+  return `/remote/${extensionPath}`;
 };
 
-const tryToGetActualImportErrorMessage = async (url, error) => {
-  let response;
+const handleRpcInfos = extension => {
   try {
-    response = await fetch(url);
+    if (!extension) {
+      return;
+    }
+    const rpcs = extension.rpc;
+    const urlPrefix = getUrlPrefix(extension.path);
+    if (!rpcs) {
+      return;
+    }
+    if (!Array.isArray(rpcs)) {
+      return;
+    }
+    for (const rpc of rpcs) {
+      rpc.url = `${urlPrefix}/${rpc.url}`;
+      add$1(rpc.id, rpc);
+    }
   } catch (error) {
-    return `Failed to import ${url}: ${error}`;
-  }
-  if (response.ok) {
-    return await tryToGetActualErrorMessage(error, url, response);
-  }
-  switch (response.status) {
-    case NotFound:
-      throw new Error(`Failed to import ${url}: Not found (404)`);
-    default:
-      return `Failed to import ${url}: ${error}`;
+    console.warn(`Failed to handle extension rpcs: ${error}`);
   }
 };
 
-const importScript = async url => {
-  try {
-    return await import(url);
-  } catch (error) {
-    if (isImportError(error)) {
-      const actualErrorMessage = await tryToGetActualImportErrorMessage(url, error);
-      throw new Error(actualErrorMessage);
-    }
-    // content security policy errors arrive a little bit later
-    await sleep(0);
-    if (hasRecentErrors()) {
-      const recentError = getRecentError();
-      // @ts-ignore
-      throw new ContentSecurityPolicyError(recentError.violatedDirective, recentError.sourceFile, recentError.lineNumber, recentError.columnNumber);
+class ContentSecurityPolicyError extends Error {
+  constructor(violatedDirective, sourceFile, lineNumber, columnNumber) {
+    super(`Content Security Policy Violation: ${violatedDirective}`);
+    this.name = 'ContentSecurityPolicyError';
+    if (sourceFile) {
+      this.stack = `Content Security Policy Violation
+    at ${sourceFile}:${lineNumber}:${columnNumber}`;
+    } else {
+      this.stack = `Content Security Policy Violation
+    at <unknown>`;
     }
-    throw error;
   }
+}
+
+const isImportErrorChrome = error => {
+  return error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module');
 };
 
-const activationTimeout = 10_000;
-const rejectAfterTimeout = async (timeout, token) => {
-  await sleep(timeout);
-  if (isCanceled(token)) {
-    return;
-  }
-  throw new Error(`Activation timeout of ${timeout}ms exceeded`);
+const isImportErrorFirefox = error => {
+  return error && error instanceof TypeError && error.message === 'error loading dynamically imported module';
 };
-const activate = async (extension, absolutePath) => {
-  try {
-    string(extension.path);
-    string(extension.browser);
-    string(absolutePath);
-    const module = await importScript(absolutePath);
-    handleRpcInfos(extension);
-    const token = create$5();
-    try {
-      await Promise.race([module.activate(extension), rejectAfterTimeout(activationTimeout, token)]);
-    } catch (error) {
-      if (isImportError(error)) {
-        const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
-        throw new Error(actualErrorMessage);
-      }
-      throw error;
-    } finally {
-      cancel(token);
-    }
-  } catch (error) {
-    const id = getExtensionId(extension);
-    throw new VError(error, `Failed to activate extension ${id}`);
-  }
-  // console.info('activated', path)
+
+const isSyntaxError = error => {
+  return error instanceof SyntaxError;
 };
 
-class ExecError extends Error {
-  constructor(command, args, stdout, stderr, exitCode) {
-    super(`Failed to execute ${command}: process exited with code ${exitCode}`);
-    this.name = 'ExecError';
-    // @ts-ignore
-    this.stdout = stdout;
-    // @ts-ignore
-    this.stderr = stderr;
-    // @ts-ignore
-    this.exitCode = exitCode;
-  }
-}
+const isImportError = error => {
+  return isImportErrorChrome(error) || isImportErrorFirefox(error) || isSyntaxError(error);
+};
 
-const mockExec = () => {
-  try {
-    // @ts-ignore
-    api.exec = async (command, args, options) => {
-      const result = await invoke('Test.executeMockExecFunction', command, args, options);
-      const {
-        stdout,
-        stderr,
-        exitCode
-      } = result;
-      if (exitCode !== 0) {
-        throw new ExecError(command, args, stdout, stderr, exitCode);
-      }
-      return {
-        stdout,
-        stderr,
-        exitCode
-      };
-    };
-  } catch (error) {
-    throw new VError(error, 'Failed to mock exec function');
+const sleep = duration => {
+  const promiseCallback = (resolve, reject) => {
+    setTimeout(resolve, duration);
+  };
+  return new Promise(promiseCallback);
+};
+
+const NotFound = 404;
+
+const RE_LINE_COLUMN = /(.*)(?:\(\d+\:\d+\))/;
+const getBabelErrorMessage = message => {
+  const match = message.match(RE_LINE_COLUMN);
+  if (match) {
+    return match[1].trim();
   }
+  return message;
 };
+class BabelParseError extends SyntaxError {
+  constructor(url, error) {
+    const message = getBabelErrorMessage(error.message);
+    super(message);
+    this.name = 'BabelParseError';
+    // @ts-ignore
+    const line = error.loc.line;
+    // @ts-ignore
+    const column = error.loc.column + 1;
+    this.stack = `${message}
+  at ${url}:${line}:${column}`;
+  }
+}
 
-const mockRpc = () => {
+const getAssetDir = () => {
   // @ts-ignore
-  api.createNodeRpc = async options => {
-    try {
-      return {
-        async invoke(method, ...params) {
-          const result = await invoke('Test.executeMockRpcFunction', options.name, method, ...params);
-          return result;
-        }
-      };
-    } catch (error) {
-      throw new VError(error, 'Failed to mock exec function');
-    }
-  };
-};
-
-const getStatusBarItems = async () => {
-  const providers = Object.values(state$5.providers);
-  const statusBarItems = [];
-  for (const provider of providers) {
+  if (typeof ASSET_DIR !== 'undefined') {
     // @ts-ignore
-    if (provider && provider.statusBarCommands) {
-      // @ts-ignore
-      statusBarItems.push(...provider.statusBarCommands);
-    }
+    return ASSET_DIR;
   }
-  return statusBarItems;
+  if (platform === Electron) {
+    return '../../../../..';
+  }
+  return '';
 };
-const registerChangeListener = () => {
-  // TODO
+const assetDir = getAssetDir();
+
+const loadBabelParser = () => {
+  const url = `${assetDir}/js/babel-parser.js`;
+  return import(url);
 };
 
-const handleBeforeUnload = () => {
-  // TODO save all webviews in localstorage
-  // cannot use indexeddb during unload
-  console.log('before unload');
+const parse = async (code, options) => {
+  const BabelParse = await loadBabelParser();
+  return BabelParse.parse(code, options);
 };
 
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ModuleWorkerWithMessagePort = 4;
-const Auto = () => {
-  if (globalThis.acceptPort) {
-    return MessagePort$1;
+const Module = 'module';
+
+const getLineAndColumn = (text, start, end) => {
+  let index = -1;
+  let line = 0;
+  const column = 0;
+  while ((index = text.indexOf('\n', index + 1)) !== -1) {
+    line++;
+    if (index >= start) {
+      break;
+    }
   }
-  return ModuleWorkerWithMessagePort;
+  return {
+    line,
+    column
+  };
 };
 
-const walkValue = (value, transferrables, isTransferrable) => {
-  if (!value) {
-    return;
+class DependencyNotFoundError extends Error {
+  constructor(code, start, end, dependencyRelativePath, dependencyUrl, sourceUrl) {
+    super(`Module not found "${dependencyRelativePath}"`);
+    const {
+      line,
+      column
+    } = getLineAndColumn(code, start);
+    this.stack = `${this.message}
+    at Module (${sourceUrl}:${line}:${column})`;
   }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
+}
+
+const ArrowFunctionExpression = 'ArrowFunctionExpression';
+const AwaitExpression = 'AwaitExpression';
+const BlockStatement = 'BlockStatement';
+const CallExpression = 'CallExpression';
+const ExportAllDeclaration = 'ExportAllDeclaration';
+const ExportNamedDeclaration = 'ExportNamedDeclaration';
+const ExpressionStatement = 'ExpressionStatement';
+const File$1 = 'File';
+const Import = 'Import';
+const ImportDeclaration = 'ImportDeclaration';
+const Program = 'Program';
+const StringLiteral = 'StringLiteral';
+const VariableDeclaration = 'VariableDeclaration';
+const VariableDeclarator = 'VariableDeclarator';
+
+const walk = (node, visitor) => {
+  if (!node) {
     return;
   }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      walk(item, visitor);
     }
     return;
   }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
+  visitor(node);
+  switch (node.type) {
+    case File$1:
+      walk(node.program, visitor);
+      break;
+    case Program:
+      walk(node.body, visitor);
+      break;
+    case ExportNamedDeclaration:
+      walk(node.declaration, visitor);
+      break;
+    case VariableDeclaration:
+      walk(node.declarations, visitor);
+      break;
+    case VariableDeclarator:
+      walk(node.init, visitor);
+      break;
+    case ArrowFunctionExpression:
+      walk(node.body, visitor);
+      break;
+    case BlockStatement:
+      walk(node.body, visitor);
+      break;
+    case ExpressionStatement:
+      walk(node.expression, visitor);
+      break;
+    case AwaitExpression:
+      walk(node.argument, visitor);
+      break;
+    case CallExpression:
+      walk(node.callee, visitor);
+      break;
   }
 };
-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;
+const getBabelAstDependencies = (code, ast) => {
+  const {
+    program
+  } = ast;
+  const {
+    body
+  } = program;
+  const dependencies = [];
+  for (const node of body) {
+    if (node.type === ImportDeclaration || node.type === ExportAllDeclaration) {
+      const relativePath = node.source.extra.rawValue;
+      const start = node.source.start;
+      const end = node.source.end;
+      // @ts-ignore
+      dependencies.push({
+        relativePath,
+        code,
+        start,
+        end
+      });
+    } else if (node.type === VariableDeclaration && node.declarations && node.declarations[0] && node.declarations[0].type === VariableDeclarator && node.declarations[0].init && node.declarations[0].init.type === AwaitExpression && node.declarations[0].init.argument && node.declarations[0].init.argument.type === CallExpression && node.declarations[0].init.argument.callee && node.declarations[0].init.argument.callee.type === Import && node.declarations[0].init.argument.arguments && node.declarations[0].init.argument.arguments[0] && node.declarations[0].init.argument.arguments[0].type === StringLiteral) {
+      const relativePath = node.declarations[0].init.argument.arguments[0].extra.rawValue;
+      const start = node.declarations[0].init.argument.arguments[0].start;
+      const end = node.declarations[0].init.argument.arguments[0].end;
+      // @ts-ignore
+      dependencies.push({
+        relativePath,
+        code,
+        start,
+        end
+      });
     }
   }
-  return false;
-};
-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 = '\n';
-const joinLines = lines => {
-  return lines.join(NewLine);
-};
-const splitLines$1 = lines => {
-  return lines.split(NewLine);
-};
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
-};
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines$1(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
-  return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+  const visitor = node => {
+    if (node && node.type === CallExpression && node.callee && node.callee.type === Import && node.arguments && node.arguments[0] && node.arguments[0].type === StringLiteral) {
+      const relativePath = node.arguments[0].extra.rawValue;
+      const start = node.arguments[0].start;
+      const end = node.arguments[0].end;
+      // @ts-ignore
+      dependencies.push({
+        relativePath,
+        code,
+        start,
+        end
+      });
+    }
   };
+  walk(ast, visitor);
+  return dependencies;
 };
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
-const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
-const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
-};
-const isMessageCodeBlockStartIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_START.test(line);
-};
-const isMessageCodeBlockEndIndex = line => {
-  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+
+const isBabelError = error => {
+  // @ts-ignore
+  return isSyntaxError(error) && error.code === BABEL_PARSER_SYNTAX_ERROR;
 };
-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 getOrigin = () => {
+  return location.origin;
 };
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
-  return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
-  };
+
+const getAbsoluteUrl = (relativePath, sourceUrl) => {
+  if (sourceUrl.startsWith('/')) {
+    const origin = getOrigin();
+    const absoluteSourceUrl = new URL(sourceUrl, origin).toString();
+    return new URL(relativePath, absoluteSourceUrl).toString();
+  }
+  return new URL(relativePath, sourceUrl).toString();
 };
-const isModulesSyntaxError = stderr => {
-  if (!stderr) {
+
+const isExternal = url => {
+  if (url.startsWith('/')) {
     return false;
   }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
-};
-const isModuleNotFoundError = stderr => {
-  if (!stderr) {
+  if (url.startsWith(location.protocol)) {
     return false;
   }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
-};
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+  return true;
 };
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines(lines),
-      rest: []
-    };
-  }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break;
+const getErrorInDependencies = async (url, dependencies, seenUrls) => {
+  for (const dependency of dependencies) {
+    const dependencyUrl = getAbsoluteUrl(dependency.relativePath, url);
+    if (isExternal(dependencyUrl) || seenUrls.includes(dependencyUrl)) {
+      continue;
     }
-  }
-  return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
-  };
-};
-const getHelpfulChildProcessError = (stdout, stderr) => {
-  if (isUnhelpfulNativeModuleError(stderr)) {
-    return getNativeModuleErrorMessage(stderr);
-  }
-  if (isModulesSyntaxError(stderr)) {
-    return getModuleSyntaxError();
-  }
-  if (isModuleNotFoundError(stderr)) {
-    return getModuleNotFoundError(stderr);
-  }
-  const lines = splitLines$1(stderr);
-  const {
-    actualMessage,
-    rest
-  } = getDetails(lines);
-  return {
-    message: `${actualMessage}`,
-    code: '',
-    stack: rest
-  };
-};
-let IpcError$1 = class IpcError extends VError {
-  // @ts-ignore
-  constructor(betterMessage, stdout = '', stderr = '') {
-    if (stdout || stderr) {
-      // @ts-ignore
-      const {
-        message,
-        code,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      // @ts-ignore
-      cause.code = code;
-      cause.stack = stack;
-      super(cause, betterMessage);
+    seenUrls.push(dependencyUrl);
+    // let dependencyResponse
+    // try {
+    const dependencyResponse = await fetch(dependencyUrl);
+    // } catch (error) {}
+    if (dependencyResponse.ok) {
+      await tryToGetActualErrorMessage(null, dependencyUrl, dependencyResponse, seenUrls);
     } else {
-      super(betterMessage);
+      switch (dependencyResponse.status) {
+        case NotFound:
+          throw new DependencyNotFoundError(dependency.code, dependency.start, dependency.end, dependency.relativePath, dependencyUrl, url);
+        // return `Failed to import ${url}: ${error}`
+      }
     }
-    // @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$8 = ({
-  port
-}) => {
-  return port;
-};
-const signal$8 = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
+
+/**
+ *
+ * @param {string} url
+ * @param {Response} response
+ * @returns
+ */
+const tryToGetActualErrorMessage = async (error, url, response, seenUrls = []) => {
+  let text;
+  try {
+    text = await response.text();
+  } catch (error) {
+    return `Failed to import ${url}: Unknown Network Error`;
   }
-  getData(event) {
-    return getData$2(event);
+  let ast;
+  try {
+    ast = await parse(text, {
+      sourceType: Module
+    });
+  } catch (error) {
+    if (isBabelError(error)) {
+      throw new BabelParseError(url, error);
+    }
+    throw error;
   }
-  send(message) {
-    this._rawIpc.postMessage(message);
+  const dependencies = getBabelAstDependencies(text, ast);
+  await getErrorInDependencies(url, dependencies, seenUrls);
+  if (hasRecentErrors()) {
+    const recentError = getRecentError();
+    // @ts-ignore
+    throw new ContentSecurityPolicyError(recentError.violatedDirective, recentError.sourceFile, recentError.lineNumber, recentError.columnNumber);
   }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
+  const contentType = response.headers.get('Content-Type');
+  if (url.endsWith('.ts') && contentType === null) {
+    return `Failed to import ${url}: Missing Content-Type header for javascript`;
   }
-  dispose() {
-    // ignore
+  return `Failed to import ${url}: Unknown Network Error`;
+};
+
+const tryToGetActualImportErrorMessage = async (url, error) => {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (error) {
+    return `Failed to import ${url}: ${error}`;
   }
-  onClose(callback) {
-    // ignore
+  if (response.ok) {
+    return await tryToGetActualErrorMessage(error, url, response);
   }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
+  switch (response.status) {
+    case NotFound:
+      throw new Error(`Failed to import ${url}: Not found (404)`);
+    default:
+      return `Failed to import ${url}: ${error}`;
   }
-}
-const wrap$f = port => {
-  return new IpcChildWithMessagePort(port);
-};
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$8,
-  signal: signal$8,
-  wrap: wrap$f
 };
-const listen$7 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
+
+const importScript = async url => {
+  try {
+    return await import(url);
+  } catch (error) {
+    if (isImportError(error)) {
+      const actualErrorMessage = await tryToGetActualImportErrorMessage(url, error);
+      throw new Error(actualErrorMessage);
+    }
+    // content security policy errors arrive a little bit later
+    await sleep(0);
+    if (hasRecentErrors()) {
+      const recentError = getRecentError();
+      // @ts-ignore
+      throw new ContentSecurityPolicyError(recentError.violatedDirective, recentError.sourceFile, recentError.lineNumber, recentError.columnNumber);
+    }
+    throw error;
   }
-  return globalThis;
 };
-const signal$7 = global => {
-  global.postMessage(readyMessage);
+
+const activationTimeout = 10_000;
+const rejectAfterTimeout = async (timeout, token) => {
+  await sleep(timeout);
+  if (isCanceled(token)) {
+    return;
+  }
+  throw new Error(`Activation timeout of ${timeout}ms exceeded`);
 };
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$2(event);
+const activate = async (extension, absolutePath) => {
+  try {
+    string(extension.path);
+    string(extension.browser);
+    string(absolutePath);
+    const module = await importScript(absolutePath);
+    handleRpcInfos(extension);
+    const token = create$5();
+    try {
+      await Promise.race([module.activate(extension), rejectAfterTimeout(activationTimeout, token)]);
+    } catch (error) {
+      if (isImportError(error)) {
+        const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
+        throw new Error(actualErrorMessage);
+      }
+      throw error;
+    } finally {
+      cancel(token);
+    }
+  } catch (error) {
+    const id = getExtensionId(extension);
+    throw new VError(error, `Failed to activate extension ${id}`);
   }
-  send(message) {
+  // console.info('activated', path)
+};
+
+class ExecError extends Error {
+  constructor(command, args, stdout, stderr, exitCode) {
+    super(`Failed to execute ${command}: process exited with code ${exitCode}`);
+    this.name = 'ExecError';
     // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
+    this.stdout = stdout;
     // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
+    this.stderr = stderr;
+    // @ts-ignore
+    this.exitCode = exitCode;
   }
 }
-const wrap$e = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  listen: listen$7,
-  signal: signal$7,
-  wrap: wrap$e
-};
-const withResolvers$1 = () => {
-  let _resolve;
-  const promise = new Promise(resolve => {
-    _resolve = resolve;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
+
+const mockExec = () => {
+  try {
+    // @ts-ignore
+    api.exec = async (command, args, options) => {
+      const result = await invoke$1('Test.executeMockExecFunction', command, args, options);
+      const {
+        stdout,
+        stderr,
+        exitCode
+      } = result;
+      if (exitCode !== 0) {
+        throw new ExecError(command, args, stdout, stderr, exitCode);
+      }
+      return {
+        stdout,
+        stderr,
+        exitCode
+      };
+    };
+  } catch (error) {
+    throw new VError(error, 'Failed to mock exec function');
+  }
 };
-const waitForFirstMessage = async port => {
-  const {
-    resolve,
-    promise
-  } = withResolvers$1();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
+
+const mockRpc = () => {
   // @ts-ignore
-  return event.data;
-};
-const listen$6 = async () => {
-  const parentIpcRaw = listen$7();
-  signal$7(parentIpcRaw);
-  const parentIpc = wrap$e(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError$1('unexpected first message');
-  }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      jsonrpc: '2.0',
-      id: firstMessage.id,
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
-  }
-  return globalThis;
+  api.createNodeRpc = async options => {
+    try {
+      return {
+        async invoke(method, ...params) {
+          const result = await invoke$1('Test.executeMockRpcFunction', options.name, method, ...params);
+          return result;
+        }
+      };
+    } catch (error) {
+      throw new VError(error, 'Failed to mock exec function');
+    }
+  };
 };
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  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();
+
+const getStatusBarItems = async () => {
+  const providers = Object.values(state$5.providers);
+  const statusBarItems = [];
+  for (const provider of providers) {
+    // @ts-ignore
+    if (provider && provider.statusBarCommands) {
+      // @ts-ignore
+      statusBarItems.push(...provider.statusBarCommands);
     }
   }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$d = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
+  return statusBarItems;
 };
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$6,
-  wrap: wrap$d
+const registerChangeListener = () => {
+  // TODO
+};
+
+const handleBeforeUnload = () => {
+  // TODO save all webviews in localstorage
+  // cannot use indexeddb during unload
+  console.log('before unload');
 };
 
+const MessagePort$1 = 1;
+const ModuleWorker = 2;
+const ModuleWorkerWithMessagePort = 4;
+
+// @ts-ignore
 const getModule$1 = method => {
   switch (method) {
     case ModuleWorker:
@@ -3310,7 +3434,7 @@ const getModule$1 = method => {
 const handleMessagePort = port => {
   const module = getModule$1(MessagePort$1);
   const ipc = module.wrap(port);
-  handleIpc(ipc);
+  handleIpc$1(ipc);
   ipc.send('ready');
 };
 
@@ -4084,82 +4208,19 @@ const commandMap = {
   [WorkspaceSetPath]: setWorkspacePath
 };
 
-const handleError = async error => {
-  console.error(error);
-};
-
-/**
- * @param {PromiseRejectionEvent} event
- */
-const handleUnhandledRejection = async event => {
-  try {
-    event.preventDefault();
-    await handleError(event.reason);
-  } catch {
-    console.error(event.reason);
-  }
-};
-
-/**
- * @param {ErrorEvent} event
- */
-const handleUnhandledError = async event => {
-  try {
-    event.preventDefault();
-    await handleError(event.error);
-  } catch {
-    console.error(event.error);
-  }
-};
-
-const handleContentSecurityPolicyViolation = event => {
-  const {
-    violatedDirective,
-    sourceFile,
-    lineNumber,
-    columnNumber
-  } = event;
-  addError({
-    violatedDirective,
-    sourceFile,
-    lineNumber,
-    columnNumber
+const listen = async () => {
+  const rpc = await WebWorkerRpcClient.create({
+    commandMap: commandMap
   });
-};
-
-const listen = async ({
-  method
-}) => {
-  const module = await getModule$1(method);
-  const rawIpc = await module.listen();
-  // @ts-ignore
-  if (module.signal) {
-    // @ts-ignore
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const setStackTraceLimit = value => {
-  if (Error.stackTraceLimit && Error.stackTraceLimit < value) {
-    Error.stackTraceLimit = value;
-  }
+  setRpc(rpc);
 };
 
 const main = async () => {
-  setStackTraceLimit(20);
-  onerror ||= handleUnhandledError;
-  onunhandledrejection ||= handleUnhandledRejection;
-  if ('SecurityPolicyViolationEvent' in self) {
-    self.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
-  }
-  globalThis.vscode = api;
-  register$1(commandMap);
-  const ipc = await listen({
-    method: Auto()
+  setup({
+    errorConstructor: Error,
+    global: globalThis
   });
-  listen$1(ipc);
+  await listen();
 };
 
 main();
@@ -4353,7 +4414,7 @@ const create$2 = async ({
     port1,
     port2
   } = getPortTuple();
-  await invokeAndTransfer('IpcParent.create', {
+  await invokeAndTransfer$1('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url,
     name,
@@ -4430,7 +4491,7 @@ const create$1 = ({
   return {
     ipc,
     invoke(method, ...params) {
-      return invoke$1(this.ipc, method, ...params);
+      return invoke(this.ipc, method, ...params);
     }
   };
 };
@@ -4441,7 +4502,7 @@ const RpcParentWithJsonRpc = {
 };
 
 const sendMessagePortToElectron = async (port, initialCommand) => {
-  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
+  await invokeAndTransfer$1('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
 };
 
 const getPort = async type => {