@lvce-editor/server 0.35.2 → 0.35.3

package/static/{24eca37 → 05f09be}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -36,10 +36,7 @@ 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$2 = value => {
+const getType$3 = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -62,31 +59,31 @@ const getType$2 = value => {
   }
 };
 const object = value => {
-  const type = getType$2(value);
+  const type = getType$3(value);
   if (type !== 'object') {
     throw new AssertionError$1('expected value to be of type object');
   }
 };
 const number$1 = value => {
-  const type = getType$2(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$2(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$2(value);
+  const type = getType$3(value);
   if (type !== 'string') {
     throw new AssertionError$1('expected value to be of type string');
   }
 };
 const fn = value => {
-  const type = getType$2(value);
+  const type = getType$3(value);
   if (type !== 'function') {
     throw new AssertionError$1('expected value to be of type function');
   }
@@ -310,7 +307,7 @@ const get$3 = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
 };
-const getText$1 = textDocument => {
+const getText = textDocument => {
   return textDocument.text;
 };
 const setLanguageId = (textDocumentId, languageId) => {
@@ -334,32 +331,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,10 +380,14 @@ let VError$1 = class VError extends Error {
       // @ts-ignore
       this.codeFrame = error.codeFrame;
     }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
   }
 };
 
-const getType$1 = value => {
+const getType$2 = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -411,7 +418,7 @@ const validateResultObject = (result, resultShape) => {
   for (const [key, value] of Object.entries(resultShape.properties)) {
     // @ts-ignore
     const expectedType = value.type;
-    const actualType = getType$1(result[key]);
+    const actualType = getType$2(result[key]);
     if (expectedType !== actualType) {
       return `item.${key} must be of type ${expectedType}`;
     }
@@ -420,7 +427,7 @@ const validateResultObject = (result, resultShape) => {
 };
 const validateResultArray = (result, resultShape) => {
   for (const item of result) {
-    const actualType = getType$1(item);
+    const actualType = getType$2(item);
     const expectedType = resultShape.items.type;
     if (actualType !== expectedType) {
       return `expected result to be of type ${expectedType} but was of type ${actualType}`;
@@ -441,7 +448,7 @@ const getPreviewString = item => {
   return `"${item}"`;
 };
 const getPreview = item => {
-  const type = getType$1(item);
+  const type = getType$2(item);
   switch (type) {
     case 'object':
       return getPreviewObject();
@@ -454,7 +461,7 @@ const getPreview = item => {
   }
 };
 const validate = (item, schema) => {
-  const actualType = getType$1(item);
+  const actualType = getType$2(item);
   const expectedType = schema.type;
   if (actualType !== expectedType) {
     if (schema.allowUndefined && (item === undefined || item === null)) {
@@ -505,17 +512,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 +557,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 +572,7 @@ const registerMethod = ({
     }
   };
 };
-const create$a = ({
+const create$9 = ({
   name,
   resultShape,
   executeKey = '',
@@ -609,15 +616,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$9({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -627,7 +634,7 @@ const {
 const {
   registerClosingTagProvider,
   executeClosingTagProvider
-} = create$a({
+} = create$9({
   name: 'ClosingTag',
   returnUndefinedWhenNoProviderFound: true,
   resultShape: {
@@ -639,7 +646,7 @@ const {
 const {
   registerCodeActionProvider,
   executeCodeActionProvider
-} = create$a({
+} = create$9({
   name: 'CodeAction',
   resultShape: {
     type: Array$1,
@@ -722,7 +729,7 @@ const {
   registerCompletionProvider,
   executeCompletionProvider,
   executeresolveCompletionItemProvider
-} = create$a({
+} = create$9({
   name: 'Completion',
   resultShape: {
     type: Array$1,
@@ -752,11 +759,10 @@ const setConfigurations = preferences => {
   state$9.configuration = preferences;
 };
 
-// @ts-nocheck
-const Two$1 = "2.0";
+const Two = '2.0';
 const create$4$1 = (method, params) => {
   return {
-    jsonrpc: Two$1,
+    jsonrpc: Two,
     method,
     params
   };
@@ -764,35 +770,35 @@ const create$4$1 = (method, params) => {
 class AssertionError extends Error {
   constructor(message) {
     super(message);
-    this.name = "AssertionError";
+    this.name = 'AssertionError';
   }
 }
-const getType = value => {
+const getType$1 = value => {
   switch (typeof value) {
-    case "number":
-      return "number";
-    case "function":
-      return "function";
-    case "string":
-      return "string";
-    case "object":
+    case 'number':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
       if (value === null) {
-        return "null";
+        return 'null';
       }
       if (Array.isArray(value)) {
-        return "array";
+        return 'array';
       }
-      return "object";
-    case "boolean":
-      return "boolean";
+      return 'object';
+    case 'boolean':
+      return 'boolean';
     default:
-      return "unknown";
+      return 'unknown';
   }
 };
 const number = value => {
-  const type = getType(value);
-  if (type !== "number") {
-    throw new AssertionError("expected value to be of type number");
+  const type = getType$1(value);
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number');
   }
 };
 const state$1$1 = {
@@ -817,9 +823,12 @@ const warn = (...args) => {
   console.warn(...args);
 };
 const withResolvers$2 = () => {
+  /**
+   * @type {any}
+   */
   let _resolve;
-  const promise = new Promise(resolve2 => {
-    _resolve = resolve2;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
   });
   return {
     resolve: _resolve,
@@ -829,10 +838,10 @@ const withResolvers$2 = () => {
 const registerPromise = () => {
   const id = create$3$1();
   const {
-    resolve: resolve2,
+    resolve,
     promise
   } = withResolvers$2();
-  set$2(id, resolve2);
+  set$2(id, resolve);
   return {
     id,
     promise
@@ -855,7 +864,7 @@ const create$2$1 = (method, params) => {
     promise
   } = registerPromise();
   const message = {
-    jsonrpc: Two$1,
+    jsonrpc: Two,
     method,
     params,
     id
@@ -865,17 +874,17 @@ 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";
+    this.name = 'JsonRpcError';
   }
-};
-const NewLine$2 = "\n";
-const DomException = "DOMException";
-const ReferenceError$1 = "ReferenceError";
-const SyntaxError$1 = "SyntaxError";
-const TypeError$1 = "TypeError";
+}
+const NewLine$2 = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
 const getErrorConstructor = (message, type) => {
   if (type) {
     switch (type) {
@@ -891,13 +900,13 @@ const getErrorConstructor = (message, type) => {
         return Error;
     }
   }
-  if (message.startsWith("TypeError: ")) {
+  if (message.startsWith('TypeError: ')) {
     return TypeError;
   }
-  if (message.startsWith("SyntaxError: ")) {
+  if (message.startsWith('SyntaxError: ')) {
     return SyntaxError;
   }
-  if (message.startsWith("ReferenceError: ")) {
+  if (message.startsWith('ReferenceError: ')) {
     return ReferenceError;
   }
   return Error;
@@ -909,38 +918,38 @@ const constructError = (message, type, name) => {
   }
   if (ErrorConstructor === Error) {
     const error = new Error(message);
-    if (name && name !== "VError") {
+    if (name && name !== 'VError') {
       error.name = name;
     }
     return error;
   }
   return new ErrorConstructor(message);
 };
-const getNewLineIndex$1 = (string, startIndex = void 0) => {
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
   return string.indexOf(NewLine$2, startIndex);
 };
 const getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || "";
-  if (parentStack.startsWith("    at")) {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
     parentStack = error.message + NewLine$2 + parentStack;
   }
   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;
@@ -949,59 +958,67 @@ const restoreJsonRpcError = error => {
     const restoredError = constructError(error.message, error.type, error.name);
     if (error.data) {
       if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ": " + error.message + NewLine$2 + error.data.stack + NewLine$2 + currentStack;
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$2 + error.data.stack + NewLine$2 + currentStack;
       } else if (error.data.stack) {
         restoredError.stack = error.data.stack;
       }
       if (error.data.codeFrame) {
+        // @ts-ignore
         restoredError.codeFrame = error.data.codeFrame;
       }
       if (error.data.code) {
+        // @ts-ignore
         restoredError.code = error.data.code;
       }
       if (error.data.type) {
+        // @ts-ignore
         restoredError.name = error.data.type;
       }
     } else {
       if (error.stack) {
-        const lowerStack = restoredError.stack || "";
+        const lowerStack = restoredError.stack || '';
+        // @ts-ignore
         const indexNewLine = getNewLineIndex$1(lowerStack);
         const parentStack = getParentStack(error);
+        // @ts-ignore
         restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
       }
       if (error.codeFrame) {
+        // @ts-ignore
         restoredError.codeFrame = error.codeFrame;
       }
     }
     return restoredError;
   }
-  if (typeof error === "string") {
+  if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
   }
   return new Error(`JsonRpc Error: ${error}`);
 };
 const unwrapJsonRpcResult = responseMessage => {
-  if ("error" in responseMessage) {
+  if ('error' in responseMessage) {
     const restoredError = restoreJsonRpcError(responseMessage.error);
     throw restoredError;
   }
-  if ("result" in responseMessage) {
+  if ('result' in responseMessage) {
     return responseMessage.result;
   }
-  throw new JsonRpcError$1("unexpected response message");
+  throw new JsonRpcError('unexpected response message');
 };
-const create$1$1 = (message, error) => {
-  return {
-    jsonrpc: Two$1,
-    id: message.id,
-    error
-  };
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
 };
-const E_COMMAND_NOT_FOUND = "E_COMMAND_NOT_FOUND";
 const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
-      code: MethodNotFound$1,
+      code: MethodNotFound,
       message: error.message,
       data: error.stack
     };
@@ -1012,51 +1029,61 @@ const getErrorProperty = (error, prettyError) => {
     data: {
       stack: prettyError.stack,
       codeFrame: prettyError.codeFrame,
-      type: prettyError.type,
-      code: prettyError.code
+      type: getType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
     }
   };
 };
-const getErrorResponse$1 = (message, error, preparePrettyError, logError) => {
+const create$1$1 = (message, error) => {
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error
+  };
+};
+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$8 = (message, result) => {
   return {
-    jsonrpc: Two$1,
+    jsonrpc: Two,
     id: message.id,
-    result: result != null ? result : null
+    result: result ?? null
   };
 };
-const getSuccessResponse$1 = (message, result) => {
-  const resultProperty = result != null ? result : null;
-  return create$9(message, resultProperty);
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$8(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 => {
   return error;
 };
-const defaultLogError = () => {};
+const defaultLogError = () => {
+  // ignore
+};
 const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage$1 = async (...args) => {
+const handleJsonRpcMessage = async (...args) => {
   let message;
   let ipc;
   let execute;
   let preparePrettyError;
   let logError;
-  let resolve2;
+  let resolve;
   let requiresSocket;
   if (args.length === 1) {
     const arg = args[0];
@@ -1066,35 +1093,35 @@ const handleJsonRpcMessage$1 = async (...args) => {
     preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
     logError = arg.logError || defaultLogError;
     requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve2 = arg.resolve || defaultResolve;
+    resolve = arg.resolve || defaultResolve;
   } else {
     ipc = args[0];
     message = args[1];
     execute = args[2];
-    resolve2 = args[3];
+    resolve = args[3];
     preparePrettyError = args[4];
     logError = args[5];
     requiresSocket = args[6];
   }
-  if ("id" in message) {
-    if ("method" in message) {
-      const response = await getResponse$1(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
       try {
         ipc.send(response);
       } catch (error) {
-        const errorResponse = getErrorResponse$1(message, error, preparePrettyError, logError);
+        const errorResponse = getErrorResponse(message, error, preparePrettyError, logError);
         ipc.send(errorResponse);
       }
       return;
     }
-    resolve2(message.id, message);
+    resolve(message.id, message);
     return;
   }
-  if ("method" in message) {
-    await getResponse$1(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
     return;
   }
-  throw new JsonRpcError$1("unexpected message");
+  throw new JsonRpcError('unexpected message');
 };
 const send$1 = (transport, method, ...params) => {
   const message = create$4$1(method, params);
@@ -1110,11 +1137,7 @@ const invoke$1 = async (ipc, method, ...params) => {
   const result = unwrapJsonRpcResult(responseMessage);
   return result;
 };
-const invokeAndTransfer$1 = async (ipc, handle, method, ...params) => {
-  if (typeof handle === "string") {
-    params = [method, ...params];
-    method = handle;
-  }
+const invokeAndTransfer$1 = async (ipc, method, ...params) => {
   const {
     message,
     promise
@@ -1125,31 +1148,43 @@ const invokeAndTransfer$1 = async (ipc, handle, 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$7 = {};
+const register = commandMap => {
+  Object.assign(state$7, commandMap);
 };
 const execute = (method, ...params) => {
   // @ts-ignore
-  const fn = state$7.getFn(method);
+  const fn = state$7[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 => {
@@ -1312,20 +1347,20 @@ const {
   registerDefinitionProvider,
   executeDefinitionProvider,
   reset: reset$8
-} = create$a({
+} = create$9({
   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
       }
     }
   }
@@ -1334,7 +1369,7 @@ const {
 const {
   registerDiagnosticProvider,
   executeDiagnosticProvider
-} = create$a({
+} = create$9({
   name: 'Diagnostic',
   resultShape: {
     type: Array$1,
@@ -1470,6 +1505,8 @@ const createWebView = async (providerId, port, uri, uid, origin) => {
   };
   port.onmessage = handlePortMessage;
   const rpc = {
+    uri,
+    provider,
     uid,
     origin,
     invoke(method, ...params) {
@@ -1483,7 +1520,10 @@ const createWebView = async (providerId, port, uri, uid, origin) => {
   };
   // TODO allow creating multiple webviews per provider
   setWebView(providerId, rpc);
-  provider.create(rpc, uri);
+};
+const load = async providerId => {
+  const rpc = getWebView(providerId);
+  await rpc.provider.create(rpc, rpc.uri);
 };
 const disposeWebView = id => {
   // TODO race condition
@@ -1497,7 +1537,7 @@ const {
   registerFormattingProvider,
   executeFormattingProvider,
   reset: reset$7
-} = create$a({
+} = create$9({
   name: 'Formatting',
   executeKey: 'format',
   resultShape: {
@@ -1507,13 +1547,13 @@ const {
       type: Object$1,
       properties: {
         startOffset: {
-          type: Number$1
+          type: Number
         },
         endOffset: {
-          type: Number$1
+          type: Number
         },
         inserted: {
-          type: String$1
+          type: String
         }
       }
     }
@@ -1559,7 +1599,7 @@ const {
   registerHoverProvider,
   executeHoverProvider,
   reset: reset$6
-} = create$a({
+} = create$9({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -1572,7 +1612,7 @@ const {
   registerImplementationProvider,
   executeImplementationProvider,
   reset: reset$5
-} = create$a({
+} = create$9({
   name: 'Implementation',
   resultShape: {
     type: Array$1,
@@ -1599,7 +1639,7 @@ const getModule$3 = method => {
   }
 };
 
-const create$8 = async ({
+const create$7 = async ({
   method,
   ...options
 }) => {
@@ -1626,7 +1666,7 @@ const getModule$2 = method => {
   }
 };
 
-const create$7 = async ({
+const create$6 = async ({
   method,
   ...options
 }) => {
@@ -1647,12 +1687,12 @@ const createNodeRpc = async ({
   try {
     string(path);
     fn(execute);
-    const ipc = await create$8({
+    const ipc = await create$7({
       method: ElectronMessagePort,
       type: 'extension-host-helper-process',
       name
     });
-    const rpc = await create$7({
+    const rpc = await create$6({
       ipc,
       method: JsonRpc,
       execute
@@ -1686,7 +1726,7 @@ const {
   executeReferenceProvider,
   executefileReferenceProvider,
   reset: reset$4
-} = create$a({
+} = create$9({
   name: 'Reference',
   resultShape: {
     type: Array$1,
@@ -1713,7 +1753,7 @@ const {
   executeRenameProvider,
   executeprepareRenameProvider,
   reset: reset$3
-} = create$a({
+} = create$9({
   name: 'Rename',
   resultShape: {
     type: Object$1,
@@ -1740,7 +1780,7 @@ const get = id => {
 };
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/24eca37/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/05f09be/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
@@ -1753,12 +1793,12 @@ const createRpcWithId = async ({
   if (!info) {
     throw new Error(`rpc with id ${id} not found`);
   }
-  const ipc = await create$8({
+  const ipc = await create$7({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url: extensionHostSubWorkerUrl,
     name: info.name
   });
-  const rpc = await create$7({
+  const rpc = await create$6({
     ipc,
     method: JsonRpc,
     execute
@@ -1799,12 +1839,12 @@ const createRpc = async ({
     if (contentSecurityPolicy) {
       await set(url, contentSecurityPolicy);
     }
-    const ipc = await create$8({
+    const ipc = await create$7({
       method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
       url: extensionHostSubWorkerUrl,
       name
     });
-    const rpc = await create$7({
+    const rpc = await create$6({
       ipc,
       method: JsonRpc,
       execute
@@ -1820,7 +1860,7 @@ const {
   registerSelectionProvider,
   executeSelectionProvider,
   reset: reset$2
-} = create$a({
+} = create$9({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
@@ -1928,7 +1968,7 @@ const {
   registerTabCompletionProvider,
   executeTabCompletionProvider,
   reset: reset$1
-} = create$a({
+} = create$9({
   name: 'TabCompletion',
   resultShape: {
     type: Object$1,
@@ -1969,20 +2009,20 @@ const {
   registerTypeDefinitionProvider,
   executeTypeDefinitionProvider,
   reset
-} = create$a({
+} = create$9({
   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
       }
     }
   }
@@ -1996,7 +2036,7 @@ const createWorker = async ({
   string(method);
   string(url);
   string(name);
-  const ipc = create$8({
+  const ipc = create$7({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
     url,
     name
@@ -2226,7 +2266,7 @@ const api = {
   registerTabCompletionProvider: registerTabCompletionProvider,
   executeTabCompletionProvider: executeTabCompletionProvider,
   // Text Document
-  getTextFromTextDocument: getText$1,
+  getTextFromTextDocument: getText,
   // Text Search
   registerTextSearchProvider: registerTextSearchProvider,
   executeTextSearchProvider: executeTextSearchProvider,
@@ -2244,17 +2284,6 @@ const api = {
   getWorkspaceFolder: getWorkspaceFolder
 };
 
-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 BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
 const ClosingTagExecuteClosingTagProvider = 'ExtensionHostClosingTag.executeClosingTagProvider';
 const CommandExecute = 'ExtensionHostCommand.executeCommand';
@@ -2294,7 +2323,7 @@ const WorkspaceSetPath = 'Workspace.setWorkspacePath';
 const SelectionExecuteSelectionProvider = 'ExtensionHostSelection.executeSelectionProvider';
 const ConfigurationSetConfiguration = 'ExtensionHostConfiguration.setConfiguration';
 
-const create$6 = () => {
+const create$5 = () => {
   return {
     finished: false
   };
@@ -2428,10 +2457,14 @@ class BabelParseError extends SyntaxError {
 
 const getAssetDir = () => {
   // @ts-ignore
-  {
+  if (typeof '/05f09be' !== 'undefined') {
     // @ts-ignore
-    return '/24eca37';
+    return '/05f09be';
   }
+  if (platform === Electron) {
+    return '../../../../..';
+  }
+  return '';
 };
 const assetDir = getAssetDir();
 
@@ -2725,7 +2758,7 @@ const activate = async (extension, absolutePath) => {
     string(absolutePath);
     const module = await importScript(absolutePath);
     handleRpcInfos(extension);
-    const token = create$6();
+    const token = create$5();
     try {
       await Promise.race([module.activate(extension), rejectAfterTimeout(activationTimeout, token)]);
     } catch (error) {
@@ -2826,23 +2859,23 @@ const Auto = () => {
 const getData$1 = event => {
   return event.data;
 };
-const walkValue = (value, transferrables2, isTransferrable2) => {
+const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
   }
-  if (isTransferrable2(value)) {
-    transferrables2.push(value);
+  if (isTransferrable(value)) {
+    transferrables.push(value);
     return;
   }
   if (Array.isArray(value)) {
     for (const item of value) {
-      walkValue(item, transferrables2, isTransferrable2);
+      walkValue(item, transferrables, isTransferrable);
     }
     return;
   }
-  if (typeof value === "object") {
+  if (typeof value === 'object') {
     for (const property of Object.values(value)) {
-      walkValue(property, transferrables2, isTransferrable2);
+      walkValue(property, transferrables, isTransferrable);
     }
     return;
   }
@@ -2851,17 +2884,16 @@ const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
 const isMessagePortMain = value => {
-  return value && value.constructor && value.constructor.name === "MessagePortMain";
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
 };
 const isOffscreenCanvas = value => {
-  return typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas;
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
 };
 const isInstanceOf = (value, constructorName) => {
-  var _a;
-  return ((_a = value == null ? void 0 : value.constructor) == null ? void 0 : _a.name) === constructorName;
+  return value?.constructor?.name === constructorName;
 };
 const isSocket = value => {
-  return isInstanceOf(value, "Socket");
+  return isInstanceOf(value, 'Socket');
 };
 const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
 const isTransferrable = value => {
@@ -2873,20 +2905,20 @@ const isTransferrable = value => {
   return false;
 };
 const getTransferrables = value => {
-  const transferrables2 = [];
-  walkValue(value, transferrables2, isTransferrable);
-  return transferrables2;
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
 };
 const attachEvents = that => {
   const handleMessage = (...args) => {
     const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent("message", {
+    that.dispatchEvent(new MessageEvent('message', {
       data
     }));
   };
   that.onMessage(handleMessage);
   const handleClose = event => {
-    that.dispatchEvent(new Event("close"));
+    that.dispatchEvent(new Event('close'));
   };
   that.onClose(handleClose);
 };
@@ -2897,10 +2929,11 @@ class Ipc extends EventTarget {
     attachEvents(this);
   }
 }
-const readyMessage = "ready";
+const readyMessage = 'ready';
 const listen$4 = () => {
-  if (typeof WorkerGlobalScope === "undefined") {
-    throw new TypeError("module is not in web worker scope");
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
@@ -2912,16 +2945,22 @@ class IpcChildWithModuleWorker extends Ipc {
     return getData$1(event);
   }
   send(message) {
+    // @ts-ignore
     this._rawIpc.postMessage(message);
   }
   sendAndTransfer(message) {
     const transfer = getTransferrables(message);
+    // @ts-ignore
     this._rawIpc.postMessage(message, transfer);
   }
-  dispose() {}
-  onClose(callback) {}
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
   onMessage(callback) {
-    this._rawIpc.addEventListener("message", callback);
+    this._rawIpc.addEventListener('message', callback);
   }
 }
 const wrap$6 = global => {
@@ -2933,21 +2972,21 @@ const IpcChildWithModuleWorker$1 = {
   signal: signal$3,
   wrap: wrap$6
 };
-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 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 = 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]");
+  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 {
@@ -2971,11 +3010,11 @@ 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);
-  const relevantMessage = relevantLines.join(" ").slice("Error: ".length);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
   return relevantMessage;
 };
 const getNativeModuleErrorMessage = stderr => {
@@ -2989,7 +3028,7 @@ const isModulesSyntaxError = stderr => {
   if (!stderr) {
     return false;
   }
-  return stderr.includes("SyntaxError: Cannot use import statement outside a module");
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
 const getModuleSyntaxError = () => {
   return {
@@ -3001,7 +3040,7 @@ const isModuleNotFoundError = stderr => {
   if (!stderr) {
     return false;
   }
-  return stderr.includes("ERR_MODULE_NOT_FOUND");
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
 const isNormalStackLine = line => {
   return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
@@ -3010,7 +3049,7 @@ const getDetails = lines => {
   const index = lines.findIndex(isNormalStackLine);
   if (index === -1) {
     return {
-      actualMessage: joinLines$1(lines),
+      actualMessage: joinLines(lines),
       rest: []
     };
   }
@@ -3035,22 +3074,22 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
   if (isModuleNotFoundError(stderr)) {
     return getModuleNotFoundError(stderr);
   }
-  const lines = splitLines$1(stderr);
+  const lines = splitLines(stderr);
   const {
     actualMessage,
     rest
   } = getDetails(lines);
   return {
     message: `${actualMessage}`,
-    code: "",
+    code: '',
     stack: rest
   };
 };
 const normalizeLine = line => {
-  if (line.startsWith("Error: ")) {
+  if (line.startsWith('Error: ')) {
     return line.slice(`Error: `.length);
   }
-  if (line.startsWith("VError: ")) {
+  if (line.startsWith('VError: ')) {
     return line.slice(`VError: `.length);
   }
   return line;
@@ -3062,8 +3101,8 @@ const getCombinedMessage = (error, message) => {
   }
   return stringifiedError;
 };
-const NewLine = "\n";
-const getNewLineIndex = (string, startIndex = void 0) => {
+const NewLine = '\n';
+const getNewLineIndex = (string, startIndex = undefined) => {
   return string.indexOf(NewLine, startIndex);
 };
 const mergeStacks = (parent, child) => {
@@ -3087,35 +3126,43 @@ class VError extends Error {
   constructor(error, message) {
     const combinedMessage = getCombinedMessage(error, message);
     super(combinedMessage);
-    this.name = "VError";
+    this.name = 'VError';
     if (error instanceof Error) {
       this.stack = mergeStacks(this.stack, error.stack);
     }
     if (error.codeFrame) {
+      // @ts-ignore
       this.codeFrame = error.codeFrame;
     }
     if (error.code) {
+      // @ts-ignore
       this.code = error.code;
     }
   }
 }
 let IpcError$1 = class IpcError extends VError {
-  constructor(betterMessage, stdout = "", stderr = "") {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
     if (stdout || stderr) {
+      // @ts-ignore
       const {
         message,
         code,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
+      // @ts-ignore
       cause.code = code;
       cause.stack = stack;
       super(cause, betterMessage);
     } else {
       super(betterMessage);
     }
-    this.name = "IpcError";
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
     this.stdout = stdout;
+    // @ts-ignore
     this.stderr = stderr;
   }
 };
@@ -3134,10 +3181,11 @@ const waitForFirstMessage = async port => {
     resolve,
     promise
   } = withResolvers$1();
-  port.addEventListener("message", resolve, {
+  port.addEventListener('message', resolve, {
     once: true
   });
   const event = await promise;
+  // @ts-ignore
   return event.data;
 };
 const listen$3 = async () => {
@@ -3145,13 +3193,13 @@ const listen$3 = async () => {
   signal$3(parentIpcRaw);
   const parentIpc = wrap$6(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== "initialize") {
-    throw new IpcError$1("unexpected first message");
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError$1('unexpected first message');
   }
   const type = firstMessage.params[0];
-  if (type === "message-port") {
+  if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: "2.0",
+      jsonrpc: '2.0',
       id: firstMessage.id,
       result: null
     });
@@ -3180,9 +3228,11 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
       this._rawIpc.close();
     }
   }
-  onClose(callback) {}
+  onClose(callback) {
+    // ignore
+  }
   onMessage(callback) {
-    this._rawIpc.addEventListener("message", callback);
+    this._rawIpc.addEventListener('message', callback);
     this._rawIpc.start();
   }
 }
@@ -3216,10 +3266,14 @@ class IpcChildWithMessagePort extends Ipc {
     const transfer = getTransferrables(message);
     this._rawIpc.postMessage(message, transfer);
   }
-  dispose() {}
-  onClose(callback) {}
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
   onMessage(callback) {
-    this._rawIpc.addEventListener("message", callback);
+    this._rawIpc.addEventListener('message', callback);
     this._rawIpc.start();
   }
 }
@@ -3253,393 +3307,64 @@ const handleMessagePort = port => {
   ipc.send('ready');
 };
 
-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;
-    default:
-      throw new CommandNotFoundError(method);
-  }
-};
-
-/**
- *
- * @returns {Promise<any>}
- */
-const loadKy = async () => {
-  const url = `${assetDir}/js/ky.js`;
-  const module = await import(url);
-  return module;
-};
-
-const getText = async (url, options = {}) => {
-  try {
-    const {
-      default: ky
-    } = await loadKy();
-    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}"`);
-  }
+const commandMap = {
+  ['ExtensionHostDebug.evaluate']: evaluate,
+  ['ExtensionHostDebug.getProperties']: getProperties,
+  ['ExtensionHostDebug.listProcesses']: listProcesses,
+  ['ExtensionHostDebug.pause']: pause,
+  ['ExtensionHostDebug.resume']: resume,
+  ['ExtensionHostDebug.setPauseOnException']: setPauseOnException,
+  ['ExtensionHostDebug.setPauseOnExceptions']: setPauseOnExceptions,
+  ['ExtensionHostDebug.start']: start,
+  ['ExtensionHostDebug.stepInto']: stepInto,
+  ['ExtensionHostDebug.stepOut']: stepOut,
+  ['ExtensionHostDebug.stepOver']: stepOver,
+  ['ExtensionHostWebView.create']: createWebView,
+  ['ExtensionHostWebView.dispose']: disposeWebView,
+  ['ExtensionHostWebView.load']: load,
+  ['HandleMessagePort.handleMessagePort']: handleMessagePort,
+  [BraceCompletionExecuteBraceCompletionProvider]: executeBraceCompletionProvider,
+  [ClosingTagExecuteClosingTagProvider]: executeClosingTagProvider,
+  [CommandExecute]: executeCommand,
+  [CompletionExecute]: executeCompletionProvider,
+  [CompletionResolveExecute]: executeresolveCompletionItemProvider,
+  [ConfigurationSetConfiguration]: setConfigurations,
+  [DefinitionExecuteDefinitionProvider]: executeDefinitionProvider,
+  [DiagnosticExecuteDiagnosticProvider]: executeDiagnosticProvider,
+  [ExtensionActivate]: activate,
+  [FileSystemGetPathSeparator]: getPathSeparator,
+  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes,
+  [FileSystemReadFile]: readFile,
+  [FileSystemWriteFile]: writeFile,
+  [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
+  [HoverExecute]: executeHoverProvider,
+  [ImplementationExecuteImplementationProvider]: executeImplementationProvider,
+  [MockExec]: mockExec,
+  [MockRpc]: mockRpc,
+  [OrganizeImportsExecute]: executeOrganizeImports,
+  [ReferenceExecuteFileReferenceProvider]: executefileReferenceProvider,
+  [ReferenceExecuteReferenceProvider]: executeReferenceProvider,
+  [SelectionExecuteSelectionProvider]: executeSelectionProvider,
+  [SourceControlAcceptInput]: acceptInput,
+  [SourceControlAdd]: add,
+  [SourceControlDiscard]: discard,
+  [SourceControlGetChangedFiles]: getChangedFiles,
+  [SourceControlGetEnabledProviderIds]: getEnabledProviderIds,
+  [SourceControlGetFileBefore]: getFileBefore,
+  [SourceControlGetGroups]: getGroups,
+  [StatusBarGetStatusBarItems]: getStatusBarItems,
+  [StatusBarRegisterChangeListener]: registerChangeListener,
+  [TabCompletionExecuteTabCompletionProvider]: executeTabCompletionProvider,
+  [TextDocumentSetLanguageId]: setLanguageId,
+  [TextDocumentSyncFull]: syncFull,
+  [TextDocumentSyncIncremental]: syncIncremental,
+  [TextSearchExecuteTextSearchProvider]: executeTextSearchProvider,
+  [TypeDefinitionExecuteTypeDefinitionProvider]: executeTypeDefinitionProvider,
+  [WorkspaceSetPath]: setWorkspacePath
 };
 
-// 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);
-  }
+  console.error(error);
 };
 
 /**
@@ -3709,8 +3434,7 @@ const main = async () => {
     self.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
   }
   globalThis.vscode = api;
-  // @ts-ignore
-  state$7.getFn = getFn;
+  register(commandMap);
   const ipc = await listen({
     method: Auto()
   });
@@ -3728,17 +3452,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
   };
 };
@@ -3969,105 +3687,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
@@ -4075,7 +3703,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 {