@lvce-editor/renderer-process 30.17.1 → 30.19.0

package/dist/editorOnlyRendererProcessMain.js

@@ -0,0 +1,2815 @@
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine$2 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(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;
+};
+class VError 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) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+
+const isMessagePort = value => {
+  return value && value instanceof MessagePort;
+};
+const isMessagePortMain = value => {
+  return value && value.constructor && value.constructor.name === 'MessagePortMain';
+};
+const isOffscreenCanvas = value => {
+  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
+};
+const isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+const isSocket = value => {
+  return isInstanceOf(value, 'Socket');
+};
+const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+const isTransferrable = value => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
+  }
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+  }
+};
+const getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
+};
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
+const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
+const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
+const NewLine$1 = '\n';
+const joinLines$1 = lines => {
+  return lines.join(NewLine$1);
+};
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+};
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines$1(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)
+  };
+};
+const splitLines$1 = lines => {
+  return lines.split(NewLine$1);
+};
+const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
+const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
+const isMessageCodeBlockStartIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_START.test(line);
+};
+const isMessageCodeBlockEndIndex = line => {
+  return RE_MESSAGE_CODE_BLOCK_END.test(line);
+};
+const getMessageCodeBlock = stderr => {
+  const lines = splitLines$1(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;
+};
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines$1(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
+  return {
+    code: ERR_MODULE_NOT_FOUND,
+    message
+  };
+};
+const isModuleNotFoundError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
+};
+const isModulesSyntaxError = stderr => {
+  if (!stderr) {
+    return false;
+  }
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
+};
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
+};
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
+  return {
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
+  };
+};
+const getModuleSyntaxError = () => {
+  return {
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
+  };
+};
+const getHelpfulChildProcessError = (stdout, stderr) => {
+  if (isUnhelpfulNativeModuleError(stderr)) {
+    return getNativeModuleErrorMessage(stderr);
+  }
+  if (isModulesSyntaxError(stderr)) {
+    return getModuleSyntaxError();
+  }
+  if (isModuleNotFoundError(stderr)) {
+    return getModuleNotFoundError(stderr);
+  }
+  const lines = splitLines$1(stderr);
+  const {
+    actualMessage,
+    rest
+  } = getDetails(lines);
+  return {
+    code: '',
+    message: actualMessage,
+    stack: rest
+  };
+};
+class IpcError extends VError {
+  // @ts-ignore
+  constructor(betterMessage, stdout = '', stderr = '') {
+    if (stdout || stderr) {
+      // @ts-ignore
+      const {
+        code,
+        message,
+        stack
+      } = getHelpfulChildProcessError(stdout, stderr);
+      const cause = new Error(message);
+      // @ts-ignore
+      cause.code = code;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
+      super(cause, betterMessage);
+    } else {
+      super(betterMessage);
+    }
+    // @ts-ignore
+    this.name = 'IpcError';
+    // @ts-ignore
+    this.stdout = stdout;
+    // @ts-ignore
+    this.stderr = stderr;
+  }
+}
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = 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;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort 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) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
+const Message = 'message';
+const Error$1 = 'error';
+const getFirstWorkerEvent = worker => {
+  return getFirstEvent(worker, {
+    error: Error$1,
+    message: Message
+  });
+};
+const isErrorEvent = event => {
+  return event instanceof ErrorEvent;
+};
+const getWorkerDisplayName = name => {
+  if (!name) {
+    return '<unknown> worker';
+  }
+  if (name.endsWith('Worker') || name.endsWith('worker')) {
+    return name.toLowerCase();
+  }
+  return `${name} Worker`;
+};
+const tryToGetActualErrorMessage = async ({
+  name
+}) => {
+  const displayName = getWorkerDisplayName(name);
+  return `Failed to start ${displayName}: Worker Launch Error`;
+};
+class WorkerError extends Error {
+  constructor(event) {
+    super(event.message);
+    const stackLines = splitLines$1(this.stack || '');
+    const relevantLines = stackLines.slice(1);
+    const relevant = joinLines$1(relevantLines);
+    this.stack = `${event.message}
+    at Module (${event.filename}:${event.lineno}:${event.colno})
+${relevant}`;
+  }
+}
+const Module = 'module';
+const create$4$1 = async ({
+  name,
+  url
+}) => {
+  const worker = new Worker(url, {
+    name,
+    type: Module
+  });
+  const {
+    event,
+    type
+  } = await getFirstWorkerEvent(worker);
+  switch (type) {
+    case Message:
+      if (event.data !== readyMessage) {
+        throw new IpcError('unexpected first message from worker');
+      }
+      break;
+    case Error$1:
+      if (isErrorEvent(event)) {
+        throw new WorkerError(event);
+      }
+      const actualErrorMessage = await tryToGetActualErrorMessage({
+        name
+      });
+      throw new Error(actualErrorMessage);
+  }
+  return worker;
+};
+const getData = event => {
+  // TODO why are some events not instance of message event?
+  if (event instanceof MessageEvent) {
+    return event.data;
+  }
+  return event;
+};
+class IpcParentWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$4 = worker => {
+  return new IpcParentWithModuleWorker(worker);
+};
+const IpcParentWithModuleWorker$1 = {
+  __proto__: null,
+  create: create$4$1,
+  wrap: wrap$4
+};
+
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+const Two$1 = '2.0';
+const callbacks = Object.create(null);
+const get$3 = id => {
+  return callbacks[id];
+};
+const remove = id => {
+  delete callbacks[id];
+};
+class JsonRpcError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'JsonRpcError';
+  }
+}
+const NewLine = '\n';
+const DomException = 'DOMException';
+const ReferenceError$1 = 'ReferenceError';
+const SyntaxError$1 = 'SyntaxError';
+const TypeError$1 = 'TypeError';
+const 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;
+};
+const 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);
+};
+const joinLines = lines => {
+  return lines.join(NewLine);
+};
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
+const getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
+  return currentStack;
+};
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
+};
+const getParentStack = error => {
+  let parentStack = error.stack || error.data || error.message || '';
+  if (parentStack.startsWith('    at')) {
+    parentStack = error.message + NewLine + parentStack;
+  }
+  return parentStack;
+};
+const MethodNotFound = -32601;
+const Custom = -32001;
+const 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
+  });
+};
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
+const 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}`);
+};
+const 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');
+};
+const warn = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$3(id);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove(id);
+};
+const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
+const getErrorType = prettyError => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return undefined;
+};
+const isAlreadyStack = line => {
+  return line.trim().startsWith('at ');
+};
+const 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;
+};
+const 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
+  };
+};
+const create$1$1 = (id, error) => {
+  return {
+    error,
+    id,
+    jsonrpc: Two$1
+  };
+};
+const getErrorResponse = (id, error, preparePrettyError, logError) => {
+  const prettyError = preparePrettyError(error);
+  logError(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1$1(id, errorProperty);
+};
+const create$7 = (message, result) => {
+  return {
+    id: message.id,
+    jsonrpc: Two$1,
+    result: result ?? null
+  };
+};
+const getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create$7(message, resultProperty);
+};
+const getErrorResponseSimple = (id, error) => {
+  return {
+    error: {
+      code: Custom,
+      data: error,
+      // @ts-ignore
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
+  };
+};
+const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
+  try {
+    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError, logError);
+  }
+};
+const defaultPreparePrettyError = error => {
+  return error;
+};
+const defaultLogError = () => {
+  // ignore
+};
+const defaultRequiresSocket = () => {
+  return false;
+};
+const defaultResolve = resolve;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const 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]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    execute,
+    ipc,
+    logError,
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
+  } = options;
+  if ('id' in message) {
+    if ('method' in message) {
+      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve(message.id, message);
+    return;
+  }
+  if ('method' in message) {
+    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
+    return;
+  }
+  throw new JsonRpcError('unexpected message');
+};
+
+const Two = '2.0';
+
+const create$6 = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+
+const create$5 = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+
+let id = 0;
+const create$4 = () => {
+  return ++id;
+};
+
+const registerPromise = map => {
+  const id = create$4();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$5(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create$6(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
+};
+
+const requiresSocket = () => {
+  return false;
+};
+const preparePrettyError = error => {
+  return error;
+};
+const logError = () => {
+  // handled by renderer worker
+};
+const 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);
+};
+
+const handleIpc = ipc => {
+  if ('addEventListener' in ipc) {
+    ipc.addEventListener('message', handleMessage);
+  } else if ('on' in ipc) {
+    // deprecated
+    ipc.on('message', handleMessage);
+  }
+};
+const unhandleIpc = ipc => {
+  if ('removeEventListener' in ipc) {
+    ipc.removeEventListener('message', handleMessage);
+  } else {
+    // deprecated
+    ipc.onmessage = null;
+  }
+};
+
+const create$3 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const isWorker = value => {
+  return value instanceof Worker;
+};
+
+const create$2 = async ({
+  commandMap,
+  name,
+  port,
+  url
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const worker = await IpcParentWithModuleWorker$1.create({
+    name,
+    url
+  });
+  if (!isWorker(worker)) {
+    throw new Error(`worker must be of type Worker`);
+  }
+  const ipc = IpcParentWithModuleWorker$1.wrap(worker);
+  handleIpc(ipc);
+  const workerRpc = createRpc(ipc);
+  await workerRpc.invokeAndTransfer('initialize', 'message-port', port);
+  unhandleIpc(ipc);
+  return workerRpc;
+};
+
+const commandMapRef = {};
+
+const getEditorOnlyConfig = () => {
+  const configElement = document.getElementById('Config');
+  if (!configElement?.textContent) {
+    return {};
+  }
+  const config = JSON.parse(configElement.textContent);
+  return config.editorOnly || {};
+};
+
+const controlOrMeta = event => {
+  return event.ctrlKey || event.metaKey;
+};
+const getShortcutCommand = event => {
+  if (!controlOrMeta(event)) {
+    return '';
+  }
+  switch (event.key.toLowerCase()) {
+    case 'a':
+      return 'selectAll';
+    case 'y':
+      return 'redo';
+    case 'z':
+      return event.shiftKey ? 'redo' : 'undo';
+    default:
+      return '';
+  }
+};
+const getHorizontalCommand = event => {
+  if (event.key === 'ArrowLeft') {
+    if (event.shiftKey) {
+      return 'selectCharacterLeft';
+    }
+    return controlOrMeta(event) ? 'cursorWordLeft' : 'cursorLeft';
+  }
+  if (event.key === 'ArrowRight') {
+    if (event.shiftKey) {
+      return 'selectCharacterRight';
+    }
+    return controlOrMeta(event) ? 'cursorWordRight' : 'cursorRight';
+  }
+  return '';
+};
+const getNavigationCommand = event => {
+  switch (event.key) {
+    case 'ArrowDown':
+      return event.shiftKey ? 'selectDown' : 'cursorDown';
+    case 'ArrowUp':
+      return event.shiftKey ? 'selectUp' : 'cursorUp';
+    case 'Backspace':
+      return controlOrMeta(event) ? 'deleteWordLeft' : 'deleteLeft';
+    case 'Delete':
+      return controlOrMeta(event) ? 'deleteWordRight' : 'deleteRight';
+    case 'End':
+      return 'cursorEnd';
+    case 'Home':
+      return 'cursorHome';
+    case 'PageDown':
+      return 'cursorPageDown';
+    case 'Tab':
+      return 'handleTab';
+    default:
+      return '';
+  }
+};
+const getEditorCommand = event => {
+  return getShortcutCommand(event) || getHorizontalCommand(event) || getNavigationCommand(event);
+};
+
+const uidSymbol = Symbol('uid');
+
+const getUidTarget = $Element => {
+  while ($Element) {
+    if (Object.getOwnPropertyDescriptor($Element, uidSymbol)?.value) {
+      return $Element;
+    }
+    $Element = $Element.parentNode;
+  }
+  return undefined;
+};
+
+const setComponentUid = ($Element, uid) => {
+  Object.defineProperty($Element, uidSymbol, {
+    configurable: true,
+    value: uid,
+    writable: true
+  });
+};
+const getComponentUid = $Element => {
+  const $Target = getUidTarget($Element);
+  if (!$Target) {
+    return 0;
+  }
+  return Object.getOwnPropertyDescriptor($Target, uidSymbol)?.value;
+};
+const getComponentUidFromEvent = event => {
+  const {
+    currentTarget,
+    target
+  } = event;
+  return getComponentUid(currentTarget || target);
+};
+
+const dragInfos = Object.create(null);
+const getDragInfo = id => {
+  return dragInfos[id];
+};
+const isDragInfoOld = data => {
+  return Array.isArray(data);
+};
+
+const setDragImage = (dataTransfer, label) => {
+  const dragImage = document.createElement('div');
+  dragImage.className = 'DragImage';
+  dragImage.textContent = label;
+  document.body.append(dragImage);
+  dataTransfer.setDragImage(dragImage, -10, -10);
+  const handleTimeout = () => {
+    dragImage.remove();
+  };
+  setTimeout(handleTimeout, 0);
+};
+
+const applyDragInfoMaybe = event => {
+  const {
+    dataTransfer,
+    target
+  } = event;
+  if (dataTransfer) {
+    const uid = getComponentUid(target);
+    const dragInfo = getDragInfo(uid);
+    if (!dragInfo) {
+      return;
+    }
+    if (isDragInfoOld(dragInfo)) {
+      for (const item of dragInfo) {
+        dataTransfer.setData(item.type, item.data);
+      }
+    } else {
+      for (const item of dragInfo.items) {
+        dataTransfer.items.add(item.data, item.type);
+      }
+      if (dragInfo.label) {
+        setDragImage(dataTransfer, dragInfo.label);
+      }
+    }
+  }
+};
+
+const PointerMove = 'pointermove';
+const PointerUp = 'pointerup';
+const lostpointercapture = 'lostpointercapture';
+
+const createEventState = () => {
+  let ignore = false;
+  return {
+    startIgnore() {
+      ignore = true;
+    },
+    stopIgnore() {
+      ignore = false;
+    },
+    enabled() {
+      return ignore;
+    }
+  };
+};
+const eventState = createEventState();
+const startIgnore = () => {
+  eventState.startIgnore();
+};
+const stopIgnore = () => {
+  eventState.stopIgnore();
+};
+const enabled = () => {
+  return eventState.enabled();
+};
+
+const createIdGenerator = () => {
+  let id = 0;
+  return () => {
+    return ++id;
+  };
+};
+const create$1 = createIdGenerator();
+
+const state$2 = Object.create(null);
+const add$1 = promise => {
+  const id = create$1();
+  state$2[id] = promise;
+  return id;
+};
+
+const unwrapItemString = async item => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  item.getAsString(resolve);
+  const value = await promise;
+  return {
+    kind: 'string',
+    type: item.type,
+    value
+  };
+};
+const unwrapItemFile = async item => {
+  // @ts-ignore
+  if (item.getAsFileSystemHandle) {
+    // @ts-ignore
+    const file = await item.getAsFileSystemHandle();
+    return {
+      kind: 'file',
+      type: item.type,
+      value: file
+    };
+  }
+  const file = item.getAsFile();
+  return {
+    kind: 'file-legacy',
+    type: item.type,
+    value: file
+  };
+};
+const unknownItem = {
+  kind: 'unknown',
+  type: '',
+  value: ''
+};
+const unwrapItem = item => {
+  switch (item.kind) {
+    case 'file':
+      return unwrapItemFile(item);
+    case 'string':
+      return unwrapItemString(item);
+    default:
+      return unknownItem;
+  }
+};
+const handleDataTransferFiles = event => {
+  if (!event.dataTransfer) {
+    return [];
+  }
+  const items = [...event.dataTransfer.items];
+  const promises = items.map(unwrapItem);
+  const ids = promises.map(promise => add$1(promise));
+  return ids;
+};
+const handleClipboardDataFiles = event => {
+  if (!event.clipboardData) {
+    return [];
+  }
+  const files = [];
+  for (const item of event.clipboardData.items) {
+    if (item.kind !== 'file') {
+      continue;
+    }
+    const file = item.getAsFile();
+    if (file) {
+      files.push(file);
+    }
+  }
+  return files;
+};
+const getTargetName = event => {
+  const {
+    target
+  } = event;
+  if (target.name) {
+    return target.name;
+  }
+  const namedTarget = target.closest?.('[name]') || target.parentElement?.closest?.('[name]');
+  if (event.currentTarget?.contains && namedTarget !== event.currentTarget && !event.currentTarget.contains(namedTarget)) {
+    return '';
+  }
+  return namedTarget?.getAttribute?.('name') || namedTarget?.name || '';
+};
+const getNestedProperty = (value, path) => {
+  const parts = path.split('.');
+  let current = value;
+  for (const part of parts) {
+    if (current === undefined || current === null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+};
+const getEventListenerArg = (param, event) => {
+  switch (param) {
+    case 'event.altKey':
+      return event.altKey;
+    case 'event.button':
+      return event.button;
+    case 'event.clientX':
+      return event.clientX;
+    case 'event.clientY':
+      return event.clientY;
+    case 'event.clipboardData.files':
+      return handleClipboardDataFiles(event);
+    case 'event.ctrlKey':
+      return event.ctrlKey;
+    case 'event.data':
+      return event.data;
+    case 'event.dataTransfer.files':
+      return event.dataTransfer.files;
+    case 'event.dataTransfer.files2':
+      return handleDataTransferFiles(event);
+    case 'event.defaultPrevented':
+      return event.defaultPrevented;
+    case 'event.deltaMode':
+      return event.deltaMode;
+    case 'event.deltaX':
+      return event.deltaX;
+    case 'event.deltaY':
+      return event.deltaY;
+    case 'event.detail':
+      return event.detail;
+    case 'event.inputType':
+      return event.inputType;
+    case 'event.isTrusted':
+      return event.isTrusted;
+    case 'event.key':
+      return event.key;
+    case 'event.shiftKey':
+      return event.shiftKey;
+    case 'event.target.checked':
+      return event.target.checked;
+    case 'event.target.className':
+      return event.target.className;
+    case 'event.target.href':
+      return event.target.href;
+    case 'event.target.name':
+      return getTargetName(event);
+    case 'event.target.nodeName':
+      return event.target.nodeName;
+    case 'event.target.scrollTop':
+      return event.target.scrollTop;
+    case 'event.target.selectionEnd':
+      return event.target.selectionEnd;
+    case 'event.target.selectionStart':
+      return event.target.selectionStart;
+    case 'event.target.src':
+      return event.target.src;
+    case 'event.target.value':
+      return event.target.value;
+    case 'event.x':
+      return event.x;
+    case 'event.y':
+      return event.y;
+    default:
+      if (typeof param === 'string' && param.startsWith('event.currentTarget.')) {
+        const path = param.slice('event.currentTarget.'.length);
+        return getNestedProperty(event.currentTarget, path);
+      }
+      if (typeof param === 'string' && param.startsWith('event.target.')) {
+        const path = param.slice('event.target.'.length);
+        return getNestedProperty(event.target, path);
+      }
+      return param;
+  }
+};
+
+const getEventListenerArgs = (params, event) => {
+  const serialized = Array.from(params, param => getEventListenerArg(param, event));
+  return serialized;
+};
+
+const state$1 = {
+  ipc: undefined
+};
+const getIpc = () => {
+  return state$1.ipc;
+};
+const setIpc = value => {
+  state$1.ipc = value;
+};
+
+const nameAnonymousFunction = (fn, name) => {
+  Object.defineProperty(fn, 'name', {
+    value: name
+  });
+};
+
+const isInputElement = element => {
+  return element instanceof HTMLInputElement;
+};
+
+const preventEventsMaybe = (info, event) => {
+  if (info.preventDefault === 2) {
+    if (!isInputElement(event.target)) {
+      event.preventDefault();
+    }
+  } else if (info.preventDefault) {
+    event.preventDefault();
+  }
+  if (info.stopPropagation) {
+    event.stopPropagation();
+  }
+};
+
+const applyPointerTrackMaybe = (info, map, event) => {
+  const {
+    trackPointerEvents
+  } = info;
+  if (!trackPointerEvents) {
+    return;
+  }
+  const {
+    pointerId,
+    target
+  } = event;
+  target.setPointerCapture(pointerId);
+  const [pointerMoveKey, pointerUpKey] = trackPointerEvents;
+  const pointerMove = map[pointerMoveKey];
+  const pointerUp = map[pointerUpKey];
+  const cleanup = () => {
+    target.removeEventListener(PointerMove, pointerMove);
+    target.removeEventListener(PointerUp, handlePointerUp);
+    target.removeEventListener(lostpointercapture, handlePointerUp);
+  };
+  const handlePointerUp = event => {
+    cleanup();
+    pointerUp(event);
+  };
+  target.addEventListener(PointerMove, pointerMove);
+  target.addEventListener(PointerUp, handlePointerUp);
+  target.addEventListener(lostpointercapture, handlePointerUp);
+};
+const createFn = (info, map) => {
+  const fn = event => {
+    if (enabled()) {
+      return;
+    }
+    const uid = getComponentUidFromEvent(event);
+    const args = getEventListenerArgs(info.params, event);
+    preventEventsMaybe(info, event);
+    applyDragInfoMaybe(event);
+    applyPointerTrackMaybe(info, map, event);
+    if (args.length === 0) {
+      return;
+    }
+    const ipc = getIpc();
+    ipc.send('Viewlet.executeViewletCommand', uid, ...args);
+  };
+  nameAnonymousFunction(fn, info.name);
+  if (info.passive) {
+    // TODO avoid mutating function property, maybe return an object with function and options
+    fn.passive = true;
+  }
+  if (info.capture) {
+    // TODO avoid mutating function property, maybe return an object with function and options
+    fn.capture = true;
+  }
+  return fn;
+};
+
+const listeners = Object.create(null);
+const registerEventListeners = (id, eventListeners) => {
+  const map = Object.create(null);
+  for (const info of eventListeners) {
+    const fn = createFn(info, map);
+    map[info.name] = fn;
+  }
+  listeners[id] = map;
+};
+const getEventListenerMap = id => {
+  const map = listeners[id];
+  return map;
+};
+
+const clearNode = $Node => {
+  $Node.textContent = '';
+};
+
+const Audio$1 = 'audio';
+const Button$1 = 'button';
+const Col$1 = 'col';
+const ColGroup$1 = 'colgroup';
+const Del$1 = 'del';
+const Div$1 = 'div';
+const H1$1 = 'h1';
+const H2$1 = 'h2';
+const H3$1 = 'h3';
+const H4$1 = 'h4';
+const H5$1 = 'h5';
+const H6$1 = 'h6';
+const I$1 = 'i';
+const Img$1 = 'img';
+const Input$1 = 'input';
+const Ins$1 = 'ins';
+const Kbd$1 = 'kbd';
+const Span$1 = 'span';
+const Table$1 = 'table';
+const TBody$1 = 'tbody';
+const Td$1 = 'td';
+const Th$1 = 'th';
+const THead$1 = 'thead';
+const Tr$1 = 'tr';
+const Article$1 = 'article';
+const Aside$1 = 'aside';
+const Footer$1 = 'footer';
+const Header$1 = 'header';
+const Nav$1 = 'nav';
+const Section$1 = 'section';
+const Search$1 = 'search';
+const Dd$1 = 'dd';
+const Dl$1 = 'dl';
+const Figcaption$1 = 'figcaption';
+const Figure$1 = 'figure';
+const Hr$1 = 'hr';
+const Li$1 = 'li';
+const Ol$1 = 'ol';
+const P$1 = 'p';
+const Pre$1 = 'pre';
+const A$1 = 'a';
+const Br$1 = 'br';
+const Cite$1 = 'cite';
+const Data$1 = 'data';
+const Time$1 = 'time';
+const Tfoot$1 = 'tfoot';
+const Ul$1 = 'ul';
+const Video$1 = 'video';
+const TextArea$1 = 'textarea';
+const Select$1 = 'select';
+const Option$1 = 'option';
+const Code$1 = 'code';
+const Label$1 = 'label';
+const Dt$1 = 'dt';
+const Iframe$1 = 'iframe';
+const Main$1 = 'main';
+const Em$1 = 'em';
+const Strong$1 = 'strong';
+const Style$1 = 'style';
+const Html$1 = 'html';
+const Head$1 = 'head';
+const Title$1 = 'title';
+const Meta$1 = 'meta';
+const Canvas$1 = 'canvas';
+const Circle$1 = 'circle';
+const Form$1 = 'form';
+const Defs$1 = 'defs';
+const Ellipse$1 = 'ellipse';
+const G$1 = 'g';
+const Line$1 = 'line';
+const Path$1 = 'path';
+const Polygon$1 = 'polygon';
+const Polyline$1 = 'polyline';
+const Quote$1 = 'quote';
+const BlockQuote$1 = 'blockquote';
+const Rect$1 = 'rect';
+const Svg$1 = 'svg';
+const Use$1 = 'use';
+
+const Audio = 0;
+const Button = 1;
+const Col = 2;
+const ColGroup = 3;
+const Div = 4;
+const H1 = 5;
+const Input = 6;
+const Kbd = 7;
+const Span = 8;
+const Table = 9;
+const TBody = 10;
+const Td = 11;
+const Text$1 = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const I = 16;
+const Img = 17;
+const Ins = 20;
+const Del = 21;
+const H2 = 22;
+const H3 = 23;
+const H4 = 24;
+const H5 = 25;
+const H6 = 26;
+const Article = 27;
+const Aside = 28;
+const Footer = 29;
+const Header = 30;
+const Nav = 40;
+const Section = 41;
+const Search = 42;
+const Dd = 43;
+const Dl = 44;
+const Figcaption = 45;
+const Figure = 46;
+const Hr = 47;
+const Li = 48;
+const Ol = 49;
+const P = 50;
+const Pre = 51;
+const A = 53;
+const Br = 55;
+const Cite = 56;
+const Data = 57;
+const Time = 58;
+const Tfoot = 59;
+const Ul = 60;
+const Video = 61;
+const TextArea = 62;
+const Select = 63;
+const Option = 64;
+const Code = 65;
+const Label = 66;
+const Dt = 67;
+const Iframe = 68;
+const Main = 69;
+const Strong = 70;
+const Em = 71;
+const Style = 72;
+const Html = 73;
+const Head = 74;
+const Title = 75;
+const Meta = 76;
+const Canvas = 77;
+const Form = 78;
+const BlockQuote = 79;
+const Quote = 80;
+const Circle = 81;
+const Defs = 82;
+const Ellipse = 83;
+const G = 84;
+const Line = 85;
+const Path = 86;
+const Polygon = 87;
+const Polyline = 88;
+const Rect = 89;
+const Svg = 90;
+const Use = 91;
+const Reference$1 = 100;
+
+const VirtualDomElements = {
+  __proto__: null,
+  A,
+  Article,
+  Aside,
+  Audio,
+  BlockQuote,
+  Br,
+  Button,
+  Canvas,
+  Circle,
+  Cite,
+  Code,
+  Col,
+  ColGroup,
+  Data,
+  Dd,
+  Defs,
+  Del,
+  Div,
+  Dl,
+  Dt,
+  Ellipse,
+  Em,
+  Figcaption,
+  Figure,
+  Footer,
+  Form,
+  G,
+  H1,
+  H2,
+  H3,
+  H4,
+  H5,
+  H6,
+  Head,
+  Header,
+  Hr,
+  Html,
+  I,
+  Iframe,
+  Img,
+  Input,
+  Ins,
+  Kbd,
+  Label,
+  Li,
+  Line,
+  Main,
+  Meta,
+  Nav,
+  Ol,
+  Option,
+  P,
+  Path,
+  Polygon,
+  Polyline,
+  Pre,
+  Quote,
+  Rect,
+  Reference: Reference$1,
+  Search,
+  Section,
+  Select,
+  Span,
+  Strong,
+  Style,
+  Svg,
+  TBody,
+  THead,
+  Table,
+  Td,
+  Text: Text$1,
+  TextArea,
+  Tfoot,
+  Th,
+  Time,
+  Title,
+  Tr,
+  Ul,
+  Use,
+  Video
+};
+
+const elementTagMap = {
+  [A]: A$1,
+  [Article]: Article$1,
+  [Aside]: Aside$1,
+  [Audio]: Audio$1,
+  [BlockQuote]: BlockQuote$1,
+  [Br]: Br$1,
+  [Button]: Button$1,
+  [Canvas]: Canvas$1,
+  [Circle]: Circle$1,
+  [Cite]: Cite$1,
+  [Code]: Code$1,
+  [Col]: Col$1,
+  [ColGroup]: ColGroup$1,
+  [Data]: Data$1,
+  [Dd]: Dd$1,
+  [Defs]: Defs$1,
+  [Del]: Del$1,
+  [Div]: Div$1,
+  [Dl]: Dl$1,
+  [Dt]: Dt$1,
+  [Ellipse]: Ellipse$1,
+  [Em]: Em$1,
+  [Figcaption]: Figcaption$1,
+  [Figure]: Figure$1,
+  [Footer]: Footer$1,
+  [Form]: Form$1,
+  [G]: G$1,
+  [H1]: H1$1,
+  [H2]: H2$1,
+  [H3]: H3$1,
+  [H4]: H4$1,
+  [H5]: H5$1,
+  [H6]: H6$1,
+  [Head]: Head$1,
+  [Header]: Header$1,
+  [Hr]: Hr$1,
+  [Html]: Html$1,
+  [I]: I$1,
+  [Iframe]: Iframe$1,
+  [Img]: Img$1,
+  [Input]: Input$1,
+  [Ins]: Ins$1,
+  [Kbd]: Kbd$1,
+  [Label]: Label$1,
+  [Li]: Li$1,
+  [Line]: Line$1,
+  [Main]: Main$1,
+  [Meta]: Meta$1,
+  [Nav]: Nav$1,
+  [Ol]: Ol$1,
+  [Option]: Option$1,
+  [P]: P$1,
+  [Path]: Path$1,
+  [Polygon]: Polygon$1,
+  [Polyline]: Polyline$1,
+  [Pre]: Pre$1,
+  [Quote]: Quote$1,
+  [Rect]: Rect$1,
+  [Search]: Search$1,
+  [Section]: Section$1,
+  [Select]: Select$1,
+  [Span]: Span$1,
+  [Strong]: Strong$1,
+  [Style]: Style$1,
+  [Svg]: Svg$1,
+  [Table]: Table$1,
+  [TBody]: TBody$1,
+  [Td]: Td$1,
+  [TextArea]: TextArea$1,
+  [Tfoot]: Tfoot$1,
+  [Th]: Th$1,
+  [THead]: THead$1,
+  [Time]: Time$1,
+  [Title]: Title$1,
+  [Tr]: Tr$1,
+  [Ul]: Ul$1,
+  [Use]: Use$1,
+  [Video]: Video$1
+};
+const getElementTag$1 = type => {
+  const elementTag = elementTagMap[type];
+  if (elementTag) {
+    return elementTag;
+  }
+  throw new Error(`element tag not found ${type}`);
+};
+
+const ElementTagMap = {
+  __proto__: null,
+  getElementTag: getElementTag$1
+};
+
+const {
+  getElementTag
+} = ElementTagMap;
+
+const instances = Object.create(null);
+const get$2 = viewletId => {
+  return instances[viewletId];
+};
+const set$2 = (viewletId, instance) => {
+  instances[viewletId] = instance;
+};
+
+const getEventListenerOptions = (eventName, value) => {
+  if (value.passive) {
+    return {
+      passive: true
+    };
+  }
+  if (value.capture) {
+    return {
+      capture: true
+    };
+  }
+  switch (eventName) {
+    case 'wheel':
+      return {
+        passive: true
+      };
+    default:
+      return undefined;
+  }
+};
+
+const cache = new Map();
+const has = listener => {
+  return cache.has(listener);
+};
+const set$1 = (listener, value) => {
+  cache.set(listener, value);
+};
+const get$1 = listener => {
+  return cache.get(listener);
+};
+
+const getWrappedListener = (listener, returnValue) => {
+  if (!returnValue) {
+    return listener;
+  }
+  if (!has(listener)) {
+    const wrapped = event => {
+      const uid = getComponentUidFromEvent(event);
+      const result = listener(event);
+      // TODO check for empty array by value
+      if (result.length === 0) {
+        return;
+      }
+      const ipc = getIpc();
+      ipc.send('Viewlet.executeViewletCommand', uid, ...result);
+    };
+    nameAnonymousFunction(wrapped, listener.name);
+    set$1(listener, wrapped);
+  }
+  return get$1(listener);
+};
+
+const attachedListeners = new WeakMap();
+const getOptions = fn => {
+  if (fn.passive) {
+    return {
+      passive: true
+    };
+  }
+  if (fn.capture) {
+    return {
+      capture: true
+    };
+  }
+  return undefined;
+};
+const attachEvent = ($Node, eventMap, key, value, newEventMap) => {
+  const keyLower = key.toLowerCase();
+  const listenersByEvent = attachedListeners.get($Node) || new Map();
+  const previous = listenersByEvent.get(keyLower);
+  if (previous) {
+    $Node.removeEventListener(keyLower, previous.listener, previous.options);
+  }
+  const fn = newEventMap?.[value];
+  if (fn) {
+    const options = getOptions(fn);
+    // TODO support event listener options
+    $Node.addEventListener(keyLower, fn, options);
+    listenersByEvent.set(keyLower, {
+      listener: fn,
+      options
+    });
+    attachedListeners.set($Node, listenersByEvent);
+    return;
+  }
+  const listener = eventMap[value];
+  if (!listener) {
+    console.warn('listener not found', value);
+    return;
+  }
+  const options = getEventListenerOptions(key, value);
+  const wrapped = getWrappedListener(listener, eventMap.returnValue);
+  $Node.addEventListener(keyLower, wrapped, options);
+  listenersByEvent.set(keyLower, {
+    listener: wrapped,
+    options
+  });
+  attachedListeners.set($Node, listenersByEvent);
+};
+const detachEvent = ($Node, key) => {
+  const keyLower = key.toLowerCase();
+  const listenersByEvent = attachedListeners.get($Node);
+  const previous = listenersByEvent?.get(keyLower);
+  if (!previous) {
+    return;
+  }
+  $Node.removeEventListener(keyLower, previous.listener, previous.options);
+  listenersByEvent?.delete(keyLower);
+};
+
+const toCamelCase = key => {
+  let camelCaseKey = '';
+  let shouldUpperCase = false;
+  for (const char of key) {
+    if (char === '-') {
+      shouldUpperCase = true;
+      continue;
+    }
+    camelCaseKey += shouldUpperCase ? char.toUpperCase() : char;
+    shouldUpperCase = false;
+  }
+  return camelCaseKey;
+};
+const setStyle = ($Element, styleString) => {
+  if (typeof styleString !== 'string') {
+    return;
+  }
+  for (const declaration of styleString.split(';')) {
+    const colonIndex = declaration.indexOf(':');
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = declaration.slice(0, colonIndex).trim();
+    const value = declaration.slice(colonIndex + 1).trim();
+    if (!key || !value) {
+      continue;
+    }
+    if (key.startsWith('--')) {
+      $Element.style.setProperty(key, value);
+      continue;
+    }
+    const camelCaseKey = toCamelCase(key);
+    $Element.style[camelCaseKey] = value;
+  }
+};
+
+const removedAttributeProps = new Map([['ariaActivedescendant', 'aria-activedescendant'], ['ariaControls', 'aria-controls'], ['ariaDescribedBy', 'aria-describedby'], ['ariaInvalid', 'aria-invalid'], ['ariaLabelledBy', 'aria-labelledby'], ['ariaOwns', 'aria-owns'], ['className', 'class'], ['htmlFor', 'for'], ['inputType', 'type']]);
+const pixelStyleProps = new Set(['height', 'left', 'marginTop', 'paddingLeft', 'paddingRight', 'top', 'width']);
+const eventProps = new Set(['onBlur', 'onChange', 'onClick', 'onContextMenu', 'onBeforeInput', 'onDblClick', 'onDragEnd', 'onDragEnter', 'onDragLeave', 'onDragOver', 'onDragStart', 'onDrop', 'onError', 'onFocus', 'onFocusIn', 'onFocusOut', 'onInput', 'onKeydown', 'onKeyDown', 'onKeyUp', 'onLoadedData', 'onMouseDown', 'onMouseMove', 'onMouseOut', 'onMouseOver', 'onMouseUp', 'onPointerDown', 'onPointerMove', 'onPointerOut', 'onPointerOver', 'onScroll', 'onSelectionChange', 'onSubmit', 'onTimeUpdate', 'onWheel']);
+const setOptionalAttribute = ($Element, attributeName, value) => {
+  if (value) {
+    $Element.setAttribute(attributeName, value);
+    return;
+  }
+  $Element.removeAttribute(attributeName);
+};
+const setDimension = ($Element, key, value) => {
+  if ($Element instanceof HTMLImageElement) {
+    $Element[key] = value;
+    return;
+  }
+  $Element.style[key] = typeof value === 'number' ? `${value}px` : value;
+};
+const setPixelStyle = ($Element, key, value) => {
+  $Element.style[key] = typeof value === 'number' ? `${value}px` : value;
+};
+const setEventProp = ($Element, key, value, eventMap, newEventMap) => {
+  if (!eventMap || !value) {
+    return;
+  }
+  const eventName = key.slice(2).toLowerCase();
+  attachEvent($Element, eventMap, eventName, value, newEventMap);
+};
+const removeProp = ($Element, key) => {
+  if (eventProps.has(key)) {
+    const eventName = key.slice(2).toLowerCase();
+    detachEvent($Element, eventName);
+    return;
+  }
+  if ((key === 'height' || key === 'width') && $Element instanceof HTMLImageElement) {
+    $Element.removeAttribute(key);
+    return;
+  }
+  if (pixelStyleProps.has(key)) {
+    $Element.style[key] = '';
+    return;
+  }
+  const attributeName = removedAttributeProps.get(key) || key;
+  $Element.removeAttribute(attributeName);
+};
+const setProp = ($Element, key, value, eventMap, newEventMap) => {
+  if (key.startsWith('aria-')) {
+    $Element.setAttribute(key, String(value));
+    return;
+  }
+  switch (key) {
+    case 'ariaActivedescendant':
+      setOptionalAttribute($Element, 'aria-activedescendant', value);
+      return;
+    case 'ariaControls':
+      $Element.setAttribute('aria-controls', value);
+      return;
+    case 'ariaDescribedBy':
+      $Element.setAttribute('aria-describedby', value);
+      return;
+    case 'ariaInvalid':
+      $Element.setAttribute('aria-invalid', value);
+      return;
+    case 'ariaLabelledBy':
+      $Element.setAttribute('aria-labelledby', value);
+      return;
+    case 'ariaOwns':
+      setOptionalAttribute($Element, 'aria-owns', value);
+      return;
+  }
+  if (key === 'height' || key === 'width') {
+    setDimension($Element, key, value);
+    return;
+  }
+  if (key === 'id') {
+    if (value) {
+      $Element[key] = value;
+    } else {
+      $Element.removeAttribute(key);
+    }
+    return;
+  }
+  if (key === 'inputType') {
+    // @ts-ignore
+    $Element.type = value;
+    return;
+  }
+  if (pixelStyleProps.has(key)) {
+    setPixelStyle($Element, key, value);
+    return;
+  }
+  if (key === 'maskImage') {
+    $Element.style.maskImage = `url('${value}')`;
+    $Element.style.webkitMaskImage = `url('${value}')`;
+    return;
+  }
+  if (eventProps.has(key)) {
+    setEventProp($Element, key, value, eventMap, newEventMap);
+    return;
+  }
+  if (key === 'style') {
+    setStyle($Element, value);
+    return;
+  }
+  if (key === 'translate') {
+    $Element.style[key] = value;
+    return;
+  }
+  if (key.startsWith('data-')) {
+    $Element.dataset[key.slice('data-'.length)] = value;
+    return;
+  }
+  $Element[key] = value;
+};
+
+const setProps = ($Element, props, eventMap, newEventMap) => {
+  for (const key in props) {
+    if (key === 'childCount' || key === 'type') {
+      continue;
+    }
+    setProp($Element, key, props[key], eventMap, newEventMap);
+  }
+};
+
+const {
+  Text,
+  Reference} = VirtualDomElements;
+
+const renderDomTextNode = element => {
+  return document.createTextNode(element.text);
+};
+const renderDomElement = (element, eventMap, newEventMap) => {
+  const tag = getElementTag(element.type);
+  const $Element = document.createElement(tag);
+  setProps($Element, element, eventMap, newEventMap);
+  return $Element;
+};
+const renderReferenceNode = (element, eventMap, newEventMap) => {
+  const instance = get$2(element.uid);
+  if (!instance || !instance.state) {
+    return document.createTextNode('Reference node not found');
+  }
+  const $Node = instance.state.$Viewlet;
+  const props = Object.fromEntries(Object.entries(element).filter(([key]) => key !== 'uid'));
+  setProps($Node, props, eventMap, newEventMap);
+  return $Node;
+};
+const render$2 = (element, eventMap, newEventMap) => {
+  switch (element.type) {
+    case Reference:
+      return renderReferenceNode(element, eventMap, newEventMap);
+    case Text:
+      return renderDomTextNode(element);
+    default:
+      return renderDomElement(element, eventMap, newEventMap);
+  }
+};
+
+const renderInternal = ($Parent, elements, eventMap, newEventMap) => {
+  const max = elements.length - 1;
+  let stack = [];
+  for (let i = max; i >= 0; i--) {
+    const element = elements[i];
+    const $Element = render$2(element, eventMap, newEventMap);
+    if (element.childCount > 0) {
+      // @ts-expect-error
+      $Element.append(...stack.slice(0, element.childCount));
+      stack = stack.slice(element.childCount);
+    }
+    stack.unshift($Element);
+  }
+  $Parent.append(...stack);
+};
+
+const renderInto = ($Parent, dom, eventMap = {}) => {
+  clearNode($Parent);
+  renderInternal($Parent, dom, eventMap);
+};
+/**
+ *
+ * @param {any[]} elements
+ * @returns
+ */
+const render$1 = (elements, eventMap = {}, newEventMap = {}) => {
+  const $Root = document.createElement('div');
+  renderInternal($Root, elements, eventMap, newEventMap);
+  return $Root;
+};
+
+const setText$1 = ($Element, value) => {
+  $Element.nodeValue = value;
+};
+const removeChild = ($Element, index) => {
+  const $Child = $Element.childNodes[index];
+  if ($Child) {
+    $Child.remove();
+  }
+};
+const add = ($Element, nodes, eventMap = {}) => {
+  renderInternal($Element, nodes, eventMap, eventMap);
+};
+const replace = ($Element, nodes, eventMap = {}) => {
+  // Create a temporary container to render the new nodes
+  const $Temp = document.createElement('div');
+  renderInternal($Temp, nodes, eventMap, eventMap);
+  // Replace the current element with the new node(s)
+  const $NewNode = $Temp.firstChild;
+  if (!$NewNode) {
+    // No node was created, just remove the old element
+    $Element.remove();
+    return $Element;
+  }
+  $Element.replaceWith($NewNode);
+  return $NewNode;
+};
+
+const SetText = 1;
+const Replace = 2;
+const SetAttribute = 3;
+const RemoveAttribute = 4;
+const Add = 6;
+const NavigateChild = 7;
+const NavigateParent = 8;
+const RemoveChild = 9;
+const NavigateSibling = 10;
+const SetReferenceNodeUid = 11;
+
+const handleNavigateChild = (state, patches, patchIndex) => {
+  const patch = patches[patchIndex];
+  const $Children = state.current.childNodes;
+  const $Child = $Children[patch.index];
+  if ($Child) {
+    state.current = $Child;
+    return true;
+  }
+  const nextPatch = patches[patchIndex + 1];
+  if (nextPatch && (nextPatch.type === Replace || nextPatch.type === SetReferenceNodeUid) && patch.index === $Children.length) {
+    const $Placeholder = document.createComment('virtual-dom-placeholder');
+    state.current.append($Placeholder);
+    state.current = $Placeholder;
+    return true;
+  }
+  console.error('Cannot navigate to child: child not found at index', {
+    $Current: state.current,
+    index: patch.index,
+    childCount: $Children.length
+  });
+  return false;
+};
+const handleNavigateParent = state => {
+  const $Parent = state.current.parentNode;
+  if (!$Parent) {
+    console.error('Cannot navigate to parent: current node has no parent', {
+      $Current: state.current
+    });
+    return false;
+  }
+  state.current = $Parent;
+  return true;
+};
+const handleNavigateSibling = (state, patch, $Element, patchIndex) => {
+  const $Parent = state.current.parentNode;
+  if (!$Parent) {
+    console.error('Cannot navigate to sibling: current node has no parent', {
+      patchIndex
+    });
+    return false;
+  }
+  let $Sibling = $Parent.childNodes[patch.index];
+  if (!$Sibling && !state.hasAppliedMutation && state.current !== $Element) {
+    $Sibling = $Element.childNodes[patch.index];
+  }
+  if (!$Sibling) {
+    console.error('Cannot navigate to sibling: sibling not found at index', {
+      $Parent,
+      index: patch.index,
+      childCount: $Parent.childNodes.length
+    });
+    return false;
+  }
+  state.current = $Sibling;
+  return true;
+};
+const handleSetReferenceNodeUid = (state, patch) => {
+  const instance = get$2(patch.uid);
+  if (!instance || !instance.state) {
+    console.error('Cannot set reference node uid: instance not found', {
+      uid: patch.uid
+    });
+    return false;
+  }
+  const $NewNode = instance.state.$Viewlet;
+  // @ts-ignore
+  state.current.replaceWith($NewNode);
+  state.current = $NewNode;
+  state.hasAppliedMutation = true;
+  return true;
+};
+const handleNavigationPatch = (state, patch, patches, patchIndex, $Element) => {
+  switch (patch.type) {
+    case NavigateChild:
+      return handleNavigateChild(state, patches, patchIndex);
+    case NavigateParent:
+      return handleNavigateParent(state);
+    case NavigateSibling:
+      return handleNavigateSibling(state, patch, $Element, patchIndex);
+    default:
+      return true;
+  }
+};
+const applyMutationPatch = (state, patch, events) => {
+  switch (patch.type) {
+    case Add:
+      add(state.current, patch.nodes, events);
+      state.hasAppliedMutation = true;
+      break;
+    case RemoveAttribute:
+      removeProp(state.current, patch.key);
+      state.hasAppliedMutation = true;
+      break;
+    case RemoveChild:
+      removeChild(state.current, patch.index);
+      state.hasAppliedMutation = true;
+      break;
+    case Replace:
+      state.current = replace(state.current, patch.nodes, events);
+      state.hasAppliedMutation = true;
+      break;
+    case SetAttribute:
+      setProp(state.current, patch.key, patch.value, events);
+      state.hasAppliedMutation = true;
+      break;
+    case SetText:
+      setText$1(state.current, patch.value);
+      state.hasAppliedMutation = true;
+      break;
+  }
+};
+const applyPatch = ($Element, patches, eventMap = {}, id = 0) => {
+  const events = getEventListenerMap(id) || eventMap;
+  const state = {
+    current: $Element,
+    hasAppliedMutation: false
+  };
+  for (let patchIndex = 0; patchIndex < patches.length; patchIndex++) {
+    const patch = patches[patchIndex];
+    try {
+      if (!handleNavigationPatch(state, patch, patches, patchIndex, $Element)) {
+        return;
+      }
+      if (patch.type === SetReferenceNodeUid) {
+        if (!handleSetReferenceNodeUid(state, patch)) {
+          return;
+        }
+        continue;
+      }
+      applyMutationPatch(state, patch, events);
+    } catch (error) {
+      console.error('Error applying patch at index ' + patchIndex, patch, error);
+      throw error;
+    }
+  }
+};
+
+const getActiveElementInside = $Viewlet => {
+  if (!$Viewlet) {
+    return undefined;
+  }
+  const $ActiveElement = document.activeElement;
+  if (!$ActiveElement) {
+    return undefined;
+  }
+  if (!$Viewlet.contains($ActiveElement)) {
+    return undefined;
+  }
+  return $ActiveElement;
+};
+
+const queryInputs = $Viewlet => {
+  return [...$Viewlet.querySelectorAll(':scope input, :scope textarea, :scope select')];
+};
+
+const focusElement = $Element => {
+  $Element.focus({
+    preventScroll: true
+  });
+};
+const getInputMap = $Viewlet => {
+  const $$Inputs = queryInputs($Viewlet);
+  const inputMap = Object.create(null);
+  for (const $Input of $$Inputs) {
+    inputMap[$Input.name] = $Input.value;
+  }
+  return inputMap;
+};
+const createHiddenContainer = (activeElement, focused) => {
+  const $Hidden = document.createElement('div');
+  $Hidden.style.display = 'none';
+  if (focused && activeElement && document.body) {
+    document.body.append($Hidden);
+    $Hidden.append(activeElement);
+  }
+  return $Hidden;
+};
+const restoreFocusedElement = ($Hidden, $New, focused) => {
+  const $NewFocused = $New.querySelector(`[name="${CSS.escape(focused)}"]`);
+  if (!$NewFocused) {
+    return;
+  }
+  const $Previous = $Hidden.firstChild;
+  if (!$Previous) {
+    return;
+  }
+  $Previous.className = $NewFocused.className;
+  $Previous.placeholder = $NewFocused.placeholder;
+  if ($NewFocused.childNodes) {
+    $Previous.replaceChildren(...$NewFocused.childNodes);
+  }
+  $NewFocused.replaceWith($Previous);
+};
+const renderWithUid = ($Viewlet, dom, eventMap, uid, inputMap, focused, $Hidden) => {
+  const newEventMap = getEventListenerMap(uid);
+  const $New = render$1(dom, eventMap, newEventMap).firstChild;
+  setComponentUid($New, uid);
+  const $$NewInputs = queryInputs($New);
+  for (const $Input of $$NewInputs) {
+    $Input.value = inputMap[$Input.name] || $Input.value || '';
+  }
+  $Viewlet.replaceWith($New);
+  if (focused) {
+    restoreFocusedElement($Hidden, $New, focused);
+  }
+  return $New;
+};
+const restoreFocus = ($Viewlet, isRootTree, isTreeFocused, focused) => {
+  if (isRootTree) {
+    focusElement($Viewlet);
+    return;
+  }
+  if (isTreeFocused) {
+    const $Tree = $Viewlet.querySelector(':scope [role="tree"]');
+    if ($Tree) {
+      // @ts-ignore
+      focusElement($Tree);
+    }
+    return;
+  }
+  if (!focused) {
+    return;
+  }
+  const $Focused = $Viewlet.querySelector(`[name="${CSS.escape(focused)}"]`);
+  if ($Focused) {
+    // @ts-ignore
+    focusElement($Focused);
+  }
+};
+const rememberFocus = ($Viewlet, dom, eventMap, uid = 0) => {
+  startIgnore();
+  const oldLeft = $Viewlet.style.left;
+  const oldTop = $Viewlet.style.top;
+  const oldWidth = $Viewlet.style.width;
+  const oldHeight = $Viewlet.style.height;
+  const activeElement = getActiveElementInside($Viewlet);
+  const isTreeFocused = activeElement?.getAttribute('role') === 'tree';
+  const isRootTree = $Viewlet.getAttribute('role') === 'tree' && activeElement === $Viewlet;
+  const focused = activeElement?.getAttribute('name') || null;
+  const $Hidden = createHiddenContainer(activeElement, focused);
+  if (uid) {
+    const numericUid = Number(uid);
+    const inputMap = getInputMap($Viewlet);
+    $Viewlet = renderWithUid($Viewlet, dom, eventMap, numericUid, inputMap, focused, $Hidden);
+  }
+  if (!uid) {
+    renderInto($Viewlet, dom, eventMap);
+  }
+  $Hidden.remove();
+  restoreFocus($Viewlet, isRootTree, isTreeFocused, focused);
+  $Viewlet.style.top = oldTop;
+  $Viewlet.style.left = oldLeft;
+  $Viewlet.style.height = oldHeight;
+  $Viewlet.style.width = oldWidth;
+  stopIgnore();
+  return $Viewlet;
+};
+
+const state = {
+  styleSheets: Object.create(null),
+  texts: Object.create(null)
+};
+const set = (id, sheet) => {
+  state.styleSheets[id] = sheet;
+};
+const get = id => {
+  return state.styleSheets[id];
+};
+const setText = (id, text) => {
+  state.texts[id] = text;
+};
+
+const addCssStyleSheet = (id, text) => {
+  const existing = get(id);
+  if (existing) {
+    existing.replaceSync(text);
+    setText(id, text);
+    return;
+  }
+  const sheet = new CSSStyleSheet({});
+  set(id, sheet);
+  setText(id, text);
+  sheet.replaceSync(text);
+  document.adoptedStyleSheets.push(sheet);
+};
+
+const ignoreCommand = () => {};
+const getElement = uid => {
+  const instance = get$2(uid);
+  const element = instance?.state?.$Viewlet;
+  if (!(element instanceof HTMLElement)) {
+    throw new TypeError(`Editor element ${uid} not found`);
+  }
+  return element;
+};
+const create = uid => {
+  const element = document.createElement('div');
+  setComponentUid(element, uid);
+  set$2(uid, {
+    factory: {},
+    state: {
+      $Viewlet: element
+    }
+  });
+  document.body.append(element);
+};
+const dispose = uid => {
+  getElement(uid).remove();
+  set$2(uid, undefined);
+};
+const focusSelector = (uid, selector) => {
+  const element = getElement(uid).querySelector(selector);
+  element?.focus();
+};
+const setBounds = (uid, left, top, width, height) => {
+  const element = getElement(uid);
+  element.style.left = `${left}px`;
+  element.style.top = `${top}px`;
+  element.style.width = `${width}px`;
+  element.style.height = `${height}px`;
+};
+const setPatches = (uid, patches) => {
+  const element = getElement(uid);
+  if (patches.length === 1 && patches[0].type === 6) {
+    const replacement = rememberFocus(element, patches[0].nodes, {}, uid);
+    setComponentUid(replacement, uid);
+    const instance = get$2(uid);
+    set$2(uid, {
+      ...instance,
+      state: {
+        ...instance.state,
+        $Viewlet: replacement
+      }
+    });
+    return;
+  }
+  applyPatch(element, patches, {}, uid);
+};
+const setSelectionByName = (uid, name, start, end) => {
+  const input = getElement(uid).querySelector(`[name="${CSS.escape(name)}"]`);
+  if (!input) {
+    return;
+  }
+  input.selectionStart = start;
+  input.selectionEnd = end;
+};
+const setUid = (uid, componentUid) => {
+  setComponentUid(getElement(uid), componentUid);
+};
+const setValueByName = (uid, name, value) => {
+  const input = getElement(uid).querySelector(`[name="${CSS.escape(name)}"]`);
+  if (input) {
+    input.value = value;
+  }
+};
+const commandHandlers = {
+  'Viewlet.dispose': dispose,
+  'Viewlet.focusSelector': focusSelector,
+  'Viewlet.setAdditionalFocus': ignoreCommand,
+  'Viewlet.setBounds': setBounds,
+  'Viewlet.setCss': addCssStyleSheet,
+  'Viewlet.setFocusContext': ignoreCommand,
+  'Viewlet.setPatches': setPatches,
+  'Viewlet.setSelectionByName': setSelectionByName,
+  'Viewlet.setUid': setUid,
+  'Viewlet.setValueByName': setValueByName,
+  'Viewlet.unsetAdditionalFocus': ignoreCommand
+};
+const executeCommands = commands => {
+  for (const [command, ...args] of commands) {
+    const handler = commandHandlers[command];
+    if (!handler) {
+      throw new Error(`Unsupported editor-only render command: ${command}`);
+    }
+    handler(...args);
+  }
+};
+
+const Web = 1;
+const Electron = 2;
+const Remote = 3;
+
+/**
+ * @returns {number}
+ */
+const getPlatform = () => {
+  // @ts-expect-error
+  if (typeof PLATFORM !== 'undefined') {
+    // @ts-expect-error
+    return PLATFORM;
+  }
+  // @ts-ignore
+  if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+    return Remote;
+  }
+  if (globalThis.isElectron) {
+    return Electron;
+  }
+  if (typeof location !== 'undefined' && location.search === '?web') {
+    return Web;
+  }
+  return Remote;
+};
+const platform = getPlatform();
+
+const getAssetDir = () => {
+  // @ts-expect-error
+  if (typeof ASSET_DIR !== 'undefined') {
+    // @ts-expect-error
+    return ASSET_DIR;
+  }
+  if (platform === Electron) {
+    return '../../../../..';
+  }
+  return '';
+};
+const assetDir = getAssetDir();
+
+const getConfiguredWorkerUrl = key => {
+  if (typeof location === 'undefined' || typeof document === 'undefined') {
+    return '';
+  }
+  const configElement = document.getElementById('Config');
+  if (!configElement) {
+    return '';
+  }
+  const text = configElement.textContent;
+  if (!text) {
+    return '';
+  }
+  const config = JSON.parse(text);
+  return config[key] || '';
+};
+
+const getConfiguredEditorWorkerUrl = () => {
+  return getConfiguredWorkerUrl('editorWorkerUrl');
+};
+
+const editorWorkerUrl = getConfiguredEditorWorkerUrl() || `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/editor-worker/dist/editorWorkerMain.js`;
+
+const getConfiguredSyntaxHighlightingWorkerUrl = () => {
+  return getConfiguredWorkerUrl('syntaxHighlightingWorkerUrl');
+};
+
+const syntaxHighlightingWorkerUrl = getConfiguredSyntaxHighlightingWorkerUrl() || `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/syntax-highlighting-worker/dist/syntaxHighlightingWorkerMain.js`;
+
+const editorUid = 1;
+const getCharWidth = (fontFamily, fontSize, fontWeight) => {
+  const canvas = document.createElement('canvas');
+  const context = canvas.getContext('2d');
+  if (!context) {
+    return 9;
+  }
+  context.font = `${fontWeight} ${fontSize}px ${fontFamily}`;
+  return context.measureText('a').width;
+};
+const launchWorker = async (name, url, commandMap) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await create$2({
+    commandMap: {},
+    name,
+    port: port1,
+    url
+  });
+  return create$3({
+    commandMap,
+    messagePort: port2
+  });
+};
+const getBounds = () => {
+  return {
+    height: window.innerHeight,
+    width: window.innerWidth,
+    x: 0,
+    y: 0
+  };
+};
+const getEditorMethod = command => {
+  return command.includes('.') ? command : `Editor.${command}`;
+};
+const render = async editorRpc => {
+  const diffResult = await editorRpc.invoke('Editor.diff2', editorUid);
+  const commands = await editorRpc.invoke('Editor.render2', editorUid, diffResult);
+  executeCommands(commands);
+};
+const focus = () => {
+  const input = document.querySelector('.EditorInput textarea');
+  input?.focus();
+};
+const markRendered = async () => {
+  await new Promise(resolve => {
+    requestAnimationFrame(() => {
+      requestAnimationFrame(() => resolve());
+    });
+  });
+  performance.mark('syntax-highlight-rendered');
+  document.documentElement.dataset.renderBenchmarkReady = 'true';
+};
+const setError = error => {
+  document.documentElement.dataset.benchmarkReady = 'error';
+  document.body.textContent = error instanceof Error ? error.stack || error.message : String(error);
+};
+const main = async () => {
+  document.documentElement.dataset.benchmarkStage = 'starting';
+  try {
+    document.documentElement.dataset.benchmarkStage = 'launching-syntax-worker';
+    const syntaxHighlightingRpc = await launchWorker('Syntax Highlighting Worker', syntaxHighlightingWorkerUrl, {});
+    Object.assign(commandMapRef, {
+      'Main.handleModifiedStatusChange': () => undefined,
+      'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker': async (port, initialCommand) => {
+        document.documentElement.dataset.benchmarkStage = 'connecting-syntax-worker';
+        await syntaxHighlightingRpc.invokeAndTransfer(initialCommand, port);
+        document.documentElement.dataset.benchmarkStage = 'syntax-worker-connected';
+      }
+    });
+    document.documentElement.dataset.benchmarkStage = 'launching-editor-worker';
+    const editorRpc = await launchWorker('Editor Worker', editorWorkerUrl, commandMapRef);
+    document.documentElement.dataset.benchmarkStage = 'initializing-editor-worker';
+    await editorRpc.invoke('Initialize.initialize', true, true);
+    document.documentElement.dataset.benchmarkStage = 'creating-editor';
+    const config = getEditorOnlyConfig();
+    const fontFamily = config.fontFamily || 'monospace';
+    const fontSize = config.fontSize || 15;
+    const fontWeight = config.fontWeight || 400;
+    const bounds = getBounds();
+    await editorRpc.invoke('Editor.createStandalone', {
+      assetDir: '',
+      charWidth: getCharWidth(fontFamily, fontSize, fontWeight),
+      content: config.content || '',
+      fontFamily,
+      fontSize,
+      fontWeight,
+      ...bounds,
+      id: editorUid,
+      languageId: config.languageId || 'plaintext',
+      letterSpacing: config.letterSpacing || 0,
+      lineNumbers: config.lineNumbers || false,
+      platform: Web,
+      rowHeight: config.rowHeight || 20,
+      tabSize: config.tabSize || 2,
+      tokenizePath: config.tokenizePath || '',
+      uri: config.uri || 'file:///standalone.txt'
+    });
+    document.documentElement.dataset.benchmarkStage = 'rendering-editor';
+    create(editorUid);
+    const listeners = await editorRpc.invoke('Editor.renderEventListeners');
+    registerEventListeners(editorUid, listeners);
+    let text = config.content || '';
+    let pending = Promise.resolve();
+    const executeQueued = async (previous, command, args) => {
+      try {
+        await previous;
+        await editorRpc.invoke(getEditorMethod(command), editorUid, ...args);
+        await render(editorRpc);
+        text = await editorRpc.invoke('Editor.getText', editorUid);
+      } catch (error) {
+        setError(error);
+      }
+    };
+    const execute = (command, ...args) => {
+      pending = executeQueued(pending, command, args);
+    };
+    setIpc({
+      send(method, uid, command, ...args) {
+        if (method !== 'Viewlet.executeViewletCommand' || uid !== editorUid) {
+          throw new Error(`Unsupported editor-only event: ${method}`);
+        }
+        execute(command, ...args);
+      }
+    });
+    document.addEventListener('keydown', event => {
+      const command = getEditorCommand(event);
+      if (!command) {
+        return;
+      }
+      event.preventDefault();
+      execute(command);
+    }, {
+      capture: true
+    });
+    window.addEventListener('resize', () => {
+      execute('resize', getBounds());
+    });
+    await render(editorRpc);
+    Object.defineProperty(window, '__typingBenchmark', {
+      configurable: true,
+      value: {
+        focus,
+        getText: () => text
+      }
+    });
+    focus();
+    await markRendered();
+    document.documentElement.dataset.benchmarkReady = 'true';
+    document.documentElement.dataset.benchmarkStage = 'ready';
+  } catch (error) {
+    setError(error);
+  }
+};
+
+main();