@simon_he/vue-tui 1.1.3 → 1.1.5

package/dist/mermaid.cjs

@@ -28,11 +28,22 @@ __export(mermaid_exports, {
   TBeautifulMermaid: () => TBeautifulMermaid,
   TBeautifulMermaidText: () => TBeautifulMermaidText,
   TMermaid: () => TMermaid,
+  TMermaidImage: () => TMermaidImage,
   TMermaidText: () => TMermaidText2,
   beautifulMermaidRenderer: () => beautifulMermaidRenderer,
+  clearMermaidImageCache: () => clearMermaidImageCache,
   createBeautifulMermaidRenderer: () => createBeautifulMermaidRenderer,
+  getCachedMermaidImage: () => getCachedMermaidImage,
+  getMermaidImage: () => getMermaidImage,
+  isMermaidImageRendererReady: () => isMermaidImageRendererReady,
   isSimpleMermaidFlowchartSource: () => isSimpleMermaidFlowchartSource,
-  markMermaidRenderErrorFatal: () => markMermaidRenderErrorFatal
+  loadMermaidImageRenderer: () => loadMermaidImageRenderer,
+  markMermaidRenderErrorFatal: () => markMermaidRenderErrorFatal,
+  normalizeMermaidImageOptions: () => normalizeMermaidImageOptions,
+  resolveMermaidImageColor: () => resolveMermaidImageColor,
+  resolveMermaidSvgForResvg: () => resolveMermaidSvgForResvg,
+  setMermaidImageRasterizer: () => setMermaidImageRasterizer,
+  subscribeMermaidImage: () => subscribeMermaidImage
 });
 module.exports = __toCommonJS(mermaid_exports);
 
@@ -1385,8 +1396,8 @@ var tMermaidTextProps = {
       return snapshot && snapshot.source === source.value && hasVisibleRenderedOutput(snapshot.lines) ? snapshot.lines : sourceLines.value;
     }), currentStyle = (0, import_vue8.computed)(() => props.style ?? defaultStyle.value), fullHeight = (0, import_vue8.computed)(() => {
       if (props.h != null) {
-        let h3 = Math.floor(Number(props.h));
-        return Number.isFinite(h3) ? Math.max(0, h3) : 0;
+        let h4 = Math.floor(Number(props.h));
+        return Number.isFinite(h4) ? Math.max(0, h4) : 0;
       }
       let autoContentHeight = Math.max(1, displayLines.value.length);
       return reservesBoxRows.value ? autoContentHeight + 2 : autoContentHeight;
@@ -1587,7 +1598,1427 @@ var tMermaidTextProps = {
 });
 
 // src/vue/mermaid/beautiful-mermaid.ts
+var import_vue10 = require("vue");
+
+// src/vue/components/TMermaidImage.ts
 var import_vue9 = require("vue");
+
+// src/core/terminal/create-terminal.ts
+var TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals"), TERMINAL_ROOT = Symbol.for("@simon_he/vue-tui:v1:terminal-root");
+function getRootTerminal(terminal) {
+  return terminal[TERMINAL_ROOT] ?? terminal;
+}
+
+// src/renderer/terminal-graphics.ts
+var ESC2 = "\x1B", BEL2 = "\x07", ST = `${ESC2}\\`, ESC_RE = "\\u001B", BEL_RE = "\\u0007", CSI_RE = new RegExp(`${ESC_RE}\\[[0-?]*[ -/]*[@-~]`, "g"), OSC_RE = new RegExp(`${ESC_RE}\\][\\s\\S]*?(?:${BEL_RE}|${ESC_RE}\\\\)`, "g"), DCS_RE = new RegExp(`${ESC_RE}P[\\s\\S]*?${ESC_RE}\\\\`, "g"), APC_RE = new RegExp(`${ESC_RE}_[\\s\\S]*?${ESC_RE}\\\\`, "g"), C1_CSI_RE = new RegExp("\\u009B[0-?]*[ -/]*[@-~]", "g"), C1_OSC_RE = new RegExp(`\\u009D[\\s\\S]*?(?:${BEL_RE}|\\u009C)`, "g"), C1_DCS_RE = new RegExp("\\u0090[\\s\\S]*?\\u009C", "g"), C1_APC_RE = new RegExp("\\u009F[\\s\\S]*?\\u009C", "g"), MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS = 16 * 1024 * 1024;
+var MAX_TERMINAL_GRAPHIC_CELLS = 1e4, TERMINAL_GRAPHICS_REGISTRY = Symbol.for("@simon_he/vue-tui:v1:terminal-graphics"), terminalGraphicsGlobal = globalThis, terminalGraphicsRegistry = terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] ?? {
+  outputs: /* @__PURE__ */ new WeakMap(),
+  outputVersions: /* @__PURE__ */ new WeakMap(),
+  outputListeners: /* @__PURE__ */ new WeakMap()
+};
+terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] = terminalGraphicsRegistry;
+var terminalGraphicsOutputs = terminalGraphicsRegistry.outputs, terminalGraphicsOutputVersions = terminalGraphicsRegistry.outputVersions, terminalGraphicsOutputListeners = terminalGraphicsRegistry.outputListeners;
+function getTerminalGraphicsOutput(terminal) {
+  return terminalGraphicsOutputs.get(getRootTerminal(terminal)) ?? null;
+}
+function getTerminalGraphicsOutputVersion(terminal) {
+  return terminalGraphicsOutputVersions.get(getRootTerminal(terminal)) ?? 0;
+}
+function subscribeTerminalGraphicsOutput(terminal, listener) {
+  let rootTerminal = getRootTerminal(terminal), listeners = terminalGraphicsOutputListeners.get(rootTerminal);
+  return listeners || (listeners = /* @__PURE__ */ new Set(), terminalGraphicsOutputListeners.set(rootTerminal, listeners)), listeners.add(listener), () => {
+    listeners.delete(listener), listeners.size === 0 && terminalGraphicsOutputListeners.delete(rootTerminal);
+  };
+}
+function stableTerminalGraphicNumericId(input, options = {}) {
+  let min = Math.floor(options.min ?? 1), max = Math.floor(options.max ?? 2147483647), span = Math.max(1, max - min + 1), hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1)
+    hash ^= input.charCodeAt(index), hash = Math.imul(hash, 16777619);
+  return min + (hash >>> 0) % span;
+}
+function positiveGraphicInt(value, max) {
+  let n = Math.trunc(Number(value));
+  return !Number.isFinite(n) || n <= 0 ? null : Math.min(max, n);
+}
+function normalizeTerminalGraphicSize(width, height) {
+  let w = positiveGraphicInt(width, MAX_TERMINAL_GRAPHIC_CELLS), h4 = positiveGraphicInt(height, MAX_TERMINAL_GRAPHIC_CELLS);
+  return w == null || h4 == null || w * h4 > MAX_TERMINAL_GRAPHIC_CELLS ? null : { width: w, height: h4 };
+}
+function isBase64ish(value) {
+  return /^[A-Za-z0-9+/=]*$/.test(value);
+}
+var KITTY_UINT32_MAX = 4294967295, KITTY_INT32_MIN = -2147483648, KITTY_INT32_MAX = 2147483647;
+function validateIterm2Dimension(value) {
+  return /^auto$/i.test(value) || /^(?:[1-9]\d{0,4})(?:px|%)?$/.test(value);
+}
+function uint32Control(key, value, min = 0) {
+  if (value == null)
+    return "";
+  let n = Math.floor(value);
+  return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX ? `${key}=${n}` : "";
+}
+function int32Control(key, value) {
+  if (value == null)
+    return "";
+  let n = Math.floor(value);
+  return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX ? `${key}=${n}` : "";
+}
+function sanitizeBase64(value) {
+  let data = String(value ?? "").replace(/\s+/g, "");
+  return isBase64ish(data) ? data : "";
+}
+function kittyGraphicCellControls(columns, rows) {
+  if (columns == null && rows == null)
+    return [];
+  let size = normalizeTerminalGraphicSize(columns ?? 1, rows ?? 1);
+  return size ? [columns == null ? "" : `c=${size.width}`, rows == null ? "" : `r=${size.height}`] : [];
+}
+function kittyGraphicSourceControls(sourceX, sourceY, sourceWidth, sourceHeight) {
+  return [
+    uint32Control("x", sourceX),
+    uint32Control("y", sourceY),
+    uint32Control("w", sourceWidth, 1),
+    uint32Control("h", sourceHeight, 1)
+  ];
+}
+function chunkBase64(value, chunkSize) {
+  let normalizedSize = Math.max(4, Math.floor(chunkSize / 4) * 4), chunks = [];
+  for (let index = 0; index < value.length; index += normalizedSize)
+    chunks.push(value.slice(index, index + normalizedSize));
+  return chunks.length ? chunks : [""];
+}
+function createKittyPlacementSequence(options) {
+  let imageId = uint32Control("i", options.imageId), imageNumber = uint32Control("I", options.imageNumber);
+  if (!imageId && !imageNumber)
+    return "";
+  let controls = [
+    "a=p",
+    options.quiet === !1 ? "" : "q=2",
+    options.noCursorMove === !1 ? "" : "C=1",
+    imageId,
+    imageNumber,
+    uint32Control("p", options.placementId),
+    ...kittyGraphicCellControls(options.columns, options.rows),
+    ...kittyGraphicSourceControls(
+      options.sourceX,
+      options.sourceY,
+      options.sourceWidth,
+      options.sourceHeight
+    ),
+    int32Control("z", options.zIndex)
+  ].filter(Boolean);
+  return `${ESC2}_G${controls.join(",")}${ST}`;
+}
+function createKittyGraphicsSequence(base64Png, options = {}) {
+  let data = sanitizeBase64(base64Png);
+  if (!data)
+    return "";
+  let chunks = chunkBase64(data, options.chunkSize ?? 4096), baseControls = [
+    "a=T",
+    "f=100",
+    options.quiet === !1 ? "" : "q=2",
+    options.noCursorMove === !1 ? "" : "C=1",
+    uint32Control("i", options.imageId),
+    uint32Control("I", options.imageNumber),
+    uint32Control("p", options.placementId),
+    ...kittyGraphicCellControls(options.columns, options.rows),
+    ...kittyGraphicSourceControls(
+      options.sourceX,
+      options.sourceY,
+      options.sourceWidth,
+      options.sourceHeight
+    ),
+    int32Control("z", options.zIndex)
+  ].filter(Boolean);
+  return chunks.map((chunk, index) => {
+    let last = index === chunks.length - 1, controls = index === 0 ? [...baseControls, chunks.length > 1 ? `m=${last ? 0 : 1}` : ""] : [options.quiet === !1 ? "" : "q=2", `m=${last ? 0 : 1}`].filter(Boolean);
+    return `${ESC2}_G${controls.filter(Boolean).join(",")};${chunk}${ST}`;
+  }).join("");
+}
+function createKittyDeleteGraphicsSequence(options = {}) {
+  let controls = ["a=d"];
+  if (options.allVisible)
+    controls.push(`d=${options.freeImageData ? "A" : "a"}`);
+  else if (options.imageId != null) {
+    let imageId = uint32Control("i", options.imageId), placementId = uint32Control("p", options.placementId);
+    if (!imageId || options.placementId != null && !placementId)
+      return "";
+    controls.push(`d=${options.freeImageData ? "I" : "i"}`), controls.push(imageId), controls.push(placementId);
+  } else if (options.currentCell)
+    controls.push(`d=${options.freeImageData ? "C" : "c"}`);
+  else
+    return "";
+  return options.quiet !== !1 && controls.push("q=2"), `${ESC2}_G${controls.filter(Boolean).join(",")}${ST}`;
+}
+function createIterm2InlineImageSequence(base64Data, options = {}) {
+  let data = sanitizeBase64(base64Data);
+  if (!data)
+    return "";
+  let params = [
+    "inline=1",
+    options.width != null ? `width=${formatItermDimension(options.width)}` : "",
+    options.height != null ? `height=${formatItermDimension(options.height)}` : "",
+    `preserveAspectRatio=${options.preserveAspectRatio === !1 ? 0 : 1}`,
+    options.doNotMoveCursor === !1 ? "" : "doNotMoveCursor=1"
+  ].filter(Boolean);
+  return `${ESC2}]1337;File=${params.join(";")}:${data}${BEL2}`;
+}
+function formatItermDimension(value) {
+  if (typeof value == "number") {
+    let n = Math.floor(value);
+    return Number.isFinite(n) ? String(Math.min(99999, Math.max(1, n))) : "auto";
+  }
+  let raw = String(value ?? "").trim();
+  return validateIterm2Dimension(raw) ? raw : "auto";
+}
+function resolveKittyPngSourceCrop(rect, fullRect, sourceWidth, sourceHeight) {
+  if (fullRect.w <= 0 || fullRect.h <= 0)
+    return null;
+  let offsetX = Math.max(0, rect.x - fullRect.x), offsetY = Math.max(0, rect.y - fullRect.y), visibleW = Math.max(0, Math.min(rect.w, fullRect.w - offsetX)), visibleH = Math.max(0, Math.min(rect.h, fullRect.h - offsetY));
+  if (offsetX <= 0 && offsetY <= 0 && visibleW >= fullRect.w && visibleH >= fullRect.h)
+    return null;
+  let sourceX = Math.max(
+    0,
+    Math.min(sourceWidth - 1, Math.floor(offsetX * sourceWidth / fullRect.w))
+  ), sourceY = Math.max(
+    0,
+    Math.min(sourceHeight - 1, Math.floor(offsetY * sourceHeight / fullRect.h))
+  ), sourceRight = Math.max(
+    sourceX + 1,
+    Math.min(sourceWidth, Math.ceil((offsetX + visibleW) * sourceWidth / fullRect.w))
+  ), sourceBottom = Math.max(
+    sourceY + 1,
+    Math.min(sourceHeight, Math.ceil((offsetY + visibleH) * sourceHeight / fullRect.h))
+  );
+  return {
+    sourceX,
+    sourceY,
+    sourceWidth: sourceRight - sourceX,
+    sourceHeight: sourceBottom - sourceY
+  };
+}
+function createTerminalGraphicPngSequence(options) {
+  if (options.protocol === "kitty") {
+    let placement = {
+      columns: options.placementColumns,
+      rows: options.placementRows
+    };
+    if (options.rect && options.fullRect && options.sourceWidth && options.sourceHeight) {
+      let crop = resolveKittyPngSourceCrop(
+        options.rect,
+        options.fullRect,
+        options.sourceWidth,
+        options.sourceHeight
+      );
+      crop && (placement = { ...placement, ...crop });
+    }
+    let transmissionPlacement = options.cropTransmission !== !1 ? placement : {
+      columns: options.transmissionColumns ?? options.placementColumns,
+      rows: options.transmissionRows ?? options.placementRows
+    };
+    return {
+      type: "sequence",
+      protocol: "kitty",
+      sequence: createKittyGraphicsSequence(options.base64, {
+        imageId: options.imageId,
+        placementId: options.placementId,
+        zIndex: options.zIndex,
+        ...transmissionPlacement
+      }),
+      resizeSequence: createKittyPlacementSequence({
+        imageId: options.imageId,
+        placementId: options.placementId,
+        zIndex: options.zIndex,
+        ...placement
+      }),
+      clearSequence: createKittyDeleteGraphicsSequence({
+        imageId: options.imageId,
+        placementId: options.placementId,
+        freeImageData: options.freeImageData
+      }),
+      ...options.fallback != null ? { fallback: options.fallback } : {},
+      ...options.cols != null ? { cols: options.cols } : {},
+      ...options.rows != null ? { rows: options.rows } : {},
+      ...options.sourceWidth != null ? { sourceWidth: options.sourceWidth } : {},
+      ...options.sourceHeight != null ? { sourceHeight: options.sourceHeight } : {},
+      ...options.zIndex != null ? { zIndex: options.zIndex } : {}
+    };
+  }
+  return options.protocol === "iterm2" ? {
+    type: "sequence",
+    protocol: "iterm2",
+    sequence: createIterm2InlineImageSequence(options.base64, {
+      width: options.cols,
+      height: options.rows,
+      preserveAspectRatio: !0,
+      doNotMoveCursor: !0
+    }),
+    ...options.fallback != null ? { fallback: options.fallback } : {},
+    ...options.cols != null ? { cols: options.cols } : {},
+    ...options.rows != null ? { rows: options.rows } : {},
+    ...options.sourceWidth != null ? { sourceWidth: options.sourceWidth } : {},
+    ...options.sourceHeight != null ? { sourceHeight: options.sourceHeight } : {}
+  } : null;
+}
+
+// src/vue/markdown/math-image.ts
+var DEFAULT_MATH_IMAGE_OPTIONS = Object.freeze({
+  cellWidthPx: 8,
+  cellHeightPx: 16,
+  scale: 2,
+  color: "#f8f8f2",
+  maxWidthCells: 0,
+  baselineRatio: 0.78
+});
+var NAMED_STYLE_FG_HEX = Object.freeze({
+  black: "#000000",
+  red: "#e53935",
+  green: "#43a047",
+  yellow: "#fdd835",
+  blue: "#1e88e5",
+  magenta: "#d81b60",
+  cyan: "#00acc1",
+  white: "#ffffff",
+  gray: "#9e9e9e",
+  grey: "#9e9e9e",
+  blackBright: "#4a4a4a",
+  redBright: "#ff6e6e",
+  greenBright: "#69db7c",
+  yellowBright: "#ffe066",
+  blueBright: "#74c0fc",
+  magentaBright: "#f783ac",
+  cyanBright: "#3bc9db",
+  whiteBright: "#f8f8f2",
+  grayBright: "#bdbdbd",
+  greyBright: "#bdbdbd"
+});
+function resolveMarkdownMathColor(fg) {
+  if (typeof fg != "string" || !fg)
+    return;
+  let trimmed = fg.trim();
+  return trimmed.startsWith("#") && /^#[0-9a-f]{3,8}$/i.test(trimmed) ? trimmed.toLowerCase() : NAMED_STYLE_FG_HEX[trimmed.toLowerCase()];
+}
+
+// src/vue/mermaid/mermaid-image.ts
+var DEFAULT_MERMAID_IMAGE_OPTIONS = Object.freeze({
+  cellWidthPx: 8,
+  cellHeightPx: 16,
+  scale: 2,
+  bg: "#1e1e2e",
+  fg: "#f8f8f2",
+  maxWidthCells: 0,
+  maxHeightCells: 0,
+  padding: 40
+}), MAX_CACHE_ENTRIES = 48, MAX_FAILED_ENTRIES = 96, mermaidImageCache = /* @__PURE__ */ new Map(), mermaidImageFailed = /* @__PURE__ */ new Set(), mermaidImageInflight = /* @__PURE__ */ new Map(), mermaidImageListeners = /* @__PURE__ */ new Set(), customRasterizer = null, builtinRasterizerLoad = null, builtinRasterizerReady = !1;
+function normalizeMermaidImageOptions(options) {
+  return {
+    cellWidthPx: Math.max(
+      1,
+      Math.floor(options?.cellWidthPx ?? DEFAULT_MERMAID_IMAGE_OPTIONS.cellWidthPx)
+    ),
+    cellHeightPx: Math.max(
+      1,
+      Math.floor(options?.cellHeightPx ?? DEFAULT_MERMAID_IMAGE_OPTIONS.cellHeightPx)
+    ),
+    scale: Math.max(1, Math.floor(options?.scale ?? DEFAULT_MERMAID_IMAGE_OPTIONS.scale)),
+    bg: options?.bg ?? DEFAULT_MERMAID_IMAGE_OPTIONS.bg,
+    fg: options?.fg ?? DEFAULT_MERMAID_IMAGE_OPTIONS.fg,
+    maxWidthCells: Math.max(0, Math.floor(options?.maxWidthCells ?? 0)),
+    maxHeightCells: Math.max(0, Math.floor(options?.maxHeightCells ?? 0)),
+    padding: Math.max(0, Math.floor(options?.padding ?? DEFAULT_MERMAID_IMAGE_OPTIONS.padding))
+  };
+}
+function resolveMermaidImageColor(fg) {
+  return resolveMarkdownMathColor(fg);
+}
+function setMermaidImageRasterizer(rasterizer) {
+  customRasterizer = rasterizer;
+}
+function subscribeMermaidImage(listener) {
+  return mermaidImageListeners.add(listener), () => mermaidImageListeners.delete(listener);
+}
+function isMermaidImageRendererReady() {
+  return customRasterizer != null || builtinRasterizerReady;
+}
+async function loadMermaidImageRenderer() {
+  return isMermaidImageRendererReady() ? !0 : (builtinRasterizerReady = (customRasterizer ?? await loadBuiltinMermaidRasterizer()) != null, builtinRasterizerReady);
+}
+function hashMermaidImageKey(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i++)
+    hash ^= value.charCodeAt(i), hash = Math.imul(hash, 16777619);
+  return (hash >>> 0).toString(36);
+}
+function mermaidImageCacheKey(code, options) {
+  return hashMermaidImageKey(
+    [
+      code,
+      options.cellWidthPx,
+      options.cellHeightPx,
+      options.scale,
+      options.bg,
+      options.fg,
+      options.maxWidthCells,
+      options.maxHeightCells,
+      options.padding
+    ].join("")
+  );
+}
+function notifyMermaidImageListeners() {
+  for (let listener of mermaidImageListeners)
+    try {
+      listener();
+    } catch {
+    }
+}
+function getCachedMermaidImage(code, options) {
+  return mermaidImageCache.get(mermaidImageCacheKey(code, normalizeMermaidImageOptions(options))) ?? null;
+}
+function clearMermaidImageCache() {
+  mermaidImageCache.clear(), mermaidImageFailed.clear();
+}
+function evictOldestMermaidImageEntry() {
+  let oldest = mermaidImageCache.keys().next().value;
+  oldest != null && mermaidImageCache.delete(oldest);
+}
+async function getMermaidImage(code, options) {
+  let source = String(code ?? "").trim();
+  if (!source)
+    return null;
+  let normalized = normalizeMermaidImageOptions(options), key = mermaidImageCacheKey(source, normalized), cached = mermaidImageCache.get(key);
+  if (cached)
+    return cached;
+  if (mermaidImageFailed.has(key))
+    return null;
+  let inflight = mermaidImageInflight.get(key);
+  if (inflight)
+    return inflight;
+  let pending = (async () => {
+    try {
+      let rasterizer = customRasterizer ?? await loadBuiltinMermaidRasterizer();
+      if (!rasterizer)
+        return null;
+      let result = await rasterizer(source, normalized);
+      if (result && result.base64)
+        mermaidImageCache.set(key, result), mermaidImageCache.size > MAX_CACHE_ENTRIES && evictOldestMermaidImageEntry(), notifyMermaidImageListeners();
+      else if (result === null && (mermaidImageFailed.add(key), mermaidImageFailed.size > MAX_FAILED_ENTRIES)) {
+        let oldest = mermaidImageFailed.values().next().value;
+        oldest != null && mermaidImageFailed.delete(oldest);
+      }
+      return result;
+    } catch {
+      return null;
+    } finally {
+      mermaidImageInflight.delete(key);
+    }
+  })();
+  return mermaidImageInflight.set(key, pending), pending;
+}
+function base64FromBytes(bytes) {
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += 32768)
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+  return typeof btoa == "function" ? btoa(binary) : Buffer.from(bytes).toString("base64");
+}
+function positiveInt(value) {
+  let n = Math.floor(Number(value));
+  return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function clampCellsToLimits(widthCells, heightCells, maxWidthCells, maxHeightCells) {
+  let w = widthCells, h4 = heightCells;
+  return maxWidthCells > 0 && w > maxWidthCells && (h4 = Math.max(1, Math.round(h4 * maxWidthCells / w)), w = maxWidthCells), maxHeightCells > 0 && h4 > maxHeightCells && (w = Math.max(1, Math.round(w * maxHeightCells / h4)), h4 = maxHeightCells), { widthCells: Math.max(1, w), heightCells: Math.max(1, h4) };
+}
+var RESVG_MODULE_ID = "@resvg/resvg-js";
+function svgRenderFunction(mod) {
+  let candidates = [
+    mod.renderMermaidSVGAsync,
+    mod.renderMermaidSVG,
+    mod.renderMermaid,
+    mod.default?.renderMermaidSVGAsync,
+    mod.default?.renderMermaidSVG
+  ];
+  for (let candidate of candidates)
+    if (typeof candidate == "function")
+      return candidate;
+  return null;
+}
+function resolveMermaidSvgForResvg(svg, fallbackBg, fallbackFg) {
+  let { bg, fg } = extractSvgRootStyleColors(svg, fallbackBg, fallbackFg), variables = extractSvgCssVariables(svg), root = { bg, fg }, resolved = svg, guard = 0;
+  for (; (resolved.includes("var(") || resolved.includes("color-mix(")) && guard++ < 500; ) {
+    let varIndex = resolved.lastIndexOf("var("), mixIndex = resolved.lastIndexOf("color-mix("), at = Math.max(varIndex, mixIndex);
+    if (at < 0)
+      break;
+    let open = resolved.indexOf("(", at), close = findMatchingSvgParen(resolved, open);
+    if (open < 0 || close < 0)
+      break;
+    let expr = resolved.slice(at, close + 1), color = resolveSvgColorExpr(expr, root, variables);
+    resolved = resolved.slice(0, at) + color + resolved.slice(close + 1);
+  }
+  return stripSvgStyleBlocks(resolved);
+}
+function extractSvgRootStyleColors(svg, fallbackBg, fallbackFg) {
+  let bg = fallbackBg, fg = fallbackFg, styleMatch = /<svg\b[^>]*\bstyle="([^"]*)"/i.exec(svg);
+  if (styleMatch?.[1]) {
+    let bgMatch = /(?:^|;)\s*--bg\s*:\s*([^;]+)/i.exec(styleMatch[1]), fgMatch = /(?:^|;)\s*--fg\s*:\s*([^;]+)/i.exec(styleMatch[1]);
+    bgMatch?.[1] && (bg = bgMatch[1].trim()), fgMatch?.[1] && (fg = fgMatch[1].trim());
+  }
+  return { bg, fg };
+}
+function extractSvgCssVariables(svg) {
+  let map = /* @__PURE__ */ new Map(), styleMatch = /<style[^>]*>([\s\S]*?)<\/style>/i.exec(svg);
+  if (!styleMatch?.[1])
+    return map;
+  let declaration = /(--[A-Za-z0-9_-]+)\s*:\s*([^;{}]+);/g, match;
+  for (; (match = declaration.exec(styleMatch[1])) !== null; )
+    map.set(match[1], match[2].trim());
+  return map;
+}
+function stripSvgStyleBlocks(svg) {
+  return svg.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+}
+function findMatchingSvgParen(input, openIndex) {
+  let depth = 0;
+  for (let i = openIndex; i < input.length; i++) {
+    let ch = input[i];
+    if (ch === "(")
+      depth++;
+    else if (ch === ")" && (depth--, depth === 0))
+      return i;
+  }
+  return -1;
+}
+function findTopLevelSvgComma(input) {
+  let depth = 0;
+  for (let i = 0; i < input.length; i++) {
+    let ch = input[i];
+    if (ch === "(")
+      depth++;
+    else if (ch === ")")
+      depth--;
+    else if (ch === "," && depth === 0)
+      return i;
+  }
+  return -1;
+}
+function normalizeHexColor(value) {
+  let match = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(value.trim());
+  if (!match)
+    return null;
+  let hex = match[1];
+  return hex.length === 3 && (hex = hex.split("").map((ch) => ch + ch).join("")), `#${hex.toLowerCase()}`;
+}
+function mixSrgbColors(aHex, bHex, percent) {
+  let a = parseHexRgb(aHex), b = parseHexRgb(bHex), p = Math.max(0, Math.min(100, percent)) / 100, mix = (x, y) => Math.round(x * p + y * (1 - p)), toHex = (value) => value.toString(16).padStart(2, "0");
+  return `#${toHex(mix(a[0], b[0]))}${toHex(mix(a[1], b[1]))}${toHex(mix(a[2], b[2]))}`;
+}
+function parseHexRgb(hex) {
+  return [
+    parseInt(hex.slice(1, 3), 16),
+    parseInt(hex.slice(3, 5), 16),
+    parseInt(hex.slice(5, 7), 16)
+  ];
+}
+function resolveSvgColorExpr(expr, root, variables) {
+  let value = expr.trim();
+  if (value.startsWith("var(")) {
+    let close = findMatchingSvgParen(value, 3);
+    if (close < 0)
+      return value;
+    let inner = value.slice(4, close).trim(), comma = findTopLevelSvgComma(inner), name = (comma < 0 ? inner : inner.slice(0, comma)).trim(), fallback = comma < 0 ? "" : inner.slice(comma + 1).trim(), direct = name === "--fg" ? root.fg : name === "--bg" ? root.bg : variables.get(name);
+    return direct != null ? resolveSvgColorExpr(direct, root, variables) : fallback ? resolveSvgColorExpr(fallback, root, variables) : value;
+  }
+  if (value.startsWith("color-mix(")) {
+    let close = findMatchingSvgParen(value, 9);
+    if (close < 0)
+      return value;
+    let afterMethod = value.slice(10, close).trim().replace(/^in\s+srgb\s*,\s*/i, ""), comma = findTopLevelSvgComma(afterMethod);
+    if (comma < 0)
+      return value;
+    let left = afterMethod.slice(0, comma).trim(), right = afterMethod.slice(comma + 1).trim(), leftMatch = /^([^%\s]+)\s+([\d.]+)%$/.exec(left) ?? /^([\d.]+)%\s+([^%\s]+)$/.exec(left);
+    if (!leftMatch)
+      return value;
+    let a = normalizeHexColor(resolveSvgColorExpr(leftMatch[1], root, variables)), b = normalizeHexColor(resolveSvgColorExpr(right, root, variables));
+    return !a || !b ? value : mixSrgbColors(a, b, Number(leftMatch[2]));
+  }
+  return normalizeHexColor(value) ?? value;
+}
+function loadBuiltinMermaidRasterizer() {
+  return builtinRasterizerLoad || (builtinRasterizerLoad = (async () => {
+    try {
+      let [mermaidMod, resvgMod] = await Promise.all([
+        import("beautiful-mermaid").then(
+          (mod) => mod,
+          () => null
+        ),
+        import(RESVG_MODULE_ID).then(
+          (mod) => mod,
+          () => null
+        )
+      ]), renderSvg = svgRenderFunction(mermaidMod ?? {}), Resvg = resvgMod?.Resvg;
+      return !renderSvg || typeof Resvg != "function" ? null : async (code, options) => {
+        let svg = await renderSvg(code, {
+          bg: options.bg,
+          fg: options.fg,
+          padding: options.padding,
+          transparent: !0
+        }), svgText = String(svg ?? "");
+        if (!svgText.includes("<svg"))
+          return null;
+        let resolvedSvg = resolveMermaidSvgForResvg(svgText, options.bg, options.fg), rendered = new Resvg(resolvedSvg, {
+          background: "rgba(0,0,0,0)"
+        }).render(), naturalWidth = positiveInt(rendered?.width), naturalHeight = positiveInt(rendered?.height), png = typeof rendered?.asPng == "function" ? rendered.asPng() : void 0;
+        if (!png || png.length < 8 || naturalWidth == null || naturalHeight == null)
+          return null;
+        let rawWidthCells = Math.max(
+          1,
+          Math.round(naturalWidth / (options.cellWidthPx * options.scale))
+        ), rawHeightCells = Math.max(
+          1,
+          Math.round(naturalHeight / (options.cellHeightPx * options.scale))
+        ), { widthCells, heightCells } = clampCellsToLimits(
+          rawWidthCells,
+          rawHeightCells,
+          options.maxWidthCells,
+          options.maxHeightCells
+        );
+        return {
+          base64: base64FromBytes(png),
+          widthCells,
+          heightCells,
+          naturalWidth,
+          naturalHeight
+        };
+      };
+    } catch {
+      return null;
+    }
+  })()), builtinRasterizerLoad;
+}
+
+// src/vue/components/TMermaidImage.ts
+var UNICODE_MERMAID_IMAGE_BOX_CHARS = Object.freeze({
+  tl: "\u250C",
+  tr: "\u2510",
+  bl: "\u2514",
+  br: "\u2518",
+  h: "\u2500",
+  v: "\u2502"
+}), ASCII_MERMAID_IMAGE_BOX_CHARS = Object.freeze({
+  tl: "+",
+  tr: "+",
+  bl: "+",
+  br: "+",
+  h: "-",
+  v: "|"
+}), DEFAULT_MERMAID_IMAGE_COPIED_DURATION_MS = 1200, DEFAULT_MERMAID_IMAGE_MAX_RENDER_SOURCE_CHARS = 2e4, DEFAULT_MERMAID_IMAGE_MAX_RENDER_SOURCE_LINES = 400, ESC3 = "\x1B", BEL3 = "\x07", TERMINAL_ESCAPE_RE2 = new RegExp(
+  [
+    `${ESC3}\\][\\s\\S]*?(?:${BEL3}|${ESC3}\\\\)`,
+    `${ESC3}[PX^_][\\s\\S]*?${ESC3}\\\\`,
+    `${ESC3}\\[[0-?]*[ -/]*[@-~]`,
+    `${ESC3}[@-Z\\\\-_]`
+  ].join("|"),
+  "g"
+);
+function stripTerminalEscapes2(value) {
+  return value.replace(TERMINAL_ESCAPE_RE2, "");
+}
+function normalizeNonNegativeInt2(value, fallback) {
+  let n = Number(value);
+  return Number.isFinite(n) ? Math.max(0, Math.floor(n)) : fallback;
+}
+function countLinesUpTo2(value, max) {
+  if (max <= 0)
+    return 0;
+  let lines = 1;
+  for (let index = 0; index < value.length; index++) {
+    let code = value.charCodeAt(index);
+    if (!(code !== 10 && code !== 13) && (lines++, code === 13 && value.charCodeAt(index + 1) === 10 && index++, lines > max))
+      return lines;
+  }
+  return lines;
+}
+function splitRenderedOutput2(value) {
+  let lines = sanitizeTextBlock(
+    stripTerminalEscapes2(String(value ?? "")).replace(/\r\n?/g, `
+`)
+  ).split(`
+`);
+  return lines.length ? lines : [""];
+}
+function fitImageCells(cells, maxW, maxH) {
+  if (maxW <= 0 || maxH <= 0)
+    return null;
+  let w = Math.max(1, Math.floor(cells.widthCells)), h4 = Math.max(1, Math.floor(cells.heightCells));
+  return w > maxW && (h4 = Math.max(1, Math.round(h4 * maxW / w)), w = maxW), h4 > maxH && (w = Math.max(1, Math.round(w * maxH / h4)), h4 = maxH), { displayW: Math.max(1, w), displayH: Math.max(1, h4) };
+}
+var tMermaidImageProps = {
+  x: { type: Number, required: !0 },
+  y: { type: Number, required: !0 },
+  w: { type: Number, required: !0 },
+  h: { type: Number, default: void 0 },
+  zIndex: { type: Number, default: 0 },
+  content: { type: String, default: "" },
+  code: { type: String, default: void 0 },
+  style: { type: Object, default: void 0 },
+  clear: { type: Boolean, default: !0 },
+  final: { type: Boolean, default: !0 },
+  streaming: { type: Boolean, default: !1 },
+  // Image pipeline. Without a renderer the built-in lazy rasterizer
+  // (beautiful-mermaid SVG + @resvg/resvg-js) is used; when graphics are
+  // unsupported or the rasterizer is missing, the raw source is shown.
+  renderer: {
+    type: Function,
+    default: void 0
+  },
+  cellWidthPx: { type: Number, default: void 0 },
+  cellHeightPx: { type: Number, default: void 0 },
+  scale: { type: Number, default: void 0 },
+  bg: { type: String, default: void 0 },
+  fg: { type: String, default: void 0 },
+  maxWidthCells: { type: Number, default: void 0 },
+  maxHeightCells: { type: Number, default: void 0 },
+  padding: { type: Number, default: void 0 },
+  // Adaptive ANSI fallback. When the terminal has no graphics protocol (or the
+  // image rasterizer fails for this source), the component renders the diagram
+  // as ASCII text through a text renderer before falling back to the raw
+  // source. Without a textRenderer the component stays image-or-raw.
+  textRenderer: {
+    type: Function,
+    default: void 0
+  },
+  // Eligibility guard for the ANSI fallback; returning false keeps the raw
+  // source visible (e.g. only render simple flowcharts as ASCII).
+  shouldRenderSource: {
+    type: Function,
+    default: void 0
+  },
+  // Spacing/theme options forwarded to the ANSI text renderer.
+  textOptions: {
+    type: Object,
+    default: void 0
+  },
+  // Box chrome (mirrors TMermaidText).
+  box: { type: Boolean, default: !0 },
+  title: { type: String, default: "mermaid" },
+  copyButton: { type: Boolean, default: !0 },
+  copyText: { type: String, default: "copy" },
+  copiedText: { type: String, default: "copied" },
+  copiedDurationMs: { type: Number, default: DEFAULT_MERMAID_IMAGE_COPIED_DURATION_MS },
+  renderTimeoutMs: { type: Number, default: 0 },
+  maxRenderSourceChars: { type: Number, default: DEFAULT_MERMAID_IMAGE_MAX_RENDER_SOURCE_CHARS },
+  maxRenderSourceLines: { type: Number, default: DEFAULT_MERMAID_IMAGE_MAX_RENDER_SOURCE_LINES },
+  // Clicking the diagram (or the copy button) copies the full raw mermaid source.
+  copyOnClick: { type: Boolean, default: !0 },
+  ascii: { type: Boolean, default: !1 },
+  // Wheel zoom (Kitty graphics only): with the zoom modifier held, wheel over
+  // the image zooms centered on the mouse, clamped to the container area.
+  // Without the modifier the wheel passes through to the surrounding scroll
+  // container (historical-message scrolling is never blocked). iTerm2 has no
+  // in-place resize sequence, so zoom stays disabled there.
+  zoomOnWheel: { type: Boolean, default: !0 },
+  zoomModifier: {
+    type: String,
+    default: "metaCtrl"
+  },
+  minZoom: { type: Number, default: 1 },
+  maxZoom: { type: Number, default: 6 },
+  zoomSensitivity: { type: Number, default: 2e-3 }
+}, TMermaidImage = (0, import_vue9.defineComponent)({
+  name: "TMermaidImage",
+  props: tMermaidImageProps,
+  emits: {
+    copy: (_payload) => !0
+  },
+  setup(props, { emit }) {
+    let instance = (0, import_vue9.getCurrentInstance)(), terminalContext = useTerminal(), { terminal, defaultStyle, scheduler, widthProvider } = terminalContext, layout = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue9.inject)(EventZIndexContextKey, (0, import_vue9.computed)(() => 0)), imageCells = (0, import_vue9.shallowRef)(null), textSnapshot = (0, import_vue9.shallowRef)(null), zoomScale = (0, import_vue9.shallowRef)(1), panX = (0, import_vue9.shallowRef)(0), panY = (0, import_vue9.shallowRef)(0), documentVersion = (0, import_vue9.shallowRef)(0), copied = (0, import_vue9.shallowRef)(!1), dragState = null, dragMoved = !1, lastDragAt = 0, DRAG_CLICK_SUPPRESS_MS = 250, builtOnce = !1, renderVersion = 0, alive = !0, frameTaskId = `TMermaidImage:${instance?.uid ?? "unknown"}:mermaid-image`, uid = instance?.uid ?? 0, copiedTimer = null, copyRequestVersion = 0, activeGraphicId = null, activeImageSignature = "", source = (0, import_vue9.computed)(() => props.code ?? props.content ?? ""), waitingForStreamingSourceToFinish = (0, import_vue9.computed)(() => props.streaming && !props.final), graphicsOutputVersion = (0, import_vue9.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), graphicsOutput = (0, import_vue9.computed)(() => (graphicsOutputVersion.value, getTerminalGraphicsOutput(terminal))), graphicsProtocol = (0, import_vue9.computed)(() => {
+      let output = graphicsOutput.value;
+      if (!output?.capabilities.supported)
+        return null;
+      let protocol = output.capabilities.preferredProtocol;
+      return protocol === "kitty" || protocol === "iterm2" ? protocol : null;
+    });
+    function bump() {
+      documentVersion.value++;
+    }
+    function clearCopiedTimer() {
+      copiedTimer != null && (clearTimeout(copiedTimer), copiedTimer = null);
+    }
+    function setCopied(next, repaint = !0) {
+      next || clearCopiedTimer(), copied.value !== next && (copied.value = next, repaint && bump());
+    }
+    function resetCopyFeedback(repaint = !0) {
+      copyRequestVersion++, setCopied(!1, repaint);
+    }
+    function showCopiedFeedback() {
+      clearCopiedTimer();
+      let duration = normalizeNonNegativeInt2(
+        props.copiedDurationMs,
+        DEFAULT_MERMAID_IMAGE_COPIED_DURATION_MS
+      );
+      if (duration <= 0) {
+        setCopied(!1);
+        return;
+      }
+      setCopied(!0), copiedTimer = setTimeout(() => {
+        copiedTimer = null, alive && setCopied(!1);
+      }, duration);
+    }
+    function queueClearGraphic() {
+      if (activeGraphicId == null)
+        return;
+      let id = activeGraphicId;
+      activeGraphicId = null;
+      try {
+        graphicsOutput.value?.clear?.(id);
+      } catch {
+      }
+    }
+    function clampZoom(zoom) {
+      let min = Number.isFinite(Number(props.minZoom)) ? Math.max(0.05, Number(props.minZoom)) : 1, max = Number.isFinite(Number(props.maxZoom)) ? Math.max(min, Number(props.maxZoom)) : Math.max(min, 6);
+      return Math.min(max, Math.max(min, zoom));
+    }
+    function zoomSensitivity() {
+      let value = Number(props.zoomSensitivity);
+      return Number.isFinite(value) && value > 0 ? value : 2e-3;
+    }
+    function wheelZoomFactor(deltaY, deltaMode) {
+      let sign = deltaY > 0 ? -1 : 1, sensitivity = zoomSensitivity(), abs = Math.abs(deltaY), magnitude = (deltaMode ?? 0) === 1 || abs > 0 && abs <= 3 && Number.isInteger(deltaY) ? 100 : abs;
+      return Math.exp(sign * magnitude * sensitivity);
+    }
+    function resetZoomState() {
+      zoomScale.value === 1 && panX.value === 0 && panY.value === 0 || (zoomScale.value = 1, panX.value = 0, panY.value = 0, dragState = null);
+    }
+    function hasZoomModifier(event) {
+      let modifier = props.zoomModifier ?? "metaCtrl";
+      return modifier === "none" ? !0 : modifier === "meta" ? event.metaKey === !0 : modifier === "ctrl" ? event.ctrlKey === !0 : event.ctrlKey === !0 || event.metaKey === !0;
+    }
+    function clampPan() {
+      let inner = innerRectFrom(fullRect.value), fit = displayFit.value;
+      if (!fit || inner.w <= 0 || inner.h <= 0)
+        return;
+      let zoom = clampZoom(zoomScale.value), fullW = fit.displayW * zoom, fullH = fit.displayH * zoom, fitOriginX = inner.x + (inner.w > fit.displayW ? Math.floor((inner.w - fit.displayW) / 2) : 0), nextX = panX.value, nextY = panY.value;
+      fullW <= inner.w ? nextX = 0 : nextX = Math.min(
+        inner.x - fitOriginX,
+        Math.max(inner.x + inner.w - fullW - fitOriginX, nextX)
+      ), fullH <= inner.h ? nextY = 0 : nextY = Math.min(0, Math.max(inner.h - fullH, nextY)), nextX !== panX.value && (panX.value = nextX), nextY !== panY.value && (panY.value = nextY);
+    }
+    function setImageCells(cells) {
+      let signature = cells ? cells.base64 : "";
+      signature !== activeImageSignature && (activeImageSignature = signature, resetZoomState()), imageCells.value = cells;
+    }
+    let hasBox = (0, import_vue9.computed)(() => props.box !== !1), normalizedWidth = (0, import_vue9.computed)(() => {
+      let width = Math.floor(Number(props.w));
+      return Number.isFinite(width) ? Math.max(0, width) : 0;
+    }), reservesBoxRows = (0, import_vue9.computed)(() => hasBox.value && normalizedWidth.value >= 2), boxChars = (0, import_vue9.computed)(
+      () => props.ascii ? ASCII_MERMAID_IMAGE_BOX_CHARS : UNICODE_MERMAID_IMAGE_BOX_CHARS
+    ), sourceLines = (0, import_vue9.computed)(() => splitRenderedOutput2(source.value)), displayLines = (0, import_vue9.computed)(() => {
+      let snapshot = textSnapshot.value;
+      return snapshot && snapshot.source === source.value && hasVisibleTextOutput(snapshot.lines) ? snapshot.lines : sourceLines.value;
+    }), currentStyle = (0, import_vue9.computed)(() => props.style ?? defaultStyle.value), innerWidth = (0, import_vue9.computed)(() => {
+      let w = normalizedWidth.value;
+      return reservesBoxRows.value ? Math.max(0, w - 2) : w;
+    }), fixedInnerHeight = (0, import_vue9.computed)(() => {
+      if (props.h == null)
+        return 0;
+      let h4 = Math.floor(Number(props.h));
+      if (!Number.isFinite(h4))
+        return 0;
+      let value = Math.max(0, h4);
+      return reservesBoxRows.value ? Math.max(0, value - 2) : value;
+    }), autoHeight = (0, import_vue9.computed)(() => props.h == null), displayFit = (0, import_vue9.computed)(() => {
+      let cells = imageCells.value;
+      return cells ? autoHeight.value ? fitImageCells(cells, innerWidth.value, Number.MAX_SAFE_INTEGER) : fitImageCells(cells, innerWidth.value, fixedInnerHeight.value) : null;
+    }), contentHeight = (0, import_vue9.computed)(() => autoHeight.value ? displayFit.value?.displayH ?? Math.max(1, displayLines.value.length) : fixedInnerHeight.value), fullHeight = (0, import_vue9.computed)(() => {
+      if (props.h != null) {
+        let h4 = Math.floor(Number(props.h));
+        return Number.isFinite(h4) ? Math.max(0, h4) : 0;
+      }
+      return reservesBoxRows.value ? contentHeight.value + 2 : contentHeight.value;
+    }), fullRect = (0, import_vue9.computed)(() => translateRect(
+      { x: props.x, y: props.y, w: props.w, h: fullHeight.value },
+      layout.originX,
+      layout.originY
+    )), absRect = (0, import_vue9.computed)(() => {
+      let translated = fullRect.value;
+      return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : translated;
+    }), copyLabel = (0, import_vue9.computed)(() => copied.value ? props.copiedText : props.copyText);
+    function cellWidth(value) {
+      return withTextWidthProvider(widthProvider, () => textCellWidth(value));
+    }
+    function sliceCells(text, maxCells) {
+      return withTextWidthProvider(widthProvider, () => sliceByCells(text, maxCells));
+    }
+    function sliceCellsRange(text, startCells, endCells) {
+      return withTextWidthProvider(
+        widthProvider,
+        () => sliceByCellsRange(text, startCells, endCells)
+      );
+    }
+    function padCells(text, width) {
+      return withTextWidthProvider(widthProvider, () => padEndByCells(text, width));
+    }
+    function resolveImageOptions() {
+      let resolvedFg = props.fg ?? resolveMermaidImageColor(currentStyle.value.fg) ?? void 0;
+      return normalizeMermaidImageOptions({
+        cellWidthPx: props.cellWidthPx,
+        cellHeightPx: props.cellHeightPx,
+        scale: props.scale,
+        bg: props.bg,
+        fg: resolvedFg,
+        maxWidthCells: props.maxWidthCells,
+        maxHeightCells: props.maxHeightCells,
+        padding: props.padding
+      });
+    }
+    function hasVisibleTextOutput(lines) {
+      return lines.some((line) => line.trim().length > 0);
+    }
+    function resolveTextOptions() {
+      return {
+        ...props.textOptions ?? {},
+        useAscii: props.ascii,
+        colorMode: "none"
+      };
+    }
+    function textRenderSignature(code) {
+      return [
+        code,
+        props.ascii ? "a" : "",
+        JSON.stringify(props.textOptions ?? null),
+        props.textRenderer != null ? "r" : "",
+        props.shouldRenderSource != null ? "g" : ""
+      ].join("");
+    }
+    async function renderTextWithTimeout(renderer, code, options) {
+      let timeoutMs = normalizeNonNegativeInt2(props.renderTimeoutMs, 0);
+      if (timeoutMs <= 0)
+        return await renderer(code, options);
+      let timer = null;
+      try {
+        return await Promise.race([
+          Promise.resolve().then(() => renderer(code, options)),
+          new Promise((_resolve, reject) => {
+            timer = setTimeout(() => reject(new Error("Mermaid text render timeout")), timeoutMs);
+          })
+        ]);
+      } finally {
+        timer != null && clearTimeout(timer);
+      }
+    }
+    async function runCustomRasterizer(code, options) {
+      let renderer = props.renderer;
+      if (!renderer)
+        return null;
+      let timeoutMs = normalizeNonNegativeInt2(props.renderTimeoutMs, 0), run = () => renderer(code, options);
+      if (timeoutMs <= 0)
+        return await run() ?? null;
+      let timer = null;
+      try {
+        return await Promise.race([
+          run(),
+          new Promise((resolve) => {
+            timer = setTimeout(() => resolve(null), timeoutMs);
+          })
+        ]) ?? null;
+      } finally {
+        timer != null && clearTimeout(timer);
+      }
+    }
+    function shouldSkipRenderForSize(code) {
+      let maxChars = normalizeNonNegativeInt2(
+        props.maxRenderSourceChars,
+        DEFAULT_MERMAID_IMAGE_MAX_RENDER_SOURCE_CHARS
+      );
+      if (maxChars > 0 && code.length > maxChars)
+        return !0;
+      let maxLines = normalizeNonNegativeInt2(
+        props.maxRenderSourceLines,
+        DEFAULT_MERMAID_IMAGE_MAX_RENDER_SOURCE_LINES
+      );
+      return maxLines > 0 && countLinesUpTo2(code, maxLines) > maxLines;
+    }
+    async function rasterizeWithTimeout(code, options) {
+      let timeoutMs = normalizeNonNegativeInt2(props.renderTimeoutMs, 0);
+      if (timeoutMs <= 0)
+        return await getMermaidImage(code, options);
+      let timer = null;
+      try {
+        return await Promise.race([
+          getMermaidImage(code, options),
+          new Promise((resolve) => {
+            timer = setTimeout(() => resolve(null), timeoutMs);
+          })
+        ]);
+      } finally {
+        timer != null && clearTimeout(timer);
+      }
+    }
+    async function renderTextFallback(version) {
+      let code = source.value, renderer = props.textRenderer;
+      if (!renderer)
+        return;
+      let guard = props.shouldRenderSource;
+      if (guard) {
+        let eligible = !1;
+        try {
+          eligible = guard(code, { final: props.final, streaming: props.streaming });
+        } catch {
+          eligible = !1;
+        }
+        if (!eligible)
+          return;
+      }
+      try {
+        let rendered = await renderTextWithTimeout(renderer, code, resolveTextOptions());
+        if (!alive || version !== renderVersion)
+          return;
+        let lines = splitRenderedOutput2(rendered);
+        if (!hasVisibleTextOutput(lines))
+          return;
+        textSnapshot.value = (0, import_vue9.markRaw)({
+          source: code,
+          signature: textRenderSignature(code),
+          lines: (0, import_vue9.markRaw)(lines)
+        }), bump();
+      } catch {
+      }
+    }
+    async function renderPresentation(version) {
+      let code = source.value;
+      if (!code.trim()) {
+        if (!alive || version !== renderVersion)
+          return;
+        setImageCells(null), textSnapshot.value = null, bump();
+        return;
+      }
+      if (waitingForStreamingSourceToFinish.value || shouldSkipRenderForSize(code)) {
+        if (!alive || version !== renderVersion)
+          return;
+        setImageCells(null), textSnapshot.value = null, bump();
+        return;
+      }
+      let protocol = graphicsProtocol.value, options = resolveImageOptions(), cached = protocol && !props.renderer ? getCachedMermaidImage(code, options) : null;
+      if (cached) {
+        if (!alive || version !== renderVersion)
+          return;
+        setImageCells(cached), textSnapshot.value = null, bump();
+        return;
+      }
+      let currentSignature = textRenderSignature(code), keepText = textSnapshot.value != null && textSnapshot.value.source === code && textSnapshot.value.signature === currentSignature;
+      if (keepText || (setImageCells(null), textSnapshot.value = null, bump()), protocol) {
+        let result = null;
+        if (props.renderer)
+          result = await runCustomRasterizer(code, options);
+        else if (isMermaidImageRendererReady())
+          result = await rasterizeWithTimeout(code, options);
+        else {
+          loadMermaidImageRenderer().then((ready) => {
+            !alive || version !== renderVersion || !ready || renderPresentation(version);
+          });
+          return;
+        }
+        if (!alive || version !== renderVersion)
+          return;
+        if (result) {
+          setImageCells(result), textSnapshot.value = null, bump();
+          return;
+        }
+      }
+      keepText || await renderTextFallback(version);
+    }
+    function scheduleRender() {
+      let version = ++renderVersion;
+      if (resetCopyFeedback(!1), setImageCells(null), waitingForStreamingSourceToFinish.value) {
+        builtOnce = !0, scheduler.cancelFrameTask?.(frameTaskId), bump();
+        return;
+      }
+      if (!builtOnce || !props.streaming) {
+        builtOnce = !0, renderPresentation(version);
+        return;
+      }
+      scheduler.queueFrameTask({
+        id: frameTaskId,
+        reason: "stream",
+        priority: "low",
+        sync: !1,
+        run: () => {
+          alive && version === renderVersion && renderPresentation(version);
+        }
+      }) === !1 && renderPresentation(version);
+    }
+    (0, import_vue9.watch)(
+      [
+        source,
+        () => props.renderer,
+        () => props.cellWidthPx,
+        () => props.cellHeightPx,
+        () => props.scale,
+        () => props.bg,
+        () => props.fg,
+        () => props.maxWidthCells,
+        () => props.maxHeightCells,
+        () => props.padding,
+        () => props.streaming,
+        () => props.final,
+        () => props.maxRenderSourceChars,
+        () => props.maxRenderSourceLines,
+        () => props.textRenderer,
+        () => props.shouldRenderSource,
+        () => props.textOptions,
+        () => props.ascii,
+        () => props.zoomModifier
+      ],
+      () => {
+        scheduleRender();
+      },
+      { immediate: !0, deep: !0 }
+    );
+    let unsubscribeMermaidImage = subscribeMermaidImage(() => {
+      if (!alive || !graphicsProtocol.value || props.renderer)
+        return;
+      let cached = getCachedMermaidImage(source.value, resolveImageOptions());
+      cached && alive && (setImageCells(cached), textSnapshot.value = null, bump());
+    }), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
+      alive && (graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal), scheduleRender());
+    });
+    (0, import_vue9.onBeforeUnmount)(() => {
+      alive = !1, renderVersion++, clearCopiedTimer(), queueClearGraphic(), unsubscribeMermaidImage(), unsubscribeGraphicsOutput(), scheduler.cancelFrameTask?.(frameTaskId);
+    });
+    function canDrawBox(width, height) {
+      return hasBox.value && Math.floor(width) >= 2 && Math.floor(height) >= 2;
+    }
+    function headerCopySegment(width) {
+      if (!hasBox.value || !props.copyButton)
+        return null;
+      let rowWidth = Math.max(0, Math.floor(width));
+      if (rowWidth < 4)
+        return null;
+      let label = sanitizeInlineText(copyLabel.value);
+      if (!label)
+        return null;
+      let maxCells = Math.max(0, rowWidth - 2), text = sliceCells(` ${label} `, maxCells), cells = cellWidth(text);
+      return !text || cells <= 0 ? null : {
+        text,
+        start: Math.max(1, rowWidth - cells - 1),
+        cells
+      };
+    }
+    function headerTitleSegment(width, copy) {
+      if (!hasBox.value)
+        return null;
+      let rowWidth = Math.max(0, Math.floor(width));
+      if (rowWidth < 4)
+        return null;
+      let title = sanitizeInlineText(props.title);
+      if (!title)
+        return null;
+      let titleStart = 1, titleEnd = copy ? Math.max(titleStart, copy.start - 1) : rowWidth - 1, maxCells = Math.max(0, titleEnd - titleStart);
+      if (maxCells <= 0)
+        return null;
+      let text = sliceCells(` ${title} `, maxCells), cells = cellWidth(text);
+      return !text || cells <= 0 ? null : {
+        text,
+        start: titleStart,
+        cells
+      };
+    }
+    function overlayCells(row, segment, width) {
+      let rowWidth = Math.max(0, Math.floor(width)), start = Math.max(0, Math.floor(segment.start));
+      if (rowWidth <= 1 || start >= rowWidth - 1 || segment.cells <= 0)
+        return row;
+      let maxCells = Math.max(0, rowWidth - 1 - start), text = sliceCells(segment.text, maxCells), cells = cellWidth(text);
+      return !text || cells <= 0 ? row : `${sliceCells(row, start)}${text}${sliceCellsRange(row, start + cells, rowWidth)}`;
+    }
+    function boxRow(rowIndex, width, height) {
+      let rowWidth = Math.max(0, Math.floor(width)), rowHeight = Math.max(0, Math.floor(height));
+      if (!canDrawBox(rowWidth, rowHeight))
+        return contentLine(rowIndex, rowWidth, props.clear);
+      let chars = boxChars.value, innerW = Math.max(0, rowWidth - 2);
+      if (rowIndex === 0) {
+        let row = `${chars.tl}${repeatChar(chars.h, innerW)}${chars.tr}`, copy = headerCopySegment(rowWidth), title = headerTitleSegment(rowWidth, copy);
+        return title && (row = overlayCells(row, title, rowWidth)), copy && (row = overlayCells(row, copy, rowWidth)), row;
+      }
+      return rowIndex === rowHeight - 1 ? `${chars.bl}${repeatChar(chars.h, innerW)}${chars.br}` : `${chars.v}${contentLine(rowIndex - 1, innerW, !0)}${chars.v}`;
+    }
+    function contentLine(rowIndex, width, pad) {
+      let src = imageCells.value != null && displayFit.value != null && graphicsProtocol.value != null ? spaces(width) : displayLines.value[rowIndex] ?? "", clipped = sliceCells(src, width);
+      return pad ? padCells(clipped, width) : clipped;
+    }
+    function innerRectFrom(full) {
+      let x = Math.floor(full.x) + (reservesBoxRows.value ? 1 : 0), y = Math.floor(full.y) + (reservesBoxRows.value ? 1 : 0), w = Math.max(0, Math.floor(full.w) - (reservesBoxRows.value ? 2 : 0)), h4 = Math.max(0, Math.floor(full.h) - (reservesBoxRows.value ? 2 : 0));
+      return { x, y, w, h: h4 };
+    }
+    function queueImageGraphic(full, fit) {
+      let protocol = graphicsProtocol.value, cells = imageCells.value;
+      if (!protocol || !cells) {
+        queueClearGraphic();
+        return;
+      }
+      let inner = innerRectFrom(full);
+      if (inner.w <= 0 || inner.h <= 0) {
+        queueClearGraphic();
+        return;
+      }
+      let zoom = clampZoom(zoomScale.value), fitW = fit.displayW, fitH = fit.displayH, fullRect2 = {
+        x: inner.x + (inner.w > fitW ? Math.floor((inner.w - fitW) / 2) : 0) + panX.value,
+        y: inner.y + panY.value,
+        w: fitW * zoom,
+        h: fitH * zoom
+      }, visible2 = intersectRect(fullRect2, inner);
+      if (!visible2 || visible2.w < 1 || visible2.h < 1) {
+        queueClearGraphic();
+        return;
+      }
+      let rectX = Math.max(inner.x, Math.round(visible2.x)), rectY = Math.max(inner.y, Math.round(visible2.y)), rect = {
+        x: rectX,
+        y: rectY,
+        w: Math.max(1, Math.min(inner.x + inner.w, rectX + Math.round(visible2.w)) - rectX),
+        h: Math.max(1, Math.min(inner.y + inner.h, rectY + Math.round(visible2.h)) - rectY)
+      }, imageId = stableTerminalGraphicNumericId(`mermaid-image:${uid}:${renderVersion}:img`), placementId = stableTerminalGraphicNumericId(
+        `mermaid-image:${uid}:${renderVersion}:plc`
+      ), built = createTerminalGraphicPngSequence({
+        protocol,
+        base64: cells.base64,
+        imageId,
+        placementId,
+        cols: cells.widthCells,
+        rows: cells.heightCells,
+        sourceWidth: cells.naturalWidth,
+        sourceHeight: cells.naturalHeight,
+        placementColumns: rect.w,
+        placementRows: rect.h,
+        // Keep the initial transmission stable at the fit size without a
+        // source crop so wheel zoom can replace the placement (a=p) without
+        // re-sending the PNG, and every placement references the full image.
+        transmissionColumns: fitW,
+        transmissionRows: fitH,
+        cropTransmission: !1,
+        rect,
+        fullRect: fullRect2,
+        zIndex: -1,
+        fallback: source.value
+      });
+      if (!built) {
+        queueClearGraphic();
+        return;
+      }
+      let id = `mermaid-image:${uid}:${renderVersion}`, output = graphicsOutput.value;
+      if (!output) {
+        queueClearGraphic();
+        return;
+      }
+      if (activeGraphicId != null && activeGraphicId !== id) {
+        try {
+          output.clear?.(activeGraphicId);
+        } catch {
+        }
+        activeGraphicId = null;
+      }
+      output.queue({
+        id,
+        x: rect.x,
+        y: rect.y,
+        w: rect.w,
+        h: rect.h,
+        protocol,
+        sequence: built.sequence,
+        resizeSequence: built.resizeSequence,
+        clearSequence: built.clearSequence,
+        fallbackText: source.value,
+        // Same image data + placement id: let the stdout renderer replace the
+        // placement with the resize sequence instead of re-sending the PNG.
+        placementMoveWithoutClear: protocol === "kitty"
+      }) ? activeGraphicId = id : queueClearGraphic();
+    }
+    let copyHitRect = (0, import_vue9.computed)(() => {
+      let full = fullRect.value;
+      if (!visible.value || !props.copyButton || !canDrawBox(full.w, full.h))
+        return { x: 0, y: 0, w: 0, h: 0 };
+      let copy = headerCopySegment(Math.max(0, Math.floor(full.w)));
+      if (!copy)
+        return { x: 0, y: 0, w: 0, h: 0 };
+      let raw = {
+        x: Math.floor(full.x) + copy.start,
+        y: Math.floor(full.y),
+        w: copy.cells,
+        h: 1
+      };
+      return layout.clipRect ? intersectRect(raw, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : raw;
+    }), contentHitRect = (0, import_vue9.computed)(() => {
+      if (!visible.value)
+        return { x: 0, y: 0, w: 0, h: 0 };
+      let full = fullRect.value;
+      if (full.w <= 0 || full.h <= 0)
+        return { x: 0, y: 0, w: 0, h: 0 };
+      let inner = innerRectFrom(full);
+      return inner.w <= 0 || inner.h <= 0 ? { x: 0, y: 0, w: 0, h: 0 } : layout.clipRect ? intersectRect(inner, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : inner;
+    });
+    function clipboardCanWrite2(api) {
+      return api.canWrite ?? api.supported;
+    }
+    async function writeClipboardText(text) {
+      let contextClipboard = terminalContext.clipboard;
+      if (contextClipboard) {
+        if (!clipboardCanWrite2(contextClipboard))
+          throw new Error("Clipboard write not available in this runtime");
+        await contextClipboard.writeText(text);
+        return;
+      }
+      let navClipboard = globalThis.navigator?.clipboard;
+      if (navClipboard && typeof navClipboard.writeText == "function") {
+        await navClipboard.writeText(text);
+        return;
+      }
+      throw new Error("Clipboard write not available in this runtime");
+    }
+    async function copySource() {
+      let text = source.value, requestVersion = ++copyRequestVersion, ok = !1, copyError;
+      try {
+        await writeClipboardText(text), ok = !0;
+      } catch (err) {
+        copyError = err;
+      }
+      if (!alive)
+        return;
+      requestVersion === copyRequestVersion && source.value === text && (ok ? showCopiedFeedback() : setCopied(!1)), emit("copy", ok ? { text, ok } : { text, ok, error: copyError });
+    }
+    function onCopyClick(event) {
+      event.preventDefault(), event.stopPropagation(), !(Date.now() - lastDragAt < DRAG_CLICK_SUPPRESS_MS) && copySource();
+    }
+    function onCopyKeydown(event) {
+      event.key !== "Enter" && event.key !== " " || (event.preventDefault(), event.stopPropagation(), copySource());
+    }
+    let zoomEnabled = (0, import_vue9.computed)(
+      () => props.zoomOnWheel !== !1 && imageCells.value != null && displayFit.value != null && graphicsProtocol.value === "kitty" && contentHitRect.value.w > 0 && contentHitRect.value.h > 0
+    ), dragEnabled = (0, import_vue9.computed)(
+      () => props.zoomOnWheel !== !1 && imageCells.value != null && displayFit.value != null && graphicsProtocol.value === "kitty" && zoomScale.value > 1 && contentHitRect.value.w > 0 && contentHitRect.value.h > 0
+    );
+    function onWheel(event) {
+      if (!zoomEnabled.value || !hasZoomModifier(event))
+        return;
+      event.preventDefault(), event.stopPropagation();
+      let deltaY = event.deltaY ?? 0;
+      if (!Number.isFinite(deltaY) || deltaY === 0)
+        return;
+      let inner = innerRectFrom(fullRect.value), fit = displayFit.value;
+      if (!fit || inner.w <= 0 || inner.h <= 0)
+        return;
+      let currentZoom = clampZoom(zoomScale.value), fitW = fit.displayW, fitH = fit.displayH, fitOriginX = inner.x + (inner.w > fitW ? Math.floor((inner.w - fitW) / 2) : 0), fullX = fitOriginX + panX.value, fullY = inner.y + panY.value, mouseX = event.cellX, mouseY = event.cellY, fx = currentZoom > 0 ? (mouseX - fullX) / (fitW * currentZoom) : 0.5, fy = currentZoom > 0 ? (mouseY - fullY) / (fitH * currentZoom) : 0.5, nextZoom = clampZoom(currentZoom * wheelZoomFactor(deltaY, event.deltaMode));
+      if (nextZoom === currentZoom)
+        return;
+      let nextW = fitW * nextZoom, nextH = fitH * nextZoom, nextX = mouseX - fx * nextW, nextY = mouseY - fy * nextH;
+      nextW <= inner.w ? nextX = inner.x + (inner.w - nextW) / 2 : nextX = Math.min(inner.x, Math.max(inner.x + inner.w - nextW, nextX)), nextH <= inner.h ? nextY = inner.y + (inner.h - nextH) / 2 : nextY = Math.min(inner.y, Math.max(inner.y + inner.h - nextH, nextY)), zoomScale.value = nextZoom, panX.value = nextX - fitOriginX, panY.value = nextY - inner.y, clampPan(), bump();
+    }
+    function onPointerDown(event) {
+      dragEnabled.value && (event.preventDefault(), event.stopPropagation(), dragState = {
+        startX: event.cellX,
+        startY: event.cellY,
+        panStartX: panX.value,
+        panStartY: panY.value
+      }, dragMoved = !1);
+    }
+    function onPointerMove(event) {
+      let drag = dragState;
+      if (!drag)
+        return;
+      event.preventDefault(), event.stopPropagation();
+      let dx = event.cellX - drag.startX, dy = event.cellY - drag.startY;
+      !dragMoved && Math.abs(dx) + Math.abs(dy) >= 1 && (dragMoved = !0), dragMoved && (panX.value = drag.panStartX + dx, panY.value = drag.panStartY + dy, clampPan(), bump());
+    }
+    function onPointerUp(event) {
+      dragState && (event.preventDefault(), event.stopPropagation(), dragState = null, dragMoved && (lastDragAt = Date.now()));
+    }
+    let copyNodeActive = (0, import_vue9.computed)(
+      () => visible.value && props.copyButton && copyHitRect.value.w > 0 && copyHitRect.value.h > 0
+    );
+    useTerminalNode(() => ({
+      rect: copyHitRect.value,
+      zIndex: (parentEventZ.value ?? 0) + props.zIndex + 1,
+      visible: copyNodeActive.value,
+      focusable: copyNodeActive.value,
+      selectable: !1,
+      handlers: copyNodeActive.value ? {
+        click: onCopyClick,
+        keydown: onCopyKeydown
+      } : {}
+    }));
+    let contentNodeActive = (0, import_vue9.computed)(
+      () => visible.value && (props.copyOnClick || zoomEnabled.value || dragEnabled.value) && contentHitRect.value.w > 0 && contentHitRect.value.h > 0
+    );
+    return useTerminalNode(() => ({
+      rect: contentHitRect.value,
+      zIndex: (parentEventZ.value ?? 0) + props.zIndex,
+      visible: contentNodeActive.value,
+      focusable: !1,
+      selectable: !1,
+      handlers: contentNodeActive.value ? {
+        click: props.copyOnClick ? onCopyClick : void 0,
+        wheel: zoomEnabled.value ? onWheel : void 0,
+        pointerdown: dragEnabled.value ? onPointerDown : void 0,
+        pointermove: dragEnabled.value ? onPointerMove : void 0,
+        pointerup: dragEnabled.value ? onPointerUp : void 0
+      } : {}
+    })), useRenderNode(() => ({
+      zIndex: props.zIndex,
+      rect: visible.value ? absRect.value : { x: 0, y: 0, w: 0, h: 0 },
+      deps: [
+        visible.value,
+        absRect.value,
+        fullRect.value,
+        imageCells.value,
+        displayFit.value,
+        zoomScale.value,
+        panX.value,
+        panY.value,
+        textSnapshot.value,
+        displayLines.value,
+        sourceLines.value,
+        currentStyle.value,
+        props.clear,
+        hasBox.value,
+        boxChars.value,
+        props.title,
+        props.copyButton,
+        copyLabel.value,
+        graphicsOutputVersion.value,
+        documentVersion.value
+      ],
+      paint: (dirtyRows) => {
+        withTextWidthProvider(widthProvider, () => {
+          if (!visible.value) {
+            queueClearGraphic();
+            return;
+          }
+          let r = absRect.value, full = fullRect.value;
+          if (r.w <= 0 || r.h <= 0) {
+            queueClearGraphic();
+            return;
+          }
+          let style = currentStyle.value, dx = Math.max(0, Math.floor(r.x - full.x)), fullY = Math.floor(full.y), fullW = Math.max(0, Math.floor(full.w)), fullH = Math.max(0, Math.floor(full.h)), blank = props.clear ? spaces(r.w) : "", paintRow = (y) => {
+            if (y < r.y || y >= r.y + r.h)
+              return;
+            let rowIndex = y - fullY;
+            if (rowIndex < 0 || rowIndex >= fullH) {
+              props.clear && terminal.write(blank, { x: r.x, y, style });
+              return;
+            }
+            let src = boxRow(rowIndex, fullW, fullH), clipped = dx > 0 ? sliceCellsRange(src, dx, dx + r.w) : sliceCells(src, r.w), value = props.clear ? padCells(clipped, r.w) : clipped;
+            (value || props.clear) && terminal.write(value, { x: r.x, y, style });
+          };
+          if (imageCells.value && displayFit.value ? queueImageGraphic(full, displayFit.value) : queueClearGraphic(), dirtyRows?.length) {
+            for (let y of dirtyRows)
+              paintRow(y);
+            return;
+          }
+          for (let y = r.y; y < r.y + r.h; y++)
+            paintRow(y);
+        });
+      }
+    })), () => (0, import_vue9.h)("span", rootProps);
+  }
+});
+
+// src/vue/mermaid/beautiful-mermaid.ts
 var BEAUTIFUL_MERMAID_INSTALL_HINT = "Install beautiful-mermaid and use TMermaidText from @simon_he/vue-tui/mermaid or @simon_he/vue-tui/agent/mermaid, or pass a custom renderer prop.", MISSING_BEAUTIFUL_MERMAID_ERROR_CODE = "VUE_TUI_MISSING_BEAUTIFUL_MERMAID", INVALID_BEAUTIFUL_MERMAID_EXPORT_ERROR_CODE = "VUE_TUI_INVALID_BEAUTIFUL_MERMAID_EXPORT", cachedBeautifulMermaid = null;
 function functionValue(value) {
   return typeof value == "function" ? value : null;
@@ -1680,7 +3111,7 @@ var beautifulMermaidRenderer = async (code, options) => {
 function createBeautifulMermaidRenderer() {
   return beautifulMermaidRenderer;
 }
-var TMermaidText2 = (0, import_vue9.defineComponent)({
+var TMermaidText2 = (0, import_vue10.defineComponent)({
   name: "TMermaidText",
   inheritAttrs: !1,
   props: tMermaidTextProps,
@@ -1690,7 +3121,7 @@ var TMermaidText2 = (0, import_vue9.defineComponent)({
   setup(props, { attrs, emit, slots }) {
     return () => {
       let renderer = props.renderer ?? beautifulMermaidRenderer, shouldRenderSource = props.shouldRenderSource ?? isSimpleMermaidFlowchartSource;
-      return (0, import_vue9.h)(
+      return (0, import_vue10.h)(
         TMermaidText,
         {
           ...attrs,
@@ -1704,4 +3135,27 @@ var TMermaidText2 = (0, import_vue9.defineComponent)({
       );
     };
   }
-}), TMermaid = TMermaidText2, TBeautifulMermaidText = TMermaidText2, TBeautifulMermaid = TMermaidText2;
+}), TMermaid = (0, import_vue10.defineComponent)({
+  name: "TMermaid",
+  inheritAttrs: !1,
+  props: tMermaidImageProps,
+  emits: {
+    copy: (_payload) => !0
+  },
+  setup(props, { attrs, emit, slots }) {
+    return () => {
+      let { renderer: _legacyTextRenderer, ...rest } = props, textRenderer = props.textRenderer ?? props.renderer ?? beautifulMermaidRenderer;
+      return (0, import_vue10.h)(
+        TMermaidImage,
+        {
+          ...attrs,
+          ...rest,
+          textRenderer,
+          shouldRenderSource: props.shouldRenderSource ?? isSimpleMermaidFlowchartSource,
+          onCopy: (payload) => emit("copy", payload)
+        },
+        slots
+      );
+    };
+  }
+}), TBeautifulMermaidText = TMermaidText2, TBeautifulMermaid = TMermaid;