@simon_he/vue-tui 1.1.3 → 1.1.4

package/dist/markdown.d.cts

@@ -4,6 +4,9 @@ export { createMarkdownBlockSource } from "./vue/markdown/block-source.js";
 export { buildMarkdownBlocks, buildMarkdownVisualRows } from "./vue/markdown/document.js";
 export { layoutMarkdownBlocks } from "./vue/markdown/layout.js";
 export { loadMarkdownMathRenderer } from "./vue/markdown/math.js";
+export { clearMarkdownMathImageCache, enqueueMarkdownMathImages, getCachedMarkdownMathImage, getMarkdownMathImage, isMarkdownMathImageRendererReady, loadMarkdownMathImageRenderer, setMarkdownMathRasterizer, subscribeMarkdownMathImage, } from "./vue/markdown/math-image.js";
+export type { TuiMarkdownMathImageCells, TuiMarkdownMathImageOptions, TuiMarkdownMathMode, TuiMarkdownMathRasterizer, } from "./vue/markdown/math-image.js";
+export type { TuiMarkdownMathOptions } from "./vue/markdown/ast.js";
 export { createTuiMarkdownParser, isSafeMarkdownLink } from "./vue/markdown/parser.js";
 export type { TuiMarkdownBlockSource, TuiMarkdownBlockSourceOptions, TuiMarkdownBlockSourceSnapshot, } from "./vue/markdown/block-source.js";
 export type { TuiMarkdownLayoutOptions } from "./vue/markdown/layout.js";

package/dist/markdown.d.ts

@@ -4,6 +4,9 @@ export { createMarkdownBlockSource } from "./vue/markdown/block-source.js";
 export { buildMarkdownBlocks, buildMarkdownVisualRows } from "./vue/markdown/document.js";
 export { layoutMarkdownBlocks } from "./vue/markdown/layout.js";
 export { loadMarkdownMathRenderer } from "./vue/markdown/math.js";
+export { clearMarkdownMathImageCache, enqueueMarkdownMathImages, getCachedMarkdownMathImage, getMarkdownMathImage, isMarkdownMathImageRendererReady, loadMarkdownMathImageRenderer, setMarkdownMathRasterizer, subscribeMarkdownMathImage, } from "./vue/markdown/math-image.js";
+export type { TuiMarkdownMathImageCells, TuiMarkdownMathImageOptions, TuiMarkdownMathMode, TuiMarkdownMathRasterizer, } from "./vue/markdown/math-image.js";
+export type { TuiMarkdownMathOptions } from "./vue/markdown/ast.js";
 export { createTuiMarkdownParser, isSafeMarkdownLink } from "./vue/markdown/parser.js";
 export type { TuiMarkdownBlockSource, TuiMarkdownBlockSourceOptions, TuiMarkdownBlockSourceSnapshot, } from "./vue/markdown/block-source.js";
 export type { TuiMarkdownLayoutOptions } from "./vue/markdown/layout.js";

package/dist/markdown.js

@@ -1,12 +1,13 @@
-import "./hyperlink-_1FAj7Wq.js";
-import "./width-GqllnV8C.js";
-import { EventZIndexContextKey, intersectRect, translateRect, useLayout, useRenderNode, useTerminal, useTerminalNode, useVisibility, withTextWidthProvider } from "./rect-DUpeDfBg.js";
+import "./create-terminal-Db_-UGVQ.js";
+import "./hyperlink-clbb_ha_.js";
+import { EventZIndexContextKey, intersectRect, translateRect, useLayout, useRenderNode, useTerminal, useTerminalNode, useVisibility, withTextWidthProvider } from "./rect-JzWMJxxc.js";
 import "./env-Cl8qmNFN.js";
 import "./terminal-selection-4W1SJj4c.js";
 import "./debug-logger-CmsGI4of.js";
 import "./wheel-scroll-DASkEZr-.js";
-import { getTerminalGraphicsOutputVersion, subscribeTerminalGraphicsOutput } from "./terminal-graphics-Bbe83wSr.js";
-import { TVirtualMarkdown, buildMarkdownBlocks, buildMarkdownVisualRows, clearMarkdownImageGraphics, collectVisibleMarkdownImageGraphicIds, createMarkdownBlockSource, createTuiMarkdownParser, findMarkdownImageActionAt, findMarkdownLinkActionAt, findMarkdownMathActionAt, isSafeMarkdownLink, layoutMarkdownBlocks, loadMarkdownMathRenderer, markdownThemeSignature, paintMarkdownVisualRow, subscribeMarkdownMathRenderer } from "./block-source-Crro3mxi.js";
+import { getTerminalGraphicsOutput, getTerminalGraphicsOutputVersion, subscribeTerminalGraphicsOutput } from "./terminal-graphics-DWZrl3oh.js";
+import { TVirtualMarkdown, buildMarkdownBlocks, buildMarkdownVisualRows, clearMarkdownImageGraphics, collectVisibleMarkdownImageGraphicIds, createMarkdownBlockSource, createTuiMarkdownParser, findMarkdownImageActionAt, findMarkdownLinkActionAt, findMarkdownMathActionAt, isSafeMarkdownLink, layoutMarkdownBlocks, loadMarkdownMathRenderer, markdownThemeSignature, paintMarkdownVisualRow, subscribeMarkdownMathRenderer } from "./block-source-D3YGTErb.js";
+import { clearMarkdownMathImageCache, enqueueMarkdownMathImages, getCachedMarkdownMathImage, getMarkdownMathImage, isMarkdownMathImageRendererReady, loadMarkdownMathImageRenderer, resolveMarkdownMathColor, setMarkdownMathRasterizer, subscribeMarkdownMathImage } from "./math-image-BZhmfUeu.js";
 import { computed, defineComponent, getCurrentInstance, h, inject, markRaw, onBeforeUnmount, shallowRef, watch } from "vue";
 
 //#region src/vue/components/TMarkdownText.ts
@@ -85,6 +86,34 @@ const TMarkdownText = defineComponent({
 			type: Boolean,
 			default: true
 		},
+		mathImages: {
+			type: Boolean,
+			default: true
+		},
+		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: false
@@ -126,16 +155,44 @@ const TMarkdownText = defineComponent({
 		const graphicsOutputVersion = shallowRef(getTerminalGraphicsOutputVersion(terminal));
 		const unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
 			graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+			enqueuePendingMathImages();
 		});
 		const unsubscribeMathRenderer = subscribeMarkdownMathRenderer(() => {
 			scheduleRebuild();
 		});
+		const unsubscribeMathImage = subscribeMarkdownMathImage(() => {
+			scheduleRebuild();
+		});
 		watch(() => `${props.streaming ? 1 : 0}:${(props.customHtmlTags ?? []).join("\0")}`, () => {
 			parser.value = markRaw(createTuiMarkdownParser({
 				streaming: props.streaming,
 				customHtmlTags: props.customHtmlTags
 			}));
 		});
+		function mathOptions() {
+			if (props.mathImages === false) return { enabled: false };
+			const resolvedColor = props.mathColor ?? resolveMarkdownMathColor(defaultStyle.value.fg);
+			return {
+				enabled: true,
+				...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 === false) return;
+			if (!getTerminalGraphicsOutput(terminal)?.capabilities.supported) return;
+			if (!isMarkdownMathImageRendererReady()) {
+				loadMarkdownMathImageRenderer().then((ready) => {
+					if (ready && alive) scheduleRebuild();
+				});
+				return;
+			}
+			enqueueMarkdownMathImages(rows.value, mathOptions());
+		}
 		function rebuildRows() {
 			rows.value = markRaw(withTextWidthProvider(widthProvider, () => buildMarkdownVisualRows(props.content, props.w, parser.value, {
 				final: props.final,
@@ -147,9 +204,11 @@ const TMarkdownText = defineComponent({
 					minHeight: props.imageMinHeight,
 					maxHeight: props.imageMaxHeight,
 					preserveAspectRatio: props.imagePreserveAspectRatio
-				}
+				},
+				math: mathOptions()
 			})));
 			documentVersion.value++;
+			enqueuePendingMathImages();
 		}
 		function scheduleRebuild() {
 			const currentVersion = ++rebuildVersion;
@@ -181,7 +240,14 @@ const TMarkdownText = 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: true });
@@ -190,6 +256,7 @@ const TMarkdownText = defineComponent({
 			rebuildVersion++;
 			unsubscribeGraphicsOutput();
 			unsubscribeMathRenderer();
+			unsubscribeMathImage();
 			clearMarkdownImageGraphics(terminal, fullRect.value);
 		});
 		const fullRect = computed(() => {
@@ -351,4 +418,4 @@ const TMarkdownText = defineComponent({
 });
 
 //#endregion
-export { TMarkdownText, TVirtualMarkdown, buildMarkdownBlocks, buildMarkdownVisualRows, createMarkdownBlockSource, createTuiMarkdownParser, isSafeMarkdownLink, layoutMarkdownBlocks, loadMarkdownMathRenderer };
+export { TMarkdownText, TVirtualMarkdown, buildMarkdownBlocks, buildMarkdownVisualRows, clearMarkdownMathImageCache, createMarkdownBlockSource, createTuiMarkdownParser, enqueueMarkdownMathImages, getCachedMarkdownMathImage, getMarkdownMathImage, isMarkdownMathImageRendererReady, isSafeMarkdownLink, layoutMarkdownBlocks, loadMarkdownMathImageRenderer, loadMarkdownMathRenderer, setMarkdownMathRasterizer, subscribeMarkdownMathImage };

package/dist/math-image-BZhmfUeu.js

@@ -0,0 +1,308 @@
+//#region src/vue/markdown/math-image.ts
+const DEFAULT_MATH_IMAGE_OPTIONS = Object.freeze({
+	cellWidthPx: 8,
+	cellHeightPx: 16,
+	scale: 2,
+	color: "#f8f8f2",
+	maxWidthCells: 0,
+	baselineRatio: .78
+});
+const MAX_CACHE_ENTRIES = 64;
+const MAX_FAILED_ENTRIES = 128;
+const mathImageCache = new Map();
+const mathImageFailed = new Set();
+const mathImageInflight = new Map();
+const mathImageListeners = new Set();
+let customRasterizer = null;
+let builtinRasterizerLoad = null;
+let builtinRasterizerReady = false;
+/**
+* Map common terminal foreground style values to hex so rasterized formulas
+* stay readable on any theme (a light formula on a light background would be
+* invisible). Unknown values resolve to `undefined` and the caller falls back
+* to a neutral default.
+*/
+const 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 void 0;
+	const trimmed = fg.trim();
+	if (trimmed.startsWith("#") && /^#[0-9a-f]{3,8}$/i.test(trimmed)) return trimmed.toLowerCase();
+	return NAMED_STYLE_FG_HEX[trimmed.toLowerCase()];
+}
+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)
+	};
+}
+function clamp01(value) {
+	if (!Number.isFinite(value)) return .78;
+	return Math.min(1, Math.max(0, value));
+}
+/**
+* Install a custom TeX -> PNG rasterizer (e.g. consumers that already have a
+* katex/mathjax pipeline). Passing `null` restores the built-in lazy loader.
+*/
+function setMarkdownMathRasterizer(rasterizer) {
+	customRasterizer = rasterizer;
+}
+function subscribeMarkdownMathImage(listener) {
+	mathImageListeners.add(listener);
+	return () => mathImageListeners.delete(listener);
+}
+/**
+* True when a rasterizer is confirmed available (a custom one was installed or
+* the built-in MathJax+resvg stack finished loading). Components should gate
+* image production on this so they never spend time rasterizing formulas while
+* the math engine is still loading or missing.
+*/
+function isMarkdownMathImageRendererReady() {
+	return customRasterizer != null || builtinRasterizerReady;
+}
+/**
+* Ensure the math image rasterizer is loaded (or resolved as unavailable).
+* Resolves `true` once a rasterizer is usable. Safe to call repeatedly; the
+* underlying load is shared and its outcome is cached.
+*/
+async function loadMarkdownMathImageRenderer() {
+	if (isMarkdownMathImageRendererReady()) return true;
+	const rasterizer = customRasterizer ?? await loadBuiltinMathRasterizer();
+	builtinRasterizerReady = rasterizer != null;
+	return 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 notifyMathImageListeners() {
+	for (const listener of mathImageListeners) try {
+		listener();
+	} catch {}
+}
+/** Synchronous cache lookup used by the markdown AST/layout phase. */
+function getCachedMarkdownMathImage(tex, mode, options) {
+	return mathImageCache.get(mathImageCacheKey(tex, mode, normalizeMathImageOptions(options))) ?? null;
+}
+/**
+* Drop all cached rasterized formulas (PNG + failed lookups). Useful for long
+* running processes that change cell metrics, and for tests.
+*/
+function clearMarkdownMathImageCache() {
+	mathImageCache.clear();
+	mathImageFailed.clear();
+}
+function evictOldestMathImageEntry() {
+	const oldest = mathImageCache.keys().next().value;
+	if (oldest != null) mathImageCache.delete(oldest);
+}
+/**
+* Resolve a TeX formula to a PNG base64 + cell size. Cached per
+* (tex, mode, cell metrics, color). In-flight requests are deduped. When a new
+* image finishes, `subscribeMarkdownMathImage` listeners are notified so
+* components can rebuild/re-paint with the real size.
+*/
+async function getMarkdownMathImage(tex, mode, options) {
+	const source = String(tex ?? "").trim();
+	if (!source) return null;
+	const normalized = normalizeMathImageOptions(options);
+	const key = mathImageCacheKey(source, mode, normalized);
+	const cached = mathImageCache.get(key);
+	if (cached) return cached;
+	if (mathImageFailed.has(key)) return null;
+	const inflight = mathImageInflight.get(key);
+	if (inflight) return inflight;
+	const pending = (async () => {
+		try {
+			const rasterizer = customRasterizer ?? await loadBuiltinMathRasterizer();
+			if (!rasterizer) return null;
+			const result = await rasterizer(source, mode, normalized);
+			if (result && result.base64) {
+				mathImageCache.set(key, result);
+				if (mathImageCache.size > MAX_CACHE_ENTRIES) evictOldestMathImageEntry();
+				notifyMathImageListeners();
+			} else if (result === null) {
+				mathImageFailed.add(key);
+				if (mathImageFailed.size > MAX_FAILED_ENTRIES) {
+					const oldest = mathImageFailed.values().next().value;
+					if (oldest != null) mathImageFailed.delete(oldest);
+				}
+			}
+			return result;
+		} catch {
+			return null;
+		} finally {
+			mathImageInflight.delete(key);
+		}
+	})();
+	mathImageInflight.set(key, pending);
+	return pending;
+}
+/**
+* Kick off rasterization for every math graphic segment in the given row range
+* that does not have a cached PNG yet. Safe to call after every row rebuild;
+* in-flight and cached requests are deduped inside getMarkdownMathImage. Pass a
+* viewport to avoid rasterizing off-screen formulas (e.g. virtualized views).
+*/
+function enqueueMarkdownMathImages(rows, options, viewport) {
+	const first = Math.max(0, Math.floor(viewport?.firstRow ?? 0));
+	const last = Math.min(rows.length, Math.max(first, Math.ceil(viewport?.lastRow ?? rows.length)));
+	for (let index = first; index < last; index++) {
+		const row = rows[index];
+		if (!row) continue;
+		for (const segment of row.segments) {
+			const graphic = segment.graphic;
+			if (graphic?.kind === "math") {
+				if (!graphic.base64 && graphic.tex) getMarkdownMathImage(graphic.tex, "display", options);
+				continue;
+			}
+			const pending = segment.mathAction?.pendingImage;
+			if (pending && segment.mathAction?.source) getMarkdownMathImage(segment.mathAction.source, segment.mathAction.mode ?? "display", options);
+		}
+	}
+}
+function base64FromBytes(bytes) {
+	const chunk = 32768;
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += chunk) binary += String.fromCharCode(...bytes.subarray(offset, offset + chunk));
+	return typeof btoa === "function" ? btoa(binary) : Buffer.from(bytes).toString("base64");
+}
+function extractSvgMarkup(containerMarkup) {
+	const start = containerMarkup.indexOf("<svg");
+	if (start < 0) return "";
+	const end = containerMarkup.lastIndexOf("</svg>");
+	if (end < start) return "";
+	return containerMarkup.slice(start, end + 6);
+}
+/**
+* resvg is a Node-only native addon. Keeping the specifier in a variable (a
+* non-literal dynamic import) stops browser bundlers (vite/rolldown) from
+* statically resolving it and failing on its platform `.node` binding; at
+* runtime a browser load fails and the rasterizer falls back to raw text.
+*/
+const RESVG_MODULE_ID = "@resvg/resvg-js";
+function loadBuiltinMathRasterizer() {
+	if (!builtinRasterizerLoad) builtinRasterizerLoad = (async () => {
+		try {
+			const [{ 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)
+			]);
+			const adaptor = liteAdaptor();
+			RegisterHTMLHandler(adaptor);
+			const texInput = new TeX({
+				packages: AllPackages,
+				formatError: () => {
+					throw new Error("Malformed TeX");
+				}
+			});
+			const svgOutput = new SVG({ fontCache: "none" });
+			const document = mathjax.document("", {
+				InputJax: texInput,
+				OutputJax: svgOutput
+			});
+			return async (source, mode, options) => {
+				const node = document.convert(source, { display: mode === "display" });
+				let svg = extractSvgMarkup(adaptor.outerHTML(node));
+				if (!svg) return null;
+				const widthEx = Number(/width="([\d.]+)ex"/.exec(svg)?.[1] ?? 0);
+				const heightEx = Number(/height="([\d.]+)ex"/.exec(svg)?.[1] ?? 0);
+				if (!(widthEx > 0) || !(heightEx > 0)) return null;
+				const exPx = options.cellHeightPx / 2 * options.scale;
+				if (mode === "inline") {
+					const naturalH = heightEx * exPx;
+					const naturalW = widthEx * exPx;
+					if (naturalH > options.cellHeightPx * options.scale * 2) return null;
+					const rectH = options.cellHeightPx * options.scale;
+					const k = rectH / naturalH;
+					const contentW = Math.max(1, Math.round(naturalW * k));
+					const widthCells = Math.max(1, Math.ceil(contentW / (options.cellWidthPx * options.scale)));
+					const rectW = widthCells * options.cellWidthPx * options.scale;
+					const verticalAlignEx = Number(/vertical-align:\s*(-?[\d.]+)ex/.exec(svg)?.[1] ?? 0);
+					const formulaBaseline = (heightEx - Math.abs(verticalAlignEx)) * exPx * k;
+					const terminalBaseline = options.baselineRatio * rectH;
+					const offsetY = terminalBaseline - formulaBaseline;
+					const inner = svg.replace(/style="vertical-align:[^"]*"/, "").replace(/width="[\d.]+ex"/, `width="${contentW}px"`).replace(/height="[\d.]+ex"/, `height="${rectH}px"`);
+					const 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>`;
+					const renderedInline = new Resvg(wrapped, { background: "rgba(0,0,0,0)" }).render();
+					const pngInline = renderedInline.asPng();
+					if (!pngInline || pngInline.length < 8) return null;
+					return {
+						base64: base64FromBytes(pngInline),
+						widthCells,
+						heightCells: 1
+					};
+				}
+				let widthPx = Math.max(1, Math.round(widthEx * exPx));
+				let heightPx = Math.max(1, Math.round(heightEx * exPx));
+				if (options.maxWidthCells > 0) {
+					const maxPx = options.maxWidthCells * options.cellWidthPx * options.scale;
+					if (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}"`);
+				const rendered = new Resvg(svg, { background: "rgba(0,0,0,0)" }).render();
+				const png = rendered.asPng();
+				if (!png || png.length < 8) return null;
+				return {
+					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;
+		}
+	})();
+	return builtinRasterizerLoad;
+}
+
+//#endregion
+export { clearMarkdownMathImageCache, enqueueMarkdownMathImages, getCachedMarkdownMathImage, getMarkdownMathImage, isMarkdownMathImageRendererReady, loadMarkdownMathImageRenderer, resolveMarkdownMathColor, setMarkdownMathRasterizer, subscribeMarkdownMathImage };