@lvce-editor/server 0.11.6 → 0.11.7

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

@@ -0,0 +1,2345 @@
+const Property = 1;
+const Value = 2;
+const Function$1 = 3;
+const Variable = 4;
+const Keyword = 5;
+const Folder = 6;
+const File$1 = 7;
+
+const EditorCompletionType = {
+  __proto__: null,
+  Property,
+  Value,
+  Function: Function$1,
+  Variable,
+  Keyword,
+  Folder,
+  File: File$1
+};
+
+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)) {
+    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 getPreview = (item) => {
+  const type = getType$1(item);
+  switch (type) {
+    case 'object':
+      return getPreviewObject()
+    case 'array':
+      return getPreviewArray(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) {
+      return undefined
+    }
+    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 combineMessages = (error, message) => {
+  if (error && error.message) {
+    return `${message}: ${error.message}`
+  }
+  return `${error}`
+};
+
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = combineMessages(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+  }
+}
+
+// TODO consider using an assertion library like https://github.com/alexreardon/tiny-invariant, https://github.com/tj/better-assert
+
+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 object = (value) => {
+  const type = getType(value);
+  if (type !== 'object') {
+    throw new Error('expected value to be of type object')
+  }
+};
+
+const number = (value) => {
+  const type = getType(value);
+  if (type !== 'number') {
+    throw new Error('expected value to be of type number')
+  }
+};
+
+const array = (value) => {
+  const type = getType(value);
+  if (type !== 'array') {
+    throw new Error('expected value to be of type array')
+  }
+};
+
+const string = (value) => {
+  const type = getType(value);
+  if (type !== 'string') {
+    throw new Error('expected value to be of type string')
+  }
+};
+
+// TODO when using textDocument.create sync with renderer worker only if necessary
+// e.g. when is virtual file system -> need to get from renderer worker
+// else just create it
+
+const state$8 = {
+  /** @type{any[]} */
+  onDidOpenEditorListeners: [],
+  /** @type{any[]} */
+  onWillChangeEditorListeners: [],
+  /** @type{any[]} */
+  onDidChangeTextDocumentListeners: [],
+  /** @type{any[]} */
+  onDidSaveTextDocumentListeners: [],
+  textDocuments: Object.create(null),
+};
+
+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 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,
+  };
+  state$8.textDocuments[textDocumentId] = textDocument;
+  runListenersSafe(state$8.onDidOpenEditorListeners, textDocument);
+};
+
+const getSyntheticChanges = (textDocument, changes) => {
+  // console.log({ textDocument, changes })
+  object(textDocument);
+  array(changes);
+  const change = changes[0];
+  const startOffset = getOffset(textDocument, change.start);
+  const endOffset = getOffset(textDocument, change.end);
+  const inserted = change.inserted.join('\n');
+  const syntheticChanges = [
+    {
+      startOffset,
+      endOffset,
+      inserted,
+    },
+  ];
+  return syntheticChanges
+};
+
+const syncIncremental = (textDocumentId, changes) => {
+  number(textDocumentId);
+  array(changes);
+  const textDocument = state$8.textDocuments[textDocumentId];
+  if (!textDocument) {
+    console.warn(
+      `sync not possible, no matching textDocument with id ${textDocumentId}`
+    );
+    return
+  }
+  const syntheticChanges = getSyntheticChanges(textDocument, changes);
+  runListenersSafe(
+    state$8.onWillChangeEditorListeners,
+    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(
+    state$8.onDidChangeTextDocumentListeners,
+    textDocument,
+    syntheticChanges
+  );
+};
+
+const get = (textDocumentId) => {
+  const textDocument = state$8.textDocuments[textDocumentId];
+  return textDocument
+};
+
+const getText$1 = (textDocument) => {
+  return textDocument.text
+};
+
+const setLanguageId = (textDocumentId, languageId) => {
+  const newTextDocument = {
+    ...state$8.textDocuments[textDocumentId],
+    languageId,
+  };
+  state$8.textDocuments[textDocumentId] = newTextDocument;
+  runListenersSafe(state$8.onDidOpenEditorListeners, newTextDocument);
+};
+
+const RE_UPPERCASE_LETTER = /[A-Z]/g;
+
+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 improveValidationError = (name, validationError) => {
+  const camelCaseName = toCamelCase(name);
+  const spacedOutName = spaceOut(name);
+  const pre = `invalid ${spacedOutName} result`;
+  const post = validationError
+    .replace('item', camelCaseName)
+    .replace(`result`, `${camelCaseName} item`);
+  return pre + ': ' + post
+};
+
+class NonError extends Error {
+  name = 'NonError'
+
+  constructor(message) {
+    super(message);
+  }
+}
+
+// ensureError based on https://github.com/sindresorhus/ensure-error/blob/main/index.js (License MIT)
+const ensureError = (input) => {
+  if (!(input instanceof Error)) {
+    return new NonError(input)
+  }
+  return input
+};
+
+const create$7 = ({ name, resultShape, executeKey = '' }) => {
+  const providers = Object.create(null);
+  const multipleResults = resultShape.type === 'array';
+  const methodName =
+    executeKey || (multipleResults ? `provide${name}s` : `provide${name}`);
+  return {
+    [`register${name}Provider`](provider) {
+      providers[provider.languageId] = provider;
+    },
+    reset() {
+      for (const key in providers) {
+        delete providers[key];
+      }
+    },
+    async [`execute${name}Provider`](textDocumentId, ...params) {
+      try {
+        const textDocument = get(textDocumentId);
+        if (!textDocument) {
+          throw new Error(`textDocument with id ${textDocumentId} not found`)
+        }
+        const provider = providers[textDocument.languageId];
+        if (!provider) {
+          const spacedOutName = spaceOut(name);
+          throw new VError(
+            `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);
+          throw new VError(improvedError)
+        }
+        return result
+      } catch (error) {
+        const actualError = ensureError(error);
+        const spacedOutName = spaceOut(name);
+        if (actualError && actualError.message) {
+          if (
+            actualError.message === 'provider[methodName] is not a function'
+          ) {
+            const camelCaseName = toCamelCase(name);
+
+            throw new VError(
+              `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 {
+  registerBraceCompletionProvider,
+  executeBraceCompletionProvider,
+  reset: reset$6,
+} = create$7({
+  name: 'BraceCompletion',
+  resultShape: {
+    type: 'boolean',
+  },
+});
+
+const state$7 = {
+  commands: Object.create(null),
+};
+
+const registerCommand = (command) => {
+  try {
+    if (!command) {
+      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')
+    }
+    state$7.commands[command.id] = command;
+  } catch (error) {
+    throw new VError(error, `Failed to register command`)
+  }
+};
+
+const executeCommand = async (id, ...args) => {
+  try {
+    const command = state$7.commands[id];
+    if (!command) {
+      throw new Error(`command ${id} not found`)
+    }
+    const results = await command.execute(...args);
+    return results
+  } catch (error) {
+    if (error && error.isExpected) {
+      throw error
+    }
+    throw new VError(error, `Failed to execute command`)
+  }
+};
+
+const { registerCompletionProvider, executeCompletionProvider } =
+  create$7({
+    name: 'Completion',
+    resultShape: {
+      type: 'array',
+      items: {
+        type: 'object',
+      },
+    },
+  });
+
+const getConfiguration = (key) => {
+  // TODO
+  return ''
+};
+
+const { registerDefinitionProvider, executeDefinitionProvider, reset: reset$5 } =
+  create$7({
+    name: 'Definition',
+    resultShape: {
+      allowUndefined: true,
+      type: 'object',
+      properties: {
+        uri: {
+          type: 'string',
+        },
+        startOffset: {
+          type: 'number',
+        },
+        endOffset: {
+          type: 'number',
+        },
+      },
+    },
+  });
+
+const env = {};
+
+const WebSocket$1 = 5;
+const ElectronMessagePort = 6;
+
+const getModule$1 = (method) => {
+  switch (method) {
+    case WebSocket$1:
+      return Promise.resolve().then(function () { return IpcParentWithWebSocket; })
+    case ElectronMessagePort:
+      return Promise.resolve().then(function () { return IpcParentWithElectronMessagePort; })
+    default:
+      throw new Error('unexpected ipc type')
+  }
+};
+
+const create$6 = async ({ method, ...options }) => {
+  const module = await getModule$1(method);
+  return module.create(options)
+};
+
+const create$5 = (method) => {
+  return create$6({
+    method,
+    protocol: ['lvce.extension-host-helper-process'],
+  })
+};
+
+const getIpcType = () => {
+  const isElectron = navigator.userAgent.includes('Electron');
+  if (isElectron) {
+    return ElectronMessagePort
+  }
+  return WebSocket$1
+};
+
+const state$6 = {
+  id: 0,
+};
+
+const create$4 = () => {
+  return ++state$6.id
+};
+
+const state$5 = {
+  callbacks: Object.create(null),
+};
+
+const register = (resolve, reject) => {
+  const id = create$4();
+  state$5.callbacks[id] = {
+    resolve,
+    reject,
+  };
+  return id
+};
+
+const resolve = (id, args) => {
+  number(id);
+  if (!(id in state$5.callbacks)) {
+    console.log(args);
+    console.warn(`callback ${id} may already be disposed`);
+    return
+  }
+  state$5.callbacks[id].resolve(args);
+  delete state$5.callbacks[id];
+};
+
+const reject = (id, error) => {
+  number(id);
+  if (!(id in state$5.callbacks)) {
+    console.warn(`callback ${id} may already be disposed`);
+    return
+  }
+  state$5.callbacks[id].reject(error);
+  delete state$5.callbacks[id];
+};
+
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+
+const MethodNotFound = -32601;
+
+const Two = '2.0';
+
+const getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case 'DomException':
+        return DOMException
+      case 'TypeError':
+        return TypeError
+      case 'SyntaxError':
+        return SyntaxError
+      case 'ReferenceError':
+        return ReferenceError
+      case 'DOMException':
+        return DOMException
+      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) {
+    return new Error(message)
+  }
+  const shortMessage = message.slice(ErrorConstructor.name.length + 2);
+  return new ErrorConstructor(shortMessage)
+};
+
+const restoreError = (error) => {
+  if (error && error instanceof Error) {
+    return error
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    restoredError.stack = error.stack;
+    return restoredError
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+
+        if (error.data.codeFrame) {
+          // @ts-ignore
+          restoredError.codeFrame = error.data.codeFrame;
+        }
+      }
+    } else if (restoredError.stack) {
+      // TODO accessing stack might be slow
+      const lowerStack = restoredError.stack;
+      // @ts-ignore
+      const indexNewLine = lowerStack.indexOf('\n');
+      // @ts-ignore
+      restoredError.stack = error.stack + lowerStack.slice(indexNewLine);
+    }
+    return restoredError
+  }
+  if (error && error.shortMessage && typeof error.shortMessage === 'string') {
+    return new Error(error.shortMessage)
+  }
+  if (typeof error === 'string') {
+    return new Error(`JsonRpc Error: ${error}`)
+  }
+  return new Error(`JsonRpc Error: ${error}`)
+};
+
+const invoke$1 = async (ipc, method, ...params) => {
+  const responseMessage = await new Promise((resolve, reject) => {
+    // TODO use one map instead of two
+    const callbackId = register(resolve, reject);
+    ipc.send({
+      jsonrpc: Two,
+      method,
+      params,
+      id: callbackId,
+    });
+  });
+  if ('error' in responseMessage) {
+    const restoredError = restoreError(responseMessage.error);
+    throw restoredError
+  }
+  if ('result' in responseMessage) {
+    return responseMessage.result
+  }
+
+  throw new Error('unexpected response message')
+};
+
+const handleMessage = (message) => {
+  if ('id' in message) {
+    if ('method' in message) {
+      throw new Error('not implemented')
+    }
+    resolve(message.id, message);
+    return
+  }
+};
+
+const listen$5 = async (ipc) => {
+  ipc.onmessage = handleMessage;
+  return {
+    async invoke(method, params) {
+      return invoke$1(ipc, method, ...params)
+    },
+  }
+};
+
+const state$4 = {
+  /**
+   * @type {any}
+   */
+  rpcPromise: undefined,
+};
+
+const getOrCreateRpc = () => {
+  if (!state$4.rpcPromise) {
+    const type = getIpcType();
+    state$4.rpcPromise = create$5(type).then(
+      listen$5
+    );
+  }
+  return state$4.rpcPromise
+};
+
+const invoke = async (method, ...params) => {
+  const rpc = await getOrCreateRpc();
+  return rpc.invoke(method, params)
+};
+
+let ExecError$1 = class ExecError extends Error {
+  constructor(stdout, stderr, exitCode) {
+    super(`Failed to execute`);
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+  }
+};
+
+const exec = async (command, args, options) => {
+  const { stdout, stderr, exitCode } = await invoke(
+    'Exec.exec',
+    command,
+    args,
+    options
+  );
+  if (exitCode !== 0) {
+    throw new ExecError$1(stdout, stderr, exitCode)
+  }
+  return {
+    stdout,
+    stderr,
+    exitCode,
+  }
+};
+
+const state$3 = {
+  fileSystemProviderMap: Object.create(null),
+};
+
+const getFileSystemProvider = (protocol) => {
+  const provider = state$3.fileSystemProviderMap[protocol];
+  if (!provider) {
+    throw new VError(`no file system provider for protocol "${protocol}" found`)
+  }
+  return provider
+};
+
+const registerFileSystemProvider = (fileSystemProvider) => {
+  if (!fileSystemProvider.id) {
+    throw new Error(`Failed to register file system provider: missing id`)
+  }
+  state$3.fileSystemProviderMap[fileSystemProvider.id] = fileSystemProvider;
+};
+
+const readDirWithFileTypes = async (protocol, path) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return await provider.readDirWithFileTypes(path)
+  } catch (error) {
+    throw new VError(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(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(error, 'Failed to execute file system provider')
+  }
+};
+
+const getPathSeparator = (protocol) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return provider.pathSeparator
+  } catch (error) {
+    throw new VError(error, 'Failed to execute file system provider')
+  }
+};
+
+const { registerFormattingProvider, executeFormattingProvider, reset: reset$4 } =
+  create$7({
+    name: 'Formatting',
+    executeKey: 'format',
+    resultShape: {
+      allowUndefined: true,
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          startOffset: {
+            type: 'number',
+          },
+          endOffset: {
+            type: 'number',
+          },
+          inserted: {
+            type: 'string',
+          },
+        },
+      },
+    },
+  });
+
+const { registerImplementationProvider, executeImplementationProvider, reset: reset$3 } =
+  create$7({
+    name: 'Implementation',
+    resultShape: {
+      type: 'array',
+      items: {
+        type: 'object',
+      },
+    },
+  });
+
+const { registerReferenceProvider, executeReferenceProvider, reset: reset$2 } =
+  create$7({
+    name: 'Reference',
+    resultShape: {
+      type: 'array',
+      items: {
+        type: 'object',
+      },
+    },
+  });
+
+const state$2 = {
+  providers: Object.create(null),
+};
+
+const registerSourceControlProvider = (provider) => {
+  state$2.providers[provider.id] = provider;
+};
+
+const getFilesFromProvider = (provider) => {
+  return provider.getChangedFiles()
+};
+
+const getChangedFiles = async () => {
+  const providers = Object.values(state$2.providers);
+  const changedFiles = await Promise.all(providers.map(getFilesFromProvider));
+  const flattenedChangedFiles = changedFiles.flat(1);
+  return flattenedChangedFiles
+};
+
+const acceptInput = async (value) => {
+  const provider = Object.values(state$2.providers)[0];
+  if (!provider) {
+    return
+  }
+  await provider.acceptInput(value);
+};
+
+const add = async (path) => {
+  const provider = Object.values(state$2.providers)[0];
+  if (!provider) {
+    return
+  }
+  await provider.add(path);
+};
+
+const discard = async (path) => {
+  const provider = Object.values(state$2.providers)[0];
+  if (!provider) {
+    return
+  }
+  await provider.discard(path);
+};
+
+const { registerTabCompletionProvider, executeTabCompletionProvider, reset: reset$1 } =
+  create$7({
+    name: 'TabCompletion',
+    resultShape: {
+      type: 'object',
+      allowUndefined: true,
+    },
+  });
+
+const state$1 = {
+  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$1.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+  } catch (error) {
+    throw new VError(error, `Failed to register text search provider`)
+  }
+};
+
+const executeTextSearchProvider = async (scheme, query) => {
+  try {
+    const textSearchProvider = state$1.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(error, `Failed to execute text search provider`)
+  }
+};
+
+const { registerTypeDefinitionProvider, executeTypeDefinitionProvider, reset } =
+  create$7({
+    name: 'TypeDefinition',
+    resultShape: {
+      allowUndefined: true,
+      type: 'object',
+      properties: {
+        uri: {
+          type: 'string',
+        },
+        startOffset: {
+          type: 'number',
+        },
+        endOffset: {
+          type: 'number',
+        },
+      },
+    },
+  });
+
+const state = {
+  workspacePath: '',
+};
+
+const setWorkspacePath = (path) => {
+  state.workspacePath = path;
+};
+
+const getWorkspaceFolder = (path) => {
+  return state.workspacePath
+};
+
+const File = 1;
+const Match = 2;
+
+const TextSearchResultType = {
+  __proto__: null,
+  File,
+  Match
+};
+
+class FormattingError extends Error {
+  constructor(message, codeFrame) {
+    super(message);
+    this.codeFrame = codeFrame;
+    this.name = 'FormattingError';
+  }
+}
+
+// prettier-ignore
+const api =  {
+  // Brace Completion
+  registerBraceCompletionProvider:registerBraceCompletionProvider,
+  executeBraceCompletionProvider: executeBraceCompletionProvider,
+
+  // Command
+  registerCommand: registerCommand,
+  executeCommand: executeCommand,
+
+  // Completion
+  registerCompletionProvider:registerCompletionProvider,
+  executeCompletionProvider: executeCompletionProvider,
+  EditorCompletionType,
+
+  // Configuration
+  getConfiguration: getConfiguration,
+
+  // Definition
+  registerDefinitionProvider: registerDefinitionProvider,
+  executeDefinitionProvider: executeDefinitionProvider,
+
+  // Env
+  env: env,
+
+  // Errors
+  FormattingError,
+  VError,
+
+  // Exec
+  exec: exec,
+
+  // File System
+  registerFileSystemProvider: registerFileSystemProvider,
+
+
+  // Formatting
+  registerFormattingProvider: registerFormattingProvider,
+  executeFormattingProvider: executeFormattingProvider,
+
+  // Implementation
+  registerImplementationProvider: registerImplementationProvider,
+  executeImplementationProvider: executeImplementationProvider,
+
+  // Reference
+  registerReferenceProvider: registerReferenceProvider,
+  executeReferenceProvider: executeReferenceProvider,
+
+  // 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,
+
+  // Workspace
+  getWorkspaceFolder: getWorkspaceFolder
+};
+
+class HTTPError extends Error {
+  constructor(response, request, options) {
+    const code = response.status || response.status === 0 ? response.status : "";
+    const title = response.statusText || "";
+    const status = `${code} ${title}`.trim();
+    const reason = status ? `status code ${status}` : "an unknown error";
+    super(`Request failed with ${reason}`);
+    Object.defineProperty(this, "response", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "request", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "options", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.name = "HTTPError";
+    this.response = response;
+    this.request = request;
+    this.options = options;
+  }
+}
+class TimeoutError extends Error {
+  constructor(request) {
+    super("Request timed out");
+    Object.defineProperty(this, "request", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+}
+const isObject = (value) => value !== null && typeof value === "object";
+const validateAndMerge = (...sources) => {
+  for (const source of sources) {
+    if ((!isObject(source) || Array.isArray(source)) && typeof source !== "undefined") {
+      throw new TypeError("The `options` argument must be an object");
+    }
+  }
+  return deepMerge({}, ...sources);
+};
+const mergeHeaders = (source1 = {}, source2 = {}) => {
+  const result = new globalThis.Headers(source1);
+  const isHeadersInstance = source2 instanceof globalThis.Headers;
+  const source = new globalThis.Headers(source2);
+  for (const [key, value] of source.entries()) {
+    if (isHeadersInstance && value === "undefined" || value === void 0) {
+      result.delete(key);
+    } else {
+      result.set(key, value);
+    }
+  }
+  return result;
+};
+const deepMerge = (...sources) => {
+  let returnValue = {};
+  let headers = {};
+  for (const source of sources) {
+    if (Array.isArray(source)) {
+      if (!Array.isArray(returnValue)) {
+        returnValue = [];
+      }
+      returnValue = [...returnValue, ...source];
+    } else if (isObject(source)) {
+      for (let [key, value] of Object.entries(source)) {
+        if (isObject(value) && key in returnValue) {
+          value = deepMerge(returnValue[key], value);
+        }
+        returnValue = {...returnValue, [key]: value};
+      }
+      if (isObject(source.headers)) {
+        headers = mergeHeaders(headers, source.headers);
+        returnValue.headers = headers;
+      }
+    }
+  }
+  return returnValue;
+};
+const supportsStreams = (() => {
+  let duplexAccessed = false;
+  let hasContentType = false;
+  const supportsReadableStream = typeof globalThis.ReadableStream === "function";
+  if (supportsReadableStream) {
+    hasContentType = new globalThis.Request("https://a.com", {
+      body: new globalThis.ReadableStream(),
+      method: "POST",
+      get duplex() {
+        duplexAccessed = true;
+        return "half";
+      }
+    }).headers.has("Content-Type");
+  }
+  return duplexAccessed && !hasContentType;
+})();
+const supportsAbortController = typeof globalThis.AbortController === "function";
+const supportsFormData = typeof globalThis.FormData === "function";
+const requestMethods = ["get", "post", "put", "patch", "head", "delete"];
+const responseTypes = {
+  json: "application/json",
+  text: "text/*",
+  formData: "multipart/form-data",
+  arrayBuffer: "*/*",
+  blob: "*/*"
+};
+const maxSafeTimeout = 2147483647;
+const stop = Symbol("stop");
+const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
+const retryMethods = ["get", "put", "head", "delete", "options", "trace"];
+const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+const retryAfterStatusCodes = [413, 429, 503];
+const defaultRetryOptions = {
+  limit: 2,
+  methods: retryMethods,
+  statusCodes: retryStatusCodes,
+  afterStatusCodes: retryAfterStatusCodes,
+  maxRetryAfter: Number.POSITIVE_INFINITY
+};
+const normalizeRetryOptions = (retry = {}) => {
+  if (typeof retry === "number") {
+    return {
+      ...defaultRetryOptions,
+      limit: retry
+    };
+  }
+  if (retry.methods && !Array.isArray(retry.methods)) {
+    throw new Error("retry.methods must be an array");
+  }
+  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
+    throw new Error("retry.statusCodes must be an array");
+  }
+  return {
+    ...defaultRetryOptions,
+    ...retry,
+    afterStatusCodes: retryAfterStatusCodes
+  };
+};
+const timeout = async (request, abortController, options) => new Promise((resolve, reject) => {
+  const timeoutId = setTimeout(() => {
+    if (abortController) {
+      abortController.abort();
+    }
+    reject(new TimeoutError(request));
+  }, options.timeout);
+  void options.fetch(request).then(resolve).catch(reject).then(() => {
+    clearTimeout(timeoutId);
+  });
+});
+const delay = async (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+class Ky {
+  constructor(input, options = {}) {
+    var _a, _b, _c;
+    Object.defineProperty(this, "request", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "abortController", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_retryCount", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 0
+    });
+    Object.defineProperty(this, "_input", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_options", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._input = input;
+    this._options = {
+      credentials: this._input.credentials || "same-origin",
+      ...options,
+      headers: mergeHeaders(this._input.headers, options.headers),
+      hooks: deepMerge({
+        beforeRequest: [],
+        beforeRetry: [],
+        beforeError: [],
+        afterResponse: []
+      }, options.hooks),
+      method: normalizeRequestMethod((_a = options.method) != null ? _a : this._input.method),
+      prefixUrl: String(options.prefixUrl || ""),
+      retry: normalizeRetryOptions(options.retry),
+      throwHttpErrors: options.throwHttpErrors !== false,
+      timeout: typeof options.timeout === "undefined" ? 1e4 : options.timeout,
+      fetch: (_b = options.fetch) != null ? _b : globalThis.fetch.bind(globalThis)
+    };
+    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
+      throw new TypeError("`input` must be a string, URL, or Request");
+    }
+    if (this._options.prefixUrl && typeof this._input === "string") {
+      if (this._input.startsWith("/")) {
+        throw new Error("`input` must not begin with a slash when using `prefixUrl`");
+      }
+      if (!this._options.prefixUrl.endsWith("/")) {
+        this._options.prefixUrl += "/";
+      }
+      this._input = this._options.prefixUrl + this._input;
+    }
+    if (supportsAbortController) {
+      this.abortController = new globalThis.AbortController();
+      if (this._options.signal) {
+        this._options.signal.addEventListener("abort", () => {
+          this.abortController.abort();
+        });
+      }
+      this._options.signal = this.abortController.signal;
+    }
+    this.request = new globalThis.Request(this._input, this._options);
+    if (supportsStreams) {
+      this.request.duplex = "half";
+    }
+    if (this._options.searchParams) {
+      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(this._options.searchParams).toString();
+      const searchParams = "?" + textSearchParams;
+      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
+      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
+        this.request.headers.delete("content-type");
+      }
+      this.request = new globalThis.Request(new globalThis.Request(url, this.request), this._options);
+    }
+    if (this._options.json !== void 0) {
+      this._options.body = JSON.stringify(this._options.json);
+      this.request.headers.set("content-type", (_c = this._options.headers.get("content-type")) != null ? _c : "application/json");
+      this.request = new globalThis.Request(this.request, {body: this._options.body});
+    }
+  }
+  static create(input, options) {
+    const ky2 = new Ky(input, options);
+    const fn = async () => {
+      if (ky2._options.timeout > maxSafeTimeout) {
+        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
+      }
+      await Promise.resolve();
+      let response = await ky2._fetch();
+      for (const hook of ky2._options.hooks.afterResponse) {
+        const modifiedResponse = await hook(ky2.request, ky2._options, ky2._decorateResponse(response.clone()));
+        if (modifiedResponse instanceof globalThis.Response) {
+          response = modifiedResponse;
+        }
+      }
+      ky2._decorateResponse(response);
+      if (!response.ok && ky2._options.throwHttpErrors) {
+        let error = new HTTPError(response, ky2.request, ky2._options);
+        for (const hook of ky2._options.hooks.beforeError) {
+          error = await hook(error);
+        }
+        throw error;
+      }
+      if (ky2._options.onDownloadProgress) {
+        if (typeof ky2._options.onDownloadProgress !== "function") {
+          throw new TypeError("The `onDownloadProgress` option must be a function");
+        }
+        if (!supportsStreams) {
+          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
+        }
+        return ky2._stream(response.clone(), ky2._options.onDownloadProgress);
+      }
+      return response;
+    };
+    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
+    const result = isRetriableMethod ? ky2._retry(fn) : fn();
+    for (const [type, mimeType] of Object.entries(responseTypes)) {
+      result[type] = async () => {
+        ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
+        const awaitedResult = await result;
+        const response = awaitedResult.clone();
+        if (type === "json") {
+          if (response.status === 204) {
+            return "";
+          }
+          if (options.parseJson) {
+            return options.parseJson(await response.text());
+          }
+        }
+        return response[type]();
+      };
+    }
+    return result;
+  }
+  _calculateRetryDelay(error) {
+    this._retryCount++;
+    if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
+      if (error instanceof HTTPError) {
+        if (!this._options.retry.statusCodes.includes(error.response.status)) {
+          return 0;
+        }
+        const retryAfter = error.response.headers.get("Retry-After");
+        if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+          let after = Number(retryAfter);
+          if (Number.isNaN(after)) {
+            after = Date.parse(retryAfter) - Date.now();
+          } else {
+            after *= 1e3;
+          }
+          if (typeof this._options.retry.maxRetryAfter !== "undefined" && after > this._options.retry.maxRetryAfter) {
+            return 0;
+          }
+          return after;
+        }
+        if (error.response.status === 413) {
+          return 0;
+        }
+      }
+      const BACKOFF_FACTOR = 0.3;
+      return BACKOFF_FACTOR * 2 ** (this._retryCount - 1) * 1e3;
+    }
+    return 0;
+  }
+  _decorateResponse(response) {
+    if (this._options.parseJson) {
+      response.json = async () => this._options.parseJson(await response.text());
+    }
+    return response;
+  }
+  async _retry(fn) {
+    try {
+      return await fn();
+    } catch (error) {
+      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
+      if (ms !== 0 && this._retryCount > 0) {
+        await delay(ms);
+        for (const hook of this._options.hooks.beforeRetry) {
+          const hookResult = await hook({
+            request: this.request,
+            options: this._options,
+            error,
+            retryCount: this._retryCount
+          });
+          if (hookResult === stop) {
+            return;
+          }
+        }
+        return this._retry(fn);
+      }
+      throw error;
+    }
+  }
+  async _fetch() {
+    for (const hook of this._options.hooks.beforeRequest) {
+      const result = await hook(this.request, this._options);
+      if (result instanceof Request) {
+        this.request = result;
+        break;
+      }
+      if (result instanceof Response) {
+        return result;
+      }
+    }
+    if (this._options.timeout === false) {
+      return this._options.fetch(this.request.clone());
+    }
+    return timeout(this.request.clone(), this.abortController, this._options);
+  }
+  _stream(response, onDownloadProgress) {
+    const totalBytes = Number(response.headers.get("content-length")) || 0;
+    let transferredBytes = 0;
+    if (response.status === 204) {
+      if (onDownloadProgress) {
+        onDownloadProgress({percent: 1, totalBytes, transferredBytes}, new Uint8Array());
+      }
+      return new globalThis.Response(null, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    }
+    return new globalThis.Response(new globalThis.ReadableStream({
+      async start(controller) {
+        const reader = response.body.getReader();
+        if (onDownloadProgress) {
+          onDownloadProgress({percent: 0, transferredBytes: 0, totalBytes}, new Uint8Array());
+        }
+        async function read() {
+          const {done, value} = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          if (onDownloadProgress) {
+            transferredBytes += value.byteLength;
+            const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+            onDownloadProgress({percent, transferredBytes, totalBytes}, value);
+          }
+          controller.enqueue(value);
+          await read();
+        }
+        await read();
+      }
+    }), {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+}
+/*! MIT License © Sindre Sorhus */
+const createInstance = (defaults) => {
+  const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
+  for (const method of requestMethods) {
+    ky2[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, {method}));
+  }
+  ky2.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
+  ky2.extend = (newDefaults) => createInstance(validateAndMerge(defaults, newDefaults));
+  ky2.stop = stop;
+  return ky2;
+};
+const ky = createInstance();
+
+const getText = async (url, options = {}) => {
+  try {
+    return await ky(url, options).text()
+  } catch (error) {
+    if (
+      error &&
+      error instanceof TypeError &&
+      error.message === 'Failed to fetch'
+    ) {
+      throw new VError(
+        error,
+        `Failed to request text from "${url}". Make sure that the server is running and has CORS enabled`
+      )
+    }
+    throw new VError(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$3 = (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('');
+
+          if (lastMarkerLine && opts.message) {
+            markerLine += ' ' + opts.message;
+          }
+        }
+        return [
+          '>',
+          gutter,
+          line.length > 0 ? ` ${line}` : '',
+          markerLine,
+        ].join('')
+      } else {
+        return ` ${gutter}${line.length > 0 ? ` ${line}` : ''}`
+      }
+    })
+    .join('\n');
+
+  if (opts.message && !hasColumns) {
+    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 (line.match(RE_PATH_1) || line.match(RE_PATH_2)) {
+      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 = parseInt(line);
+    const parsedColumn = parseInt(column);
+    const codeFrame = create$3(text, {
+      start: {
+        line: parsedLine,
+        column: parsedColumn,
+      },
+      end: {
+        line: parsedLine,
+        column: parsedColumn,
+      },
+    });
+    const relevantStack = joinLines(lines.slice(1));
+    let 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 {
+    const prettyError = 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 MessagePort = 1;
+const ModuleWorker = 2;
+const ReferencePort = 3;
+
+const Auto = () => {
+  if (globalThis.acceptPort) {
+    return MessagePort
+  }
+  if (globalThis.acceptReferencePort) {
+    return ReferencePort
+  }
+  return ModuleWorker
+};
+
+const getModule = (method) => {
+  switch (method) {
+    case MessagePort:
+      return Promise.resolve().then(function () { return IpcChildWithMessagePort; })
+    case ModuleWorker:
+      return Promise.resolve().then(function () { return IpcChildWithModuleWorker; })
+    case ReferencePort:
+      return Promise.resolve().then(function () { return IpcChildWithReferencePort; })
+    default:
+      throw new Error('unexpected ipc type')
+  }
+};
+
+const listen$4 = async ({ method }) => {
+  const module = await getModule(method);
+  return module.listen()
+};
+
+const getAbsolutePath = (isWeb, path, relativePath, origin) => {
+  if (path.startsWith('http')) {
+    if (path.endsWith('/')) {
+      return new URL(relativePath, path).toString()
+    }
+    return new URL(relativePath, path + '/').toString()
+  }
+  if (!path.startsWith('/')) {
+    path = '/' + path;
+  }
+  if (isWeb) {
+    return path + '/' + relativePath
+  }
+  return new URL('/remote' + path + '/' + relativePath, origin).toString()
+};
+
+const baseName = (path) => {
+  const slashIndex = path.lastIndexOf('/');
+  return path.slice(slashIndex + 1)
+};
+
+const getId = (extension) => {
+  if (extension && extension.id) {
+    return extension.id
+  }
+  if (extension && extension.path) {
+    return baseName(extension.path)
+  }
+  return '<unknown>'
+};
+
+const activate = async (extension) => {
+  try {
+    string(extension.path);
+    string(extension.browser);
+    const absolutePath = getAbsolutePath(
+      extension.isWeb,
+      extension.path,
+      extension.browser,
+      location.origin
+    );
+    const module = await import(absolutePath);
+    await module.activate();
+  } catch (error) {
+    const id = getId(extension);
+    throw new Error(`Failed to activate extension ${id}: ${error}`)
+  }
+  // console.info('activated', path)
+};
+
+const create$2 = (fnString) => {
+  return new Function('return ' + fnString)()
+};
+
+const nameAnonymousFunction = (fn, name) => {
+  Object.defineProperty(fn, 'name', {
+    value: name,
+  });
+};
+
+class ExecError extends Error {
+  constructor(stdout, stderr, exitCode) {
+    super(``);
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+  }
+}
+
+const mockExec = (fnString) => {
+  const fn = create$2(fnString);
+  nameAnonymousFunction(fn, 'mockExec');
+  // @ts-ignore
+  api.exec = async (command, args, options) => {
+    const { stdout, stderr, exitCode } = await fn(command, args, options);
+    if (exitCode !== 0) {
+      throw new ExecError(stdout, stderr, exitCode)
+    }
+    return { stdout, stderr, exitCode }
+  };
+};
+
+const getFn = (method) => {
+  switch (method) {
+    case 'ExtensionHostExtension.activate':
+    case 'ExtensionHostExtension.enableExtension':
+      return activate
+    case 'Reference.execute':
+    case 'References.execute':
+    case 'ExtensionHostReference.executeReferenceProvider':
+    case 'ExtensionHostReferences.executeReferenceProvider':
+      return executeReferenceProvider
+    case 'ExtensionHostCompletion.execute':
+      return executeCompletionProvider
+    case 'ExtensionHostTextDocument.syncFull':
+      return syncFull
+    case 'ExtensionHostTextDocument.setLanguageId':
+      return setLanguageId
+    case 'ExtensionHostTypeDefinition.executeTypeDefinitionProvider':
+      return executeTypeDefinitionProvider
+    case 'ExtensionHost.executeTabCompletionProvider':
+      return executeTabCompletionProvider
+    case 'ExtensionHostBraceCompletion.executeBraceCompletionProvider':
+      return executeBraceCompletionProvider
+    case 'ExtensionHostTextDocument.syncIncremental':
+      return syncIncremental
+    case 'ExtensionHostTextSearch.executeTextSearchProvider':
+      return executeTextSearchProvider
+    case 'ExtensionHostCommand.executeCommand':
+    case 'ExtensionHost.executeCommand':
+      return executeCommand
+    case 'Workspace.setWorkspacePath':
+      return setWorkspacePath
+    case 'ExtensionHostDefinition.executeDefinitionProvider':
+      return executeDefinitionProvider
+    case 'ExtensionHost.sourceControlGetChangedFiles':
+      return getChangedFiles
+    case 'ExtensionHostSourceControl.acceptInput':
+    case 'ExtensionHost.sourceControlAcceptInput':
+      return acceptInput
+    case 'ExtensionHostFormatting.executeFormattingProvider':
+      return executeFormattingProvider
+    case 'ExtensionHostMockExec.mockExec':
+      return mockExec
+    case 'ExtensionHostFileSystem.readFile':
+      return readFile
+    case 'ExtensionHostFileSystem.readDirWithFileTypes':
+      return readDirWithFileTypes
+    case 'ExtensionHostFileSystem.writeFile':
+      return writeFile
+    case 'ExtensionHostFileSystem.getPathSeparator':
+      return getPathSeparator
+    case 'ExtensionHostSourceControl.add':
+      return add
+    case 'ExtensionHostSourceContro.discard':
+      return discard
+    default:
+      throw new Error(`[extension-host-worker] method not found: ${method}`)
+  }
+};
+
+const execute = (method, ...params) => {
+  const fn = getFn(method);
+  return fn(...params)
+};
+
+const getErrorResponse = (message, error) => {
+  if (
+    error &&
+    error instanceof Error &&
+    error.message &&
+    error.message.startsWith('method not found')
+  ) {
+    return {
+      jsonrpc: Two,
+      id: message.id,
+      error: {
+        code: MethodNotFound,
+        message: error.message,
+        data: error.stack,
+      },
+    }
+  }
+  return {
+    jsonrpc: Two,
+    id: message.id,
+    error,
+  }
+};
+
+const getResponse = async (message) => {
+  try {
+    const result = await execute(message.method, ...message.params);
+    return {
+      jsonrpc: Two,
+      id: message.id,
+      result,
+    }
+  } catch (error) {
+    return getErrorResponse(message, error)
+  }
+};
+
+const listen$3 = (ipc) => {
+  const handleMessage = async (event) => {
+    const message = event.data;
+    if ('method' in message) {
+      const response = await getResponse(message);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        await logError(error);
+        const errorResponse = getErrorResponse(message, error);
+        ipc.send(errorResponse);
+      }
+    } else if ('result' in message) {
+      resolve(message.id, message.result);
+    } else if ('error' in message) {
+      reject(message.id, message.error);
+    } else {
+      console.log({ message });
+    }
+  };
+  ipc.onmessage = handleMessage;
+};
+
+const main = async () => {
+  onerror ||= handleUnhandledError;
+  onunhandledrejection ||= handleUnhandledRejection;
+  globalThis.vscode = api;
+  const ipc = await listen$4({ method: Auto() });
+  listen$3(ipc);
+};
+
+main();
+
+const getWebSocketProtocol = () => {
+  return location.protocol === 'https:' ? 'wss:' : 'ws:'
+};
+
+const getWsUrl = () => {
+  const wsProtocol = getWebSocketProtocol();
+  return `${wsProtocol}//${location.host}`
+};
+
+const create$1 = ({ protocol }) => {
+  // TODO replace this during build
+  const wsUrl = getWsUrl();
+  const webSocket = new WebSocket(wsUrl, [protocol]);
+  const pendingMessages = [];
+  webSocket.onopen = () => {
+    ipc.send = (message) => {
+      const stringifiedMessage = JSON.stringify(message);
+      webSocket.send(stringifiedMessage);
+    };
+    for (const message of pendingMessages) {
+      ipc.send(message);
+    }
+    pendingMessages.length = 0;
+  };
+  let handleMessage;
+  const ipc = {
+    get onmessage() {
+      return handleMessage
+    },
+    set onmessage(listener) {
+      if (listener) {
+        handleMessage = (event) => {
+          // TODO why are some events not instance of message event?
+          if (event instanceof MessageEvent) {
+            const message = JSON.parse(event.data);
+            listener(message);
+          } else {
+            listener(event);
+          }
+        };
+      } else {
+        handleMessage = null;
+      }
+      webSocket.onmessage = handleMessage;
+    },
+    send(message) {
+      pendingMessages.push(message);
+    },
+  };
+  return ipc
+};
+
+const IpcParentWithWebSocket = {
+  __proto__: null,
+  create: create$1
+};
+
+const getPort = () => {
+  return new Promise((resolve, reject) => {
+    const id = register(resolve, reject);
+    const message = {
+      jsonrpc: '2.0',
+      method: 'ElectronMessagePort.create',
+      params: [],
+      id,
+    };
+    postMessage(message);
+  })
+};
+
+const create = async () => {
+  const port = await getPort();
+  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
+};
+
+const listen$2 = () => {
+  const messageChannel = new MessageChannel();
+  const { port1, port2 } = messageChannel;
+  globalThis.acceptPort(port2);
+  return {
+    send(message) {
+      port1.postMessage(message);
+    },
+    sendAndTransfer(message, transferables) {
+      port1.postMessage(message, transferables);
+    },
+    get onmessage() {
+      return port1.onmessage
+    },
+    set onmessage(listener) {
+      port1.onmessage = listener;
+    },
+  }
+};
+
+const IpcChildWithMessagePort = {
+  __proto__: null,
+  listen: listen$2
+};
+
+const listen$1 = () => {
+  const postMessageFn = globalThis.postMessage;
+  postMessageFn('ready');
+  return {
+    send(message) {
+      postMessageFn(message);
+    },
+    sendAndTransfer(message, transferables) {
+      postMessageFn(message, transferables);
+    },
+    get onmessage() {
+      return onmessage
+    },
+    set onmessage(listener) {
+      onmessage = listener;
+    },
+  }
+};
+
+const IpcChildWithModuleWorker = {
+  __proto__: null,
+  listen: listen$1
+};
+
+const listen = () => {
+  const referencePort = {
+    onmessage(message, transferables) {},
+    postMessage() {},
+  };
+  // TODO get rid of extra data wrapper
+  globalThis.acceptReferencePort(referencePort);
+  return {
+    send(message) {
+      referencePort.onmessage({ data: message });
+    },
+    sendAndTransfer({ data: message }, transferables) {
+      referencePort.onmessage(message, transferables);
+    },
+    get onmessage() {
+      // TODO
+      return null
+    },
+    set onmessage(listener) {
+      // TODO
+    },
+  }
+};
+
+const IpcChildWithReferencePort = {
+  __proto__: null,
+  listen
+};
+//# sourceMappingURL=extensionHostWorkerMain.js.map