@lvce-editor/static-server 0.85.3 → 0.86.0

package/static/bbc1fd1/packages/preview-worker/dist/previewWorkerMain.js

@@ -1,4369 +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;
-    }
-  }
-}
-
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const Object$1 = 1;
-const Number$1 = 2;
-const Array$1 = 3;
-const String = 4;
-const Boolean$1 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown = 8;
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return Number$1;
-    case 'function':
-      return Function;
-    case 'string':
-      return String;
-    case 'object':
-      if (value === null) {
-        return Null;
-      }
-      if (Array.isArray(value)) {
-        return Array$1;
-      }
-      return Object$1;
-    case 'boolean':
-      return Boolean$1;
-    default:
-      return Unknown;
-  }
-};
-const array = value => {
-  const type = getType(value);
-  if (type !== Array$1) {
-    throw new AssertionError('expected value to be of type array');
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== String) {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-
-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);
-    }
-    return;
-  }
-};
-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;
-      cause.stack = stack;
-      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 listen$7 = () => {
-  // @ts-ignore
-  if (typeof WorkerGlobalScope === 'undefined') {
-    throw new TypeError('module is not in web worker scope');
-  }
-  return globalThis;
-};
-const signal$8 = global => {
-  global.postMessage(readyMessage);
-};
-class IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-  }
-}
-const wrap$f = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const waitForFirstMessage = async port => {
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
-};
-const listen$6 = async () => {
-  const parentIpcRaw = listen$7();
-  signal$8(parentIpcRaw);
-  const parentIpc = wrap$f(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError('unexpected first message');
-  }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      id: firstMessage.id,
-      jsonrpc: '2.0',
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
-  }
-  return globalThis;
-};
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    if (this._rawIpc.close) {
-      this._rawIpc.close();
-    }
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$e = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
-};
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$6,
-  wrap: wrap$e
-};
-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
-};
-
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register$1 = 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$1 = Object.create(null);
-const get$2 = id => {
-  return callbacks$1[id];
-};
-const remove$1 = id => {
-  delete callbacks$1[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') {
-      error.name = 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 = undefined) => {
-  return string.indexOf(NewLine, startIndex);
-};
-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 restoreJsonRpcError = error => {
-  const currentStack = getCurrentStack();
-  if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
-  }
-  if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
-  }
-  if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      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;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
-  }
-  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$1 = (id, response) => {
-  const fn = get$2(id);
-  if (!fn) {
-    console.log(response);
-    warn(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(response);
-  remove$1(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$a = (message, result) => {
-  return {
-    id: message.id,
-    jsonrpc: Two$1,
-    result: result ?? null
-  };
-};
-const getSuccessResponse = (message, result) => {
-  const resultProperty = result ?? null;
-  return create$a(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$1;
-
-// 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$9 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
-
-const create$8 = (id, method, params) => {
-  const message = {
-    id,
-    jsonrpc: Two,
-    method,
-    params
-  };
-  return message;
-};
-
-let id = 0;
-const create$7 = () => {
-  return ++id;
-};
-
-const registerPromise = map => {
-  const id = create$7();
-  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$8(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$9(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 listen$1 = async (module, options) => {
-  const rawIpc = await module.listen(options);
-  if (module.signal) {
-    module.signal(rawIpc);
-  }
-  const ipc = module.wrap(rawIpc);
-  return ipc;
-};
-
-const create$6 = async ({
-  commandMap,
-  isMessagePortOpen = true,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register$1(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 create$5 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$6({
-    commandMap,
-    isMessagePortOpen,
-    messagePort: port2
-  });
-};
-
-const createSharedLazyRpc = factory => {
-  let rpcPromise;
-  const getOrCreate = () => {
-    if (!rpcPromise) {
-      rpcPromise = factory();
-    }
-    return rpcPromise;
-  };
-  return {
-    async dispose() {
-      const rpc = await getOrCreate();
-      await rpc.dispose();
-    },
-    async invoke(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invoke(method, ...params);
-    },
-    async invokeAndTransfer(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    async send(method, ...params) {
-      const rpc = await getOrCreate();
-      rpc.send(method, ...params);
-    }
-  };
-};
-
-const create$4 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  return createSharedLazyRpc(() => {
-    return create$5({
-      commandMap,
-      isMessagePortOpen,
-      send
-    });
-  });
-};
-
-const create$3 = async ({
-  commandMap
-}) => {
-  // TODO create a commandMap per rpc instance
-  register$1(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  return rpc;
-};
-
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invocations,
-    invoke,
-    invokeAndTransfer: invoke
-  };
-  return mockRpc;
-};
-
-const rpcs = Object.create(null);
-const set$3 = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get$1 = id => {
-  return rpcs[id];
-};
-const remove = id => {
-  delete rpcs[id];
-};
-
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$2 = rpcId => {
-  return {
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
-    },
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get$1(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    registerMockRpc(commandMap) {
-      const mockRpc = createMockRpc({
-        commandMap
-      });
-      set$3(rpcId, mockRpc);
-      // @ts-ignore
-      mockRpc[Symbol.dispose] = () => {
-        remove(rpcId);
-      };
-      // @ts-ignore
-      return mockRpc;
-    },
-    set(rpc) {
-      set$3(rpcId, rpc);
-    }
-  };
-};
-
-const Button$1 = 1;
-const Div$1 = 4;
-const H1$1 = 5;
-const Input$1 = 6;
-const Span$1 = 8;
-const Table$1 = 9;
-const TBody$1 = 10;
-const Td$1 = 11;
-const Text$1 = 12;
-const Th$1 = 13;
-const THead$1 = 14;
-const Tr$1 = 15;
-const Img$1 = 17;
-const Del$1 = 21;
-const H2$1 = 22;
-const H3$1 = 23;
-const H4$1 = 24;
-const H5$1 = 25;
-const H6$1 = 26;
-const Article$1 = 27;
-const Aside$1 = 28;
-const Footer$1 = 29;
-const Header$1 = 30;
-const Nav$1 = 40;
-const Section$1 = 41;
-const Search$1 = 42;
-const Dd$1 = 43;
-const Dl$1 = 44;
-const Figcaption$1 = 45;
-const Figure$1 = 46;
-const Hr$1 = 47;
-const Li$1 = 48;
-const Ol$1 = 49;
-const P$1 = 50;
-const Pre$1 = 51;
-const A$1 = 53;
-const Abbr$1 = 54;
-const Br$1 = 55;
-const Cite$1 = 56;
-const Data$1 = 57;
-const Time$1 = 58;
-const Tfoot$1 = 59;
-const Ul$1 = 60;
-const TextArea$1 = 62;
-const Select$1 = 63;
-const Option$1 = 64;
-const Code$1 = 65;
-const Label$1 = 66;
-const Dt$1 = 67;
-const Iframe$1 = 68;
-const Style = 72;
-const Html$1 = 73;
-const Canvas$1 = 77;
-const Reference = 100;
-
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const Key = 'event.key';
-const TargetValue = 'event.target.value';
-
-const EditorWorker = 99;
-const RendererWorker = 1;
-
-const SetDom2 = 'Viewlet.setDom2';
-const SetPatches = 'Viewlet.setPatches';
-
-const {
-  invoke: invoke$1,
-  set: set$2
-} = create$2(EditorWorker);
-
-const {
-  invoke,
-  invokeAndTransfer,
-  set: set$1
-} = create$2(RendererWorker);
-const sendMessagePortToEditorWorker = async (port, rpcId) => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
-};
-const readFile = async uri => {
-  return invoke('FileSystem.readFile', uri);
-};
-
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$1 = () => {
-  const states = Object.create(null);
-  const commandMapRef = {};
-  return {
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    diff(uid, modules, numbers) {
-      const {
-        newState,
-        oldState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    dispose(uid) {
-      delete states[uid];
-    },
-    get(uid) {
-      return states[uid];
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseFloat(key);
-      });
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        newState,
-        oldState
-      };
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (oldState === newerState || newState === newerState) {
-          return;
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...newerState
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    wrapLoadContent(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const result = await fn(newState, ...args);
-        const {
-          error,
-          state
-        } = result;
-        if (oldState === state || newState === state) {
-          return {
-            error
-          };
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...state
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState
-        };
-        return {
-          error
-        };
-      };
-      return wrapped;
-    }
-  };
-};
-const terminate = () => {
-  globalThis.close();
-};
-
-const createSandboxRpc = async () => {
-  const sandboxRpc = await create$4({
-    commandMap: {},
-    send: async port => await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToPreviewSandBoxWorker', port, 'SandBox.handleMessagePort')
-  });
-  return sandboxRpc;
-};
-
-const {
-  get,
-  getCommandIds,
-  getKeys: getKeys$1,
-  registerCommands,
-  set,
-  wrapCommand,
-  wrapGetter
-} = create$1();
-
-const create = async (uid, uri, x, y, width, height, platform, assetDir, options = {}) => {
-  const {
-    loadExternalStyleSheets = true,
-    loadJavaScript = true,
-    loadStyleElements = true
-  } = options;
-  const sandboxRpc = await createSandboxRpc();
-  const state = {
-    assetDir,
-    content: '',
-    css: [],
-    errorCount: 0,
-    errorMessage: '',
-    height,
-    initial: true,
-    listenerId: '',
-    loadExternalStyleSheets,
-    loadJavaScript,
-    loadStyleElements,
-    parsedDom: [],
-    parsedNodesChildNodeCount: 0,
-    platform,
-    sandboxRpc,
-    scripts: [],
-    styleSheets: [],
-    uid,
-    uri,
-    warningCount: 0,
-    width,
-    x,
-    y
-  };
-  set(uid, state, state);
-};
-
-const iEqual = (oldState, newState) => {
-  if (oldState.css.length !== newState.css.length) {
-    return false;
-  }
-  for (let i = 0; i < oldState.css.length; i++) {
-    if (oldState.css[i] !== newState.css[i]) {
-      return false;
-    }
-  }
-  return true;
-};
-
-const isEqual = (oldState, newState) => {
-  return oldState.warningCount === newState.warningCount && oldState.initial === newState.initial && oldState.content === newState.content && oldState.parsedDom === newState.parsedDom && oldState.parsedNodesChildNodeCount === newState.parsedNodesChildNodeCount && oldState.css === newState.css && oldState.scripts === newState.scripts;
-};
-
-const RenderItems = 4;
-const RenderCss = 10;
-const RenderIncremental = 11;
-
-const modules = [isEqual, iEqual];
-const numbers = [RenderIncremental, RenderCss];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
-    }
-  }
-  return diffResult;
-};
-
-const diff2 = uid => {
-  const {
-    newState,
-    oldState
-  } = get(uid);
-  const result = diff(oldState, newState);
-  return result;
-};
-
-const callbackRpcs = Object.create(null);
-const executeCallback = async (id, ...args) => {
-  const rpc = callbackRpcs[id];
-  await rpc.invokeAndTransfer('SandBox.executeCallback', id, ...args);
-};
-const getOffscreenCanvas = async (state, id, width, height) => {
-  // TODO possible race condition / conflict if multiple
-  // previews create offscreen canvases at the same time
-  callbackRpcs[id] = state.sandboxRpc;
-  await invoke('OffscreenCanvas.createForPreview', id, width, height);
-};
-
-const callAndUpdate = async (state, method, ...args) => {
-  const {
-    sandboxRpc,
-    uid
-  } = state;
-  await sandboxRpc.invoke(method, uid, ...args);
-  return state;
-};
-
-const callbacks = Object.create(null);
-const register = (type, id, callback) => {
-  callbacks[type] ||= Object.create(null);
-  callbacks[type][id] = callback;
-};
-const has = (type, id) => {
-  return type in callbacks && id in callbacks[type];
-};
-const resolve = (type, id) => {
-  const callback = callbacks[type]?.[id];
-  if (callback) {
-    callback();
-    delete callbacks[id];
-  }
-};
-
-const handleClick = async (state, hdId, clientX, clientY) => {
-  const {
-    uid
-  } = state;
-  // TODO race condition: click promise should only be resolved once preview has rerendered
-  if (has('click', uid)) {
-    resolve('click', uid);
-  }
-  if (!hdId) {
-    return state;
-  }
-  const {
-    x,
-    y
-  } = state;
-  const adjustedClientX = clientX - x;
-  const adjustedClientY = clientY - y;
-  return callAndUpdate(state, 'SandBox.handleClick', hdId, adjustedClientX, adjustedClientY);
-};
-
-const getParsedNodesChildNodeCount = parsedDom => {
-  array(parsedDom);
-  const rootCountFromParse = parsedDom.rootChildCount;
-  if (typeof rootCountFromParse === 'number') {
-    return rootCountFromParse;
-  }
-  let rootChildCount = 0;
-  let i = 0;
-  while (i < parsedDom.length) {
-    rootChildCount++;
-
-    // skip the entire subtree of the current node
-    let toSkip = parsedDom[i].childCount;
-    i++;
-    while (toSkip > 0 && i < parsedDom.length) {
-      toSkip -= 1;
-      toSkip += parsedDom[i].childCount;
-      i++;
-    }
-  }
-  return rootChildCount;
-};
-
-const hasScheme = uri => {
-  return /^[a-z][a-z\d+.-]*:/i.test(uri);
-};
-
-const isAbsoluteFileSystemPath = href => {
-  return href.startsWith('/') || /^[a-zA-Z]:[\\/\\]/.test(href) || /^\\\\/.test(href);
-};
-
-const isBlockedStylesheetHref = href => {
-  if (/^\/\//.test(href)) {
-    return true;
-  }
-  if (isAbsoluteFileSystemPath(href)) {
-    return true;
-  }
-  if (/^(?:data|javascript|blob):/i.test(href)) {
-    return true;
-  }
-  if (/^(?:http|https|file):/i.test(href)) {
-    return true;
-  }
-  return false;
-};
-
-const toBaseUrl = uri => {
-  if (hasScheme(uri)) {
-    return uri;
-  }
-  return `file://${uri}`;
-};
-
-const resolveStylesheetUri = (documentUri, href) => {
-  if (!href || href.startsWith('#') || isBlockedStylesheetHref(href)) {
-    return '';
-  }
-  try {
-    const baseUrl = toBaseUrl(documentUri);
-    const resolved = new URL(href, baseUrl);
-    if (/^(?:http|https):$/i.test(resolved.protocol)) {
-      return '';
-    }
-    if (resolved.protocol === 'file:' && !hasScheme(documentUri)) {
-      return decodeURIComponent(resolved.pathname);
-    }
-    return resolved.href;
-  } catch {
-    return '';
-  }
-};
-
-const normalizeUri = uri => {
-  if (!uri) {
-    return uri;
-  }
-  if (uri.startsWith('file://')) {
-    try {
-      return decodeURIComponent(new URL(uri).pathname);
-    } catch {
-      return uri;
-    }
-  }
-  try {
-    return decodeURIComponent(uri);
-  } catch {
-    return uri;
-  }
-};
-const isSameUri = (left, right) => {
-  if (left === right) {
-    return true;
-  }
-  return normalizeUri(left) === normalizeUri(right);
-};
-const hasMatchingLinkedStyleSheet = (documentUri, styleSheets, changedEditorUri) => {
-  for (const styleSheet of styleSheets) {
-    if (styleSheet.type !== 'link' || !styleSheet.href) {
-      continue;
-    }
-    const styleSheetUri = resolveStylesheetUri(documentUri, styleSheet.href);
-    if (styleSheetUri && isSameUri(styleSheetUri, changedEditorUri)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-const getUriPath = uri => {
-  const withoutHash = uri.split('#')[0];
-  const withoutQuery = withoutHash.split('?')[0];
-  if (withoutQuery.startsWith('file://')) {
-    try {
-      return decodeURIComponent(new URL(withoutQuery).pathname);
-    } catch {
-      return withoutQuery;
-    }
-  }
-  return withoutQuery;
-};
-const isTsxUri = uri => {
-  const path = getUriPath(uri).toLowerCase();
-  return path.endsWith('.tsx') || path.endsWith('.jsx');
-};
-
-const isBlockedScriptSrc = src => {
-  if (/^\/\//.test(src)) {
-    return true;
-  }
-  if (isAbsoluteFileSystemPath(src)) {
-    return true;
-  }
-  if (/^(?:data|javascript|blob):/i.test(src)) {
-    return true;
-  }
-  if (/^(?:file):/i.test(src)) {
-    return true;
-  }
-  return false;
-};
-
-const resolveScriptUri = (documentUri, src) => {
-  if (!src || src.startsWith('#') || isBlockedScriptSrc(src)) {
-    return '';
-  }
-  try {
-    const baseUrl = toBaseUrl(documentUri);
-    const resolved = new URL(src, baseUrl);
-    if (resolved.protocol === 'file:' && !hasScheme(documentUri)) {
-      return decodeURIComponent(resolved.pathname);
-    }
-    return resolved.href;
-  } catch {
-    return '';
-  }
-};
-
-const loadRemoteScript = async uri => {
-  const response = await fetch(uri);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${uri}`);
-  }
-  return response.text();
-};
-const loadLinkedScript = async (documentUri, src) => {
-  const scriptUri = resolveScriptUri(documentUri, src);
-  if (!scriptUri) {
-    return '';
-  }
-  try {
-    if (/^https?:\/\//i.test(scriptUri)) {
-      return loadRemoteScript(scriptUri);
-    }
-    return await readFile(scriptUri);
-  } catch (error) {
-    console.error(error);
-    return '';
-  }
-};
-
-const loadScriptTags = async (documentUri, scriptTags) => {
-  const scripts = [];
-  for (const scriptTag of scriptTags) {
-    if (scriptTag.type === 'inline') {
-      if (scriptTag.content.trim()) {
-        scripts.push(scriptTag.content);
-      }
-      continue;
-    }
-    const loadedScript = await loadLinkedScript(documentUri, scriptTag.src);
-    if (loadedScript.trim()) {
-      scripts.push(loadedScript);
-    }
-  }
-  return scripts;
-};
-
-const loadLinkedStyleSheet = async (documentUri, href) => {
-  const stylesheetUri = resolveStylesheetUri(documentUri, href);
-  if (!stylesheetUri) {
-    return '';
-  }
-  try {
-    return await readFile(stylesheetUri);
-  } catch (error) {
-    console.error(error);
-    return '';
-  }
-};
-
-const loadStyleSheets = async (documentUri, styleSheets, loadExternalStyleSheets, loadStyleElements) => {
-  const css = [];
-  for (const styleSheet of styleSheets) {
-    if (styleSheet.type === 'style') {
-      if (loadStyleElements && styleSheet.content) {
-        css.push(styleSheet.content);
-      }
-      continue;
-    }
-    if (!loadExternalStyleSheets || !styleSheet.href) {
-      continue;
-    }
-    const linkedStyleSheet = await loadLinkedStyleSheet(documentUri, styleSheet.href);
-    if (linkedStyleSheet) {
-      css.push(linkedStyleSheet);
-    }
-  }
-  return css;
-};
-
-const loadStyleSheetsWithEditorOverride = async (documentUri, styleSheets, currentCss, loadExternalStyleSheets, loadStyleElements, changedEditorUri, changedEditorContent) => {
-  const css = [];
-  let cssIndex = 0;
-  for (const styleSheet of styleSheets) {
-    if (styleSheet.type === 'style') {
-      if (loadStyleElements && styleSheet.content) {
-        if (cssIndex < currentCss.length) {
-          css.push(currentCss[cssIndex]);
-        } else {
-          css.push(styleSheet.content);
-        }
-        cssIndex++;
-      }
-      continue;
-    }
-    if (!loadExternalStyleSheets || !styleSheet.href) {
-      continue;
-    }
-    const styleSheetUri = resolveStylesheetUri(documentUri, styleSheet.href);
-    if (!styleSheetUri) {
-      continue;
-    }
-    if (isSameUri(styleSheetUri, changedEditorUri)) {
-      if (changedEditorContent) {
-        css.push(changedEditorContent);
-      }
-      if (cssIndex < currentCss.length) {
-        cssIndex++;
-      }
-      continue;
-    }
-    if (cssIndex < currentCss.length) {
-      css.push(currentCss[cssIndex]);
-      cssIndex++;
-    }
-  }
-  return css;
-};
-
-const loadScripts = async (state, content, css, scripts) => {
-  const {
-    height,
-    sandboxRpc,
-    uid,
-    width
-  } = state;
-  await sandboxRpc.invoke('SandBox.loadContent', uid, width, height, content, scripts);
-  const serialized = await sandboxRpc.invoke('SandBox.getSerializedDom', uid);
-  const finalParsedDom = serialized.dom;
-  const finalParsedNodesChildNodeCount = getParsedNodesChildNodeCount(finalParsedDom);
-  return {
-    ...state,
-    content,
-    css,
-    errorMessage: '',
-    parsedDom: finalParsedDom,
-    parsedNodesChildNodeCount: finalParsedNodesChildNodeCount,
-    scripts
-  };
-};
-
-const createTsxBootstrapScript = transpiledSource => {
-  return `;(async () => {
-const globalObject = globalThis
-if (typeof globalObject.window === 'undefined') {
-  Reflect.set(globalObject, 'window', globalObject)
-}
-if (typeof globalObject.self === 'undefined') {
-  Reflect.set(globalObject, 'self', globalObject)
-}
-const reactModule = await import('https://esm.sh/react@19/?dev')
-const reactDomClientModule = await import('https://esm.sh/react-dom@19/client?dev')
-const React = reactModule.default ?? reactModule
-const ReactDOMClient = reactDomClientModule.default ?? reactDomClientModule
-${transpiledSource}
-const rootElement = document.getElementById('root')
-if (!rootElement) {
-  throw new Error('TSX preview root element not found')
-}
-const output = Component()
-if (output && typeof Node !== 'undefined' && output instanceof Node) {
-  rootElement.replaceChildren(output)
-  return
-}
-if (!ReactDOMClient || typeof ReactDOMClient.createRoot !== 'function') {
-  throw new Error('ReactDOM client failed to load for TSX preview')
-}
-const root = ReactDOMClient.createRoot(rootElement)
-root.render(output)
-})().catch((error) => {
-  setTimeout(() => {
-    throw error
-  }, 0)
-})`;
-};
-
-const ensureComponentExport = source => {
-  if (source.includes('export const Component')) {
-    return source.replaceAll(/\bexport\s+const\s+Component\b/g, 'const Component');
-  }
-  throw new Error('TSX preview requires `export const Component = () => ...`');
-};
-
-const fetchText = async url => {
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${url}`);
-  }
-  return response.text();
-};
-
-const PREVIEW_CDN_CACHE_NAME = 'preview-cdn-cache-v1';
-const getCachedText = async url => {
-  if (typeof caches === 'undefined') {
-    return fetchText(url);
-  }
-  const cache = await caches.open(PREVIEW_CDN_CACHE_NAME);
-  const cached = await cache.match(url);
-  if (cached) {
-    return cached.text();
-  }
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch ${url}`);
-  }
-  await cache.put(url, response.clone());
-  return response.text();
-};
-
-const BABEL_CDN_URL = 'https://unpkg.com/@babel/standalone@7/babel.min.js';
-let babelPromise;
-const getBabel = async () => {
-  if (babelPromise) {
-    return babelPromise;
-  }
-  babelPromise = (async () => {
-    const source = await getCachedText(BABEL_CDN_URL);
-    const blob = new Blob([source], {
-      type: 'text/javascript'
-    });
-    const blobUrl = URL.createObjectURL(blob);
-    await import(/* @vite-ignore */blobUrl);
-    URL.revokeObjectURL(blobUrl);
-    const babel = globalThis.Babel;
-    if (!babel || typeof babel.transform !== 'function') {
-      throw new Error('Failed to load Babel standalone runtime');
-    }
-    return babel;
-  })();
-  return babelPromise;
-};
-
-const transpileTsx = async source => {
-  const normalizedSource = ensureComponentExport(source);
-  const babel = await getBabel();
-  const result = babel.transform(normalizedSource, {
-    presets: [['typescript', {
-      allExtensions: true,
-      isTSX: true
-    }], ['react', {
-      runtime: 'classic'
-    }]],
-    sourceType: 'script'
-  });
-  if (!result.code) {
-    throw new Error('Failed to transpile TSX preview source');
-  }
-  return result.code;
-};
-
-const getTsxScripts = async source => {
-  const transpiledSource = await transpileTsx(source);
-  const bootstrapSource = createTsxBootstrapScript(transpiledSource);
-  return [bootstrapSource];
-};
-
-const TSX_PREVIEW_HTML = '<!doctype html><html><head></head><body><div id="root"></div></body></html>';
-const loadTsx = async (state, content) => {
-  if (!state.loadJavaScript) {
-    return {
-      content,
-      css: [],
-      errorMessage: 'JavaScript execution is disabled, TSX preview is unavailable',
-      parsedDom: [],
-      parsedNodesChildNodeCount: 0,
-      scripts: [],
-      styleSheets: []
-    };
-  }
-  try {
-    const scripts = await getTsxScripts(content);
-    const scriptResult = await loadScripts(state, TSX_PREVIEW_HTML, [], scripts);
-    return {
-      content,
-      css: scriptResult.css,
-      errorMessage: '',
-      parsedDom: scriptResult.parsedDom,
-      parsedNodesChildNodeCount: scriptResult.parsedNodesChildNodeCount,
-      scripts,
-      styleSheets: []
-    };
-  } catch (error) {
-    return {
-      content,
-      css: [],
-      errorMessage: error instanceof Error ? error.message : 'Unknown error',
-      parsedDom: [],
-      parsedNodesChildNodeCount: 0,
-      scripts: [],
-      styleSheets: []
-    };
-  }
-};
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-
-const text = data => {
-  return {
-    childCount: 0,
-    text: data,
-    type: Text$1
-  };
-};
-
-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 isKey = key => {
-  return key !== 'type' && key !== 'childCount';
-};
-
-const getKeys = node => {
-  const keys = Object.keys(node).filter(isKey);
-  return keys;
-};
-
-const arrayToTree = nodes => {
-  const result = [];
-  let i = 0;
-  while (i < nodes.length) {
-    const node = nodes[i];
-    const {
-      children,
-      nodesConsumed
-    } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
-    result.push({
-      node,
-      children
-    });
-    i += 1 + nodesConsumed;
-  }
-  return result;
-};
-const getChildrenWithCount = (nodes, startIndex, childCount) => {
-  if (childCount === 0) {
-    return {
-      children: [],
-      nodesConsumed: 0
-    };
-  }
-  const children = [];
-  let i = startIndex;
-  let remaining = childCount;
-  let totalConsumed = 0;
-  while (remaining > 0 && i < nodes.length) {
-    const node = nodes[i];
-    const nodeChildCount = node.childCount || 0;
-    const {
-      children: nodeChildren,
-      nodesConsumed
-    } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
-    children.push({
-      node,
-      children: nodeChildren
-    });
-    const nodeSize = 1 + nodesConsumed;
-    i += nodeSize;
-    totalConsumed += nodeSize;
-    remaining--;
-  }
-  return {
-    children,
-    nodesConsumed: totalConsumed
-  };
-};
-
-const compareNodes = (oldNode, newNode) => {
-  const patches = [];
-  // Check if node type changed - return null to signal incompatible nodes
-  // (caller should handle this with a Replace operation)
-  if (oldNode.type !== newNode.type) {
-    return null;
-  }
-  // Handle reference nodes - special handling for uid changes
-  if (oldNode.type === Reference) {
-    if (oldNode.uid !== newNode.uid) {
-      patches.push({
-        type: SetReferenceNodeUid,
-        uid: newNode.uid
-      });
-    }
-    return patches;
-  }
-  // Handle text nodes
-  if (oldNode.type === Text$1 && newNode.type === Text$1) {
-    if (oldNode.text !== newNode.text) {
-      patches.push({
-        type: SetText,
-        value: newNode.text
-      });
-    }
-    return patches;
-  }
-  // Compare attributes
-  const oldKeys = getKeys(oldNode);
-  const newKeys = getKeys(newNode);
-  // Check for attribute changes
-  for (const key of newKeys) {
-    if (oldNode[key] !== newNode[key]) {
-      patches.push({
-        type: SetAttribute,
-        key,
-        value: newNode[key]
-      });
-    }
-  }
-  // Check for removed attributes
-  for (const key of oldKeys) {
-    if (!(key in newNode)) {
-      patches.push({
-        type: RemoveAttribute,
-        key
-      });
-    }
-  }
-  return patches;
-};
-
-const treeToArray = node => {
-  const result = [node.node];
-  for (const child of node.children) {
-    result.push(...treeToArray(child));
-  }
-  return result;
-};
-
-const diffChildren = (oldChildren, newChildren, patches) => {
-  const maxLength = Math.max(oldChildren.length, newChildren.length);
-  // Track where we are: -1 means at parent, >= 0 means at child index
-  let currentChildIndex = -1;
-  // Collect indices of children to remove (we'll add these patches at the end in reverse order)
-  const indicesToRemove = [];
-  for (let i = 0; i < maxLength; i++) {
-    const oldNode = oldChildren[i];
-    const newNode = newChildren[i];
-    if (!oldNode && !newNode) {
-      continue;
-    }
-    if (!oldNode) {
-      // Add new node - we should be at the parent
-      if (currentChildIndex >= 0) {
-        // Navigate back to parent
-        patches.push({
-          type: NavigateParent
-        });
-        currentChildIndex = -1;
-      }
-      // Flatten the entire subtree so renderInternal can handle it
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Add,
-        nodes: flatNodes
-      });
-    } else if (newNode) {
-      // Compare nodes to see if we need any patches
-      const nodePatches = compareNodes(oldNode.node, newNode.node);
-      // If nodePatches is null, the node types are incompatible - need to replace
-      if (nodePatches === null) {
-        // Navigate to this child
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Replace the entire subtree
-        const flatNodes = treeToArray(newNode);
-        patches.push({
-          type: Replace,
-          nodes: flatNodes
-        });
-        // After replace, we're at the new element (same position)
-        continue;
-      }
-      // Check if we need to recurse into children
-      const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
-      // Only navigate to this element if we need to do something
-      if (nodePatches.length > 0 || hasChildrenToCompare) {
-        // Navigate to this child if not already there
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Apply node patches (these apply to the current element, not children)
-        if (nodePatches.length > 0) {
-          patches.push(...nodePatches);
-        }
-        // Compare children recursively
-        if (hasChildrenToCompare) {
-          diffChildren(oldNode.children, newNode.children, patches);
-        }
-      }
-    } else {
-      // Remove old node - collect the index for later removal
-      indicesToRemove.push(i);
-    }
-  }
-  // Navigate back to parent if we ended at a child
-  if (currentChildIndex >= 0) {
-    patches.push({
-      type: NavigateParent
-    });
-    currentChildIndex = -1;
-  }
-  // Add remove patches in reverse order (highest index first)
-  // This ensures indices remain valid as we remove
-  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
-    patches.push({
-      type: RemoveChild,
-      index: indicesToRemove[j]
-    });
-  }
-};
-const diffTrees = (oldTree, newTree, patches, path) => {
-  // At the root level (path.length === 0), we're already AT the element
-  // So we compare the root node directly, then compare its children
-  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
-    const oldNode = oldTree[0];
-    const newNode = newTree[0];
-    // Compare root nodes
-    const nodePatches = compareNodes(oldNode.node, newNode.node);
-    // If nodePatches is null, the root node types are incompatible - need to replace
-    if (nodePatches === null) {
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Replace,
-        nodes: flatNodes
-      });
-      return;
-    }
-    if (nodePatches.length > 0) {
-      patches.push(...nodePatches);
-    }
-    // Compare children
-    if (oldNode.children.length > 0 || newNode.children.length > 0) {
-      diffChildren(oldNode.children, newNode.children, patches);
-    }
-  } else {
-    // Non-root level or multiple root elements - use the regular comparison
-    diffChildren(oldTree, newTree, patches);
-  }
-};
-
-const removeTrailingNavigationPatches = patches => {
-  // Find the last non-navigation patch
-  let lastNonNavigationIndex = -1;
-  for (let i = patches.length - 1; i >= 0; i--) {
-    const patch = patches[i];
-    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
-      lastNonNavigationIndex = i;
-      break;
-    }
-  }
-  // Return patches up to and including the last non-navigation patch
-  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
-};
-
-const diffTree = (oldNodes, newNodes) => {
-  // Step 1: Convert flat arrays to tree structures
-  const oldTree = arrayToTree(oldNodes);
-  const newTree = arrayToTree(newNodes);
-  // Step 3: Compare the trees
-  const patches = [];
-  diffTrees(oldTree, newTree, patches, []);
-  // Remove trailing navigation patches since they serve no purpose
-  return removeTrailingNavigationPatches(patches);
-};
-
-const Div = 'div';
-const H1 = 'h1';
-const H2 = 'h2';
-const H3 = 'h3';
-const H4 = 'h4';
-const H5 = 'h5';
-const Img = 'img';
-const Span = 'span';
-const Article = 'article';
-const Aside = 'aside';
-const Footer = 'footer';
-const Header = 'header';
-const Nav = 'nav';
-const Section = 'section';
-const Search = 'search';
-const Dd = 'dd';
-const Dl = 'dl';
-const Figcaption = 'figcaption';
-const Figure = 'figure';
-const Hr = 'hr';
-const Li = 'li';
-const Ol = 'ol';
-const P = 'p';
-const Pre = 'pre';
-const A = 'a';
-const Abbr = 'abbr';
-const Br = 'br';
-const Cite = 'cite';
-const Data = 'data';
-const Time = 'time';
-const Tfoot = 'tfoot';
-const Button = 'button';
-const Input = 'input';
-const Code = 'code';
-const Form = 'form';
-const Table = 'table';
-const TBody = 'tbody';
-const THead = 'thead';
-const Tr = 'tr';
-const Td = 'td';
-const Th = 'th';
-const Ul = 'ul';
-const TextArea = 'textarea';
-const Select = 'select';
-const Option = 'option';
-const Label = 'label';
-const Dt = 'dt';
-const Iframe = 'iframe';
-const Del = 'del';
-const H6 = 'h6';
-const Canvas = 'canvas';
-
-const ElementTags = {
-  __proto__: null,
-  A,
-  Abbr,
-  Article,
-  Aside,
-  Br,
-  Button,
-  Canvas,
-  Cite,
-  Code,
-  Data,
-  Dd,
-  Del,
-  Div,
-  Dl,
-  Dt,
-  Figcaption,
-  Figure,
-  Footer,
-  Form,
-  H1,
-  H2,
-  H3,
-  H4,
-  H5,
-  H6,
-  Header,
-  Hr,
-  Iframe,
-  Img,
-  Input,
-  Label,
-  Li,
-  Nav,
-  Ol,
-  Option,
-  P,
-  Pre,
-  Search,
-  Section,
-  Select,
-  Span,
-  TBody,
-  THead,
-  Table,
-  Td,
-  TextArea,
-  Tfoot,
-  Th,
-  Time,
-  Tr,
-  Ul
-};
-
-const getVirtualDomTag = text => {
-  switch (text) {
-    case A:
-      return A$1;
-    case Abbr:
-      return Abbr$1;
-    case Article:
-      return Article$1;
-    case Aside:
-      return Aside$1;
-    case Br:
-      return Br$1;
-    case Button:
-      return Button$1;
-    case Canvas:
-      return Canvas$1;
-    case Cite:
-      return Cite$1;
-    case Code:
-      return Code$1;
-    case Data:
-      return Data$1;
-    case Dd:
-      return Dd$1;
-    case Del:
-      return Del$1;
-    case Div:
-      return Div$1;
-    case Dl:
-      return Dl$1;
-    case Dt:
-      return Dt$1;
-    case Figcaption:
-      return Figcaption$1;
-    case Figure:
-      return Figure$1;
-    case Footer:
-      return Footer$1;
-    case Form:
-      return Div$1;
-    case H1:
-      return H1$1;
-    case H2:
-      return H2$1;
-    case H3:
-      return H3$1;
-    case H4:
-      return H4$1;
-    case H5:
-      return H5$1;
-    case H6:
-      return H6$1;
-    case Header:
-      return Header$1;
-    case Hr:
-      return Hr$1;
-    case Iframe:
-      return Iframe$1;
-    case Img:
-      return Img$1;
-    case Input:
-      return Input$1;
-    case Label:
-      return Label$1;
-    case Li:
-      return Li$1;
-    case Nav:
-      return Nav$1;
-    case Ol:
-      return Ol$1;
-    case Option:
-      return Option$1;
-    case P:
-      return P$1;
-    case Pre:
-      return Pre$1;
-    case Search:
-      return Search$1;
-    case Section:
-      return Section$1;
-    case Select:
-      return Select$1;
-    case Span:
-      return Span$1;
-    case Table:
-      return Table$1;
-    case TBody:
-      return TBody$1;
-    case Td:
-      return Td$1;
-    case TextArea:
-      return TextArea$1;
-    case Tfoot:
-      return Tfoot$1;
-    case Th:
-      return Th$1;
-    case THead:
-      return THead$1;
-    case Time:
-      return Time$1;
-    case Tr:
-      return Tr$1;
-    case Ul:
-      return Ul$1;
-    case 'html':
-      return Html$1;
-    case 'style':
-      return Style;
-    default:
-      return Div$1;
-  }
-};
-
-const OpeningAngleBracket = 1;
-const ClosingAngleBracket = 2;
-const TagNameStart = 3;
-const TagNameEnd = 4;
-const Content = 5;
-const ClosingTagSlash = 6;
-const WhitespaceInsideOpeningTag = 7;
-const AttributeName = 8;
-const AttributeEqualSign = 9;
-const AttributeQuoteStart = 10;
-const AttributeValue = 11;
-const AttributeQuoteEnd = 12;
-const WhitespaceAfterClosingTagSlash = 13;
-const WhitespaceAfterOpeningTagOpenAngleBracket = 14;
-const ExclamationMark = 15;
-const Doctype = 16;
-const StartCommentDashes = 17;
-const Comment = 18;
-const EndCommentTag = 19;
-const Text = 20;
-const CommentStart = 21;
-
-/* eslint-disable @cspell/spellchecker */
-// Common HTML attributes that are safe to allow by default
-const commonAllowedAttributes = new Set([
-// Global attributes
-'id', 'title', 'tabindex', 'class', 'style', 'lang', 'dir', 'hidden', 'contenteditable', 'draggable', 'spellcheck', 'translate', 'role',
-// Form input attributes
-'disabled', 'name', 'type', 'value', 'placeholder', 'required', 'readonly', 'checked', 'autofocus', 'autocomplete', 'multiple', 'accept', 'min', 'max', 'step', 'pattern', 'maxlength', 'minlength', 'size', 'rows', 'cols', 'wrap', 'inputmode',
-// Form attributes
-'action', 'method', 'enctype', 'target', 'novalidate', 'form',
-// Link attributes
-'href', 'rel', 'download', 'hreflang',
-// Image attributes
-'src', 'alt', 'width', 'height', 'loading', 'decoding', 'crossorigin', 'srcset', 'sizes',
-// Media attributes
-'controls', 'autoplay', 'loop', 'muted', 'preload', 'poster',
-// Table attributes
-'colspan', 'rowspan', 'headers', 'scope',
-// List attributes
-'reversed', 'start',
-// Other semantic attributes
-'open', 'datetime', 'cite', 'for', 'label']);
-const isDefaultAllowedAttribute = (attributeName, defaultAllowedAttributes) => {
-  // Allow data-* attributes
-  if (attributeName.startsWith('data-')) {
-    return true;
-  }
-  // Allow aria-* attributes
-  if (attributeName.startsWith('aria-')) {
-    return true;
-  }
-  // Check if it's a common HTML attribute
-  if (commonAllowedAttributes.has(attributeName)) {
-    return true;
-  }
-  // Check if in default list
-  return defaultAllowedAttributes.includes(attributeName);
-};
-
-const isSelfClosingTag = tag => {
-  switch (tag.toLowerCase()) {
-    case 'area':
-    case 'base':
-    case 'col':
-    case Br:
-    case Hr:
-    case Img:
-    case Input:
-    case 'embed':
-    case 'link':
-    case 'meta':
-    case 'param':
-    case 'source':
-    case 'track':
-    case 'wbr':
-      return true;
-    default:
-      return false;
-  }
-};
-
-const normalizeAttributeName = attribute => {
-  if (attribute === 'class') {
-    return 'className';
-  }
-  if (attribute === 'type') {
-    return 'inputType';
-  }
-  return attribute;
-};
-
-const parseText = text => {
-  return text.replaceAll('&gt;', '>').replaceAll('&lt;', '<').replaceAll('&amp;', '&');
-};
-
-class UnexpectedTokenError extends Error {
-  constructor() {
-    super('Unexpected token');
-    this.name = 'UnexpectedTokenError';
-  }
-}
-
-const State = {
-  AfterAttributeEqualSign: 8,
-  AfterAttributeName: 7,
-  AfterAttributeValueClosingQuote: 11,
-  AfterAttributeValueInsideDoubleQuote: 10,
-  AfterAttributeValueInsideSingleQuote: 19,
-  AfterClosingTagName: 5,
-  AfterClosingTagSlash: 4,
-  AfterExclamationMark: 16,
-  AfterOpeningAngleBracket: 2,
-  InsideAttributeAfterDoubleQuote: 9,
-  InsideAttributeAfterSingleQuote: 20,
-  InsideComment: 17,
-  InsideOpeningTag: 3,
-  InsideOpeningTagAfterWhitespace: 6,
-  InsideRawTextElement: 18,
-  TopLevelContent: 1
-};
-
-// Raw-text elements whose content should not be parsed as HTML
-const RAW_TEXT_ELEMENTS = new Set(['script', 'style']);
-const RE_ANGLE_BRACKET_OPEN = /^</;
-const RE_ANGLE_BRACKET_OPEN_TAG = /^<(?![\s%])/;
-const RE_ANGLE_BRACKET_CLOSE = /^>/;
-const RE_SLASH = /^\//;
-const RE_TAGNAME = /^[a-zA-Z\d$]+/;
-const RE_CONTENT = /^[^<>]+/;
-const RE_WHITESPACE = /^\s+/;
-const RE_ATTRIBUTE_NAME = /^[a-zA-Z\d-]+/;
-const RE_EQUAL_SIGN = /^=/;
-const RE_DOUBLE_QUOTE = /^"/;
-const RE_SINGLE_QUOTE = /^'/;
-const RE_ATTRIBUTE_VALUE_INSIDE_DOUBLE_QUOTE = /^[^"\n]+/;
-const RE_ATTRIBUTE_VALUE_INSIDE_SINGLE_QUOTE = /^[^'\n]+/;
-const RE_TEXT = /^[^<>]+/;
-const RE_EXCLAMATION_MARK = /^!/;
-const RE_DASH_DASH = /^--/;
-const RE_DOCTYPE = /^doctype/i;
-const RE_BLOCK_COMMENT_CONTENT = /^[a-zA-Z\s]+/;
-const RE_COMMENT_END = /^-->/;
-const RE_TAG_TEXT = /^[^\s>]+/;
-const RE_ANY_TEXT = /^[^\n]+/;
-const RE_ATTRIBUTE_TEXT = /^[^\n<>/\s]+/;
-const RE_BLOCK_COMMENT_START = /^<!--/;
-const RE_SELF_CLOSING = /^\/>/;
-const tokenizeHtml = text => {
-  string(text);
-  let state = State.TopLevelContent;
-  let index = 0;
-  let next;
-  const tokens = [];
-  let token;
-  let rawTextTagName = ''; // Track which raw-text element we're inside
-  while (index < text.length) {
-    const part = text.slice(index);
-    switch (state) {
-      case State.AfterAttributeEqualSign:
-        if (next = part.match(RE_DOUBLE_QUOTE)) {
-          token = AttributeQuoteStart;
-          state = State.InsideAttributeAfterDoubleQuote;
-        } else if (next = part.match(RE_SINGLE_QUOTE)) {
-          token = AttributeQuoteStart;
-          state = State.InsideAttributeAfterSingleQuote;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_ATTRIBUTE_TEXT)) {
-          token = AttributeValue;
-          state = State.InsideOpeningTag;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeName:
-        if (next = part.match(RE_EQUAL_SIGN)) {
-          token = AttributeEqualSign;
-          state = State.AfterAttributeEqualSign;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceInsideOpeningTag;
-          state = State.InsideOpeningTagAfterWhitespace;
-        } else if (next = part.match(RE_ANGLE_BRACKET_OPEN)) {
-          token = OpeningAngleBracket;
-          state = State.AfterOpeningAngleBracket;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeValueClosingQuote:
-        if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceInsideOpeningTag;
-          state = State.InsideOpeningTagAfterWhitespace;
-        } else if (next = part.match(RE_SELF_CLOSING)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeValueInsideDoubleQuote:
-        if (next = part.match(RE_DOUBLE_QUOTE)) {
-          token = AttributeQuoteEnd;
-          state = State.AfterAttributeValueClosingQuote;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterAttributeValueInsideSingleQuote:
-        if (next = part.match(RE_SINGLE_QUOTE)) {
-          token = AttributeQuoteEnd;
-          state = State.AfterAttributeValueClosingQuote;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterClosingTagName:
-        if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = Content;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterClosingTagSlash:
-        if (next = part.match(RE_TAGNAME)) {
-          token = TagNameEnd;
-          state = State.AfterClosingTagName;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceAfterClosingTagSlash;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterExclamationMark:
-        if (next = part.match(RE_DASH_DASH)) {
-          token = StartCommentDashes;
-          state = State.InsideComment;
-        } else if (next = part.match(RE_DOCTYPE)) {
-          token = Doctype;
-          state = State.InsideOpeningTag;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.AfterOpeningAngleBracket:
-        if (next = part.match(RE_TAGNAME)) {
-          token = TagNameStart;
-          state = State.InsideOpeningTag;
-          // Track raw-text elements so we can switch to raw content mode after >
-          if (RAW_TEXT_ELEMENTS.has(next[0].toLowerCase())) {
-            rawTextTagName = next[0].toLowerCase();
-          }
-        } else if (next = part.match(RE_SLASH)) {
-          token = ClosingTagSlash;
-          state = State.AfterClosingTagSlash;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceAfterOpeningTagOpenAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_EXCLAMATION_MARK)) {
-          token = ExclamationMark;
-          state = State.AfterExclamationMark;
-        } else if (next = part.match(RE_ANY_TEXT)) {
-          token = Text;
-          state = State.TopLevelContent;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideAttributeAfterDoubleQuote:
-        if (next = text.slice(index).match(RE_ATTRIBUTE_VALUE_INSIDE_DOUBLE_QUOTE)) {
-          token = AttributeValue;
-          state = State.AfterAttributeValueInsideDoubleQuote;
-        } else if (next = part.match(RE_DOUBLE_QUOTE)) {
-          token = AttributeQuoteEnd;
-          state = State.AfterAttributeValueClosingQuote;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideAttributeAfterSingleQuote:
-        if (next = text.slice(index).match(RE_ATTRIBUTE_VALUE_INSIDE_SINGLE_QUOTE)) {
-          token = AttributeValue;
-          state = State.AfterAttributeValueInsideSingleQuote;
-        } else if (next = part.match(RE_SINGLE_QUOTE)) {
-          token = AttributeQuoteEnd;
-          state = State.AfterAttributeValueClosingQuote;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideComment:
-        if (next = part.match(RE_BLOCK_COMMENT_CONTENT)) {
-          token = Comment;
-          state = State.InsideComment;
-        } else if (next = part.match(RE_COMMENT_END)) {
-          token = EndCommentTag;
-          state = State.TopLevelContent;
-        } else {
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideOpeningTag:
-        if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_WHITESPACE)) {
-          token = WhitespaceInsideOpeningTag;
-          state = State.InsideOpeningTagAfterWhitespace;
-        } else if (next = part.match(RE_TAG_TEXT)) {
-          token = Text;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideOpeningTagAfterWhitespace:
-        if (next = part.match(RE_ATTRIBUTE_NAME)) {
-          token = AttributeName;
-          state = State.AfterAttributeName;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_SELF_CLOSING)) {
-          token = ClosingAngleBracket;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_TEXT)) {
-          token = AttributeName;
-          state = State.AfterAttributeName;
-        } else {
-          text.slice(index).match(RE_TEXT); // ?
-          text.slice(index); // ?
-          throw new UnexpectedTokenError();
-        }
-        break;
-      case State.InsideRawTextElement:
-        {
-          // Match everything up to the closing tag for the current raw-text element
-          const closingTagPattern = new RegExp(`^([\\s\\S]*?)(<\\/${rawTextTagName}>)`, 'i');
-          const rawMatch = part.match(closingTagPattern);
-          if (rawMatch) {
-            // Emit content before the closing tag (if any)
-            if (rawMatch[1].length > 0) {
-              tokens.push({
-                text: rawMatch[1],
-                type: Content
-              });
-              index += rawMatch[1].length;
-            }
-            // Now emit the closing tag tokens: <, /, tagname, >
-            // < token
-            tokens.push({
-              text: '<',
-              type: OpeningAngleBracket
-            });
-            index += 1;
-            // / token
-            tokens.push({
-              text: '/',
-              type: ClosingTagSlash
-            });
-            index += 1;
-            // tagname token
-            tokens.push({
-              text: rawTextTagName,
-              type: TagNameEnd
-            });
-            index += rawTextTagName.length;
-            // > token
-            tokens.push({
-              text: '>',
-              type: ClosingAngleBracket
-            });
-            index += 1;
-            rawTextTagName = '';
-            state = State.TopLevelContent;
-            continue;
-          }
-          // No closing tag found — consume everything as content
-          next = [part];
-          token = Content;
-          rawTextTagName = '';
-          state = State.TopLevelContent;
-          break;
-        }
-      case State.TopLevelContent:
-        if (next = part.match(RE_ANGLE_BRACKET_OPEN_TAG)) {
-          token = OpeningAngleBracket;
-          state = State.AfterOpeningAngleBracket;
-        } else if (next = part.match(RE_CONTENT)) {
-          token = Content;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_BLOCK_COMMENT_START)) {
-          token = CommentStart;
-          state = State.InsideComment;
-        } else if (next = part.match(RE_ANGLE_BRACKET_CLOSE)) {
-          token = Content;
-          state = State.TopLevelContent;
-        } else if (next = part.match(RE_ANGLE_BRACKET_OPEN)) {
-          token = Text;
-          state = State.TopLevelContent;
-        } else {
-          throw new UnexpectedTokenError();
-        }
-        break;
-      default:
-        throw new UnexpectedTokenError();
-    }
-    const tokenText = next[0];
-    // After closing angle bracket of a raw-text element opening tag,
-    // switch to raw text content mode instead of top-level content
-    if (rawTextTagName && token === ClosingAngleBracket && state === State.TopLevelContent) {
-      state = State.InsideRawTextElement;
-    }
-    tokens.push({
-      text: tokenText,
-      type: token
-    });
-    index += tokenText.length;
-  }
-  return tokens;
-};
-
-// Tags that should be completely skipped (both tag and content)
-const TAGS_TO_SKIP_COMPLETELY = new Set(['meta', 'title']);
-
-// Tags that should have their opening/closing tags skipped but content processed
-const TAGS_TO_SKIP_TAG_ONLY = new Set(['html', 'head']);
-
-// Tags where we capture content as CSS
-const TAGS_TO_CAPTURE_AS_CSS = new Set(['style']);
-
-// Tags where we capture content as JavaScript
-const TAGS_TO_CAPTURE_AS_JS = new Set(['script']);
-
-// Attribute name normalization is implemented in a separate module
-
-const parseHtml = (html, allowedAttributes = [], defaultAllowedAttributes = []) => {
-  string(html);
-  array(allowedAttributes);
-  array(defaultAllowedAttributes);
-
-  // Combine default allowed attributes with any additional ones provided
-  const allAllowedAttributes = new Set([...defaultAllowedAttributes, ...allowedAttributes]);
-  const useBuiltInDefaults = allowedAttributes.length === 0;
-  const tokens = tokenizeHtml(html);
-  const dom = [];
-  const css = [];
-  const scripts = [];
-  const scriptTags = [];
-  const styleSheets = [];
-  const stylesheets = [];
-  const root = {
-    childCount: 0,
-    type: 0
-  };
-  let current = root;
-  const stack = [root];
-  const tagStack = []; // Track tag names to match closing tags
-  let attributeName = '';
-  let lastTagWasSelfClosing = false;
-  let skipDepth = 0; // Track how many levels deep we are in skipped content
-  let captureCss = false; // Track if we're inside a style tag
-  let cssContent = ''; // Accumulate CSS content
-  let captureJs = false; // Track if we're inside a script tag
-  let jsContent = ''; // Accumulate JavaScript content
-  let captureScriptAttributes = false;
-  let scriptSrc = '';
-  let captureStylesheetLink = false;
-  let stylesheetHref = '';
-  let stylesheetRel = '';
-  const setStylesheetAttribute = (name, value) => {
-    if (name === 'href') {
-      stylesheetHref = value;
-    } else if (name === 'rel') {
-      stylesheetRel = value;
-    }
-  };
-  const finalizeStylesheetLink = () => {
-    if (stylesheetRel.toLowerCase() === 'stylesheet' && stylesheetHref) {
-      stylesheets.push(stylesheetHref);
-      styleSheets.push({
-        href: stylesheetHref,
-        type: 'link'
-      });
-    }
-    captureStylesheetLink = false;
-    stylesheetHref = '';
-    stylesheetRel = '';
-  };
-  const setScriptAttribute = (name, value) => {
-    if (name === 'src') {
-      scriptSrc = value;
-    }
-  };
-  for (const token of tokens) {
-    switch (token.type) {
-      case AttributeName:
-        if (captureScriptAttributes) {
-          attributeName = token.text;
-        } else if (skipDepth === 0 && !captureCss && !captureJs) {
-          attributeName = token.text;
-        }
-        break;
-      case AttributeValue:
-        if (captureStylesheetLink) {
-          setStylesheetAttribute(attributeName, token.text);
-        } else if (captureScriptAttributes) {
-          setScriptAttribute(attributeName, token.text);
-        } else if (skipDepth === 0 && !captureCss && !captureJs && (allAllowedAttributes.has(attributeName) || useBuiltInDefaults && isDefaultAllowedAttribute(attributeName, defaultAllowedAttributes))) {
-          const finalAttributeName = normalizeAttributeName(attributeName);
-          current[finalAttributeName] = token.text;
-        }
-        attributeName = '';
-        break;
-      case ClosingAngleBracket:
-        if (captureScriptAttributes) {
-          if (attributeName) {
-            setScriptAttribute(attributeName, attributeName);
-          }
-          captureScriptAttributes = false;
-          attributeName = '';
-        }
-        if (captureStylesheetLink && lastTagWasSelfClosing) {
-          finalizeStylesheetLink();
-        }
-        if (skipDepth === 0 && !captureCss && !captureJs && !captureStylesheetLink) {
-          // Handle boolean attributes (attributes without values)
-          if (attributeName && (allAllowedAttributes.has(attributeName) || useBuiltInDefaults && isDefaultAllowedAttribute(attributeName, defaultAllowedAttributes))) {
-            const finalAttributeName = normalizeAttributeName(attributeName);
-            current[finalAttributeName] = attributeName;
-          }
-          attributeName = '';
-          // Return to parent if the current tag is self-closing
-          if (lastTagWasSelfClosing) {
-            current = stack.at(-1) || root;
-            lastTagWasSelfClosing = false;
-          }
-        }
-        break;
-      case Content:
-        if (captureCss) {
-          cssContent += token.text;
-        } else if (captureJs) {
-          jsContent += token.text;
-        } else if (skipDepth === 0) {
-          current.childCount++;
-          dom.push(text(parseText(token.text)));
-        }
-        break;
-      case Doctype:
-        // Ignore DOCTYPE - it's parsed but not rendered since we're in a div
-        break;
-      case TagNameEnd:
-        const tagNameToClose = tagStack.pop()?.toLowerCase() || '';
-        if (TAGS_TO_CAPTURE_AS_CSS.has(tagNameToClose)) {
-          // Finished capturing CSS
-          if (cssContent.trim()) {
-            css.push(cssContent);
-            styleSheets.push({
-              content: cssContent,
-              type: 'style'
-            });
-          }
-          cssContent = '';
-          captureCss = false;
-        } else if (TAGS_TO_CAPTURE_AS_JS.has(tagNameToClose)) {
-          // Finished capturing JavaScript
-          if (scriptSrc.trim()) {
-            scriptTags.push({
-              src: scriptSrc,
-              type: 'external'
-            });
-          } else if (jsContent.trim()) {
-            scripts.push(jsContent);
-            scriptTags.push({
-              content: jsContent,
-              type: 'inline'
-            });
-          }
-          jsContent = '';
-          scriptSrc = '';
-          captureJs = false;
-          captureScriptAttributes = false;
-        } else if (tagNameToClose === 'link' && captureStylesheetLink) {
-          finalizeStylesheetLink();
-        } else if (TAGS_TO_SKIP_COMPLETELY.has(tagNameToClose)) {
-          // We were skipping this content, so decrement skipDepth
-          skipDepth--;
-        } else if (TAGS_TO_SKIP_TAG_ONLY.has(tagNameToClose)) ; else {
-          // Normal tag - pop from stack
-          if (stack.length > 1) {
-            stack.pop();
-          }
-          current = stack.at(-1) || root;
-        }
-        break;
-      case TagNameStart:
-        const tagNameLower = token.text.toLowerCase();
-        lastTagWasSelfClosing = isSelfClosingTag(token.text);
-
-        // Check if this tag captures CSS content
-        if (TAGS_TO_CAPTURE_AS_CSS.has(tagNameLower)) {
-          captureCss = true;
-          cssContent = '';
-          tagStack.push(token.text);
-        }
-        // Check if this tag captures JavaScript content
-        else if (TAGS_TO_CAPTURE_AS_JS.has(tagNameLower)) {
-          captureJs = true;
-          jsContent = '';
-          scriptSrc = '';
-          captureScriptAttributes = true;
-          tagStack.push(token.text);
-        } else if (tagNameLower === 'link') {
-          captureStylesheetLink = true;
-          stylesheetHref = '';
-          stylesheetRel = '';
-          if (!lastTagWasSelfClosing) {
-            tagStack.push(token.text);
-          }
-        }
-        // Check if this tag should be completely skipped (meta, title)
-        else if (TAGS_TO_SKIP_COMPLETELY.has(tagNameLower)) {
-          if (!lastTagWasSelfClosing) {
-            // For non-self-closing tags like title, mark as skipped
-            skipDepth++;
-            tagStack.push(token.text);
-          }
-          // For self-closing tags like meta, we just skip them without tracking
-        }
-        // Check if this tag should have its opening/closing tags skipped (html, head)
-        else if (TAGS_TO_SKIP_TAG_ONLY.has(tagNameLower)) {
-          if (!lastTagWasSelfClosing) {
-            // Track the tag name for matching the closing tag
-            tagStack.push(token.text);
-          }
-        }
-        // Normal tag processing
-        else if (skipDepth === 0) {
-          current.childCount++;
-          const newNode = {
-            childCount: 0,
-            type: getVirtualDomTag(token.text)
-          };
-          dom.push(newNode);
-          current = newNode;
-          if (!lastTagWasSelfClosing) {
-            stack.push(current);
-            tagStack.push(token.text);
-          }
-        }
-        break;
-      case WhitespaceInsideOpeningTag:
-        if (captureStylesheetLink && attributeName) {
-          setStylesheetAttribute(attributeName, attributeName);
-        } else if (captureScriptAttributes && attributeName) {
-          setScriptAttribute(attributeName, attributeName);
-        } else if (skipDepth === 0 && !captureCss && !captureJs &&
-        // Handle boolean attributes (attributes without values)
-        attributeName && (allAllowedAttributes.has(attributeName) || useBuiltInDefaults && isDefaultAllowedAttribute(attributeName, defaultAllowedAttributes))) {
-          const finalAttributeName = normalizeAttributeName(attributeName);
-          current[finalAttributeName] = attributeName;
-        }
-        attributeName = '';
-        break;
-    }
-  }
-  try {
-    Object.defineProperty(dom, 'rootChildCount', {
-      configurable: true,
-      enumerable: false,
-      value: root.childCount
-    });
-  } catch {
-    dom.rootChildCount = root.childCount;
-  }
-  return {
-    css,
-    dom,
-    scripts,
-    scriptTags,
-    styleSheets,
-    stylesheets
-  };
-};
-
-const getUpdatedStateFromContent = async (state, content) => {
-  if (isTsxUri(state.uri)) {
-    return {
-      ...state,
-      ...(await loadTsx(state, content))
-    };
-  }
-  const parseResult = parseHtml(content, []);
-  const parsedNodesChildNodeCount = getParsedNodesChildNodeCount(parseResult.dom);
-  const css = await loadStyleSheets(state.uri, parseResult.styleSheets, state.loadExternalStyleSheets, state.loadStyleElements);
-  const scripts = state.loadJavaScript ? await loadScriptTags(state.uri, parseResult.scriptTags) : [];
-  return {
-    ...state,
-    content,
-    css,
-    errorMessage: '',
-    parsedDom: parseResult.dom,
-    parsedNodesChildNodeCount,
-    scripts,
-    styleSheets: parseResult.styleSheets
-  };
-};
-const handleEditorChanged = async editorUid => {
-  const hasSpecificEditor = Number.isFinite(editorUid);
-  if (!hasSpecificEditor) {
-    // Get all preview instance keys
-    const previewKeys = getKeys$1();
-
-    // Get all editor keys from the editor worker
-    const editorKeys = await invoke$1('Editor.getKeys');
-
-    // For each preview instance
-    for (const previewUid of previewKeys) {
-      const {
-        newState: state
-      } = get(previewUid);
-
-      // Skip if no URI is set
-      if (!state.uri) {
-        continue;
-      }
-
-      // Find the editor that matches our preview's URI
-      let matchingEditorUid = null;
-      for (const editorKey of editorKeys) {
-        const currentEditorUid = Number.parseFloat(editorKey);
-        const editorUri = await invoke$1('Editor.getUri', currentEditorUid);
-        if (editorUri === state.uri) {
-          matchingEditorUid = currentEditorUid;
-          break;
-        }
-      }
-
-      // If we found a matching editor, get its text and update the preview
-      if (matchingEditorUid !== null) {
-        try {
-          const content = await invoke$1('Editor.getText', matchingEditorUid);
-          const updatedState = await getUpdatedStateFromContent(state, content);
-          set(previewUid, state, updatedState);
-        } catch (error) {
-          // If getting text fails, update with error message
-          const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-          const updatedState = {
-            ...state,
-            content: '',
-            css: [],
-            errorMessage,
-            parsedDom: [],
-            scripts: [],
-            styleSheets: []
-          };
-          set(previewUid, state, updatedState);
-        }
-      }
-    }
-
-    // Rerender all previews after updates are complete
-    await invoke('Preview.rerender');
-    return;
-  }
-  const changedEditorUid = editorUid;
-  const changedEditorUri = await invoke$1('Editor.getUri', changedEditorUid);
-  const previewKeys = getKeys$1();
-  let changedEditorContent;
-  const getChangedEditorContent = async () => {
-    const cachedContent = changedEditorContent;
-    if (cachedContent !== undefined) {
-      return cachedContent;
-    }
-    const content = await invoke$1('Editor.getText', changedEditorUid);
-    changedEditorContent = content;
-    return content;
-  };
-  let didUpdate = false;
-
-  // Get all preview instance keys
-  for (const previewUid of previewKeys) {
-    const {
-      newState: state
-    } = get(previewUid);
-
-    // Skip if no URI is set
-    if (!state.uri) {
-      continue;
-    }
-    if (changedEditorUri === state.uri) {
-      try {
-        const content = await getChangedEditorContent();
-        const updatedState = await getUpdatedStateFromContent(state, content);
-        set(previewUid, state, updatedState);
-        didUpdate = true;
-      } catch (error) {
-        // If getting text fails, update with error message
-        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-        const updatedState = {
-          ...state,
-          content: '',
-          css: [],
-          errorMessage,
-          parsedDom: [],
-          scripts: [],
-          styleSheets: []
-        };
-        set(previewUid, state, updatedState);
-        didUpdate = true;
-      }
-      continue;
-    }
-    if (!state.loadExternalStyleSheets) {
-      continue;
-    }
-    if (!hasMatchingLinkedStyleSheet(state.uri, state.styleSheets, changedEditorUri)) {
-      continue;
-    }
-    try {
-      const content = await getChangedEditorContent();
-      const css = await loadStyleSheetsWithEditorOverride(state.uri, state.styleSheets, state.css, state.loadExternalStyleSheets, state.loadStyleElements, changedEditorUri, content);
-      const updatedState = {
-        ...state,
-        css,
-        errorMessage: ''
-      };
-      set(previewUid, state, updatedState);
-      didUpdate = true;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      const updatedState = {
-        ...state,
-        errorMessage
-      };
-      set(previewUid, state, updatedState);
-      didUpdate = true;
-    }
-  }
-  if (didUpdate) {
-    await invoke('Preview.rerender');
-  }
-};
-
-const updateContent = async (state, uri) => {
-  try {
-    const {
-      loadExternalStyleSheets,
-      loadJavaScript,
-      loadStyleElements
-    } = state;
-    // Read the file content using RendererWorker RPC
-    const content = await readFile(uri);
-    if (isTsxUri(uri)) {
-      const tsxResult = await loadTsx(state, content);
-      return {
-        ...state,
-        ...tsxResult
-      };
-    }
-
-    // Parse the content into virtual DOM and CSS
-    const parseResult = parseHtml(content);
-    const parsedDom = parseResult.dom;
-    const css = await loadStyleSheets(uri, parseResult.styleSheets, loadExternalStyleSheets, loadStyleElements);
-    const scripts = loadJavaScript ? await loadScriptTags(uri, parseResult.scriptTags) : [];
-    if (scripts.length > 0) {
-      return loadScripts(state, content, css, scripts);
-    }
-    const parsedNodesChildNodeCount = getParsedNodesChildNodeCount(parsedDom);
-    return {
-      ...state,
-      content,
-      css,
-      errorMessage: '',
-      parsedDom,
-      parsedNodesChildNodeCount,
-      scripts,
-      styleSheets: parseResult.styleSheets
-    };
-  } catch (error) {
-    // If file reading or parsing fails, return empty content and parsedDom with error message
-    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-    return {
-      ...state,
-      content: '',
-      css: [],
-      errorMessage,
-      parsedDom: [],
-      parsedNodesChildNodeCount: 0,
-      scripts: [],
-      styleSheets: []
-    };
-  }
-};
-
-const handleFileEdited = async state => {
-  const {
-    content,
-    css,
-    errorMessage,
-    parsedDom,
-    parsedNodesChildNodeCount,
-    scripts,
-    styleSheets
-  } = await updateContent(state, state.uri);
-  let finalParsedDom = parsedDom;
-  let finalCss = [...css];
-  let finalParsedNodesChildNodeCount = parsedNodesChildNodeCount;
-  if (scripts.length > 0) {
-    const {
-      sandboxRpc,
-      uid
-    } = state;
-    await sandboxRpc.invoke('SandBox.initialize', uid, content, scripts);
-    const serialized = await sandboxRpc.invoke('SandBox.getSerializedDom', uid);
-    finalParsedDom = serialized.dom;
-    finalCss = [...serialized.css];
-    for (const cssContent of css) {
-      if (!finalCss.includes(cssContent)) {
-        finalCss.push(cssContent);
-      }
-    }
-    finalParsedNodesChildNodeCount = getParsedNodesChildNodeCount(finalParsedDom);
-  }
-  return {
-    ...state,
-    content,
-    css: finalCss,
-    errorMessage,
-    parsedDom: finalParsedDom,
-    parsedNodesChildNodeCount: finalParsedNodesChildNodeCount,
-    scripts,
-    styleSheets
-  };
-};
-
-const handleInput = async (state, hdId, value) => {
-  if (!hdId) {
-    return state;
-  }
-  return callAndUpdate(state, 'SandBox.handleInput', hdId, value);
-};
-
-const handleKeydown = async (state, hdId, key, code) => {
-  return callAndUpdate(state, 'SandBox.handleKeyDown', hdId, key, code);
-};
-
-const handleKeyup = async (state, hdId, key, code) => {
-  return callAndUpdate(state, 'SandBox.handleKeyUp', hdId, key, code);
-};
-
-const handleMousedown = async (state, hdId, clientX, clientY) => {
-  if (!hdId) {
-    return state;
-  }
-  const {
-    x,
-    y
-  } = state;
-  const adjustedClientX = clientX - x;
-  const adjustedClientY = clientY - y;
-  return callAndUpdate(state, 'SandBox.handleMousedown', hdId, adjustedClientX, adjustedClientY);
-};
-
-const handleMousemove = async (state, hdId, clientX, clientY) => {
-  if (!hdId) {
-    return state;
-  }
-  const {
-    x,
-    y
-  } = state;
-  const adjustedClientX = clientX - x;
-  const adjustedClientY = clientY - y;
-  return callAndUpdate(state, 'SandBox.handleMousemove', hdId, adjustedClientX, adjustedClientY);
-};
-
-const handleMouseup = async (state, hdId) => {
-  if (!hdId) {
-    return state;
-  }
-  return callAndUpdate(state, 'SandBox.handleMouseup', hdId);
-};
-
-const triggerRerender = async state => {
-  await invoke('Preview.rerender');
-  return state;
-};
-
-const handleMutation = async state => {
-  const {
-    uid
-  } = state;
-  await triggerRerender(state);
-  if (has('mutation', uid)) {
-    resolve('mutation', uid);
-  }
-  return state;
-};
-
-const createUuid = () => {
-  return globalThis.crypto.randomUUID();
-};
-
-const loadContent = async state => {
-  // Try to register to receive editor change notifications from the editor worker.
-  // Use dynamic access and ignore errors so this is safe in environments where
-  // the EditorWorker / ListenerType are not available (e.g. unit tests).
-  const EditorChange = 1;
-  const rpcId = 9112;
-  const listenerId = createUuid();
-  try {
-    await invoke$1('Listener.register', EditorChange, rpcId, listenerId);
-  } catch (error) {
-    console.error(error);
-  }
-  const {
-    uri
-  } = state;
-
-  // Read and parse file contents if we have a URI
-  const {
-    content,
-    css,
-    errorMessage,
-    parsedDom,
-    parsedNodesChildNodeCount,
-    scripts,
-    styleSheets
-  } = uri ? await updateContent(state, state.uri) : {
-    content: state.content,
-    css: state.css,
-    errorMessage: state.errorMessage,
-    parsedDom: state.parsedDom,
-    parsedNodesChildNodeCount: state.parsedNodesChildNodeCount,
-    scripts: state.scripts,
-    styleSheets: state.styleSheets
-  };
-  return {
-    ...state,
-    content,
-    css,
-    errorCount: 0,
-    errorMessage,
-    initial: false,
-    listenerId,
-    parsedDom,
-    parsedNodesChildNodeCount,
-    scripts,
-    styleSheets,
-    warningCount: 1
-  };
-};
-
-const PREVIEW_SELECTOR = '.Preview';
-const HTML_SELECTOR = '.Preview .Html';
-const ROOT_SELECTOR = PREVIEW_SELECTOR;
-const startsWithRootPseudoSelector = selector => {
-  return selector.toLowerCase().startsWith(':root') && !isIdentifierChar(selector[5]);
-};
-const replaceRootPseudoSelector = selector => {
-  const normalizedHtmlRootSelector = `${HTML_SELECTOR}:root`;
-  if (selector.toLowerCase().startsWith(normalizedHtmlRootSelector.toLowerCase()) && !isIdentifierChar(selector[normalizedHtmlRootSelector.length])) {
-    return `${ROOT_SELECTOR}${selector.slice(normalizedHtmlRootSelector.length)}`;
-  }
-  if (startsWithRootPseudoSelector(selector)) {
-    return `${ROOT_SELECTOR}${selector.slice(5)}`;
-  }
-  return selector;
-};
-const isIdentifierChar = char => {
-  if (!char) {
-    return false;
-  }
-  return /[a-zA-Z0-9_-]/.test(char);
-};
-const isLikelyTypeSelectorStart = (selector, tokenStart) => {
-  if (tokenStart === 0) {
-    return true;
-  }
-  const previous = selector[tokenStart - 1];
-  return /[\s,+>~(|&]/.test(previous);
-};
-const replaceHtmlAndBodyTypeSelectors = selector => {
-  let result = '';
-  let quote;
-  let inComment = false;
-  let bracketsDepth = 0;
-  for (let i = 0; i < selector.length; i++) {
-    const char = selector[i];
-    const next = selector[i + 1];
-    if (inComment) {
-      result += char;
-      if (char === '*' && next === '/') {
-        result += '/';
-        i++;
-        inComment = false;
-      }
-      continue;
-    }
-    if (quote) {
-      result += char;
-      if (char === '\\') {
-        const escaped = selector[i + 1];
-        if (escaped) {
-          result += escaped;
-          i++;
-        }
-        continue;
-      }
-      if (char === quote) {
-        quote = undefined;
-      }
-      continue;
-    }
-    if (char === '/' && next === '*') {
-      result += '/*';
-      i++;
-      inComment = true;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      result += char;
-      quote = char;
-      continue;
-    }
-    if (char === '[') {
-      bracketsDepth++;
-      result += char;
-      continue;
-    }
-    if (char === ']') {
-      bracketsDepth = Math.max(0, bracketsDepth - 1);
-      result += char;
-      continue;
-    }
-    if (bracketsDepth === 0 && /[a-zA-Z_-]/.test(char)) {
-      let j = i + 1;
-      while (j < selector.length && isIdentifierChar(selector[j])) {
-        j++;
-      }
-      const token = selector.slice(i, j);
-      const lowerToken = token.toLowerCase();
-      const shouldReplace = (lowerToken === 'html' || lowerToken === 'body') && isLikelyTypeSelectorStart(selector, i);
-      if (shouldReplace) {
-        result += HTML_SELECTOR;
-      } else {
-        result += token;
-      }
-      i = j - 1;
-      continue;
-    }
-    result += char;
-  }
-  return result;
-};
-const hasTopLevelPreviewAnchor = selector => {
-  let quote;
-  let inComment = false;
-  let parenthesesDepth = 0;
-  let bracketsDepth = 0;
-  for (let i = 0; i < selector.length; i++) {
-    const char = selector[i];
-    const next = selector[i + 1];
-    if (inComment) {
-      if (char === '*' && next === '/') {
-        i++;
-        inComment = false;
-      }
-      continue;
-    }
-    if (quote) {
-      if (char === '\\') {
-        i++;
-        continue;
-      }
-      if (char === quote) {
-        quote = undefined;
-      }
-      continue;
-    }
-    if (char === '/' && next === '*') {
-      i++;
-      inComment = true;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-    if (char === '(') {
-      parenthesesDepth++;
-      continue;
-    }
-    if (char === ')') {
-      parenthesesDepth = Math.max(0, parenthesesDepth - 1);
-      continue;
-    }
-    if (char === '[') {
-      bracketsDepth++;
-      continue;
-    }
-    if (char === ']') {
-      bracketsDepth = Math.max(0, bracketsDepth - 1);
-      continue;
-    }
-    if (parenthesesDepth !== 0 || bracketsDepth !== 0) {
-      continue;
-    }
-    if (selector.startsWith(PREVIEW_SELECTOR, i)) {
-      if (i === 0) {
-        return true;
-      }
-      const previous = selector[i - 1];
-      if (/[\s>+~,&|]/.test(previous)) {
-        return true;
-      }
-    }
-  }
-  return false;
-};
-const isAlreadyScopedSelector = selector => {
-  const trimmed = selector.trim();
-  return hasTopLevelPreviewAnchor(trimmed);
-};
-const splitByCommaAtTopLevel = selectorText => {
-  const selectors = [];
-  let current = '';
-  let quote;
-  let inComment = false;
-  let parenthesesDepth = 0;
-  let bracketsDepth = 0;
-  for (let i = 0; i < selectorText.length; i++) {
-    const char = selectorText[i];
-    const next = selectorText[i + 1];
-    if (inComment) {
-      current += char;
-      if (char === '*' && next === '/') {
-        current += '/';
-        i++;
-        inComment = false;
-      }
-      continue;
-    }
-    if (quote) {
-      current += char;
-      if (char === '\\') {
-        const escaped = selectorText[i + 1];
-        if (escaped) {
-          current += escaped;
-          i++;
-        }
-        continue;
-      }
-      if (char === quote) {
-        quote = undefined;
-      }
-      continue;
-    }
-    if (char === '/' && next === '*') {
-      current += '/*';
-      i++;
-      inComment = true;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      current += char;
-      quote = char;
-      continue;
-    }
-    if (char === '(') {
-      parenthesesDepth++;
-      current += char;
-      continue;
-    }
-    if (char === ')') {
-      parenthesesDepth = Math.max(0, parenthesesDepth - 1);
-      current += char;
-      continue;
-    }
-    if (char === '[') {
-      bracketsDepth++;
-      current += char;
-      continue;
-    }
-    if (char === ']') {
-      bracketsDepth = Math.max(0, bracketsDepth - 1);
-      current += char;
-      continue;
-    }
-    if (char === ',' && parenthesesDepth === 0 && bracketsDepth === 0) {
-      selectors.push(current);
-      current = '';
-      continue;
-    }
-    current += char;
-  }
-  selectors.push(current);
-  return selectors;
-};
-const scopeSingleSelector = selector => {
-  const trimmed = selector.trim();
-  if (!trimmed) {
-    return '';
-  }
-  const normalized = replaceRootPseudoSelector(replaceHtmlAndBodyTypeSelectors(trimmed));
-  if (isAlreadyScopedSelector(normalized)) {
-    return normalized;
-  }
-  return `${PREVIEW_SELECTOR} ${normalized}`;
-};
-const scopeSelectorList = selectorList => {
-  const selectors = splitByCommaAtTopLevel(selectorList);
-  const scopedSelectors = selectors.map(scopeSingleSelector).filter(Boolean);
-  return scopedSelectors.join(', ');
-};
-const findBlockEnd = (css, blockStart) => {
-  let quote;
-  let inComment = false;
-  let depth = 1;
-  for (let i = blockStart + 1; i < css.length; i++) {
-    const char = css[i];
-    const next = css[i + 1];
-    if (inComment) {
-      if (char === '*' && next === '/') {
-        i++;
-        inComment = false;
-      }
-      continue;
-    }
-    if (quote) {
-      if (char === '\\') {
-        i++;
-        continue;
-      }
-      if (char === quote) {
-        quote = undefined;
-      }
-      continue;
-    }
-    if (char === '/' && next === '*') {
-      i++;
-      inComment = true;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-    if (char === '{') {
-      depth++;
-      continue;
-    }
-    if (char === '}') {
-      depth--;
-      if (depth === 0) {
-        return i;
-      }
-    }
-  }
-  return -1;
-};
-const shouldScopeNestedAtRule = prelude => {
-  const lowerPrelude = prelude.trim().toLowerCase();
-  return lowerPrelude.startsWith('@media') || lowerPrelude.startsWith('@supports') || lowerPrelude.startsWith('@container') || lowerPrelude.startsWith('@layer') || lowerPrelude.startsWith('@scope') || lowerPrelude.startsWith('@document');
-};
-const formatRule = (prelude, block) => {
-  const startsWithNewline = block.startsWith('\n') || block.startsWith('\r');
-  if (startsWithNewline) {
-    return `${prelude} {${block} }`;
-  }
-  return `${prelude} { ${block} }`;
-};
-const scopeCss = css => {
-  const rules = [];
-  let index = 0;
-  while (index < css.length) {
-    while (index < css.length) {
-      if (css[index] === '}' || /\s/.test(css[index])) {
-        index++;
-        continue;
-      }
-      if (css[index] === '/' && css[index + 1] === '*') {
-        const endComment = css.indexOf('*/', index + 2);
-        if (endComment === -1) {
-          index = css.length;
-          break;
-        }
-        index = endComment + 2;
-        continue;
-      }
-      break;
-    }
-    if (index >= css.length) {
-      break;
-    }
-    let quote;
-    let inComment = false;
-    let parenthesesDepth = 0;
-    let bracketsDepth = 0;
-    let delimiterIndex = -1;
-    let delimiter = '';
-    for (let i = index; i < css.length; i++) {
-      const char = css[i];
-      const next = css[i + 1];
-      if (inComment) {
-        if (char === '*' && next === '/') {
-          i++;
-          inComment = false;
-        }
-        continue;
-      }
-      if (quote) {
-        if (char === '\\') {
-          i++;
-          continue;
-        }
-        if (char === quote) {
-          quote = undefined;
-        }
-        continue;
-      }
-      if (char === '/' && next === '*') {
-        i++;
-        inComment = true;
-        continue;
-      }
-      if (char === '"' || char === "'") {
-        quote = char;
-        continue;
-      }
-      if (char === '(') {
-        parenthesesDepth++;
-        continue;
-      }
-      if (char === ')') {
-        parenthesesDepth = Math.max(0, parenthesesDepth - 1);
-        continue;
-      }
-      if (char === '[') {
-        bracketsDepth++;
-        continue;
-      }
-      if (char === ']') {
-        bracketsDepth = Math.max(0, bracketsDepth - 1);
-        continue;
-      }
-      if (parenthesesDepth === 0 && bracketsDepth === 0 && (char === '{' || char === ';')) {
-        delimiterIndex = i;
-        delimiter = char;
-        break;
-      }
-    }
-    if (delimiterIndex === -1) {
-      break;
-    }
-    if (delimiter === ';') {
-      const statement = css.slice(index, delimiterIndex + 1).trim();
-      if (statement) {
-        rules.push(statement);
-      }
-      index = delimiterIndex + 1;
-      continue;
-    }
-    const prelude = css.slice(index, delimiterIndex).trim();
-    const blockEnd = findBlockEnd(css, delimiterIndex);
-    if (blockEnd === -1) {
-      break;
-    }
-    const block = css.slice(delimiterIndex + 1, blockEnd);
-    if (!prelude) {
-      index = blockEnd + 1;
-      continue;
-    }
-    if (prelude.startsWith('@')) {
-      if (shouldScopeNestedAtRule(prelude)) {
-        const scopedBlock = scopeCss(block);
-        if (scopedBlock) {
-          rules.push(formatRule(prelude, scopedBlock));
-        }
-      } else {
-        rules.push(formatRule(prelude, block));
-      }
-    } else {
-      const scopedPrelude = scopeSelectorList(prelude);
-      if (scopedPrelude) {
-        rules.push(formatRule(scopedPrelude, block));
-      }
-    }
-    index = blockEnd + 1;
-  }
-  return rules.join(' ');
-};
-const replaceCssBodySelector = css => {
-  if (!css.trim()) {
-    return css;
-  }
-  return scopeCss(css);
-};
-
-const renderCss = (oldState, newState) => {
-  const {
-    css,
-    uid
-  } = newState;
-
-  // Combine all CSS strings into a single string
-  let cssString = css.join('\n');
-
-  // Replace html/body selectors with .Preview .Html since we render document content in nested div elements
-  cssString = replaceCssBodySelector(cssString);
-
-  // Return command in format that can be handled by the viewlet
-  // The 'Viewlet.setCss' is a method that should be called on the viewlet
-  return ['Viewlet.setCss', uid, cssString];
-};
-
-const Html = 'Html';
-const Preview = 'Preview';
-const Viewlet = 'Viewlet';
-
-const HandleInput = 4;
-const HandleClick = 11;
-const HandleKeydown = 12;
-const HandleKeyup = 13;
-const HandleMousedown = 14;
-const HandleMousemove = 15;
-const HandleMouseup = 16;
-
-const getEmptyPreviewDom = () => {
-  return [{
-    childCount: 1,
-    className: mergeClassNames(Viewlet, Preview),
-    type: Div$1
-  }, {
-    childCount: 1,
-    className: Html,
-    type: Div$1
-  }, {
-    childCount: 1,
-    type: H1$1
-  }, {
-    text: 'No URI has been specified',
-    type: Text$1
-  }];
-};
-
-const getPreviewUninitializedVirtualDom = () => {
-  return [{
-    childCount: 1,
-    className: mergeClassNames(Viewlet, Preview),
-    onClick: HandleClick,
-    onInput: HandleInput,
-    onKeyDown: HandleKeydown,
-    onKeyUp: HandleKeyup,
-    onMouseDown: HandleMousedown,
-    onMouseMove: HandleMousemove,
-    onMouseUp: HandleMouseup,
-    tabIndex: 0,
-    type: Div$1
-  }, {
-    childCount: 1,
-    className: Html,
-    type: Div$1
-  }, {
-    childCount: 1,
-    type: H1$1
-  }, {
-    text: 'Edit the file on the left to get started.',
-    type: Text$1
-  }];
-};
-
-const getPreviewDom = state => {
-  const {
-    parsedDom,
-    parsedNodesChildNodeCount,
-    uri
-  } = state;
-  if (!uri) {
-    return getEmptyPreviewDom();
-  }
-
-  // If parsedDom is available, render it as children of the wrapper
-  if (parsedDom && parsedDom.length > 0) {
-    return [{
-      childCount: 1,
-      className: mergeClassNames(Viewlet, Preview),
-      onClick: HandleClick,
-      onInput: HandleInput,
-      onKeyDown: HandleKeydown,
-      onKeyUp: HandleKeyup,
-      onMouseDown: HandleMousedown,
-      onMouseMove: HandleMousemove,
-      onMouseUp: HandleMouseup,
-      tabIndex: 0,
-      type: Div$1
-    }, {
-      childCount: parsedNodesChildNodeCount,
-      className: Html,
-      type: Div$1
-    }, ...parsedDom];
-  }
-  return getPreviewUninitializedVirtualDom();
-};
-
-const renderItems = (oldState, newState) => {
-  const {
-    initial,
-    uid
-  } = newState;
-  if (initial) {
-    return [SetDom2, uid, []];
-  }
-  const dom = getPreviewDom(newState);
-  return [SetDom2, uid, dom];
-};
-
-const renderIncremental = (oldState, newState) => {
-  const oldDom = renderItems(oldState, oldState)[2];
-  const newDom = renderItems(newState, newState)[2];
-  const patches = diffTree(oldDom, newDom);
-  return [SetPatches, newState.uid, patches];
-};
-
-const getRenderer = diffType => {
-  switch (diffType) {
-    case RenderCss:
-      return renderCss;
-    case RenderIncremental:
-      return renderIncremental;
-    case RenderItems:
-      return renderItems;
-    default:
-      throw new Error('unknown renderer');
-  }
-};
-
-const applyRender = (oldState, newState, diffResult) => {
-  const commands = [];
-  for (const item of diffResult) {
-    const fn = getRenderer(item);
-    const result = fn(oldState, newState);
-    if (result.length > 0) {
-      commands.push(result);
-    }
-  }
-  return commands;
-};
-
-const render2 = (uid, diffResult) => {
-  const {
-    newState,
-    oldState
-  } = get(uid);
-  set(uid, newState, newState);
-  const commands = applyRender(oldState, newState, diffResult);
-  return commands;
-};
-
-const renderEventListeners = () => {
-  return [{
-    capture: true,
-    name: HandleClick,
-    params: ['handleClick', 'event.target.dataset.id', ClientX, ClientY]
-  }, {
-    capture: true,
-    name: HandleInput,
-    params: ['handleInput', 'event.target.dataset.id', TargetValue]
-  }, {
-    capture: true,
-    name: HandleKeydown,
-    params: ['handleKeyDown', 'event.target.dataset.id', Key, 'event.code']
-  }, {
-    capture: true,
-    name: HandleKeyup,
-    params: ['handleKeyUp', 'event.target.dataset.id', Key, 'event.code']
-  }, {
-    capture: true,
-    name: HandleMousedown,
-    params: ['handleMousedown', 'event.target.dataset.id', ClientX, ClientY]
-  }, {
-    capture: true,
-    name: HandleMousemove,
-    params: ['handleMousemove', 'event.target.dataset.id', ClientX, ClientY]
-  }, {
-    capture: true,
-    name: HandleMouseup,
-    params: ['handleMouseup', 'event.target.dataset.id']
-  }];
-};
-
-const getLinkedStyleSheetCss = state => {
-  const linkedCss = [];
-  let cssIndex = 0;
-  for (const styleSheet of state.styleSheets) {
-    if (styleSheet.type === 'style') {
-      if (state.loadStyleElements && styleSheet.content) {
-        cssIndex++;
-      }
-      continue;
-    }
-    if (!state.loadExternalStyleSheets || !styleSheet.href) {
-      continue;
-    }
-    const cssContent = state.css[cssIndex];
-    if (cssContent) {
-      linkedCss.push(cssContent);
-      cssIndex++;
-    }
-  }
-  return linkedCss;
-};
-const rerender = async state => {
-  const {
-    loadJavaScript,
-    sandboxRpc,
-    scripts,
-    uid
-  } = state;
-  if (!loadJavaScript || scripts.length === 0) {
-    return state;
-  }
-  const serialized = await sandboxRpc.invoke('SandBox.getSerializedDom', uid);
-  const parsedDom = serialized.dom;
-  const css = [...serialized.css];
-  for (const linkedCss of getLinkedStyleSheetCss(state)) {
-    if (!css.includes(linkedCss)) {
-      css.push(linkedCss);
-    }
-  }
-  const parsedNodesChildNodeCount = getParsedNodesChildNodeCount(parsedDom);
-  return {
-    ...state,
-    css,
-    parsedDom,
-    parsedNodesChildNodeCount
-  };
-};
-
-const resize = (state, dimensions) => {
-  return {
-    ...state,
-    ...dimensions
-  };
-};
-
-const saveState = state => {
-  return {
-    x: 0
-  };
-};
-
-const setUri = async (state, uri) => {
-  const {
-    content,
-    css,
-    errorMessage,
-    parsedDom,
-    parsedNodesChildNodeCount,
-    scripts,
-    styleSheets
-  } = await updateContent(state, uri);
-  return {
-    ...state,
-    content,
-    css,
-    errorMessage,
-    parsedDom,
-    parsedNodesChildNodeCount,
-    scripts,
-    styleSheets,
-    uri
-  };
-};
-
-const waitForClick = async state => {
-  const {
-    uid
-  } = state;
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  register('click', uid, resolve);
-  await promise;
-  return state;
-};
-
-const defaultTimeout = 5000;
-const pollInterval = 16;
-const hasClass = (className, expectedClass) => {
-  if (typeof className !== 'string') {
-    return false;
-  }
-  return className.split(' ').includes(expectedClass);
-};
-const isTagSelector = selector => {
-  const lowerCaseSelector = selector.toLowerCase();
-  return Object.values(ElementTags).includes(lowerCaseSelector) || lowerCaseSelector === 'html' || lowerCaseSelector === 'style';
-};
-const hasMatchingSelector = (dom, selector) => {
-  if (selector.startsWith('#')) {
-    const id = selector.slice(1);
-    return dom.some(node => node && typeof node === 'object' && node.id === id);
-  }
-  if (selector.startsWith('.')) {
-    const className = selector.slice(1);
-    return dom.some(node => node && typeof node === 'object' && hasClass(node.className, className));
-  }
-  if (isTagSelector(selector)) {
-    const tag = getVirtualDomTag(selector.toLowerCase());
-    return dom.some(node => node && typeof node === 'object' && node.type === tag);
-  }
-  throw new Error(`Unsupported selector "${selector}". Supported selectors: #id, .class, tag`);
-};
-const waitForSelector = async (state, selector, timeout) => {
-  const {
-    sandboxRpc,
-    uid
-  } = state;
-  const start = Date.now();
-  while (Date.now() - start <= timeout) {
-    const serialized = await sandboxRpc.invoke('SandBox.getSerializedDom', uid);
-    const dom = serialized?.dom ?? [];
-    if (hasMatchingSelector(dom, selector)) {
-      return;
-    }
-    await new Promise(resolve => setTimeout(resolve, pollInterval));
-  }
-  throw new Error(`Timed out waiting for selector "${selector}" after ${timeout}ms`);
-};
-const waitForMutation = async (state, options) => {
-  const selector = options?.selector;
-  if (selector) {
-    const timeout = options?.timeout ?? defaultTimeout;
-    await waitForSelector(state, selector, timeout);
-    return state;
-  }
-  const {
-    uid
-  } = state;
-  const {
-    promise,
-    resolve
-  } = Promise.withResolvers();
-  register('mutation', uid, resolve);
-  await promise;
-  return state;
-};
-
-const commandMap = {
-  handleEditorChanged: handleEditorChanged,
-  'Preview.create': create,
-  'Preview.createOffscreenCanvas': wrapGetter(getOffscreenCanvas),
-  'Preview.diff2': diff2,
-  'Preview.executeCallback': executeCallback,
-  'Preview.getCommandIds': getCommandIds,
-  'Preview.handleClick': wrapCommand(handleClick),
-  'Preview.handleFileEdited': wrapCommand(handleFileEdited),
-  'Preview.handleInput': wrapCommand(handleInput),
-  'Preview.handleKeyDown': wrapCommand(handleKeydown),
-  'Preview.handleKeyUp': wrapCommand(handleKeyup),
-  'Preview.handleMousedown': wrapCommand(handleMousedown),
-  'Preview.handleMousemove': wrapCommand(handleMousemove),
-  'Preview.handleMouseup': wrapCommand(handleMouseup),
-  'Preview.handleMutation': wrapCommand(handleMutation),
-  'Preview.loadContent': wrapCommand(loadContent),
-  'Preview.render2': render2,
-  'Preview.renderEventListeners': renderEventListeners,
-  'Preview.rerender': wrapCommand(rerender),
-  'Preview.resize': wrapCommand(resize),
-  'Preview.saveState': wrapGetter(saveState),
-  'Preview.setUri': wrapCommand(setUri),
-  'Preview.terminate': terminate,
-  'Preview.triggerRerender': wrapCommand(triggerRerender),
-  'Preview.waitForClick': wrapCommand(waitForClick),
-  'Preview.waitForMutation': wrapCommand(waitForMutation)
-};
-
-const listen = async () => {
-  registerCommands(commandMap);
-  const rpc = await create$3({
-    commandMap: commandMap
-  });
-  set$1(rpc);
-  const editorRpc = await create$4({
-    commandMap: {},
-    send: port => sendMessagePortToEditorWorker(port, 9112)
-  });
-  set$2(editorRpc);
-};
-
-const main = async () => {
-  await listen();
-};
-
-main();