@lvce-editor/server 0.11.7 → 0.11.8

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

@@ -1,2345 +0,0 @@
-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