@lvce-editor/static-server 0.113.14 → 0.113.17

package/static/bbafe88/packages/renderer-process/dist/editorOnlyRendererProcessMain.js

@@ -1,2985 +0,0 @@
-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$3 = Object.create(null);
-const retainString = (item, index) => {
-  const value = new Promise(resolve => {
-    item.getAsString(resolve);
-  });
-  return {
-    index,
-    kind: 'string',
-    type: item.type,
-    value
-  };
-};
-const retainFileSystemHandle = async item => {
-  // getAsFileSystemHandle must be invoked while the drag data store is readable.
-  const {
-    getAsFileSystemHandle
-  } = item;
-  if (typeof getAsFileSystemHandle !== 'function') {
-    return undefined;
-  }
-  try {
-    return await getAsFileSystemHandle.call(item);
-  } catch {
-    return undefined;
-  }
-};
-const retainFile = (item, index) => {
-  return {
-    file: item.getAsFile(),
-    fileSystemHandle: retainFileSystemHandle(item),
-    index,
-    kind: 'file',
-    type: item.type
-  };
-};
-const retainItems = dataTransfer => {
-  if (!dataTransfer) {
-    return [];
-  }
-  const items = [];
-  for (const [index, item] of [...dataTransfer.items].entries()) {
-    if (item.kind === 'string') {
-      items.push(retainString(item, index));
-    } else if (item.kind === 'file') {
-      items.push(retainFile(item, index));
-    }
-  }
-  return items;
-};
-const addItems = items => {
-  const id = create$1();
-  state$3[id] = items;
-  return id;
-};
-const add$2 = dataTransfer => {
-  return addItems(retainItems(dataTransfer));
-};
-
-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) {
-    const nativeFile = item.getAsFile();
-    // @ts-ignore
-    const fileHandle = await item.getAsFileSystemHandle();
-    return {
-      file: nativeFile,
-      kind: 'file',
-      type: item.type,
-      value: fileHandle
-    };
-  }
-  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 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 handleClipboardDataFiles2 = event => {
-  if (!event.clipboardData) {
-    return [];
-  }
-  const fileItems = [...event.clipboardData.items].filter(item => item.kind === 'file');
-  const promises = fileItems.map(unwrapItem);
-  return promises.map(promise => add$1(promise));
-};
-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) => {
-  if (param === 'event.clipboardData.files') {
-    return handleClipboardDataFiles(event);
-  }
-  if (param === 'event.clipboardData.files2') {
-    return handleClipboardDataFiles2(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.ctrlKey':
-      return event.ctrlKey;
-    case 'event.data':
-      return event.data;
-    case 'event.dataTransfer.files':
-      return event.dataTransfer.files;
-    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.dropId':
-      if (event.type !== 'drop') {
-        throw new Error('event.dropId is only available for drop events');
-      }
-      return add$2(event.dataTransfer || null);
-    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$2 = 'circle';
-const Form$1 = 'form';
-const Defs$2 = 'defs';
-const Ellipse$2 = 'ellipse';
-const G$2 = 'g';
-const Line$2 = 'line';
-const Path$2 = 'path';
-const Polygon$2 = 'polygon';
-const Polyline$2 = 'polyline';
-const Quote$1 = 'quote';
-const BlockQuote$1 = 'blockquote';
-const Rect$2 = 'rect';
-const Svg$2 = 'svg';
-const Use$2 = '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$1 = 81;
-const Defs$1 = 82;
-const Ellipse$1 = 83;
-const G$1 = 84;
-const Line$1 = 85;
-const Path$1 = 86;
-const Polygon$1 = 87;
-const Polyline$1 = 88;
-const Rect$1 = 89;
-const Svg$1 = 90;
-const Use$1 = 91;
-const Reference$1 = 100;
-
-const VirtualDomElements = {
-  __proto__: null,
-  A,
-  Article,
-  Aside,
-  Audio,
-  BlockQuote,
-  Br,
-  Button,
-  Canvas,
-  Circle: Circle$1,
-  Cite,
-  Code,
-  Col,
-  ColGroup,
-  Data,
-  Dd,
-  Defs: Defs$1,
-  Del,
-  Div,
-  Dl,
-  Dt,
-  Ellipse: Ellipse$1,
-  Em,
-  Figcaption,
-  Figure,
-  Footer,
-  Form,
-  G: G$1,
-  H1,
-  H2,
-  H3,
-  H4,
-  H5,
-  H6,
-  Head,
-  Header,
-  Hr,
-  Html,
-  I,
-  Iframe,
-  Img,
-  Input,
-  Ins,
-  Kbd,
-  Label,
-  Li,
-  Line: Line$1,
-  Main,
-  Meta,
-  Nav,
-  Ol,
-  Option,
-  P,
-  Path: Path$1,
-  Polygon: Polygon$1,
-  Polyline: Polyline$1,
-  Pre,
-  Quote,
-  Rect: Rect$1,
-  Reference: Reference$1,
-  Search,
-  Section,
-  Select,
-  Span,
-  Strong,
-  Style,
-  Svg: Svg$1,
-  TBody,
-  THead,
-  Table,
-  Td,
-  Text: Text$1,
-  TextArea,
-  Tfoot,
-  Th,
-  Time,
-  Title,
-  Tr,
-  Ul,
-  Use: Use$1,
-  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$1]: Circle$2,
-  [Cite]: Cite$1,
-  [Code]: Code$1,
-  [Col]: Col$1,
-  [ColGroup]: ColGroup$1,
-  [Data]: Data$1,
-  [Dd]: Dd$1,
-  [Defs$1]: Defs$2,
-  [Del]: Del$1,
-  [Div]: Div$1,
-  [Dl]: Dl$1,
-  [Dt]: Dt$1,
-  [Ellipse$1]: Ellipse$2,
-  [Em]: Em$1,
-  [Figcaption]: Figcaption$1,
-  [Figure]: Figure$1,
-  [Footer]: Footer$1,
-  [Form]: Form$1,
-  [G$1]: G$2,
-  [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$1]: Line$2,
-  [Main]: Main$1,
-  [Meta]: Meta$1,
-  [Nav]: Nav$1,
-  [Ol]: Ol$1,
-  [Option]: Option$1,
-  [P]: P$1,
-  [Path$1]: Path$2,
-  [Polygon$1]: Polygon$2,
-  [Polyline$1]: Polyline$2,
-  [Pre]: Pre$1,
-  [Quote]: Quote$1,
-  [Rect$1]: Rect$2,
-  [Search]: Search$1,
-  [Section]: Section$1,
-  [Select]: Select$1,
-  [Span]: Span$1,
-  [Strong]: Strong$1,
-  [Style]: Style$1,
-  [Svg$1]: Svg$2,
-  [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$1]: Use$2,
-  [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', 'onLoad', '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 ($Element instanceof SVGElement) {
-    const attributeName = removedAttributeProps.get(key) || key;
-    $Element.removeAttribute(attributeName);
-    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 setSvgProp = ($Element, key, value) => {
-  if (key === 'style') {
-    setStyle($Element, value);
-    return;
-  }
-  const attributeName = removedAttributeProps.get(key) || key;
-  $Element.setAttribute(attributeName, String(value));
-};
-const setHtmlProp = ($Element, key, value) => {
-  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 (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 setProp = ($Element, key, value, eventMap, newEventMap) => {
-  if (eventProps.has(key)) {
-    setEventProp($Element, key, value, eventMap, newEventMap);
-    return;
-  }
-  if ($Element instanceof SVGElement) {
-    setSvgProp($Element, key, value);
-    return;
-  }
-  setHtmlProp($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 {
-  Circle,
-  Defs,
-  Ellipse,
-  G,
-  Line,
-  Path,
-  Polygon,
-  Polyline,
-  Rect,
-  Svg,
-  Text,
-  Use,
-  Reference} = VirtualDomElements;
-
-const svgNamespace = 'http://www.w3.org/2000/svg';
-const svgElementTypes = new Set([Circle, Defs, Ellipse, G, Line, Path, Polygon, Polyline, Rect, Svg, Use]);
-const renderDomTextNode = element => {
-  return document.createTextNode(element.text);
-};
-const renderDomElement = (element, eventMap, newEventMap) => {
-  const tag = getElementTag(element.type);
-  const $Element = svgElementTypes.has(element.type) ? document.createElementNS(svgNamespace, tag) : 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 MultiNavigation = 18;
-
-const handleNavigateChild = (state, index, nextPatchType) => {
-  const $Children = state.current.childNodes;
-  const $Child = $Children[index];
-  if ($Child) {
-    state.current = $Child;
-    return true;
-  }
-  if ((nextPatchType === Replace || nextPatchType === SetReferenceNodeUid) && 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,
-    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, index, $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[index];
-  if (!$Sibling && !state.hasAppliedMutation && state.current !== $Element) {
-    $Sibling = $Element.childNodes[index];
-  }
-  if (!$Sibling) {
-    console.error('Cannot navigate to sibling: sibling not found at index', {
-      $Parent,
-      index,
-      childCount: $Parent.childNodes.length
-    });
-    return false;
-  }
-  state.current = $Sibling;
-  return true;
-};
-const handleSingleNavigation = (state, type, index, nextPatchType, $Element, patchIndex) => {
-  switch (type) {
-    case NavigateChild:
-      return handleNavigateChild(state, index, nextPatchType);
-    case NavigateParent:
-      return handleNavigateParent(state);
-    case NavigateSibling:
-      return handleNavigateSibling(state, index, $Element, patchIndex);
-    default:
-      console.error('Unknown navigation type', {
-        type
-      });
-      return false;
-  }
-};
-const handleMultiNavigation = (state, navigations, nextPatchType, $Element, patchIndex) => {
-  for (let i = 0; i < navigations.length; i += 2) {
-    const type = navigations[i];
-    const index = navigations[i + 1];
-    const nextType = navigations[i + 2] ?? nextPatchType;
-    if (!handleSingleNavigation(state, type, index, nextType, $Element, patchIndex)) {
-      return false;
-    }
-  }
-  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 MultiNavigation:
-      return handleMultiNavigation(state, patch.navigations, patches[patchIndex + 1]?.type, $Element, patchIndex);
-    case NavigateChild:
-      return handleNavigateChild(state, patch.index, patches[patchIndex + 1]?.type);
-    case NavigateParent:
-      return handleNavigateParent(state);
-    case NavigateSibling:
-      return handleNavigateSibling(state, patch.index, $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) {
-    if (!$Input.readOnly) {
-      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 updateAttributes = ($Previous, $New) => {
-  const newAttributeNames = new Set($New.getAttributeNames());
-  for (const attributeName of $Previous.getAttributeNames()) {
-    if (!newAttributeNames.has(attributeName)) {
-      $Previous.removeAttribute(attributeName);
-    }
-  }
-  for (const attributeName of newAttributeNames) {
-    $Previous.setAttribute(attributeName, $New.getAttribute(attributeName));
-  }
-};
-const restoreFocusedElement = ($Hidden, $New, focused) => {
-  const $NewFocused = $New.querySelector(`[name="${CSS.escape(focused)}"]`);
-  if (!$NewFocused) {
-    return;
-  }
-  if ($NewFocused.readOnly) {
-    return;
-  }
-  const $Previous = $Hidden.firstChild;
-  if (!$Previous) {
-    return;
-  }
-  updateAttributes($Previous, $NewFocused);
-  if ($NewFocused.childNodes) {
-    $Previous.replaceChildren(...$NewFocused.childNodes);
-  }
-  $NewFocused.replaceWith($Previous);
-};
-const renderWithUid = ($Viewlet, dom, eventMap, uid, inputMap, focused, activeElement) => {
-  const newEventMap = getEventListenerMap(uid);
-  const $New = render$1(dom, eventMap, newEventMap).firstChild;
-  const $Hidden = createHiddenContainer($New.contains(activeElement || null) ? undefined : activeElement, focused);
-  setComponentUid($New, uid);
-  const $$NewInputs = queryInputs($New);
-  for (const $Input of $$NewInputs) {
-    if (!$Input.readOnly) {
-      $Input.value = inputMap[$Input.name] || $Input.value || '';
-    }
-  }
-  $Viewlet.replaceWith($New);
-  if (focused) {
-    restoreFocusedElement($Hidden, $New, focused);
-  }
-  $Hidden.remove();
-  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();
-  try {
-    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;
-    if (uid) {
-      const numericUid = Number(uid);
-      const inputMap = getInputMap($Viewlet);
-      $Viewlet = renderWithUid($Viewlet, dom, eventMap, numericUid, inputMap, focused, activeElement);
-    }
-    if (!uid) {
-      const $Hidden = createHiddenContainer(activeElement, focused);
-      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;
-    return $Viewlet;
-  } finally {
-    stopIgnore();
-  }
-};
-
-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 focusSelectorAfterRender = (uid, selector) => {
-  requestAnimationFrame(() => {
-    requestAnimationFrame(() => {
-      focusSelector(uid, selector);
-    });
-  });
-};
-const scrollSelectorBy = (uid, selector, delta) => {
-  const element = getElement(uid).querySelector(selector);
-  if (element) {
-    element.scrollLeft += delta;
-  }
-};
-const scrollSelectorIntoView = (uid, selector) => {
-  getElement(uid).querySelector(selector)?.scrollIntoView({
-    block: 'nearest',
-    inline: 'nearest'
-  });
-};
-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.focusSelectorAfterRender': focusSelectorAfterRender,
-  'Viewlet.scrollSelectorBy': scrollSelectorBy,
-  'Viewlet.scrollSelectorIntoView': scrollSelectorIntoView,
-  '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();