@lvce-editor/server 0.31.6 → 0.32.1

package/static/7808edb/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -1,3794 +0,0 @@
-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$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';
-    default:
-      return 'unknown';
-  }
-};
-const object = value => {
-  const type = getType$2(value);
-  if (type !== 'object') {
-    throw new AssertionError$1('expected value to be of type object');
-  }
-};
-const number$1 = value => {
-  const type = getType$2(value);
-  if (type !== 'number') {
-    throw new AssertionError$1('expected value to be of type number');
-  }
-};
-const array = value => {
-  const type = getType$2(value);
-  if (type !== 'array') {
-    throw new AssertionError$1('expected value to be of type array');
-  }
-};
-const string = value => {
-  const type = getType$2(value);
-  if (type !== 'string') {
-    throw new AssertionError$1('expected value to be of type string');
-  }
-};
-const fn = value => {
-  const type = getType$2(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$2 = 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$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';
-    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$1(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$1(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$1(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$1(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$2(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$2(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;
-};
-
-// @ts-nocheck
-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 = 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(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$1 = 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 = () => {
-  let _resolve;
-  const promise = new Promise(resolve2 => {
-    _resolve = resolve2;
-  });
-  return {
-    resolve: _resolve,
-    promise
-  };
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve: resolve2,
-    promise
-  } = withResolvers$2();
-  set$2(id, resolve2);
-  return {
-    id,
-    promise
-  };
-};
-const resolve = (id, args) => {
-  number(id);
-  const fn = get$1(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 = void 0) => {
-  return string.indexOf(NewLine$2, startIndex);
-};
-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 getParentStack = error => {
-  let parentStack = error.stack || error.data || error.message || "";
-  if (parentStack.startsWith("    at")) {
-    parentStack = error.message + NewLine$2 + parentStack;
-  }
-  return parentStack;
-};
-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) {
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || "";
-        const indexNewLine = getNewLineIndex$1(lowerStack);
-        const parentStack = getParentStack(error);
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        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 create$1$1 = (message, error) => {
-  return {
-    jsonrpc: Two$1,
-    id: message.id,
-    error
-  };
-};
-const E_COMMAND_NOT_FOUND = "E_COMMAND_NOT_FOUND";
-const getErrorProperty = (error, prettyError) => {
-  if (error && error.code === E_COMMAND_NOT_FOUND) {
-    return {
-      code: MethodNotFound$1,
-      message: error.message,
-      data: error.stack
-    };
-  }
-  return {
-    code: Custom,
-    message: prettyError.message,
-    data: {
-      stack: prettyError.stack,
-      codeFrame: prettyError.codeFrame,
-      type: prettyError.type,
-      code: prettyError.code
-    }
-  };
-};
-const getErrorResponse$1 = (message, error, ipc, 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 ? result : null
-  };
-};
-const getSuccessResponse$1 = (message, result) => {
-  const resultProperty = result != null ? 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, ipc, preparePrettyError, logError);
-  }
-};
-const handleJsonRpcMessage$1 = async (ipc, message, execute, resolve2, preparePrettyError, logError, requiresSocket) => {
-  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, ipc, preparePrettyError, logError);
-        ipc.send(errorResponse);
-      }
-      return;
-    }
-    resolve2(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, handle, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  ipc.sendAndTransfer(message, handle);
-  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 => {
-  console.error(error);
-};
-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 = () => {
-  return state$6.ipc;
-};
-const set$1 = ipc => {
-  state$6.ipc = ipc;
-};
-
-const send = (method, ...params) => {
-  const ipc = get();
-  send$1(ipc, method, ...params);
-};
-const invoke = (method, ...params) => {
-  const ipc = get();
-  return invoke$1(ipc, method, ...params);
-};
-const invokeAndTransfer = (transfer, method, ...params) => {
-  const ipc = get();
-  return invokeAndTransfer$1(ipc, transfer, method, ...params);
-};
-const listen$4 = 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 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 {
-  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 getExtensionHostSubWorkerUrl = () => {
-  return '/7808edb/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
-};
-const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
-
-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 ({
-  url,
-  name,
-  execute = defaultExecute,
-  contentSecurityPolicy
-}) => {
-  try {
-    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;
-};
-
-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,
-  // 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,
-  // 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>';
-};
-
-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 Electron = 'electron';
-const Remote = 'remote';
-
-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 getAssetDir = () => {
-  // @ts-ignore
-  {
-    // @ts-ignore
-    return '/7808edb';
-  }
-};
-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);
-    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;
-const ModuleWorker = 2;
-const ReferencePort = 3;
-const ModuleWorkerWithMessagePort = 4;
-const Auto = () => {
-  if (globalThis.acceptPort) {
-    return MessagePort;
-  }
-  if (globalThis.acceptReferencePort) {
-    return ReferencePort;
-  }
-  return ModuleWorkerWithMessagePort;
-};
-
-const getData$1 = event => {
-  return event.data;
-};
-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$3 = () => {
-  if (typeof WorkerGlobalScope === "undefined") {
-    throw new TypeError("module is not in web worker scope");
-  }
-  return globalThis;
-};
-const signal$2 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message, transfer) {
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {}
-  onClose(callback) {}
-  onMessage(callback) {
-    this._rawIpc.addEventListener("message", callback);
-  }
-}
-const wrap$5 = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  listen: listen$3,
-  signal: signal$2,
-  wrap: wrap$5
-};
-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 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 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 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 = void 0) => {
-  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) {
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      this.code = error.code;
-    }
-  }
-}
-let IpcError$1 = class IpcError extends VError {
-  constructor(betterMessage, stdout = "", stderr = "") {
-    if (stdout || stderr) {
-      const {
-        message,
-        code,
-        stack
-      } = getHelpfulChildProcessError(stdout, stderr);
-      const cause = new Error(message);
-      cause.code = code;
-      cause.stack = stack;
-      super(cause, betterMessage);
-    } else {
-      super(betterMessage);
-    }
-    this.name = "IpcError";
-    this.stdout = stdout;
-    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;
-  return event.data;
-};
-const listen$2 = async () => {
-  const parentIpcRaw = listen$3();
-  signal$2(parentIpcRaw);
-  const parentIpc = wrap$5(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.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, transfer) {
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    if (this._rawIpc.close) {
-      this._rawIpc.close();
-    }
-  }
-  onClose(callback) {}
-  onMessage(callback) {
-    this._rawIpc.addEventListener("message", callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$4 = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
-};
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$2,
-  wrap: wrap$4
-};
-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, transfer) {
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {}
-  onClose(callback) {}
-  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:
-      return IpcChildWithMessagePort$1;
-    default:
-      throw new Error('unexpected ipc type');
-  }
-};
-
-const handleMessagePort = port => {
-  const module = getModule$1(MessagePort);
-  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;
-    default:
-      throw new CommandNotFoundError(method);
-  }
-};
-
-/**
- *
- * @returns {Promise<any>}
- */
-const loadKy = async () => {
-  const url = `${assetDir}/js/ky.js`;
-  const module = await import(url);
-  return module;
-};
-
-const getText = async (url, options = {}) => {
-  try {
-    const {
-      default: ky
-    } = await loadKy();
-    return await ky(url, options).text();
-  } catch (error) {
-    if (error && error instanceof TypeError && error.message === 'Failed to fetch') {
-      throw new VError$1(error, `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`);
-    }
-    throw new VError$1(error, `Failed to request text from "${url}"`);
-  }
-};
-
-// 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$4(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 getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
-};
-
-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([port], '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
-};
-//# sourceMappingURL=extensionHostWorkerMain.js.map