@lvce-editor/server 0.11.2 → 0.11.3

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

@@ -0,0 +1,1286 @@
+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/ExtensionHostFileSystem/ExtensionHostFileSystem.js
+var state9 = {
+  fileSystemProviderMap: /* @__PURE__ */ Object.create(null)
+};
+var getFileSystemProvider = (protocol) => {
+  const provider = state9.fileSystemProviderMap[protocol];
+  if (!provider) {
+    throw new VError(`no file system provider for protocol "${protocol}" found`);
+  }
+  return provider;
+};
+var registerFileSystemProvider = (fileSystemProvider) => {
+  if (!fileSystemProvider.id) {
+    throw new Error(`Failed to register file system provider: missing id`);
+  }
+  state9.fileSystemProviderMap[fileSystemProvider.id] = fileSystemProvider;
+};
+var 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");
+  }
+};
+var 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");
+  }
+};
+var 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");
+  }
+};
+var getPathSeparator = (protocol) => {
+  try {
+    const provider = getFileSystemProvider(protocol);
+    return provider.pathSeparator;
+  } catch (error) {
+    throw new VError(error, "Failed to execute file system provider");
+  }
+};
+
+// src/parts/EditorCompletionType/EditorCompletionType.js
+var EditorCompletionType_exports = {};
+__export(EditorCompletionType_exports, {
+  File: () => File,
+  Folder: () => Folder,
+  Function: () => Function2,
+  Keyword: () => Keyword,
+  Property: () => Property,
+  Value: () => Value,
+  Variable: () => Variable
+});
+var Property = 1;
+var Value = 2;
+var Function2 = 3;
+var Variable = 4;
+var Keyword = 5;
+var Folder = 6;
+var File = 7;
+
+// 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,
+  EditorCompletionType: EditorCompletionType_exports,
+  getConfiguration,
+  registerDefinitionProvider,
+  executeDefinitionProvider,
+  env,
+  FormattingError,
+  VError,
+  exec,
+  registerFileSystemProvider,
+  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;
+    case "ExtensionHostFileSystem.readFile":
+      return readFile;
+    case "ExtensionHostFileSystem.readDirWithFileTypes":
+      return readDirWithFileTypes;
+    case "ExtensionHostFileSystem.writeFile":
+      return writeFile;
+    case "ExtensionHostFileSystem.getPathSeparator":
+      return getPathSeparator;
+    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