@lvce-editor/server 0.10.7 → 0.11.0

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

@@ -0,0 +1,862 @@
+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/IpcChild/IpcChildWithMessagePort.js
+var IpcChildWithMessagePort_exports = {};
+__export(IpcChildWithMessagePort_exports, {
+  listen: () => listen
+});
+var listen;
+var init_IpcChildWithMessagePort = __esm({
+  "src/parts/IpcChild/IpcChildWithMessagePort.js"() {
+    "use strict";
+    listen = () => {
+      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: () => listen2
+});
+var listen2;
+var init_IpcChildWithModuleWorker = __esm({
+  "src/parts/IpcChild/IpcChildWithModuleWorker.js"() {
+    "use strict";
+    listen2 = () => {
+      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: () => listen3
+});
+var listen3;
+var init_IpcChildWithReferencePort = __esm({
+  "src/parts/IpcChild/IpcChildWithReferencePort.js"() {
+    "use strict";
+    listen3 = () => {
+      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/Assert/Assert.js
+var 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";
+  }
+};
+var object = (value) => {
+  const type = getType2(value);
+  if (type !== "object") {
+    throw new Error("expected value to be of type object");
+  }
+};
+var number = (value) => {
+  const type = getType2(value);
+  if (type !== "number") {
+    throw new Error("expected value to be of type number");
+  }
+};
+var array = (value) => {
+  const type = getType2(value);
+  if (type !== "array") {
+    throw new Error("expected value to be of type array");
+  }
+};
+var string = (value) => {
+  const type = getType2(value);
+  if (type !== "string") {
+    throw new Error("expected value to be of type string");
+  }
+};
+
+// src/parts/ExtensionHostTextDocument/ExtensionHostTextDocument.js
+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) {
+    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/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/ExtensionHostExtension/ExtensionHostExtension.js
+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/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 state3 = {
+  providers: /* @__PURE__ */ Object.create(null)
+};
+var registerSourceControlProvider = (provider) => {
+  state3.providers[provider.id] = provider;
+};
+var getFilesFromProvider = (provider) => {
+  return provider.getChangedFiles();
+};
+var getChangedFiles = () => {
+  const providers = Object.values(state3.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 state4 = {
+  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");
+    }
+    state4.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+  } catch (error) {
+    throw new VError(error, `Failed to register text search provider`);
+  }
+};
+var executeTextSearchProvider = async (scheme, query) => {
+  try {
+    const textSearchProvider = state4.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/Api/Api.js
+var FormattingError = class extends Error {
+  constructor(message, codeFrame) {
+    super(message);
+    this.codeFrame = codeFrame;
+    this.name = "FormattingError";
+  }
+};
+var create2 = () => {
+  return {
+    registerBraceCompletionProvider,
+    executeBraceCompletionProvider,
+    registerCommand,
+    executeCommand,
+    registerCompletionProvider,
+    executeCompletionProvider,
+    registerDefinitionProvider,
+    executeDefinitionProvider,
+    FormattingError,
+    registerFormattingProvider,
+    executeFormattingProvider,
+    registerImplementationProvider,
+    executeImplementationProvider,
+    registerReferenceProvider,
+    executeReferenceProvider,
+    registerSourceControlProvider,
+    registerTabCompletionProvider,
+    executeTabCompletionProvider,
+    getTextFromTextDocument: getText,
+    registerTextSearchProvider,
+    executeTextSearchProvider,
+    registerTypeDefinitionProvider,
+    executeTypeDefinitionProvider
+  };
+};
+
+// 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 getModule = (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 listen4 = async ({ method }) => {
+  const module = await getModule(method);
+  return module.listen();
+};
+
+// src/parts/ExtensionHostWorkspace/ExtensionHostWorkspace.js
+var state5 = {
+  workspacePath: ""
+};
+var setWorkspacePath = (path) => {
+  state5.workspacePath = path;
+};
+
+// 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;
+    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
+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 listen5 = (ipc) => {
+  const handleMessage = async (event) => {
+    const message = event.data;
+    if (message.method) {
+      const response = await getResponse(message);
+      ipc.send(response);
+    }
+  };
+  ipc.onmessage = handleMessage;
+};
+
+// src/extensionHostWorkerMain.js
+var main = async () => {
+  globalThis.vscode = create2();
+  const ipc = await listen4({ method: Methods.Auto });
+  listen5(ipc);
+};
+main();
+//# sourceMappingURL=extensionHostWorkerMain.js.map