@lvce-editor/extension-host-worker 1.1.0 → 1.2.1

package/dist/extensionHostWorkerMain.js

@@ -4,13 +4,13 @@ const Function = 3;
 const Variable = 4;
 const Keyword = 5;
 const Folder = 6;
-const File$1 = 7;
+const File$2 = 7;
 const Field = 8;
 
 const EditorCompletionType = {
   __proto__: null,
   Field,
-  File: File$1,
+  File: File$2,
   Folder,
   Function,
   Keyword,
@@ -64,6 +64,18 @@ const object = value => {
     throw new AssertionError$1('expected value to be of type object');
   }
 };
+const number$1 = value => {
+  const type = getType$3(value);
+  if (type !== 'number') {
+    throw new AssertionError$1('expected value to be of type number');
+  }
+};
+const array = value => {
+  const type = getType$3(value);
+  if (type !== 'array') {
+    throw new AssertionError$1('expected value to be of type array');
+  }
+};
 const string = value => {
   const type = getType$3(value);
   if (type !== 'string') {
@@ -77,7 +89,7 @@ const fn = value => {
   }
 };
 
-const state$a = {
+const state$b = {
   /** @type{any[]} */
   onDidOpenEditorListeners: [],
   /** @type{any[]} */
@@ -88,10 +100,209 @@ const state$a = {
   onDidSaveTextDocumentListeners: [],
   textDocuments: Object.create(null)
 };
+const setDocument = (textDocumentId, textDocument) => {
+  state$b.textDocuments[textDocumentId] = textDocument;
+};
+const getDidOpenListeners = () => {
+  return state$b.onDidSaveTextDocumentListeners;
+};
+const getWillChangeListeners = () => {
+  return state$b.onWillChangeEditorListeners;
+};
+const getDidChangeListeners = () => {
+  return state$b.onDidChangeTextDocumentListeners;
+};
 const getDocument = textDocumentId => {
-  return state$a.textDocuments[textDocumentId];
+  return state$b.textDocuments[textDocumentId];
 };
 
+const getOffset$1 = (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 toOffsetBasedEdit = (textDocument, documentEdit) => {
+//   switch (documentEdit.type) {
+//     case /* singleLineEdit */ 1: {
+//       const offset = getOffset(textDocument, documentEdit)
+//       return {
+//         offset,
+//         inserted: documentEdit.inserted,
+//         deleted: documentEdit.deleted,
+//         // type: /* singleLineEdit */ 1
+//       }
+//     }
+//     case /* splice */ 2:
+//       const offset = getOffset(textDocument, {
+//         rowIndex: documentEdit.rowIndex,
+//         columnIndex: textDocument.lines[documentEdit.rowIndex - 1].length,
+//       })
+//       const inserted = '\n' + documentEdit.newLines.join('\n')
+//       return {
+//         offset,
+//         inserted,
+//         deleted: 0 /* TODO */,
+//       }
+//   }
+// }
+
+// TODO incremental edits, don't send full text
+// export const applyEdit = (id, text, edits) => {
+//   const textDocument = get(id)
+//   textDocument.lines = text.split('\n')
+//   const offsetBasedEdits = edits.map((edit) =>
+//     toOffsetBasedEdit(textDocument, edit)
+//   )
+//   for (const listener of state.onDidChangeTextDocumentListeners) {
+//     // TODO avoid extra object allocation
+//     listener(textDocument, offsetBasedEdits)
+//   }
+// }
+
+// TODO data oriented vs object oriented
+// data -> simpler, exposes internals, sometimes weird/long (vscode.TextDocument.getText(textDocument))
+// object oriented -> hides internals, banana problem (textDocument.getText())
+
+// TODO send to shared process, which sends it to renderer worker
+// renderer worker sends back the edit
+// export const applyEdit2 = (textDocument, edit) => {
+//   if (VALIDATION_ENABLED) {
+//     assert(typeof textDocument === 'object')
+//     assert(textDocument !== null)
+//     assert(typeof textDocument.id === 'number')
+//     assert(textDocument.id > 0)
+//     assert(typeof textDocument.getText === 'function')
+//     assert(typeof edit === 'object')
+//     assert(typeof edit.offset === 'number')
+//     assert(typeof edit.inserted === 'string')
+//     assert(typeof edit.deleted === 'number')
+//   }
+
+//   let rowIndex = 0
+//   let offset = 0
+//   const lines = textDocument.getText().split('\n')
+//   while (offset < edit.offset) {
+//     offset += lines[rowIndex++].length + 1
+//   }
+//   rowIndex--
+//   offset -= lines[rowIndex].length + 1
+//   const edit2 = {
+//     rowIndex,
+//     inserted: edit.inserted,
+//     deleted: edit.deleted,
+//     columnIndex: edit.offset - offset + edit.deleted,
+//     type: 1,
+//   }
+
+//   // // TODO should be invoke and return boolean whether edit was applied or not
+//   SharedProcess.send({
+//     event: 'TextDocument.applyEdit',
+//     args: [/* id */ textDocument.id, /* edits */ edit2],
+//   })
+// }
+
+// export const create = (textDocumentId, languageId, content) => {
+//   const textDocument = {
+//     languageId,
+//     lines: content.split('\n'),
+//   }
+//   state.textDocuments[textDocumentId] = textDocument
+// }
+
+// const createTextDocument = (uri, languageId, text) => {
+//   if (VALIDATION_ENABLED) {
+//     assert(typeof uri === 'string')
+//     assert(typeof languageId === 'string')
+//     assert(typeof text === 'string')
+//   }
+//   const state = {
+//     /** @internal */
+//     lines: text.split('\n'),
+//     uri,
+//     languageId,
+//     getText() {
+//       return state.lines.join('\n')
+//     },
+//   }
+//   return state
+// }
+
+// export const sync = (documentId, languageId, text) => {
+//   const textDocument = get(documentId)
+//   if (!textDocument) {
+//     console.warn(`textDocument is undefined ${languageId}`)
+//     return
+//   }
+//   textDocument.languageId = languageId
+//   textDocument.lines = text.split('\n')
+//   // console.log('sync', JSON.stringify(text))
+// }
+
+const runListenerSafe = async (listener, ...args) => {
+  try {
+    await listener(...args);
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.message) {
+      // @ts-ignore
+      error.message = 'Failed to run open listener: ' + error.message;
+    }
+    console.error(error);
+  }
+};
+const runListenersSafe = (listeners, ...args) => {
+  for (const listener of listeners) {
+    runListenerSafe(listener, ...args);
+  }
+};
+const syncFull = (uri, textDocumentId, languageId, text) => {
+  const textDocument = {
+    uri,
+    documentId: textDocumentId,
+    languageId,
+    text
+  };
+  setDocument(textDocumentId, textDocument);
+  runListenersSafe(getDidOpenListeners(), textDocument);
+};
+const getSyntheticChanges = (textDocument, changes) => {
+  // console.log({ textDocument, changes })
+  object(textDocument);
+  array(changes);
+  const change = changes[0];
+  const startOffset = getOffset$1(textDocument, change.start);
+  const endOffset = getOffset$1(textDocument, change.end);
+  const inserted = change.inserted.join('\n');
+  const syntheticChanges = [{
+    startOffset,
+    endOffset,
+    inserted
+  }];
+  return syntheticChanges;
+};
+const syncIncremental = (textDocumentId, changes) => {
+  number$1(textDocumentId);
+  array(changes);
+  const textDocument = getDocument(textDocumentId);
+  if (!textDocument) {
+    console.warn(`sync not possible, no matching textDocument with id ${textDocumentId}`);
+    return;
+  }
+  const syntheticChanges = getSyntheticChanges(textDocument, changes);
+  runListenersSafe(getWillChangeListeners(), textDocument, syntheticChanges);
+  const syntheticChange = syntheticChanges[0];
+  const oldText = textDocument.text;
+  const before = oldText.slice(0, syntheticChange.startOffset);
+  const after = oldText.slice(syntheticChange.endOffset);
+  textDocument.text = before + syntheticChange.inserted + after;
+  runListenersSafe(getDidChangeListeners(), textDocument, syntheticChanges);
+};
 const get$3 = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
@@ -99,7 +310,16 @@ const get$3 = textDocumentId => {
 const getText = textDocument => {
   return textDocument.text;
 };
+const setLanguageId = (textDocumentId, languageId) => {
+  const newTextDocument = {
+    ...getDocument(textDocumentId),
+    languageId
+  };
+  setDocument(textDocumentId, newTextDocument);
+  runListenersSafe(getDidOpenListeners(), newTextDocument);
+};
 
+const BABEL_PARSER_SYNTAX_ERROR = 'BABEL_PARSER_SYNTAX_ERROR';
 const E_COMMAND_NOT_FOUND$1 = 'E_COMMAND_NOT_FOUND';
 const E_NO_PROVIDER_FOUND = 'E_NO_PROVIDER_FOUND';
 
@@ -352,7 +572,7 @@ const registerMethod = ({
     }
   };
 };
-const create$8 = ({
+const create$9 = ({
   name,
   resultShape,
   executeKey = '',
@@ -404,7 +624,7 @@ const {
   registerBraceCompletionProvider,
   executeBraceCompletionProvider,
   reset: reset$9
-} = create$8({
+} = create$9({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -414,7 +634,7 @@ const {
 const {
   registerClosingTagProvider,
   executeClosingTagProvider
-} = create$8({
+} = create$9({
   name: 'ClosingTag',
   returnUndefinedWhenNoProviderFound: true,
   resultShape: {
@@ -426,7 +646,7 @@ const {
 const {
   registerCodeActionProvider,
   executeCodeActionProvider
-} = create$8({
+} = create$9({
   name: 'CodeAction',
   resultShape: {
     type: Array$1,
@@ -435,8 +655,28 @@ const {
     }
   }
 });
+const isOrganizeImports = action => {
+  return action.kind === 'source.organizeImports';
+};
 
-const state$9 = {
+// TODO handle case when multiple organize imports providers are registered
+const executeOrganizeImports = async uid => {
+  const actions = await executeCodeActionProvider(uid);
+  // @ts-ignore
+  if (!actions || actions.length === 0) {
+    return [];
+  }
+  // @ts-ignore
+  const organizeImportsAction = actions.find(isOrganizeImports);
+  if (!organizeImportsAction) {
+    return [];
+  }
+  const textDocument = get$3(uid);
+  const edits = await organizeImportsAction.execute(textDocument);
+  return edits;
+};
+
+const state$a = {
   commands: Object.create(null)
 };
 const getCommandDisplay = command => {
@@ -459,10 +699,10 @@ const registerCommand = command => {
     if (!command.execute) {
       throw new Error('command is missing execute function');
     }
-    if (command.id in state$9.commands) {
+    if (command.id in state$a.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$9.commands[command.id] = command;
+    state$a.commands[command.id] = command;
   } catch (error) {
     const commandDisplayId = getCommandDisplay(command);
     throw new VError$1(error, `Failed to register command${commandDisplayId}`);
@@ -470,7 +710,7 @@ const registerCommand = command => {
 };
 const executeCommand = async (id, ...args) => {
   try {
-    const command = state$9.commands[id];
+    const command = state$a.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -489,7 +729,7 @@ const {
   registerCompletionProvider,
   executeCompletionProvider,
   executeresolveCompletionItemProvider
-} = create$8({
+} = create$9({
   name: 'Completion',
   resultShape: {
     type: Array$1,
@@ -509,14 +749,24 @@ const {
   }]
 });
 
-const state$8 = {
+const state$9 = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$8.configuration[key] ?? '';
+  return state$9.configuration[key] ?? '';
+};
+const setConfigurations = preferences => {
+  state$9.configuration = preferences;
 };
 
 const Two = '2.0';
+const create$4$1 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -563,11 +813,11 @@ const get$2 = id => {
 const remove = id => {
   delete state$1$1.callbacks[id];
 };
-const state$7 = {
+const state$8 = {
   id: 0
 };
 const create$3$1 = () => {
-  return ++state$7.id;
+  return ++state$8.id;
 };
 const warn = (...args) => {
   console.warn(...args);
@@ -798,7 +1048,7 @@ const getErrorResponse = (message, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(message, errorProperty);
 };
-const create$7 = (message, result) => {
+const create$8 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -807,7 +1057,7 @@ const create$7 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$7(message, resultProperty);
+  return create$8(message, resultProperty);
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
   try {
@@ -873,6 +1123,10 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
+const send$1 = (transport, method, ...params) => {
+  const message = create$4$1(method, params);
+  transport.send(message);
+};
 const invoke$1 = async (ipc, method, ...params) => {
   const {
     message,
@@ -905,10 +1159,13 @@ class CommandNotFoundError extends Error {
   }
 }
 
-const state$6 = {};
+const state$7 = {};
+const register = commandMap => {
+  Object.assign(state$7, commandMap);
+};
 const execute = (method, ...params) => {
   // @ts-ignore
-  const fn = state$6[method];
+  const fn = state$7[method];
   // @ts-ignore
   if (!fn) {
     throw new CommandNotFoundError(method);
@@ -934,19 +1191,23 @@ const handleIpc = ipc => {
   ipc.addEventListener('message', handleMessage);
 };
 
-const state$5 = {
+const state$6 = {
   /**
    * @type {any}
    */
   ipc: undefined
 };
 const get$1 = () => {
-  return state$5.ipc;
+  return state$6.ipc;
 };
 const set$1 = ipc => {
-  state$5.ipc = ipc;
+  state$6.ipc = ipc;
 };
 
+const send = (method, ...params) => {
+  const ipc = get$1();
+  send$1(ipc, method, ...params);
+};
 const invoke = (method, ...params) => {
   const ipc = get$1();
   return invoke$1(ipc, method, ...params);
@@ -960,21 +1221,133 @@ const listen$2 = ipc => {
   set$1(ipc);
 };
 
-const state$4 = {
+const state$5 = {
   debugProviderMap: Object.create(null)
 };
+const getDebugProvider = id => {
+  const provider = state$5.debugProviderMap[id];
+  if (!provider) {
+    // @ts-ignore
+    throw new VError$1(`no debug provider "${id}" found`);
+  }
+  return provider;
+};
 const registerDebugProvider = debugProvider => {
   if (!debugProvider.id) {
     throw new Error('Failed to register debug system provider: missing id');
   }
-  state$4.debugProviderMap[debugProvider.id] = debugProvider;
+  state$5.debugProviderMap[debugProvider.id] = debugProvider;
+};
+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$1(error, 'Failed to execute debug provider');
+  }
+};
+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$1(error, 'Failed to execute debug provider');
+  }
+};
+const resume = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.resume();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const pause = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.pause();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const stepInto = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepInto();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const stepOut = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepOut();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const stepOver = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepOver();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const setPauseOnException = async (protocol, value) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.setPauseOnExceptions(value);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const getProperties = async (protocol, objectId) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.getProperties(objectId);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const evaluate = async (protocol, expression, callFrameId) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.evaluate(expression, callFrameId);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const setPauseOnExceptions = async (protocol, value) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.setPauseOnExceptions(value);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute setPauseOnExceptions');
+  }
 };
 
 const {
   registerDefinitionProvider,
   executeDefinitionProvider,
   reset: reset$8
-} = create$8({
+} = create$9({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
@@ -996,7 +1369,7 @@ const {
 const {
   registerDiagnosticProvider,
   executeDiagnosticProvider
-} = create$8({
+} = create$9({
   name: 'Diagnostic',
   resultShape: {
     type: Array$1,
@@ -1018,14 +1391,38 @@ const exec = async (command, args, options) => {
   throw new DepecratedError(`vscode.exec is deprecated, use createNodeRpc instead`);
 };
 
-const state$3 = {
+const state$4 = {
   fileSystemProviderMap: Object.create(null)
 };
+const getFileSystemProvider = protocol => {
+  const provider = state$4.fileSystemProviderMap[protocol];
+  if (!provider) {
+    // @ts-ignore
+    throw new VError$1(`no file system provider for protocol "${protocol}" found`);
+  }
+  return provider;
+};
 const registerFileSystemProvider = fileSystemProvider => {
   if (!fileSystemProvider.id) {
     throw new Error('Failed to register file system provider: missing id');
   }
-  state$3.fileSystemProviderMap[fileSystemProvider.id] = fileSystemProvider;
+  state$4.fileSystemProviderMap[fileSystemProvider.id] = fileSystemProvider;
+};
+const readDirWithFileTypes = async (protocol, path) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return await provider.readDirWithFileTypes(path);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute file system provider');
+  }
+};
+const readFile = async (protocol, path) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return await provider.readFile(path);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute file system provider');
+  }
 };
 const readFileExternal = async path => {
   // TODO when file is local,
@@ -1037,16 +1434,101 @@ const readFileExternal = async path => {
   const content = await invoke('FileSystem.readFile', path);
   return content;
 };
+const writeFile = async (protocol, uri, content) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return await provider.writeFile(uri, content);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute file system provider');
+  }
+};
+const getPathSeparator = protocol => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return provider.pathSeparator;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute file system provider');
+  }
+};
 
 const webViews = Object.create(null);
 const webViewProviders = Object.create(null);
+const getProvider = providerId => {
+  return webViewProviders[providerId];
+};
 const setProvider = (providerId, provider) => {
   webViewProviders[providerId] = provider;
 };
 const getWebView = id => {
   return webViews[id];
 };
+const setWebView = (id, webView) => {
+  webViews[id] = webView;
+};
+
+// TODO pass uuid to allow having multiple webviews open at the same time
+const createWebView = async (providerId, port, uri, uid, origin) => {
+  const provider = getProvider(providerId);
+  if (!provider) {
+    throw new Error(`webview provider ${providerId} not found`);
+  }
+
+  // TODO cancel promise when webview is disposed before sending message
+  // TODO handle case when webview doesn't send ready message
+  // TODO handle error
+  await new Promise(resolve => {
+    port.onmessage = resolve;
+  });
 
+  // TODO use ipc module
+  const handlePortMessage = async event => {
+    const {
+      data,
+      target
+    } = event;
+    const {
+      method,
+      params,
+      id
+    } = data;
+    if (provider && provider.commands && provider.commands[method]) {
+      const fn = provider.commands[method];
+      const result = await fn(...params);
+      if (id) {
+        target.postMessage({
+          jsonrpc: '2.0',
+          id,
+          result
+        });
+      }
+    }
+  };
+  port.onmessage = handlePortMessage;
+  const rpc = {
+    uri,
+    provider,
+    uid,
+    origin,
+    invoke(method, ...params) {
+      // TODO return promise with result
+      port.postMessage({
+        jsonrpc: '2.0',
+        method,
+        params
+      });
+    }
+  };
+  // TODO allow creating multiple webviews per provider
+  setWebView(providerId, rpc);
+};
+const load = async providerId => {
+  const rpc = getWebView(providerId);
+  await rpc.provider.create(rpc, rpc.uri);
+};
+const disposeWebView = id => {
+  // TODO race condition
+  // const webView=webViews[id]
+};
 const registerWebViewProvider = provider => {
   setProvider(provider.id, provider);
 };
@@ -1055,7 +1537,7 @@ const {
   registerFormattingProvider,
   executeFormattingProvider,
   reset: reset$7
-} = create$8({
+} = create$9({
   name: 'Formatting',
   executeKey: 'format',
   resultShape: {
@@ -1117,7 +1599,7 @@ const {
   registerHoverProvider,
   executeHoverProvider,
   reset: reset$6
-} = create$8({
+} = create$9({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -1130,7 +1612,7 @@ const {
   registerImplementationProvider,
   executeImplementationProvider,
   reset: reset$5
-} = create$8({
+} = create$9({
   name: 'Implementation',
   resultShape: {
     type: Array$1,
@@ -1157,7 +1639,7 @@ const getModule$3 = method => {
   }
 };
 
-const create$6 = async ({
+const create$7 = async ({
   method,
   ...options
 }) => {
@@ -1184,7 +1666,7 @@ const getModule$2 = method => {
   }
 };
 
-const create$5 = async ({
+const create$6 = async ({
   method,
   ...options
 }) => {
@@ -1205,12 +1687,12 @@ const createNodeRpc = async ({
   try {
     string(path);
     fn(execute);
-    const ipc = await create$6({
+    const ipc = await create$7({
       method: ElectronMessagePort,
       type: 'extension-host-helper-process',
       name
     });
-    const rpc = await create$5({
+    const rpc = await create$6({
       ipc,
       method: JsonRpc,
       execute
@@ -1244,7 +1726,7 @@ const {
   executeReferenceProvider,
   executefileReferenceProvider,
   reset: reset$4
-} = create$8({
+} = create$9({
   name: 'Reference',
   resultShape: {
     type: Array$1,
@@ -1271,7 +1753,7 @@ const {
   executeRenameProvider,
   executeprepareRenameProvider,
   reset: reset$3
-} = create$8({
+} = create$9({
   name: 'Rename',
   resultShape: {
     type: Object$1,
@@ -1290,6 +1772,9 @@ const {
 });
 
 const rpcs = Object.create(null);
+const add$1 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
 const get = id => {
   return rpcs[id];
 };
@@ -1308,12 +1793,12 @@ const createRpcWithId = async ({
   if (!info) {
     throw new Error(`rpc with id ${id} not found`);
   }
-  const ipc = await create$6({
+  const ipc = await create$7({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url: extensionHostSubWorkerUrl,
     name: info.name
   });
-  const rpc = await create$5({
+  const rpc = await create$6({
     ipc,
     method: JsonRpc,
     execute
@@ -1354,12 +1839,12 @@ const createRpc = async ({
     if (contentSecurityPolicy) {
       await set(url, contentSecurityPolicy);
     }
-    const ipc = await create$6({
+    const ipc = await create$7({
       method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
       url: extensionHostSubWorkerUrl,
       name
     });
-    const rpc = await create$5({
+    const rpc = await create$6({
       ipc,
       method: JsonRpc,
       execute
@@ -1375,7 +1860,7 @@ const {
   registerSelectionProvider,
   executeSelectionProvider,
   reset: reset$2
-} = create$8({
+} = create$9({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
@@ -1386,18 +1871,104 @@ const {
   }
 });
 
-const state$2 = {
+const state$3 = {
   providers: Object.create(null)
 };
 const registerSourceControlProvider = provider => {
-  state$2.providers[provider.id] = provider;
+  state$3.providers[provider.id] = provider;
+};
+const getFilesFromProvider = provider => {
+  return provider.getChangedFiles();
+};
+const getChangedFiles = async providerId => {
+  const provider = state$3.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
+  }
+  const changedFiles = await getFilesFromProvider(provider);
+  const flattenedChangedFiles = changedFiles;
+  return flattenedChangedFiles;
+};
+const getFileBefore = async (providerId, uri) => {
+  string(providerId);
+  string(uri);
+  const provider = state$3.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
+  }
+  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 getGroups = async (providerId, cwd) => {
+  const provider = state$3.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
+  }
+  const groups = await getGroupsFromProvider(provider, cwd);
+  return groups;
+};
+const acceptInput = async (providerId, value) => {
+  const provider = state$3.providers[providerId];
+  if (!provider) {
+    throw new Error('no source control provider found');
+  }
+  await provider.acceptInput(value);
+};
+const add = async path => {
+  const provider = Object.values(state$3.providers)[0];
+  if (!provider) {
+    return;
+  }
+  // @ts-ignore
+  await provider.add(path);
+};
+const discard = async path => {
+  const provider = Object.values(state$3.providers)[0];
+  if (!provider) {
+    return;
+  }
+  // @ts-ignore
+  await provider.discard(path);
+};
+const getEnabledProviderIds = async (scheme, root) => {
+  string(scheme);
+  string(root);
+  const providers = Object.values(state$3.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$8({
+} = create$9({
   name: 'TabCompletion',
   resultShape: {
     type: Object$1,
@@ -1405,7 +1976,7 @@ const {
   }
 });
 
-const state$1 = {
+const state$2 = {
   textSearchProviders: Object.create(null)
 };
 const registerTextSearchProvider = textSearchProvider => {
@@ -1416,14 +1987,14 @@ const registerTextSearchProvider = textSearchProvider => {
     if (!textSearchProvider.scheme) {
       throw new Error('textSearchProvider is missing scheme');
     }
-    state$1.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+    state$2.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
   } catch (error) {
     throw new VError$1(error, 'Failed to register text search provider');
   }
 };
 const executeTextSearchProvider = async (scheme, query) => {
   try {
-    const textSearchProvider = state$1.textSearchProviders[scheme];
+    const textSearchProvider = state$2.textSearchProviders[scheme];
     if (!textSearchProvider) {
       throw new Error(`no text search provider for ${scheme} found`);
     }
@@ -1438,7 +2009,7 @@ const {
   registerTypeDefinitionProvider,
   executeTypeDefinitionProvider,
   reset
-} = create$8({
+} = create$9({
   name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
@@ -1465,7 +2036,7 @@ const createWorker = async ({
   string(method);
   string(url);
   string(name);
-  const ipc = create$6({
+  const ipc = create$7({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url,
     name
@@ -1473,11 +2044,14 @@ const createWorker = async ({
   return ipc;
 };
 
-const state = {
+const state$1 = {
   workspacePath: ''
 };
+const setWorkspacePath = path => {
+  state$1.workspacePath = path;
+};
 const getWorkspaceFolder = path => {
-  return state.workspacePath;
+  return state$1.workspacePath;
 };
 
 const RE_PROTOCOL = /^([a-z\-]+):\/\//;
@@ -1607,12 +2181,12 @@ class FormattingError extends Error {
   }
 }
 
-const File = 1;
+const File$1 = 1;
 const Match = 2;
 
 const TextSearchResultType = {
   __proto__: null,
-  File,
+  File: File$1,
   Match
 };
 
@@ -1710,6 +2284,177 @@ 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 create$5 = () => {
+  return {
+    finished: false
+  };
+};
+const cancel = token => {
+  token.finished = true;
+};
+const isCanceled = token => {
+  return token.finished;
+};
+
+const baseName = path => {
+  const slashIndex = path.lastIndexOf('/');
+  return path.slice(slashIndex + 1);
+};
+const getExtensionId = extension => {
+  if (extension && extension.id) {
+    return extension.id;
+  }
+  if (extension && extension.path) {
+    return baseName(extension.path);
+  }
+  return '<unknown>';
+};
+
+const getUrlPrefix = extensionPath => {
+  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
+    return extensionPath;
+  }
+  return `/remote/${extensionPath}`;
+};
+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}`);
+  }
+};
+
+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 state = {
+  /**
+   * @type {any[]}
+   */
+  errors: []
+};
+const addError = error => {
+  // @ts-ignore
+  state.errors.push(error);
+};
+const hasRecentErrors = () => {
+  return state.errors.length > 0;
+};
+const getRecentError = () => {
+  return state.errors.at(-1);
+};
+
+const isImportErrorChrome = error => {
+  return error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module');
+};
+
+const isImportErrorFirefox = error => {
+  return error && error instanceof TypeError && error.message === 'error loading dynamically imported module';
+};
+
+const isSyntaxError = error => {
+  return error instanceof SyntaxError;
+};
+
+const isImportError = error => {
+  return isImportErrorChrome(error) || isImportErrorFirefox(error) || isSyntaxError(error);
+};
+
+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 getAssetDir = () => {
   // @ts-ignore
   if (typeof ASSET_DIR !== 'undefined') {
@@ -1721,7 +2466,385 @@ const getAssetDir = () => {
   }
   return '';
 };
-getAssetDir();
+const assetDir = getAssetDir();
+
+const loadBabelParser = () => {
+  const url = `${assetDir}/js/babel-parser.js`;
+  return import(url);
+};
+
+const parse = async (code, options) => {
+  const BabelParse = await loadBabelParser();
+  return BabelParse.parse(code, options);
+};
+
+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
+  };
+};
+
+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 = '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:
+      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
+      });
+    }
+  };
+  walk(ast, visitor);
+  return dependencies;
+};
+
+const isBabelError = error => {
+  // @ts-ignore
+  return isSyntaxError(error) && error.code === BABEL_PARSER_SYNTAX_ERROR;
+};
+
+const getOrigin = () => {
+  return location.origin;
+};
+
+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 isExternal = url => {
+  if (url.startsWith('/')) {
+    return false;
+  }
+  if (url.startsWith(location.protocol)) {
+    return false;
+  }
+  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}`
+      }
+    }
+  }
+};
+
+/**
+ *
+ * @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 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);
+  }
+  const contentType = response.headers.get('Content-Type');
+  if (url.endsWith('.ts') && contentType === null) {
+    return `Failed to import ${url}: Missing Content-Type header for javascript`;
+  }
+  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}`;
+  }
+  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}`;
+  }
+};
+
+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;
+  }
+};
+
+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 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$1(error, `Failed to activate extension ${id}`);
+  }
+  // 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.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+    // @ts-ignore
+    this.exitCode = exitCode;
+  }
+}
+
+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$1(error, 'Failed to mock exec function');
+  }
+};
+
+const mockRpc = () => {
+  // @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$1(error, 'Failed to mock exec function');
+    }
+  };
+};
+
+const getStatusBarItems = async () => {
+  const providers = Object.values(state$3.providers);
+  const statusBarItems = [];
+  for (const provider of providers) {
+    // @ts-ignore
+    if (provider && provider.statusBarCommands) {
+      // @ts-ignore
+      statusBarItems.push(...provider.statusBarCommands);
+    }
+  }
+  return statusBarItems;
+};
+const registerChangeListener = () => {
+  // TODO
+};
 
 const MessagePort$1 = 1;
 const ModuleWorker = 2;
@@ -2177,6 +3300,69 @@ const getModule$1 = method => {
   }
 };
 
+const handleMessagePort = port => {
+  const module = getModule$1(MessagePort$1);
+  const ipc = module.wrap(port);
+  handleIpc(ipc);
+  ipc.send('ready');
+};
+
+const commandMap = {
+  ['ExtensionHostDebug.evaluate']: evaluate,
+  ['ExtensionHostDebug.getProperties']: getProperties,
+  ['ExtensionHostDebug.listProcesses']: listProcesses,
+  ['ExtensionHostDebug.pause']: pause,
+  ['ExtensionHostDebug.resume']: resume,
+  ['ExtensionHostDebug.setPauseOnException']: setPauseOnException,
+  ['ExtensionHostDebug.setPauseOnExceptions']: setPauseOnExceptions,
+  ['ExtensionHostDebug.start']: start,
+  ['ExtensionHostDebug.stepInto']: stepInto,
+  ['ExtensionHostDebug.stepOut']: stepOut,
+  ['ExtensionHostDebug.stepOver']: stepOver,
+  ['ExtensionHostWebView.create']: createWebView,
+  ['ExtensionHostWebView.dispose']: disposeWebView,
+  ['ExtensionHostWebView.load']: load,
+  ['HandleMessagePort.handleMessagePort']: handleMessagePort,
+  [BraceCompletionExecuteBraceCompletionProvider]: executeBraceCompletionProvider,
+  [ClosingTagExecuteClosingTagProvider]: executeClosingTagProvider,
+  [CommandExecute]: executeCommand,
+  [CompletionExecute]: executeCompletionProvider,
+  [CompletionResolveExecute]: executeresolveCompletionItemProvider,
+  [ConfigurationSetConfiguration]: setConfigurations,
+  [DefinitionExecuteDefinitionProvider]: executeDefinitionProvider,
+  [DiagnosticExecuteDiagnosticProvider]: executeDiagnosticProvider,
+  [ExtensionActivate]: activate,
+  [FileSystemGetPathSeparator]: getPathSeparator,
+  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes,
+  [FileSystemReadFile]: readFile,
+  [FileSystemWriteFile]: writeFile,
+  [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
+  [HoverExecute]: executeHoverProvider,
+  [ImplementationExecuteImplementationProvider]: executeImplementationProvider,
+  [MockExec]: mockExec,
+  [MockRpc]: mockRpc,
+  [OrganizeImportsExecute]: executeOrganizeImports,
+  [ReferenceExecuteFileReferenceProvider]: executefileReferenceProvider,
+  [ReferenceExecuteReferenceProvider]: executeReferenceProvider,
+  [SelectionExecuteSelectionProvider]: executeSelectionProvider,
+  [SourceControlAcceptInput]: acceptInput,
+  [SourceControlAdd]: add,
+  [SourceControlDiscard]: discard,
+  [SourceControlGetChangedFiles]: getChangedFiles,
+  [SourceControlGetEnabledProviderIds]: getEnabledProviderIds,
+  [SourceControlGetFileBefore]: getFileBefore,
+  [SourceControlGetGroups]: getGroups,
+  [StatusBarGetStatusBarItems]: getStatusBarItems,
+  [StatusBarRegisterChangeListener]: registerChangeListener,
+  [TabCompletionExecuteTabCompletionProvider]: executeTabCompletionProvider,
+  [TextDocumentSetLanguageId]: setLanguageId,
+  [TextDocumentSyncFull]: syncFull,
+  [TextDocumentSyncIncremental]: syncIncremental,
+  [TextSearchExecuteTextSearchProvider]: executeTextSearchProvider,
+  [TypeDefinitionExecuteTypeDefinitionProvider]: executeTypeDefinitionProvider,
+  [WorkspaceSetPath]: setWorkspacePath
+};
+
 const handleError = async error => {
   console.error(error);
 };
@@ -2206,6 +3392,18 @@ const handleUnhandledError = async event => {
 };
 
 const handleContentSecurityPolicyViolation = event => {
+  const {
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
+  } = event;
+  addError({
+    violatedDirective,
+    sourceFile,
+    lineNumber,
+    columnNumber
+  });
 };
 
 const listen = async ({
@@ -2236,8 +3434,7 @@ const main = async () => {
     self.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
   }
   globalThis.vscode = api;
-  // @ts-ignore
-  undefined.getFn = undefined;
+  register(commandMap);
   const ipc = await listen({
     method: Auto()
   });
@@ -2435,7 +3632,7 @@ const create$2 = async ({
     port1,
     port2
   } = getPortTuple();
-  await invokeAndTransfer([port1], 'IpcParent.create', {
+  await invokeAndTransfer('IpcParent.create', {
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
     url,
     name,