@lvce-editor/extension-host-worker 1.0.0

package/dist/extensionHostWorkerMain.js

@@ -0,0 +1,4717 @@
+const Property = 1;
+const Value = 2;
+const Function = 3;
+const Variable = 4;
+const Keyword = 5;
+const Folder = 6;
+const File$2 = 7;
+const Field = 8;
+
+const EditorCompletionType = {
+  __proto__: null,
+  Field,
+  File: File$2,
+  Folder,
+  Function,
+  Keyword,
+  Property,
+  Value,
+  Variable
+};
+
+class DepecratedError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'DeprecatedError';
+  }
+}
+
+const getJson = async url => {
+  throw new DepecratedError(`vscode.getJson is deprecated, use createNodeRpc instead`);
+};
+
+let AssertionError$1 = class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    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':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      return 'object';
+    case 'boolean':
+      return 'boolean';
+    default:
+      return 'unknown';
+  }
+};
+const object = 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$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') {
+    throw new AssertionError$1('expected value to be of type string');
+  }
+};
+const fn = value => {
+  const type = getType$3(value);
+  if (type !== 'function') {
+    throw new AssertionError$1('expected value to be of type function');
+  }
+};
+
+const state$b = {
+  /** @type{any[]} */
+  onDidOpenEditorListeners: [],
+  /** @type{any[]} */
+  onWillChangeEditorListeners: [],
+  /** @type{any[]} */
+  onDidChangeTextDocumentListeners: [],
+  /** @type{any[]} */
+  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;
+};
+
+// 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 => {
+  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';
+
+class NoProviderFoundError extends Error {
+  constructor(message) {
+    super(message);
+    // @ts-ignore
+    this.code = E_NO_PROVIDER_FOUND;
+  }
+}
+
+const stringifyError = error => {
+  const errorPrefixes = ['Error: ', 'VError: '];
+  const stringifiedError = `${error}`;
+  for (const errorPrefix of errorPrefixes) {
+    if (stringifiedError.startsWith(errorPrefix)) {
+      return stringifiedError.slice(errorPrefix.length);
+    }
+  }
+  return stringifiedError;
+};
+const getCombinedMessage$1 = (error, message) => {
+  const stringifiedError = stringifyError(error);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return `${stringifiedError}`;
+};
+const mergeStacks$1 = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = parent.indexOf('\n');
+  const childNewLineIndex = child.indexOf('\n');
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = child.slice(0, childNewLineIndex);
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+let VError$1 = class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage$1(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks$1(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+  }
+};
+
+const getType$2 = value => {
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      return 'object';
+    case 'boolean':
+      return 'boolean';
+    case 'undefined':
+      return 'undefined';
+    default:
+      return 'unknown';
+  }
+};
+const validateResultObject = (result, resultShape) => {
+  if (!resultShape.properties) {
+    return undefined;
+  }
+  for (const [key, value] of Object.entries(resultShape.properties)) {
+    // @ts-ignore
+    const expectedType = value.type;
+    const actualType = getType$2(result[key]);
+    if (expectedType !== actualType) {
+      return `item.${key} must be of type ${expectedType}`;
+    }
+  }
+  return undefined;
+};
+const validateResultArray = (result, resultShape) => {
+  for (const item of result) {
+    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}`;
+    }
+  }
+  return undefined;
+};
+const getPreviewObject = item => {
+  return 'object';
+};
+const getPreviewArray = item => {
+  if (item.length === 0) {
+    return '[]';
+  }
+  return 'array';
+};
+const getPreviewString = item => {
+  return `"${item}"`;
+};
+const getPreview = item => {
+  const type = getType$2(item);
+  switch (type) {
+    case 'object':
+      return getPreviewObject();
+    case 'array':
+      return getPreviewArray(item);
+    case 'string':
+      return getPreviewString(item);
+    default:
+      return `${item}`;
+  }
+};
+const validate = (item, schema) => {
+  const actualType = getType$2(item);
+  const expectedType = schema.type;
+  if (actualType !== expectedType) {
+    if (schema.allowUndefined && (item === undefined || item === null)) {
+      return item;
+    }
+    const preview = getPreview(item);
+    return `item must be of type ${expectedType} but is ${preview}`;
+  }
+  switch (actualType) {
+    case 'object':
+      return validateResultObject(item, schema);
+    case 'array':
+      return validateResultArray(item, schema);
+  }
+  // TODO use json schema to validate result
+  return undefined;
+};
+
+const RE_UPPERCASE_LETTER = /[A-Z]/g;
+const RE_PROPERTY = /item\..*must be of type/;
+const spaceOut = camelCaseWord => {
+  return camelCaseWord.replaceAll(RE_UPPERCASE_LETTER, (character, index) => {
+    if (index === 0) {
+      return character.toLowerCase();
+    }
+    return ' ' + character.toLowerCase();
+  });
+};
+const toCamelCase = string => {
+  return string[0].toLowerCase() + string.slice(1);
+};
+const improveValidationErrorPostMessage = (validationError, camelCaseName) => {
+  if (validationError.startsWith('item must be of type')) {
+    return validationError.replace('item', camelCaseName);
+  }
+  if (validationError.startsWith('expected result to be')) {
+    return validationError.replace('result', `${camelCaseName} item`);
+  }
+  if (RE_PROPERTY.test(validationError)) {
+    return validationError.replace('item', camelCaseName);
+  }
+  return validationError;
+};
+const improveValidationError = (name, validationError) => {
+  const camelCaseName = toCamelCase(name);
+  const spacedOutName = spaceOut(name);
+  const pre = `invalid ${spacedOutName} result`;
+  const post = improveValidationErrorPostMessage(validationError, camelCaseName);
+  return pre + ': ' + post;
+};
+let NonError$1 = 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 => {
+  if (!(input instanceof Error)) {
+    return new NonError$1(input);
+  }
+  return input;
+};
+const registerMethod = ({
+  context,
+  providers,
+  returnUndefinedWhenNoProviderFound,
+  name,
+  methodName,
+  resultShape
+}) => {
+  context[`execute${name}Provider`] = async function (textDocumentId, ...params) {
+    try {
+      const textDocument = get$3(textDocumentId);
+      if (!textDocument) {
+        throw new Error(`textDocument with id ${textDocumentId} not found`);
+      }
+      const provider = providers[textDocument.languageId];
+      if (!provider) {
+        if (returnUndefinedWhenNoProviderFound) {
+          return undefined;
+        }
+        const spacedOutName = spaceOut(name);
+        throw new NoProviderFoundError(`No ${spacedOutName} provider found for ${textDocument.languageId}`);
+      }
+      const result = await provider[methodName](textDocument, ...params);
+      const error = validate(result, resultShape);
+      if (error) {
+        const improvedError = improveValidationError(name, error);
+        // @ts-ignore
+        throw new VError$1(improvedError);
+      }
+      return result;
+    } catch (error) {
+      const actualError = ensureError$1(error);
+      const spacedOutName = spaceOut(name);
+      if (actualError && actualError.message) {
+        if (actualError.message === 'provider[methodName] is not a function') {
+          const camelCaseName = toCamelCase(name);
+          // @ts-ignore
+          throw new VError$1(`Failed to execute ${spacedOutName} provider: VError: ${camelCaseName}Provider.${methodName} is not a function`);
+        }
+        const message = actualError.name === 'Error' ? `${actualError.message}` : `${actualError.name}: ${actualError.message}`;
+        actualError.message = `Failed to execute ${spacedOutName} provider: ${message}`;
+      }
+      throw actualError;
+    }
+  };
+};
+const create$a = ({
+  name,
+  resultShape,
+  executeKey = '',
+  returnUndefinedWhenNoProviderFound = false,
+  additionalMethodNames = []
+}) => {
+  const multipleResults = resultShape.type === 'array';
+  const methodName = executeKey || (multipleResults ? `provide${name}s` : `provide${name}`);
+  const providers = Object.create(null);
+  const context = {
+    [`register${name}Provider`](provider) {
+      providers[provider.languageId] = provider;
+    },
+    reset() {
+      for (const key in providers) {
+        delete providers[key];
+      }
+    }
+  };
+  registerMethod({
+    context,
+    providers,
+    name,
+    methodName,
+    returnUndefinedWhenNoProviderFound,
+    resultShape
+  });
+  for (const method of additionalMethodNames) {
+    // @ts-ignore
+    registerMethod({
+      context,
+      providers,
+      ...method
+    });
+  }
+  const finalContext = {
+    ...context
+  };
+  return finalContext;
+};
+
+const Array$1 = 'array';
+const Boolean = 'boolean';
+const Number$1 = 'number';
+const Object$1 = 'object';
+const String$1 = 'string';
+
+const {
+  registerBraceCompletionProvider,
+  executeBraceCompletionProvider,
+  reset: reset$9
+} = create$a({
+  name: 'BraceCompletion',
+  resultShape: {
+    type: Boolean
+  }
+});
+
+const {
+  registerClosingTagProvider,
+  executeClosingTagProvider
+} = create$a({
+  name: 'ClosingTag',
+  returnUndefinedWhenNoProviderFound: true,
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  }
+});
+
+const {
+  registerCodeActionProvider,
+  executeCodeActionProvider
+} = create$a({
+  name: 'CodeAction',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
+    }
+  }
+});
+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 = {
+  commands: Object.create(null)
+};
+const getCommandDisplay = command => {
+  if (command && command.id && typeof command.id === 'string') {
+    return ` ${command.id}`;
+  }
+  return '';
+};
+const registerCommand = command => {
+  try {
+    if (!command) {
+      if (command === null) {
+        throw new Error(`command is null`);
+      }
+      throw new Error('command is not defined');
+    }
+    if (!command.id) {
+      throw new Error('command is missing id');
+    }
+    if (!command.execute) {
+      throw new Error('command is missing execute function');
+    }
+    if (command.id in state$a.commands) {
+      throw new Error(`command cannot be registered multiple times`);
+    }
+    state$a.commands[command.id] = command;
+  } catch (error) {
+    const commandDisplayId = getCommandDisplay(command);
+    throw new VError$1(error, `Failed to register command${commandDisplayId}`);
+  }
+};
+const executeCommand = async (id, ...args) => {
+  try {
+    const command = state$a.commands[id];
+    if (!command) {
+      throw new Error(`command ${id} not found`);
+    }
+    const results = await command.execute(...args);
+    return results;
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.isExpected) {
+      throw error;
+    }
+    throw new VError$1(error, 'Failed to execute command');
+  }
+};
+
+const {
+  registerCompletionProvider,
+  executeCompletionProvider,
+  executeresolveCompletionItemProvider
+} = create$a({
+  name: 'Completion',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
+    }
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'resolveCompletionItem',
+    methodName: 'resolveCompletionItem',
+    resultShape: {
+      type: Object$1,
+      allowUndefined: true
+    }
+  }]
+});
+
+const state$9 = {
+  configuration: Object.create(null)
+};
+const getConfiguration = key => {
+  return state$9.configuration[key] ?? '';
+};
+const setConfigurations = preferences => {
+  state$9.configuration = preferences;
+};
+
+const Two$1 = '2.0';
+const create$4$1 = (method, params) => {
+  return {
+    jsonrpc: Two$1,
+    method,
+    params
+  };
+};
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const getType$1 = value => {
+  switch (typeof value) {
+    case 'number':
+      return 'number';
+    case 'function':
+      return 'function';
+    case 'string':
+      return 'string';
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+      if (Array.isArray(value)) {
+        return 'array';
+      }
+      return 'object';
+    case 'boolean':
+      return 'boolean';
+    default:
+      return 'unknown';
+  }
+};
+const number = value => {
+  const type = getType$1(value);
+  if (type !== 'number') {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const state$1$1 = {
+  callbacks: Object.create(null)
+};
+const set$2 = (id, fn) => {
+  state$1$1.callbacks[id] = fn;
+};
+const get$2 = id => {
+  return state$1$1.callbacks[id];
+};
+const remove = id => {
+  delete state$1$1.callbacks[id];
+};
+const state$8 = {
+  id: 0
+};
+const create$3$1 = () => {
+  return ++state$8.id;
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const withResolvers$2 = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+const registerPromise = () => {
+  const id = create$3$1();
+  const {
+    resolve,
+    promise
+  } = withResolvers$2();
+  set$2(id, resolve);
+  return {
+    id,
+    promise
+  };
+};
+const resolve = (id, args) => {
+  number(id);
+  const fn = get$2(id);
+  if (!fn) {
+    console.log(args);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(args);
+  remove(id);
+};
+const create$2$1 = (method, params) => {
+  const {
+    id,
+    promise
+  } = registerPromise();
+  const message = {
+    jsonrpc: Two$1,
+    method,
+    params,
+    id
+  };
+  return {
+    message,
+    promise
+  };
+};
+let JsonRpcError$1 = class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+};
+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) {
+      case DomException:
+        return DOMException;
+      case TypeError$1:
+        return TypeError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case ReferenceError$1:
+        return ReferenceError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith('TypeError: ')) {
+    return TypeError;
+  }
+  if (message.startsWith('SyntaxError: ')) {
+    return SyntaxError;
+  }
+  if (message.startsWith('ReferenceError: ')) {
+    return ReferenceError;
+  }
+  return Error;
+};
+const constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== 'VError') {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+const 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')) {
+    parentStack = error.message + NewLine$2 + parentStack;
+  }
+  return parentStack;
+};
+const joinLines$2 = lines => {
+  return lines.join(NewLine$2);
+};
+const MethodNotFound$1 = -32601;
+const Custom = -32001;
+const splitLines$2 = 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 parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine$2 + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$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 || '';
+        // @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') {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+const unwrapJsonRpcResult = responseMessage => {
+  if ('error' in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError$1('unexpected response message');
+};
+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 getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound$1,
+      message: error.message,
+      data: error.stack
+    };
+  }
+  return {
+    code: Custom,
+    message: prettyError.message,
+    data: {
+      stack: prettyError.stack,
+      codeFrame: prettyError.codeFrame,
+      type: getType(prettyError),
+      code: prettyError.code,
+      name: prettyError.name
+    }
+  };
+};
+const create$1$1 = (message, error) => {
+  return {
+    jsonrpc: Two$1,
+    id: message.id,
+    error
+  };
+};
+const getErrorResponse$1 = (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) => {
+  return {
+    jsonrpc: Two$1,
+    id: message.id,
+    result: result ?? null
+  };
+};
+const getSuccessResponse$1 = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$9(message, resultProperty);
+};
+const getResponse$1 = 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);
+  } catch (error) {
+    return getErrorResponse$1(message, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+const handleJsonRpcMessage$1 = async (...args) => {
+  let message;
+  let ipc;
+  let execute;
+  let preparePrettyError;
+  let logError;
+  let resolve;
+  let requiresSocket;
+  if (args.length === 1) {
+    const arg = args[0];
+    message = arg.message;
+    ipc = arg.ipc;
+    execute = arg.execute;
+    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
+    logError = arg.logError || defaultLogError;
+    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
+    resolve = arg.resolve || defaultResolve;
+  } else {
+    ipc = args[0];
+    message = args[1];
+    execute = args[2];
+    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);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse$1(message, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse$1(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);
+};
+const invoke$1 = async (ipc, method, ...params) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  ipc.send(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
+const invokeAndTransfer$1 = async (ipc, method, ...params) => {
+  const {
+    message,
+    promise
+  } = create$2$1(method, params);
+  ipc.sendAndTransfer(message);
+  const responseMessage = await promise;
+  const result = unwrapJsonRpcResult(responseMessage);
+  return result;
+};
+
+const state$7 = {
+  getFn() {}
+};
+const execute = (method, ...params) => {
+  // @ts-ignore
+  const fn = state$7.getFn(method);
+  // @ts-ignore
+  if (!fn) {
+    throw new Error(`command not found ${method}`);
+  }
+  // @ts-ignore
+  return fn(...params);
+};
+
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = 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);
+};
+
+const handleIpc = ipc => {
+  ipc.addEventListener('message', handleMessage);
+};
+
+const state$6 = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined
+};
+const get$1 = () => {
+  return state$6.ipc;
+};
+const set$1 = ipc => {
+  state$6.ipc = ipc;
+};
+
+const send = (method, ...params) => {
+  const ipc = get$1();
+  send$1(ipc, method, ...params);
+};
+const invoke = (method, ...params) => {
+  const ipc = get$1();
+  return invoke$1(ipc, method, ...params);
+};
+const invokeAndTransfer = (method, ...params) => {
+  const ipc = get$1();
+  return invokeAndTransfer$1(ipc, method, ...params);
+};
+const listen$2 = ipc => {
+  handleIpc(ipc);
+  set$1(ipc);
+};
+
+const state$5 = {
+  debugProviderMap: Object.create(null)
+};
+const getDebugProvider = id => {
+  const provider = state$5.debugProviderMap[id];
+  if (!provider) {
+    // @ts-ignore
+    throw new VError$1(`no debug provider "${id}" found`);
+  }
+  return provider;
+};
+const registerDebugProvider = debugProvider => {
+  if (!debugProvider.id) {
+    throw new Error('Failed to register debug system provider: missing id');
+  }
+  state$5.debugProviderMap[debugProvider.id] = debugProvider;
+};
+const start = async (protocol, path) => {
+  try {
+    const handlePaused = params => {
+      console.log('send paused', params);
+      send('Debug.paused', params);
+    };
+    const handleResumed = () => {
+      send('Debug.resumed');
+    };
+    const handleScriptParsed = parsedScript => {
+      send('Debug.scriptParsed', parsedScript);
+    };
+    const provider = getDebugProvider(protocol);
+    await provider.start({
+      handlePaused,
+      handleResumed,
+      handleScriptParsed
+    }, path);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const listProcesses = async (protocol, path) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    const processes = await provider.listProcesses(path);
+    array(processes);
+    return processes;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const resume = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.resume();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const pause = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.pause();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const stepInto = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepInto();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const stepOut = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepOut();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const stepOver = async protocol => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.stepOver();
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const setPauseOnException = async (protocol, value) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.setPauseOnExceptions(value);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const getProperties = async (protocol, objectId) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.getProperties(objectId);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const evaluate = async (protocol, expression, callFrameId) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.evaluate(expression, callFrameId);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute debug provider');
+  }
+};
+const setPauseOnExceptions = async (protocol, value) => {
+  try {
+    const provider = getDebugProvider(protocol);
+    return await provider.setPauseOnExceptions(value);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute setPauseOnExceptions');
+  }
+};
+
+const {
+  registerDefinitionProvider,
+  executeDefinitionProvider,
+  reset: reset$8
+} = create$a({
+  name: 'Definition',
+  resultShape: {
+    allowUndefined: true,
+    type: Object$1,
+    properties: {
+      uri: {
+        type: String$1
+      },
+      startOffset: {
+        type: Number$1
+      },
+      endOffset: {
+        type: Number$1
+      }
+    }
+  }
+});
+
+const {
+  registerDiagnosticProvider,
+  executeDiagnosticProvider
+} = create$a({
+  name: 'Diagnostic',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
+    }
+  }
+});
+
+const showInformationMessage = message => {
+  string(message);
+  const result = invoke('ExtensionHostDialog.showInformationMessage', message);
+  return result;
+};
+
+const env = {};
+
+const exec = async (command, args, options) => {
+  throw new DepecratedError(`vscode.exec is deprecated, use createNodeRpc instead`);
+};
+
+const state$4 = {
+  fileSystemProviderMap: Object.create(null)
+};
+const getFileSystemProvider = protocol => {
+  const provider = state$4.fileSystemProviderMap[protocol];
+  if (!provider) {
+    // @ts-ignore
+    throw new VError$1(`no file system provider for protocol "${protocol}" found`);
+  }
+  return provider;
+};
+const registerFileSystemProvider = fileSystemProvider => {
+  if (!fileSystemProvider.id) {
+    throw new Error('Failed to register file system provider: missing id');
+  }
+  state$4.fileSystemProviderMap[fileSystemProvider.id] = fileSystemProvider;
+};
+const readDirWithFileTypes = async (protocol, path) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return await provider.readDirWithFileTypes(path);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute file system provider');
+  }
+};
+const readFile = async (protocol, path) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return await provider.readFile(path);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute file system provider');
+  }
+};
+const readFileExternal = async path => {
+  // TODO when file is local,
+  // don't ask renderer worker
+  // instead read file directly from shared process
+  // this avoid parsing the potentially large message
+  // and improve performance by not blocking the renderer worker
+  // when reading / writing large files
+  const content = await invoke('FileSystem.readFile', path);
+  return content;
+};
+const 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);
+};
+
+const {
+  registerFormattingProvider,
+  executeFormattingProvider,
+  reset: reset$7
+} = create$a({
+  name: 'Formatting',
+  executeKey: 'format',
+  resultShape: {
+    allowUndefined: true,
+    type: Array$1,
+    items: {
+      type: Object$1,
+      properties: {
+        startOffset: {
+          type: Number$1
+        },
+        endOffset: {
+          type: Number$1
+        },
+        inserted: {
+          type: String$1
+        }
+      }
+    }
+  }
+});
+
+const getOffset = (textDocument, position) => {
+  let offset = 0;
+  let rowIndex = 0;
+  while (rowIndex++ < position.rowIndex) {
+    const newLineIndex = textDocument.text.indexOf('\n', offset);
+    offset = newLineIndex + 1;
+  }
+  offset += position.columnIndex;
+  return offset;
+};
+
+const getPosition = (textDocument, offset) => {
+  let index = 0;
+  let rowIndex = 0;
+  let newLineIndex = 0;
+  const text = textDocument.text;
+  while (index < offset) {
+    newLineIndex = text.indexOf('\n', index);
+    if (newLineIndex === -1) {
+      break;
+    }
+    const newIndex = newLineIndex + 1;
+    if (newIndex > offset) {
+      break;
+    }
+    index = newIndex;
+    rowIndex++;
+  }
+  const columnIndex = offset - index;
+  return {
+    rowIndex,
+    columnIndex
+  };
+};
+
+const {
+  registerHoverProvider,
+  executeHoverProvider,
+  reset: reset$6
+} = create$a({
+  name: 'Hover',
+  resultShape: {
+    allowUndefined: true,
+    type: Object$1,
+    properties: {}
+  }
+});
+
+const {
+  registerImplementationProvider,
+  executeImplementationProvider,
+  reset: reset$5
+} = create$a({
+  name: 'Implementation',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
+    }
+  }
+});
+
+const WebSocket$1 = 5;
+const ElectronMessagePort = 6;
+const ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1 = 7;
+
+const getModule$3 = method => {
+  switch (method) {
+    case WebSocket$1:
+      return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
+    case ElectronMessagePort:
+      return Promise.resolve().then(function () { return IpcParentWithNode; });
+    case ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1:
+      return Promise.resolve().then(function () { return IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug; });
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const create$8 = async ({
+  method,
+  ...options
+}) => {
+  try {
+    const module = await getModule$3(method);
+    // @ts-ignore
+    const rawIpc = await module.create(options);
+    // @ts-ignore
+    const ipc = module.wrap(rawIpc);
+    return ipc;
+  } catch (error) {
+    throw new VError$1(error, `Failed to create ipc`);
+  }
+};
+
+const JsonRpc = 1;
+
+const getModule$2 = method => {
+  switch (method) {
+    case JsonRpc:
+      return Promise.resolve().then(function () { return RpcParentWithJsonRpc; });
+    default:
+      throw new Error('unexpected rpc type');
+  }
+};
+
+const create$7 = async ({
+  method,
+  ...options
+}) => {
+  const module = await getModule$2(method);
+  // @ts-ignore
+  const rpc = module.create(options);
+  return rpc;
+};
+
+const defaultExecute$1 = () => {
+  throw new Error('not implemented');
+};
+const createNodeRpc = async ({
+  path,
+  execute = defaultExecute$1,
+  name = ''
+}) => {
+  try {
+    string(path);
+    fn(execute);
+    const ipc = await create$8({
+      method: ElectronMessagePort,
+      type: 'extension-host-helper-process',
+      name
+    });
+    const rpc = await create$7({
+      ipc,
+      method: JsonRpc,
+      execute
+    });
+    await rpc.invoke('LoadFile.loadFile', path);
+    return rpc;
+  } catch (error) {
+    throw new VError$1(error, `Failed to create node rpc`);
+  }
+};
+
+const confirm = message => {
+  string(message);
+  const result = invoke('ConfirmPrompt.prompt', message);
+  return result;
+};
+
+const ExtensionHostQuickPickShow = 'ExtensionHostQuickPick.show';
+
+const showQuickPick = async ({
+  getPicks,
+  toPick
+}) => {
+  const rawPicks = await getPicks();
+  const picks = rawPicks.map(toPick);
+  return invoke(ExtensionHostQuickPickShow, picks);
+};
+
+const {
+  registerReferenceProvider,
+  executeReferenceProvider,
+  executefileReferenceProvider,
+  reset: reset$4
+} = create$a({
+  name: 'Reference',
+  resultShape: {
+    type: Array$1,
+    items: {
+      type: Object$1
+    }
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'fileReference',
+    methodName: 'provideFileReferences',
+    resultShape: {
+      type: Array$1,
+      items: {
+        type: Object$1
+      }
+    }
+  }]
+});
+
+const {
+  registerRenameProvider,
+  executeRenameProvider,
+  executeprepareRenameProvider,
+  reset: reset$3
+} = create$a({
+  name: 'Rename',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  },
+  additionalMethodNames: [
+  // @ts-ignore
+  {
+    name: 'prepareRename',
+    methodName: 'prepareRename',
+    resultShape: {
+      type: Object$1,
+      allowUndefined: true
+    }
+  }]
+});
+
+const rpcs = Object.create(null);
+const add$1 = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+
+const getExtensionHostSubWorkerUrl = () => {
+  return new URL('../../../../extension-host-sub-worker/src/extensionHostSubWorkerMain.js', import.meta.url).toString();
+};
+const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
+
+const createRpcWithId = async ({
+  id,
+  execute
+}) => {
+  string(id);
+  const info = get(id);
+  if (!info) {
+    throw new Error(`rpc with id ${id} not found`);
+  }
+  const ipc = await create$8({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url: extensionHostSubWorkerUrl,
+    name: info.name
+  });
+  const rpc = await create$7({
+    ipc,
+    method: JsonRpc,
+    execute
+  });
+  await rpc.invoke('LoadFile.loadFile', info.url);
+  return rpc;
+};
+
+const set = async (url, contentSecurityPolicy) => {
+  const pathName = new URL(url).pathname;
+  await invoke('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
+};
+
+const defaultExecute = () => {
+  throw new Error('not implemented');
+};
+const createRpc = async ({
+  id,
+  url,
+  name,
+  execute = defaultExecute,
+  contentSecurityPolicy
+}) => {
+  try {
+    if (id) {
+      string(id);
+      const rpc = await createRpcWithId({
+        id,
+        execute
+      });
+      return rpc;
+    }
+
+    // deprecated
+    string(url);
+    string(name);
+    fn(execute);
+    if (contentSecurityPolicy) {
+      await set(url, contentSecurityPolicy);
+    }
+    const ipc = await create$8({
+      method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+      url: extensionHostSubWorkerUrl,
+      name
+    });
+    const rpc = await create$7({
+      ipc,
+      method: JsonRpc,
+      execute
+    });
+    await rpc.invoke('LoadFile.loadFile', url);
+    return rpc;
+  } catch (error) {
+    throw new VError$1(error, `Failed to create webworker rpc`);
+  }
+};
+
+const {
+  registerSelectionProvider,
+  executeSelectionProvider,
+  reset: reset$2
+} = create$a({
+  name: 'Selection',
+  resultShape: {
+    allowUndefined: true,
+    type: Array$1,
+    items: {
+      type: 'number'
+    }
+  }
+});
+
+const state$3 = {
+  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;
+};
+
+const {
+  registerTabCompletionProvider,
+  executeTabCompletionProvider,
+  reset: reset$1
+} = create$a({
+  name: 'TabCompletion',
+  resultShape: {
+    type: Object$1,
+    allowUndefined: true
+  }
+});
+
+const state$2 = {
+  textSearchProviders: Object.create(null)
+};
+const registerTextSearchProvider = textSearchProvider => {
+  try {
+    if (!textSearchProvider) {
+      throw new Error('textSearchProvider is not defined');
+    }
+    if (!textSearchProvider.scheme) {
+      throw new Error('textSearchProvider is missing scheme');
+    }
+    state$2.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to register text search provider');
+  }
+};
+const executeTextSearchProvider = async (scheme, query) => {
+  try {
+    const textSearchProvider = state$2.textSearchProviders[scheme];
+    if (!textSearchProvider) {
+      throw new Error(`no text search provider for ${scheme} found`);
+    }
+    const results = await textSearchProvider.provideTextSearchResults(query);
+    return results;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to execute text search provider');
+  }
+};
+
+const {
+  registerTypeDefinitionProvider,
+  executeTypeDefinitionProvider,
+  reset
+} = create$a({
+  name: 'TypeDefinition',
+  resultShape: {
+    allowUndefined: true,
+    type: Object$1,
+    properties: {
+      uri: {
+        type: String$1
+      },
+      startOffset: {
+        type: Number$1
+      },
+      endOffset: {
+        type: Number$1
+      }
+    }
+  }
+});
+
+const createWorker = async ({
+  method,
+  url,
+  name
+}) => {
+  string(method);
+  string(url);
+  string(name);
+  const ipc = create$8({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    url,
+    name
+  });
+  return ipc;
+};
+
+const state$1 = {
+  workspacePath: ''
+};
+const setWorkspacePath = path => {
+  state$1.workspacePath = path;
+};
+const getWorkspaceFolder = path => {
+  return state$1.workspacePath;
+};
+
+const RE_PROTOCOL = /^([a-z\-]+):\/\//;
+const getProtocol = uri => {
+  const protocolMatch = uri.match(RE_PROTOCOL);
+  if (protocolMatch) {
+    return protocolMatch[1];
+  }
+  return '';
+};
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
+};
+
+const createWebViewIpc = async webView => {
+  const {
+    uid,
+    origin
+  } = webView;
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  const promise = new Promise(resolve => {
+    port2.onmessage = resolve;
+  });
+  const portType = 'test';
+  await invokeAndTransfer('WebView.setPort', uid, port1, origin, portType);
+  const event = await promise;
+  // @ts-ignore
+  if (event.data !== 'ready') {
+    throw new Error('unexpected first message');
+  }
+  const ipc = {
+    addEventListener(type, listener) {
+      const that = this;
+      const wrapped = event => {
+        const actualEvent = {
+          target: that,
+          data: event.data
+        };
+        listener(actualEvent);
+      };
+      port2.addEventListener(type, wrapped);
+    },
+    dispose() {},
+    send(message) {
+      port2.postMessage(message);
+    }
+  };
+  // TODO maybe don't send a message port only to get object url?
+  // TODO dispose ipc to avoid memory leak
+  handleIpc(ipc);
+  return ipc;
+};
+
+// TODO if webViewId is provided,
+// 1. read file as blob
+// 2. send blob to webview
+// 3. create objecturl in webview
+// 4. send back objecturl to extension host worker
+// 5. provide objectUrl to extension
+
+const getRemoteUrlForWebView = async (uri, options = {}) => {
+  const webView = getWebView(options.webViewId);
+  if (!webView) {
+    throw new Error(`webview ${options.webViewId} not found`);
+  }
+  const [ipc, blob] = await Promise.all([createWebViewIpc(webView), invoke('FileSystem.getBlob', uri)]);
+  const objectUrl = await invoke$1(ipc, 'createObjectUrl', blob);
+  return objectUrl;
+};
+
+const Electron = 'electron';
+const Remote = 'remote';
+const Test = 'test';
+
+const getPlatform = () => {
+  // @ts-ignore
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-ignore
+    return PLATFORM;
+  }
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return Test;
+  }
+  // TODO find a better way to pass runtime environment
+  if (typeof name !== 'undefined' && name.endsWith('(Electron)')) {
+    return Electron;
+  }
+  return Remote;
+};
+const platform = getPlatform(); // TODO tree-shake this out in production
+
+const getRemoteUrl = async (uri, options = {}) => {
+  const protocol = getProtocol(uri);
+  if (platform === Remote && !protocol) {
+    return `/remote/${uri}`;
+  }
+  if (platform === Electron && !protocol) {
+    return `/remote/${uri}`;
+  }
+  if (options.webViewId) {
+    return getRemoteUrlForWebView(uri, options);
+  }
+  if (uri.startsWith('html://')) {
+    const url = await invoke('Blob.getSrc', uri);
+    return url;
+  }
+  throw new Error(`unsupported platform for remote url`);
+};
+
+class FormattingError extends Error {
+  constructor(message, codeFrame) {
+    super(message);
+    // @ts-ignore
+    this.codeFrame = codeFrame;
+    this.name = 'FormattingError';
+  }
+}
+
+const File$1 = 1;
+const Match = 2;
+
+const TextSearchResultType = {
+  __proto__: null,
+  File: File$1,
+  Match
+};
+
+const api = {
+  // Ajax
+  getJson: getJson,
+  // Brace Completion
+  registerBraceCompletionProvider: registerBraceCompletionProvider,
+  executeBraceCompletionProvider: executeBraceCompletionProvider,
+  // Closing Tag
+  registerClosingTagProvider: registerClosingTagProvider,
+  executeClosingTagProvider: executeClosingTagProvider,
+  // Code Action
+  registerCodeActionsProvider: registerCodeActionProvider,
+  // Command
+  registerCommand: registerCommand,
+  executeCommand: executeCommand,
+  // Completion
+  registerCompletionProvider: registerCompletionProvider,
+  executeCompletionProvider: executeCompletionProvider,
+  EditorCompletionType,
+  // Configuration
+  getConfiguration: getConfiguration,
+  // Debug
+  registerDebugProvider: registerDebugProvider,
+  // Definition
+  registerDefinitionProvider: registerDefinitionProvider,
+  executeDefinitionProvider: executeDefinitionProvider,
+  // Diagnostic
+  registerDiagnosticProvider: registerDiagnosticProvider,
+  executeDiagnosticProvider: executeDiagnosticProvider,
+  // Dialog
+  showInformationMessage: showInformationMessage,
+  // Env
+  env: env,
+  // Errors
+  FormattingError,
+  VError: VError$1,
+  // Exec
+  exec: exec,
+  // File System
+  registerFileSystemProvider: registerFileSystemProvider,
+  readFile: readFileExternal,
+  // Formatting
+  registerFormattingProvider: registerFormattingProvider,
+  executeFormattingProvider: executeFormattingProvider,
+  // Get Offset
+  getOffset: getOffset,
+  // Get Position
+  getPosition: getPosition,
+  // Hover
+  registerHoverProvider: registerHoverProvider,
+  executeHoverProvider: executeHoverProvider,
+  // Rpc
+  createRpc: createRpc,
+  createNodeRpc: createNodeRpc,
+  // Implementation
+  registerImplementationProvider: registerImplementationProvider,
+  executeImplementationProvider: executeImplementationProvider,
+  // Prompt
+  confirm: confirm,
+  // QuickPick
+  showQuickPick: showQuickPick,
+  // Rename
+  registerRenameProvider: registerRenameProvider,
+  executeRenameProvider: executeRenameProvider,
+  executePrepareRenameProvider: executeprepareRenameProvider,
+  // Reference
+  registerReferenceProvider: registerReferenceProvider,
+  executeReferenceProvider: executeReferenceProvider,
+  // Selection
+  registerSelectionProvider: registerSelectionProvider,
+  executeSelectionProvider: executeSelectionProvider,
+  // Source Control
+  registerSourceControlProvider: registerSourceControlProvider,
+  // Tab Completion
+  registerTabCompletionProvider: registerTabCompletionProvider,
+  executeTabCompletionProvider: executeTabCompletionProvider,
+  // Text Document
+  getTextFromTextDocument: getText$1,
+  // Text Search
+  registerTextSearchProvider: registerTextSearchProvider,
+  executeTextSearchProvider: executeTextSearchProvider,
+  TextSearchResultType,
+  // Type Definition
+  registerTypeDefinitionProvider: registerTypeDefinitionProvider,
+  executeTypeDefinitionProvider: executeTypeDefinitionProvider,
+  // Url
+  getRemoteUrl: getRemoteUrl,
+  // Webview
+  registerWebViewProvider: registerWebViewProvider,
+  // Worker
+  createWorker: createWorker,
+  // Workspace
+  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';
+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
+};
+
+const MessagePort$1 = 1;
+const ModuleWorker = 2;
+const ModuleWorkerWithMessagePort = 4;
+const Auto = () => {
+  if (globalThis.acceptPort) {
+    return MessagePort$1;
+  }
+  return ModuleWorkerWithMessagePort;
+};
+
+const getData$1 = event => {
+  return event.data;
+};
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
+  }
+};
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const readyMessage = 'ready';
+const listen$4 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$3 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    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() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$6 = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$4,
+  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 => {
+  return lines.join(NewLine$1);
+};
+const splitLines$1 = 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 messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    message,
+    code: ERR_MODULE_NOT_FOUND
+  };
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$1(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
+  return relevantMessage;
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$1(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$1(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    message: `${actualMessage}`,
+    code: '',
+    stack: rest
+  };
+};
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice(`Error: `.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice(`VError: `.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine = '\n';
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex(parent);
+  const childNewLineIndex = getNewLineIndex(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+let IpcError$1 = class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        message,
+        code,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
+};
+const withResolvers$1 = () => {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  return {
+    resolve: _resolve,
+    promise
+  };
+};
+const waitForFirstMessage = async port => {
+  const {
+    resolve,
+    promise
+  } = withResolvers$1();
+  port.addEventListener('message', resolve, {
+    once: true
+  });
+  const event = await promise;
+  // @ts-ignore
+  return event.data;
+};
+const listen$3 = async () => {
+  const parentIpcRaw = listen$4();
+  signal$3(parentIpcRaw);
+  const parentIpc = wrap$6(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== 'initialize') {
+    throw new IpcError$1('unexpected first message');
+  }
+  const type = firstMessage.params[0];
+  if (type === 'message-port') {
+    parentIpc.send({
+      jsonrpc: '2.0',
+      id: firstMessage.id,
+      result: null
+    });
+    parentIpc.dispose();
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
+    }
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$5 = port => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
+};
+const IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$3,
+  wrap: wrap$5
+};
+const listen$1 = ({
+  port
+}) => {
+  return port;
+};
+const signal = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
+  }
+}
+const wrap$2$1 = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$1,
+  signal,
+  wrap: wrap$2$1
+};
+
+const getModule$1 = method => {
+  switch (method) {
+    case ModuleWorker:
+      return IpcChildWithModuleWorker$1;
+    case ModuleWorkerWithMessagePort:
+      return IpcChildWithModuleWorkerAndMessagePort$1;
+    case MessagePort$1:
+      return IpcChildWithMessagePort$1;
+    default:
+      throw new Error('unexpected ipc type');
+  }
+};
+
+const handleMessagePort = port => {
+  const module = getModule$1(MessagePort$1);
+  const ipc = module.wrap(port);
+  handleIpc(ipc);
+  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;
+    case 'ExtensionHostWebView.load':
+      return load;
+    default:
+      throw new CommandNotFoundError(method);
+  }
+};
+
+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');
+    }
+  }
+  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 listen = async ({
+  method
+}) => {
+  const module = await getModule$1(method);
+  const rawIpc = await module.listen();
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+const setStackTraceLimit = value => {
+  if (Error.stackTraceLimit && Error.stackTraceLimit < value) {
+    Error.stackTraceLimit = value;
+  }
+};
+
+const main = async () => {
+  setStackTraceLimit(20);
+  onerror ||= handleUnhandledError;
+  onunhandledrejection ||= handleUnhandledRejection;
+  if ('SecurityPolicyViolationEvent' in self) {
+    self.addEventListener('securitypolicyviolation', handleContentSecurityPolicyViolation);
+  }
+  globalThis.vscode = api;
+  // @ts-ignore
+  state$7.getFn = getFn;
+  const ipc = await listen({
+    method: Auto()
+  });
+  listen$2(ipc);
+};
+
+main();
+
+const Error$1 = 1;
+const Open = 2;
+const Close = 3;
+
+const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise
+  };
+};
+
+const getFirstEvent = (eventTarget, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      eventTarget.removeEventListener(event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    eventTarget.addEventListener(event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+
+/**
+ *
+ * @param {WebSocket} webSocket
+ * @returns
+ */
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close,
+    error: Error$1
+  });
+};
+
+const getWebSocketProtocol = () => {
+  return location.protocol === 'https:' ? 'wss:' : 'ws:';
+};
+
+const getWebSocketUrl = type => {
+  const wsProtocol = getWebSocketProtocol();
+  return `${wsProtocol}//${location.host}/websocket/${type}`;
+};
+
+class IpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'IpcError';
+  }
+}
+
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+
+const create$4 = async ({
+  type
+}) => {
+  string(type);
+  const wsUrl = getWebSocketUrl(type);
+  const webSocket = new WebSocket(wsUrl);
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  // @ts-ignore
+  if (firstWebSocketEvent.type === Error$1) {
+    throw new IpcError(`WebSocket connection error`);
+  }
+  // @ts-ignore
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError(`Websocket connection was closed`);
+  }
+  return webSocket;
+};
+const wrap$3 = webSocket => {
+  return {
+    /**
+     * @type {any}
+     */
+    handleMessage: undefined,
+    webSocket,
+    get onmessage() {
+      return this.handleMessage;
+    },
+    set onmessage(listener) {
+      if (listener) {
+        // @ts-ignore
+        this.handleMessage = event => {
+          // TODO why are some events not instance of message event?
+          if (event instanceof MessageEvent) {
+            const message = JSON.parse(event.data);
+            // @ts-ignore
+            listener(message);
+          } else {
+            // @ts-ignore
+            listener(event);
+          }
+        };
+      } else {
+        // @ts-ignore
+        this.handleMessage = null;
+      }
+      this.webSocket.onmessage = this.handleMessage;
+    },
+    send(message) {
+      if (this.webSocket.readyState !== webSocket.OPEN) {
+        // @ts-ignore
+        throw new VError$1(`Failed to send message: WebSocket is not open`);
+      }
+      const stringifiedMessage = stringifyCompact(message);
+      this.webSocket.send(stringifiedMessage);
+    }
+  };
+};
+
+const IpcParentWithWebSocket = {
+  __proto__: null,
+  create: create$4,
+  wrap: wrap$3
+};
+
+const getModule = async () => {
+  switch (platform) {
+    case Remote:
+      return Promise.resolve().then(function () { return IpcParentWithWebSocket; });
+    default:
+      return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; });
+  }
+};
+const create$3 = async ({
+  type,
+  raw
+}) => {
+  const module = await getModule();
+  const rawIpc = await module.create({
+    type
+  });
+  if (raw) {
+    return rawIpc;
+  }
+  return {
+    module,
+    rawIpc
+  };
+};
+const wrap$2 = ({
+  module,
+  rawIpc
+}) => {
+  return module.wrap(rawIpc);
+};
+
+const IpcParentWithNode = {
+  __proto__: null,
+  create: create$3,
+  wrap: wrap$2
+};
+
+const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
+
+const create$2 = async ({
+  url,
+  name
+}) => {
+  string(url);
+  string(name);
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  await invokeAndTransfer([port1], 'IpcParent.create', {
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    url,
+    name,
+    raw: true,
+    port: port1
+  });
+  return port2;
+};
+const wrap$1 = port => {
+  return {
+    port,
+    /**
+     * @type {any}
+     */
+    handleMessage: undefined,
+    get onmessage() {
+      return this.handleMessage;
+    },
+    set onmessage(listener) {
+      if (listener) {
+        // @ts-ignore
+        this.handleMessage = event => {
+          // TODO why are some events not instance of message event?
+          if (event instanceof MessageEvent) {
+            const message = event.data;
+            // @ts-ignore
+            listener(message, event);
+          } else {
+            // @ts-ignore
+
+            listener(event);
+          }
+        };
+      } else {
+        // @ts-ignore
+        this.handleMessage = null;
+      }
+      this.port.onmessage = this.handleMessage;
+    },
+    send(message) {
+      this.port.postMessage(message);
+    },
+    sendAndTransfer(message, transfer) {
+      this.port.postMessage(message, transfer);
+    }
+  };
+};
+
+const IpcParentWithModuleWorkerAndWorkaroundForChromeDevtoolsBug = {
+  __proto__: null,
+  create: create$2,
+  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 getResponse = async (message, execute) => {
+  try {
+    const result = await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    return getErrorResponse(message, error);
+  }
+};
+
+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 create$1 = ({
+  ipc,
+  execute
+}) => {
+  object(ipc);
+  fn(execute);
+  const handleMessage = async message => {
+    return handleJsonRpcMessage(ipc, message, execute, resolve);
+  };
+  ipc.onmessage = handleMessage;
+  return {
+    ipc,
+    invoke(method, ...params) {
+      return invoke$1(this.ipc, method, ...params);
+    }
+  };
+};
+
+const RpcParentWithJsonRpc = {
+  __proto__: null,
+  create: create$1
+};
+
+const sendMessagePortToElectron = async (port, initialCommand) => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, initialCommand);
+};
+
+const getPort = async type => {
+  const {
+    port1,
+    port2
+  } = getPortTuple();
+  await sendMessagePortToElectron(port1, 'HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess');
+  return port2;
+};
+const create = async ({
+  type
+}) => {
+  const port = await getPort();
+  return port;
+};
+const wrap = port => {
+  let handleMessage;
+  return {
+    get onmessage() {
+      return handleMessage;
+    },
+    set onmessage(listener) {
+      let handleMessage;
+      if (listener) {
+        handleMessage = event => {
+          listener(event.data);
+        };
+      } else {
+        handleMessage = null;
+      }
+      port.onmessage = handleMessage;
+    },
+    send(message) {
+      port.postMessage(message);
+    }
+  };
+};
+
+const IpcParentWithElectronMessagePort = {
+  __proto__: null,
+  create,
+  wrap
+};