@lvce-editor/server 0.11.2 → 0.11.3

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

@@ -1,1207 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/parts/Assert/Assert.js
-var getType2, object, number, array, string;
-var init_Assert = __esm({
-  "src/parts/Assert/Assert.js"() {
-    "use strict";
-    getType2 = (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";
-      }
-    };
-    object = (value) => {
-      const type = getType2(value);
-      if (type !== "object") {
-        throw new Error("expected value to be of type object");
-      }
-    };
-    number = (value) => {
-      const type = getType2(value);
-      if (type !== "number") {
-        throw new Error("expected value to be of type number");
-      }
-    };
-    array = (value) => {
-      const type = getType2(value);
-      if (type !== "array") {
-        throw new Error("expected value to be of type array");
-      }
-    };
-    string = (value) => {
-      const type = getType2(value);
-      if (type !== "string") {
-        throw new Error("expected value to be of type string");
-      }
-    };
-  }
-});
-
-// src/parts/WebSocketProtocol/WebSocketProtocol.js
-var getWebSocketProtocol;
-var init_WebSocketProtocol = __esm({
-  "src/parts/WebSocketProtocol/WebSocketProtocol.js"() {
-    "use strict";
-    getWebSocketProtocol = () => {
-      return location.protocol === "https:" ? "wss:" : "ws:";
-    };
-  }
-});
-
-// src/parts/IpcParent/IpcParentWithWebSocket.js
-var IpcParentWithWebSocket_exports = {};
-__export(IpcParentWithWebSocket_exports, {
-  create: () => create2
-});
-var getWsUrl, create2;
-var init_IpcParentWithWebSocket = __esm({
-  "src/parts/IpcParent/IpcParentWithWebSocket.js"() {
-    "use strict";
-    init_WebSocketProtocol();
-    getWsUrl = () => {
-      const wsProtocol = getWebSocketProtocol();
-      return `${wsProtocol}//${location.host}`;
-    };
-    create2 = ({ protocol }) => {
-      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 handleMessage2;
-      const ipc = {
-        get onmessage() {
-          return handleMessage2;
-        },
-        set onmessage(listener) {
-          if (listener) {
-            handleMessage2 = (event) => {
-              if (event instanceof MessageEvent) {
-                const message = JSON.parse(event.data);
-                listener(message);
-              } else {
-                listener(event);
-              }
-            };
-          } else {
-            handleMessage2 = null;
-          }
-          webSocket.onmessage = handleMessage2;
-        },
-        send(message) {
-          pendingMessages.push(message);
-        }
-      };
-      return ipc;
-    };
-  }
-});
-
-// src/parts/Id/Id.js
-var state3, create3;
-var init_Id = __esm({
-  "src/parts/Id/Id.js"() {
-    "use strict";
-    state3 = {
-      id: 0
-    };
-    create3 = () => {
-      return ++state3.id;
-    };
-  }
-});
-
-// src/parts/Callback/Callback.js
-var state4, register, resolve, reject;
-var init_Callback = __esm({
-  "src/parts/Callback/Callback.js"() {
-    "use strict";
-    init_Assert();
-    init_Id();
-    state4 = {
-      callbacks: /* @__PURE__ */ Object.create(null)
-    };
-    register = (resolve2, reject2) => {
-      const id = create3();
-      state4.callbacks[id] = {
-        resolve: resolve2,
-        reject: reject2
-      };
-      return id;
-    };
-    resolve = (id, args) => {
-      number(id);
-      if (!(id in state4.callbacks)) {
-        console.log(args);
-        console.warn(`callback ${id} may already be disposed`);
-        return;
-      }
-      state4.callbacks[id].resolve(args);
-      delete state4.callbacks[id];
-    };
-    reject = (id, error) => {
-      number(id);
-      if (!(id in state4.callbacks)) {
-        console.warn(`callback ${id} may already be disposed`);
-        return;
-      }
-      state4.callbacks[id].reject(error);
-      delete state4.callbacks[id];
-    };
-  }
-});
-
-// src/parts/IpcParent/IpcParentWithElectronMessagePort.js
-var IpcParentWithElectronMessagePort_exports = {};
-__export(IpcParentWithElectronMessagePort_exports, {
-  create: () => create4
-});
-var getPort, create4;
-var init_IpcParentWithElectronMessagePort = __esm({
-  "src/parts/IpcParent/IpcParentWithElectronMessagePort.js"() {
-    "use strict";
-    init_Callback();
-    getPort = () => {
-      return new Promise((resolve2, reject2) => {
-        const id = register(resolve2, reject2);
-        const message = {
-          jsonrpc: "2.0",
-          method: "ElectronMessagePort.create",
-          params: [],
-          id
-        };
-        postMessage(message);
-      });
-    };
-    create4 = async () => {
-      const port = await getPort();
-      let handleMessage2;
-      return {
-        get onmessage() {
-          return handleMessage2;
-        },
-        set onmessage(listener) {
-          let handleMessage3;
-          if (listener) {
-            handleMessage3 = (event) => {
-              listener(event.data);
-            };
-          } else {
-            handleMessage3 = null;
-          }
-          port.onmessage = handleMessage3;
-        },
-        send(message) {
-          port.postMessage(message);
-        }
-      };
-    };
-  }
-});
-
-// src/parts/IpcChild/IpcChildWithMessagePort.js
-var IpcChildWithMessagePort_exports = {};
-__export(IpcChildWithMessagePort_exports, {
-  listen: () => listen2
-});
-var listen2;
-var init_IpcChildWithMessagePort = __esm({
-  "src/parts/IpcChild/IpcChildWithMessagePort.js"() {
-    "use strict";
-    listen2 = () => {
-      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;
-        }
-      };
-    };
-  }
-});
-
-// src/parts/IpcChild/IpcChildWithModuleWorker.js
-var IpcChildWithModuleWorker_exports = {};
-__export(IpcChildWithModuleWorker_exports, {
-  listen: () => listen3
-});
-var listen3;
-var init_IpcChildWithModuleWorker = __esm({
-  "src/parts/IpcChild/IpcChildWithModuleWorker.js"() {
-    "use strict";
-    listen3 = () => {
-      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;
-        }
-      };
-    };
-  }
-});
-
-// src/parts/IpcChild/IpcChildWithReferencePort.js
-var IpcChildWithReferencePort_exports = {};
-__export(IpcChildWithReferencePort_exports, {
-  listen: () => listen4
-});
-var listen4;
-var init_IpcChildWithReferencePort = __esm({
-  "src/parts/IpcChild/IpcChildWithReferencePort.js"() {
-    "use strict";
-    listen4 = () => {
-      const referencePort = {
-        onmessage(message, transferables) {
-        },
-        postMessage() {
-        }
-      };
-      globalThis.acceptReferencePort(referencePort);
-      return {
-        send(message) {
-          referencePort.onmessage({ data: message });
-        },
-        sendAndTransfer({ data: message }, transferables) {
-          referencePort.onmessage(message, transferables);
-        },
-        get onmessage() {
-          return null;
-        },
-        set onmessage(listener) {
-        }
-      };
-    };
-  }
-});
-
-// src/parts/Validation/Validation.js
-var 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";
-    case "undefined":
-      return "undefined";
-    default:
-      return "unknown";
-  }
-};
-var validateResultObject = (result, resultShape) => {
-  if (!resultShape.properties) {
-    return void 0;
-  }
-  for (const [key, value] of Object.entries(resultShape.properties)) {
-    const expectedType = value.type;
-    const actualType = getType(result[key]);
-    if (expectedType !== actualType) {
-      return `item.${key} must be of type ${expectedType}`;
-    }
-  }
-  return void 0;
-};
-var validateResultArray = (result, resultShape) => {
-  for (const item of result) {
-    const actualType = getType(item);
-    const expectedType = resultShape.items.type;
-    if (actualType !== expectedType) {
-      return `expected result to be of type ${expectedType} but was of type ${actualType}`;
-    }
-  }
-  return void 0;
-};
-var getPreviewObject = (item) => {
-  return "object";
-};
-var getPreviewArray = (item) => {
-  if (item.length === 0) {
-    return "[]";
-  }
-  return "array";
-};
-var getPreview = (item) => {
-  const type = getType(item);
-  switch (type) {
-    case "object":
-      return getPreviewObject(item);
-    case "array":
-      return getPreviewArray(item);
-    default:
-      return `${item}`;
-  }
-};
-var validate = (item, schema) => {
-  const actualType = getType(item);
-  const expectedType = schema.type;
-  if (actualType !== expectedType) {
-    if (schema.allowUndefined && item === void 0) {
-      return void 0;
-    }
-    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);
-  }
-  return void 0;
-};
-
-// src/parts/VError/VError.js
-var combineMessages = (error, message) => {
-  if (error && error.message) {
-    return `${message}: ${error.message}`;
-  }
-  return `${error}`;
-};
-var VError = class extends Error {
-  constructor(error, message) {
-    const combinedMessage = combineMessages(error, message);
-    super(combinedMessage);
-    this.name = "VError";
-  }
-};
-
-// src/parts/ExtensionHostTextDocument/ExtensionHostTextDocument.js
-init_Assert();
-var state = {
-  onDidOpenEditorListeners: [],
-  onWillChangeEditorListeners: [],
-  onDidChangeTextDocumentListeners: [],
-  onDidSaveTextDocumentListeners: [],
-  textDocuments: /* @__PURE__ */ Object.create(null)
-};
-var 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;
-};
-var runListenerSafe = async (listener, ...args) => {
-  try {
-    await listener(...args);
-  } catch (error) {
-    if (error && error.message) {
-      error.message = "Failed to run open listener: " + error.message;
-    }
-    console.error(error);
-  }
-};
-var runListenersSafe = (listeners, ...args) => {
-  for (const listener of listeners) {
-    runListenerSafe(listener, ...args);
-  }
-};
-var syncFull = (uri, textDocumentId, languageId, text) => {
-  const textDocument = {
-    uri,
-    documentId: textDocumentId,
-    languageId,
-    text
-  };
-  state.textDocuments[textDocumentId] = textDocument;
-  runListenersSafe(state.onDidOpenEditorListeners, textDocument);
-};
-var getSyntheticChanges = (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;
-};
-var syncIncremental = (textDocumentId, changes) => {
-  number(textDocumentId);
-  array(changes);
-  const textDocument = state.textDocuments[textDocumentId];
-  if (!textDocument) {
-    console.warn(
-      `sync not possible, no matching textDocument with id ${textDocumentId}`
-    );
-    return;
-  }
-  const syntheticChanges = getSyntheticChanges(textDocument, changes);
-  runListenersSafe(
-    state.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.onDidChangeTextDocumentListeners,
-    textDocument,
-    syntheticChanges
-  );
-};
-var get = (textDocumentId) => {
-  const textDocument = state.textDocuments[textDocumentId];
-  return textDocument;
-};
-var getText = (textDocument) => {
-  return textDocument.text;
-};
-var setLanguageId = (textDocumentId, languageId) => {
-  const newTextDocument = {
-    ...state.textDocuments[textDocumentId],
-    languageId
-  };
-  state.textDocuments[textDocumentId] = newTextDocument;
-  runListenersSafe(state.onDidOpenEditorListeners, newTextDocument);
-};
-
-// src/parts/Registry/Registry.js
-var RE_UPPERCASE_LETTER = /[A-Z]/g;
-var spaceOut = (camelCaseWord) => {
-  return camelCaseWord.replaceAll(RE_UPPERCASE_LETTER, (character, index) => {
-    if (index === 0) {
-      return character.toLowerCase();
-    }
-    return " " + character.toLowerCase();
-  });
-};
-var toCamelCase = (string2) => {
-  return string2[0].toLowerCase() + string2.slice(1);
-};
-var 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;
-};
-var NonError = class extends Error {
-  name = "NonError";
-  constructor(message) {
-    super(message);
-  }
-};
-var ensureError = (input) => {
-  if (!(input instanceof Error)) {
-    return new NonError(input);
-  }
-  return input;
-};
-var create = ({ name, resultShape, executeKey = "" }) => {
-  const providers = /* @__PURE__ */ 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;
-      }
-    }
-  };
-};
-
-// src/parts/ExtensionHostBraceCompletion/ExtensionHostBraceCompletion.js
-var {
-  registerBraceCompletionProvider,
-  executeBraceCompletionProvider,
-  reset
-} = create({
-  name: "BraceCompletion",
-  resultShape: {
-    type: "boolean"
-  }
-});
-
-// src/parts/ExtensionHostCommand/ExtensionHostCommand.js
-var state2 = {
-  commands: /* @__PURE__ */ Object.create(null)
-};
-var 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");
-    }
-    state2.commands[command.id] = command;
-  } catch (error) {
-    throw new VError(error, `Failed to register command`);
-  }
-};
-var executeCommand = async (id, ...args) => {
-  try {
-    const command = state2.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`);
-  }
-};
-
-// src/parts/ExtensionHostCompletion/ExtensionHostCompletion.js
-var { registerCompletionProvider, executeCompletionProvider } = create({
-  name: "Completion",
-  resultShape: {
-    type: "array",
-    items: {
-      type: "object"
-    }
-  }
-});
-
-// src/parts/ExtensionHostConfiguration/ExtensionHostConfiguration.js
-var getConfiguration = (key) => {
-  return "";
-};
-
-// src/parts/ExtensionHostDefinition/ExtensionHostDefinition.js
-var { registerDefinitionProvider, executeDefinitionProvider, reset: reset2 } = create({
-  name: "Definition",
-  resultShape: {
-    allowUndefined: true,
-    type: "object",
-    properties: {
-      uri: {
-        type: "string"
-      },
-      startOffset: {
-        type: "number"
-      },
-      endOffset: {
-        type: "number"
-      }
-    }
-  }
-});
-
-// src/parts/ExtensionHostEnv/ExtensionHostEnv.js
-var env = {};
-
-// src/parts/IpcParentType/IpcParentType.js
-var WebSocket2 = 5;
-var ElectronMessagePort = 6;
-
-// src/parts/IpcParent/IpcParent.js
-var getModule = (method) => {
-  switch (method) {
-    case WebSocket2:
-      return Promise.resolve().then(() => (init_IpcParentWithWebSocket(), IpcParentWithWebSocket_exports));
-    case ElectronMessagePort:
-      return Promise.resolve().then(() => (init_IpcParentWithElectronMessagePort(), IpcParentWithElectronMessagePort_exports));
-    default:
-      throw new Error("unexpected ipc type");
-  }
-};
-var create5 = async ({ method, ...options }) => {
-  const module = await getModule(method);
-  return module.create(options);
-};
-
-// src/parts/ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js
-var create6 = (method) => {
-  return create5({
-    method,
-    protocol: ["lvce.extension-host-helper-process"]
-  });
-};
-
-// src/parts/ExtensionHostHelperProcessIpcType/ExtensionHostHelperProcessIpcType.js
-var getIpcType = () => {
-  const isElectron = navigator.userAgent.includes("Electron");
-  if (isElectron) {
-    return ElectronMessagePort;
-  }
-  return WebSocket2;
-};
-
-// src/parts/ExtensionHostHelperProcessRpc/ExtensionHostHelperProcessRpc.js
-init_Callback();
-var handleMessage = (message) => {
-  if ("result" in message) {
-    resolve(message.id, message.result);
-  } else if ("error" in message) {
-    reject(message.id, message.error);
-  } else {
-    console.log({ message });
-  }
-};
-var listen = async (ipc) => {
-  ipc.onmessage = handleMessage;
-  return {
-    invoke(method, params) {
-      return new Promise((resolve2, reject2) => {
-        const id = register(resolve2, reject2);
-        ipc.send({
-          jsonrpc: "2.0",
-          method,
-          id,
-          params
-        });
-      });
-    }
-  };
-};
-
-// src/parts/ExtensionHostHelperProcess/ExtensionHostHelperProcess.js
-var state5 = {
-  rpcPromise: void 0
-};
-var getOrCreateRpc = () => {
-  if (!state5.rpcPromise) {
-    const type = getIpcType();
-    state5.rpcPromise = create6(type).then(
-      listen
-    );
-  }
-  return state5.rpcPromise;
-};
-var invoke = async (method, ...params) => {
-  const rpc = await getOrCreateRpc();
-  return rpc.invoke(method, params);
-};
-
-// src/parts/ExtensionHostExec/ExtensionHostExec.js
-var ExecError = class extends Error {
-  constructor(stdout, stderr, exitCode) {
-    super(`Failed to execute`);
-    this.stdout = stdout;
-    this.stderr = stderr;
-    this.exitCode = exitCode;
-  }
-};
-var exec = async (command, args, options) => {
-  const { stdout, stderr, exitCode } = await invoke(
-    "Exec.exec",
-    command,
-    args
-  );
-  if (exitCode !== 0) {
-    throw new ExecError(stdout, stderr, exitCode);
-  }
-  return {
-    stdout,
-    stderr,
-    exitCode
-  };
-};
-
-// src/parts/ExtensionHostFormatting/ExtensionHostFormatting.js
-var { registerFormattingProvider, executeFormattingProvider, reset: reset3 } = create({
-  name: "Formatting",
-  executeKey: "format",
-  resultShape: {
-    allowUndefined: true,
-    type: "array",
-    items: {
-      type: "object",
-      properties: {
-        startOffset: {
-          type: "number"
-        },
-        endOffset: {
-          type: "number"
-        },
-        inserted: {
-          type: "string"
-        }
-      }
-    }
-  }
-});
-
-// src/parts/ExtensionHostImplementation/ExtensionHostImplementation.js
-var { registerImplementationProvider, executeImplementationProvider, reset: reset4 } = create({
-  name: "Implementation",
-  resultShape: {
-    type: "array",
-    items: {
-      type: "object"
-    }
-  }
-});
-
-// src/parts/ExtensionHostReference/ExtensionHostReference.js
-var { registerReferenceProvider, executeReferenceProvider, reset: reset5 } = create({
-  name: "Reference",
-  resultShape: {
-    type: "array",
-    items: {
-      type: "object"
-    }
-  }
-});
-
-// src/parts/ExtensionHostSourceControl/ExtensionHostSourceControl.js
-var state6 = {
-  providers: /* @__PURE__ */ Object.create(null)
-};
-var registerSourceControlProvider = (provider) => {
-  state6.providers[provider.id] = provider;
-};
-var getFilesFromProvider = (provider) => {
-  return provider.getChangedFiles();
-};
-var getChangedFiles = () => {
-  const providers = Object.values(state6.providers);
-  const changedFiles = providers.map(getFilesFromProvider);
-  const flattenedChangedFiles = changedFiles.flat(1);
-  return flattenedChangedFiles;
-};
-
-// src/parts/ExtensionHostTabCompletion/ExtensionHostTabCompletion.js
-var { registerTabCompletionProvider, executeTabCompletionProvider, reset: reset6 } = create({
-  name: "TabCompletion",
-  resultShape: {
-    type: "object",
-    allowUndefined: true
-  }
-});
-
-// src/parts/ExtensionHostTextSearch/ExtensionHostTextSearch.js
-var state7 = {
-  textSearchProviders: /* @__PURE__ */ Object.create(null)
-};
-var registerTextSearchProvider = (textSearchProvider) => {
-  try {
-    if (!textSearchProvider) {
-      throw new Error("textSearchProvider is not defined");
-    }
-    if (!textSearchProvider.scheme) {
-      throw new Error("textSearchProvider is missing scheme");
-    }
-    state7.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
-  } catch (error) {
-    throw new VError(error, `Failed to register text search provider`);
-  }
-};
-var executeTextSearchProvider = async (scheme, query) => {
-  try {
-    const textSearchProvider = state7.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`);
-  }
-};
-
-// src/parts/ExtensionHostTypeDefinition/ExtensionHostTypeDefinition.js
-var { registerTypeDefinitionProvider, executeTypeDefinitionProvider, reset: reset7 } = create({
-  name: "TypeDefinition",
-  resultShape: {
-    allowUndefined: true,
-    type: "object",
-    properties: {
-      uri: {
-        type: "string"
-      },
-      startOffset: {
-        type: "number"
-      },
-      endOffset: {
-        type: "number"
-      }
-    }
-  }
-});
-
-// src/parts/ExtensionHostWorkspace/ExtensionHostWorkspace.js
-var state8 = {
-  workspacePath: ""
-};
-var setWorkspacePath = (path) => {
-  state8.workspacePath = path;
-};
-var getWorkspaceFolder = (path) => {
-  return state8.workspacePath;
-};
-
-// src/parts/Api/Api.js
-var FormattingError = class extends Error {
-  constructor(message, codeFrame) {
-    super(message);
-    this.codeFrame = codeFrame;
-    this.name = "FormattingError";
-  }
-};
-var api = {
-  registerBraceCompletionProvider,
-  executeBraceCompletionProvider,
-  registerCommand,
-  executeCommand,
-  registerCompletionProvider,
-  executeCompletionProvider,
-  getConfiguration,
-  registerDefinitionProvider,
-  executeDefinitionProvider,
-  env,
-  FormattingError,
-  VError,
-  exec,
-  registerFormattingProvider,
-  executeFormattingProvider,
-  registerImplementationProvider,
-  executeImplementationProvider,
-  registerReferenceProvider,
-  executeReferenceProvider,
-  registerSourceControlProvider,
-  registerTabCompletionProvider,
-  executeTabCompletionProvider,
-  getTextFromTextDocument: getText,
-  registerTextSearchProvider,
-  executeTextSearchProvider,
-  registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider,
-  getWorkspaceFolder
-};
-
-// src/parts/IpcChild/IpcChild.js
-var Methods = {
-  MessagePort: 1,
-  ModuleWorker: 2,
-  ReferencePort: 3,
-  get Auto() {
-    if (globalThis.acceptPort) {
-      return Methods.MessagePort;
-    }
-    if (globalThis.acceptReferencePort) {
-      return Methods.ReferencePort;
-    }
-    return Methods.ModuleWorker;
-  }
-};
-var getModule2 = (method) => {
-  switch (method) {
-    case Methods.MessagePort:
-      return Promise.resolve().then(() => (init_IpcChildWithMessagePort(), IpcChildWithMessagePort_exports));
-    case Methods.ModuleWorker:
-      return Promise.resolve().then(() => (init_IpcChildWithModuleWorker(), IpcChildWithModuleWorker_exports));
-    case Methods.ReferencePort:
-      return Promise.resolve().then(() => (init_IpcChildWithReferencePort(), IpcChildWithReferencePort_exports));
-    default:
-      throw new Error("unexpected ipc type");
-  }
-};
-var listen5 = async ({ method }) => {
-  const module = await getModule2(method);
-  return module.listen();
-};
-
-// src/parts/ExtensionHostExtension/ExtensionHostExtension.js
-init_Assert();
-var 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();
-};
-var baseName = (path) => {
-  const slashIndex = path.lastIndexOf("/");
-  return path.slice(slashIndex + 1);
-};
-var getId = (extension) => {
-  if (extension && extension.id) {
-    return extension.id;
-  }
-  if (extension && extension.path) {
-    return baseName(extension.path);
-  }
-  return "<unknown>";
-};
-var 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}`);
-  }
-};
-
-// src/parts/FunctionFromString/FunctionFromString.js
-var create7 = (fnString) => {
-  return new Function("return " + fnString)();
-};
-
-// src/parts/NameAnonymousFunction/NameAnonymousFunction.js
-var nameAnonymousFunction = (fn, name) => {
-  Object.defineProperty(fn, "name", {
-    value: name
-  });
-};
-
-// src/parts/ExtensionHostMockExec/ExtensionHostMockExec.js
-var ExecError2 = class extends Error {
-  constructor(stdout, stderr, exitCode) {
-    super(``);
-    this.stdout = stdout;
-    this.stderr = stderr;
-    this.exitCode = exitCode;
-  }
-};
-var mockExec = (fnString) => {
-  const fn = create7(fnString);
-  nameAnonymousFunction(fn, "mockExec");
-  api.exec = async (command, args, options) => {
-    const { stdout, stderr, exitCode } = await fn(command, args, options);
-    if (exitCode !== 0) {
-      throw new ExecError2(stdout, stderr, exitCode);
-    }
-    return { stdout, stderr, exitCode };
-  };
-};
-
-// src/parts/Command/Command.js
-var 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 "ExtensionHostFormatting.executeFormattingProvider":
-      return executeFormattingProvider;
-    case "ExtensionHostMockExec.mockExec":
-      return mockExec;
-    default:
-      throw new Error(`[extension-host-worker] method not found: ${method}`);
-  }
-};
-var execute = (method, ...params) => {
-  const fn = getFn(method);
-  return fn(...params);
-};
-
-// src/parts/JsonRpcErrorCode/JsonRpcErrorCode.js
-var MethodNotFound = -32601;
-
-// src/parts/JsonRpcVersion/JsonRpcVersion.js
-var Two = "2.0";
-
-// src/parts/Rpc/Rpc.js
-init_Callback();
-var getResponse = async (message) => {
-  try {
-    const result = await execute(message.method, ...message.params);
-    return {
-      jsonrpc: Two,
-      id: message.id,
-      result
-    };
-  } catch (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
-    };
-  }
-};
-var listen6 = (ipc) => {
-  const handleMessage2 = async (event) => {
-    const message = event.data;
-    if ("method" in message) {
-      const response = await getResponse(message);
-      ipc.send(response);
-    } 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 = handleMessage2;
-};
-
-// src/extensionHostWorkerMain.js
-var main = async () => {
-  globalThis.vscode = api;
-  const ipc = await listen5({ method: Methods.Auto });
-  listen6(ipc);
-};
-main();
-//# sourceMappingURL=extensionHostWorkerMain.js.map