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

package/dist/extensionHostWorkerMain.js

@@ -4,13 +4,13 @@ const Function = 3;
 const Variable = 4;
 const Keyword = 5;
 const Folder = 6;
-const File$2 = 7;
+const File$1 = 7;
 const Field = 8;
 
 const EditorCompletionType = {
   __proto__: null,
   Field,
-  File: File$2,
+  File: File$1,
   Folder,
   Function,
   Keyword,
@@ -36,9 +36,6 @@ let AssertionError$1 = class AssertionError extends Error {
     this.name = 'AssertionError';
   }
 };
-
-// TODO consider using an assertion library like https://github.com/alexreardon/tiny-invariant, https://github.com/tj/better-assert
-
 const getType$3 = value => {
   switch (typeof value) {
     case 'number':
@@ -67,18 +64,6 @@ 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') {
@@ -92,7 +77,7 @@ const fn = value => {
   }
 };
 
-const state$b = {
+const state$a = {
   /** @type{any[]} */
   onDidOpenEditorListeners: [],
   /** @type{any[]} */
@@ -103,226 +88,18 @@ const state$b = {
   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$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;
+  return state$a.textDocuments[textDocumentId];
 };
 
-// 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;
 };
-const getText$1 = textDocument => {
+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';
 
@@ -334,32 +111,38 @@ class NoProviderFoundError extends Error {
   }
 }
 
-const stringifyError = error => {
-  const errorPrefixes = ['Error: ', 'VError: '];
-  const stringifiedError = `${error}`;
-  for (const errorPrefix of errorPrefixes) {
-    if (stringifiedError.startsWith(errorPrefix)) {
-      return stringifiedError.slice(errorPrefix.length);
-    }
+const normalizeLine$1 = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice(`Error: `.length);
   }
-  return stringifiedError;
+  if (line.startsWith('VError: ')) {
+    return line.slice(`VError: `.length);
+  }
+  return line;
 };
 const getCombinedMessage$1 = (error, message) => {
-  const stringifiedError = stringifyError(error);
+  const stringifiedError = normalizeLine$1(`${error}`);
   if (message) {
     return `${message}: ${stringifiedError}`;
   }
-  return `${stringifiedError}`;
+  return stringifiedError;
+};
+const NewLine$3 = '\n';
+const getNewLineIndex$2 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
 };
 const mergeStacks$1 = (parent, child) => {
   if (!child) {
     return parent;
   }
-  const parentNewLineIndex = parent.indexOf('\n');
-  const childNewLineIndex = child.indexOf('\n');
+  const parentNewLineIndex = getNewLineIndex$2(parent);
+  const childNewLineIndex = getNewLineIndex$2(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
   const parentFirstLine = parent.slice(0, parentNewLineIndex);
   const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = child.slice(0, childNewLineIndex);
+  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
   if (parentFirstLine.includes(childFirstLine)) {
     return parentFirstLine + childRest;
   }
@@ -377,6 +160,10 @@ let VError$1 = class VError extends Error {
       // @ts-ignore
       this.codeFrame = error.codeFrame;
     }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
   }
 };
 
@@ -505,17 +292,17 @@ const improveValidationError = (name, validationError) => {
   const post = improveValidationErrorPostMessage(validationError, camelCaseName);
   return pre + ': ' + post;
 };
-let NonError$1 = class NonError extends Error {
+class NonError extends Error {
   name = 'NonError';
   constructor(message) {
     super(message);
   }
-};
+}
 
 // ensureError based on https://github.com/sindresorhus/ensure-error/blob/main/index.ts (License MIT)
-const ensureError$1 = input => {
+const ensureError = input => {
   if (!(input instanceof Error)) {
-    return new NonError$1(input);
+    return new NonError(input);
   }
   return input;
 };
@@ -550,7 +337,7 @@ const registerMethod = ({
       }
       return result;
     } catch (error) {
-      const actualError = ensureError$1(error);
+      const actualError = ensureError(error);
       const spacedOutName = spaceOut(name);
       if (actualError && actualError.message) {
         if (actualError.message === 'provider[methodName] is not a function') {
@@ -565,7 +352,7 @@ const registerMethod = ({
     }
   };
 };
-const create$a = ({
+const create$8 = ({
   name,
   resultShape,
   executeKey = '',
@@ -609,15 +396,15 @@ const create$a = ({
 
 const Array$1 = 'array';
 const Boolean = 'boolean';
-const Number$1 = 'number';
+const Number = 'number';
 const Object$1 = 'object';
-const String$1 = 'string';
+const String = 'string';
 
 const {
   registerBraceCompletionProvider,
   executeBraceCompletionProvider,
   reset: reset$9
-} = create$a({
+} = create$8({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -627,7 +414,7 @@ const {
 const {
   registerClosingTagProvider,
   executeClosingTagProvider
-} = create$a({
+} = create$8({
   name: 'ClosingTag',
   returnUndefinedWhenNoProviderFound: true,
   resultShape: {
@@ -639,7 +426,7 @@ const {
 const {
   registerCodeActionProvider,
   executeCodeActionProvider
-} = create$a({
+} = create$8({
   name: 'CodeAction',
   resultShape: {
     type: Array$1,
@@ -648,28 +435,8 @@ const {
     }
   }
 });
-const isOrganizeImports = action => {
-  return action.kind === 'source.organizeImports';
-};
-
-// 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 = {
+const state$9 = {
   commands: Object.create(null)
 };
 const getCommandDisplay = command => {
@@ -692,10 +459,10 @@ const registerCommand = command => {
     if (!command.execute) {
       throw new Error('command is missing execute function');
     }
-    if (command.id in state$a.commands) {
+    if (command.id in state$9.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$a.commands[command.id] = command;
+    state$9.commands[command.id] = command;
   } catch (error) {
     const commandDisplayId = getCommandDisplay(command);
     throw new VError$1(error, `Failed to register command${commandDisplayId}`);
@@ -703,7 +470,7 @@ const registerCommand = command => {
 };
 const executeCommand = async (id, ...args) => {
   try {
-    const command = state$a.commands[id];
+    const command = state$9.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -722,7 +489,7 @@ const {
   registerCompletionProvider,
   executeCompletionProvider,
   executeresolveCompletionItemProvider
-} = create$a({
+} = create$8({
   name: 'Completion',
   resultShape: {
     type: Array$1,
@@ -742,24 +509,14 @@ const {
   }]
 });
 
-const state$9 = {
+const state$8 = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$9.configuration[key] ?? '';
-};
-const setConfigurations = preferences => {
-  state$9.configuration = preferences;
+  return state$8.configuration[key] ?? '';
 };
 
-const Two$1 = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two$1,
-    method,
-    params
-  };
-};
+const Two = '2.0';
 class AssertionError extends Error {
   constructor(message) {
     super(message);
@@ -806,11 +563,11 @@ const get$2 = id => {
 const remove = id => {
   delete state$1$1.callbacks[id];
 };
-const state$8 = {
+const state$7 = {
   id: 0
 };
 const create$3$1 = () => {
-  return ++state$8.id;
+  return ++state$7.id;
 };
 const warn = (...args) => {
   console.warn(...args);
@@ -857,7 +614,7 @@ const create$2$1 = (method, params) => {
     promise
   } = registerPromise();
   const message = {
-    jsonrpc: Two$1,
+    jsonrpc: Two,
     method,
     params,
     id
@@ -867,12 +624,12 @@ const create$2$1 = (method, params) => {
     promise
   };
 };
-let JsonRpcError$1 = class JsonRpcError extends Error {
+class JsonRpcError extends Error {
   constructor(message) {
     super(message);
     this.name = 'JsonRpcError';
   }
-};
+}
 const NewLine$2 = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
@@ -928,21 +685,21 @@ const getParentStack = error => {
   }
   return parentStack;
 };
-const joinLines$2 = lines => {
+const joinLines$1 = lines => {
   return lines.join(NewLine$2);
 };
-const MethodNotFound$1 = -32601;
+const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines$2 = lines => {
+const splitLines$1 = lines => {
   return lines.split(NewLine$2);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines$2(splitLines$2(new Error().stack || '').slice(1));
-  if (error && error.code && error.code === MethodNotFound$1) {
-    const restoredError = new JsonRpcError$1(error.message);
+  const currentStack = joinLines$1(splitLines$1(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$2 + currentStack;
     return restoredError;
@@ -996,7 +753,7 @@ const unwrapJsonRpcResult = responseMessage => {
   if ('result' in responseMessage) {
     return responseMessage.result;
   }
-  throw new JsonRpcError$1('unexpected response message');
+  throw new JsonRpcError('unexpected response message');
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getType = prettyError => {
@@ -1011,7 +768,7 @@ const getType = prettyError => {
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
-      code: MethodNotFound$1,
+      code: MethodNotFound,
       message: error.message,
       data: error.stack
     };
@@ -1030,34 +787,34 @@ const getErrorProperty = (error, prettyError) => {
 };
 const create$1$1 = (message, error) => {
   return {
-    jsonrpc: Two$1,
+    jsonrpc: Two,
     id: message.id,
     error
   };
 };
-const getErrorResponse$1 = (message, error, preparePrettyError, logError) => {
+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 create$9 = (message, result) => {
+const create$7 = (message, result) => {
   return {
-    jsonrpc: Two$1,
+    jsonrpc: Two,
     id: message.id,
     result: result ?? null
   };
 };
-const getSuccessResponse$1 = (message, result) => {
+const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$7(message, resultProperty);
 };
-const getResponse$1 = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+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$1(message, result);
+    return getSuccessResponse(message, result);
   } catch (error) {
-    return getErrorResponse$1(message, error, preparePrettyError, logError);
+    return getErrorResponse(message, error, preparePrettyError, logError);
   }
 };
 const defaultPreparePrettyError = error => {
@@ -1070,7 +827,7 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage$1 = async (...args) => {
+const handleJsonRpcMessage = async (...args) => {
   let message;
   let ipc;
   let execute;
@@ -1098,11 +855,11 @@ const handleJsonRpcMessage$1 = async (...args) => {
   }
   if ('id' in message) {
     if ('method' in message) {
-      const response = await getResponse$1(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse$1(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
@@ -1111,14 +868,10 @@ const handleJsonRpcMessage$1 = async (...args) => {
     return;
   }
   if ('method' in message) {
-    await getResponse$1(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
     return;
   }
-  throw new JsonRpcError$1('unexpected message');
-};
-const send$1 = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
+  throw new JsonRpcError('unexpected message');
 };
 const invoke$1 = async (ipc, method, ...params) => {
   const {
@@ -1141,54 +894,59 @@ const invokeAndTransfer$1 = async (ipc, method, ...params) => {
   return result;
 };
 
-const state$7 = {
-  getFn() {}
-};
+const processName = `extension host worker`;
+
+class CommandNotFoundError extends Error {
+  constructor(id) {
+    super(`Command "${id}" not found (${processName})`);
+    this.name = 'CommandNotFoundError';
+    // @ts-ignore
+    this.code = E_COMMAND_NOT_FOUND$1;
+  }
+}
+
+const state$6 = {};
 const execute = (method, ...params) => {
   // @ts-ignore
-  const fn = state$7.getFn(method);
+  const fn = state$6[method];
   // @ts-ignore
   if (!fn) {
-    throw new Error(`command not found ${method}`);
+    throw new CommandNotFoundError(method);
   }
   // @ts-ignore
   return fn(...params);
 };
 
-const requiresSocket = () => {
+const requiresSocket$1 = () => {
   return false;
 };
-const preparePrettyError = error => {
+const preparePrettyError$1 = error => {
   return error;
 };
 const logError$1 = error => {
   // handled by renderer worker
 };
 const handleMessage = event => {
-  return handleJsonRpcMessage$1(event.target, event.data, execute, resolve, preparePrettyError, logError$1, requiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, execute, resolve, preparePrettyError$1, logError$1, requiresSocket$1);
 };
 
 const handleIpc = ipc => {
   ipc.addEventListener('message', handleMessage);
 };
 
-const state$6 = {
+const state$5 = {
   /**
    * @type {any}
    */
   ipc: undefined
 };
 const get$1 = () => {
-  return state$6.ipc;
+  return state$5.ipc;
 };
 const set$1 = ipc => {
-  state$6.ipc = ipc;
+  state$5.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);
@@ -1202,146 +960,34 @@ const listen$2 = ipc => {
   set$1(ipc);
 };
 
-const state$5 = {
+const state$4 = {
   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$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');
-  }
+  state$4.debugProviderMap[debugProvider.id] = debugProvider;
 };
 
 const {
   registerDefinitionProvider,
   executeDefinitionProvider,
   reset: reset$8
-} = create$a({
+} = create$8({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
     type: Object$1,
     properties: {
       uri: {
-        type: String$1
+        type: String
       },
       startOffset: {
-        type: Number$1
+        type: Number
       },
       endOffset: {
-        type: Number$1
+        type: Number
       }
     }
   }
@@ -1350,7 +996,7 @@ const {
 const {
   registerDiagnosticProvider,
   executeDiagnosticProvider
-} = create$a({
+} = create$8({
   name: 'Diagnostic',
   resultShape: {
     type: Array$1,
@@ -1372,38 +1018,14 @@ const exec = async (command, args, options) => {
   throw new DepecratedError(`vscode.exec is deprecated, use createNodeRpc instead`);
 };
 
-const state$4 = {
+const state$3 = {
   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$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');
-  }
+  state$3.fileSystemProviderMap[fileSystemProvider.id] = fileSystemProvider;
 };
 const readFileExternal = async path => {
   // TODO when file is local,
@@ -1415,101 +1037,16 @@ 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);
 };
@@ -1518,7 +1055,7 @@ const {
   registerFormattingProvider,
   executeFormattingProvider,
   reset: reset$7
-} = create$a({
+} = create$8({
   name: 'Formatting',
   executeKey: 'format',
   resultShape: {
@@ -1528,13 +1065,13 @@ const {
       type: Object$1,
       properties: {
         startOffset: {
-          type: Number$1
+          type: Number
         },
         endOffset: {
-          type: Number$1
+          type: Number
         },
         inserted: {
-          type: String$1
+          type: String
         }
       }
     }
@@ -1580,7 +1117,7 @@ const {
   registerHoverProvider,
   executeHoverProvider,
   reset: reset$6
-} = create$a({
+} = create$8({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -1593,7 +1130,7 @@ const {
   registerImplementationProvider,
   executeImplementationProvider,
   reset: reset$5
-} = create$a({
+} = create$8({
   name: 'Implementation',
   resultShape: {
     type: Array$1,
@@ -1620,7 +1157,7 @@ const getModule$3 = method => {
   }
 };
 
-const create$8 = async ({
+const create$6 = async ({
   method,
   ...options
 }) => {
@@ -1647,7 +1184,7 @@ const getModule$2 = method => {
   }
 };
 
-const create$7 = async ({
+const create$5 = async ({
   method,
   ...options
 }) => {
@@ -1668,12 +1205,12 @@ const createNodeRpc = async ({
   try {
     string(path);
     fn(execute);
-    const ipc = await create$8({
+    const ipc = await create$6({
       method: ElectronMessagePort,
       type: 'extension-host-helper-process',
       name
     });
-    const rpc = await create$7({
+    const rpc = await create$5({
       ipc,
       method: JsonRpc,
       execute
@@ -1707,7 +1244,7 @@ const {
   executeReferenceProvider,
   executefileReferenceProvider,
   reset: reset$4
-} = create$a({
+} = create$8({
   name: 'Reference',
   resultShape: {
     type: Array$1,
@@ -1734,7 +1271,7 @@ const {
   executeRenameProvider,
   executeprepareRenameProvider,
   reset: reset$3
-} = create$a({
+} = create$8({
   name: 'Rename',
   resultShape: {
     type: Object$1,
@@ -1753,9 +1290,6 @@ const {
 });
 
 const rpcs = Object.create(null);
-const add$1 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
 const get = id => {
   return rpcs[id];
 };
@@ -1774,12 +1308,12 @@ const createRpcWithId = async ({
   if (!info) {
     throw new Error(`rpc with id ${id} not found`);
   }
-  const ipc = await create$8({
+  const ipc = await create$6({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url: extensionHostSubWorkerUrl,
     name: info.name
   });
-  const rpc = await create$7({
+  const rpc = await create$5({
     ipc,
     method: JsonRpc,
     execute
@@ -1820,12 +1354,12 @@ const createRpc = async ({
     if (contentSecurityPolicy) {
       await set(url, contentSecurityPolicy);
     }
-    const ipc = await create$8({
+    const ipc = await create$6({
       method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
       url: extensionHostSubWorkerUrl,
       name
     });
-    const rpc = await create$7({
+    const rpc = await create$5({
       ipc,
       method: JsonRpc,
       execute
@@ -1841,7 +1375,7 @@ const {
   registerSelectionProvider,
   executeSelectionProvider,
   reset: reset$2
-} = create$a({
+} = create$8({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
@@ -1852,104 +1386,18 @@ const {
   }
 });
 
-const state$3 = {
+const state$2 = {
   providers: Object.create(null)
 };
 const registerSourceControlProvider = 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;
+  state$2.providers[provider.id] = provider;
 };
 
 const {
   registerTabCompletionProvider,
   executeTabCompletionProvider,
   reset: reset$1
-} = create$a({
+} = create$8({
   name: 'TabCompletion',
   resultShape: {
     type: Object$1,
@@ -1957,7 +1405,7 @@ const {
   }
 });
 
-const state$2 = {
+const state$1 = {
   textSearchProviders: Object.create(null)
 };
 const registerTextSearchProvider = textSearchProvider => {
@@ -1968,14 +1416,14 @@ const registerTextSearchProvider = textSearchProvider => {
     if (!textSearchProvider.scheme) {
       throw new Error('textSearchProvider is missing scheme');
     }
-    state$2.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+    state$1.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$2.textSearchProviders[scheme];
+    const textSearchProvider = state$1.textSearchProviders[scheme];
     if (!textSearchProvider) {
       throw new Error(`no text search provider for ${scheme} found`);
     }
@@ -1990,20 +1438,20 @@ const {
   registerTypeDefinitionProvider,
   executeTypeDefinitionProvider,
   reset
-} = create$a({
+} = create$8({
   name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
     type: Object$1,
     properties: {
       uri: {
-        type: String$1
+        type: String
       },
       startOffset: {
-        type: Number$1
+        type: Number
       },
       endOffset: {
-        type: Number$1
+        type: Number
       }
     }
   }
@@ -2017,7 +1465,7 @@ const createWorker = async ({
   string(method);
   string(url);
   string(name);
-  const ipc = create$8({
+  const ipc = create$6({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url,
     name
@@ -2025,14 +1473,11 @@ const createWorker = async ({
   return ipc;
 };
 
-const state$1 = {
+const state = {
   workspacePath: ''
 };
-const setWorkspacePath = path => {
-  state$1.workspacePath = path;
-};
 const getWorkspaceFolder = path => {
-  return state$1.workspacePath;
+  return state.workspacePath;
 };
 
 const RE_PROTOCOL = /^([a-z\-]+):\/\//;
@@ -2162,12 +1607,12 @@ class FormattingError extends Error {
   }
 }
 
-const File$1 = 1;
+const File = 1;
 const Match = 2;
 
 const TextSearchResultType = {
   __proto__: null,
-  File: File$1,
+  File,
   Match
 };
 
@@ -2247,7 +1692,7 @@ const api = {
   registerTabCompletionProvider: registerTabCompletionProvider,
   executeTabCompletionProvider: executeTabCompletionProvider,
   // Text Document
-  getTextFromTextDocument: getText$1,
+  getTextFromTextDocument: getText,
   // Text Search
   registerTextSearchProvider: registerTextSearchProvider,
   executeTextSearchProvider: executeTextSearchProvider,
@@ -2265,578 +1710,18 @@ const api = {
   getWorkspaceFolder: getWorkspaceFolder
 };
 
-const processName = `extension host worker`;
-
-class CommandNotFoundError extends Error {
-  constructor(id) {
-    super(`Command "${id}" not found (${processName})`);
-    this.name = 'CommandNotFoundError';
+const getAssetDir = () => {
+  // @ts-ignore
+  if (typeof ASSET_DIR !== 'undefined') {
     // @ts-ignore
-    this.code = E_COMMAND_NOT_FOUND$1;
+    return ASSET_DIR;
   }
-}
-
-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$6 = () => {
-  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') {
-    // @ts-ignore
-    return ASSET_DIR;
-  }
-  if (platform === Electron) {
-    return '../../../../..';
-  }
-  return '';
-};
-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$6();
-    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
+  if (platform === Electron) {
+    return '../../../../..';
+  }
+  return '';
 };
+getAssetDir();
 
 const MessagePort$1 = 1;
 const ModuleWorker = 2;
@@ -2968,17 +1853,17 @@ const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
 const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
 const NewLine$1 = '\n';
-const joinLines$1 = lines => {
+const joinLines = lines => {
   return lines.join(NewLine$1);
 };
-const splitLines$1 = lines => {
+const splitLines = lines => {
   return lines.split(NewLine$1);
 };
 const isModuleNotFoundMessage = line => {
   return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
 const getModuleNotFoundError = stderr => {
-  const lines = splitLines$1(stderr);
+  const lines = splitLines(stderr);
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
@@ -3002,7 +1887,7 @@ const isMessageCodeBlockEndIndex = line => {
   return RE_MESSAGE_CODE_BLOCK_END.test(line);
 };
 const getMessageCodeBlock = stderr => {
-  const lines = splitLines$1(stderr);
+  const lines = splitLines(stderr);
   const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
   const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
   const relevantLines = lines.slice(startIndex, endIndex);
@@ -3041,7 +1926,7 @@ const getDetails = lines => {
   const index = lines.findIndex(isNormalStackLine);
   if (index === -1) {
     return {
-      actualMessage: joinLines$1(lines),
+      actualMessage: joinLines(lines),
       rest: []
     };
   }
@@ -3066,7 +1951,7 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
   if (isModuleNotFoundError(stderr)) {
     return getModuleNotFoundError(stderr);
   }
-  const lines = splitLines$1(stderr);
+  const lines = splitLines(stderr);
   const {
     actualMessage,
     rest
@@ -3292,971 +2177,35 @@ const getModule$1 = method => {
   }
 };
 
-const handleMessagePort = port => {
-  const module = getModule$1(MessagePort$1);
-  const ipc = module.wrap(port);
-  handleIpc(ipc);
-  ipc.send('ready');
+const handleError = async error => {
+  console.error(error);
 };
 
-const getFn = method => {
-  switch (method) {
-    case ExtensionActivate:
-      return activate;
-    case ReferenceExecuteReferenceProvider:
-      return executeReferenceProvider;
-    case ReferenceExecuteFileReferenceProvider:
-      return executefileReferenceProvider;
-    case CompletionExecute:
-      return executeCompletionProvider;
-    case CompletionResolveExecute:
-      return executeresolveCompletionItemProvider;
-    case TextDocumentSyncFull:
-      return syncFull;
-    case TextDocumentSetLanguageId:
-      return setLanguageId;
-    case TypeDefinitionExecuteTypeDefinitionProvider:
-      return executeTypeDefinitionProvider;
-    case TabCompletionExecuteTabCompletionProvider:
-      return executeTabCompletionProvider;
-    case BraceCompletionExecuteBraceCompletionProvider:
-      return executeBraceCompletionProvider;
-    case TextDocumentSyncIncremental:
-      return syncIncremental;
-    case TextSearchExecuteTextSearchProvider:
-      return executeTextSearchProvider;
-    case CommandExecute:
-      return executeCommand;
-    case DiagnosticExecuteDiagnosticProvider:
-      return executeDiagnosticProvider;
-    case WorkspaceSetPath:
-      return setWorkspacePath;
-    case DefinitionExecuteDefinitionProvider:
-      return executeDefinitionProvider;
-    case SourceControlGetChangedFiles:
-      return getChangedFiles;
-    case SourceControlAcceptInput:
-      return acceptInput;
-    case FormattingExecuteFormmattingProvider:
-      return executeFormattingProvider;
-    case SourceControlGetFileBefore:
-      return getFileBefore;
-    case MockExec:
-      return mockExec;
-    case MockRpc:
-      return mockRpc;
-    case FileSystemReadFile:
-      return readFile;
-    case FileSystemReadDirWithFileTypes:
-      return readDirWithFileTypes;
-    case FileSystemWriteFile:
-      return writeFile;
-    case FileSystemGetPathSeparator:
-      return getPathSeparator;
-    case SourceControlAdd:
-      return add;
-    case SourceControlDiscard:
-      return discard;
-    case SourceControlGetEnabledProviderIds:
-      return getEnabledProviderIds;
-    case SourceControlGetGroups:
-      return getGroups;
-    case 'ExtensionHostDebug.listProcesses':
-      return listProcesses;
-    case 'ExtensionHostDebug.pause':
-      return pause;
-    case 'ExtensionHostDebug.resume':
-      return resume;
-    case 'ExtensionHostDebug.setPauseOnException':
-      return setPauseOnException;
-    case 'ExtensionHostDebug.start':
-      return start;
-    case 'ExtensionHostDebug.stepOver':
-      return stepOver;
-    case 'ExtensionHostDebug.stepOut':
-      return stepOut;
-    case 'ExtensionHostDebug.stepInto':
-      return stepInto;
-    case 'ExtensionHostDebug.getProperties':
-      return getProperties;
-    case 'ExtensionHostDebug.evaluate':
-      return evaluate;
-    case 'ExtensionHostDebug.setPauseOnExceptions':
-      return setPauseOnExceptions;
-    case ClosingTagExecuteClosingTagProvider:
-      return executeClosingTagProvider;
-    case ImplementationExecuteImplementationProvider:
-      return executeImplementationProvider;
-    case HoverExecute:
-      return executeHoverProvider;
-    case StatusBarGetStatusBarItems:
-      return getStatusBarItems;
-    case StatusBarRegisterChangeListener:
-      return registerChangeListener;
-    case OrganizeImportsExecute:
-      return executeOrganizeImports;
-    case SelectionExecuteSelectionProvider:
-      return executeSelectionProvider;
-    case ConfigurationSetConfiguration:
-      return setConfigurations;
-    case 'HandleMessagePort.handleMessagePort':
-      return handleMessagePort;
-    case 'ExtensionHostWebView.create':
-      return createWebView;
-    case 'ExtensionHostWebView.dispose':
-      return disposeWebView;
-    case 'ExtensionHostWebView.load':
-      return load;
-    default:
-      throw new CommandNotFoundError(method);
+/**
+ * @param {PromiseRejectionEvent} event
+ */
+const handleUnhandledRejection = async event => {
+  try {
+    event.preventDefault();
+    await handleError(event.reason);
+  } catch {
+    console.error(event.reason);
   }
 };
 
-class HTTPError extends Error {
-  response;
-  request;
-  options;
-  constructor(response, request, options) {
-    const code = response.status || response.status === 0 ? response.status : '';
-    const title = response.statusText || '';
-    const status = `${code} ${title}`.trim();
-    const reason = status ? `status code ${status}` : 'an unknown error';
-    super(`Request failed with ${reason}: ${request.method} ${request.url}`);
-    this.name = 'HTTPError';
-    this.response = response;
-    this.request = request;
-    this.options = options;
-  }
-}
-
-class TimeoutError extends Error {
-  request;
-  constructor(request) {
-    super(`Request timed out: ${request.method} ${request.url}`);
-    this.name = 'TimeoutError';
-    this.request = request;
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-const isObject = value => value !== null && typeof value === 'object';
-
-const validateAndMerge = (...sources) => {
-  for (const source of sources) {
-    if ((!isObject(source) || Array.isArray(source)) && source !== undefined) {
-      throw new TypeError('The `options` argument must be an object');
-    }
+/**
+ * @param {ErrorEvent} event
+ */
+const handleUnhandledError = async event => {
+  try {
+    event.preventDefault();
+    await handleError(event.error);
+  } catch {
+    console.error(event.error);
   }
-  return deepMerge({}, ...sources);
 };
-const mergeHeaders = (source1 = {}, source2 = {}) => {
-  const result = new globalThis.Headers(source1);
-  const isHeadersInstance = source2 instanceof globalThis.Headers;
-  const source = new globalThis.Headers(source2);
-  for (const [key, value] of source.entries()) {
-    if (isHeadersInstance && value === 'undefined' || value === undefined) {
-      result.delete(key);
-    } else {
-      result.set(key, value);
-    }
-  }
-  return result;
-};
-function newHookValue(original, incoming, property) {
-  return Object.hasOwn(incoming, property) && incoming[property] === undefined ? [] : deepMerge(original[property] ?? [], incoming[property] ?? []);
-}
-const mergeHooks = (original = {}, incoming = {}) => ({
-  beforeRequest: newHookValue(original, incoming, 'beforeRequest'),
-  beforeRetry: newHookValue(original, incoming, 'beforeRetry'),
-  afterResponse: newHookValue(original, incoming, 'afterResponse'),
-  beforeError: newHookValue(original, incoming, 'beforeError')
-});
-// TODO: Make this strongly-typed (no `any`).
-const deepMerge = (...sources) => {
-  let returnValue = {};
-  let headers = {};
-  let hooks = {};
-  for (const source of sources) {
-    if (Array.isArray(source)) {
-      if (!Array.isArray(returnValue)) {
-        returnValue = [];
-      }
-      returnValue = [...returnValue, ...source];
-    } else if (isObject(source)) {
-      for (let [key, value] of Object.entries(source)) {
-        if (isObject(value) && key in returnValue) {
-          value = deepMerge(returnValue[key], value);
-        }
-        returnValue = {
-          ...returnValue,
-          [key]: value
-        };
-      }
-      if (isObject(source.hooks)) {
-        hooks = mergeHooks(hooks, source.hooks);
-        returnValue.hooks = hooks;
-      }
-      if (isObject(source.headers)) {
-        headers = mergeHeaders(headers, source.headers);
-        returnValue.headers = headers;
-      }
-    }
-  }
-  return returnValue;
-};
-
-const supportsRequestStreams = (() => {
-  let duplexAccessed = false;
-  let hasContentType = false;
-  const supportsReadableStream = typeof globalThis.ReadableStream === 'function';
-  const supportsRequest = typeof globalThis.Request === 'function';
-  if (supportsReadableStream && supportsRequest) {
-    try {
-      hasContentType = new globalThis.Request('https://empty.invalid', {
-        body: new globalThis.ReadableStream(),
-        method: 'POST',
-        // @ts-expect-error - Types are outdated.
-        get duplex() {
-          duplexAccessed = true;
-          return 'half';
-        }
-      }).headers.has('Content-Type');
-    } catch (error) {
-      // QQBrowser on iOS throws "unsupported BodyInit type" error (see issue #581)
-      if (error instanceof Error && error.message === 'unsupported BodyInit type') {
-        return false;
-      }
-      throw error;
-    }
-  }
-  return duplexAccessed && !hasContentType;
-})();
-const supportsAbortController = typeof globalThis.AbortController === 'function';
-const supportsResponseStreams = typeof globalThis.ReadableStream === 'function';
-const supportsFormData = typeof globalThis.FormData === 'function';
-const requestMethods = ['get', 'post', 'put', 'patch', 'head', 'delete'];
-const responseTypes = {
-  json: 'application/json',
-  text: 'text/*',
-  formData: 'multipart/form-data',
-  arrayBuffer: '*/*',
-  blob: '*/*'
-};
-// The maximum value of a 32bit int (see issue #117)
-const maxSafeTimeout = 2_147_483_647;
-const stop = Symbol('stop');
-const kyOptionKeys = {
-  json: true,
-  parseJson: true,
-  stringifyJson: true,
-  searchParams: true,
-  prefixUrl: true,
-  retry: true,
-  timeout: true,
-  hooks: true,
-  throwHttpErrors: true,
-  onDownloadProgress: true,
-  fetch: true
-};
-const requestOptionsRegistry = {
-  method: true,
-  headers: true,
-  body: true,
-  mode: true,
-  credentials: true,
-  cache: true,
-  redirect: true,
-  referrer: true,
-  referrerPolicy: true,
-  integrity: true,
-  keepalive: true,
-  signal: true,
-  window: true,
-  dispatcher: true,
-  duplex: true,
-  priority: true
-};
-
-const normalizeRequestMethod = input => requestMethods.includes(input) ? input.toUpperCase() : input;
-const retryMethods = ['get', 'put', 'head', 'delete', 'options', 'trace'];
-const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
-const retryAfterStatusCodes = [413, 429, 503];
-const defaultRetryOptions = {
-  limit: 2,
-  methods: retryMethods,
-  statusCodes: retryStatusCodes,
-  afterStatusCodes: retryAfterStatusCodes,
-  maxRetryAfter: Number.POSITIVE_INFINITY,
-  backoffLimit: Number.POSITIVE_INFINITY,
-  delay: attemptCount => 0.3 * 2 ** (attemptCount - 1) * 1000
-};
-const normalizeRetryOptions = (retry = {}) => {
-  if (typeof retry === 'number') {
-    return {
-      ...defaultRetryOptions,
-      limit: retry
-    };
-  }
-  if (retry.methods && !Array.isArray(retry.methods)) {
-    throw new Error('retry.methods must be an array');
-  }
-  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
-    throw new Error('retry.statusCodes must be an array');
-  }
-  return {
-    ...defaultRetryOptions,
-    ...retry
-  };
-};
-
-// `Promise.race()` workaround (#91)
-async function timeout(request, init, abortController, options) {
-  return new Promise((resolve, reject) => {
-    const timeoutId = setTimeout(() => {
-      if (abortController) {
-        abortController.abort();
-      }
-      reject(new TimeoutError(request));
-    }, options.timeout);
-    void options.fetch(request, init).then(resolve).catch(reject).then(() => {
-      clearTimeout(timeoutId);
-    });
-  });
-}
-
-// https://github.com/sindresorhus/delay/tree/ab98ae8dfcb38e1593286c94d934e70d14a4e111
-async function delay(ms, {
-  signal
-}) {
-  return new Promise((resolve, reject) => {
-    if (signal) {
-      signal.throwIfAborted();
-      signal.addEventListener('abort', abortHandler, {
-        once: true
-      });
-    }
-    function abortHandler() {
-      clearTimeout(timeoutId);
-      reject(signal.reason);
-    }
-    const timeoutId = setTimeout(() => {
-      signal?.removeEventListener('abort', abortHandler);
-      resolve();
-    }, ms);
-  });
-}
-
-const findUnknownOptions = (request, options) => {
-  const unknownOptions = {};
-  for (const key in options) {
-    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
-      unknownOptions[key] = options[key];
-    }
-  }
-  return unknownOptions;
-};
-
-class Ky {
-  static create(input, options) {
-    const ky = new Ky(input, options);
-    const function_ = async () => {
-      if (typeof ky._options.timeout === 'number' && ky._options.timeout > maxSafeTimeout) {
-        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
-      }
-      // Delay the fetch so that body method shortcuts can set the Accept header
-      await Promise.resolve();
-      let response = await ky._fetch();
-      for (const hook of ky._options.hooks.afterResponse) {
-        // eslint-disable-next-line no-await-in-loop
-        const modifiedResponse = await hook(ky.request, ky._options, ky._decorateResponse(response.clone()));
-        if (modifiedResponse instanceof globalThis.Response) {
-          response = modifiedResponse;
-        }
-      }
-      ky._decorateResponse(response);
-      if (!response.ok && ky._options.throwHttpErrors) {
-        let error = new HTTPError(response, ky.request, ky._options);
-        for (const hook of ky._options.hooks.beforeError) {
-          // eslint-disable-next-line no-await-in-loop
-          error = await hook(error);
-        }
-        throw error;
-      }
-      // If `onDownloadProgress` is passed, it uses the stream API internally
-      /* istanbul ignore next */
-      if (ky._options.onDownloadProgress) {
-        if (typeof ky._options.onDownloadProgress !== 'function') {
-          throw new TypeError('The `onDownloadProgress` option must be a function');
-        }
-        if (!supportsResponseStreams) {
-          throw new Error('Streams are not supported in your environment. `ReadableStream` is missing.');
-        }
-        return ky._stream(response.clone(), ky._options.onDownloadProgress);
-      }
-      return response;
-    };
-    const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
-    const result = isRetriableMethod ? ky._retry(function_) : function_();
-    for (const [type, mimeType] of Object.entries(responseTypes)) {
-      result[type] = async () => {
-        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-        ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
-        const awaitedResult = await result;
-        const response = awaitedResult.clone();
-        if (type === 'json') {
-          if (response.status === 204) {
-            return '';
-          }
-          const arrayBuffer = await response.clone().arrayBuffer();
-          const responseSize = arrayBuffer.byteLength;
-          if (responseSize === 0) {
-            return '';
-          }
-          if (options.parseJson) {
-            return options.parseJson(await response.text());
-          }
-        }
-        return response[type]();
-      };
-    }
-    return result;
-  }
-  request;
-  abortController;
-  _retryCount = 0;
-  _input;
-  _options;
-  // eslint-disable-next-line complexity
-  constructor(input, options = {}) {
-    this._input = input;
-    this._options = {
-      ...options,
-      headers: mergeHeaders(this._input.headers, options.headers),
-      hooks: mergeHooks({
-        beforeRequest: [],
-        beforeRetry: [],
-        beforeError: [],
-        afterResponse: []
-      }, options.hooks),
-      method: normalizeRequestMethod(options.method ?? this._input.method),
-      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
-      prefixUrl: String(options.prefixUrl || ''),
-      retry: normalizeRetryOptions(options.retry),
-      throwHttpErrors: options.throwHttpErrors !== false,
-      timeout: options.timeout ?? 10_000,
-      fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
-    };
-    if (typeof this._input !== 'string' && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
-      throw new TypeError('`input` must be a string, URL, or Request');
-    }
-    if (this._options.prefixUrl && typeof this._input === 'string') {
-      if (this._input.startsWith('/')) {
-        throw new Error('`input` must not begin with a slash when using `prefixUrl`');
-      }
-      if (!this._options.prefixUrl.endsWith('/')) {
-        this._options.prefixUrl += '/';
-      }
-      this._input = this._options.prefixUrl + this._input;
-    }
-    if (supportsAbortController) {
-      this.abortController = new globalThis.AbortController();
-      const originalSignal = this._options.signal ?? this._input.signal;
-      originalSignal?.addEventListener('abort', () => {
-        this.abortController.abort(originalSignal.reason);
-      });
-      this._options.signal = this.abortController.signal;
-    }
-    if (supportsRequestStreams) {
-      // @ts-expect-error - Types are outdated.
-      this._options.duplex = 'half';
-    }
-    if (this._options.json !== undefined) {
-      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
-      this._options.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');
-    }
-    this.request = new globalThis.Request(this._input, this._options);
-    if (this._options.searchParams) {
-      // eslint-disable-next-line unicorn/prevent-abbreviations
-      const textSearchParams = typeof this._options.searchParams === 'string' ? this._options.searchParams.replace(/^\?/, '') : new URLSearchParams(this._options.searchParams).toString();
-      // eslint-disable-next-line unicorn/prevent-abbreviations
-      const searchParams = '?' + textSearchParams;
-      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-      // To provide correct form boundary, Content-Type header should be deleted each time when new Request instantiated from another one
-      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers['content-type'])) {
-        this.request.headers.delete('content-type');
-      }
-      // The spread of `this.request` is required as otherwise it misses the `duplex` option for some reason and throws.
-      this.request = new globalThis.Request(new globalThis.Request(url, {
-        ...this.request
-      }), this._options);
-    }
-  }
-  _calculateRetryDelay(error) {
-    this._retryCount++;
-    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
-      throw error;
-    }
-    if (error instanceof HTTPError) {
-      if (!this._options.retry.statusCodes.includes(error.response.status)) {
-        throw error;
-      }
-      const retryAfter = error.response.headers.get('Retry-After') ?? error.response.headers.get('RateLimit-Reset') ?? error.response.headers.get('X-RateLimit-Reset') // GitHub
-      ?? error.response.headers.get('X-Rate-Limit-Reset'); // Twitter
-      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
-        let after = Number(retryAfter) * 1000;
-        if (Number.isNaN(after)) {
-          after = Date.parse(retryAfter) - Date.now();
-        } else if (after >= Date.parse('2024-01-01')) {
-          // A large number is treated as a timestamp (fixed threshold protects against clock skew)
-          after -= Date.now();
-        }
-        const max = this._options.retry.maxRetryAfter ?? after;
-        return after < max ? after : max;
-      }
-      if (error.response.status === 413) {
-        throw error;
-      }
-    }
-    const retryDelay = this._options.retry.delay(this._retryCount);
-    return Math.min(this._options.retry.backoffLimit, retryDelay);
-  }
-  _decorateResponse(response) {
-    if (this._options.parseJson) {
-      response.json = async () => this._options.parseJson(await response.text());
-    }
-    return response;
-  }
-  async _retry(function_) {
-    try {
-      return await function_();
-    } catch (error) {
-      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-      if (this._retryCount < 1) {
-        throw error;
-      }
-      await delay(ms, {
-        signal: this._options.signal
-      });
-      for (const hook of this._options.hooks.beforeRetry) {
-        // eslint-disable-next-line no-await-in-loop
-        const hookResult = await hook({
-          request: this.request,
-          options: this._options,
-          error: error,
-          retryCount: this._retryCount
-        });
-        // If `stop` is returned from the hook, the retry process is stopped
-        if (hookResult === stop) {
-          return;
-        }
-      }
-      return this._retry(function_);
-    }
-  }
-  async _fetch() {
-    for (const hook of this._options.hooks.beforeRequest) {
-      // eslint-disable-next-line no-await-in-loop
-      const result = await hook(this.request, this._options);
-      if (result instanceof Request) {
-        this.request = result;
-        break;
-      }
-      if (result instanceof Response) {
-        return result;
-      }
-    }
-    const nonRequestOptions = findUnknownOptions(this.request, this._options);
-    // Cloning is done here to prepare in advance for retries
-    const mainRequest = this.request;
-    this.request = mainRequest.clone();
-    if (this._options.timeout === false) {
-      return this._options.fetch(mainRequest, nonRequestOptions);
-    }
-    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
-  }
-  /* istanbul ignore next */
-  _stream(response, onDownloadProgress) {
-    const totalBytes = Number(response.headers.get('content-length')) || 0;
-    let transferredBytes = 0;
-    if (response.status === 204) {
-      if (onDownloadProgress) {
-        onDownloadProgress({
-          percent: 1,
-          totalBytes,
-          transferredBytes
-        }, new Uint8Array());
-      }
-      return new globalThis.Response(null, {
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
-    }
-    return new globalThis.Response(new globalThis.ReadableStream({
-      async start(controller) {
-        const reader = response.body.getReader();
-        if (onDownloadProgress) {
-          onDownloadProgress({
-            percent: 0,
-            transferredBytes: 0,
-            totalBytes
-          }, new Uint8Array());
-        }
-        async function read() {
-          const {
-            done,
-            value
-          } = await reader.read();
-          if (done) {
-            controller.close();
-            return;
-          }
-          if (onDownloadProgress) {
-            transferredBytes += value.byteLength;
-            const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-            onDownloadProgress({
-              percent,
-              transferredBytes,
-              totalBytes
-            }, value);
-          }
-          controller.enqueue(value);
-          await read();
-        }
-        await read();
-      }
-    }), {
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers
-    });
-  }
-}
-
-/*! MIT License © Sindre Sorhus */
-const createInstance = defaults => {
-  // eslint-disable-next-line @typescript-eslint/promise-function-async
-  const ky = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
-  for (const method of requestMethods) {
-    // eslint-disable-next-line @typescript-eslint/promise-function-async
-    ky[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, {
-      method
-    }));
-  }
-  ky.create = newDefaults => createInstance(validateAndMerge(newDefaults));
-  ky.extend = newDefaults => {
-    if (typeof newDefaults === 'function') {
-      newDefaults = newDefaults(defaults ?? {});
-    }
-    return createInstance(validateAndMerge(defaults, newDefaults));
-  };
-  ky.stop = stop;
-  return ky;
-};
-const ky = createInstance();
-
-const getText = async (url, options = {}) => {
-  try {
-    return await ky(url, options).text();
-  } catch (error) {
-    if (error && error instanceof TypeError && error.message === 'Failed to fetch') {
-      throw new VError$1(error, `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`);
-    }
-    throw new VError$1(error, `Failed to request text from "${url}"`);
-  }
-};
-
-// based on https://github.com/babel/babel/blob/6be6e04f396f03feace4431f709564a8d842163a/packages/babel-code-frame/src/index.ts (License MIT)
-
-/**
- * RegExp to test for newlines in terminal.
- */
-
-const NEWLINE = /\n/;
-
-/**
- * Extract what lines should be marked and highlighted.
- */
-const getMarkerLines = (loc, source, opts) => {
-  const startLoc = {
-    column: 0,
-    line: -1,
-    ...loc.start
-  };
-  const endLoc = {
-    ...startLoc,
-    ...loc.end
-  };
-  const {
-    linesAbove = 2,
-    linesBelow = 3
-  } = opts || {};
-  const startLine = startLoc.line;
-  const startColumn = startLoc.column;
-  const endLine = endLoc.line;
-  const endColumn = endLoc.column;
-  let start = Math.max(startLine - (linesAbove + 1), 0);
-  let end = Math.min(source.length, endLine + linesBelow);
-  if (startLine === -1) {
-    start = 0;
-  }
-  if (endLine === -1) {
-    end = source.length;
-  }
-  const lineDiff = endLine - startLine;
-  const markerLines = {};
-  if (lineDiff) {
-    for (let i = 0; i <= lineDiff; i++) {
-      const lineNumber = i + startLine;
-      if (!startColumn) {
-        markerLines[lineNumber] = true;
-      } else if (i === 0) {
-        const sourceLength = source[lineNumber - 1].length;
-        markerLines[lineNumber] = [startColumn, sourceLength - startColumn + 1];
-      } else if (i === lineDiff) {
-        markerLines[lineNumber] = [0, endColumn];
-      } else {
-        const sourceLength = source[lineNumber - i].length;
-        markerLines[lineNumber] = [0, sourceLength];
-      }
-    }
-  } else if (startColumn === endColumn) {
-    if (startColumn) {
-      markerLines[startLine] = [startColumn, 0];
-    } else {
-      markerLines[startLine] = true;
-    }
-  } else {
-    markerLines[startLine] = [startColumn, endColumn - startColumn];
-  }
-  return {
-    start,
-    end,
-    markerLines
-  };
-};
-const create$5 = (rawLines, loc, opts = {}) => {
-  const lines = rawLines.split(NEWLINE);
-  const {
-    start,
-    end,
-    markerLines
-  } = getMarkerLines(loc, lines, opts);
-  const hasColumns = loc.start && typeof loc.start.column === 'number';
-  const numberMaxWidth = String(end).length;
-  let frame = rawLines.split(NEWLINE, end).slice(start, end).map((line, index) => {
-    const number = start + 1 + index;
-    const paddedNumber = ` ${number}`.slice(-numberMaxWidth);
-    const gutter = ` ${paddedNumber} |`;
-    const hasMarker = markerLines[number];
-    const lastMarkerLine = !markerLines[number + 1];
-    if (hasMarker) {
-      let markerLine = '';
-      if (Array.isArray(hasMarker)) {
-        const markerSpacing = line.slice(0, Math.max(hasMarker[0] - 1, 0)).replace(/[^\t]/g, ' ');
-        const numberOfMarkers = hasMarker[1] || 1;
-        markerLine = ['\n ', gutter.replace(/\d/g, ' '), ' ', markerSpacing, '^'.repeat(numberOfMarkers)].join('');
-
-        // @ts-ignore
-        if (lastMarkerLine && opts.message) {
-          // @ts-ignore
-          markerLine += ' ' + opts.message;
-        }
-      }
-      return ['>', gutter, line.length > 0 ? ` ${line}` : '', markerLine].join('');
-    }
-    return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`;
-  }).join('\n');
-
-  // @ts-ignore
-  if (opts.message && !hasColumns) {
-    // @ts-ignore
-    frame = `${' '.repeat(numberMaxWidth + 1)}${opts.message}\n${frame}`;
-  }
-  return frame;
-};
-
-const joinLines = lines => {
-  return lines.join('\n');
-};
-
-const splitLines = lines => {
-  return lines.split('\n');
-};
-
-const getErrorMessage = error => {
-  if (!error) {
-    return `Error: ${error}`;
-  }
-  let message = error.message;
-  while (error.cause) {
-    error = error.cause;
-    message += `: ${error}`;
-  }
-  return message;
-};
-const prepareErrorMessageWithCodeFrame = error => {
-  if (!error) {
-    return {
-      message: error,
-      stack: undefined,
-      codeFrame: undefined,
-      type: 'Error'
-    };
-  }
-  const message = getErrorMessage(error);
-  if (error.codeFrame) {
-    return {
-      message,
-      stack: error.stack,
-      codeFrame: error.codeFrame,
-      type: error.constructor.name
-    };
-  }
-  return {
-    message,
-    stack: error.originalStack,
-    codeFrame: error.originalCodeFrame,
-    category: error.category,
-    stderr: error.stderr
-  };
-};
-const RE_PATH_1 = /\((.*):(\d+):(\d+)\)$/;
-const RE_PATH_2 = /at (.*):(\d+):(\d+)$/;
-
-/**
- *
- * @param {readonly string[]} lines
- * @returns
- */
-const getFile = lines => {
-  for (const line of lines) {
-    if (RE_PATH_1.test(line) || RE_PATH_2.test(line)) {
-      return line;
-    }
-  }
-  return '';
-};
-const prepareErrorMessageWithoutCodeFrame = async error => {
-  try {
-    const lines = splitLines(error.stack);
-    const file = getFile(lines);
-    let match = file.match(RE_PATH_1);
-    if (!match) {
-      match = file.match(RE_PATH_2);
-    }
-    if (!match) {
-      return error;
-    }
-    const [_, path, line, column] = match;
-    const text = await getText(path);
-    const parsedLine = Number.parseInt(line);
-    const parsedColumn = Number.parseInt(column);
-    const codeFrame = create$5(text, {
-      start: {
-        line: parsedLine,
-        column: parsedColumn
-      },
-      end: {
-        line: parsedLine,
-        column: parsedColumn
-      }
-    });
-    const relevantStack = joinLines(lines.slice(1));
-    const message = getErrorMessage(error);
-    return {
-      message,
-      codeFrame,
-      stack: relevantStack,
-      type: error.constructor.name
-    };
-  } catch (otherError) {
-    console.warn('ErrorHandling Error');
-    console.warn(otherError);
-    return error;
-  }
-};
-const prepare = async error => {
-  if (error && error.message && error.codeFrame) {
-    return prepareErrorMessageWithCodeFrame(error);
-  }
-  if (error && error.stack) {
-    return prepareErrorMessageWithoutCodeFrame(error);
-  }
-  return error;
-};
-const print = error => {
-  if (error && error.type && error.message && error.codeFrame) {
-    return `${error.type}: ${error.message}\n\n${error.codeFrame}\n\n${error.stack}`;
-  }
-  if (error && error.message && error.codeFrame) {
-    return `${error.message}\n\n${error.codeFrame}\n\n${error.stack}`;
-  }
-  if (error && error.type && error.message) {
-    return `${error.type}: ${error.message}\n${error.stack}`;
-  }
-  if (error && error.stack) {
-    return `${error.stack}`;
-  }
-  if (error === null) {
-    return null;
-  }
-  return `${error}`;
-};
-
-const logError = async error => {
-  const prettyError = await prepare(error);
-  const prettyErrorString = print(prettyError);
-  console.error(prettyErrorString);
-  return prettyError;
-};
-const handleError = async error => {
-  try {
-    await logError(error);
-  } catch (otherError) {
-    console.warn('ErrorHandling error');
-    console.warn(otherError);
-    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 handleContentSecurityPolicyViolation = event => {
 };
 
 const listen = async ({
@@ -4288,7 +2237,7 @@ const main = async () => {
   }
   globalThis.vscode = api;
   // @ts-ignore
-  state$7.getFn = getFn;
+  undefined.getFn = undefined;
   const ipc = await listen({
     method: Auto()
   });
@@ -4306,17 +2255,11 @@ const withResolvers = () => {
    * @type {any}
    */
   let _resolve;
-  /**
-   * @type {any}
-   */
-  let _reject;
-  const promise = new Promise((resolve, reject) => {
+  const promise = new Promise(resolve => {
     _resolve = resolve;
-    _reject = reject;
   });
   return {
     resolve: _resolve,
-    reject: _reject,
     promise
   };
 };
@@ -4547,105 +2490,15 @@ const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
   wrap: wrap$1
 };
 
-const MethodNotFound = -32601;
-
-const Two = '2.0';
-
-class NonError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'NonError';
-  }
-}
-
-// ensureError based on https://github.com/sindresorhus/ensure-error/blob/main/index.ts (License MIT)
-const ensureError = input => {
-  if (!(input instanceof Error)) {
-    return new NonError(input);
-  }
-  return input;
-};
-
-const serializeError = error => {
-  error = ensureError(error);
-  return {
-    stack: error.stack,
-    message: error.message,
-    name: error.name,
-    type: error.constructor.name,
-    codeFrame: error.codeFrame || ''
-  };
-};
-
-const getErrorResponse = (message, error) => {
-  if (error && error instanceof CommandNotFoundError) {
-    return {
-      jsonrpc: Two,
-      id: message.id,
-      error: {
-        code: MethodNotFound,
-        message: error.message,
-        data: error.stack
-      }
-    };
-  }
-  const serializedError = serializeError(error);
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    error: {
-      codeFrame: serializedError.codeFrame,
-      message: serializedError.message,
-      stack: serializedError.stack,
-      name: serializedError.name,
-      type: serializedError.type
-    }
-  };
-};
-
-const getSuccessResponse = (message, result) => {
-  return {
-    jsonrpc: Two,
-    id: message.id,
-    result
-  };
+const preparePrettyError = error => {
+  return error;
 };
-
-const getResponse = async (message, execute) => {
-  try {
-    const result = await execute(message.method, ...message.params);
-    return getSuccessResponse(message, result);
-  } catch (error) {
-    return getErrorResponse(message, error);
-  }
+const logError = error => {
+  // handled by renderer worker
 };
-
-class JsonRpcError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'JsonRpcError';
-  }
-}
-
-const handleJsonRpcMessage = async (ipc, message, execute, resolve) => {
-  if ('id' in message) {
-    if ('method' in message) {
-      const response = await getResponse(message, execute);
-      try {
-        ipc.send(response);
-      } catch (error) {
-        await logError(error);
-        const errorResponse = getErrorResponse(message, error);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve(message.id, message);
-    return;
-  }
-  throw new JsonRpcError('unexpected message from renderer worker');
+const requiresSocket = () => {
+  return false;
 };
-
 const create$1 = ({
   ipc,
   execute
@@ -4653,7 +2506,7 @@ const create$1 = ({
   object(ipc);
   fn(execute);
   const handleMessage = async message => {
-    return handleJsonRpcMessage(ipc, message, execute, resolve);
+    return handleJsonRpcMessage(ipc, message, execute, resolve, preparePrettyError, logError, requiresSocket);
   };
   ipc.onmessage = handleMessage;
   return {