@lvce-editor/extension-host-worker 8.16.0 → 8.17.0

package/dist/extension-api/index.js

@@ -0,0 +1,1360 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/extension-api/node_modules/@lvce-editor/verror/dist/index.js
+var normalizeLine = (line) => {
+  if (line.startsWith("Error: ")) {
+    return line.slice("Error: ".length);
+  }
+  if (line.startsWith("VError: ")) {
+    return line.slice("VError: ".length);
+  }
+  return line;
+};
+var getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+var NewLine = "\n";
+var getNewLineIndex = (string2, startIndex = void 0) => {
+  return string2.indexOf(NewLine, startIndex);
+};
+var mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex(parent);
+  const childNewLineIndex = getNewLineIndex(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+var VError = class extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = "VError";
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      this.code = error.code;
+    }
+  }
+};
+
+// packages/extension-api/node_modules/@lvce-editor/ipc/dist/index.js
+var isMessagePort = (value) => {
+  return value && value instanceof MessagePort;
+};
+var isMessagePortMain = (value) => {
+  return value && value.constructor && value.constructor.name === "MessagePortMain";
+};
+var isOffscreenCanvas = (value) => {
+  return typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas;
+};
+var isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+var isSocket = (value) => {
+  return isInstanceOf(value, "Socket");
+};
+var transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+var isTransferrable = (value) => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+var walkValue = (value, transferrables2, isTransferrable2) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable2(value)) {
+    transferrables2.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables2, isTransferrable2);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables2, isTransferrable2);
+    }
+    return;
+  }
+};
+var getTransferrables = (value) => {
+  const transferrables2 = [];
+  walkValue(value, transferrables2, isTransferrable);
+  return transferrables2;
+};
+var attachEvents = (that) => {
+  const handleMessage2 = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent("message", {
+      data
+    }));
+  };
+  that.onMessage(handleMessage2);
+  const handleClose = (event) => {
+    that.dispatchEvent(new Event("close"));
+  };
+  that.onClose(handleClose);
+};
+var Ipc = class extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+};
+var E_INCOMPATIBLE_NATIVE_MODULE = "E_INCOMPATIBLE_NATIVE_MODULE";
+var E_MODULES_NOT_SUPPORTED_IN_ELECTRON = "E_MODULES_NOT_SUPPORTED_IN_ELECTRON";
+var ERR_MODULE_NOT_FOUND = "ERR_MODULE_NOT_FOUND";
+var NewLine2 = "\n";
+var joinLines = (lines) => {
+  return lines.join(NewLine2);
+};
+var RE_AT = /^\s+at/;
+var RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+var isNormalStackLine = (line) => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+var getDetails = (lines) => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
+  return {
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
+  };
+};
+var splitLines = (lines) => {
+  return lines.split(NewLine2);
+};
+var RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+var RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+var isMessageCodeBlockStartIndex = (line) => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+var isMessageCodeBlockEndIndex = (line) => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+var getMessageCodeBlock = (stderr) => {
+  const lines = splitLines(stderr);
+  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
+  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
+  const relevantLines = lines.slice(startIndex, endIndex);
+  const relevantMessage = relevantLines.join(" ").slice("Error: ".length);
+  return relevantMessage;
+};
+var isModuleNotFoundMessage = (line) => {
+  return line.includes("[ERR_MODULE_NOT_FOUND]");
+};
+var getModuleNotFoundError = (stderr) => {
+  const lines = splitLines(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    code: ERR_MODULE_NOT_FOUND,
+    message
+  };
+};
+var isModuleNotFoundError = (stderr) => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes("ERR_MODULE_NOT_FOUND");
+};
+var isModulesSyntaxError = (stderr) => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes("SyntaxError: Cannot use import statement outside a module");
+};
+var RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+var RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+var isUnhelpfulNativeModuleError = (stderr) => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+var getNativeModuleErrorMessage = (stderr) => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
+  };
+};
+var getModuleSyntaxError = () => {
+  return {
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
+  };
+};
+var getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    code: "",
+    message: actualMessage,
+    stack: rest
+  };
+};
+var IpcError = class extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = "", stderr = "") {
+    if (stdout || stderr) {
+      const {
+        code,
+        message,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      cause.code = code;
+      cause.stack = stack;
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    this.name = "IpcError";
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+};
+var readyMessage = "ready";
+var getData$2 = (event) => {
+  return event.data;
+};
+var listen$7 = () => {
+  if (typeof WorkerGlobalScope === "undefined") {
+    throw new TypeError("module is not in web worker scope");
+  }
+  return globalThis;
+};
+var signal$8 = (global) => {
+  global.postMessage(readyMessage);
+};
+var IpcChildWithModuleWorker = class extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+  }
+  onClose(callback) {
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener("message", callback);
+  }
+};
+var wrap$f = (global) => {
+  return new IpcChildWithModuleWorker(global);
+};
+var waitForFirstMessage = async (port) => {
+  const {
+    promise,
+    resolve: resolve2
+  } = Promise.withResolvers();
+  port.addEventListener("message", resolve2, {
+    once: true
+  });
+  const event = await promise;
+  return event.data;
+};
+var listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$8(parentIpcRaw);
+  const parentIpc = wrap$f(parentIpcRaw);
+  const firstMessage = await waitForFirstMessage(parentIpc);
+  if (firstMessage.method !== "initialize") {
+    throw new IpcError("unexpected first message");
+  }
+  const type = firstMessage.params[0];
+  if (type === "message-port") {
+    parentIpc.send({
+      id: firstMessage.id,
+      jsonrpc: "2.0",
+      result: null
+    });
+    parentIpc.dispose();
+    const port = firstMessage.params[1];
+    return port;
+  }
+  return globalThis;
+};
+var IpcChildWithModuleWorkerAndMessagePort = class extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    if (this._rawIpc.close) {
+      this._rawIpc.close();
+    }
+  }
+  onClose(callback) {
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener("message", callback);
+    this._rawIpc.start();
+  }
+};
+var wrap$e = (port) => {
+  return new IpcChildWithModuleWorkerAndMessagePort(port);
+};
+var IpcChildWithModuleWorkerAndMessagePort$1 = {
+  __proto__: null,
+  listen: listen$6,
+  wrap: wrap$e
+};
+var addListener = (emitter, type, callback) => {
+  if ("addEventListener" in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+var removeListener = (emitter, type, callback) => {
+  if ("removeEventListener" in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+var getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    promise,
+    resolve: resolve2
+  } = Promise.withResolvers();
+  const listenerMap = /* @__PURE__ */ Object.create(null);
+  const cleanup = (value) => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve2(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = (event2) => {
+      cleanup({
+        event: event2,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+var Message$1 = 3;
+var create$5 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError("port must be of type MessagePort");
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    event,
+    type
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError("Failed to wait for ipc message");
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError("unexpected first message");
+  }
+  return messagePort;
+};
+var signal$1 = (messagePort) => {
+  messagePort.start();
+};
+var IpcParentWithMessagePort = class extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener("message", callback);
+  }
+  onClose(callback) {
+  }
+};
+var wrap$5 = (messagePort) => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+var IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5,
+  signal: signal$1,
+  wrap: wrap$5
+};
+
+// packages/extension-api/node_modules/@lvce-editor/command/dist/index.js
+var CommandNotFoundError = class extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = "CommandNotFoundError";
+  }
+};
+var commands = /* @__PURE__ */ Object.create(null);
+var register = (commandMap5) => {
+  Object.assign(commands, commandMap5);
+};
+var getCommand = (key) => {
+  return commands[key];
+};
+var execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+// packages/extension-api/node_modules/@lvce-editor/json-rpc/dist/index.js
+var Two = "2.0";
+var callbacks = /* @__PURE__ */ Object.create(null);
+var get = (id2) => {
+  return callbacks[id2];
+};
+var remove = (id2) => {
+  delete callbacks[id2];
+};
+var JsonRpcError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JsonRpcError";
+  }
+};
+var NewLine3 = "\n";
+var DomException = "DOMException";
+var ReferenceError$1 = "ReferenceError";
+var SyntaxError$1 = "SyntaxError";
+var TypeError$1 = "TypeError";
+var getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case ReferenceError$1:
+        return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith("TypeError: ")) {
+    return TypeError;
+  }
+  if (message.startsWith("SyntaxError: ")) {
+    return SyntaxError;
+  }
+  if (message.startsWith("ReferenceError: ")) {
+    return ReferenceError;
+  }
+  return Error;
+};
+var constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== "VError") {
+      error.name = name;
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+var joinLines2 = (lines) => {
+  return lines.join(NewLine3);
+};
+var splitLines2 = (lines) => {
+  return lines.split(NewLine3);
+};
+var getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines2(splitLines2(new Error().stack || "").slice(stackLinesToSkip));
+  return currentStack;
+};
+var getNewLineIndex2 = (string2, startIndex = void 0) => {
+  return string2.indexOf(NewLine3, startIndex);
+};
+var getParentStack = (error) => {
+  let parentStack = error.stack || error.data || error.message || "";
+  if (parentStack.startsWith("    at")) {
+    parentStack = error.message + NewLine3 + parentStack;
+  }
+  return parentStack;
+};
+var MethodNotFound = -32601;
+var Custom = -32001;
+var restoreJsonRpcError = (error) => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    if (typeof error.stack === "string") {
+      error.stack = error.stack + NewLine3 + currentStack;
+    }
+    return error;
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    const restoredError = new JsonRpcError(error.message);
+    const parentStack = getParentStack(error);
+    restoredError.stack = parentStack + NewLine3 + currentStack;
+    return restoredError;
+  }
+  if (error && error.message) {
+    const restoredError = constructError(error.message, error.type, error.name);
+    if (error.data) {
+      if (error.data.stack && error.data.type && error.message) {
+        restoredError.stack = error.data.type + ": " + error.message + NewLine3 + error.data.stack + NewLine3 + currentStack;
+      } else if (error.data.stack) {
+        restoredError.stack = error.data.stack;
+      }
+      if (error.data.codeFrame) {
+        restoredError.codeFrame = error.data.codeFrame;
+      }
+      if (error.data.code) {
+        restoredError.code = error.data.code;
+      }
+      if (error.data.type) {
+        restoredError.name = error.data.type;
+      }
+    } else {
+      if (error.stack) {
+        const lowerStack = restoredError.stack || "";
+        const indexNewLine = getNewLineIndex2(lowerStack);
+        const parentStack = getParentStack(error);
+        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
+      }
+      if (error.codeFrame) {
+        restoredError.codeFrame = error.codeFrame;
+      }
+    }
+    return restoredError;
+  }
+  if (typeof error === "string") {
+    return new Error(`JsonRpc Error: ${error}`);
+  }
+  return new Error(`JsonRpc Error: ${error}`);
+};
+var unwrapJsonRpcResult = (responseMessage) => {
+  if ("error" in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ("result" in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError("unexpected response message");
+};
+var warn = (...args) => {
+  console.warn(...args);
+};
+var resolve = (id2, response) => {
+  const fn = get(id2);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id2} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove(id2);
+};
+var E_COMMAND_NOT_FOUND = "E_COMMAND_NOT_FOUND";
+var getErrorType = (prettyError) => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return void 0;
+};
+var isAlreadyStack = (line) => {
+  return line.trim().startsWith("at ");
+};
+var getStack = (prettyError) => {
+  const stackString = prettyError.stack || "";
+  const newLineIndex = stackString.indexOf("\n");
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+var getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      data: error.stack,
+      message: error.message
+    };
+  }
+  return {
+    code: Custom,
+    data: {
+      code: prettyError.code,
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
+  };
+};
+var create$1 = (id2, error) => {
+  return {
+    error,
+    id: id2,
+    jsonrpc: Two
+  };
+};
+var getErrorResponse = (id2, error, preparePrettyError2, logError2) => {
+  const prettyError = preparePrettyError2(error);
+  logError2(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1(id2, errorProperty);
+};
+var create = (message, result) => {
+  return {
+    id: message.id,
+    jsonrpc: Two,
+    result: result ?? null
+  };
+};
+var getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create(message, resultProperty);
+};
+var getErrorResponseSimple = (id2, error) => {
+  return {
+    error: {
+      code: Custom,
+      data: error,
+      // @ts-ignore
+      message: error.message
+    },
+    id: id2,
+    jsonrpc: Two
+  };
+};
+var getResponse = async (message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2) => {
+  try {
+    const result = requiresSocket2(message.method) ? await execute2(message.method, ipc, ...message.params) : await execute2(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError2, logError2);
+  }
+};
+var defaultPreparePrettyError = (error) => {
+  return error;
+};
+var defaultLogError = () => {
+};
+var defaultRequiresSocket = () => {
+  return false;
+};
+var defaultResolve = resolve;
+var normalizeParams = (args) => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      execute: options.execute,
+      ipc: options.ipc,
+      logError: options.logError || defaultLogError,
+      message: options.message,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
+    };
+  }
+  return {
+    execute: args[2],
+    ipc: args[0],
+    logError: args[5],
+    message: args[1],
+    preparePrettyError: args[4],
+    requiresSocket: args[6],
+    resolve: args[3]
+  };
+};
+var handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    execute: execute2,
+    ipc,
+    logError: logError2,
+    message,
+    preparePrettyError: preparePrettyError2,
+    requiresSocket: requiresSocket2,
+    resolve: resolve2
+  } = options;
+  if ("id" in message) {
+    if ("method" in message) {
+      const response = await getResponse(message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError2, logError2);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve2(message.id, message);
+    return;
+  }
+  if ("method" in message) {
+    await getResponse(message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2);
+    return;
+  }
+  throw new JsonRpcError("unexpected message");
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/JsonRpcVersion/JsonRpcVersion.js
+var Two2 = "2.0";
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/JsonRpcEvent/JsonRpcEvent.js
+var create2 = (method, params) => {
+  return {
+    jsonrpc: Two2,
+    method,
+    params
+  };
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/JsonRpcRequest/JsonRpcRequest.js
+var create3 = (id2, method, params) => {
+  const message = {
+    id: id2,
+    jsonrpc: Two2,
+    method,
+    params
+  };
+  return message;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/Id/Id.js
+var id = 0;
+var create4 = () => {
+  return ++id;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/RegisterPromise/RegisterPromise.js
+var registerPromise = (map) => {
+  const id2 = create4();
+  const { promise, resolve: resolve2 } = Promise.withResolvers();
+  map[id2] = resolve2;
+  return { id: id2, promise };
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/CreateRpc/CreateRpc.js
+var invokeHelper = async (callbacks2, ipc, method, params, useSendAndTransfer) => {
+  const { id: id2, promise } = registerPromise(callbacks2);
+  const message = create3(id2, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+var createRpc = (ipc) => {
+  const callbacks2 = /* @__PURE__ */ Object.create(null);
+  ipc._resolve = (id2, response) => {
+    const fn = callbacks2[id2];
+    if (!fn) {
+      console.warn(`callback ${id2} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks2[id2];
+  };
+  const rpc2 = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks2, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks2, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create2(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc2;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/HandleMessage/HandleMessage.js
+var requiresSocket = () => {
+  return false;
+};
+var preparePrettyError = (error) => {
+  return error;
+};
+var logError = () => {
+};
+var handleMessage = (event) => {
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/HandleIpc/HandleIpc.js
+var handleIpc = (ipc) => {
+  if ("addEventListener" in ipc) {
+    ipc.addEventListener("message", handleMessage);
+  } else if ("on" in ipc) {
+    ipc.on("message", handleMessage);
+  }
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/IpcChildNode/IpcChildNode.js
+var listen = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/PlainMessagePortRpc/PlainMessagePortRpc.js
+var PlainMessagePortRpc_exports = {};
+__export(PlainMessagePortRpc_exports, {
+  create: () => create5
+});
+var create5 = async ({ commandMap: commandMap5, isMessagePortOpen = true, messagePort }) => {
+  register(commandMap5);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc2 = createRpc(ipc);
+  messagePort.start();
+  return rpc2;
+};
+
+// packages/extension-api/node_modules/@lvce-editor/rpc/dist/parts/WebWorkerRpcClient/WebWorkerRpcClient.js
+var WebWorkerRpcClient_exports = {};
+__export(WebWorkerRpcClient_exports, {
+  create: () => create6
+});
+var create6 = async ({ commandMap: commandMap5 }) => {
+  register(commandMap5);
+  const ipc = await listen(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc2 = createRpc(ipc);
+  return rpc2;
+};
+
+// packages/extension-api/src/parts/ExtensionApiError/ExtensionApiError.ts
+var ExtensionApiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExtensionApiError";
+  }
+};
+
+// packages/extension-api/src/parts/CommandRegistry/CommandRegistry.ts
+var commands2 = /* @__PURE__ */ Object.create(null);
+var assertCommand = (command) => {
+  if (!command) {
+    throw new ExtensionApiError("command is not defined");
+  }
+  if (typeof command.id !== "string" || command.id.length === 0) {
+    throw new ExtensionApiError("command is missing id");
+  }
+  if (typeof command.execute !== "function") {
+    throw new ExtensionApiError(`command ${command.id} is missing execute function`);
+  }
+  if (command.id in commands2) {
+    throw new ExtensionApiError(`command ${command.id} is already registered`);
+  }
+};
+var registerCommand = (command) => {
+  assertCommand(command);
+  commands2[command.id] = {
+    execute(...args) {
+      return command.execute(...args);
+    },
+    id: command.id
+  };
+  return {
+    dispose() {
+      delete commands2[command.id];
+    }
+  };
+};
+var getCommandRegistrySnapshot = () => {
+  return {
+    commands: Object.values(commands2)
+  };
+};
+var executeCommand = async (id2, ...args) => {
+  const command = commands2[id2];
+  if (!command) {
+    throw new ExtensionApiError(`command ${id2} not found`);
+  }
+  return command.execute(...args);
+};
+
+// packages/extension-api/src/parts/ProviderRegistry/ProviderRegistry.ts
+var getProviderMethod = (provider, methodName) => {
+  const method = provider[methodName];
+  if (typeof method !== "function") {
+    return void 0;
+  }
+  return method;
+};
+var assertProviderMethod = (provider, providerName, providerId, methodName) => {
+  if (typeof provider[methodName] !== "function") {
+    throw new ExtensionApiError(`${providerName} ${providerId} is missing ${methodName} function`);
+  }
+};
+var assertOptionalProviderMethod = (provider, providerName, providerId, methodName) => {
+  if (provider[methodName] !== void 0 && typeof provider[methodName] !== "function") {
+    throw new ExtensionApiError(`${providerName} ${providerId} has invalid ${methodName} function`);
+  }
+};
+var createProviderRegistry = ({
+  mapProvider,
+  optionalMethods = [],
+  providerName,
+  requiredMethods,
+  requireLanguageId = false
+}) => {
+  const providers = /* @__PURE__ */ Object.create(null);
+  const hasProvider = (id2) => {
+    return id2 in providers;
+  };
+  const registerProvider = (provider) => {
+    if (!provider) {
+      throw new ExtensionApiError(`${providerName} is not defined`);
+    }
+    const providerRecord = provider;
+    const { id: id2 } = providerRecord;
+    if (typeof id2 !== "string" || id2.length === 0) {
+      throw new ExtensionApiError(`${providerName} is missing id`);
+    }
+    if (requireLanguageId && (typeof providerRecord.languageId !== "string" || providerRecord.languageId.length === 0)) {
+      throw new ExtensionApiError(`${providerName} ${id2} is missing languageId`);
+    }
+    for (const methodName of requiredMethods) {
+      assertProviderMethod(providerRecord, providerName, id2, methodName);
+    }
+    for (const methodName of optionalMethods) {
+      assertOptionalProviderMethod(providerRecord, providerName, id2, methodName);
+    }
+    if (hasProvider(id2)) {
+      throw new ExtensionApiError(`${providerName} ${id2} is already registered`);
+    }
+    const registeredProvider = mapProvider(provider);
+    providers[registeredProvider.id] = registeredProvider;
+    return registeredProvider;
+  };
+  const deleteProvider = (id2) => {
+    delete providers[id2];
+  };
+  const getProviders = () => {
+    return Object.values(providers);
+  };
+  const getProviderByLanguageId = (languageId) => {
+    return getProviders().find((provider) => {
+      return "languageId" in provider && provider.languageId === languageId;
+    });
+  };
+  const reset = () => {
+    for (const id2 of Object.keys(providers)) {
+      delete providers[id2];
+    }
+  };
+  const executeProviderByLanguageId = async (languageId, methodName, args, validateResult) => {
+    const provider = getProviderByLanguageId(languageId);
+    if (!provider) {
+      throw new ExtensionApiError(`No ${providerName} found for ${languageId}`);
+    }
+    const method = getProviderMethod(provider, methodName);
+    if (!method) {
+      throw new ExtensionApiError(`${providerName} ${provider.id} is missing ${methodName} function`);
+    }
+    const result = await method(...args);
+    return validateResult ? validateResult(result) : result;
+  };
+  return {
+    deleteProvider,
+    executeProviderByLanguageId,
+    getProviderByLanguageId,
+    getProviders,
+    hasProvider,
+    registerProvider,
+    reset
+  };
+};
+
+// packages/extension-api/src/parts/CompletionProviderRegistry/CompletionProviderRegistry.ts
+var getType = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return typeof value;
+};
+var validateCompletionResult = (completion) => {
+  if (!Array.isArray(completion)) {
+    throw new ExtensionApiError(`invalid completion result: completion must be of type array but is ${getType(completion)}`);
+  }
+  for (const item of completion) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw new ExtensionApiError(`invalid completion result: expected completion item to be of type object but was of type ${getType(item)}`);
+    }
+  }
+  return completion;
+};
+var registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      id: provider.id,
+      languageId: provider.languageId,
+      provideCompletions(textDocument, offset, ...args) {
+        return provider.provideCompletions(textDocument, offset, ...args);
+      },
+      resolveCompletionItem: provider.resolveCompletionItem ? (textDocument, offset, name, completionItem, ...args) => provider.resolveCompletionItem?.(textDocument, offset, name, completionItem, ...args) : void 0
+    };
+  },
+  optionalMethods: ["resolveCompletionItem"],
+  providerName: "completion provider",
+  requiredMethods: ["provideCompletions"],
+  requireLanguageId: true
+});
+var hasCompletionProvider = registry.hasProvider;
+var registerCompletionProvider = (provider) => {
+  const registeredProvider = registry.registerProvider(provider);
+  return {
+    dispose() {
+      registry.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+var executeCompletionProvider = async (textDocument, offset, ...args) => {
+  return registry.executeProviderByLanguageId(
+    textDocument.languageId,
+    "provideCompletions",
+    [textDocument, offset, ...args],
+    validateCompletionResult
+  );
+};
+var executeResolveCompletionItemProvider = async (textDocument, offset, name, completionItem, ...args) => {
+  const provider = registry.getProviderByLanguageId(textDocument.languageId);
+  if (!provider) {
+    throw new ExtensionApiError(`No completion provider found for ${textDocument.languageId}`);
+  }
+  return provider.resolveCompletionItem?.(textDocument, offset, name, completionItem, ...args);
+};
+var getCompletionProviders = registry.getProviders;
+var getCompletionProviderRegistrySnapshot = () => {
+  return {
+    providers: registry.getProviders()
+  };
+};
+var resetCompletionProviderRegistry = registry.reset;
+
+// packages/extension-api/src/parts/FormattingProviderRegistry/FormattingProviderRegistry.ts
+var registry2 = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      format(textDocument, ...args) {
+        return provider.format(textDocument, ...args);
+      },
+      id: provider.id,
+      languageId: provider.languageId
+    };
+  },
+  providerName: "formatting provider",
+  requiredMethods: ["format"],
+  requireLanguageId: true
+});
+var hasFormattingProvider = registry2.hasProvider;
+var registerFormattingProvider = (provider) => {
+  const registeredProvider = registry2.registerProvider(provider);
+  return {
+    dispose() {
+      registry2.deleteProvider(registeredProvider.id);
+    }
+  };
+};
+var executeFormattingProvider = async (textDocument, ...args) => {
+  return registry2.executeProviderByLanguageId(textDocument.languageId, "format", [textDocument, ...args]);
+};
+var getFormattingProviders = registry2.getProviders;
+var getFormattingProviderRegistrySnapshot = () => {
+  return {
+    providers: registry2.getProviders()
+  };
+};
+var resetFormattingProviderRegistry = registry2.reset;
+
+// packages/extension-api/src/parts/Rpc/Rpc.ts
+var rpc;
+var set = (value) => {
+  rpc = value;
+};
+var invoke = async (method, ...params) => {
+  if (!rpc) {
+    return void 0;
+  }
+  return rpc.invoke(method, ...params);
+};
+
+// packages/extension-api/src/parts/NotifyStatusBarChange/NotifyStatusBarChange.ts
+var notifyStatusBarChange = async (id2) => {
+  await invoke("StatusBar.handleChange", id2);
+};
+
+// packages/extension-api/src/parts/StatusBarItemProviderRegistry/StatusBarItemProviderRegistry.ts
+var registry3 = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      getStatusBarItem() {
+        return provider.getStatusBarItem();
+      },
+      id: provider.id
+    };
+  },
+  providerName: "status bar item provider",
+  requiredMethods: ["getStatusBarItem"]
+});
+var getStatusBarItem = (provider) => {
+  return provider.getStatusBarItem();
+};
+var isStatusBarItem = (item) => {
+  return item !== void 0;
+};
+var hasStatusBarItemProvider = registry3.hasProvider;
+var registerStatusBarItemProvider = (provider) => {
+  const registeredProvider = registry3.registerProvider(provider);
+  void notifyStatusBarChange(registeredProvider.id);
+  return {
+    dispose() {
+      registry3.deleteProvider(registeredProvider.id);
+      void notifyStatusBarChange(registeredProvider.id);
+    },
+    async refresh() {
+      await notifyStatusBarChange(registeredProvider.id);
+    }
+  };
+};
+var getStatusBarItemProviders = registry3.getProviders;
+var getStatusBarItems = () => {
+  return registry3.getProviders().map(getStatusBarItem).filter(isStatusBarItem);
+};
+var getStatusBarItemProviderRegistrySnapshot = () => {
+  return {
+    providers: registry3.getProviders()
+  };
+};
+var resetStatusBarItemProviderRegistry = registry3.reset;
+
+// packages/extension-api/src/parts/ExtensionApiCommandMap/ExtensionApiCommandMap.ts
+var commandMap = {
+  "ExtensionApi.executeCommand": executeCommand,
+  "ExtensionApi.executeCompletionProvider": executeCompletionProvider,
+  "ExtensionApi.executeFormattingProvider": executeFormattingProvider,
+  "ExtensionApi.executeResolveCompletionItemProvider": executeResolveCompletionItemProvider,
+  "ExtensionApi.getCommandRegistrySnapshot": getCommandRegistrySnapshot,
+  "ExtensionApi.getCompletionProviderRegistrySnapshot": getCompletionProviderRegistrySnapshot,
+  "ExtensionApi.getFormattingProviderRegistrySnapshot": getFormattingProviderRegistrySnapshot,
+  "ExtensionApi.getStatusBarItems": getStatusBarItems
+};
+
+// packages/extension-api/src/parts/ExtensionApiWorkerHandleMessagePort/ExtensionApiWorkerHandleMessagePort.ts
+var commandMap2 = {
+  ...commandMap,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+var handleExtensionManagementMessagePort = async (port) => {
+  await PlainMessagePortRpc_exports.create({
+    commandMap: commandMap2,
+    isMessagePortOpen: true,
+    messagePort: port
+  });
+};
+
+// packages/extension-api/src/parts/ExtensionApiWorkerCommandMap/ExtensionApiWorkerCommandMap.ts
+var commandMap3 = {
+  ...commandMap,
+  "HandleMessagePort.handleExtensionManagementMessagePort": handleExtensionManagementMessagePort,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+
+// packages/extension-api/src/parts/ExtensionApiWorkerListen/ExtensionApiWorkerListen.ts
+var listen2 = async () => {
+  const rpc2 = WebWorkerRpcClient_exports.create({
+    commandMap: commandMap3
+  });
+  return rpc2;
+};
+
+// packages/extension-api/src/parts/Activation/Activation.ts
+var rpcPromise;
+var activate = async () => {
+  if (!rpcPromise) {
+    rpcPromise = listen2();
+  }
+  const rpc2 = await rpcPromise;
+  set(rpc2);
+};
+
+// packages/extension-api/src/parts/ExecuteCommand/ExecuteCommand.ts
+var executeCommand2 = async (id2, ...args) => {
+  return invoke("Extensions.executeCommand", id2, ...args);
+};
+
+// packages/extension-api/src/parts/QuickPick/QuickPick.ts
+var showQuickPick = async (options) => {
+  return invoke("ExtensionHostQuickPick.showQuickPick", options);
+};
+
+// packages/extension-api/src/parts/CommandMap/CommandMap.ts
+var commandMap4 = {
+  ...commandMap,
+  async initialize(type, port) {
+    if (type !== "message-port") {
+      throw new Error(`unsupported initialize type ${type}`);
+    }
+    await handleExtensionManagementMessagePort(port);
+  }
+};
+
+// packages/extension-api/src/parts/HandleExtensionManagementMessagePort/HandleExtensionManagementMessagePort.ts
+var handleExtensionManagementMessagePort2 = async ({
+  commandMap: commandMap5,
+  createMessagePortRpcClient,
+  port
+}) => {
+  await createMessagePortRpcClient({
+    commandMap: {
+      ...commandMap4,
+      ...commandMap5
+    },
+    messagePort: port
+  });
+};
+export {
+  activate,
+  executeCommand2 as executeCommand,
+  executeCompletionProvider,
+  executeFormattingProvider,
+  executeResolveCompletionItemProvider,
+  getCompletionProviderRegistrySnapshot,
+  getFormattingProviderRegistrySnapshot,
+  getStatusBarItemProviderRegistrySnapshot,
+  handleExtensionManagementMessagePort2 as handleExtensionManagementMessagePort,
+  registerCommand,
+  registerCompletionProvider,
+  registerFormattingProvider,
+  registerStatusBarItemProvider,
+  resetCompletionProviderRegistry,
+  resetFormattingProviderRegistry,
+  resetStatusBarItemProviderRegistry,
+  showQuickPick
+};