@lvce-editor/about-view 7.19.0 → 7.20.0

package/dist/notificationCenterWorkerMain.js

@@ -0,0 +1,2641 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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;
+    }
+  }
+};
+
+// node_modules/@lvce-editor/assert/dist/index.js
+var AssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AssertionError";
+  }
+};
+var Object$1 = 1;
+var Number2 = 2;
+var Array$1 = 3;
+var String = 4;
+var Boolean2 = 5;
+var Function = 6;
+var Null = 7;
+var Unknown = 8;
+var getType = (value) => {
+  switch (typeof value) {
+    case "number":
+      return Number2;
+    case "function":
+      return Function;
+    case "string":
+      return String;
+    case "object":
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case "boolean":
+      return Boolean2;
+    default:
+      return Unknown;
+  }
+};
+var number = (value) => {
+  const type = getType(value);
+  if (type !== Number2) {
+    throw new AssertionError("expected value to be of type number");
+  }
+};
+
+// 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);
+    }
+  }
+};
+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;
+      if (stack) {
+        Object.defineProperty(cause, "stack", {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
+      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
+};
+
+// 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 = (commandMap2) => {
+  Object.assign(commands, commandMap2);
+};
+var getCommand = (key) => {
+  return commands[key];
+};
+var execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+// 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") {
+      Object.defineProperty(error, "name", {
+        configurable: true,
+        value: 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) => {
+  {
+    return string2.indexOf(NewLine3);
+  }
+};
+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 setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, "stack");
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, "stack", {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+var restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === "string") {
+    setStack(error, `${error.stack}${NewLine3}${currentStack}`);
+  }
+  return error;
+};
+var restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine3}${currentStack}`);
+  return restoredError;
+};
+var restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine3}${error.data.stack}${NewLine3}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+var applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  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;
+  }
+};
+var applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || "";
+    const indexNewLine = getNewLineIndex2(lowerStack);
+    const parentStack = getParentStack(error);
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+var restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
+var restoreJsonRpcError = (error) => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    return restoreExistingError(error, currentStack);
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    return restoreMethodNotFoundError(error, currentStack);
+  }
+  if (error && error.message) {
+    return restoreMessageError(error);
+  }
+  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");
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcVersion/JsonRpcVersion.js
+var Two2 = "2.0";
+
+// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcEvent/JsonRpcEvent.js
+var create2 = (method, params) => {
+  return {
+    jsonrpc: Two2,
+    method,
+    params
+  };
+};
+
+// 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;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/Id/Id.js
+var id = 0;
+var create4 = () => {
+  return ++id;
+};
+
+// 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 };
+};
+
+// 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 rpc = {
+    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 rpc;
+};
+
+// 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);
+};
+
+// 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);
+  }
+};
+
+// 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;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/SharedLazyRpc/SharedLazyRpc.js
+var createSharedLazyRpc = (factory) => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/LazyTransferMessagePortRpcParent/LazyTransferMessagePortRpcParent.js
+var LazyTransferMessagePortRpcParent_exports = {};
+__export(LazyTransferMessagePortRpcParent_exports, {
+  create: () => create7
+});
+
+// node_modules/@lvce-editor/rpc/dist/parts/PlainMessagePortRpc/PlainMessagePortRpc.js
+var PlainMessagePortRpc_exports = {};
+__export(PlainMessagePortRpc_exports, {
+  create: () => create5
+});
+var create5 = async ({ commandMap: commandMap2, isMessagePortOpen = true, messagePort }) => {
+  register(commandMap2);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/TransferMessagePortRpcParent/TransferMessagePortRpcParent.js
+var create6 = async ({ commandMap: commandMap2, isMessagePortOpen, send: send5 }) => {
+  const { port1, port2 } = new MessageChannel();
+  await send5(port1);
+  return create5({
+    commandMap: commandMap2,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/LazyTransferMessagePortRpcParent/LazyTransferMessagePortRpcParent.js
+var create7 = async ({ commandMap: commandMap2, isMessagePortOpen, send: send5 }) => {
+  return createSharedLazyRpc(() => {
+    return create6({
+      commandMap: commandMap2,
+      isMessagePortOpen,
+      send: send5
+    });
+  });
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/WebWorkerRpcClient/WebWorkerRpcClient.js
+var WebWorkerRpcClient_exports = {};
+__export(WebWorkerRpcClient_exports, {
+  create: () => create8
+});
+var create8 = async ({ commandMap: commandMap2 }) => {
+  register(commandMap2);
+  const ipc = await listen(IpcChildWithModuleWorkerAndMessagePort$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/CreateMockRpc/CreateMockRpc.js
+var createMockRpc = ({ commandMap: commandMap2 }) => {
+  const invocations = [];
+  const invoke7 = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap2[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invocations,
+    invoke: invoke7,
+    invokeAndTransfer: invoke7
+  };
+  return mockRpc;
+};
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/RpcRegistry/RpcRegistry.js
+var rpcs = /* @__PURE__ */ Object.create(null);
+var set = (id2, rpc) => {
+  rpcs[id2] = rpc;
+};
+var get2 = (id2) => {
+  return rpcs[id2];
+};
+var remove2 = (id2) => {
+  delete rpcs[id2];
+};
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/RpcFactory/RpcFactory.js
+var create9 = (rpcId) => {
+  return {
+    async dispose() {
+      const rpc = get2(rpcId);
+      await rpc.dispose();
+    },
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get2(rpcId);
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get2(rpcId);
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    registerMockRpc(commandMap2) {
+      const mockRpc = createMockRpc({ commandMap: commandMap2 });
+      set(rpcId, mockRpc);
+      mockRpc[Symbol.dispose] = () => {
+        remove2(rpcId);
+      };
+      return mockRpc;
+    },
+    set(rpc) {
+      set(rpcId, rpc);
+    }
+  };
+};
+
+// node_modules/@lvce-editor/constants/dist/parts/VirtualDomElements/VirtualDomElements.js
+var VirtualDomElements_exports = {};
+__export(VirtualDomElements_exports, {
+  A: () => A,
+  Abbr: () => Abbr,
+  Article: () => Article,
+  Aside: () => Aside,
+  Audio: () => Audio,
+  BlockQuote: () => BlockQuote,
+  Br: () => Br,
+  Button: () => Button,
+  Canvas: () => Canvas,
+  Circle: () => Circle,
+  Cite: () => Cite,
+  Code: () => Code,
+  Col: () => Col,
+  ColGroup: () => ColGroup,
+  Data: () => Data,
+  Dd: () => Dd,
+  Defs: () => Defs,
+  Del: () => Del,
+  Div: () => Div,
+  Dl: () => Dl,
+  Dt: () => Dt,
+  Ellipse: () => Ellipse,
+  Em: () => Em,
+  Figcaption: () => Figcaption,
+  Figure: () => Figure,
+  Footer: () => Footer,
+  Form: () => Form,
+  G: () => G,
+  H1: () => H1,
+  H2: () => H2,
+  H3: () => H3,
+  H4: () => H4,
+  H5: () => H5,
+  H6: () => H6,
+  Head: () => Head,
+  Header: () => Header,
+  Hr: () => Hr,
+  Html: () => Html,
+  I: () => I,
+  Iframe: () => Iframe,
+  Img: () => Img,
+  Input: () => Input,
+  Ins: () => Ins,
+  Kbd: () => Kbd,
+  Label: () => Label,
+  Li: () => Li,
+  Line: () => Line,
+  Main: () => Main,
+  Meta: () => Meta,
+  Nav: () => Nav,
+  Ol: () => Ol,
+  Option: () => Option,
+  P: () => P,
+  Path: () => Path,
+  Polygon: () => Polygon,
+  Polyline: () => Polyline,
+  Pre: () => Pre,
+  Quote: () => Quote,
+  Rect: () => Rect,
+  Reference: () => Reference,
+  Root: () => Root,
+  Search: () => Search,
+  Section: () => Section,
+  Select: () => Select,
+  Span: () => Span,
+  Strong: () => Strong,
+  Style: () => Style,
+  Svg: () => Svg,
+  TBody: () => TBody,
+  THead: () => THead,
+  Table: () => Table,
+  Td: () => Td,
+  Text: () => Text,
+  TextArea: () => TextArea,
+  Tfoot: () => Tfoot,
+  Th: () => Th,
+  Time: () => Time,
+  Title: () => Title,
+  Tr: () => Tr,
+  Ul: () => Ul,
+  Use: () => Use,
+  Video: () => Video
+});
+var Audio = 0;
+var Button = 1;
+var Col = 2;
+var ColGroup = 3;
+var Div = 4;
+var H1 = 5;
+var Input = 6;
+var Kbd = 7;
+var Span = 8;
+var Table = 9;
+var TBody = 10;
+var Td = 11;
+var Text = 12;
+var Th = 13;
+var THead = 14;
+var Tr = 15;
+var I = 16;
+var Img = 17;
+var Root = 0;
+var Ins = 20;
+var Del = 21;
+var H2 = 22;
+var H3 = 23;
+var H4 = 24;
+var H5 = 25;
+var H6 = 26;
+var Article = 27;
+var Aside = 28;
+var Footer = 29;
+var Header = 30;
+var Nav = 40;
+var Section = 41;
+var Search = 42;
+var Dd = 43;
+var Dl = 44;
+var Figcaption = 45;
+var Figure = 46;
+var Hr = 47;
+var Li = 48;
+var Ol = 49;
+var P = 50;
+var Pre = 51;
+var A = 53;
+var Abbr = 54;
+var Br = 55;
+var Cite = 56;
+var Data = 57;
+var Time = 58;
+var Tfoot = 59;
+var Ul = 60;
+var Video = 61;
+var TextArea = 62;
+var Select = 63;
+var Option = 64;
+var Code = 65;
+var Label = 66;
+var Dt = 67;
+var Iframe = 68;
+var Main = 69;
+var Strong = 70;
+var Em = 71;
+var Style = 72;
+var Html = 73;
+var Head = 74;
+var Title = 75;
+var Meta = 76;
+var Canvas = 77;
+var Form = 78;
+var BlockQuote = 79;
+var Quote = 80;
+var Circle = 81;
+var Defs = 82;
+var Ellipse = 83;
+var G = 84;
+var Line = 85;
+var Path = 86;
+var Polygon = 87;
+var Polyline = 88;
+var Rect = 89;
+var Svg = 90;
+var Use = 91;
+var Reference = 100;
+
+// node_modules/@lvce-editor/constants/dist/parts/EventExpression/EventExpression.js
+var EventExpression_exports = {};
+__export(EventExpression_exports, {
+  AltKey: () => AltKey,
+  Button: () => Button2,
+  ClientX: () => ClientX,
+  ClientY: () => ClientY,
+  CtrlKey: () => CtrlKey,
+  DataTransferFiles: () => DataTransferFiles,
+  DataTransferFiles2: () => DataTransferFiles2,
+  DefaultPrevented: () => DefaultPrevented,
+  DeltaMode: () => DeltaMode,
+  DeltaY: () => DeltaY,
+  EventTargetClassName: () => EventTargetClassName,
+  IsTrusted: () => IsTrusted,
+  Key: () => Key,
+  ShiftKey: () => ShiftKey,
+  TargetChecked: () => TargetChecked,
+  TargetHref: () => TargetHref,
+  TargetName: () => TargetName,
+  TargetNodeName: () => TargetNodeName,
+  TargetSelectionEnd: () => TargetSelectionEnd,
+  TargetSelectionStart: () => TargetSelectionStart,
+  TargetSrc: () => TargetSrc,
+  TargetValue: () => TargetValue
+});
+var AltKey = "event.altKey";
+var Button2 = "event.button";
+var ClientX = "event.clientX";
+var ClientY = "event.clientY";
+var CtrlKey = "event.ctrlKey";
+var DataTransferFiles = "event.dataTransfer.files";
+var DataTransferFiles2 = "event.dataTransfer.files2";
+var DefaultPrevented = "event.defaultPrevented";
+var DeltaMode = "event.deltaMode";
+var DeltaY = "event.deltaY";
+var EventTargetClassName = "event.target.className";
+var IsTrusted = "event.isTrusted";
+var Key = "event.key";
+var ShiftKey = "event.shiftKey";
+var TargetChecked = "event.target.checked";
+var TargetHref = "event.target.href";
+var TargetName = "event.target.name";
+var TargetNodeName = "event.target.nodeName";
+var TargetSelectionEnd = "event.target.selectionEnd";
+var TargetSelectionStart = "event.target.selectionStart";
+var TargetSrc = "event.target.src";
+var TargetValue = "event.target.value";
+
+// node_modules/@lvce-editor/constants/dist/parts/InputSource/InputSource.js
+var InputSource_exports = {};
+__export(InputSource_exports, {
+  Script: () => Script,
+  User: () => User
+});
+var User = 1;
+var Script = 2;
+
+// node_modules/@lvce-editor/constants/dist/parts/RpcId/RpcId.js
+var RpcId_exports = {};
+__export(RpcId_exports, {
+  AuthProcess: () => AuthProcess,
+  AuthWorker: () => AuthWorker,
+  BlobWorker: () => BlobWorker,
+  ChatCoordinatorWorker: () => ChatCoordinatorWorker,
+  ChatDebugWorker: () => ChatDebugWorker,
+  ChatMathWorker: () => ChatMathWorker,
+  ChatMessageParsingWorker: () => ChatMessageParsingWorker,
+  ChatNetworkWorker: () => ChatNetworkWorker,
+  ChatStorageWorker: () => ChatStorageWorker,
+  ChatToolWorker: () => ChatToolWorker,
+  ChatViewModelWorker: () => ChatViewModelWorker,
+  Cli: () => Cli,
+  ClipBoardProcess: () => ClipBoardProcess,
+  ClipBoardWorker: () => ClipBoardWorker,
+  ColorPickerWorker: () => ColorPickerWorker,
+  CompletionWorker: () => CompletionWorker,
+  DebugWorker: () => DebugWorker,
+  DialogWorker: () => DialogWorker,
+  DragAndDropWorker: () => DragAndDropWorker,
+  EditorWorker: () => EditorWorker,
+  EmbedsProcess: () => EmbedsProcess,
+  EmbedsWorker: () => EmbedsWorker,
+  ErrorWorker: () => ErrorWorker,
+  ExtensionDetailWorker: () => ExtensionDetailWorker,
+  ExtensionHostHelperProcess: () => ExtensionHostHelperProcess,
+  ExtensionHostWorker: () => ExtensionHostWorker,
+  ExtensionManagementWorker: () => ExtensionManagementWorker,
+  FilePermissionProcess: () => FilePermissionProcess,
+  FileSearchWorker: () => FileSearchWorker,
+  FileSystemProcess: () => FileSystemProcess,
+  FileSystemWorker: () => FileSystemWorker,
+  FileWatcherProcess: () => FileWatcherProcess,
+  FindWidgetWorker: () => FindWidgetWorker,
+  GithubWorker: () => GithubWorker,
+  HoverWorker: () => HoverWorker,
+  IconThemeWorker: () => IconThemeWorker,
+  IframeWorker: () => IframeWorker,
+  MainAreaWorker: () => MainAreaWorker,
+  MainProcess: () => MainProcess,
+  MarkdownWorker: () => MarkdownWorker,
+  OpenerWorker: () => OpenerWorker,
+  OutputWorker: () => OutputWorker,
+  PreviewSandBoxWorker: () => PreviewSandBoxWorker,
+  PreviewWorker: () => PreviewWorker,
+  ProblemsWorker: () => ProblemsWorker,
+  ProcessExplorerNode: () => ProcessExplorerNode,
+  ProcessExplorerRenderer: () => ProcessExplorerRenderer,
+  QuickPickWorker: () => QuickPickWorker,
+  RenameWorker: () => RenameWorker,
+  RendererProcess: () => RendererProcess,
+  RendererWorker: () => RendererWorker,
+  SearchProcess: () => SearchProcess,
+  SearchProcessElectron: () => SearchProcessElectron,
+  SettingsWorker: () => SettingsWorker,
+  SharedProcess: () => SharedProcess,
+  SourceActionWorker: () => SourceActionWorker,
+  SourceControlWorker: () => SourceControlWorker,
+  StatusBarWorker: () => StatusBarWorker,
+  SyntaxHighlightingWorker: () => SyntaxHighlightingWorker,
+  TemplateWorker: () => TemplateWorker,
+  TerminalProcess: () => TerminalProcess,
+  TestWithPlaywrightCli: () => TestWithPlaywrightCli,
+  TestWithPlaywrightWorker: () => TestWithPlaywrightWorker,
+  TestWorker: () => TestWorker,
+  TextMeasurementWorker: () => TextMeasurementWorker,
+  TextSearchViewWorker: () => TextSearchViewWorker,
+  TextSearchWorker: () => TextSearchWorker,
+  TypescriptCompileProcess: () => TypescriptCompileProcess
+});
+var AuthProcess = 6040;
+var AuthWorker = 6010;
+var BlobWorker = 19e3;
+var ChatCoordinatorWorker = 6008;
+var ChatDebugWorker = 6006;
+var ChatMathWorker = 6007;
+var ChatMessageParsingWorker = 6009;
+var ChatNetworkWorker = 6002;
+var ChatStorageWorker = 6003;
+var ChatToolWorker = 6005;
+var ChatViewModelWorker = 6022;
+var Cli = 6004;
+var ClipBoardProcess = 3401;
+var ClipBoardWorker = 3400;
+var ColorPickerWorker = 302;
+var CompletionWorker = 301;
+var DebugWorker = 55;
+var DialogWorker = 7014;
+var DragAndDropWorker = 3404;
+var EditorWorker = 99;
+var EmbedsProcess = 207;
+var EmbedsWorker = 208;
+var ErrorWorker = 3308;
+var ExtensionDetailWorker = 3402;
+var ExtensionHostHelperProcess = 3;
+var ExtensionHostWorker = 44;
+var ExtensionManagementWorker = 9006;
+var FilePermissionProcess = 7015;
+var FileSearchWorker = 7013;
+var FileSystemProcess = 210;
+var FileSystemWorker = 209;
+var FileWatcherProcess = 220;
+var FindWidgetWorker = 9002;
+var GithubWorker = 4444;
+var HoverWorker = 9003;
+var IconThemeWorker = 7009;
+var IframeWorker = 344;
+var MainAreaWorker = 82221;
+var MainProcess = -5;
+var MarkdownWorker = 300;
+var OpenerWorker = 4561;
+var OutputWorker = 7001;
+var PreviewSandBoxWorker = 3212;
+var PreviewWorker = 3211;
+var ProblemsWorker = 3403;
+var ProcessExplorerRenderer = 33;
+var ProcessExplorerNode = 10001;
+var QuickPickWorker = 1e4;
+var RenameWorker = 9004;
+var RendererProcess = 1670;
+var RendererWorker = 1;
+var SearchProcess = 77;
+var SearchProcessElectron = 2;
+var SettingsWorker = 11010;
+var SharedProcess = 1492;
+var SourceActionWorker = 303;
+var SourceControlWorker = 66;
+var StatusBarWorker = 7201;
+var SyntaxHighlightingWorker = 3309;
+var TemplateWorker = 4445;
+var TerminalProcess = 7;
+var TestWithPlaywrightCli = 6e3;
+var TestWithPlaywrightWorker = 6001;
+var TestWorker = 9001;
+var TextMeasurementWorker = 7011;
+var TextSearchViewWorker = 7012;
+var TextSearchWorker = 7010;
+var TypescriptCompileProcess = 221;
+
+// node_modules/@lvce-editor/constants/dist/parts/ViewletCommand/ViewletCommand.js
+var ViewletCommand_exports = {};
+__export(ViewletCommand_exports, {
+  FocusElementByName: () => FocusElementByName,
+  FocusSelector: () => FocusSelector,
+  SetCss: () => SetCss,
+  SetDom2: () => SetDom2,
+  SetDragData: () => SetDragData,
+  SetFocusContext: () => SetFocusContext,
+  SetPatches: () => SetPatches,
+  SetProperty: () => SetProperty,
+  SetSelectionByName: () => SetSelectionByName,
+  SetValueByName: () => SetValueByName
+});
+var FocusElementByName = "Viewlet.focusElementByName";
+var FocusSelector = "Viewlet.focusSelector";
+var SetCss = "Viewlet.setCss";
+var SetDom2 = "Viewlet.setDom2";
+var SetFocusContext = "Viewlet.setFocusContext";
+var SetProperty = "Viewlet.setProperty";
+var SetDragData = "Viewlet.setDragData";
+var SetSelectionByName = "Viewlet.setSelectionByName";
+var SetValueByName = "Viewlet.setValueByName";
+var SetPatches = "Viewlet.setPatches";
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/EditorWorker/EditorWorker.js
+var { dispose, invoke, invokeAndTransfer, registerMockRpc, set: set2 } = create9(RpcId_exports.EditorWorker);
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/ExtensionManagementWorker/ExtensionManagementWorker.js
+var ExtensionManagementWorker_exports = {};
+__export(ExtensionManagementWorker_exports, {
+  disable: () => disable,
+  disable2: () => disable2,
+  disableWorkspace: () => disableWorkspace,
+  dispose: () => dispose2,
+  enable: () => enable,
+  enable2: () => enable2,
+  getExtension: () => getExtension,
+  getLanguages: () => getLanguages,
+  getRunningExtensions: () => getRunningExtensions,
+  install: () => install,
+  invalidateExtensionsCache: () => invalidateExtensionsCache,
+  invoke: () => invoke2,
+  invokeAndTransfer: () => invokeAndTransfer2,
+  registerMockRpc: () => registerMockRpc2,
+  set: () => set3,
+  uninstall: () => uninstall
+});
+var { dispose: dispose2, invoke: invoke2, invokeAndTransfer: invokeAndTransfer2, registerMockRpc: registerMockRpc2, set: set3 } = create9(RpcId_exports.ExtensionManagementWorker);
+var enable = (id2) => {
+  return invoke2(`Extensions.enable`, id2);
+};
+var enable2 = (id2, platform) => {
+  return invoke2(`Extensions.enable2`, id2, platform);
+};
+var disable = (id2) => {
+  return invoke2(`Extensions.disable`, id2);
+};
+var disable2 = (id2, platform) => {
+  return invoke2(`Extensions.disable2`, id2, platform);
+};
+var disableWorkspace = (id2) => {
+  return invoke2("Extensions.disableWorkspace", id2);
+};
+var getExtension = (id2) => {
+  return invoke2(`Extensions.getExtension`, id2);
+};
+var getLanguages = (platform, assetDir) => {
+  return invoke2("Extensions.getLanguages", platform, assetDir);
+};
+var install = (id2) => {
+  return invoke2(`Extensions.install`, id2);
+};
+var uninstall = (id2) => {
+  return invoke2(`Extensions.uninstall`, id2);
+};
+var invalidateExtensionsCache = () => {
+  return invoke2(`Extensions.invalidateExtensionsCache`);
+};
+var getRunningExtensions = async (assetDir, platform) => {
+  return invoke2("Extensions.getRunningExtensions", assetDir, platform);
+};
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/OpenerWorker/OpenerWorker.js
+var { dispose: dispose3, invoke: invoke3, invokeAndTransfer: invokeAndTransfer3, registerMockRpc: registerMockRpc3, set: set4 } = create9(RpcId_exports.OpenerWorker);
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/ProcessExplorer/ProcessExplorer.js
+var { dispose: dispose4, invoke: invoke4, invokeAndTransfer: invokeAndTransfer4, registerMockRpc: registerMockRpc4, set: set5 } = create9(10001);
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/RendererWorker/RendererWorker.js
+var RendererWorker_exports = {};
+__export(RendererWorker_exports, {
+  activateByEvent: () => activateByEvent,
+  allocateWidgetRendererId: () => allocateWidgetRendererId,
+  applyBulkReplacement: () => applyBulkReplacement,
+  attachWidget: () => attachWidget,
+  closeWidget: () => closeWidget,
+  closeWindow: () => closeWindow,
+  confirm: () => confirm,
+  createViewlet: () => createViewlet,
+  disableExtension: () => disableExtension,
+  dispose: () => dispose6,
+  disposeEditor: () => disposeEditor,
+  enableExtension: () => enableExtension,
+  getActiveEditorId: () => getActiveEditorId,
+  getAllExtensions: () => getAllExtensions,
+  getAllPreferences: () => getAllPreferences,
+  getBadgeCounts: () => getBadgeCounts,
+  getBlob: () => getBlob,
+  getChromeVersion: () => getChromeVersion,
+  getColorThemeNames: () => getColorThemeNames,
+  getElectronVersion: () => getElectronVersion,
+  getExtension: () => getExtension2,
+  getExtensionCommands: () => getExtensionCommands,
+  getFileHandles: () => getFileHandles,
+  getFileIcon: () => getFileIcon,
+  getFilePathElectron: () => getFilePathElectron,
+  getFolderIcon: () => getFolderIcon,
+  getFolderSize: () => getFolderSize,
+  getIcons: () => getIcons,
+  getKeyBindings: () => getKeyBindings,
+  getLogsDir: () => getLogsDir,
+  getMarkdownDom: () => getMarkdownDom,
+  getNodeVersion: () => getNodeVersion,
+  getPreference: () => getPreference,
+  getRecentlyOpened: () => getRecentlyOpened,
+  getV8Version: () => getV8Version,
+  getViewletModuleId: () => getViewletModuleId,
+  getWebViewSecret: () => getWebViewSecret,
+  getWindowId: () => getWindowId,
+  getWorkspacePath: () => getWorkspacePath,
+  handleDebugChange: () => handleDebugChange,
+  handleDebugPaused: () => handleDebugPaused,
+  handleDebugResumed: () => handleDebugResumed,
+  handleDebugScriptParsed: () => handleDebugScriptParsed,
+  handleModifiedStatusChange: () => handleModifiedStatusChange,
+  handleUriChange: () => handleUriChange,
+  handleWorkspaceRefresh: () => handleWorkspaceRefresh,
+  initializeEditorWorker: () => initializeEditorWorker,
+  initializeOpenerWorker: () => initializeOpenerWorker,
+  initializeProcessExplorer: () => initializeProcessExplorer,
+  initializeTextMeasurementWorker: () => initializeTextMeasurementWorker,
+  installExtension: () => installExtension,
+  invoke: () => invoke6,
+  invokeAndTransfer: () => invokeAndTransfer6,
+  maximizeWindow: () => maximizeWindow,
+  measureTextBlockHeight: () => measureTextBlockHeight,
+  minimizeWindow: () => minimizeWindow,
+  openExtensionSearch: () => openExtensionSearch,
+  openExternal: () => openExternal,
+  openNativeFolder: () => openNativeFolder,
+  openUri: () => openUri,
+  openUrl: () => openUrl,
+  openWidget: () => openWidget,
+  readClipBoardText: () => readClipBoardText,
+  readFile: () => readFile,
+  refreshOutput: () => refreshOutput,
+  registerMockRpc: () => registerMockRpc6,
+  registerWebViewInterceptor: () => registerWebViewInterceptor,
+  removeWidget: () => removeWidget,
+  removeWidgets: () => removeWidgets,
+  renderMarkdown: () => renderMarkdown,
+  rerenderEditor: () => rerenderEditor,
+  resizeViewlet: () => resizeViewlet,
+  saveEditor: () => saveEditor,
+  searchFileFetch: () => searchFileFetch,
+  searchFileHtml: () => searchFileHtml,
+  searchFileMemory: () => searchFileMemory,
+  sendMessagePortToAuthProcess: () => sendMessagePortToAuthProcess,
+  sendMessagePortToAuthWorker: () => sendMessagePortToAuthWorker,
+  sendMessagePortToBlobWorker: () => sendMessagePortToBlobWorker,
+  sendMessagePortToChatCoordinatorWorker: () => sendMessagePortToChatCoordinatorWorker,
+  sendMessagePortToChatDebugViewWorker: () => sendMessagePortToChatDebugViewWorker,
+  sendMessagePortToChatMathWorker: () => sendMessagePortToChatMathWorker,
+  sendMessagePortToChatMessageParsingWorker: () => sendMessagePortToChatMessageParsingWorker,
+  sendMessagePortToChatNetworkWorker: () => sendMessagePortToChatNetworkWorker,
+  sendMessagePortToChatStorageWorker: () => sendMessagePortToChatStorageWorker,
+  sendMessagePortToChatToolWorker: () => sendMessagePortToChatToolWorker,
+  sendMessagePortToChatViewModel: () => sendMessagePortToChatViewModel,
+  sendMessagePortToClipBoardWorker: () => sendMessagePortToClipBoardWorker,
+  sendMessagePortToDialogWorker: () => sendMessagePortToDialogWorker,
+  sendMessagePortToDiffWorker: () => sendMessagePortToDiffWorker,
+  sendMessagePortToDragAndDropWorker: () => sendMessagePortToDragAndDropWorker,
+  sendMessagePortToEditorWorker: () => sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker: () => sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker: () => sendMessagePortToExtensionHostWorker,
+  sendMessagePortToExtensionManagementWorker: () => sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToFilePermissionProcess: () => sendMessagePortToFilePermissionProcess,
+  sendMessagePortToFileSearchWorker: () => sendMessagePortToFileSearchWorker,
+  sendMessagePortToFileSearchWorker2: () => sendMessagePortToFileSearchWorker2,
+  sendMessagePortToFileSystemProcess: () => sendMessagePortToFileSystemProcess,
+  sendMessagePortToFileSystemWorker: () => sendMessagePortToFileSystemWorker,
+  sendMessagePortToIconThemeWorker: () => sendMessagePortToIconThemeWorker,
+  sendMessagePortToIframeWorker: () => sendMessagePortToIframeWorker,
+  sendMessagePortToMainAreaWorker: () => sendMessagePortToMainAreaWorker,
+  sendMessagePortToMarkdownWorker: () => sendMessagePortToMarkdownWorker,
+  sendMessagePortToOpenerWorker: () => sendMessagePortToOpenerWorker,
+  sendMessagePortToProcessExplorer: () => sendMessagePortToProcessExplorer,
+  sendMessagePortToQuickPickWorker: () => sendMessagePortToQuickPickWorker,
+  sendMessagePortToRendererProcess: () => sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess: () => sendMessagePortToSearchProcess,
+  sendMessagePortToSettingsWorker: () => sendMessagePortToSettingsWorker,
+  sendMessagePortToSharedProcess: () => sendMessagePortToSharedProcess,
+  sendMessagePortToSourceControlWorker: () => sendMessagePortToSourceControlWorker,
+  sendMessagePortToSyntaxHighlightingWorker: () => sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTerminalProcess: () => sendMessagePortToTerminalProcess,
+  sendMessagePortToTextMeasurementWorker: () => sendMessagePortToTextMeasurementWorker,
+  sendMessagePortToTextSearchWorker: () => sendMessagePortToTextSearchWorker,
+  set: () => set7,
+  setAdditionalFocus: () => setAdditionalFocus,
+  setColorTheme: () => setColorTheme,
+  setExtensionsSearchValue: () => setExtensionsSearchValue,
+  setFocus: () => setFocus,
+  setWebViewPort: () => setWebViewPort,
+  setWorkspacePath: () => setWorkspacePath,
+  showContextMenu: () => showContextMenu,
+  showContextMenu2: () => showContextMenu2,
+  showErrorDialog: () => showErrorDialog,
+  showMessageBox: () => showMessageBox,
+  showPanel: () => showPanel,
+  showPreview: () => showPreview,
+  showSaveFilePicker: () => showSaveFilePicker,
+  showSideBar: () => showSideBar,
+  togglePanelView: () => togglePanelView,
+  uninstallExtension: () => uninstallExtension,
+  unmaximizeWindow: () => unmaximizeWindow,
+  unregisterWebViewInterceptor: () => unregisterWebViewInterceptor,
+  updateWidget: () => updateWidget,
+  writeClipBoardImage: () => writeClipBoardImage,
+  writeClipBoardText: () => writeClipBoardText,
+  writeFile: () => writeFile
+});
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/TextMeasurementWorker/TextMeasurementWorker.js
+var { dispose: dispose5, invoke: invoke5, invokeAndTransfer: invokeAndTransfer5, registerMockRpc: registerMockRpc5, set: set6 } = create9(RpcId_exports.IconThemeWorker);
+
+// node_modules/@lvce-editor/rpc-registry/dist/parts/RendererWorker/RendererWorker.js
+var { dispose: dispose6, invoke: invoke6, invokeAndTransfer: invokeAndTransfer6, registerMockRpc: registerMockRpc6, set: set7 } = create9(RpcId_exports.RendererWorker);
+var allocateWidgetRendererId = async () => {
+  return invoke6("WidgetLifecycle.allocateRendererId");
+};
+var attachWidget = async (request) => {
+  return invoke6("WidgetLifecycle.attach", request);
+};
+var removeWidget = async (request) => {
+  await invoke6("WidgetLifecycle.remove", request);
+};
+var removeWidgets = async (requests) => {
+  await invoke6("WidgetLifecycle.removeMany", requests);
+};
+var updateWidget = async (request) => {
+  return invoke6("WidgetLifecycle.update", request);
+};
+var searchFileHtml = async (uri) => {
+  return invoke6("ExtensionHost.searchFileWithHtml", uri);
+};
+var getFilePathElectron = async (file) => {
+  return invoke6("FileSystemHandle.getFilePathElectron", file);
+};
+var handleModifiedStatusChange = async (uri, modified) => {
+  return invoke6("Main.handleModifiedStatusChange", uri, modified);
+};
+var showContextMenu = async (x, y, id2, ...args) => {
+  return invoke6("ContextMenu.show", x, y, id2, ...args);
+};
+var showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  await invoke6("ContextMenu.show2", uid, menuId, x, y, args);
+};
+var getElectronVersion = async () => {
+  return invoke6("Process.getElectronVersion");
+};
+var applyBulkReplacement = async (bulkEdits) => {
+  await invoke6("BulkReplacement.applyBulkReplacement", bulkEdits);
+};
+var setColorTheme = async (id2) => {
+  return invoke6(
+    /* ColorTheme.setColorTheme */
+    "ColorTheme.setColorTheme",
+    /* colorThemeId */
+    id2
+  );
+};
+var getNodeVersion = async () => {
+  return invoke6("Process.getNodeVersion");
+};
+var getBadgeCounts = async () => {
+  return invoke6("Layout.getBadgeCounts");
+};
+var getChromeVersion = async () => {
+  return invoke6("Process.getChromeVersion");
+};
+var getV8Version = async () => {
+  return invoke6("Process.getV8Version");
+};
+var getFileHandles = async (fileIds) => {
+  const files = await invoke6("FileSystemHandle.getFileHandles", fileIds);
+  return files;
+};
+var setWorkspacePath = async (path) => {
+  await invoke6("Workspace.setPath", path);
+};
+var registerWebViewInterceptor = async (id2, port) => {
+  await invokeAndTransfer6("WebView.registerInterceptor", id2, port);
+};
+var unregisterWebViewInterceptor = async (id2) => {
+  await invoke6("WebView.unregisterInterceptor", id2);
+};
+var sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker", port, command, rpcId);
+};
+var sendMessagePortToSettingsWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToSettingsWorker", port, command, rpcId);
+};
+var sendMessagePortToClipBoardWorker = async (port, rpcId) => {
+  const command = "ClipBoard.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker", port, command, rpcId);
+};
+var sendMessagePortToDragAndDropWorker = async (port) => {
+  const command = "DragAndDrop.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToDragAndDropWorker", port, command);
+};
+var sendMessagePortToOpenerWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker", port, command, rpcId);
+};
+var sendMessagePortToChatMathWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToChatMathWorker", port, command, rpcId);
+};
+var sendMessagePortToChatCoordinatorWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToChatCoordinatorWorker", port, command, rpcId);
+};
+var sendMessagePortToChatMessageParsingWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToChatMessageParsingWorker", port, command, rpcId);
+};
+var sendMessagePortToMainAreaWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToMainAreaWorker", port, command, rpcId);
+};
+var sendMessagePortToTerminalProcess = async (port, rpcId) => {
+  const command = "HandleMessagePortForTerminalProcess.handleMessagePortForTerminalProcess";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToTerminalProcess", port, command, rpcId);
+};
+var sendMessagePortToTextSearchWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToTextSearchWorker", port, command, rpcId);
+};
+var sendMessagePortToDialogWorker = async (port) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker", port, command);
+};
+var sendMessagePortToAuthWorker = async (port, rpcId) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToAuthWorker", port, command, rpcId);
+};
+var sendMessagePortToAuthProcess = async (port, rpcId) => {
+  const command = "HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess", port, command, rpcId);
+};
+var sendMessagePortToFilePermissionProcess = async (port, rpcId) => {
+  const command = "HandleMessagePortForFilePermissionProcess.handleMessagePortForFilePermissionProcess";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess", port, command, rpcId);
+};
+var sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = "Errors.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker", port, command, rpcId);
+};
+var sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = "Markdown.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker", port, command, rpcId);
+};
+var sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = "IconTheme.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker", port, command, rpcId);
+};
+var sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = "FileSystem.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker", port, command, rpcId);
+};
+var readFile = async (uri) => {
+  return invoke6("FileSystem.readFile", uri);
+};
+var getWebViewSecret = async (key) => {
+  return invoke6("WebView.getSecret", key);
+};
+var setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer6("WebView.setPort", uid, port, origin, portType);
+};
+var setFocus = (key) => {
+  return invoke6("Focus.setFocus", key);
+};
+var getFileIcon = async (options) => {
+  return invoke6("IconTheme.getFileIcon", options);
+};
+var getColorThemeNames = async () => {
+  return invoke6("ColorTheme.getColorThemeNames");
+};
+var disableExtension = async (id2) => {
+  return invoke6("ExtensionManagement.disable", id2);
+};
+var enableExtension = async (id2) => {
+  return invoke6("ExtensionManagement.enable", id2);
+};
+var disposeEditor = async (uid) => {
+  return invoke6("Viewlet.dispose", uid);
+};
+var handleDebugChange = async (params) => {
+  return invoke6("Run And Debug.handleChange", params);
+};
+var getFolderIcon = async (options) => {
+  return invoke6("IconTheme.getFolderIcon", options);
+};
+var handleWorkspaceRefresh = async () => {
+  return invoke6("Layout.handleWorkspaceRefresh");
+};
+var closeWidget = async (widgetId) => {
+  return invoke6("Viewlet.closeWidget", widgetId);
+};
+var createViewlet = async (viewletModuleId, editorUid, tabId, bounds, uri) => {
+  return invoke6("Layout.createViewlet", viewletModuleId, editorUid, tabId, bounds, uri);
+};
+var getViewletModuleId = async (uri) => {
+  return invoke6("Layout.getModuleId", uri);
+};
+var showPanel = async () => {
+  return invoke6("Layout.showPanel");
+};
+var showPreview = async () => {
+  return invoke6("Layout.showPreview");
+};
+var saveEditor = async () => {
+  return invoke6("Editor.save");
+};
+var sendMessagePortToFileSearchWorker2 = async (port, rpcId = 0) => {
+  const command = "FileSearch.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToFileSearchWorker", port, command, rpcId);
+};
+var togglePanelView = async (id2) => {
+  return invoke6("Panel.toggleView", id2);
+};
+var resizeViewlet = async (uid, dimensions) => {
+  return invoke6("Viewlet.resize", uid, dimensions);
+};
+var sendMessagePortToFileSearchWorker = async (port, rpcId = 0) => {
+  const command = "QuickPick.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToFileSearchWorker", port, command, rpcId);
+};
+var sendMessagePortToQuickPickWorker = async (port, rpcId = 0) => {
+  const command = "QuickPick.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToQuickPickWorker", port, command, rpcId);
+};
+var sendMessagePortToSearchProcess = async (port) => {
+  await invokeAndTransfer6("SendMessagePortToElectron.sendMessagePortToElectron", port, "HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess");
+};
+var sendMessagePortToChatViewModel = async (port) => {
+  await invokeAndTransfer6("SendMessagePortToElectron.sendMessagePortToChatViewModel", port, "ViewModel.handleMessagePort");
+};
+var sendMessagePortToChatNetworkWorker = async (port) => {
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToChatNetworkWorker", port, "HandleMessagePort.handleMessagePort");
+};
+var sendMessagePortToChatToolWorker = async (port) => {
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToChatToolWorker", port, "HandleMessagePort.handleMessagePort");
+};
+var sendMessagePortToChatStorageWorker = async (port, rpcId) => {
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToChatStorageWorker", port, "HandleMessagePort.handleMessagePort", rpcId);
+};
+var sendMessagePortToChatDebugViewWorker = async (port) => {
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToChatDebugViewWorker", port, "HandleMessagePort.handleMessagePort");
+};
+var confirm = async (message, options) => {
+  const result = await invoke6("ConfirmPrompt.prompt", message, options);
+  return result;
+};
+var getRecentlyOpened = async () => {
+  return invoke6(
+    /* RecentlyOpened.getRecentlyOpened */
+    "RecentlyOpened.getRecentlyOpened"
+  );
+};
+var getKeyBindings = async () => {
+  return invoke6("KeyBindingsInitial.getKeyBindings");
+};
+var writeClipBoardText = async (text2) => {
+  await invoke6(
+    "ClipBoard.writeText",
+    /* text */
+    text2
+  );
+};
+var writeFile = async (uri, text2) => {
+  await invoke6("FileSystem.writeFile", uri, text2);
+};
+var handleUriChange = async (uri, newUri) => {
+  await invoke6("Main.handleUriChange", uri, newUri);
+};
+var readClipBoardText = async () => {
+  return invoke6("ClipBoard.readText");
+};
+var writeClipBoardImage = async (blob) => {
+  await invoke6(
+    "ClipBoard.writeImage",
+    /* text */
+    blob
+  );
+};
+var searchFileMemory = async (uri) => {
+  return invoke6("ExtensionHost.searchFileWithMemory", uri);
+};
+var searchFileFetch = async (uri) => {
+  return invoke6("ExtensionHost.searchFileWithFetch", uri);
+};
+var showMessageBox = async (options) => {
+  return invoke6("ElectronDialog.showMessageBox", options);
+};
+var handleDebugResumed = async (params) => {
+  await invoke6("Run And Debug.handleResumed", params);
+};
+var openWidget = async (name) => {
+  await invoke6("Viewlet.openWidget", name);
+};
+var getIcons = async (requests) => {
+  const icons = await invoke6("IconTheme.getIcons", requests);
+  return icons;
+};
+var activateByEvent = (event, assetDir, platform) => {
+  return invoke6("ExtensionHostManagement.activateByEvent", event, assetDir, platform);
+};
+var setAdditionalFocus = (focusKey) => {
+  return invoke6("Focus.setAdditionalFocus", focusKey);
+};
+var getActiveEditorId = () => {
+  return invoke6("GetActiveEditor.getActiveEditorId");
+};
+var getWorkspacePath = () => {
+  return invoke6("Workspace.getPath");
+};
+var sendMessagePortToRendererProcess = async (port) => {
+  const command = "HandleMessagePort.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess", port, command, RpcId_exports.DebugWorker);
+};
+var sendMessagePortToTextMeasurementWorker = async (port) => {
+  const command = "TextMeasurement.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker", port, command, 0);
+};
+var sendMessagePortToProcessExplorer = async (port) => {
+  const command = "ProcessExplorer.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToProcessExplorer", port, command, 0);
+};
+var sendMessagePortToSourceControlWorker = async (port) => {
+  const command = "SourceControl.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker", port, command, 0);
+};
+var sendMessagePortToSharedProcess = async (port) => {
+  const command = "HandleElectronMessagePort.handleElectronMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess", port, command, 0);
+};
+var sendMessagePortToFileSystemProcess = async (port, rpcId) => {
+  const command = "HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess", port, command, rpcId);
+};
+var sendMessagePortToIframeWorker = async (port, rpcId) => {
+  const command = "Iframes.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToIframeWorker", port, command, rpcId);
+};
+var sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  const command = "Extensions.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker", port, command, rpcId);
+};
+var sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  await sendMessagePortToExtensionManagementWorker(port, rpcId);
+};
+var getPreference = async (key) => {
+  return await invoke6("Preferences.get", key);
+};
+var getAllExtensions = async () => {
+  return invoke6("ExtensionManagement.getAllExtensions");
+};
+var rerenderEditor = async (key) => {
+  return invoke6("Editor.rerender", key);
+};
+var handleDebugPaused = async (params) => {
+  await invoke6("Run And Debug.handlePaused", params);
+};
+var openUri = async (uri, focus, options) => {
+  await invoke6("Main.openUri", {
+    ...options,
+    focus,
+    uri
+  });
+};
+var sendMessagePortToSyntaxHighlightingWorker = async (port) => {
+  await invokeAndTransfer6("SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker", port, "HandleMessagePort.handleMessagePort2");
+};
+var sendMessagePortToBlobWorker = async (port, rpcId = 0) => {
+  const command = "Blob.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToBlobWorker", port, command, rpcId);
+};
+var sendMessagePortToDiffWorker = async (port, rpcId = 0) => {
+  const command = "Diff.handleMessagePort";
+  await invokeAndTransfer6("SendMessagePortToExtensionHostWorker.sendMessagePortToDiffWorker", port, command, rpcId);
+};
+var handleDebugScriptParsed = async (script) => {
+  await invoke6("Run And Debug.handleScriptParsed", script);
+};
+var getWindowId = async () => {
+  return invoke6("GetWindowId.getWindowId");
+};
+var getBlob = async (uri) => {
+  return invoke6("FileSystem.getBlob", uri);
+};
+var getExtensionCommands = async () => {
+  return invoke6("ExtensionHost.getCommands");
+};
+var showErrorDialog = async (errorInfo) => {
+  await invoke6("ErrorHandling.showErrorDialog", errorInfo);
+};
+var getFolderSize = async (uri) => {
+  return await invoke6("FileSystem.getFolderSize", uri);
+};
+var getExtension2 = async (id2) => {
+  return invoke6("ExtensionManagement.getExtension", id2);
+};
+var getMarkdownDom = async (html) => {
+  return invoke6("Markdown.getVirtualDom", html);
+};
+var renderMarkdown = async (markdown, options) => {
+  return invoke6("Markdown.renderMarkdown", markdown, options);
+};
+var openNativeFolder = async (uri) => {
+  await invoke6("OpenNativeFolder.openNativeFolder", uri);
+};
+var uninstallExtension = async (id2) => {
+  return invoke6("ExtensionManagement.uninstall", id2);
+};
+var installExtension = async (id2) => {
+  return invoke6("ExtensionManagement.install", id2);
+};
+var minimizeWindow = async () => {
+  return invoke6("ElectronWindow.minimize");
+};
+var unmaximizeWindow = async () => {
+  return invoke6("ElectronWindow.unmaximize");
+};
+var maximizeWindow = async () => {
+  return invoke6("ElectronWindow.maximize");
+};
+var showSideBar = async (id2, focus) => {
+  return invoke6("SideBar.show", id2, focus);
+};
+var closeWindow = async () => {
+  return invoke6("ElectronWindow.close");
+};
+var openExtensionSearch = async () => {
+  return invoke6("SideBar.openViewlet", "Extensions");
+};
+var setExtensionsSearchValue = async (searchValue) => {
+  return invoke6("Extensions.handleInput", searchValue, InputSource_exports.Script);
+};
+var openExternal = async (uri) => {
+  await invoke6("Open.openExternal", uri);
+};
+var openUrl = async (uri) => {
+  await invoke6("Open.openUrl", uri);
+};
+var getAllPreferences = async () => {
+  return invoke6("Preferences.getAll");
+};
+var showSaveFilePicker = async () => {
+  return invoke6("FilePicker.showSaveFilePicker");
+};
+var getLogsDir = async () => {
+  return invoke6("PlatformPaths.getLogsDir");
+};
+var measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
+  return invoke6(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+};
+var refreshOutput = async () => {
+  await invoke6("Output.refresh");
+};
+var send = async (port, sourceId = 0) => {
+  await sendMessagePortToOpenerWorker(port, sourceId);
+};
+var initializeOpenerWorker = async () => {
+  const rpc = await LazyTransferMessagePortRpcParent_exports.create({
+    commandMap: {},
+    send
+  });
+  set4(rpc);
+};
+var send2 = async (port) => {
+  await sendMessagePortToEditorWorker(port, RpcId_exports.TestWorker);
+};
+var initializeEditorWorker = async () => {
+  const rpc = await LazyTransferMessagePortRpcParent_exports.create({
+    commandMap: {},
+    send: send2
+  });
+  set2(rpc);
+};
+var send3 = (port) => {
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+var initializeTextMeasurementWorker = async () => {
+  const rpc = await LazyTransferMessagePortRpcParent_exports.create({
+    commandMap: {},
+    send: send3
+  });
+  set6(rpc);
+};
+var send4 = (port) => {
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+var initializeProcessExplorer = async () => {
+  const rpc = await LazyTransferMessagePortRpcParent_exports.create({
+    commandMap: {},
+    send: send4
+  });
+  set5(rpc);
+};
+
+// node_modules/@lvce-editor/viewlet-registry/dist/index.js
+var toCommandId = (key) => {
+  const dotIndex = key.indexOf(".");
+  return key.slice(dotIndex + 1);
+};
+var create10 = () => {
+  const commandQueues = /* @__PURE__ */ new Map();
+  const generations = /* @__PURE__ */ Object.create(null);
+  const states = /* @__PURE__ */ Object.create(null);
+  const commandMapRef = {};
+  const getGeneration = (uid) => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== void 0 && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async (updater) => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
+  return {
+    clear() {
+      commandQueues.clear();
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        scheduledState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, scheduledState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    dispose(uid) {
+      commandQueues.delete(uid);
+      delete states[uid];
+    },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    getKeys() {
+      return Object.keys(states).map(Number);
+    },
+    registerCommands(commandMap2) {
+      Object.assign(commandMapRef, commandMap2);
+    },
+    set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
+      states[uid] = {
+        newState,
+        oldState,
+        scheduledState: scheduledState ?? newState
+      };
+    },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
+        }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
+    }
+  };
+};
+
+// packages/notification-center-view/src/parts/NotificationCenterStates/NotificationCenterStates.ts
+var { get: get3, getCommandIds, getKeys, registerCommands, set: set8, wrapCommand } = create10();
+
+// packages/notification-center-view/src/parts/Create/Create.ts
+var create11 = (uid) => {
+  const state = { notifications: [], uid };
+  set8(uid, state, state);
+};
+
+// packages/notification-center-view/src/parts/Diff2/Diff2.ts
+var diff2 = (uid) => {
+  const { oldState, scheduledState } = get3(uid);
+  return oldState.notifications === scheduledState.notifications ? [] : [1];
+};
+
+// packages/notification-center-view/src/parts/HandleClick/HandleClick.ts
+var handleClick = async (state, name) => {
+  if (name === "clear") {
+    await ExtensionManagementWorker_exports.invoke("Extensions.clearNotifications");
+    return { ...state, notifications: [] };
+  }
+  if (name.startsWith("dismiss:")) {
+    const id2 = Number(name.slice("dismiss:".length));
+    await ExtensionManagementWorker_exports.invoke("Extensions.dismissNotification", id2);
+    return { ...state, notifications: state.notifications.filter((notification) => notification.id !== id2) };
+  }
+  if (name.startsWith("hide:")) {
+    const extensionId = name.slice("hide:".length);
+    await ExtensionManagementWorker_exports.invoke("Extensions.hideNotificationsFromExtension", extensionId);
+    return { ...state, notifications: state.notifications.filter((notification) => notification.extensionId !== extensionId) };
+  }
+  return state;
+};
+
+// packages/notification-center-view/src/parts/HandleNotificationsChanged/HandleNotificationsChanged.ts
+var handleNotificationsChanged = (state, notifications) => {
+  return { ...state, notifications };
+};
+
+// packages/notification-center-view/src/parts/HandleExtensionManagementMessagePort/HandleExtensionManagementMessagePort.ts
+var handleExtensionManagementMessagePort = async (port) => {
+  const rpc = await PlainMessagePortRpc_exports.create({
+    commandMap: { "NotificationCenter.handleNotificationsChanged": handleNotificationsChanged },
+    messagePort: port
+  });
+  ExtensionManagementWorker_exports.set(rpc);
+};
+
+// packages/notification-center-view/src/parts/LoadContent/LoadContent.ts
+var loadContent = async (state) => {
+  const notifications = await ExtensionManagementWorker_exports.invoke("Extensions.getNotifications");
+  return { ...state, notifications };
+};
+
+// node_modules/@lvce-editor/virtual-dom-worker/dist/parts/Text/Text.js
+var text = (data) => {
+  return {
+    childCount: 0,
+    text: data,
+    type: VirtualDomElements_exports.Text
+  };
+};
+
+// node_modules/@lvce-editor/virtual-dom-worker/dist/parts/Validate/Validate.js
+var validVirtualDomElementTypes = new Set(Object.values(VirtualDomElements_exports));
+
+// packages/notification-center-view/src/parts/GetNotificationCenterVirtualDom/GetNotificationCenterVirtualDom.ts
+var onClick = 1;
+var getNotificationDom = (notification) => {
+  return [
+    { childCount: 3, className: `NotificationCenterItem NotificationCenterItem-${notification.type}`, type: VirtualDomElements_exports.Article },
+    { childCount: 2, className: "NotificationCenterItemHeader", type: VirtualDomElements_exports.Div },
+    { childCount: 1, className: "NotificationCenterExtension", type: VirtualDomElements_exports.Span },
+    text(notification.extensionId),
+    {
+      ariaLabel: "Dismiss Notification",
+      childCount: 1,
+      className: "NotificationCenterIconButton",
+      name: `dismiss:${notification.id}`,
+      onClick,
+      type: VirtualDomElements_exports.Button
+    },
+    text("\xD7"),
+    { childCount: 1, className: "NotificationCenterMessage", type: VirtualDomElements_exports.Div },
+    text(notification.message),
+    {
+      ariaLabel: `Hide notifications from ${notification.extensionId}`,
+      childCount: 1,
+      className: "NotificationCenterHideButton",
+      name: `hide:${notification.extensionId}`,
+      onClick,
+      type: VirtualDomElements_exports.Button
+    },
+    text(`Hide notifications from ${notification.extensionId}`)
+  ];
+};
+var getNotificationCenterVirtualDom = (notifications) => {
+  const content = notifications.length === 0 ? [{ childCount: 1, className: "NotificationCenterEmpty", type: VirtualDomElements_exports.Div }, text("No new notifications")] : notifications.flatMap(getNotificationDom);
+  return [
+    { ariaLabel: "Notifications", childCount: 2, className: "Viewlet NotificationCenter", role: "dialog", type: VirtualDomElements_exports.Div },
+    { childCount: 2, className: "NotificationCenterHeader", type: VirtualDomElements_exports.Div },
+    { childCount: 1, className: "NotificationCenterTitle", type: VirtualDomElements_exports.H2 },
+    text("Notifications"),
+    {
+      ariaLabel: "Clear All Notifications",
+      childCount: 1,
+      className: "NotificationCenterClearButton",
+      name: "clear",
+      onClick,
+      type: VirtualDomElements_exports.Button
+    },
+    text("Clear All"),
+    { childCount: content.length, className: "NotificationCenterList", type: VirtualDomElements_exports.Div },
+    ...content
+  ];
+};
+
+// packages/notification-center-view/src/parts/Render2/Render2.ts
+var render2 = (uid, diffResult) => {
+  const { scheduledState } = get3(uid);
+  set8(uid, scheduledState, scheduledState);
+  if (diffResult.length === 0) {
+    return [];
+  }
+  return [[ViewletCommand_exports.SetDom2, uid, getNotificationCenterVirtualDom(scheduledState.notifications)]];
+};
+
+// packages/notification-center-view/src/parts/RenderEventListeners/RenderEventListeners.ts
+var renderEventListeners = () => {
+  return [{ name: 1, params: ["handleClick", EventExpression_exports.TargetName] }];
+};
+
+// packages/notification-center-view/src/parts/CommandMap/CommandMap.ts
+var commandMap = {
+  "NotificationCenter.create": create11,
+  "NotificationCenter.diff2": diff2,
+  "NotificationCenter.getCommandIds": getCommandIds,
+  "NotificationCenter.handleClick": wrapCommand(handleClick),
+  "NotificationCenter.handleExtensionManagementMessagePort": handleExtensionManagementMessagePort,
+  "NotificationCenter.handleNotificationsChanged": wrapCommand(handleNotificationsChanged),
+  "NotificationCenter.loadContent": wrapCommand(loadContent),
+  "NotificationCenter.render2": render2,
+  "NotificationCenter.renderEventListeners": renderEventListeners
+};
+
+// packages/notification-center-view/src/parts/Main/Main.ts
+var main = async () => {
+  registerCommands(commandMap);
+  const rpc = await WebWorkerRpcClient_exports.create({ commandMap });
+  RendererWorker_exports.set(rpc);
+};
+
+// packages/notification-center-view/src/notificationCenterWorkerMain.ts
+await main();