@simon_he/vue-tui 1.0.2 → 1.1.1

package/dist/block-source-5CQp4tF8.js

@@ -0,0 +1,3230 @@
+import { getRootTerminal } from "./create-terminal-DXuZ2fci.js";
+import { hasEncodedControl, sanitizeDomHref } from "./hyperlink-B35-O-cW.js";
+import { EventZIndexContextKey, currentTextWidthProvider, forEachTextCellSegment, intersectRect, normalizeCellRect, repeatChar, sanitizeInlineText, sanitizeTextBlock, sliceByCellsRange, spaces, textCellWidth$1 as textCellWidth, translateRect, useLayout, useRenderNode, useTerminal, useTerminalNode, useVisibility, withTextWidthProvider } from "./rect-Ng-3eKzF.js";
+import { terminalSelectionRowSpans, terminalSelectionVisibleRowSpans } from "./terminal-selection-CQYr--26.js";
+import { createDebugLogger, isDebugEnabled } from "./debug-logger-ChY_PXVk.js";
+import { applyWheelScroll, createWheelScrollState, resetWheelScrollState } from "./wheel-scroll-CQ22Hcyj.js";
+import { computed, defineComponent, getCurrentInstance, h, inject, markRaw, onBeforeUnmount, ref, shallowRef, watch, watchEffect } from "vue";
+import katex from "katex";
+import { getMarkdown, parseMarkdownToStructure } from "stream-markdown-parser";
+
+//#region src/renderer/terminal-graphics.ts
+const TERMINAL_GRAPHICS_PROTOCOL_PRIORITY = [
+	"kitty",
+	"iterm2",
+	"sixel"
+];
+const ESC = "\x1B";
+const BEL = "\x07";
+const ST = `${ESC}\\`;
+const ESC_RE = "\\u001B";
+const BEL_RE = "\\u0007";
+const CSI_RE = new RegExp(`${ESC_RE}\\[[0-?]*[ -/]*[@-~]`, "g");
+const OSC_RE = new RegExp(`${ESC_RE}\\][\\s\\S]*?(?:${BEL_RE}|${ESC_RE}\\\\)`, "g");
+const DCS_RE = new RegExp(`${ESC_RE}P[\\s\\S]*?${ESC_RE}\\\\`, "g");
+const APC_RE = new RegExp(`${ESC_RE}_[\\s\\S]*?${ESC_RE}\\\\`, "g");
+const C1_CSI_RE = new RegExp("\\u009B[0-?]*[ -/]*[@-~]", "g");
+const C1_OSC_RE = new RegExp(`\\u009D[\\s\\S]*?(?:${BEL_RE}|\\u009C)`, "g");
+const C1_DCS_RE = new RegExp("\\u0090[\\s\\S]*?\\u009C", "g");
+const C1_APC_RE = new RegExp("\\u009F[\\s\\S]*?\\u009C", "g");
+const MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS = 16 * 1024 * 1024;
+const MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS = 16384;
+const MAX_TERMINAL_GRAPHIC_CELLS = 1e4;
+const TERMINAL_GRAPHICS_REGISTRY = Symbol.for("@simon_he/vue-tui:v1:terminal-graphics");
+const terminalGraphicsGlobal = globalThis;
+const terminalGraphicsRegistry = terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] ?? {
+	outputs: new WeakMap(),
+	outputVersions: new WeakMap(),
+	outputListeners: new WeakMap()
+};
+terminalGraphicsGlobal[TERMINAL_GRAPHICS_REGISTRY] = terminalGraphicsRegistry;
+const terminalGraphicsOutputs = terminalGraphicsRegistry.outputs;
+const terminalGraphicsOutputVersions = terminalGraphicsRegistry.outputVersions;
+const 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) {
+	const rootTerminal = getRootTerminal(terminal);
+	let listeners = terminalGraphicsOutputListeners.get(rootTerminal);
+	if (!listeners) {
+		listeners = new Set();
+		terminalGraphicsOutputListeners.set(rootTerminal, listeners);
+	}
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+		if (listeners.size === 0) terminalGraphicsOutputListeners.delete(rootTerminal);
+	};
+}
+function envString(env, key) {
+	const value = env[key];
+	return value == null ? void 0 : String(value);
+}
+function truthy(value) {
+	if (value == null) return false;
+	return /^(1|true|yes|on)$/i.test(String(value));
+}
+function readStdoutIsTTY() {
+	const maybeProcess = globalThis.process;
+	return Boolean(maybeProcess?.stdout?.isTTY);
+}
+function readProcessEnv() {
+	const maybeProcess = globalThis.process;
+	return maybeProcess?.env ?? {};
+}
+function normalizeMode(value) {
+	const raw = String(value ?? "auto").trim().toLowerCase();
+	if (raw === "auto" || raw === "off" || raw === "none" || raw === "kitty" || raw === "iterm2" || raw === "sixel" || raw === "unicode") return raw === "off" ? "none" : raw;
+	return "auto";
+}
+function isTerminalGraphicsProtocol(value) {
+	return value === "kitty" || value === "iterm2" || value === "sixel";
+}
+function uniqueProtocols(protocols) {
+	return [...new Set(protocols)];
+}
+function pickBestTerminalGraphicsProtocol(protocols) {
+	const available = new Set(protocols);
+	for (const protocol of TERMINAL_GRAPHICS_PROTOCOL_PRIORITY) if (available.has(protocol)) return protocol;
+	return null;
+}
+function detectCandidates(env) {
+	const candidates = [];
+	const term = String(envString(env, "TERM") ?? "").toLowerCase();
+	const termProgram = String(envString(env, "TERM_PROGRAM") ?? "").toLowerCase();
+	const termProgramVersion = String(envString(env, "TERM_PROGRAM_VERSION") ?? "").toLowerCase();
+	if (envString(env, "KITTY_WINDOW_ID") || envString(env, "GHOSTTY_RESOURCES_DIR") || /(?:^|-)kitty(?:-|$)/i.test(term) || term.includes("ghostty") || termProgram.includes("ghostty")) candidates.push("kitty");
+	if (termProgram.includes("iterm") || termProgram.includes("wezterm") || envString(env, "WEZTERM_PANE") || envString(env, "WEZTERM_EXECUTABLE")) candidates.push("iterm2");
+	if (truthy(envString(env, "VUE_TUI_SIXEL")) || truthy(envString(env, "VUE_TUI_GRAPHICS_SIXEL")) || String(envString(env, "TERMINAL_GRAPHICS") ?? "").toLowerCase().includes("sixel") || /\bsixel\b/i.test(`${term} ${termProgram} ${termProgramVersion}`)) candidates.push("sixel");
+	return uniqueProtocols(candidates);
+}
+function capabilitiesFor(protocol, input) {
+	const supported = protocol === "kitty" || protocol === "iterm2" || protocol === "sixel";
+	const candidates = uniqueProtocols([...input.candidates ?? (supported ? [protocol] : [])]);
+	return {
+		supported,
+		kitty: protocol === "kitty" || candidates.includes("kitty"),
+		iterm2: protocol === "iterm2" || candidates.includes("iterm2"),
+		sixel: protocol === "sixel" || candidates.includes("sixel"),
+		preferredProtocol: supported ? protocol : null,
+		protocol,
+		candidates,
+		stdoutIsTTY: input.stdoutIsTTY,
+		insideTmux: input.insideTmux,
+		insideScreen: input.insideScreen,
+		insideZellij: input.insideZellij,
+		multiplexer: input.multiplexer,
+		passthrough: input.passthrough,
+		forced: input.forced,
+		reason: input.reason
+	};
+}
+function detectTerminalGraphicsCapabilities(options = {}) {
+	const env = options.env ?? readProcessEnv();
+	const stdoutIsTTY = options.stdoutIsTTY ?? options.isTTY ?? readStdoutIsTTY();
+	const term = String(envString(env, "TERM") ?? "").toLowerCase();
+	const insideTmux = Boolean(envString(env, "TMUX")) || term.includes("tmux");
+	const insideScreen = Boolean(envString(env, "STY")) || term.startsWith("screen");
+	const insideZellij = Boolean(envString(env, "ZELLIJ") || envString(env, "ZELLIJ_SESSION_NAME")) || term.includes("zellij");
+	const multiplexer = insideTmux ? "tmux" : insideScreen ? "screen" : insideZellij ? "zellij" : null;
+	const passthroughRequested = options.passthrough ?? (truthy(envString(env, "VUE_TUI_TERMINAL_GRAPHICS_PASSTHROUGH")) || truthy(envString(env, "VUE_TUI_GRAPHICS_TMUX_PASSTHROUGH")));
+	const passthroughSupported = !multiplexer || multiplexer === "tmux";
+	const passthrough = passthroughRequested && passthroughSupported;
+	const protocolOptionProvided = options.protocol != null;
+	const mode = normalizeMode(options.protocol ?? envString(env, "VUE_TUI_TERMINAL_GRAPHICS") ?? envString(env, "VUE_TUI_GRAPHICS_PROTOCOL"));
+	const forceFromOption = options.force === true;
+	const force = options.force ?? truthy(envString(env, "VUE_TUI_GRAPHICS_FORCE"));
+	const base = {
+		stdoutIsTTY,
+		insideTmux,
+		insideScreen,
+		insideZellij,
+		multiplexer,
+		passthrough,
+		forced: force
+	};
+	if (mode === "none") return capabilitiesFor("none", {
+		...base,
+		reason: protocolOptionProvided ? "disabled-by-option" : "disabled-by-env"
+	});
+	if (!stdoutIsTTY && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: "stdout-is-not-tty"
+	});
+	if (truthy(envString(env, "CI")) && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: "ci"
+	});
+	if (multiplexer && passthroughRequested && !passthroughSupported && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: `${multiplexer}-passthrough-not-implemented`
+	});
+	if (multiplexer && !passthrough && !force) return capabilitiesFor("unicode", {
+		...base,
+		reason: `${multiplexer}-without-passthrough`
+	});
+	if (mode === "kitty" || mode === "iterm2" || mode === "sixel") return capabilitiesFor(mode, {
+		...base,
+		candidates: [mode],
+		reason: force ? forceFromOption ? "forced-by-option" : "forced-by-env" : protocolOptionProvided ? "selected-by-option" : "selected-by-env"
+	});
+	if (mode === "unicode") return capabilitiesFor("unicode", {
+		...base,
+		reason: protocolOptionProvided ? "unicode-forced-by-option" : "unicode-forced-by-env"
+	});
+	const candidates = detectCandidates(env);
+	const preferredProtocol = pickBestTerminalGraphicsProtocol(candidates);
+	const protocol = preferredProtocol ?? "unicode";
+	return capabilitiesFor(protocol, {
+		...base,
+		candidates,
+		reason: protocol === "unicode" ? "no-supported-graphics-protocol-detected" : "auto-detected"
+	});
+}
+function hashTerminalGraphicsString(input) {
+	let hash = 2166136261;
+	for (let index = 0; index < input.length; index += 1) {
+		hash ^= input.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function stableTerminalGraphicNumericId(input, options = {}) {
+	const min = Math.floor(options.min ?? 1);
+	const max = Math.floor(options.max ?? 2147483647);
+	const span = Math.max(1, max - min + 1);
+	let 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) {
+	const n = Math.trunc(Number(value));
+	if (!Number.isFinite(n) || n <= 0) return null;
+	return Math.min(max, n);
+}
+function normalizeTerminalGraphicSize(width, height) {
+	const w = positiveGraphicInt(width, MAX_TERMINAL_GRAPHIC_CELLS);
+	const h$1 = positiveGraphicInt(height, MAX_TERMINAL_GRAPHIC_CELLS);
+	if (w == null || h$1 == null) return null;
+	if (w * h$1 > MAX_TERMINAL_GRAPHIC_CELLS) return null;
+	return {
+		width: w,
+		height: h$1
+	};
+}
+function canDrawTerminalGraphicRect(rect, size) {
+	const x = Math.floor(rect.x);
+	const y = Math.floor(rect.y);
+	const graphicSize = normalizeTerminalGraphicSize(rect.w, rect.h);
+	const cols = Math.max(0, Math.floor(size.cols));
+	const rows = Math.max(0, Math.floor(size.rows));
+	return graphicSize != null && cols > 0 && rows > 0 && Number.isFinite(x) && Number.isFinite(y) && x >= 0 && y >= 0 && x < cols && y < rows;
+}
+function withoutNestedEscapes(body) {
+	return !body.includes(ESC) && !body.includes(BEL);
+}
+function isBase64ish(value) {
+	return /^[A-Za-z0-9+/=]*$/.test(value);
+}
+function parseKittyControls(raw) {
+	const out = new Map();
+	if (!/^[A-Za-z0-9_,=+.\-:]*$/.test(raw)) return null;
+	for (const part of raw.split(",")) {
+		if (!part) continue;
+		const eq = part.indexOf("=");
+		if (eq <= 0) return null;
+		const key = part.slice(0, eq);
+		const value = part.slice(eq + 1);
+		if (!/^[A-Za-z]$/.test(key)) return null;
+		if (!/^[A-Za-z0-9+.\-:]*$/.test(value)) return null;
+		out.set(key, value);
+	}
+	return out;
+}
+function parseKittyPackets(sequence) {
+	const packets = [];
+	let index = 0;
+	while (index < sequence.length) {
+		if (!sequence.startsWith(`${ESC}_G`, index)) return null;
+		const end = sequence.indexOf(ST, index + 3);
+		if (end < 0) return null;
+		const body = sequence.slice(index + 3, end);
+		if (!withoutNestedEscapes(body)) return null;
+		const semicolon = body.indexOf(";");
+		const rawControls = semicolon >= 0 ? body.slice(0, semicolon) : body;
+		const payload = semicolon >= 0 ? body.slice(semicolon + 1) : "";
+		const controls = parseKittyControls(rawControls);
+		if (!controls) return null;
+		if (payload && !isBase64ish(payload)) return null;
+		packets.push({
+			controls,
+			payload
+		});
+		index = end + ST.length;
+	}
+	return packets.length ? packets : null;
+}
+const KITTY_DRAW_FIRST_CONTROL_KEYS = new Set([
+	"a",
+	"f",
+	"q",
+	"C",
+	"i",
+	"I",
+	"p",
+	"c",
+	"r",
+	"x",
+	"y",
+	"w",
+	"h",
+	"z",
+	"m",
+	"t"
+]);
+const KITTY_DRAW_CONTINUATION_CONTROL_KEYS = new Set([
+	"a",
+	"q",
+	"m"
+]);
+const KITTY_CLEAR_CONTROL_KEYS = new Set([
+	"a",
+	"d",
+	"i",
+	"I",
+	"p",
+	"q"
+]);
+function kittyControlsUseOnly(controls, allowed) {
+	for (const key of controls.keys()) if (!allowed.has(key)) return false;
+	return true;
+}
+const KITTY_UINT32_MAX = 4294967295;
+const KITTY_INT32_MIN = -2147483648;
+const KITTY_INT32_MAX = 2147483647;
+function kittyControlIsUint32(controls, key, min = 0) {
+	const value = controls.get(key);
+	if (value == null) return true;
+	if (!/^\d+$/.test(value)) return false;
+	const n = Number(value);
+	return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX;
+}
+function kittyControlIsInt32(controls, key) {
+	const value = controls.get(key);
+	if (value == null) return true;
+	if (!/^-?\d+$/.test(value)) return false;
+	const n = Number(value);
+	return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX;
+}
+function kittyControlPositiveInt(controls, key, fallback) {
+	const value = controls.get(key);
+	if (value == null) return fallback;
+	if (!/^\d+$/.test(value)) return null;
+	const n = Number(value);
+	return Number.isSafeInteger(n) && n >= 1 ? n : null;
+}
+function kittyControlIsTerminalGraphicCellsBounded(controls) {
+	const columns = kittyControlPositiveInt(controls, "c", 1);
+	const rows = kittyControlPositiveInt(controls, "r", 1);
+	return columns != null && rows != null && columns * rows <= MAX_TERMINAL_GRAPHIC_CELLS;
+}
+function validateKittySharedSafeControls(controls) {
+	const q = controls.get("q");
+	if (q != null && !/^[0-2]$/.test(q)) return false;
+	const cursorMove = controls.get("C");
+	if (cursorMove != null && !/^[01]$/.test(cursorMove)) return false;
+	for (const key of [
+		"i",
+		"I",
+		"p"
+	]) if (!kittyControlIsUint32(controls, key)) return false;
+	for (const key of ["c", "r"]) if (!kittyControlIsUint32(controls, key, 1)) return false;
+	if (!kittyControlIsTerminalGraphicCellsBounded(controls)) return false;
+	for (const key of ["x", "y"]) if (!kittyControlIsUint32(controls, key)) return false;
+	for (const key of ["w", "h"]) if (!kittyControlIsUint32(controls, key, 1)) return false;
+	if (!kittyControlIsInt32(controls, "z")) return false;
+	const transmissionMedium = controls.get("t");
+	if (transmissionMedium != null && transmissionMedium !== "d") return false;
+	return true;
+}
+function validateKittySequence(sequence, op = "draw") {
+	const packets = parseKittyPackets(sequence);
+	if (!packets) return false;
+	if (op === "clear") {
+		if (packets.length !== 1) return false;
+		const packet = packets[0];
+		if (!kittyControlsUseOnly(packet.controls, KITTY_CLEAR_CONTROL_KEYS)) return false;
+		if (!validateKittySharedSafeControls(packet.controls)) return false;
+		if (packet.payload) return false;
+		if (packet.controls.get("a") !== "d") return false;
+		const d = packet.controls.get("d");
+		return d == null || /^[aAcCiI]$/.test(d);
+	}
+	const first = packets[0];
+	if (!kittyControlsUseOnly(first.controls, KITTY_DRAW_FIRST_CONTROL_KEYS)) return false;
+	if (!validateKittySharedSafeControls(first.controls)) return false;
+	if (first.controls.get("a") === "p") {
+		if (packets.length !== 1) return false;
+		if (first.payload) return false;
+		if (!first.controls.has("i") && !first.controls.has("I")) return false;
+		return true;
+	}
+	if (first.controls.get("a") !== "T") return false;
+	if (!first.payload) return false;
+	const f = first.controls.get("f");
+	if (f != null && f !== "24" && f !== "32" && f !== "100") return false;
+	const firstMore = first.controls.get("m");
+	if (firstMore != null && firstMore !== "0" && firstMore !== "1") return false;
+	if (packets.length > 1 && firstMore !== "1") return false;
+	for (let i = 1; i < packets.length; i++) {
+		const packet = packets[i];
+		if (!kittyControlsUseOnly(packet.controls, KITTY_DRAW_CONTINUATION_CONTROL_KEYS)) return false;
+		if (!validateKittySharedSafeControls(packet.controls)) return false;
+		const action = packet.controls.get("a");
+		if (action != null && action !== "T") return false;
+		const m = packet.controls.get("m");
+		if (m !== "0" && m !== "1") return false;
+		if (!packet.payload && !(i === packets.length - 1 && m === "0")) return false;
+	}
+	if (packets.length > 1 && packets[packets.length - 1].controls.get("m") === "1") return false;
+	return true;
+}
+function validateIterm2Dimension(value) {
+	return /^auto$/i.test(value) || /^(?:[1-9]\d{0,4})(?:px|%)?$/.test(value);
+}
+function validateIterm2Params(params) {
+	const seen = new Set();
+	let inline = false;
+	for (const part of params.split(";").filter(Boolean)) {
+		const eq = part.indexOf("=");
+		if (eq <= 0) return false;
+		const key = part.slice(0, eq);
+		const value = part.slice(eq + 1);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		switch (key) {
+			case "inline":
+				if (value !== "1") return false;
+				inline = true;
+				break;
+			case "width":
+			case "height":
+				if (!validateIterm2Dimension(value)) return false;
+				break;
+			case "preserveAspectRatio":
+			case "doNotMoveCursor":
+				if (!/^[01]$/.test(value)) return false;
+				break;
+			default: return false;
+		}
+	}
+	return inline;
+}
+function validateIterm2Sequence(sequence, op = "draw") {
+	if (op === "clear") return false;
+	let index = 0;
+	while (index < sequence.length) {
+		const prefix = `${ESC}]1337;File=`;
+		if (!sequence.startsWith(prefix, index)) return false;
+		const belEnd = sequence.indexOf(BEL, index + prefix.length);
+		const stEnd = sequence.indexOf(ST, index + prefix.length);
+		const end = belEnd >= 0 && stEnd >= 0 ? Math.min(belEnd, stEnd) : belEnd >= 0 ? belEnd : stEnd;
+		if (end < 0) return false;
+		const body = sequence.slice(index + `${ESC}]1337;`.length, end);
+		if (!body.startsWith("File=")) return false;
+		if (!withoutNestedEscapes(body)) return false;
+		const colon = body.indexOf(":");
+		if (colon < 0) return false;
+		const params = body.slice(5, colon);
+		const payload = body.slice(colon + 1);
+		if (!/^[A-Za-z0-9_=;,.%+\-:]*$/.test(params)) return false;
+		if (!payload || !isBase64ish(payload)) return false;
+		if (!validateIterm2Params(params)) return false;
+		index = end + (end === stEnd ? ST.length : BEL.length);
+	}
+	return sequence.length > 0;
+}
+function validateSixelSequence(sequence, op = "draw") {
+	if (op === "clear") return false;
+	let index = 0;
+	while (index < sequence.length) {
+		if (!sequence.startsWith(`${ESC}P`, index)) return false;
+		const end = sequence.indexOf(ST, index + 2);
+		if (end < 0) return false;
+		const body = sequence.slice(index + 2, end);
+		if (!withoutNestedEscapes(body)) return false;
+		for (let i = 0; i < body.length; i++) {
+			const code = body.charCodeAt(i);
+			if (code < 32 || code > 126) return false;
+		}
+		const q = body.indexOf("q");
+		if (q < 0 || q > 32) return false;
+		const introducer = body.slice(0, q);
+		if (!/^[0-9;?]*$/.test(introducer)) return false;
+		const data = body.slice(q + 1);
+		if (!data.length) return false;
+		index = end + ST.length;
+	}
+	return sequence.length > 0;
+}
+function stripTerminalControlChars(value) {
+	let out = "";
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code === 127 || code >= 128 && code <= 159) continue;
+		out += value[index];
+	}
+	return out;
+}
+function sanitizeTerminalFallbackText(text) {
+	return stripTerminalControlChars(String(text ?? "").replace(OSC_RE, "").replace(CSI_RE, "").replace(DCS_RE, "").replace(APC_RE, "").replace(C1_OSC_RE, "").replace(C1_CSI_RE, "").replace(C1_DCS_RE, "").replace(C1_APC_RE, "")).slice(0, MAX_TERMINAL_GRAPHICS_FALLBACK_CHARS);
+}
+function isSafeTerminalGraphicsSequence(sequence, protocol, op = "draw") {
+	if (!isTerminalGraphicsProtocol(protocol)) return false;
+	if (!sequence || sequence.length > MAX_TERMINAL_GRAPHICS_SEQUENCE_CHARS) return false;
+	return protocol === "kitty" ? validateKittySequence(sequence, op) : protocol === "iterm2" ? validateIterm2Sequence(sequence, op) : validateSixelSequence(sequence, op);
+}
+function uint32Control(key, value, min = 0) {
+	if (value == null) return "";
+	const n = Math.floor(value);
+	return Number.isSafeInteger(n) && n >= min && n <= KITTY_UINT32_MAX ? `${key}=${n}` : "";
+}
+function int32Control(key, value) {
+	if (value == null) return "";
+	const n = Math.floor(value);
+	return Number.isSafeInteger(n) && n >= KITTY_INT32_MIN && n <= KITTY_INT32_MAX ? `${key}=${n}` : "";
+}
+function sanitizeBase64(value) {
+	const data = String(value ?? "").replace(/\s+/g, "");
+	return isBase64ish(data) ? data : "";
+}
+function kittyGraphicCellControls(columns, rows) {
+	if (columns == null && rows == null) return [];
+	const size = normalizeTerminalGraphicSize(columns ?? 1, rows ?? 1);
+	if (!size) return [];
+	return [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) {
+	const normalizedSize = Math.max(4, Math.floor(chunkSize / 4) * 4);
+	const chunks = [];
+	for (let index = 0; index < value.length; index += normalizedSize) chunks.push(value.slice(index, index + normalizedSize));
+	return chunks.length ? chunks : [""];
+}
+function createKittyPlacementSequence(options) {
+	const imageId = uint32Control("i", options.imageId);
+	const imageNumber = uint32Control("I", options.imageNumber);
+	if (!imageId && !imageNumber) return "";
+	const controls = [
+		"a=p",
+		options.quiet === false ? "" : "q=2",
+		options.noCursorMove === false ? "" : "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 `${ESC}_G${controls.join(",")}${ST}`;
+}
+function createKittyGraphicsSequence(base64Png, options = {}) {
+	const data = sanitizeBase64(base64Png);
+	if (!data) return "";
+	const chunks = chunkBase64(data, options.chunkSize ?? 4096);
+	const baseControls = [
+		"a=T",
+		"f=100",
+		options.quiet === false ? "" : "q=2",
+		options.noCursorMove === false ? "" : "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) => {
+		const last = index === chunks.length - 1;
+		const controls = index === 0 ? [...baseControls, chunks.length > 1 ? `m=${last ? 0 : 1}` : ""] : [options.quiet === false ? "" : "q=2", `m=${last ? 0 : 1}`].filter(Boolean);
+		return `${ESC}_G${controls.filter(Boolean).join(",")};${chunk}${ST}`;
+	}).join("");
+}
+function createKittyDeleteGraphicsSequence(options = {}) {
+	const controls = ["a=d"];
+	if (options.allVisible) controls.push(`d=${options.freeImageData ? "A" : "a"}`);
+	else if (options.imageId != null) {
+		const imageId = uint32Control("i", options.imageId);
+		const 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 "";
+	if (options.quiet !== false) controls.push("q=2");
+	return `${ESC}_G${controls.filter(Boolean).join(",")}${ST}`;
+}
+function createIterm2InlineImageSequence(base64Data, options = {}) {
+	const data = sanitizeBase64(base64Data);
+	if (!data) return "";
+	const params = [
+		"inline=1",
+		options.width != null ? `width=${formatItermDimension(options.width)}` : "",
+		options.height != null ? `height=${formatItermDimension(options.height)}` : "",
+		`preserveAspectRatio=${options.preserveAspectRatio === false ? 0 : 1}`,
+		options.doNotMoveCursor === false ? "" : "doNotMoveCursor=1"
+	].filter(Boolean);
+	return `${ESC}]1337;File=${params.join(";")}:${data}${BEL}`;
+}
+function formatItermDimension(value) {
+	if (typeof value === "number") {
+		const n = Math.floor(value);
+		if (!Number.isFinite(n)) return "auto";
+		return String(Math.min(99999, Math.max(1, n)));
+	}
+	const raw = String(value ?? "").trim();
+	return validateIterm2Dimension(raw) ? raw : "auto";
+}
+
+//#endregion
+//#region src/vue/markdown/image.ts
+const DATA_IMAGE_RE = /^data:(image\/[A-Za-z0-9.+-]+);base64,([A-Za-z0-9+/=\s]+)$/i;
+const SAFE_IMAGE_MIME_RE = /^image\/(?:png|jpeg|jpg|gif|webp)$/i;
+function sanitizeMarkdownImageSource(src) {
+	if (typeof src !== "string") return null;
+	const raw = src.trim();
+	if (!raw || raw !== src) return null;
+	const data = raw.match(DATA_IMAGE_RE);
+	if (data) {
+		const mime = data[1].toLowerCase();
+		const base64 = data[2].replace(/\s+/g, "");
+		if (!SAFE_IMAGE_MIME_RE.test(mime)) return null;
+		if (!/^[A-Za-z0-9+/=]+$/.test(base64)) return null;
+		return {
+			src: raw,
+			mime,
+			base64
+		};
+	}
+	if (/^(?:blob|file):/i.test(raw)) {
+		if (raw.includes("\\") || /\s/u.test(raw) || hasEncodedControl(raw)) return null;
+		try {
+			const url = new URL(raw);
+			if (url.protocol === "blob:" || url.protocol === "file:") return { src: url.toString() };
+		} catch {
+			return null;
+		}
+	}
+	const safe = sanitizeDomHref(raw, { allowRelative: true });
+	return safe ? { src: safe } : null;
+}
+const BASE64_TABLE = (() => {
+	const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+	const table = new Map();
+	for (let i = 0; i < chars.length; i++) table.set(chars[i], i);
+	return table;
+})();
+function decodeBase64Prefix(value, maxBytes) {
+	const bytes = [];
+	let buffer = 0;
+	let bits = 0;
+	for (const ch of value.replace(/\s+/g, "")) {
+		if (ch === "=") break;
+		const sextet = BASE64_TABLE.get(ch);
+		if (sextet == null) continue;
+		buffer = buffer << 6 | sextet;
+		bits += 6;
+		while (bits >= 8) {
+			bits -= 8;
+			bytes.push(buffer >> bits & 255);
+			if (bytes.length >= maxBytes) return Uint8Array.from(bytes);
+		}
+	}
+	return Uint8Array.from(bytes);
+}
+function u16be(bytes, offset) {
+	return (bytes[offset] ?? 0) << 8 | (bytes[offset + 1] ?? 0);
+}
+function u16le(bytes, offset) {
+	return (bytes[offset] ?? 0) | (bytes[offset + 1] ?? 0) << 8;
+}
+function u24le(bytes, offset) {
+	return (bytes[offset] ?? 0) | (bytes[offset + 1] ?? 0) << 8 | (bytes[offset + 2] ?? 0) << 16;
+}
+function u32be(bytes, offset) {
+	return (bytes[offset] ?? 0) * 16777216 + ((bytes[offset + 1] ?? 0) << 16 | (bytes[offset + 2] ?? 0) << 8 | (bytes[offset + 3] ?? 0));
+}
+function validDimensions(width, height) {
+	return Number.isFinite(width) && Number.isFinite(height) && width > 0 && height > 0 ? {
+		width,
+		height
+	} : null;
+}
+function readMarkdownImageDimensions(base64) {
+	if (!base64) return null;
+	const bytes = decodeBase64Prefix(base64, 4096);
+	if (bytes.length < 10) return null;
+	if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[12] === 73 && bytes[13] === 72 && bytes[14] === 68 && bytes[15] === 82) return validDimensions(u32be(bytes, 16), u32be(bytes, 20));
+	if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) return validDimensions(u16le(bytes, 6), u16le(bytes, 8));
+	if (bytes[0] === 255 && bytes[1] === 216) for (let offset = 2; offset + 8 < bytes.length;) {
+		if (bytes[offset] !== 255) {
+			offset++;
+			continue;
+		}
+		const marker = bytes[offset + 1] ?? 0;
+		if (marker === 217 || marker === 218) break;
+		const length = u16be(bytes, offset + 2);
+		if (length < 2) break;
+		if (marker >= 192 && marker <= 195 || marker >= 197 && marker <= 199 || marker >= 201 && marker <= 203 || marker >= 205 && marker <= 207) return validDimensions(u16be(bytes, offset + 7), u16be(bytes, offset + 5));
+		offset += 2 + length;
+	}
+	if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) {
+		const format = String.fromCharCode(bytes[12] ?? 0, bytes[13] ?? 0, bytes[14] ?? 0, bytes[15] ?? 0);
+		if (format === "VP8X" && bytes.length >= 30) return validDimensions(u24le(bytes, 24) + 1, u24le(bytes, 27) + 1);
+		if (format === "VP8 " && bytes.length >= 30) return validDimensions(u16le(bytes, 26) & 16383, u16le(bytes, 28) & 16383);
+		if (format === "VP8L" && bytes.length >= 25 && bytes[20] === 47) {
+			const b0 = bytes[21] ?? 0;
+			const b1 = bytes[22] ?? 0;
+			const b2 = bytes[23] ?? 0;
+			const b3 = bytes[24] ?? 0;
+			return validDimensions(1 + ((b1 & 63) << 8 | b0), 1 + (b3 << 6 | b2 >> 2));
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/vue/markdown/math.ts
+const KATEX_TEXT_OPTIONS = Object.freeze({
+	output: "mathml",
+	throwOnError: false,
+	strict: "ignore",
+	trust: false,
+	maxSize: 20,
+	maxExpand: 200
+});
+const KATEX_VALIDATE_OPTIONS = Object.freeze({
+	...KATEX_TEXT_OPTIONS,
+	throwOnError: true
+});
+const TEX_SYMBOLS = Object.freeze({
+	alpha: "α",
+	beta: "β",
+	gamma: "γ",
+	delta: "δ",
+	epsilon: "ε",
+	theta: "θ",
+	lambda: "λ",
+	mu: "μ",
+	pi: "π",
+	rho: "ρ",
+	sigma: "σ",
+	tau: "τ",
+	phi: "φ",
+	omega: "ω",
+	Gamma: "Γ",
+	Delta: "Δ",
+	Theta: "Θ",
+	Lambda: "Λ",
+	Pi: "Π",
+	Sigma: "Σ",
+	Phi: "Φ",
+	Omega: "Ω",
+	int: "∫",
+	sum: "∑",
+	prod: "∏",
+	infty: "∞",
+	infinity: "∞",
+	pm: "±",
+	times: "×",
+	cdot: "·",
+	div: "÷",
+	le: "≤",
+	leq: "≤",
+	ge: "≥",
+	geq: "≥",
+	neq: "≠",
+	ne: "≠",
+	approx: "≈",
+	equiv: "≡",
+	to: "→",
+	rightarrow: "→",
+	leftarrow: "←",
+	leftrightarrow: "↔",
+	partial: "∂",
+	nabla: "∇",
+	sqrt: "√"
+});
+const SUPPORTED_COMMANDS = 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 mathmlTagName(tag) {
+	const start = tag.startsWith("/") ? 1 : 0;
+	let end = start;
+	while (end < tag.length) {
+		const ch = tag[end];
+		if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "/") break;
+		end++;
+	}
+	return tag.slice(start, end).toLowerCase();
+}
+function textFromKatexMathml(html) {
+	let readable = "";
+	let offset = 0;
+	const lowerHtml = html.toLowerCase();
+	while (offset < html.length) {
+		const tagStart = html.indexOf("<", offset);
+		if (tagStart < 0) {
+			readable += html.slice(offset);
+			break;
+		}
+		readable += html.slice(offset, tagStart);
+		const tagEnd = html.indexOf(">", tagStart + 1);
+		if (tagEnd < 0) break;
+		const tag = html.slice(tagStart + 1, tagEnd).trim();
+		const tagName = mathmlTagName(tag);
+		const closing = tag.startsWith("/");
+		if (!closing && tagName === "annotation") {
+			const annotationEnd = lowerHtml.indexOf("</annotation>", tagEnd + 1);
+			offset = annotationEnd < 0 ? tagEnd + 1 : annotationEnd + 13;
+			continue;
+		}
+		if (!closing && tagName === "mfrac") readable += "(";
+		else if (closing && tagName === "mfrac") readable += ")";
+		else if (!closing && tagName === "mspace") readable += " ";
+		offset = tagEnd + 1;
+	}
+	const text = sanitizeInlineText(decodeXmlEntities(readable).replace(/[<>]/g, "").replace(/\s+/g, " ").trim());
+	return text;
+}
+function approximateTexToUnicode(tex) {
+	let out = String(tex ?? "");
+	out = out.replace(/\\frac\s*\{([^{}]*)\}\s*\{([^{}]*)\}/g, "$1/$2");
+	out = out.replace(/\\sqrt\s*\{([^{}]*)\}/g, "√($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();
+	return sanitizeInlineText(out.replace(/[<>]/g, ""));
+}
+function canRenderTerminalMath(tex) {
+	const source = String(tex ?? "").trim();
+	if (!source || source.length > 160) return false;
+	if (/\\(?:begin|end|left|right|matrix|cases|array|align|color|href|html|includegraphics|class|style|tag|text|operatorname)\b/.test(source)) return false;
+	const commands = source.matchAll(/\\([A-Za-z]+)\b/g);
+	for (const match of commands) if (!SUPPORTED_COMMANDS.has(match[1] ?? "")) return false;
+	try {
+		katex.renderToString(source, KATEX_VALIDATE_OPTIONS);
+	} catch {
+		return false;
+	}
+	return true;
+}
+function renderMarkdownInlineMathSegment(tex) {
+	const source = String(tex ?? "");
+	if (!source.trim()) return {
+		text: "",
+		supported: false
+	};
+	if (!canRenderTerminalMath(source)) return {
+		text: "",
+		supported: false
+	};
+	try {
+		const html = katex.renderToString(source, KATEX_TEXT_OPTIONS);
+		const rendered = /\\frac\b/.test(source) ? approximateTexToUnicode(source) : textFromKatexMathml(html);
+		if (rendered && !rendered.includes("\\")) return {
+			text: rendered,
+			supported: true
+		};
+	} catch {
+		return {
+			text: "",
+			supported: false
+		};
+	}
+	const approximate = approximateTexToUnicode(source);
+	return approximate && !approximate.includes("\\") ? {
+		text: approximate,
+		supported: true
+	} : {
+		text: "",
+		supported: false
+	};
+}
+
+//#endregion
+//#region src/vue/markdown/parser.ts
+const markdownInstanceCache = new Map();
+const MAX_MARKDOWN_INSTANCE_CACHE = 32;
+function sanitizeMarkdownLink(url) {
+	return sanitizeDomHref(url, { allowRelative: true });
+}
+function isSafeMarkdownLink(url) {
+	return sanitizeMarkdownLink(url) != null;
+}
+function isSafeMarkdownDestination(url) {
+	return isSafeMarkdownLink(url) || sanitizeMarkdownImageSource(url) != null;
+}
+function normalizeCustomHtmlTags(config) {
+	return Array.from(new Set(config?.customHtmlTags?.filter(Boolean) ?? [])).sort();
+}
+function markdownInstanceCacheKey(customHtmlTags) {
+	return JSON.stringify({ customHtmlTags });
+}
+function getCachedMarkdownInstance(customHtmlTags) {
+	const cacheKey = markdownInstanceCacheKey(customHtmlTags);
+	const cached = markdownInstanceCache.get(cacheKey);
+	if (cached) {
+		markdownInstanceCache.delete(cacheKey);
+		markdownInstanceCache.set(cacheKey, cached);
+		return cached;
+	}
+	const created = getMarkdown(`vue-tui-markdown:${cacheKey}`, { customHtmlTags });
+	markdownInstanceCache.set(cacheKey, created);
+	while (markdownInstanceCache.size > MAX_MARKDOWN_INSTANCE_CACHE) {
+		const oldest = markdownInstanceCache.keys().next().value;
+		if (oldest == null) break;
+		markdownInstanceCache.delete(oldest);
+	}
+	return created;
+}
+function createTuiMarkdownParser(config) {
+	const customHtmlTags = normalizeCustomHtmlTags(config);
+	const md = getCachedMarkdownInstance(customHtmlTags);
+	function parse(content, final) {
+		return parseMarkdownToStructure(content, md, {
+			final,
+			customHtmlTags,
+			requireClosingStrong: final || !config?.streaming,
+			validateLink: isSafeMarkdownDestination
+		});
+	}
+	return { parse };
+}
+
+//#endregion
+//#region src/vue/markdown/ast.ts
+const EMPTY_PREFIX = Object.freeze([]);
+const HARD_BREAK_SEGMENT = Object.freeze({
+	text: "",
+	hardBreak: true
+});
+const TERMINAL_CELL_WIDTH_TO_HEIGHT_RATIO = .5;
+function mergeStyle$1(base, overlay) {
+	if (!base) return overlay;
+	if (!overlay) return base;
+	return {
+		...base,
+		...overlay
+	};
+}
+function trimBlockArray(blocks) {
+	let start = 0;
+	let end = blocks.length;
+	while (start < end && blocks[start]?.type === "blank") start++;
+	while (end > start && blocks[end - 1]?.type === "blank") end--;
+	return blocks.slice(start, end);
+}
+function nodeChildren(node) {
+	return "children" in node && Array.isArray(node.children) ? node.children : [];
+}
+function stringProp(node, key) {
+	const value = node[key];
+	return typeof value === "string" ? value : "";
+}
+function imageSourceFromRaw(raw) {
+	if (!raw.startsWith("![")) return "";
+	const marker = raw.indexOf("](");
+	if (marker < 0 || !raw.endsWith(")")) return "";
+	const destination = raw.slice(marker + 2, -1).trim();
+	if (destination.startsWith("<")) {
+		const end = destination.indexOf(">");
+		return end > 1 ? destination.slice(1, end) : "";
+	}
+	return destination.split(/\s+/u)[0] ?? "";
+}
+function imageFallbackText(raw, rawSource, sourceSrc) {
+	if (raw) return raw;
+	const src = rawSource || sourceSrc;
+	return src ? `![](${src})` : "image";
+}
+function normalizeImageResolverResult(result) {
+	if (typeof result === "string") return { base64: result.replace(/\s+/g, "") };
+	if (!result) return {};
+	return {
+		base64: result.base64.replace(/\s+/g, ""),
+		...result.originalBase64 ? { originalBase64: result.originalBase64.replace(/\s+/g, "") } : {},
+		...result.mime ? { mime: result.mime } : {},
+		...result.originalMime ? { originalMime: result.originalMime } : {}
+	};
+}
+function booleanProp(node, key) {
+	return node[key] === true;
+}
+function numberProp(node, key) {
+	const value = node[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function nodeItems(node) {
+	const value = node.items;
+	return Array.isArray(value) ? value : [];
+}
+function clampImageCells(value, min, max) {
+	return Math.max(min, Math.min(max, Math.round(value)));
+}
+function resolveImageDisplaySize(alt, size, naturalWidth, naturalHeight) {
+	if (size?.minWidth == null && size?.maxWidth == null && size?.minHeight == null && size?.maxHeight == null) return {};
+	const minWidth = Math.max(1, Math.floor(size?.minWidth ?? 1));
+	const maxWidth = Math.max(minWidth, Math.floor(size?.maxWidth ?? Number.MAX_SAFE_INTEGER));
+	const minHeight = Math.max(1, Math.floor(size?.minHeight ?? 1));
+	const maxHeight = Math.max(minHeight, Math.floor(size?.maxHeight ?? Number.MAX_SAFE_INTEGER));
+	if (size?.preserveAspectRatio !== false && naturalWidth != null && naturalHeight != null && naturalWidth > 0 && naturalHeight > 0) {
+		const cellRatio = naturalWidth / naturalHeight / TERMINAL_CELL_WIDTH_TO_HEIGHT_RATIO;
+		let width = minWidth;
+		let height = Math.max(minHeight, Math.ceil(width / cellRatio));
+		width = Math.max(width, Math.ceil(height * cellRatio));
+		if (width > maxWidth) {
+			width = maxWidth;
+			height = Math.max(minHeight, Math.ceil(width / cellRatio));
+		}
+		if (height > maxHeight) {
+			height = maxHeight;
+			width = Math.max(minWidth, Math.floor(height * cellRatio));
+		}
+		return {
+			displayWidth: clampImageCells(width, minWidth, maxWidth),
+			displayHeight: clampImageCells(height, minHeight, maxHeight)
+		};
+	}
+	return {
+		displayWidth: size?.maxWidth != null ? Math.min(maxWidth, Math.max(minWidth, textCellWidth(alt))) : Math.max(minWidth, textCellWidth(alt)),
+		displayHeight: size?.maxHeight != null ? Math.min(maxHeight, Math.max(minHeight, 1)) : minHeight
+	};
+}
+function pushTextSegments(out, text, style, graphic, mathAction) {
+	if (!text) return;
+	const normalized = sanitizeTextBlock(text);
+	if (!normalized) return;
+	const parts = normalized.split("\n");
+	for (let i = 0; i < parts.length; i++) {
+		const part = sanitizeInlineText(parts[i] ?? "");
+		if (part) out.push({
+			text: part,
+			...style ? { style } : {},
+			...i === 0 && graphic ? { graphic } : {},
+			...mathAction ? { mathAction } : {}
+		});
+		if (i < parts.length - 1) out.push(HARD_BREAK_SEGMENT);
+	}
+}
+function sanitizeCodeBlockText(text, tabSize = 4) {
+	const normalized = String(text ?? "").replace(/\r\n?/g, "\n").replace(/\t/g, spaces(tabSize)).replace(/\u00a0/g, " ");
+	return sanitizeTextBlock(normalized);
+}
+function codeBlockLanguage(node) {
+	const raw = stringProp(node, "lang") || stringProp(node, "language") || stringProp(node, "info") || stringProp(node, "meta");
+	const language = raw.trim().split(/\s+/)[0]?.toLowerCase() ?? "";
+	return language || void 0;
+}
+function inlineNodeSegments(nodes, theme, inheritedStyle, options = {}) {
+	const out = [];
+	for (const node of nodes) switch (node.type) {
+		case "text":
+			pushTextSegments(out, stringProp(node, "content"), inheritedStyle);
+			break;
+		case "inline":
+		case "paragraph":
+		case "heading":
+		case "list_item":
+		case "blockquote":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, inheritedStyle, options));
+			break;
+		case "strong":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, mergeStyle$1(inheritedStyle, theme.strong), options));
+			break;
+		case "emphasis":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, mergeStyle$1(inheritedStyle, theme.emphasis), options));
+			break;
+		case "strikethrough":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, mergeStyle$1(inheritedStyle, theme.strikethrough), options));
+			break;
+		case "highlight":
+		case "insert":
+		case "subscript":
+		case "superscript":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, inheritedStyle, options));
+			break;
+		case "inline_code":
+			pushTextSegments(out, stringProp(node, "code"), mergeStyle$1(inheritedStyle, theme.inlineCode));
+			break;
+		case "hardbreak":
+			out.push(HARD_BREAK_SEGMENT);
+			break;
+		case "link": {
+			const href = stringProp(node, "href");
+			const safeHref = href ? sanitizeMarkdownLink(href) : null;
+			const linkStyle = safeHref ? mergeStyle$1(inheritedStyle, {
+				...theme.link,
+				href: safeHref
+			}) : inheritedStyle;
+			const children = nodeChildren(node);
+			if (children.length) out.push(...inlineNodeSegments(children, theme, linkStyle, options));
+			else pushTextSegments(out, stringProp(node, "text"), linkStyle);
+			break;
+		}
+		case "image": {
+			const raw = stringProp(node, "raw");
+			const rawSource = stringProp(node, "src") || imageSourceFromRaw(raw);
+			const source = sanitizeMarkdownImageSource(rawSource);
+			const alt = stringProp(node, "alt") || imageFallbackText(raw, rawSource, source?.src);
+			if (source) {
+				const size = options.imageSize;
+				const imageLinkStyle = mergeStyle$1(inheritedStyle, {
+					...theme.link,
+					href: source.src
+				});
+				const sourceDimensions = readMarkdownImageDimensions(source.base64);
+				const graphicBase = {
+					kind: "image",
+					src: source.src,
+					alt,
+					...source.mime ? { mime: source.mime } : {},
+					...source.base64 ? { base64: source.base64 } : {},
+					...sourceDimensions ? {
+						naturalWidth: sourceDimensions.width,
+						naturalHeight: sourceDimensions.height
+					} : {},
+					...resolveImageDisplaySize(alt, size, sourceDimensions?.width, sourceDimensions?.height)
+				};
+				const resolved = normalizeImageResolverResult(options.imageResolver?.(graphicBase));
+				const base64 = resolved.base64 || source.base64;
+				if (base64) {
+					const dimensions = readMarkdownImageDimensions(base64) ?? sourceDimensions;
+					const graphic = {
+						...graphicBase,
+						base64,
+						...resolved.originalBase64 ? { originalBase64: resolved.originalBase64 } : {},
+						...resolved.mime ? { mime: resolved.mime } : {},
+						...resolved.originalMime ? { originalMime: resolved.originalMime } : {},
+						...dimensions ? {
+							naturalWidth: dimensions.width,
+							naturalHeight: dimensions.height
+						} : {},
+						...resolveImageDisplaySize(alt, size, dimensions?.width, dimensions?.height)
+					};
+					pushTextSegments(out, alt, imageLinkStyle, graphic);
+				} else pushTextSegments(out, alt, imageLinkStyle);
+			} else pushTextSegments(out, alt, mergeStyle$1(inheritedStyle, theme.link));
+			break;
+		}
+		case "checkbox":
+		case "checkbox_input":
+			pushTextSegments(out, booleanProp(node, "checked") ? "[x]" : "[ ]", inheritedStyle);
+			break;
+		case "emoji":
+			pushTextSegments(out, stringProp(node, "markup") || stringProp(node, "name"), inheritedStyle);
+			break;
+		case "math_inline":
+			{
+				const source = stringProp(node, "content");
+				const raw = stringProp(node, "raw") || `$${source}$`;
+				const rendered = renderMarkdownInlineMathSegment(source);
+				pushTextSegments(out, rendered.supported ? rendered.text : raw, mergeStyle$1(inheritedStyle, theme.inlineCode), void 0, {
+					source,
+					raw,
+					rendered: rendered.supported
+				});
+			}
+			break;
+		case "reference":
+		case "footnote_reference":
+		case "footnote_anchor":
+			pushTextSegments(out, stringProp(node, "raw"), inheritedStyle);
+			break;
+		case "html_inline":
+			pushTextSegments(out, stringProp(node, "content"), mergeStyle$1(inheritedStyle, theme.html));
+			break;
+		case "html_block":
+			pushTextSegments(out, stringProp(node, "content"), mergeStyle$1(inheritedStyle, theme.html));
+			break;
+		default:
+			if (nodeChildren(node).length) {
+				out.push(...inlineNodeSegments(nodeChildren(node), theme, inheritedStyle, options));
+				break;
+			}
+			pushTextSegments(out, stringProp(node, "raw"), inheritedStyle);
+			break;
+	}
+	return out;
+}
+function inlineBlock(key, segments, context) {
+	return {
+		type: "inline",
+		key,
+		segments,
+		prefixSegments: context.prefixSegments,
+		continuationPrefixSegments: context.continuationPrefixSegments
+	};
+}
+function blockFromParagraph(node, key, context, theme) {
+	return inlineBlock(key, inlineNodeSegments(nodeChildren(node), theme, void 0, {
+		imageResolver: context.imageResolver,
+		imageSize: context.imageSize
+	}), context);
+}
+function blockFromHeading(node, key, context, theme) {
+	const level = Math.min(6, Math.max(1, Math.floor(numberProp(node, "level") ?? 1)));
+	return inlineBlock(key, inlineNodeSegments(nodeChildren(node), theme, theme.heading[level - 1], {
+		imageResolver: context.imageResolver,
+		imageSize: context.imageSize
+	}), context);
+}
+function blockFromCodeBlock(node, key, context, theme) {
+	return {
+		type: "code_block",
+		key,
+		language: codeBlockLanguage(node),
+		lines: sanitizeCodeBlockText(stringProp(node, "code")).split("\n"),
+		style: theme.codeBlock,
+		prefixSegments: context.prefixSegments,
+		continuationPrefixSegments: context.continuationPrefixSegments
+	};
+}
+function blockFromHtmlBlock(node, key, context, theme) {
+	return inlineBlock(key, inlineNodeSegments([{
+		type: "html_block",
+		raw: stringProp(node, "raw"),
+		content: stringProp(node, "content")
+	}], theme, void 0, { imageResolver: context.imageResolver }), context);
+}
+function tableRows$1(node, key) {
+	const value = node[key];
+	if (key === "header") return value && typeof value === "object" ? [value] : [];
+	return Array.isArray(value) ? value : [];
+}
+function tableCells(row) {
+	const value = row.cells;
+	return Array.isArray(value) ? value : [];
+}
+function tableCellAlign(cell) {
+	const align = stringProp(cell, "align");
+	return align === "center" || align === "right" || align === "left" ? align : void 0;
+}
+function blockFromTable(node, key, context, theme) {
+	const headerRow = tableRows$1(node, "header")[0];
+	const header = tableCells(headerRow ?? { type: "table_row" }).map((cell) => ({
+		segments: inlineNodeSegments(nodeChildren(cell), theme, theme.strong, {
+			imageResolver: context.imageResolver,
+			imageSize: context.imageSize
+		}),
+		align: tableCellAlign(cell)
+	}));
+	const rows = tableRows$1(node, "rows").map((row) => tableCells(row).map((cell) => ({
+		segments: inlineNodeSegments(nodeChildren(cell), theme, void 0, {
+			imageResolver: context.imageResolver,
+			imageSize: context.imageSize
+		}),
+		align: tableCellAlign(cell)
+	})));
+	return {
+		type: "table",
+		key,
+		header,
+		rows,
+		borderStyle: theme.thematicBreak,
+		prefixSegments: context.prefixSegments
+	};
+}
+function childSequenceToBlocks(nodes, context, theme, keyPrefix) {
+	const out = [];
+	let appended = false;
+	for (let i = 0; i < nodes.length; i++) {
+		const childBlocks = trimBlockArray(nodeToBlocks(nodes[i], context, theme, `${keyPrefix}-${i}`));
+		if (!childBlocks.length) continue;
+		if (appended && out[out.length - 1]?.type !== "blank" && childBlocks[0]?.type !== "blank") out.push({
+			type: "blank",
+			key: `${keyPrefix}-${i}-gap`
+		});
+		out.push(...childBlocks);
+		appended = true;
+	}
+	return out;
+}
+function listItemBlocks(item, index, ordered, start, context, theme, keyPrefix) {
+	const markerText = ordered ? `${start + index}. ` : "- ";
+	const markerCells = textCellWidth(markerText);
+	const markerSegment = {
+		text: markerText,
+		style: theme.listMarker
+	};
+	const indentSegment = { text: spaces(markerCells) };
+	const firstContext = {
+		prefixSegments: [...context.prefixSegments, markerSegment],
+		continuationPrefixSegments: [...context.continuationPrefixSegments, indentSegment]
+	};
+	const nestedContext = {
+		prefixSegments: [...context.continuationPrefixSegments, indentSegment],
+		continuationPrefixSegments: [...context.continuationPrefixSegments, indentSegment]
+	};
+	const children = nodeChildren(item);
+	if (!children.length) return [inlineBlock(`${keyPrefix}-empty`, [], firstContext)];
+	const out = [];
+	let usedLead = false;
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		const useLeadContext = !usedLead && (child.type === "paragraph" || child.type === "heading" || child.type === "code_block");
+		if (!usedLead && !useLeadContext) {
+			out.push(inlineBlock(`${keyPrefix}-marker`, [], firstContext));
+			usedLead = true;
+		}
+		const childBlocks = trimBlockArray(nodeToBlocks(child, useLeadContext && !usedLead ? firstContext : nestedContext, theme, `${keyPrefix}-${i}`));
+		if (!childBlocks.length) continue;
+		const startsNestedList = child.type === "list" && out.length > 0 && out[out.length - 1]?.type === "inline" && childBlocks[0]?.type === "inline";
+		if (out.length && out[out.length - 1]?.type !== "blank" && childBlocks[0]?.type !== "blank" && !startsNestedList) out.push({
+			type: "blank",
+			key: `${keyPrefix}-${i}-gap`
+		});
+		out.push(...childBlocks);
+		usedLead = true;
+	}
+	if (!out.length) out.push(inlineBlock(`${keyPrefix}-fallback`, [], firstContext));
+	return out;
+}
+function listBlocks(node, context, theme, keyPrefix) {
+	const out = [];
+	const items = nodeItems(node);
+	for (let i = 0; i < items.length; i++) out.push(...listItemBlocks(items[i], i, booleanProp(node, "ordered"), numberProp(node, "start") ?? 1, context, theme, `${keyPrefix}-${i}`));
+	return out;
+}
+function nodeToBlocks(node, context, theme, keyPrefix) {
+	switch (node.type) {
+		case "paragraph":
+			if ("children" in node && Array.isArray(node.children)) return [blockFromParagraph(node, keyPrefix, context, theme)];
+			break;
+		case "heading":
+			if ("children" in node && Array.isArray(node.children) && "level" in node) return [blockFromHeading(node, keyPrefix, context, theme)];
+			break;
+		case "code_block":
+			if ("code" in node) return [blockFromCodeBlock(node, keyPrefix, context, theme)];
+			break;
+		case "thematic_break": return [{
+			type: "thematic_break",
+			key: keyPrefix,
+			char: "─",
+			style: theme.thematicBreak,
+			prefixSegments: context.prefixSegments
+		}];
+		case "blockquote": {
+			const quoteSegment = {
+				text: "│ ",
+				style: theme.blockquote
+			};
+			const quoteContext = {
+				prefixSegments: [...context.prefixSegments, quoteSegment],
+				continuationPrefixSegments: [...context.continuationPrefixSegments, quoteSegment],
+				imageResolver: context.imageResolver,
+				imageSize: context.imageSize
+			};
+			return childSequenceToBlocks(nodeChildren(node), quoteContext, theme, keyPrefix);
+		}
+		case "list":
+			if ("items" in node && Array.isArray(node.items)) return listBlocks(node, context, theme, keyPrefix);
+			break;
+		case "table": return [blockFromTable(node, keyPrefix, context, theme)];
+		case "inline": return [inlineBlock(keyPrefix, inlineNodeSegments(nodeChildren(node), theme, void 0, {
+			imageResolver: context.imageResolver,
+			imageSize: context.imageSize
+		}), context)];
+		case "html_block":
+			if ("content" in node) return [blockFromHtmlBlock(node, keyPrefix, context, theme)];
+			break;
+		case "text": return [inlineBlock(keyPrefix, inlineNodeSegments([node], theme, void 0, { imageResolver: context.imageResolver }), context)];
+	}
+	if (nodeChildren(node).length) return childSequenceToBlocks(nodeChildren(node), context, theme, keyPrefix);
+	return [inlineBlock(keyPrefix, inlineNodeSegments([node], theme, void 0, { imageResolver: context.imageResolver }), context)];
+}
+function markdownAstToBlocks(nodes, theme, options = {}) {
+	const blocks = trimBlockArray(childSequenceToBlocks(nodes, {
+		prefixSegments: EMPTY_PREFIX,
+		continuationPrefixSegments: EMPTY_PREFIX,
+		imageResolver: options.imageResolver,
+		imageSize: options.imageSize
+	}, theme, "md"));
+	return blocks.length ? blocks : [{
+		type: "blank",
+		key: "md-empty"
+	}];
+}
+
+//#endregion
+//#region src/vue/markdown/layout.ts
+function toVisualSegment(segment) {
+	if (!segment.text) return null;
+	const cells = textCellWidth(segment.text);
+	if (cells <= 0) return null;
+	return {
+		text: segment.text,
+		style: segment.style,
+		cells,
+		...segment.graphic ? { graphic: segment.graphic } : {},
+		...segment.mathAction ? { mathAction: segment.mathAction } : {}
+	};
+}
+function segmentsPlainText(segments) {
+	return segments.map((segment) => segment.fallbackText ?? segment.text).join("");
+}
+function segmentsVisualHeight(segments) {
+	let height = 1;
+	for (const segment of segments) {
+		if (!segment.graphic) continue;
+		height = Math.max(height, Math.max(1, Math.floor(segment.graphic.displayHeight ?? 1)));
+	}
+	return height;
+}
+function segmentsCellWidth(segments) {
+	let cells = 0;
+	for (const segment of segments) {
+		if (segment.hardBreak || !segment.text) continue;
+		cells += textCellWidth(segment.text);
+	}
+	return cells;
+}
+function normalizeInlineSegments(segments) {
+	const lines = [[]];
+	for (const segment of segments) {
+		if (segment.hardBreak) {
+			lines.push([]);
+			continue;
+		}
+		lines[lines.length - 1].push(segment);
+	}
+	return lines;
+}
+function clipInlineSegmentsToWidth(segments, width) {
+	let remaining = Math.max(0, Math.floor(width));
+	if (remaining <= 0) return [];
+	const out = [];
+	for (const segment of segments) {
+		if (segment.hardBreak || !segment.text || remaining <= 0) continue;
+		const piece = sliceByCellsRange(segment.text, 0, remaining);
+		const cells = textCellWidth(piece);
+		if (!piece || cells <= 0) continue;
+		const clipped = {
+			text: piece,
+			...segment.style ? { style: segment.style } : {},
+			...segment.mathAction ? { mathAction: segment.mathAction } : {}
+		};
+		out.push(piece === segment.text && segment.graphic ? {
+			...clipped,
+			graphic: segment.graphic
+		} : clipped);
+		remaining -= cells;
+	}
+	return out;
+}
+function clipVisualSegmentsToWidth(segments, width) {
+	let remaining = Math.max(0, Math.floor(width));
+	if (remaining <= 0) return [];
+	const out = [];
+	for (const segment of segments) {
+		if (!segment.text || remaining <= 0) continue;
+		if (segment.cells <= remaining) {
+			out.push(segment);
+			remaining -= segment.cells;
+			continue;
+		}
+		const text = sliceByCellsRange(segment.text, 0, remaining);
+		const cells = textCellWidth(text);
+		if (!text || cells <= 0) continue;
+		out.push({
+			text,
+			style: segment.style,
+			cells,
+			...text === segment.text && segment.graphic ? { graphic: segment.graphic } : {},
+			...segment.mathAction ? { mathAction: segment.mathAction } : {}
+		});
+		remaining -= cells;
+	}
+	return out;
+}
+function wrapLineSegments(source, prefixSegments, continuationPrefixSegments, width) {
+	const rows = [];
+	const prefixCells = segmentsCellWidth(prefixSegments);
+	const continuationPrefixCells = segmentsCellWidth(continuationPrefixSegments);
+	const firstPrefix = prefixCells >= width ? clipInlineSegmentsToWidth(prefixSegments, width) : prefixSegments;
+	const firstPrefixCells = segmentsCellWidth(firstPrefix);
+	const continuationPrefix = continuationPrefixCells >= width ? clipInlineSegmentsToWidth(continuationPrefixSegments, Math.max(0, width - 1)) : continuationPrefixSegments;
+	const trimmedContinuationPrefixCells = segmentsCellWidth(continuationPrefix);
+	const maxFirst = Math.max(0, width - firstPrefixCells);
+	const maxNext = Math.max(0, width - trimmedContinuationPrefixCells);
+	const openRow = (useContinuation) => {
+		const prefix = useContinuation ? continuationPrefix : firstPrefix;
+		const renderedPrefix = prefix.map(toVisualSegment).filter(Boolean);
+		return {
+			useContinuation,
+			segments: [...renderedPrefix],
+			remaining: useContinuation ? maxNext : maxFirst
+		};
+	};
+	const openDegradedRow = () => ({
+		useContinuation: true,
+		segments: [],
+		remaining: width
+	});
+	let row = openRow(false);
+	if (!source.length) {
+		rows.push(row.segments);
+		return rows;
+	}
+	const pushRow = () => {
+		rows.push(row.segments);
+		row = openRow(true);
+	};
+	const prefixLengthForRow = () => row.useContinuation ? continuationPrefix.length : firstPrefix.length;
+	const rowHasBody = () => row.segments.length > prefixLengthForRow();
+	for (const segment of source) {
+		if (segment.graphic) {
+			const displayCells = Math.max(1, Math.floor(segment.graphic.displayWidth ?? 1));
+			if (row.remaining <= 0 && !rowHasBody()) {
+				if (!row.useContinuation) {
+					rows.push(row.segments);
+					row = openDegradedRow();
+				}
+			}
+			const cells = Math.min(displayCells, Math.max(1, row.remaining || width));
+			row.segments.push({
+				text: spaces(cells),
+				style: segment.style,
+				cells,
+				graphic: segment.graphic,
+				fallbackText: segment.text
+			});
+			row.remaining -= cells;
+			continue;
+		}
+		let aborted = false;
+		forEachTextCellSegment(segment.text, (piece) => {
+			while (true) {
+				if (row.remaining <= 0) {
+					pushRow();
+					continue;
+				}
+				if (piece.cells > row.remaining) {
+					if (rowHasBody()) {
+						pushRow();
+						continue;
+					}
+					if (!row.useContinuation) {
+						rows.push(row.segments);
+						row = openDegradedRow();
+						continue;
+					}
+					if (piece.cells <= width) {
+						row = openDegradedRow();
+						continue;
+					}
+					aborted = true;
+					return false;
+				}
+				row.segments.push({
+					text: piece.text,
+					style: segment.style,
+					cells: piece.cells,
+					...segment.mathAction ? { mathAction: segment.mathAction } : {}
+				});
+				row.remaining -= piece.cells;
+				return void 0;
+			}
+		});
+		if (aborted) continue;
+	}
+	rows.push(row.segments);
+	return rows;
+}
+function inlineBlockRows(block, width) {
+	const rows = [];
+	const lines = normalizeInlineSegments(block.segments);
+	const prefix = block.prefixSegments ?? [];
+	const continuationPrefix = block.continuationPrefixSegments ?? prefix;
+	let rowInBlock = 0;
+	for (const line of lines) {
+		const wrapped = wrapLineSegments(line, prefix, continuationPrefix, width);
+		for (const visualSegments of wrapped) {
+			rows.push({
+				key: `${block.key}:${rowInBlock}`,
+				blockKey: block.key,
+				rowInBlock,
+				plainText: segmentsPlainText(visualSegments),
+				segments: visualSegments
+			});
+			rowInBlock++;
+			const height = segmentsVisualHeight(visualSegments);
+			for (let extra = 1; extra < height; extra++) {
+				rows.push({
+					key: `${block.key}:${rowInBlock}`,
+					blockKey: block.key,
+					rowInBlock,
+					plainText: "",
+					segments: []
+				});
+				rowInBlock++;
+			}
+		}
+	}
+	return rows.length ? rows : [{
+		key: `${block.key}:0`,
+		blockKey: block.key,
+		rowInBlock: 0,
+		plainText: "",
+		segments: prefix.map(toVisualSegment).filter(Boolean)
+	}];
+}
+function codeBlockRows(block, width) {
+	const rows = [];
+	const prefix = block.prefixSegments ?? [];
+	const continuationPrefix = block.continuationPrefixSegments ?? prefix;
+	const lineSegments = block.lines.length ? block.lines : [""];
+	let rowInBlock = 0;
+	for (const line of lineSegments) {
+		const sourceSegments = [{
+			text: line,
+			style: block.style
+		}];
+		const wrapped = wrapLineSegments(sourceSegments, prefix, continuationPrefix, width);
+		for (const visualSegments of wrapped) {
+			rows.push({
+				key: `${block.key}:${rowInBlock}`,
+				blockKey: block.key,
+				rowInBlock,
+				plainText: segmentsPlainText(visualSegments),
+				segments: visualSegments
+			});
+			rowInBlock++;
+		}
+	}
+	return rows;
+}
+function thematicBreakRows(block, width) {
+	const prefix = (block.prefixSegments ?? []).map(toVisualSegment).filter(Boolean);
+	const prefixCells = prefix.reduce((sum, segment) => sum + segment.cells, 0);
+	const fill = Math.max(0, width - prefixCells);
+	const bar = fill > 0 ? [{
+		text: repeatChar(block.char ?? "─", fill),
+		style: block.style,
+		cells: fill
+	}] : [];
+	return [{
+		key: `${block.key}:0`,
+		blockKey: block.key,
+		rowInBlock: 0,
+		plainText: segmentsPlainText([...prefix, ...bar]),
+		segments: [...prefix, ...bar]
+	}];
+}
+function tableColumnCount(block) {
+	let columns = block.header.length;
+	for (const row of block.rows) columns = Math.max(columns, row.length);
+	return columns;
+}
+function tableColumnWidths(block, columns, width) {
+	const widths = Array.from({ length: columns }, () => 0);
+	const measureRow = (row) => {
+		for (let index = 0; index < columns; index++) widths[index] = Math.max(widths[index] ?? 0, segmentsCellWidth(row[index]?.segments ?? []));
+	};
+	measureRow(block.header);
+	for (const row of block.rows) measureRow(row);
+	const prefixCells = segmentsCellWidth(block.prefixSegments ?? []);
+	const available = Math.max(0, width - prefixCells - (columns * 3 + 1));
+	for (let index = 0; index < widths.length; index++) widths[index] = Math.min(widths[index] ?? 0, available);
+	let total = widths.reduce((sum, item) => sum + item, 0);
+	while (total > available) {
+		let widestIndex = 0;
+		for (let index = 1; index < widths.length; index++) if ((widths[index] ?? 0) > (widths[widestIndex] ?? 0)) widestIndex = index;
+		if ((widths[widestIndex] ?? 0) <= 0) break;
+		widths[widestIndex]--;
+		total--;
+	}
+	return widths;
+}
+function appendVisualSegment(segments, text, style, graphic, mathAction) {
+	if (!text) return;
+	const cells = textCellWidth(text);
+	if (cells <= 0) return;
+	const prev = segments[segments.length - 1];
+	if (prev && prev.style === style && prev.mathAction === mathAction && !prev.graphic && !graphic) {
+		segments[segments.length - 1] = {
+			text: `${prev.text}${text}`,
+			style,
+			cells: prev.cells + cells,
+			...mathAction ? { mathAction } : {}
+		};
+		return;
+	}
+	segments.push({
+		text,
+		style,
+		cells,
+		...graphic ? { graphic } : {},
+		...mathAction ? { mathAction } : {}
+	});
+}
+function appendInlineVisualSegments(out, segments) {
+	for (const segment of segments) {
+		if (segment.hardBreak) {
+			appendVisualSegment(out, " ");
+			continue;
+		}
+		appendVisualSegment(out, segment.text, segment.style, segment.graphic, segment.mathAction);
+	}
+}
+function tableBorderRow(block, widths, width, rowInBlock, left, join, right) {
+	const prefix = (block.prefixSegments ?? []).map(toVisualSegment).filter(Boolean);
+	const segments = [...prefix];
+	let cells = prefix.reduce((sum, segment) => sum + segment.cells, 0);
+	const append = (text) => {
+		if (cells >= width) return;
+		appendVisualSegment(segments, text, block.borderStyle);
+		cells += textCellWidth(text);
+	};
+	append(left);
+	for (let index = 0; index < widths.length && cells < width; index++) {
+		append(repeatChar("─", (widths[index] ?? 0) + 2));
+		append(index === widths.length - 1 ? right : join);
+	}
+	const clipped = clipVisualSegmentsToWidth(segments, width);
+	return {
+		key: `${block.key}:${rowInBlock}`,
+		blockKey: block.key,
+		rowInBlock,
+		plainText: segmentsPlainText(clipped),
+		segments: clipped
+	};
+}
+function tableContentRow(block, row, widths, width, rowInBlock) {
+	const segments = (block.prefixSegments ?? []).map(toVisualSegment).filter(Boolean);
+	let cells = segments.reduce((sum, segment) => sum + segment.cells, 0);
+	const append = (text, style) => {
+		if (cells >= width) return;
+		appendVisualSegment(segments, text, style);
+		cells += textCellWidth(text);
+	};
+	append("│", block.borderStyle);
+	for (let index = 0; index < widths.length && cells < width; index++) {
+		const columnWidth = widths[index] ?? 0;
+		const cell = row[index];
+		const clipped$1 = clipInlineSegmentsToWidth(cell?.segments ?? [], columnWidth);
+		const contentCells = segmentsCellWidth(clipped$1);
+		const remaining = Math.max(0, columnWidth - contentCells);
+		const align = cell?.align ?? "left";
+		const leftPad = align === "right" ? remaining : align === "center" ? Math.floor(remaining / 2) : 0;
+		const rightPad = remaining - leftPad;
+		append(" ");
+		append(repeatChar(" ", leftPad));
+		if (cells < width) {
+			appendInlineVisualSegments(segments, clipped$1);
+			cells += contentCells;
+		}
+		append(repeatChar(" ", rightPad));
+		append(" ");
+		append("│", block.borderStyle);
+	}
+	const clipped = clipVisualSegmentsToWidth(segments, width);
+	return {
+		key: `${block.key}:${rowInBlock}`,
+		blockKey: block.key,
+		rowInBlock,
+		plainText: segmentsPlainText(clipped),
+		segments: clipped
+	};
+}
+function tableRows(block, width) {
+	const columns = tableColumnCount(block);
+	if (columns <= 0) return [];
+	const widths = tableColumnWidths(block, columns, width);
+	const rows = [];
+	rows.push(tableBorderRow(block, widths, width, rows.length, "╭", "┬", "╮"));
+	rows.push(tableContentRow(block, block.header, widths, width, rows.length));
+	rows.push(tableBorderRow(block, widths, width, rows.length, "├", "┼", "┤"));
+	for (const row of block.rows) rows.push(tableContentRow(block, row, widths, width, rows.length));
+	rows.push(tableBorderRow(block, widths, width, rows.length, "╰", "┴", "╯"));
+	return rows;
+}
+function styleSignature(style) {
+	if (!style) return "";
+	return [
+		style.fg ?? "",
+		style.bg ?? "",
+		style.bold ? "1" : "0",
+		style.dim ? "1" : "0",
+		style.italic ? "1" : "0",
+		style.underline ? "1" : "0",
+		style.inverse ? "1" : "0",
+		style.href ?? ""
+	].join("
");
+}
+function inlineSegmentSignature(segment) {
+	const graphic = segment.graphic ? [
+		segment.graphic.kind,
+		segment.graphic.src,
+		segment.graphic.alt ?? "",
+		segment.graphic.mime ?? "",
+		segment.graphic.base64 ?? "",
+		segment.graphic.displayWidth ?? "",
+		segment.graphic.displayHeight ?? ""
+	].join("") : "";
+	const mathAction = segment.mathAction ? [
+		segment.mathAction.source,
+		segment.mathAction.raw,
+		segment.mathAction.rendered ? "1" : "0"
+	].join("") : "";
+	return [
+		segment.text,
+		segment.hardBreak ? "1" : "0",
+		styleSignature(segment.style),
+		graphic,
+		mathAction
+	].join("");
+}
+function inlineSegmentsSignature(segments) {
+	return (segments ?? []).map(inlineSegmentSignature).join("");
+}
+function blockLayoutSignature(block) {
+	switch (block.type) {
+		case "inline": return [
+			block.type,
+			inlineSegmentsSignature(block.segments),
+			inlineSegmentsSignature(block.prefixSegments),
+			inlineSegmentsSignature(block.continuationPrefixSegments)
+		].join("");
+		case "code_block": return [
+			block.type,
+			block.language ?? "",
+			block.lines.join(""),
+			styleSignature(block.style),
+			inlineSegmentsSignature(block.prefixSegments),
+			inlineSegmentsSignature(block.continuationPrefixSegments)
+		].join("");
+		case "thematic_break": return [
+			block.type,
+			block.char ?? "",
+			styleSignature(block.style),
+			inlineSegmentsSignature(block.prefixSegments)
+		].join("");
+		case "table": return [
+			block.type,
+			inlineSegmentsSignature(block.prefixSegments),
+			styleSignature(block.borderStyle),
+			block.header.map((cell) => `${inlineSegmentsSignature(cell.segments)}\u0005${cell.align ?? ""}`).join(""),
+			block.rows.map((row) => row.map((cell) => `${inlineSegmentsSignature(cell.segments)}\u0005${cell.align ?? ""}`).join("")).join("\x07")
+		].join("");
+		case "blank": return block.type;
+	}
+}
+function layoutMarkdownBlock(block, width) {
+	switch (block.type) {
+		case "inline": return inlineBlockRows(block, width);
+		case "code_block": return codeBlockRows(block, width);
+		case "thematic_break": return thematicBreakRows(block, width);
+		case "table": return tableRows(block, width);
+		case "blank": return [{
+			key: `${block.key}:0`,
+			blockKey: block.key,
+			rowInBlock: 0,
+			plainText: "",
+			segments: []
+		}];
+	}
+}
+function layoutMarkdownBlocksCached(blocks, width, previous) {
+	const normalizedWidth = Math.max(0, Math.floor(width));
+	const widthProvider = currentTextWidthProvider();
+	if (normalizedWidth <= 0) return {
+		rows: [],
+		cache: {
+			width: normalizedWidth,
+			widthProvider,
+			entries: new Map()
+		}
+	};
+	const rows = [];
+	const entries = new Map();
+	const previousEntries = previous?.width === normalizedWidth && Object.is(previous.widthProvider ?? "default", widthProvider) ? previous.entries : void 0;
+	for (let index = 0; index < blocks.length; index++) {
+		const block = blocks[index];
+		const cacheKey = `${index}\u0000${block.key}`;
+		const signature = blockLayoutSignature(block);
+		const cached = previousEntries?.get(cacheKey);
+		const blockRows = cached?.signature === signature ? cached.rows : layoutMarkdownBlock(block, normalizedWidth);
+		if (blockRows.length) {
+			rows.push(...blockRows);
+			entries.set(cacheKey, {
+				signature,
+				rows: blockRows
+			});
+		}
+	}
+	if (!rows.length) {
+		const emptyRows = [{
+			key: "md-empty:0",
+			blockKey: "md-empty",
+			rowInBlock: 0,
+			plainText: "",
+			segments: []
+		}];
+		entries.set("0\0md-empty", {
+			signature: "empty",
+			rows: emptyRows
+		});
+		rows.push(...emptyRows);
+	}
+	return {
+		rows,
+		cache: {
+			width: normalizedWidth,
+			widthProvider,
+			entries
+		}
+	};
+}
+function layoutMarkdownBlocks(blocks, width, options) {
+	if (options?.widthProvider !== void 0) return withTextWidthProvider(options.widthProvider, () => layoutMarkdownBlocksCached(blocks, width).rows);
+	return layoutMarkdownBlocksCached(blocks, width).rows;
+}
+
+//#endregion
+//#region src/vue/markdown/theme.ts
+function freezeStyle(style) {
+	return Object.freeze(style);
+}
+function mergeFrozenStyle(base, overlay) {
+	if (!overlay) return base;
+	return freezeStyle({
+		...base,
+		...overlay
+	});
+}
+const DEFAULT_HEADING = Object.freeze([
+	freezeStyle({
+		bold: true,
+		fg: "cyanBright"
+	}),
+	freezeStyle({
+		bold: true,
+		fg: "cyanBright"
+	}),
+	freezeStyle({
+		bold: true,
+		fg: "blueBright"
+	}),
+	freezeStyle({
+		bold: true,
+		fg: "blueBright"
+	}),
+	freezeStyle({ bold: true }),
+	freezeStyle({ bold: true })
+]);
+const DEFAULT_TUI_MARKDOWN_THEME = Object.freeze({
+	heading: DEFAULT_HEADING,
+	strong: freezeStyle({ bold: true }),
+	emphasis: freezeStyle({ italic: true }),
+	strikethrough: freezeStyle({ dim: true }),
+	inlineCode: freezeStyle({ fg: "yellowBright" }),
+	link: freezeStyle({
+		fg: "blueBright",
+		underline: true
+	}),
+	blockquote: freezeStyle({ dim: true }),
+	listMarker: freezeStyle({
+		fg: "cyanBright",
+		bold: true
+	}),
+	codeBlock: freezeStyle({ fg: "yellowBright" }),
+	thematicBreak: freezeStyle({ dim: true }),
+	html: freezeStyle({ dim: true })
+});
+function stableSerialize(value) {
+	if (value == null) return "null";
+	if (typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+	const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b));
+	return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item)}`).join(",")}}`;
+}
+function markdownThemeSignature(overrides) {
+	return stableSerialize(overrides ?? null);
+}
+function resolveTuiMarkdownTheme(overrides) {
+	if (!overrides) return DEFAULT_TUI_MARKDOWN_THEME;
+	const heading = DEFAULT_TUI_MARKDOWN_THEME.heading.map((style, index) => mergeFrozenStyle(style, overrides.heading?.[index]));
+	return Object.freeze({
+		heading: Object.freeze(heading),
+		strong: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.strong, overrides.strong),
+		emphasis: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.emphasis, overrides.emphasis),
+		strikethrough: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.strikethrough, overrides.strikethrough),
+		inlineCode: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.inlineCode, overrides.inlineCode),
+		link: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.link, overrides.link),
+		blockquote: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.blockquote, overrides.blockquote),
+		listMarker: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.listMarker, overrides.listMarker),
+		codeBlock: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.codeBlock, overrides.codeBlock),
+		thematicBreak: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.thematicBreak, overrides.thematicBreak),
+		html: mergeFrozenStyle(DEFAULT_TUI_MARKDOWN_THEME.html, overrides.html)
+	});
+}
+
+//#endregion
+//#region src/vue/markdown/document.ts
+/**
+* This helper always builds visual rows from the full source string. Components
+* that need streaming reuse can call buildMarkdownBlocks and cache block layout.
+*/
+function buildMarkdownBlocks(content, parser, options) {
+	const theme = resolveTuiMarkdownTheme(options?.theme);
+	try {
+		const nodes = parser.parse(content, options?.final ?? true);
+		const blocks = markdownAstToBlocks(nodes, theme, {
+			imageResolver: options?.imageResolver,
+			imageSize: options?.imageSize
+		});
+		return {
+			nodes,
+			blocks
+		};
+	} catch (error) {
+		console.warn("[vue-tui] Markdown parse failed; falling back to plain text rendering.", error);
+		return {
+			nodes: [],
+			blocks: plainTextFallbackBlocks(content)
+		};
+	}
+}
+function buildMarkdownVisualRows(content, width, parser, options) {
+	const { blocks } = buildMarkdownBlocks(content, parser, options);
+	if (options?.widthProvider !== void 0) return layoutMarkdownBlocks(blocks, width, { widthProvider: options.widthProvider });
+	return layoutMarkdownBlocks(blocks, width);
+}
+function plainTextFallbackBlocks(content) {
+	const normalized = sanitizeTextBlock(content);
+	const lines = normalized.split("\n");
+	const blocks = [];
+	for (let index = 0; index < lines.length; index++) {
+		const line = sanitizeInlineText(lines[index] ?? "");
+		if (!line) {
+			blocks.push({
+				type: "blank",
+				key: `md-fallback:${index}`
+			});
+			continue;
+		}
+		blocks.push({
+			type: "inline",
+			key: `md-fallback:${index}`,
+			segments: [{ text: line }]
+		});
+	}
+	return blocks.length ? blocks : [{
+		type: "blank",
+		key: "md-fallback:0"
+	}];
+}
+
+//#endregion
+//#region src/vue/markdown/image-actions.ts
+function imageDisplayWidth(segment) {
+	return Math.max(1, Math.floor(segment.graphic?.displayWidth ?? segment.cells));
+}
+function imageDisplayHeight(segment) {
+	return Math.max(1, Math.floor(segment.graphic?.displayHeight ?? 1));
+}
+function findMarkdownImageActionAt(rows, point, options) {
+	const r = options.screenRect;
+	if (r.w <= 0 || r.h <= 0) return null;
+	if (point.cellX < r.x || point.cellY < r.y || point.cellX >= r.x + r.w || point.cellY >= r.y + r.h) return null;
+	const clipStart = Math.max(0, Math.floor(options.clipStart));
+	const clipEnd = clipStart + r.w;
+	const firstRow = Math.max(0, Math.floor(options.rowOffset));
+	const lastRow = Math.min(rows.length, firstRow + r.h);
+	for (let rowIndex = firstRow; rowIndex < lastRow; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		let logicalX = 0;
+		for (let segmentIndex = 0; segmentIndex < row.segments.length; segmentIndex++) {
+			const segment = row.segments[segmentIndex];
+			const segmentStart = logicalX;
+			const segmentEnd = logicalX + segment.cells;
+			logicalX = segmentEnd;
+			const image = segment.graphic;
+			if (!image) continue;
+			if (segmentEnd <= clipStart || segmentStart >= clipEnd) continue;
+			const imageX = r.x + segmentStart - clipStart;
+			const imageY = r.y + rowIndex - firstRow;
+			const imageRect = {
+				x: imageX,
+				y: imageY,
+				w: imageDisplayWidth(segment),
+				h: imageDisplayHeight(segment)
+			};
+			const visibleLeft = Math.max(r.x, imageRect.x);
+			const visibleTop = Math.max(r.y, imageRect.y);
+			const visibleRight = Math.min(r.x + r.w, imageRect.x + imageRect.w);
+			const visibleBottom = Math.min(r.y + r.h, imageRect.y + imageRect.h);
+			if (point.cellX < visibleLeft || point.cellY < visibleTop || point.cellX >= visibleRight || point.cellY >= visibleBottom) continue;
+			return {
+				image,
+				rect: imageRect,
+				cellX: point.cellX,
+				cellY: point.cellY,
+				rowIndex,
+				segmentIndex
+			};
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/vue/markdown/link-actions.ts
+function findMarkdownLinkActionAt(rows, point, options) {
+	const r = options.screenRect;
+	if (r.w <= 0 || r.h <= 0) return null;
+	if (point.cellX < r.x || point.cellY < r.y || point.cellX >= r.x + r.w || point.cellY >= r.y + r.h) return null;
+	const clipStart = Math.max(0, Math.floor(options.clipStart));
+	const clipEnd = clipStart + r.w;
+	const firstRow = Math.max(0, Math.floor(options.rowOffset));
+	const lastRow = Math.min(rows.length, firstRow + r.h);
+	for (let rowIndex = firstRow; rowIndex < lastRow; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		let logicalX = 0;
+		for (let segmentIndex = 0; segmentIndex < row.segments.length; segmentIndex++) {
+			const segment = row.segments[segmentIndex];
+			const segmentStart = logicalX;
+			const segmentEnd = logicalX + segment.cells;
+			logicalX = segmentEnd;
+			const href = segment.style?.href;
+			if (!href || segmentEnd <= clipStart || segmentStart >= clipEnd) continue;
+			const visibleStart = Math.max(segmentStart, clipStart);
+			const visibleEnd = Math.min(segmentEnd, clipEnd);
+			const rect = {
+				x: r.x + visibleStart - clipStart,
+				y: r.y + rowIndex - firstRow,
+				w: visibleEnd - visibleStart,
+				h: 1
+			};
+			if (point.cellX < rect.x || point.cellY < rect.y || point.cellX >= rect.x + rect.w || point.cellY >= rect.y + rect.h) continue;
+			let groupStart = segmentStart;
+			let groupEnd = segmentEnd;
+			const textParts = [segment.fallbackText ?? segment.text];
+			for (let index = segmentIndex - 1; index >= 0; index--) {
+				const previous = row.segments[index];
+				if (previous.style?.href !== href) break;
+				groupStart -= previous.cells;
+				textParts.unshift(previous.fallbackText ?? previous.text);
+			}
+			for (let index = segmentIndex + 1; index < row.segments.length; index++) {
+				const next = row.segments[index];
+				if (next.style?.href !== href) break;
+				groupEnd += next.cells;
+				textParts.push(next.fallbackText ?? next.text);
+			}
+			const visibleGroupStart = Math.max(groupStart, clipStart);
+			const visibleGroupEnd = Math.min(groupEnd, clipEnd);
+			return {
+				href,
+				text: textParts.join(""),
+				rect: {
+					x: r.x + visibleGroupStart - clipStart,
+					y: rect.y,
+					w: visibleGroupEnd - visibleGroupStart,
+					h: 1
+				},
+				cellX: point.cellX,
+				cellY: point.cellY,
+				rowIndex,
+				segmentIndex
+			};
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/vue/markdown/math-actions.ts
+function findMarkdownMathActionAt(rows, point, options) {
+	const r = options.screenRect;
+	if (r.w <= 0 || r.h <= 0) return null;
+	if (point.cellX < r.x || point.cellY < r.y || point.cellX >= r.x + r.w || point.cellY >= r.y + r.h) return null;
+	const clipStart = Math.max(0, Math.floor(options.clipStart));
+	const clipEnd = clipStart + r.w;
+	const firstRow = Math.max(0, Math.floor(options.rowOffset));
+	const lastRow = Math.min(rows.length, firstRow + r.h);
+	for (let rowIndex = firstRow; rowIndex < lastRow; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		let logicalX = 0;
+		for (let segmentIndex = 0; segmentIndex < row.segments.length; segmentIndex++) {
+			const segment = row.segments[segmentIndex];
+			const segmentStart = logicalX;
+			const segmentEnd = logicalX + segment.cells;
+			logicalX = segmentEnd;
+			const math = segment.mathAction;
+			if (!math || segmentEnd <= clipStart || segmentStart >= clipEnd) continue;
+			const visibleStart = Math.max(segmentStart, clipStart);
+			const visibleEnd = Math.min(segmentEnd, clipEnd);
+			const rect = {
+				x: r.x + visibleStart - clipStart,
+				y: r.y + rowIndex - firstRow,
+				w: visibleEnd - visibleStart,
+				h: 1
+			};
+			if (point.cellX < rect.x || point.cellY < rect.y || point.cellX >= rect.x + rect.w || point.cellY >= rect.y + rect.h) continue;
+			return {
+				math,
+				rect,
+				cellX: point.cellX,
+				cellY: point.cellY,
+				rowIndex,
+				segmentIndex
+			};
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/vue/markdown/render.ts
+const mergedStyleCache = new WeakMap();
+const markdownImageDebugLog = createDebugLogger(isDebugEnabled());
+const markdownImageDebug = (...parts) => {
+	if (!isDebugEnabled()) return;
+	markdownImageDebugLog.render(`markdown image ${parts.join(" ")}`);
+};
+function mergeStyle(base, overlay) {
+	if (!overlay) return base;
+	let bucket = mergedStyleCache.get(base);
+	if (!bucket) {
+		bucket = new WeakMap();
+		mergedStyleCache.set(base, bucket);
+	}
+	const cached = bucket.get(overlay);
+	if (cached) return cached;
+	const merged = Object.freeze({
+		...base,
+		...overlay
+	});
+	bucket.set(overlay, merged);
+	return merged;
+}
+const activeMarkdownImageGraphics = new WeakMap();
+function markdownImageGraphicId(segment, identity) {
+	return `md-image:${stableTerminalGraphicNumericId(`${identity}:${segment.src}:${segment.displayWidth ?? 0}:${segment.displayHeight ?? 0}:${segment.base64 ?? ""}`)}`;
+}
+function rememberMarkdownImageGraphic(terminal, id, rect) {
+	let active = activeMarkdownImageGraphics.get(terminal);
+	if (!active) {
+		active = new Map();
+		activeMarkdownImageGraphics.set(terminal, active);
+	}
+	active.set(id, rect);
+}
+function clearTrackedMarkdownImageGraphic(terminal, id) {
+	activeMarkdownImageGraphics.get(terminal)?.delete(id);
+	try {
+		getTerminalGraphicsOutput(terminal)?.clear?.(id);
+	} catch {}
+}
+function clearStaleMarkdownImageGraphicsForRow(terminal, y, keepIds, keepVisibleIds) {
+	const active = activeMarkdownImageGraphics.get(terminal);
+	if (!active?.size) return;
+	for (const [id, rect] of active) {
+		const intersectsRow = keepVisibleIds ? y >= rect.y && y < rect.y + rect.h : rect.y === y;
+		if (!intersectsRow || keepIds.has(id) || keepVisibleIds?.has(id)) continue;
+		clearTrackedMarkdownImageGraphic(terminal, id);
+	}
+}
+function canAttemptMarkdownImageGraphic(terminal, segment) {
+	if (segment.kind !== "image" || !segment.base64) return false;
+	const output = getTerminalGraphicsOutput(terminal);
+	const protocol = output?.capabilities.preferredProtocol;
+	return Boolean(output?.capabilities.supported && isTerminalGraphicsProtocol(protocol));
+}
+function clearMarkdownImageGraphics(terminal, rect) {
+	const active = activeMarkdownImageGraphics.get(terminal);
+	if (!active?.size) return;
+	for (const [id, item] of active) {
+		if (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)) continue;
+		clearTrackedMarkdownImageGraphic(terminal, id);
+	}
+}
+function queueMarkdownImageGraphic(terminal, segment, identity, rect) {
+	if (segment.kind !== "image" || !segment.base64) return "unavailable";
+	const output = getTerminalGraphicsOutput(terminal);
+	const protocol = output?.capabilities.preferredProtocol;
+	if (!output?.capabilities.supported || !isTerminalGraphicsProtocol(protocol)) return "unavailable";
+	const width = Math.max(1, Math.floor(segment.displayWidth ?? rect.w));
+	const height = Math.max(1, Math.floor(segment.displayHeight ?? 1));
+	const id = markdownImageGraphicId(segment, identity);
+	const imageId = stableTerminalGraphicNumericId(`image:${id}`);
+	const placementId = stableTerminalGraphicNumericId(`placement:${id}`);
+	const sequence = protocol === "kitty" ? createKittyGraphicsSequence(segment.base64, {
+		imageId,
+		placementId,
+		columns: width,
+		rows: height,
+		zIndex: -1
+	}) : protocol === "iterm2" ? createIterm2InlineImageSequence(segment.base64, {
+		width,
+		height,
+		preserveAspectRatio: true,
+		doNotMoveCursor: true
+	}) : "";
+	if (!sequence) return "unavailable";
+	const clearSequence = protocol === "kitty" ? createKittyDeleteGraphicsSequence({
+		imageId,
+		placementId
+	}) : void 0;
+	const resizeSequence = protocol === "kitty" ? createKittyPlacementSequence({
+		imageId,
+		placementId,
+		columns: width,
+		rows: height
+	}) : void 0;
+	const accepted = output.queue({
+		id,
+		x: rect.x,
+		y: rect.y,
+		w: width,
+		h: height,
+		protocol,
+		sequence,
+		resizeSequence,
+		clearSequence,
+		fallbackText: segment.alt ?? "image"
+	});
+	markdownImageDebug(`queue id=${id}`, `accepted=${accepted ? "true" : "false"}`, `x=${rect.x}`, `y=${rect.y}`, `w=${width}`, `h=${height}`, `visibleW=${rect.w}`, `displayW=${segment.displayWidth ?? ""}`, `displayH=${segment.displayHeight ?? ""}`);
+	if (accepted) rememberMarkdownImageGraphic(terminal, id, {
+		x: rect.x,
+		y: rect.y,
+		w: width,
+		h: height
+	});
+	return accepted ? "queued" : "rejected";
+}
+function collectVisibleMarkdownImageGraphicIds(rows, options) {
+	const keepIds = new Set();
+	if (options.w <= 0 || options.h <= 0) return keepIds;
+	const clipStart = Math.max(0, Math.floor(options.clipStart));
+	const clipEnd = clipStart + options.w;
+	const firstRow = Math.min(rows.length, Math.max(0, Math.floor(options.rowOffset)));
+	const lastRow = Math.min(rows.length, firstRow + Math.max(0, Math.floor(options.h)));
+	let scanStart = firstRow;
+	while (scanStart > 0 && (rows[scanStart]?.segments.length ?? 0) === 0) scanStart--;
+	for (let rowIndex = scanStart; rowIndex < lastRow; rowIndex++) {
+		const row = rows[rowIndex];
+		if (!row) continue;
+		let logicalX = 0;
+		for (const [segmentIndex, segment] of row.segments.entries()) {
+			const segmentStart = logicalX;
+			const segmentEnd = logicalX + segment.cells;
+			logicalX = segmentEnd;
+			if (!segment.graphic) continue;
+			if (segmentEnd <= clipStart || segmentStart >= clipEnd) continue;
+			if (Math.max(segmentStart, clipStart) !== segmentStart) continue;
+			const height = Math.max(1, Math.floor(segment.graphic.displayHeight ?? 1));
+			if (rowIndex + height <= firstRow || rowIndex >= lastRow) continue;
+			const rect = {
+				x: options.x + segmentStart - clipStart,
+				y: options.y + rowIndex - firstRow,
+				w: Math.max(1, Math.floor(segment.graphic.displayWidth ?? segment.cells)),
+				h: height
+			};
+			if (options.isGraphicCovered?.(rect)) continue;
+			keepIds.add(markdownImageGraphicId(segment.graphic, `${row.key}:${segmentIndex}`));
+		}
+	}
+	return keepIds;
+}
+function paintMarkdownVisualRow(terminal, row, options) {
+	const clipStart = Math.max(0, Math.floor(options.clipStart ?? 0));
+	const clipEnd = clipStart + options.w;
+	if (!row) {
+		if (options.clear !== false) {
+			terminal.write(spaces(options.w), {
+				x: options.x,
+				y: options.y,
+				style: options.baseStyle
+			});
+			clearStaleMarkdownImageGraphicsForRow(terminal, options.y, new Set(), options.keepGraphicIds);
+		}
+		return;
+	}
+	let logicalX = 0;
+	let used = 0;
+	const queuedGraphics = new Set();
+	for (const [segmentIndex, segment] of row.segments.entries()) {
+		if (used >= options.w || !segment.text) {
+			logicalX += segment.cells;
+			continue;
+		}
+		const segmentStart = logicalX;
+		const segmentEnd = logicalX + segment.cells;
+		logicalX += segment.cells;
+		if (segmentEnd <= clipStart || segmentStart >= clipEnd) continue;
+		const segmentStyle = mergeStyle(options.baseStyle, segment.style);
+		if (segment.graphic) {
+			const visibleStart = Math.max(segmentStart, clipStart);
+			const visibleEnd = Math.min(segmentEnd, clipEnd);
+			const visibleCells = visibleEnd - visibleStart;
+			if (visibleCells <= 0) continue;
+			const expectedUsed = visibleStart - clipStart;
+			if (expectedUsed > used) {
+				const pad = Math.min(expectedUsed - used, options.w - used);
+				terminal.write(spaces(pad), {
+					x: options.x + used,
+					y: options.y,
+					style: options.baseStyle
+				});
+				used += pad;
+			}
+			const cellX = options.x + used;
+			const graphicRect = {
+				x: cellX,
+				y: options.y,
+				w: Math.max(1, Math.floor(segment.graphic.displayWidth ?? visibleCells)),
+				h: Math.max(1, Math.floor(segment.graphic.displayHeight ?? 1))
+			};
+			const graphicCovered = options.isGraphicCovered?.(graphicRect) === true;
+			const queueResult = !graphicCovered && visibleStart === segmentStart && visibleCells > 0 && queueMarkdownImageGraphic(terminal, segment.graphic, `${row.key}:${segmentIndex}`, {
+				x: cellX,
+				y: options.y,
+				w: visibleCells
+			});
+			const graphicAvailable = queueResult || canAttemptMarkdownImageGraphic(terminal, segment.graphic);
+			const queuedGraphic = queueResult === "queued";
+			const suppressFallback = queuedGraphic || queueResult === "rejected" || graphicAvailable === true;
+			if (queuedGraphic) queuedGraphics.add(markdownImageGraphicId(segment.graphic, `${row.key}:${segmentIndex}`));
+			terminal.write(suppressFallback ? spaces(visibleCells) : sliceByCellsRange(segment.fallbackText ?? segment.graphic.alt ?? "image", 0, visibleCells) || spaces(visibleCells), {
+				x: cellX,
+				y: options.y,
+				style: suppressFallback ? options.baseStyle : segmentStyle
+			});
+			used += visibleCells;
+			continue;
+		}
+		let pieceStart = segmentStart;
+		forEachTextCellSegment(segment.text, (piece) => {
+			if (used >= options.w) return false;
+			const pieceEnd = pieceStart + piece.cells;
+			const visibleStart = Math.max(pieceStart, clipStart);
+			const visibleEnd = Math.min(pieceEnd, clipEnd);
+			pieceStart = pieceEnd;
+			if (visibleEnd <= visibleStart) return;
+			const expectedUsed = visibleStart - clipStart;
+			if (expectedUsed > used) {
+				const pad$1 = Math.min(expectedUsed - used, options.w - used);
+				terminal.write(spaces(pad$1), {
+					x: options.x + used,
+					y: options.y,
+					style: options.baseStyle
+				});
+				used += pad$1;
+			}
+			if (visibleStart === pieceStart - piece.cells && visibleEnd === pieceEnd) {
+				terminal.write(piece.text, {
+					x: options.x + used,
+					y: options.y,
+					style: segmentStyle
+				});
+				used += piece.cells;
+				return;
+			}
+			const pad = Math.min(visibleEnd - visibleStart, options.w - used);
+			if (pad > 0) {
+				const fallback = sliceByCellsRange(piece.text, visibleStart - (pieceStart - piece.cells), visibleEnd - (pieceStart - piece.cells));
+				terminal.write(fallback || spaces(pad), {
+					x: options.x + used,
+					y: options.y,
+					style: segmentStyle
+				});
+				used += pad;
+			}
+		});
+	}
+	clearStaleMarkdownImageGraphicsForRow(terminal, options.y, queuedGraphics, options.keepGraphicIds);
+	if (used < options.w && options.clear !== false) terminal.write(spaces(options.w - used), {
+		x: options.x + used,
+		y: options.y,
+		style: options.baseStyle
+	});
+}
+
+//#endregion
+//#region src/vue/components/TVirtualMarkdown.ts
+function clamp(n, min, max) {
+	return Math.max(min, Math.min(max, n));
+}
+function markdownStyleSignature(style) {
+	if (!style) return "";
+	return [
+		style.fg ?? "",
+		style.bg ?? "",
+		style.bold ? "1" : "0",
+		style.dim ? "1" : "0",
+		style.italic ? "1" : "0",
+		style.underline ? "1" : "0",
+		style.inverse ? "1" : "0",
+		style.href ?? ""
+	].join("
");
+}
+function markdownRowSignature(row) {
+	if (!row) return "";
+	return [
+		row.key,
+		row.plainText,
+		row.segments.map((segment) => `${segment.text}\u0001${segment.cells}\u0001${markdownStyleSignature(segment.style)}\u0001${segment.graphic?.src ?? ""}\u0001${segment.graphic?.base64 ?? ""}\u0001${segment.fallbackText ?? ""}`).join("")
+	].join("");
+}
+function getWheelScrollInput(e) {
+	const deltaY = Number(e.deltaY ?? 0);
+	const deltaMode = typeof e.deltaMode === "number" ? e.deltaMode : void 0;
+	if (Number.isInteger(deltaY) && deltaY !== 0 && Math.abs(deltaY) >= 100 && Math.abs(deltaY) % 100 === 0 && deltaMode == null) return {
+		deltaY: deltaY / 100,
+		mode: "line"
+	};
+	if (deltaMode === 1) return {
+		deltaY,
+		mode: "line"
+	};
+	if (deltaMode === 0) return {
+		deltaY,
+		mode: "pixel"
+	};
+	return {
+		deltaY,
+		mode: "auto"
+	};
+}
+function rowGraphicSignature(row) {
+	if (!row) return "";
+	return row.segments.map((segment) => segment.graphic ? `${segment.graphic.kind}\u0001${segment.graphic.src}\u0001${segment.graphic.base64 ?? ""}` : "").join("");
+}
+const TVirtualMarkdown = defineComponent({
+	name: "TVirtualMarkdown",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		content: {
+			type: String,
+			default: ""
+		},
+		blocks: {
+			type: Array,
+			default: void 0
+		},
+		scrollTop: {
+			type: Number,
+			default: 0
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		final: {
+			type: Boolean,
+			default: true
+		},
+		streaming: {
+			type: Boolean,
+			default: false
+		},
+		autoFocus: {
+			type: Boolean,
+			default: false
+		},
+		selectable: {
+			type: Boolean,
+			default: true
+		},
+		customHtmlTags: {
+			type: Array,
+			default: void 0
+		},
+		theme: {
+			type: Object,
+			default: void 0
+		},
+		imageRenderer: {
+			type: Function,
+			default: void 0
+		},
+		imageMinWidth: {
+			type: Number,
+			default: void 0
+		},
+		imageMaxWidth: {
+			type: Number,
+			default: void 0
+		},
+		imageMinHeight: {
+			type: Number,
+			default: void 0
+		},
+		imageMaxHeight: {
+			type: Number,
+			default: void 0
+		},
+		imagePreserveAspectRatio: {
+			type: Boolean,
+			default: true
+		},
+		imageActions: {
+			type: Boolean,
+			default: false
+		},
+		mathActions: {
+			type: Boolean,
+			default: false
+		},
+		linkActions: {
+			type: Boolean,
+			default: false
+		},
+		imageOcclusionRects: {
+			type: Array,
+			default: void 0
+		}
+	},
+	emits: {
+		"update:scrollTop": (_value) => true,
+		scroll: (_value) => true,
+		focus: () => true,
+		blur: () => true,
+		keydown: (_event) => true,
+		imageAction: (_payload) => true,
+		mathAction: (_payload) => true,
+		linkAction: (_payload) => true
+	},
+	setup(props, { emit }) {
+		const instance = getCurrentInstance();
+		const { terminal, defaultStyle, events, scheduler, selection, widthProvider } = useTerminal();
+		const layout = useLayout();
+		const { visible, rootProps } = useVisibility();
+		const parentEventZ = inject(EventZIndexContextKey, computed(() => 0));
+		const eventZ = computed(() => (parentEventZ.value ?? 0) + (props.zIndex ?? 0));
+		const internalScrollTop = ref(0);
+		const documentVersion = ref(0);
+		const rows = shallowRef(markRaw([]));
+		let pendingSelectionScrollFocusRemap = false;
+		const wheelState = createWheelScrollState();
+		let builtOnce = false;
+		let rebuildVersion = 0;
+		let layoutCache;
+		let alive = true;
+		const parser = shallowRef(markRaw(createTuiMarkdownParser({
+			streaming: props.streaming,
+			customHtmlTags: props.customHtmlTags
+		})));
+		const graphicsOutputVersion = shallowRef(getTerminalGraphicsOutputVersion(terminal));
+		const unsubscribeGraphicsOutput = subscribeTerminalGraphicsOutput(terminal, () => {
+			graphicsOutputVersion.value = getTerminalGraphicsOutputVersion(terminal);
+		});
+		watch(() => `${props.streaming ? 1 : 0}:${(props.customHtmlTags ?? []).join("\0")}`, () => {
+			parser.value = markRaw(createTuiMarkdownParser({
+				streaming: props.streaming,
+				customHtmlTags: props.customHtmlTags
+			}));
+		});
+		function rebuildRows() {
+			const prevScrollTop = internalScrollTop.value;
+			const prevVisibleRows = visibleRowSignatures(rows.value, prevScrollTop);
+			const prevVisibleGraphics = visibleRowGraphics(rows.value, prevScrollTop);
+			const nextLayout = withTextWidthProvider(widthProvider, () => {
+				const blocks = props.blocks ?? buildMarkdownBlocks(props.content, parser.value, {
+					final: props.final,
+					theme: props.theme,
+					imageResolver: props.imageRenderer,
+					imageSize: {
+						minWidth: props.imageMinWidth,
+						maxWidth: props.imageMaxWidth,
+						minHeight: props.imageMinHeight,
+						maxHeight: props.imageMaxHeight,
+						preserveAspectRatio: props.imagePreserveAspectRatio
+					}
+				}).blocks;
+				return layoutMarkdownBlocksCached(blocks, props.w, layoutCache);
+			});
+			layoutCache = markRaw(nextLayout.cache);
+			const nextRows = nextLayout.rows;
+			rows.value = markRaw(nextRows);
+			reconcileScrollTop();
+			const nextScrollTop = internalScrollTop.value;
+			const nextVisibleRows = visibleRowSignatures(nextRows, nextScrollTop);
+			const nextVisibleGraphics = visibleRowGraphics(nextRows, nextScrollTop);
+			const visibleChanged = prevVisibleRows.length !== nextVisibleRows.length || prevVisibleRows.some((row, index) => row !== nextVisibleRows[index]) || prevVisibleGraphics.some((row, index) => row !== nextVisibleGraphics[index]);
+			if (!builtOnce || prevScrollTop !== nextScrollTop || visibleChanged) {
+				documentVersion.value++;
+				selection.refresh();
+			}
+		}
+		function scheduleRebuild() {
+			const currentVersion = ++rebuildVersion;
+			if (!builtOnce || !props.streaming) {
+				builtOnce = true;
+				rebuildRows();
+				return;
+			}
+			scheduler.queueFrameTask({
+				id: `TVirtualMarkdown:${instance?.uid ?? "unknown"}:markdown`,
+				reason: props.streaming ? "stream" : "data",
+				priority: props.streaming ? "low" : "normal",
+				sync: false,
+				run: () => {
+					if (!alive) return;
+					if (currentVersion !== rebuildVersion) return;
+					rebuildRows();
+				}
+			});
+		}
+		const fullRect = computed(() => translateRect({
+			x: props.x,
+			y: props.y,
+			w: props.w,
+			h: props.h
+		}, layout.originX, layout.originY));
+		const absRect = computed(() => {
+			const translated = fullRect.value;
+			if (!layout.clipRect) return translated;
+			return intersectRect(translated, layout.clipRect) ?? {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			};
+		});
+		function normalizedRect() {
+			return normalizeCellRect(absRect.value);
+		}
+		function normalizedFullRect() {
+			return normalizeCellRect(fullRect.value);
+		}
+		function clipOffsets() {
+			const full = normalizedFullRect();
+			const clip = normalizedRect();
+			return {
+				x: Math.max(0, clip.x - full.x),
+				y: Math.max(0, clip.y - full.y)
+			};
+		}
+		function maxScrollTop() {
+			const clip = normalizedRect();
+			const { y: clipY } = clipOffsets();
+			return Math.max(0, rows.value.length - (clipY + clip.h));
+		}
+		function visibleRowSignatures(sourceRows, scrollTop) {
+			const clip = normalizedRect();
+			const { y: clipY } = clipOffsets();
+			const start = Math.max(0, scrollTop + clipY);
+			const end = Math.max(start, start + clip.h);
+			const out = [];
+			for (let index = start; index < end; index++) out.push(markdownRowSignature(sourceRows[index]));
+			return out;
+		}
+		function visibleRowGraphics(sourceRows, scrollTop) {
+			const clip = normalizedRect();
+			const { y: clipY } = clipOffsets();
+			const start = Math.max(0, scrollTop + clipY);
+			const end = Math.max(start, start + clip.h);
+			const out = [];
+			for (let index = start; index < end; index++) out.push(rowGraphicSignature(sourceRows[index]));
+			return out;
+		}
+		function hasControlledScrollTop() {
+			return Object.prototype.hasOwnProperty.call(instance?.vnode.props ?? {}, "scrollTop");
+		}
+		function applyControlledScrollTop(next, remapSelectionFocus = false) {
+			const desired = Math.floor(Number(next) || 0);
+			const clamped = clamp(desired, 0, maxScrollTop());
+			const changed = internalScrollTop.value !== clamped;
+			if (changed) internalScrollTop.value = clamped;
+			if (desired !== clamped) {
+				emit("update:scrollTop", clamped);
+				emit("scroll", clamped);
+			}
+			if (changed || remapSelectionFocus) selection.refresh(remapSelectionFocus ? { remapFocus: true } : void 0);
+		}
+		function setScrollTop(next, emitChange = true, refreshOptions) {
+			const desired = Math.floor(Number(next) || 0);
+			const clamped = clamp(desired, 0, maxScrollTop());
+			const changed = internalScrollTop.value !== clamped;
+			if (changed) internalScrollTop.value = clamped;
+			if (emitChange && (changed || refreshOptions?.emitClampEvenIfUnchanged && desired !== clamped)) {
+				emit("update:scrollTop", clamped);
+				emit("scroll", clamped);
+			}
+			if (changed || refreshOptions?.remapSelectionFocus) selection.refresh(refreshOptions?.remapSelectionFocus ? { remapFocus: true } : void 0);
+		}
+		function reconcileScrollTop() {
+			const desired = hasControlledScrollTop() ? Math.floor(Number(props.scrollTop) || 0) : internalScrollTop.value;
+			const clamped = clamp(desired, 0, maxScrollTop());
+			if (internalScrollTop.value === clamped) return;
+			internalScrollTop.value = clamped;
+			if (desired !== clamped) {
+				emit("update:scrollTop", clamped);
+				emit("scroll", clamped);
+			}
+			selection.refresh();
+		}
+		watch(() => props.scrollTop, () => {
+			if (!hasControlledScrollTop()) return;
+			const remap = pendingSelectionScrollFocusRemap;
+			pendingSelectionScrollFocusRemap = false;
+			applyControlledScrollTop(props.scrollTop, remap);
+		});
+		watch([
+			() => props.content,
+			() => props.blocks,
+			() => props.w,
+			() => parser.value,
+			() => props.final,
+			() => props.imageRenderer,
+			() => markdownThemeSignature(props.theme),
+			() => props.imageMinWidth,
+			() => props.imageMaxWidth,
+			() => props.imageMinHeight,
+			() => props.imageMaxHeight,
+			() => props.imagePreserveAspectRatio
+		], () => {
+			scheduleRebuild();
+		}, { immediate: true });
+		watch([
+			() => props.content,
+			() => props.w,
+			() => props.h,
+			() => absRect.value.h
+		], () => {
+			resetWheelScrollState(wheelState);
+		});
+		watch([
+			() => props.h,
+			() => absRect.value.y,
+			() => absRect.value.h,
+			() => fullRect.value.y,
+			() => fullRect.value.h
+		], () => {
+			reconcileScrollTop();
+		}, { immediate: true });
+		function scrollSelectionBy(delta) {
+			const n = Math.trunc(Number(delta));
+			if (!Number.isFinite(n) || n === 0) return false;
+			if (hasControlledScrollTop()) {
+				const nextTop = clamp(internalScrollTop.value + n, 0, maxScrollTop());
+				if (nextTop === internalScrollTop.value) return false;
+				if (pendingSelectionScrollFocusRemap) return false;
+				pendingSelectionScrollFocusRemap = true;
+				emit("update:scrollTop", nextTop);
+				emit("scroll", nextTop);
+				return true;
+			}
+			const before = internalScrollTop.value;
+			setScrollTop(before + n, true, { remapSelectionFocus: true });
+			return internalScrollTop.value !== before;
+		}
+		function selectionPointForCell(point) {
+			const r = normalizedRect();
+			if (point.x < r.x || point.y < r.y || point.x >= r.x + r.w || point.y >= r.y + r.h) return null;
+			const { x: clipX, y: clipY } = clipOffsets();
+			const visualY = internalScrollTop.value + clipY + (point.y - r.y);
+			if (visualY < 0 || visualY >= rows.value.length) return null;
+			return {
+				x: clamp(clipX + (point.x - r.x), 0, Math.max(0, props.w - 1)),
+				y: visualY
+			};
+		}
+		function canHandleSelectionRange(range) {
+			return Boolean(selectionPointForCell(range.anchor) && selectionPointForCell(range.focus));
+		}
+		function textForSelectionRange(range) {
+			const cols = Math.max(1, Math.floor(props.w));
+			return withTextWidthProvider(widthProvider, () => terminalSelectionRowSpans(range, cols, rows.value.length).map((span) => {
+				const text = sliceByCellsRange(rows.value[span.y]?.plainText ?? "", span.x0, span.x1);
+				return span.x1 >= cols ? text.trimEnd() : text;
+			}).join("\n"));
+		}
+		function visibleSpansForSelectionRange(providerRange, _screenRange) {
+			const r = normalizedRect();
+			const { x: clipX, y: clipY } = clipOffsets();
+			const cols = Math.max(1, Math.floor(props.w));
+			const top = internalScrollTop.value + clipY;
+			const bottom = top + r.h;
+			const providerSpans = terminalSelectionVisibleRowSpans(providerRange, cols, rows.value.length, top, bottom);
+			const result = [];
+			for (const span of providerSpans) {
+				const screenY = r.y + (span.y - top);
+				const screenX0 = r.x + span.x0 - clipX;
+				const screenX1 = r.x + span.x1 - clipX;
+				const x0 = Math.max(r.x, screenX0);
+				const x1 = Math.min(r.x + r.w, screenX1);
+				if (screenY >= r.y && screenY < r.y + r.h && x1 > x0) result.push({
+					y: screenY,
+					x0,
+					x1
+				});
+			}
+			return result;
+		}
+		function onKeydown(event) {
+			emit("keydown", event);
+			const page = Math.max(1, normalizedRect().h);
+			if (event.key === "ArrowUp") {
+				event.preventDefault();
+				setScrollTop(internalScrollTop.value - 1);
+				return;
+			}
+			if (event.key === "ArrowDown") {
+				event.preventDefault();
+				setScrollTop(internalScrollTop.value + 1);
+				return;
+			}
+			if (event.key === "PageUp") {
+				event.preventDefault();
+				setScrollTop(internalScrollTop.value - page);
+				return;
+			}
+			if (event.key === "PageDown") {
+				event.preventDefault();
+				setScrollTop(internalScrollTop.value + page);
+				return;
+			}
+			if (event.key === "Home") {
+				event.preventDefault();
+				setScrollTop(0);
+				return;
+			}
+			if (event.key === "End") {
+				event.preventDefault();
+				setScrollTop(maxScrollTop());
+			}
+		}
+		const selectionTextProvider = {
+			id: `TVirtualMarkdown:${instance?.uid ?? "unknown"}:selection-text`,
+			get rect() {
+				return normalizedRect();
+			},
+			canHandle: canHandleSelectionRange,
+			pointForCell: selectionPointForCell,
+			getText: textForSelectionRange,
+			getVisibleSpans: visibleSpansForSelectionRange
+		};
+		const unregisterSelectionTextProvider = selection.registerTextProvider(selectionTextProvider);
+		onBeforeUnmount(unregisterSelectionTextProvider);
+		const eventNode = useTerminalNode(() => ({
+			rect: normalizedRect(),
+			zIndex: eventZ.value,
+			visible: visible.value,
+			focusable: true,
+			selectable: props.selectable,
+			selectionScrollBy: scrollSelectionBy,
+			handlers: {
+				click: (event) => {
+					const r = normalizedRect();
+					const { x: clipX, y: clipY } = clipOffsets();
+					const hitOptions = {
+						screenRect: r,
+						rowOffset: internalScrollTop.value + clipY,
+						clipStart: clipX
+					};
+					if (props.imageActions) {
+						const hit = findMarkdownImageActionAt(rows.value, {
+							cellX: event.cellX,
+							cellY: event.cellY
+						}, hitOptions);
+						if (hit) {
+							event.preventDefault();
+							emit("imageAction", hit);
+							return;
+						}
+					}
+					if (props.mathActions) {
+						const math = findMarkdownMathActionAt(rows.value, {
+							cellX: event.cellX,
+							cellY: event.cellY
+						}, hitOptions);
+						if (math) {
+							event.preventDefault();
+							emit("mathAction", math);
+							return;
+						}
+					}
+					if (!props.linkActions) return;
+					const link = findMarkdownLinkActionAt(rows.value, {
+						cellX: event.cellX,
+						cellY: event.cellY
+					}, hitOptions);
+					if (!link) return;
+					event.preventDefault();
+					emit("linkAction", link);
+				},
+				wheel: (event) => {
+					const { deltaY, mode } = getWheelScrollInput(event);
+					if (!deltaY) return;
+					const now = typeof event.time === "number" ? event.time : typeof event.timeStamp === "number" ? event.timeStamp : Date.now();
+					const { nextTop, dir } = applyWheelScroll(wheelState, deltaY, internalScrollTop.value, maxScrollTop(), now, mode, { disableAcceleration: mode === "pixel" });
+					if (!dir || nextTop === internalScrollTop.value) return;
+					event.preventDefault?.();
+					setScrollTop(nextTop);
+				},
+				focus: () => {
+					emit("focus");
+				},
+				blur: () => {
+					emit("blur");
+				},
+				keydown: onKeydown
+			}
+		}));
+		watchEffect(() => {
+			if (!props.autoFocus || !visible.value) return;
+			const manager = events.value;
+			const nodeId = eventNode.id.value;
+			if (!nodeId) return;
+			if (!manager) return;
+			if (manager.getFocused() === nodeId) return;
+			manager.focus(nodeId);
+		});
+		onBeforeUnmount(() => {
+			alive = false;
+			rebuildVersion++;
+			unsubscribeGraphicsOutput();
+			clearMarkdownImageGraphics(terminal, fullRect.value);
+		});
+		useRenderNode(() => ({
+			zIndex: props.zIndex,
+			rect: visible.value ? normalizedRect() : {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			},
+			deps: [
+				visible.value,
+				absRect.value,
+				fullRect.value,
+				internalScrollTop.value,
+				props.style,
+				defaultStyle.value,
+				documentVersion.value,
+				graphicsOutputVersion.value,
+				props.imageOcclusionRects
+			],
+			paint: (dirtyRows) => {
+				withTextWidthProvider(widthProvider, () => {
+					if (!visible.value) return;
+					const r = normalizedRect();
+					if (r.w <= 0 || r.h <= 0) return;
+					const baseStyle = props.style ?? defaultStyle.value;
+					const { x: clipX, y: clipY } = clipOffsets();
+					const isGraphicCovered = (rect) => {
+						return props.imageOcclusionRects?.some((item) => intersectRect(rect, item)) === true;
+					};
+					const keepGraphicIds = collectVisibleMarkdownImageGraphicIds(rows.value, {
+						x: r.x,
+						y: r.y,
+						w: r.w,
+						h: r.h,
+						rowOffset: internalScrollTop.value + clipY,
+						clipStart: clipX,
+						isGraphicCovered
+					});
+					const paintRow = (y) => {
+						if (y < r.y || y >= r.y + r.h) return;
+						const visualIndex = internalScrollTop.value + clipY + (y - r.y);
+						paintMarkdownVisualRow(terminal, rows.value[visualIndex], {
+							x: r.x,
+							y,
+							w: r.w,
+							clipStart: clipX,
+							baseStyle,
+							clear: true,
+							keepGraphicIds,
+							isGraphicCovered
+						});
+					};
+					if (dirtyRows?.length) {
+						for (const y of dirtyRows) paintRow(y);
+						return;
+					}
+					for (let y = r.y; y < r.y + r.h; y++) paintRow(y);
+				});
+			}
+		}));
+		return () => h("span", rootProps);
+	}
+});
+
+//#endregion
+//#region src/vue/markdown/block-source.ts
+function withBlockKeyPrefix(block, prefix, index) {
+	const key = `${prefix}:${index}:${block.key}`;
+	switch (block.type) {
+		case "inline": return {
+			...block,
+			key
+		};
+		case "code_block": return {
+			...block,
+			key
+		};
+		case "thematic_break": return {
+			...block,
+			key
+		};
+		case "table": return {
+			...block,
+			key
+		};
+		case "blank": return {
+			...block,
+			key
+		};
+	}
+}
+function parseBlockGroup(text, key, parser, theme, final) {
+	const { blocks } = buildMarkdownBlocks(text, parser, {
+		final,
+		theme
+	});
+	return {
+		key,
+		blocks: blocks.map((block, index) => withBlockKeyPrefix(block, key, index))
+	};
+}
+function shouldInsertGap(previous, next) {
+	return previous != null && next != null && previous.type !== "blank" && next.type !== "blank";
+}
+function mergeGroups(groups) {
+	const out = [];
+	for (const group of groups) {
+		if (!group.blocks.length) continue;
+		if (shouldInsertGap(out[out.length - 1], group.blocks[0])) out.push({
+			type: "blank",
+			key: `${group.key}:gap`
+		});
+		out.push(...group.blocks);
+	}
+	return out;
+}
+function createMarkdownBlockSource(options) {
+	const parser = options?.parser ?? createTuiMarkdownParser({
+		streaming: true,
+		customHtmlTags: options?.customHtmlTags
+	});
+	const theme = options?.theme;
+	const finalizedGroups = [];
+	let tailText = "";
+	let nextGroupIndex = 0;
+	let version = 0;
+	let cachedVersion = -1;
+	let cachedBlocks = [];
+	const invalidate = () => {
+		version++;
+		cachedVersion = -1;
+	};
+	const currentGroups = () => {
+		if (!tailText) return finalizedGroups;
+		return [...finalizedGroups, parseBlockGroup(tailText, `md-tail-${nextGroupIndex}`, parser, theme, false)];
+	};
+	const blocks = () => {
+		if (cachedVersion === version) return cachedBlocks;
+		cachedBlocks = mergeGroups(currentGroups());
+		cachedVersion = version;
+		return cachedBlocks;
+	};
+	const snapshot = () => ({
+		version,
+		blocks: blocks()
+	});
+	return {
+		get version() {
+			return version;
+		},
+		get blocks() {
+			return blocks();
+		},
+		appendDelta(text) {
+			if (!text) return;
+			tailText += text;
+			invalidate();
+		},
+		replaceTailBlock(text) {
+			if (tailText === text) return;
+			tailText = text;
+			invalidate();
+		},
+		finalizeBlock() {
+			if (!tailText) return;
+			const key = `md-block-${nextGroupIndex++}`;
+			finalizedGroups.push(parseBlockGroup(tailText, key, parser, theme, true));
+			tailText = "";
+			invalidate();
+		},
+		clear() {
+			if (!tailText && finalizedGroups.length === 0) return;
+			finalizedGroups.length = 0;
+			tailText = "";
+			nextGroupIndex = 0;
+			invalidate();
+		},
+		snapshot
+	};
+}
+
+//#endregion
+export { TVirtualMarkdown, buildMarkdownBlocks, buildMarkdownVisualRows, canDrawTerminalGraphicRect, clearMarkdownImageGraphics, collectVisibleMarkdownImageGraphicIds, createIterm2InlineImageSequence, createKittyDeleteGraphicsSequence, createKittyGraphicsSequence, createKittyPlacementSequence, createMarkdownBlockSource, createTuiMarkdownParser, detectTerminalGraphicsCapabilities, findMarkdownImageActionAt, findMarkdownLinkActionAt, findMarkdownMathActionAt, getTerminalGraphicsOutput, getTerminalGraphicsOutputVersion, hashTerminalGraphicsString, isSafeMarkdownLink, isSafeTerminalGraphicsSequence, isTerminalGraphicsProtocol, layoutMarkdownBlocks, markdownThemeSignature, normalizeTerminalGraphicSize, paintMarkdownVisualRow, sanitizeTerminalFallbackText, stableTerminalGraphicNumericId, subscribeTerminalGraphicsOutput };