@simon_he/vue-tui 1.1.3 → 1.1.5

package/dist/markdown.cjs

@@ -31,11 +31,19 @@ __export(markdown_exports, {
   TVirtualMarkdown: () => TVirtualMarkdown,
   buildMarkdownBlocks: () => buildMarkdownBlocks,
   buildMarkdownVisualRows: () => buildMarkdownVisualRows,
+  clearMarkdownMathImageCache: () => clearMarkdownMathImageCache,
   createMarkdownBlockSource: () => createMarkdownBlockSource,
   createTuiMarkdownParser: () => createTuiMarkdownParser,
+  enqueueMarkdownMathImages: () => enqueueMarkdownMathImages,
+  getCachedMarkdownMathImage: () => getCachedMarkdownMathImage,
+  getMarkdownMathImage: () => getMarkdownMathImage,
+  isMarkdownMathImageRendererReady: () => isMarkdownMathImageRendererReady,
   isSafeMarkdownLink: () => isSafeMarkdownLink,
   layoutMarkdownBlocks: () => layoutMarkdownBlocks,
-  loadMarkdownMathRenderer: () => loadMarkdownMathRenderer
+  loadMarkdownMathImageRenderer: () => loadMarkdownMathImageRenderer,
+  loadMarkdownMathRenderer: () => loadMarkdownMathRenderer,
+  setMarkdownMathRasterizer: () => setMarkdownMathRasterizer,
+  subscribeMarkdownMathImage: () => subscribeMarkdownMathImage
 });
 module.exports = __toCommonJS(markdown_exports);
 
@@ -1033,185 +1041,242 @@ function readMarkdownImageDimensions(base64) {
   return null;
 }
 
-// src/vue/markdown/math.ts
-var loadedKatex = null, katexLoad = null, katexListeners = /* @__PURE__ */ new Set();
-function resolveKatexRenderer(value) {
-  if (!value || typeof value != "object")
-    return null;
-  let renderToString = value.renderToString;
-  return typeof renderToString == "function" ? { renderToString } : 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
+}), MAX_CACHE_ENTRIES = 64, MAX_FAILED_ENTRIES = 128, mathImageCache = /* @__PURE__ */ new Map(), mathImageFailed = /* @__PURE__ */ new Set(), mathImageInflight = /* @__PURE__ */ new Map(), mathImageListeners = /* @__PURE__ */ new Set(), customRasterizer = null, builtinRasterizerLoad = null, builtinRasterizerReady = !1, 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()];
 }
-function subscribeMarkdownMathRenderer(listener) {
-  return katexListeners.add(listener), () => katexListeners.delete(listener);
+function normalizeMathImageOptions(options) {
+  return {
+    cellWidthPx: Math.max(
+      1,
+      Math.floor(options?.cellWidthPx ?? DEFAULT_MATH_IMAGE_OPTIONS.cellWidthPx)
+    ),
+    cellHeightPx: Math.max(
+      1,
+      Math.floor(options?.cellHeightPx ?? DEFAULT_MATH_IMAGE_OPTIONS.cellHeightPx)
+    ),
+    scale: Math.max(1, Math.floor(options?.scale ?? DEFAULT_MATH_IMAGE_OPTIONS.scale)),
+    color: options?.color ?? DEFAULT_MATH_IMAGE_OPTIONS.color,
+    maxWidthCells: Math.max(0, Math.floor(options?.maxWidthCells ?? 0)),
+    baselineRatio: clamp01(options?.baselineRatio ?? DEFAULT_MATH_IMAGE_OPTIONS.baselineRatio)
+  };
 }
-async function loadMarkdownMathRenderer() {
-  return loadedKatex ? !0 : (katexLoad || (katexLoad = import("katex").then((mod) => {
-    let renderer = resolveKatexRenderer(mod.default) ?? resolveKatexRenderer(mod);
-    if (!renderer)
-      return !1;
-    loadedKatex = renderer;
-    for (let listener of katexListeners)
-      listener();
-    return !0;
-  }).catch(() => !1)), katexLoad);
+function clamp01(value) {
+  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0.78;
 }
-var KATEX_TEXT_OPTIONS = Object.freeze({
-  output: "mathml",
-  throwOnError: !1,
-  strict: "ignore",
-  trust: !1,
-  maxSize: 20,
-  maxExpand: 200
-}), KATEX_VALIDATE_OPTIONS = Object.freeze({
-  ...KATEX_TEXT_OPTIONS,
-  throwOnError: !0
-}), TEX_SYMBOLS = Object.freeze({
-  alpha: "\u03B1",
-  beta: "\u03B2",
-  gamma: "\u03B3",
-  delta: "\u03B4",
-  epsilon: "\u03B5",
-  theta: "\u03B8",
-  lambda: "\u03BB",
-  mu: "\u03BC",
-  pi: "\u03C0",
-  rho: "\u03C1",
-  sigma: "\u03C3",
-  tau: "\u03C4",
-  phi: "\u03C6",
-  omega: "\u03C9",
-  Gamma: "\u0393",
-  Delta: "\u0394",
-  Theta: "\u0398",
-  Lambda: "\u039B",
-  Pi: "\u03A0",
-  Sigma: "\u03A3",
-  Phi: "\u03A6",
-  Omega: "\u03A9",
-  int: "\u222B",
-  sum: "\u2211",
-  prod: "\u220F",
-  infty: "\u221E",
-  infinity: "\u221E",
-  pm: "\xB1",
-  times: "\xD7",
-  cdot: "\xB7",
-  div: "\xF7",
-  le: "\u2264",
-  leq: "\u2264",
-  ge: "\u2265",
-  geq: "\u2265",
-  neq: "\u2260",
-  ne: "\u2260",
-  approx: "\u2248",
-  equiv: "\u2261",
-  to: "\u2192",
-  rightarrow: "\u2192",
-  leftarrow: "\u2190",
-  leftrightarrow: "\u2194",
-  partial: "\u2202",
-  nabla: "\u2207",
-  sqrt: "\u221A"
-}), SUPPORTED_COMMANDS = /* @__PURE__ */ new Set([...Object.keys(TEX_SYMBOLS), "frac", "sqrt"]);
-function decodeXmlEntities(value) {
-  return value.replace(/&(?:#(\d+)|#x([0-9a-f]+)|([a-z]+));/gi, (match, dec, hex, named) => {
-    if (dec)
-      return String.fromCodePoint(Number(dec));
-    if (hex)
-      return String.fromCodePoint(Number.parseInt(hex, 16));
-    switch (String(named).toLowerCase()) {
-      case "amp":
-        return "&";
-      case "lt":
-        return "<";
-      case "gt":
-        return ">";
-      case "quot":
-        return '"';
-      case "apos":
-        return "'";
-      default:
-        return match;
-    }
-  });
+function setMarkdownMathRasterizer(rasterizer) {
+  customRasterizer = rasterizer;
 }
-function mathmlTagName(tag) {
-  let start = tag.startsWith("/") ? 1 : 0, end = start;
-  for (; end < tag.length; ) {
-    let ch = tag[end];
-    if (ch === " " || ch === "	" || ch === `
-` || ch === "\r" || ch === "/")
-      break;
-    end++;
-  }
-  return tag.slice(start, end).toLowerCase();
+function subscribeMarkdownMathImage(listener) {
+  return mathImageListeners.add(listener), () => mathImageListeners.delete(listener);
 }
-function textFromKatexMathml(html) {
-  let readable = "", offset = 0, lowerHtml = html.toLowerCase();
-  for (; offset < html.length; ) {
-    let tagStart = html.indexOf("<", offset);
-    if (tagStart < 0) {
-      readable += html.slice(offset);
-      break;
-    }
-    readable += html.slice(offset, tagStart);
-    let tagEnd = html.indexOf(">", tagStart + 1);
-    if (tagEnd < 0)
-      break;
-    let tag = html.slice(tagStart + 1, tagEnd).trim(), tagName = mathmlTagName(tag), closing = tag.startsWith("/");
-    if (!closing && tagName === "annotation") {
-      let annotationEnd = lowerHtml.indexOf("</annotation>", tagEnd + 1);
-      offset = annotationEnd < 0 ? tagEnd + 1 : annotationEnd + 13;
-      continue;
-    }
-    !closing && tagName === "mfrac" ? readable += "(" : closing && tagName === "mfrac" ? readable += ")" : !closing && tagName === "mspace" && (readable += " "), offset = tagEnd + 1;
-  }
-  return sanitizeInlineText(
-    decodeXmlEntities(readable).replace(/[<>]/g, "").replace(/\s+/g, " ").trim()
+function isMarkdownMathImageRendererReady() {
+  return customRasterizer != null || builtinRasterizerReady;
+}
+async function loadMarkdownMathImageRenderer() {
+  return isMarkdownMathImageRendererReady() ? !0 : (builtinRasterizerReady = (customRasterizer ?? await loadBuiltinMathRasterizer()) != null, builtinRasterizerReady);
+}
+function hashMathImageKey(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 mathImageCacheKey(tex, mode, options) {
+  return hashMathImageKey(
+    [
+      mode,
+      tex,
+      options.cellWidthPx,
+      options.cellHeightPx,
+      options.scale,
+      options.maxWidthCells,
+      options.color,
+      options.baselineRatio
+    ].join("")
   );
 }
-function approximateTexToUnicode(tex) {
-  let out = String(tex ?? "");
-  return out = out.replace(/\\frac\s*\{([^{}]*)\}\s*\{([^{}]*)\}/g, "$1/$2"), out = out.replace(/\\sqrt\s*\{([^{}]*)\}/g, "\u221A($1)"), out = out.replace(
-    /\\([A-Za-z]+)\b/g,
-    (_match, command) => TEX_SYMBOLS[command] ?? command
-  ), out = out.replace(/\\([^A-Za-z])/g, "$1"), out = out.replace(/[{}]/g, ""), out = out.replace(/\s+/g, " ").trim(), sanitizeInlineText(out.replace(/[<>]/g, ""));
+function notifyMathImageListeners() {
+  for (let listener of mathImageListeners)
+    try {
+      listener();
+    } catch {
+    }
+}
+function getCachedMarkdownMathImage(tex, mode, options) {
+  return mathImageCache.get(mathImageCacheKey(tex, mode, normalizeMathImageOptions(options))) ?? null;
 }
-function canRenderTerminalMath(tex, katex) {
+function clearMarkdownMathImageCache() {
+  mathImageCache.clear(), mathImageFailed.clear();
+}
+function evictOldestMathImageEntry() {
+  let oldest = mathImageCache.keys().next().value;
+  oldest != null && mathImageCache.delete(oldest);
+}
+async function getMarkdownMathImage(tex, mode, options) {
   let source = String(tex ?? "").trim();
-  if (!source || source.length > 160 || /\\(?:begin|end|left|right|matrix|cases|array|align|color|href|html|includegraphics|class|style|tag|text|operatorname)\b/.test(
-    source
-  ))
-    return !1;
-  let commands = source.matchAll(/\\([A-Za-z]+)\b/g);
-  for (let match of commands)
-    if (!SUPPORTED_COMMANDS.has(match[1] ?? ""))
-      return !1;
-  try {
-    katex.renderToString(source, KATEX_VALIDATE_OPTIONS);
-  } catch {
-    return !1;
+  if (!source)
+    return null;
+  let normalized = normalizeMathImageOptions(options), key = mathImageCacheKey(source, mode, normalized), cached = mathImageCache.get(key);
+  if (cached)
+    return cached;
+  if (mathImageFailed.has(key))
+    return null;
+  let inflight = mathImageInflight.get(key);
+  if (inflight)
+    return inflight;
+  let pending = (async () => {
+    try {
+      let rasterizer = customRasterizer ?? await loadBuiltinMathRasterizer();
+      if (!rasterizer)
+        return null;
+      let result = await rasterizer(source, mode, normalized);
+      if (result && result.base64)
+        mathImageCache.set(key, result), mathImageCache.size > MAX_CACHE_ENTRIES && evictOldestMathImageEntry(), notifyMathImageListeners();
+      else if (result === null && (mathImageFailed.add(key), mathImageFailed.size > MAX_FAILED_ENTRIES)) {
+        let oldest = mathImageFailed.values().next().value;
+        oldest != null && mathImageFailed.delete(oldest);
+      }
+      return result;
+    } catch {
+      return null;
+    } finally {
+      mathImageInflight.delete(key);
+    }
+  })();
+  return mathImageInflight.set(key, pending), pending;
+}
+function enqueueMarkdownMathImages(rows, options, viewport) {
+  let first = Math.max(0, Math.floor(viewport?.firstRow ?? 0)), last = Math.min(rows.length, Math.max(first, Math.ceil(viewport?.lastRow ?? rows.length)));
+  for (let index = first; index < last; index++) {
+    let row = rows[index];
+    if (row)
+      for (let segment of row.segments) {
+        let graphic = segment.graphic;
+        if (graphic?.kind === "math") {
+          !graphic.base64 && graphic.tex && getMarkdownMathImage(graphic.tex, "display", options);
+          continue;
+        }
+        segment.mathAction?.pendingImage && segment.mathAction?.source && getMarkdownMathImage(
+          segment.mathAction.source,
+          segment.mathAction.mode ?? "display",
+          options
+        );
+      }
   }
-  return !0;
 }
-function renderMarkdownInlineMathSegment(tex) {
-  let source = String(tex ?? "");
-  if (!source.trim())
-    return { text: "", supported: !1 };
-  let katex = loadedKatex;
-  if (!katex)
-    return loadMarkdownMathRenderer(), { text: "", supported: !1 };
-  if (!canRenderTerminalMath(source, katex))
-    return { text: "", supported: !1 };
-  try {
-    let html = katex.renderToString(source, KATEX_TEXT_OPTIONS), rendered = /\\frac\b/.test(source) ? approximateTexToUnicode(source) : textFromKatexMathml(html);
-    if (rendered && !rendered.includes("\\"))
-      return { text: rendered, supported: !0 };
-  } catch {
-    return { text: "", supported: !1 };
-  }
-  let approximate = approximateTexToUnicode(source);
-  return approximate && !approximate.includes("\\") ? { text: approximate, supported: !0 } : { text: "", supported: !1 };
+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 extractSvgMarkup(containerMarkup) {
+  let start = containerMarkup.indexOf("<svg");
+  if (start < 0)
+    return "";
+  let end = containerMarkup.lastIndexOf("</svg>");
+  return end < start ? "" : containerMarkup.slice(start, end + 6);
+}
+var RESVG_MODULE_ID = "@resvg/resvg-js";
+function loadBuiltinMathRasterizer() {
+  return builtinRasterizerLoad || (builtinRasterizerLoad = (async () => {
+    try {
+      let [
+        { mathjax },
+        { TeX },
+        { SVG },
+        { liteAdaptor },
+        { RegisterHTMLHandler },
+        { AllPackages },
+        { Resvg }
+      ] = await Promise.all([
+        import("mathjax-full/js/mathjax.js"),
+        import("mathjax-full/js/input/tex.js"),
+        import("mathjax-full/js/output/svg.js"),
+        import("mathjax-full/js/adaptors/liteAdaptor.js"),
+        import("mathjax-full/js/handlers/html.js"),
+        import("mathjax-full/js/input/tex/AllPackages.js"),
+        import(RESVG_MODULE_ID)
+      ]), adaptor = liteAdaptor();
+      RegisterHTMLHandler(adaptor);
+      let texInput = new TeX({
+        packages: AllPackages,
+        formatError: () => {
+          throw new Error("Malformed TeX");
+        }
+      }), svgOutput = new SVG({ fontCache: "none" }), document = mathjax.document("", { InputJax: texInput, OutputJax: svgOutput });
+      return async (source, mode, options) => {
+        let node = document.convert(source, { display: mode === "display" }), svg = extractSvgMarkup(adaptor.outerHTML(node));
+        if (!svg)
+          return null;
+        let widthEx = Number(/width="([\d.]+)ex"/.exec(svg)?.[1] ?? 0), heightEx = Number(/height="([\d.]+)ex"/.exec(svg)?.[1] ?? 0);
+        if (!(widthEx > 0) || !(heightEx > 0))
+          return null;
+        let exPx = options.cellHeightPx / 2 * options.scale;
+        if (mode === "inline") {
+          let naturalH = heightEx * exPx, naturalW = widthEx * exPx;
+          if (naturalH > options.cellHeightPx * options.scale * 2)
+            return null;
+          let rectH = options.cellHeightPx * options.scale, k = rectH / naturalH, contentW = Math.max(1, Math.round(naturalW * k)), widthCells = Math.max(
+            1,
+            Math.ceil(contentW / (options.cellWidthPx * options.scale))
+          ), rectW = widthCells * options.cellWidthPx * options.scale, verticalAlignEx = Number(/vertical-align:\s*(-?[\d.]+)ex/.exec(svg)?.[1] ?? 0), formulaBaseline = (heightEx - Math.abs(verticalAlignEx)) * exPx * k, offsetY = options.baselineRatio * rectH - formulaBaseline, inner = svg.replace(/style="vertical-align:[^"]*"/, "").replace(/width="[\d.]+ex"/, `width="${contentW}px"`).replace(/height="[\d.]+ex"/, `height="${rectH}px"`), wrapped = `<svg xmlns="http://www.w3.org/2000/svg" color="${options.color}" width="${rectW}px" height="${rectH}px" viewBox="0 0 ${rectW} ${rectH}"><g transform="translate(0 ${offsetY.toFixed(2)})">${inner}</g></svg>`, pngInline = new Resvg(wrapped, { background: "rgba(0,0,0,0)" }).render().asPng();
+          return !pngInline || pngInline.length < 8 ? null : {
+            base64: base64FromBytes(pngInline),
+            widthCells,
+            heightCells: 1
+          };
+        }
+        let widthPx = Math.max(1, Math.round(widthEx * exPx)), heightPx = Math.max(1, Math.round(heightEx * exPx));
+        if (options.maxWidthCells > 0) {
+          let maxPx = options.maxWidthCells * options.cellWidthPx * options.scale;
+          widthPx > maxPx && (heightPx = Math.max(1, Math.round(heightPx * (maxPx / widthPx))), widthPx = maxPx);
+        }
+        svg = svg.replace(/style="vertical-align:[^"]*"/, "").replace(/width="[\d.]+ex"/, `width="${widthPx}px"`).replace(/height="[\d.]+ex"/, `height="${heightPx}px"`).replace(/<svg/, `<svg color="${options.color}"`);
+        let png = new Resvg(svg, { background: "rgba(0,0,0,0)" }).render().asPng();
+        return !png || png.length < 8 ? null : {
+          base64: base64FromBytes(png),
+          widthCells: Math.max(1, Math.round(widthPx / (options.cellWidthPx * options.scale))),
+          heightCells: Math.max(1, Math.round(heightPx / (options.cellHeightPx * options.scale)))
+        };
+      };
+    } catch {
+      return null;
+    }
+  })()), builtinRasterizerLoad;
 }
 
 // node_modules/.pnpm/stream-markdown-parser@1.1.9/node_modules/stream-markdown-parser/dist/index.js
@@ -18439,17 +18504,26 @@ function inlineNodeSegments(nodes, theme, inheritedStyle, options = {}) {
         break;
       case "math_inline":
         {
-          let source = stringProp(node, "content"), raw = stringProp(node, "raw") || `$${source}$`, rendered = renderMarkdownInlineMathSegment(source);
-          pushTextSegments(
+          let source = stringProp(node, "content"), markup = stringProp(node, "markup") || "$", raw = stringProp(node, "raw") || `${markup}${source}${markup}`, mathStyle = mergeStyle(inheritedStyle, theme.inlineCode), tex = sanitizeInlineText(source), mathEnabled = options.math?.enabled !== !1, cached = tex && mathEnabled ? getCachedMarkdownMathImage(tex, "inline", options.math) : null;
+          cached ? pushTextSegments(
             out,
-            rendered.supported ? rendered.text : raw,
-            mergeStyle(inheritedStyle, theme.inlineCode),
-            void 0,
+            raw,
+            mathStyle,
             {
-              source,
+              kind: "math",
+              tex,
               raw,
-              rendered: rendered.supported
-            }
+              base64: cached.base64,
+              displayWidth: cached.widthCells,
+              displayHeight: cached.heightCells
+            },
+            { source: tex, raw, rendered: !0 }
+          ) : pushTextSegments(
+            out,
+            raw,
+            mathStyle,
+            void 0,
+            tex && mathEnabled ? { source: tex, raw, rendered: !1, pendingImage: !0, mode: "inline" } : { source, raw, rendered: !1 }
           );
         }
         break;
@@ -18489,7 +18563,8 @@ function blockFromParagraph(node, key, context, theme) {
     key,
     inlineNodeSegments(nodeChildren(node), theme, void 0, {
       imageResolver: context.imageResolver,
-      imageSize: context.imageSize
+      imageSize: context.imageSize,
+      math: context.math
     }),
     context
   );
@@ -18500,7 +18575,8 @@ function blockFromHeading(node, key, context, theme) {
     key,
     inlineNodeSegments(nodeChildren(node), theme, theme.heading[level - 1], {
       imageResolver: context.imageResolver,
-      imageSize: context.imageSize
+      imageSize: context.imageSize,
+      math: context.math
     }),
     context
   );
@@ -18530,7 +18606,7 @@ function blockFromHtmlBlock(node, key, context, theme) {
       ],
       theme,
       void 0,
-      { imageResolver: context.imageResolver }
+      { imageResolver: context.imageResolver, math: context.math }
     ),
     context
   );
@@ -18553,14 +18629,16 @@ function blockFromTable(node, key, context, theme) {
   ).map((cell) => ({
     segments: inlineNodeSegments(nodeChildren(cell), theme, theme.strong, {
       imageResolver: context.imageResolver,
-      imageSize: context.imageSize
+      imageSize: context.imageSize,
+      math: context.math
     }),
     align: tableCellAlign(cell)
   })), rows = tableRows(node, "rows").map(
     (row) => tableCells(row).map((cell) => ({
       segments: inlineNodeSegments(nodeChildren(cell), theme, void 0, {
         imageResolver: context.imageResolver,
-        imageSize: context.imageSize
+        imageSize: context.imageSize,
+        math: context.math
       }),
       align: tableCellAlign(cell)
     }))
@@ -18590,10 +18668,12 @@ function listItemBlocks(item, index, ordered, start, context, theme, keyPrefix)
     text: spaces(markerCells)
   }, firstContext = {
     prefixSegments: [...context.prefixSegments, markerSegment],
-    continuationPrefixSegments: [...context.continuationPrefixSegments, indentSegment]
+    continuationPrefixSegments: [...context.continuationPrefixSegments, indentSegment],
+    math: context.math
   }, nestedContext = {
     prefixSegments: [...context.continuationPrefixSegments, indentSegment],
-    continuationPrefixSegments: [...context.continuationPrefixSegments, indentSegment]
+    continuationPrefixSegments: [...context.continuationPrefixSegments, indentSegment],
+    math: context.math
   }, children = nodeChildren(item);
   if (!children.length)
     return [inlineBlock(`${keyPrefix}-empty`, [], firstContext)];
@@ -18632,6 +18712,37 @@ function listBlocks(node, context, theme, keyPrefix) {
     );
   return out;
 }
+function blockMathSegments(source, raw, math, theme) {
+  let tex = sanitizeInlineText(source), canUseImage = !!tex && math.enabled !== !1, cached = canUseImage ? getCachedMarkdownMathImage(tex, "display", math) : null;
+  if (canUseImage && cached)
+    return [
+      {
+        text: raw,
+        style: theme.math,
+        graphic: {
+          kind: "math",
+          tex,
+          raw,
+          base64: cached.base64,
+          displayWidth: cached.widthCells,
+          displayHeight: cached.heightCells
+        },
+        mathAction: { source: tex, raw, rendered: !0 }
+      }
+    ];
+  let maxWidth = Math.max(8, Math.floor(math.maxWidthCells ?? 0) || 40), rawCells = textCellWidth(raw), inner = Math.min(Math.max(1, rawCells + 2), maxWidth), pad = Math.max(0, inner - rawCells);
+  return [
+    { text: `\u250C${"\u2500".repeat(inner)}\u2510`, style: theme.math },
+    HARD_BREAK_SEGMENT,
+    {
+      text: `\u2502 ${raw}${" ".repeat(pad)}\u2502`,
+      style: theme.math,
+      mathAction: { source: tex, raw, rendered: !1, pendingImage: !0 }
+    },
+    HARD_BREAK_SEGMENT,
+    { text: `\u2514${"\u2500".repeat(inner)}\u2518`, style: theme.math }
+  ];
+}
 function nodeToBlocks(node, context, theme, keyPrefix) {
   switch (node.type) {
     case "paragraph":
@@ -18656,6 +18767,19 @@ function nodeToBlocks(node, context, theme, keyPrefix) {
           prefixSegments: context.prefixSegments
         }
       ];
+    case "math_block":
+      return [
+        inlineBlock(
+          keyPrefix,
+          blockMathSegments(
+            stringProp(node, "content"),
+            stringProp(node, "raw") || `$${stringProp(node, "content")}$`,
+            context.math ?? { enabled: !0 },
+            theme
+          ),
+          context
+        )
+      ];
     case "blockquote": {
       let quoteSegment = {
         text: "\u2502 ",
@@ -18664,7 +18788,8 @@ function nodeToBlocks(node, context, theme, keyPrefix) {
         prefixSegments: [...context.prefixSegments, quoteSegment],
         continuationPrefixSegments: [...context.continuationPrefixSegments, quoteSegment],
         imageResolver: context.imageResolver,
-        imageSize: context.imageSize
+        imageSize: context.imageSize,
+        math: context.math
       };
       return childSequenceToBlocks(nodeChildren(node), quoteContext, theme, keyPrefix);
     }
@@ -18680,7 +18805,8 @@ function nodeToBlocks(node, context, theme, keyPrefix) {
           keyPrefix,
           inlineNodeSegments(nodeChildren(node), theme, void 0, {
             imageResolver: context.imageResolver,
-            imageSize: context.imageSize
+            imageSize: context.imageSize,
+            math: context.math
           }),
           context
         )
@@ -18693,7 +18819,10 @@ function nodeToBlocks(node, context, theme, keyPrefix) {
       return [
         inlineBlock(
           keyPrefix,
-          inlineNodeSegments([node], theme, void 0, { imageResolver: context.imageResolver }),
+          inlineNodeSegments([node], theme, void 0, {
+            imageResolver: context.imageResolver,
+            math: context.math
+          }),
           context
         )
       ];
@@ -18701,7 +18830,10 @@ function nodeToBlocks(node, context, theme, keyPrefix) {
   return nodeChildren(node).length ? childSequenceToBlocks(nodeChildren(node), context, theme, keyPrefix) : [
     inlineBlock(
       keyPrefix,
-      inlineNodeSegments([node], theme, void 0, { imageResolver: context.imageResolver }),
+      inlineNodeSegments([node], theme, void 0, {
+        imageResolver: context.imageResolver,
+        math: context.math
+      }),
       context
     )
   ];
@@ -18714,7 +18846,8 @@ function markdownAstToBlocks(nodes, theme, options = {}) {
         prefixSegments: EMPTY_PREFIX,
         continuationPrefixSegments: EMPTY_PREFIX,
         imageResolver: options.imageResolver,
-        imageSize: options.imageSize
+        imageSize: options.imageSize,
+        math: options.math
       },
       theme,
       "md"
@@ -18835,7 +18968,8 @@ function wrapLineSegments(source, prefixSegments, continuationPrefixSegments, wi
         style: segment.style,
         cells,
         graphic: segment.graphic,
-        fallbackText: segment.text
+        fallbackText: segment.text,
+        ...segment.mathAction ? { mathAction: segment.mathAction } : {}
       }), row.remaining -= cells;
       continue;
     }
@@ -19061,7 +19195,8 @@ function styleSignature(style) {
 function inlineSegmentSignature(segment) {
   let graphic = segment.graphic ? [
     segment.graphic.kind,
-    segment.graphic.src,
+    segment.graphic.src ?? "",
+    segment.graphic.tex ?? "",
     segment.graphic.alt ?? "",
     segment.graphic.mime ?? "",
     segment.graphic.base64 ?? "",
@@ -19196,7 +19331,8 @@ var DEFAULT_HEADING = Object.freeze([
   listMarker: freezeStyle({ fg: "cyanBright", bold: !0 }),
   codeBlock: freezeStyle({ fg: "yellowBright" }),
   thematicBreak: freezeStyle({ dim: !0 }),
-  html: freezeStyle({ dim: !0 })
+  html: freezeStyle({ dim: !0 }),
+  math: freezeStyle({ fg: "cyanBright" })
 });
 function stableSerialize(value) {
   return value == null ? "null" : typeof value != "object" ? JSON.stringify(value) : Array.isArray(value) ? `[${value.map((item) => stableSerialize(item)).join(",")}]` : `{${Object.entries(value).sort(
@@ -19229,7 +19365,8 @@ function resolveTuiMarkdownTheme(overrides) {
       DEFAULT_TUI_MARKDOWN_THEME.thematicBreak,
       overrides.thematicBreak
     ),
-    html: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.html, overrides.html)
+    html: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.html, overrides.html),
+    math: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.math, overrides.math)
   });
 }
 
@@ -19239,7 +19376,8 @@ function buildMarkdownBlocks(content, parser, options) {
   try {
     let nodes = parser.parse(content, options?.final ?? !0), blocks = markdownAstToBlocks(nodes, theme, {
       imageResolver: options?.imageResolver,
-      imageSize: options?.imageSize
+      imageSize: options?.imageSize,
+      math: options?.math
     });
     return { nodes, blocks };
   } catch (error) {
@@ -19389,11 +19527,11 @@ function findMarkdownMathActionAt(rows, point, options) {
       let math = segment.mathAction;
       if (!math || segmentEnd <= clipStart || segmentStart >= clipEnd)
         continue;
-      let visibleStart = Math.max(segmentStart, clipStart), visibleEnd = Math.min(segmentEnd, clipEnd), rect = {
+      let visibleStart = Math.max(segmentStart, clipStart), visibleEnd = Math.min(segmentEnd, clipEnd), graphicHeight = segment.graphic ? Math.max(1, Math.floor(segment.graphic.displayHeight ?? 1)) : 1, rect = {
         x: r.x + visibleStart - clipStart,
         y: r.y + rowIndex - firstRow,
         w: visibleEnd - visibleStart,
-        h: 1
+        h: graphicHeight
       };
       if (!(point.cellX < rect.x || point.cellY < rect.y || point.cellX >= rect.x + rect.w || point.cellY >= rect.y + rect.h))
         return {
@@ -19409,6 +19547,87 @@ function findMarkdownMathActionAt(rows, point, options) {
   return null;
 }
 
+// src/vue/markdown/math.ts
+var loadedKatex = null, katexLoad = null, katexListeners = /* @__PURE__ */ new Set();
+function resolveKatexRenderer(value) {
+  if (!value || typeof value != "object")
+    return null;
+  let renderToString = value.renderToString;
+  return typeof renderToString == "function" ? { renderToString } : null;
+}
+function subscribeMarkdownMathRenderer(listener) {
+  return katexListeners.add(listener), () => katexListeners.delete(listener);
+}
+async function loadMarkdownMathRenderer() {
+  return loadedKatex ? !0 : (katexLoad || (katexLoad = import("katex").then((mod) => {
+    let renderer = resolveKatexRenderer(mod.default) ?? resolveKatexRenderer(mod);
+    if (!renderer)
+      return !1;
+    loadedKatex = renderer;
+    for (let listener of katexListeners)
+      listener();
+    return !0;
+  }).catch(() => !1)), katexLoad);
+}
+var KATEX_TEXT_OPTIONS = Object.freeze({
+  output: "mathml",
+  throwOnError: !1,
+  strict: "ignore",
+  trust: !1,
+  maxSize: 20,
+  maxExpand: 200
+}), KATEX_VALIDATE_OPTIONS = Object.freeze({
+  ...KATEX_TEXT_OPTIONS,
+  throwOnError: !0
+}), TEX_SYMBOLS = Object.freeze({
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  theta: "\u03B8",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigma: "\u03C3",
+  tau: "\u03C4",
+  phi: "\u03C6",
+  omega: "\u03C9",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Theta: "\u0398",
+  Lambda: "\u039B",
+  Pi: "\u03A0",
+  Sigma: "\u03A3",
+  Phi: "\u03A6",
+  Omega: "\u03A9",
+  int: "\u222B",
+  sum: "\u2211",
+  prod: "\u220F",
+  infty: "\u221E",
+  infinity: "\u221E",
+  pm: "\xB1",
+  times: "\xD7",
+  cdot: "\xB7",
+  div: "\xF7",
+  le: "\u2264",
+  leq: "\u2264",
+  ge: "\u2265",
+  geq: "\u2265",
+  neq: "\u2260",
+  ne: "\u2260",
+  approx: "\u2248",
+  equiv: "\u2261",
+  to: "\u2192",
+  rightarrow: "\u2192",
+  leftarrow: "\u2190",
+  leftrightarrow: "\u2194",
+  partial: "\u2202",
+  nabla: "\u2207",
+  sqrt: "\u221A"
+}), SUPPORTED_COMMANDS = /* @__PURE__ */ new Set([...Object.keys(TEX_SYMBOLS), "frac", "sqrt"]);
+
 // src/utils/env.ts
 function firstNonEmptyEnv(env, primary, legacy) {
   let primaryValue = env?.[primary];
@@ -19514,7 +19733,7 @@ function mergeStyle2(base, overlay) {
 var activeMarkdownImageGraphics = /* @__PURE__ */ new WeakMap();
 function markdownImageGraphicId(segment, identity) {
   return `md-image:${stableTerminalGraphicNumericId(
-    `${identity}:${segment.src}:${segment.displayWidth ?? 0}:${segment.displayHeight ?? 0}:${segment.base64 ?? ""}`
+    `${identity}:${segment.src ?? segment.tex ?? ""}:${segment.displayWidth ?? 0}:${segment.displayHeight ?? 0}:${segment.base64 ?? ""}`
   )}`;
 }
 function rememberMarkdownImageGraphic(terminal, id, rect) {
@@ -19535,7 +19754,7 @@ function clearStaleMarkdownImageGraphicsForRow(terminal, y, keepIds, keepVisible
       !(keepVisibleIds ? y >= rect.y && y < rect.y + rect.h : rect.y === y) || keepIds.has(id) || keepVisibleIds?.has(id) || clearTrackedMarkdownImageGraphic(terminal, id);
 }
 function canAttemptMarkdownImageGraphic(terminal, segment) {
-  if (segment.kind !== "image" || !segment.base64)
+  if (!segment.base64)
     return !1;
   let output = getTerminalGraphicsOutput(terminal), protocol = output?.capabilities.preferredProtocol;
   return !!(output?.capabilities.supported && isTerminalGraphicsProtocol(protocol));
@@ -19547,7 +19766,7 @@ function clearMarkdownImageGraphics(terminal, rect) {
       rect && (item.x >= rect.x + rect.w || item.x + item.w <= rect.x || item.y >= rect.y + rect.h || item.y + item.h <= rect.y) || clearTrackedMarkdownImageGraphic(terminal, id);
 }
 function queueMarkdownImageGraphic(terminal, segment, identity, rect) {
-  if (segment.kind !== "image" || !segment.base64)
+  if (!segment.base64)
     return "unavailable";
   let output = getTerminalGraphicsOutput(terminal), protocol = output?.capabilities.preferredProtocol;
   if (!output?.capabilities.supported || !isTerminalGraphicsProtocol(protocol))
@@ -19584,7 +19803,7 @@ function queueMarkdownImageGraphic(terminal, segment, identity, rect) {
     sequence,
     resizeSequence,
     clearSequence,
-    fallbackText: segment.alt ?? "image"
+    fallbackText: segment.alt ?? (segment.kind === "math" ? segment.raw ?? segment.tex ?? "math" : "image")
   });
   return markdownImageDebug(
     `queue id=${id}`,
@@ -19669,7 +19888,7 @@ function paintMarkdownVisualRow(terminal, row, options) {
       }), graphicAvailable = queueResult || canAttemptMarkdownImageGraphic(terminal, segment.graphic), queuedGraphic = queueResult === "queued", suppressFallback = queuedGraphic || queueResult === "rejected" || graphicAvailable === !0;
       queuedGraphic && queuedGraphics.add(markdownImageGraphicId(segment.graphic, `${row.key}:${segmentIndex}`)), terminal.write(
         suppressFallback ? spaces(visibleCells) : sliceByCellsRange(
-          segment.fallbackText ?? segment.graphic.alt ?? "image",
+          segment.fallbackText ?? segment.graphic.alt ?? (segment.graphic.kind === "math" ? segment.graphic.raw ?? segment.graphic.tex ?? "math" : "image"),
           0,
           visibleCells
         ) || spaces(visibleCells),
@@ -20002,6 +20221,13 @@ var TMarkdownText = (0, import_vue8.defineComponent)({
     imageMinHeight: { type: Number, default: void 0 },
     imageMaxHeight: { type: Number, default: void 0 },
     imagePreserveAspectRatio: { type: Boolean, default: !0 },
+    mathImages: { type: Boolean, default: !0 },
+    mathCellWidthPx: { type: Number, default: void 0 },
+    mathCellHeightPx: { type: Number, default: void 0 },
+    mathScale: { type: Number, default: void 0 },
+    mathColor: { type: String, default: void 0 },
+    mathMaxWidthCells: { type: Number, default: void 0 },
+    mathBaselineRatio: { type: Number, default: void 0 },
     imageActions: { type: Boolean, default: !1 },
     mathActions: { type: Boolean, default: !1 },
     linkActions: { type: Boolean, default: !1 },
@@ -20024,9 +20250,11 @@ var TMarkdownText = (0, import_vue8.defineComponent)({
         })
       )
     ), graphicsOutputVersion = (0, import_vue8.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
-      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal), enqueuePendingMathImages();
     }), unsubscribeMathRenderer = subscribeMarkdownMathRenderer(() => {
       scheduleRebuild();
+    }), unsubscribeMathImage = subscribeMarkdownMathImage(() => {
+      scheduleRebuild();
     });
     (0, import_vue8.watch)(
       () => `${props.streaming ? 1 : 0}:${(props.customHtmlTags ?? []).join("\0")}`,
@@ -20039,6 +20267,31 @@ var TMarkdownText = (0, import_vue8.defineComponent)({
         );
       }
     );
+    function mathOptions() {
+      if (props.mathImages === !1)
+        return { enabled: !1 };
+      let resolvedColor = props.mathColor ?? resolveMarkdownMathColor(defaultStyle.value.fg);
+      return {
+        enabled: !0,
+        ...props.mathCellWidthPx != null ? { cellWidthPx: props.mathCellWidthPx } : {},
+        ...props.mathCellHeightPx != null ? { cellHeightPx: props.mathCellHeightPx } : {},
+        ...props.mathScale != null ? { scale: props.mathScale } : {},
+        ...resolvedColor != null ? { color: resolvedColor } : {},
+        ...props.mathBaselineRatio != null ? { baselineRatio: props.mathBaselineRatio } : {},
+        maxWidthCells: props.mathMaxWidthCells ?? props.w
+      };
+    }
+    function enqueuePendingMathImages() {
+      if (props.mathImages !== !1 && getTerminalGraphicsOutput(terminal)?.capabilities.supported) {
+        if (!isMarkdownMathImageRendererReady()) {
+          loadMarkdownMathImageRenderer().then((ready) => {
+            ready && alive && scheduleRebuild();
+          });
+          return;
+        }
+        enqueueMarkdownMathImages(rows.value, mathOptions());
+      }
+    }
     function rebuildRows() {
       rows.value = (0, import_vue8.markRaw)(
         withTextWidthProvider(
@@ -20053,10 +20306,11 @@ var TMarkdownText = (0, import_vue8.defineComponent)({
               minHeight: props.imageMinHeight,
               maxHeight: props.imageMaxHeight,
               preserveAspectRatio: props.imagePreserveAspectRatio
-            }
+            },
+            math: mathOptions()
           })
         )
-      ), documentVersion.value++;
+      ), documentVersion.value++, enqueuePendingMathImages();
     }
     function scheduleRebuild() {
       let currentVersion = ++rebuildVersion;
@@ -20086,14 +20340,21 @@ var TMarkdownText = (0, import_vue8.defineComponent)({
         () => props.imageMaxWidth,
         () => props.imageMinHeight,
         () => props.imageMaxHeight,
-        () => props.imagePreserveAspectRatio
+        () => props.imagePreserveAspectRatio,
+        () => props.mathImages,
+        () => props.mathCellWidthPx,
+        () => props.mathCellHeightPx,
+        () => props.mathScale,
+        () => props.mathColor,
+        () => props.mathMaxWidthCells,
+        () => props.mathBaselineRatio
       ],
       () => {
         scheduleRebuild();
       },
       { immediate: !0 }
     ), (0, import_vue8.onBeforeUnmount)(() => {
-      alive = !1, rebuildVersion++, unsubscribeGraphicsOutput(), unsubscribeMathRenderer(), clearMarkdownImageGraphics(terminal, fullRect.value);
+      alive = !1, rebuildVersion++, unsubscribeGraphicsOutput(), unsubscribeMathRenderer(), unsubscribeMathImage(), clearMarkdownImageGraphics(terminal, fullRect.value);
     });
     let fullRect = (0, import_vue8.computed)(() => {
       let height = props.h ?? Math.max(1, rows.value.length);
@@ -20407,6 +20668,13 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
     imageMinHeight: { type: Number, default: void 0 },
     imageMaxHeight: { type: Number, default: void 0 },
     imagePreserveAspectRatio: { type: Boolean, default: !0 },
+    mathImages: { type: Boolean, default: !0 },
+    mathCellWidthPx: { type: Number, default: void 0 },
+    mathCellHeightPx: { type: Number, default: void 0 },
+    mathScale: { type: Number, default: void 0 },
+    mathColor: { type: String, default: void 0 },
+    mathMaxWidthCells: { type: Number, default: void 0 },
+    mathBaselineRatio: { type: Number, default: void 0 },
     imageActions: { type: Boolean, default: !1 },
     mathActions: { type: Boolean, default: !1 },
     linkActions: { type: Boolean, default: !1 },
@@ -20434,10 +20702,41 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
         })
       )
     ), graphicsOutputVersion = (0, import_vue10.shallowRef)(getTerminalGraphicsOutputVersion(terminal)), unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
-      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+      graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal), enqueuePendingMathImages();
     }), unsubscribeMathRenderer = subscribeMarkdownMathRenderer(() => {
       scheduleRebuild();
+    }), unsubscribeMathImage = subscribeMarkdownMathImage(() => {
+      scheduleRebuild();
     });
+    function mathOptions() {
+      if (props.mathImages === !1)
+        return { enabled: !1 };
+      let resolvedColor = props.mathColor ?? resolveMarkdownMathColor(defaultStyle.value.fg);
+      return {
+        enabled: !0,
+        ...props.mathCellWidthPx != null ? { cellWidthPx: props.mathCellWidthPx } : {},
+        ...props.mathCellHeightPx != null ? { cellHeightPx: props.mathCellHeightPx } : {},
+        ...props.mathScale != null ? { scale: props.mathScale } : {},
+        ...resolvedColor != null ? { color: resolvedColor } : {},
+        ...props.mathBaselineRatio != null ? { baselineRatio: props.mathBaselineRatio } : {},
+        maxWidthCells: props.mathMaxWidthCells ?? props.w
+      };
+    }
+    function enqueuePendingMathImages() {
+      if (props.mathImages === !1 || !getTerminalGraphicsOutput(terminal)?.capabilities.supported)
+        return;
+      if (!isMarkdownMathImageRendererReady()) {
+        loadMarkdownMathImageRenderer().then((ready) => {
+          ready && alive && scheduleRebuild();
+        });
+        return;
+      }
+      let h3 = Math.max(0, Math.floor(props.h ?? absRect.value.h));
+      enqueueMarkdownMathImages(rows.value, mathOptions(), {
+        firstRow: internalScrollTop.value,
+        lastRow: internalScrollTop.value + h3
+      });
+    }
     (0, import_vue10.watch)(
       () => `${props.streaming ? 1 : 0}:${(props.customHtmlTags ?? []).join("\0")}`,
       () => {
@@ -20461,13 +20760,14 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
             minHeight: props.imageMinHeight,
             maxHeight: props.imageMaxHeight,
             preserveAspectRatio: props.imagePreserveAspectRatio
-          }
+          },
+          math: mathOptions()
         }).blocks;
         return layoutMarkdownBlocksCached(blocks, props.w, layoutCache);
       });
       layoutCache = (0, import_vue10.markRaw)(nextLayout.cache);
       let nextRows = nextLayout.rows;
-      rows.value = (0, import_vue10.markRaw)(nextRows), reconcileScrollTop();
+      rows.value = (0, import_vue10.markRaw)(nextRows), enqueuePendingMathImages(), reconcileScrollTop();
       let nextScrollTop = internalScrollTop.value, nextVisibleRows = visibleRowSignatures(nextRows, nextScrollTop), nextVisibleGraphics = visibleRowGraphics(nextRows, nextScrollTop), visibleChanged = prevVisibleRows.length !== nextVisibleRows.length || prevVisibleRows.some((row, index) => row !== nextVisibleRows[index]) || prevVisibleGraphics.some((row, index) => row !== nextVisibleGraphics[index]);
       (!builtOnce || prevScrollTop !== nextScrollTop || visibleChanged) && (documentVersion.value++, selection.refresh());
     }
@@ -20549,7 +20849,9 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
         let remap = pendingSelectionScrollFocusRemap;
         pendingSelectionScrollFocusRemap = !1, applyControlledScrollTop(props.scrollTop, remap);
       }
-    ), (0, import_vue10.watch)(
+    ), (0, import_vue10.watch)(internalScrollTop, () => {
+      enqueuePendingMathImages();
+    }), (0, import_vue10.watch)(
       [
         () => props.content,
         () => props.blocks,
@@ -20562,7 +20864,14 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
         () => props.imageMaxWidth,
         () => props.imageMinHeight,
         () => props.imageMaxHeight,
-        () => props.imagePreserveAspectRatio
+        () => props.imagePreserveAspectRatio,
+        () => props.mathImages,
+        () => props.mathCellWidthPx,
+        () => props.mathCellHeightPx,
+        () => props.mathScale,
+        () => props.mathColor,
+        () => props.mathMaxWidthCells,
+        () => props.mathBaselineRatio
       ],
       () => {
         scheduleRebuild();
@@ -20743,7 +21052,7 @@ var TVirtualMarkdown = (0, import_vue10.defineComponent)({
       let manager = events.value, nodeId = eventNode.id.value;
       nodeId && manager && manager.getFocused() !== nodeId && manager.focus(nodeId);
     }), (0, import_vue10.onBeforeUnmount)(() => {
-      alive = !1, rebuildVersion++, unsubscribeGraphicsOutput(), unsubscribeMathRenderer(), clearMarkdownImageGraphics(terminal, fullRect.value);
+      alive = !1, rebuildVersion++, unsubscribeGraphicsOutput(), unsubscribeMathRenderer(), unsubscribeMathImage(), clearMarkdownImageGraphics(terminal, fullRect.value);
     }), useRenderNode(() => ({
       zIndex: props.zIndex,
       rect: visible.value ? normalizedRect() : { x: 0, y: 0, w: 0, h: 0 },