@simon_he/vue-tui 1.1.2 → 1.1.4

package/dist/mermaid.cjs

@@ -28,11 +28,21 @@ __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,
+  setMermaidImageRasterizer: () => setMermaidImageRasterizer,
+  subscribeMermaidImage: () => subscribeMermaidImage
 });
 module.exports = __toCommonJS(mermaid_exports);
 
@@ -1385,8 +1395,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;
@@ -1705,3 +1715,1079 @@ var TMermaidText2 = (0, import_vue9.defineComponent)({
     };
   }
 }), TMermaid = TMermaidText2, TBeautifulMermaidText = TMermaidText2, TBeautifulMermaid = TMermaidText2;
+
+// src/vue/components/TMermaidImage.ts
+var import_vue10 = 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 });
+    }
+    return {
+      type: "sequence",
+      protocol: "kitty",
+      sequence: createKittyGraphicsSequence(options.base64, {
+        imageId: options.imageId,
+        placementId: options.placementId,
+        zIndex: options.zIndex,
+        ...placement
+      }),
+      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 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 rendered = new Resvg(svgText, {
+          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 },
+  // 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 }
+}, TMermaidImage = (0, import_vue10.defineComponent)({
+  name: "TMermaidImage",
+  props: tMermaidImageProps,
+  emits: {
+    copy: (_payload) => !0
+  },
+  setup(props, { emit }) {
+    let instance = (0, import_vue10.getCurrentInstance)(), terminalContext = useTerminal(), { terminal, defaultStyle, scheduler, widthProvider } = terminalContext, layout = useLayout(), { visible, rootProps } = useVisibility(), parentEventZ = (0, import_vue10.inject)(EventZIndexContextKey, (0, import_vue10.computed)(() => 0)), imageCells = (0, import_vue10.shallowRef)(null), documentVersion = (0, import_vue10.shallowRef)(0), copied = (0, import_vue10.shallowRef)(!1), builtOnce = !1, renderVersion = 0, alive = !0, frameTaskId = `TMermaidImage:${instance?.uid ?? "unknown"}:mermaid-image`, uid = instance?.uid ?? 0, copiedTimer = null, copyRequestVersion = 0, activeGraphicId = null, source = (0, import_vue10.computed)(() => props.code ?? props.content ?? ""), waitingForStreamingSourceToFinish = (0, import_vue10.computed)(() => props.streaming && !props.final), graphicsOutputVersion = (0, import_vue10.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), graphicsOutput = (0, import_vue10.computed)(() => (graphicsOutputVersion.value, getTerminalGraphicsOutput(terminal))), graphicsProtocol = (0, import_vue10.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 {
+      }
+    }
+    let hasBox = (0, import_vue10.computed)(() => props.box !== !1), normalizedWidth = (0, import_vue10.computed)(() => {
+      let width = Math.floor(Number(props.w));
+      return Number.isFinite(width) ? Math.max(0, width) : 0;
+    }), reservesBoxRows = (0, import_vue10.computed)(() => hasBox.value && normalizedWidth.value >= 2), boxChars = (0, import_vue10.computed)(
+      () => props.ascii ? ASCII_MERMAID_IMAGE_BOX_CHARS : UNICODE_MERMAID_IMAGE_BOX_CHARS
+    ), sourceLines = (0, import_vue10.computed)(() => splitRenderedOutput2(source.value)), currentStyle = (0, import_vue10.computed)(() => props.style ?? defaultStyle.value), innerWidth = (0, import_vue10.computed)(() => {
+      let w = normalizedWidth.value;
+      return reservesBoxRows.value ? Math.max(0, w - 2) : w;
+    }), fixedInnerHeight = (0, import_vue10.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_vue10.computed)(() => props.h == null), displayFit = (0, import_vue10.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_vue10.computed)(() => autoHeight.value ? displayFit.value?.displayH ?? Math.max(1, sourceLines.value.length) : fixedInnerHeight.value), fullHeight = (0, import_vue10.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_vue10.computed)(() => translateRect(
+      { x: props.x, y: props.y, w: props.w, h: fullHeight.value },
+      layout.originX,
+      layout.originY
+    )), absRect = (0, import_vue10.computed)(() => {
+      let translated = fullRect.value;
+      return layout.clipRect ? intersectRect(translated, layout.clipRect) ?? { x: 0, y: 0, w: 0, h: 0 } : translated;
+    }), copyLabel = (0, import_vue10.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 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 renderImage(version) {
+      let code = source.value;
+      if (!code.trim()) {
+        if (!alive || version !== renderVersion)
+          return;
+        imageCells.value = null, bump();
+        return;
+      }
+      if (waitingForStreamingSourceToFinish.value || shouldSkipRenderForSize(code)) {
+        if (!alive || version !== renderVersion)
+          return;
+        imageCells.value = null, bump();
+        return;
+      }
+      if (imageCells.value = null, bump(), !graphicsProtocol.value)
+        return;
+      let options = resolveImageOptions(), cached = getCachedMermaidImage(code, options);
+      if (cached) {
+        if (!alive || version !== renderVersion)
+          return;
+        imageCells.value = cached, bump();
+        return;
+      }
+      if (!isMermaidImageRendererReady()) {
+        loadMermaidImageRenderer().then((ready) => {
+          !alive || version !== renderVersion || !ready || renderImage(version);
+        });
+        return;
+      }
+      let result = await rasterizeWithTimeout(code, options);
+      !alive || version !== renderVersion || (imageCells.value = result, bump());
+    }
+    function scheduleRender() {
+      let version = ++renderVersion;
+      if (resetCopyFeedback(!1), imageCells.value = null, waitingForStreamingSourceToFinish.value) {
+        builtOnce = !0, scheduler.cancelFrameTask?.(frameTaskId), bump();
+        return;
+      }
+      if (!builtOnce || !props.streaming) {
+        builtOnce = !0, renderImage(version);
+        return;
+      }
+      scheduler.queueFrameTask({
+        id: frameTaskId,
+        reason: "stream",
+        priority: "low",
+        sync: !1,
+        run: () => {
+          alive && version === renderVersion && renderImage(version);
+        }
+      }) === !1 && renderImage(version);
+    }
+    (0, import_vue10.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,
+        graphicsOutputVersion
+      ],
+      () => {
+        scheduleRender();
+      },
+      { immediate: !0, deep: !0 }
+    );
+    let unsubscribeMermaidImage = subscribeMermaidImage(() => {
+      alive && scheduleRender();
+    }), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
+      alive && (graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal), scheduleRender());
+    });
+    (0, import_vue10.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) : sourceLines.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 offsetX = inner.w > fit.displayW ? Math.floor((inner.w - fit.displayW) / 2) : 0, rect = {
+        x: inner.x + offsetX,
+        y: inner.y,
+        w: fit.displayW,
+        h: fit.displayH
+      }, 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: fit.displayW,
+        placementRows: fit.displayH,
+        rect,
+        fullRect: rect,
+        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: fit.displayW,
+        h: fit.displayH,
+        protocol,
+        sequence: built.sequence,
+        resizeSequence: built.resizeSequence,
+        clearSequence: built.clearSequence,
+        fallbackText: source.value
+      }) ? activeGraphicId = id : queueClearGraphic();
+    }
+    let copyHitRect = (0, import_vue10.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_vue10.computed)(() => {
+      if (!visible.value || !props.copyOnClick)
+        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(), copySource();
+    }
+    function onCopyKeydown(event) {
+      event.key !== "Enter" && event.key !== " " || (event.preventDefault(), event.stopPropagation(), copySource());
+    }
+    let copyNodeActive = (0, import_vue10.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_vue10.computed)(
+      () => visible.value && props.copyOnClick && 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: onCopyClick
+      } : {}
+    })), 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,
+        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_vue10.h)("span", rootProps);
+  }
+});