@simon_he/vue-tui 0.0.6 → 0.0.8

package/dist/markdown.js

@@ -0,0 +1,1581 @@
+import { EventZIndexContextKey, applyWheelScroll, createWheelScrollState, forEachTextCellSegment, intersectRect, normalizeCellRect, repeatChar, resetWheelScrollState, sanitizeInlineText, sanitizeTextBlock, sliceByCellsRange, spaces, textCellWidth, translateRect, useLayout, useRenderNode, useTerminal, useTerminalNode, useVisibility } from "./wheel-scroll-CiNsasLf.js";
+import { computed, defineComponent, getCurrentInstance, h, inject, markRaw, onBeforeUnmount, ref, shallowRef, watch, watchEffect } from "vue";
+import { getMarkdown, parseMarkdownToStructure } from "stream-markdown-parser";
+
+//#region src/vue/markdown/parser.ts
+const RELATIVE_LINK_PREFIXES = [
+	"#",
+	"/",
+	"./",
+	"../"
+];
+const SAFE_PROTOCOLS = new Set([
+	"http:",
+	"https:",
+	"mailto:"
+]);
+const markdownInstanceCache = new Map();
+const MAX_MARKDOWN_INSTANCE_CACHE = 32;
+const SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+function hasControlChars(value) {
+	for (const ch of value) {
+		const code = ch.codePointAt(0);
+		if (code >= 0 && code <= 31 || code >= 127 && code <= 159) return true;
+	}
+	return false;
+}
+function isSafeMarkdownLink(url) {
+	const raw = String(url ?? "").trim();
+	if (!raw) return false;
+	if (hasControlChars(raw)) return false;
+	if (raw.startsWith("//")) return false;
+	const value = raw.toLowerCase();
+	if (value.startsWith("javascript:")) return false;
+	if (value.startsWith("data:")) return false;
+	if (RELATIVE_LINK_PREFIXES.some((prefix) => raw.startsWith(prefix))) return true;
+	if (!SCHEME_RE.test(raw)) return true;
+	try {
+		const parsed = new URL(raw);
+		return SAFE_PROTOCOLS.has(parsed.protocol);
+	} catch {
+		return false;
+	}
+}
+function markdownInstanceCacheKey(config) {
+	var _config$customHtmlTag;
+	return JSON.stringify({ customHtmlTags: [...(config === null || config === void 0 || (_config$customHtmlTag = config.customHtmlTags) === null || _config$customHtmlTag === void 0 ? void 0 : _config$customHtmlTag.filter(Boolean)) ?? []].sort() });
+}
+function getCachedMarkdownInstance(config) {
+	var _config$customHtmlTag2;
+	const cacheKey = markdownInstanceCacheKey(config);
+	const cached = markdownInstanceCache.get(cacheKey);
+	if (cached) return cached;
+	const customHtmlTags = config === null || config === void 0 || (_config$customHtmlTag2 = config.customHtmlTags) === null || _config$customHtmlTag2 === void 0 ? void 0 : _config$customHtmlTag2.filter(Boolean);
+	const created = getMarkdown(`vue-tui-markdown:${cacheKey}`, { customHtmlTags });
+	if (markdownInstanceCache.size >= MAX_MARKDOWN_INSTANCE_CACHE) markdownInstanceCache.clear();
+	markdownInstanceCache.set(cacheKey, created);
+	return created;
+}
+function createTuiMarkdownParser(config) {
+	var _config$customHtmlTag3;
+	const customHtmlTags = config === null || config === void 0 || (_config$customHtmlTag3 = config.customHtmlTags) === null || _config$customHtmlTag3 === void 0 ? void 0 : _config$customHtmlTag3.filter(Boolean);
+	const md = getCachedMarkdownInstance(config);
+	function parse(content, final) {
+		return parseMarkdownToStructure(content, md, {
+			final,
+			customHtmlTags,
+			requireClosingStrong: final || !(config === null || config === void 0 ? void 0 : config.streaming),
+			validateLink: isSafeMarkdownLink
+		});
+	}
+	return { parse };
+}
+
+//#endregion
+//#region src/vue/markdown/ast.ts
+const EMPTY_PREFIX = Object.freeze([]);
+const HARD_BREAK_SEGMENT = Object.freeze({
+	text: "",
+	hardBreak: true
+});
+function mergeStyle$1(base, overlay) {
+	if (!base) return overlay;
+	if (!overlay) return base;
+	return {
+		...base,
+		...overlay
+	};
+}
+function trimBlockArray(blocks) {
+	var _blocks$start, _blocks;
+	let start = 0;
+	let end = blocks.length;
+	while (start < end && ((_blocks$start = blocks[start]) === null || _blocks$start === void 0 ? void 0 : _blocks$start.type) === "blank") start++;
+	while (end > start && ((_blocks = blocks[end - 1]) === null || _blocks === void 0 ? void 0 : _blocks.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 booleanProp(node, key) {
+	return node[key] === true;
+}
+function pushTextSegments(out, text, style) {
+	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(style ? {
+			text: part,
+			style
+		} : { text: part });
+		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, " ");
+	let out = "";
+	for (const ch of normalized) {
+		const code = ch.charCodeAt(0);
+		if (code >= 0 && code <= 8 || code === 11 || code === 12) continue;
+		if (code >= 14 && code <= 31 || code === 127) continue;
+		out += ch;
+	}
+	return out;
+}
+function inlineNodeSegments(nodes, theme, inheritedStyle) {
+	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));
+			break;
+		case "strong":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, mergeStyle$1(inheritedStyle, theme.strong)));
+			break;
+		case "emphasis":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, mergeStyle$1(inheritedStyle, theme.emphasis)));
+			break;
+		case "strikethrough":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, mergeStyle$1(inheritedStyle, theme.strikethrough)));
+			break;
+		case "highlight":
+		case "insert":
+		case "subscript":
+		case "superscript":
+			out.push(...inlineNodeSegments(nodeChildren(node), theme, inheritedStyle));
+			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 && isSafeMarkdownLink(href) ? href : "";
+			const linkStyle = safeHref ? mergeStyle$1(inheritedStyle, {
+				...theme.link,
+				href: safeHref
+			}) : inheritedStyle;
+			const children = nodeChildren(node);
+			if (children.length) out.push(...inlineNodeSegments(children, theme, linkStyle));
+			else pushTextSegments(out, stringProp(node, "text"), linkStyle);
+			break;
+		}
+		case "image":
+			pushTextSegments(out, stringProp(node, "alt") || stringProp(node, "src"), 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":
+			pushTextSegments(out, stringProp(node, "content"), mergeStyle$1(inheritedStyle, theme.inlineCode));
+			break;
+		case "reference":
+		case "footnote_reference":
+		case "footnote_anchor":
+			pushTextSegments(out, 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));
+				break;
+			}
+			pushTextSegments(out, 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(node.children, theme), context);
+}
+function blockFromHeading(node, key, context, theme) {
+	const level = Math.min(6, Math.max(1, Math.floor(node.level || 1)));
+	return inlineBlock(key, inlineNodeSegments(node.children, theme, theme.heading[level - 1]), context);
+}
+function blockFromCodeBlock(node, key, context, theme) {
+	return {
+		type: "code_block",
+		key,
+		lines: sanitizeCodeBlockText(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: node.raw,
+		content: node.content
+	}], theme), context);
+}
+function childSequenceToBlocks(nodes, context, theme, keyPrefix) {
+	const out = [];
+	let appended = false;
+	for (let i = 0; i < nodes.length; i++) {
+		var _out, _childBlocks$;
+		const childBlocks = trimBlockArray(nodeToBlocks(nodes[i], context, theme, `${keyPrefix}-${i}`));
+		if (!childBlocks.length) continue;
+		if (appended && ((_out = out[out.length - 1]) === null || _out === void 0 ? void 0 : _out.type) !== "blank" && ((_childBlocks$ = childBlocks[0]) === null || _childBlocks$ === void 0 ? void 0 : _childBlocks$.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]
+	};
+	if (!item.children.length) return [inlineBlock(`${keyPrefix}-empty`, [], firstContext)];
+	const out = [];
+	let usedLead = false;
+	for (let i = 0; i < item.children.length; i++) {
+		var _out2, _childBlocks$2, _out3, _childBlocks$3;
+		const child = item.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 && ((_out2 = out[out.length - 1]) === null || _out2 === void 0 ? void 0 : _out2.type) === "inline" && ((_childBlocks$2 = childBlocks[0]) === null || _childBlocks$2 === void 0 ? void 0 : _childBlocks$2.type) === "inline";
+		if (out.length && ((_out3 = out[out.length - 1]) === null || _out3 === void 0 ? void 0 : _out3.type) !== "blank" && ((_childBlocks$3 = childBlocks[0]) === null || _childBlocks$3 === void 0 ? void 0 : _childBlocks$3.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 = [];
+	for (let i = 0; i < node.items.length; i++) out.push(...listItemBlocks(node.items[i], i, node.ordered, 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]
+			};
+			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 "inline": return [inlineBlock(keyPrefix, inlineNodeSegments(nodeChildren(node), theme), context)];
+		case "html_block":
+			if ("content" in node) return [blockFromHtmlBlock(node, keyPrefix, context, theme)];
+			break;
+		case "text": return [inlineBlock(keyPrefix, inlineNodeSegments([node], theme), context)];
+	}
+	if (nodeChildren(node).length) return childSequenceToBlocks(nodeChildren(node), context, theme, keyPrefix);
+	return [inlineBlock(keyPrefix, inlineNodeSegments([node], theme), context)];
+}
+function markdownAstToBlocks(nodes, theme) {
+	const blocks = trimBlockArray(childSequenceToBlocks(nodes, {
+		prefixSegments: EMPTY_PREFIX,
+		continuationPrefixSegments: EMPTY_PREFIX
+	}, 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
+	};
+}
+function segmentsPlainText(segments) {
+	return segments.map((segment) => segment.text).join("");
+}
+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;
+		out.push(segment.style ? {
+			text: piece,
+			style: segment.style
+		} : { text: piece });
+		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) {
+		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
+				});
+				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++;
+		}
+	}
+	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 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) {
+	return [
+		segment.text,
+		segment.hardBreak ? "1" : "0",
+		styleSignature(segment.style)
+	].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.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 "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 "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));
+	if (normalizedWidth <= 0) return {
+		rows: [],
+		cache: {
+			width: normalizedWidth,
+			entries: new Map()
+		}
+	};
+	const rows = [];
+	const entries = new Map();
+	const previousEntries = (previous === null || previous === void 0 ? void 0 : previous.width) === normalizedWidth ? 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 === null || previousEntries === void 0 ? void 0 : previousEntries.get(cacheKey);
+		const blockRows = (cached === null || cached === void 0 ? void 0 : 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,
+			entries
+		}
+	};
+}
+function layoutMarkdownBlocks(blocks, width) {
+	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) => {
+		var _overrides$heading;
+		return mergeFrozenStyle(style, (_overrides$heading = overrides.heading) === null || _overrides$heading === void 0 ? void 0 : _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 === null || options === void 0 ? void 0 : options.theme);
+	try {
+		const nodes = parser.parse(content, (options === null || options === void 0 ? void 0 : options.final) ?? true);
+		const blocks = markdownAstToBlocks(nodes, theme);
+		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);
+	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/render.ts
+const mergedStyleCache = new WeakMap();
+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;
+}
+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
+		});
+		return;
+	}
+	let logicalX = 0;
+	let used = 0;
+	for (const segment of row.segments) {
+		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);
+		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) {
+				terminal.write(spaces(pad), {
+					x: options.x + used,
+					y: options.y,
+					style: segmentStyle
+				});
+				used += pad;
+			}
+		});
+	}
+	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/TMarkdownText.ts
+const TMarkdownText = defineComponent({
+	name: "TMarkdownText",
+	props: {
+		x: {
+			type: Number,
+			required: true
+		},
+		y: {
+			type: Number,
+			required: true
+		},
+		zIndex: {
+			type: Number,
+			default: 0
+		},
+		content: {
+			type: String,
+			required: true
+		},
+		w: {
+			type: Number,
+			required: true
+		},
+		h: {
+			type: Number,
+			default: void 0
+		},
+		style: {
+			type: Object,
+			default: void 0
+		},
+		final: {
+			type: Boolean,
+			default: true
+		},
+		streaming: {
+			type: Boolean,
+			default: false
+		},
+		clear: {
+			type: Boolean,
+			default: true
+		},
+		customHtmlTags: {
+			type: Array,
+			default: void 0
+		},
+		theme: {
+			type: Object,
+			default: void 0
+		}
+	},
+	setup(props) {
+		const instance = getCurrentInstance();
+		const { terminal, defaultStyle, scheduler } = useTerminal();
+		const layout = useLayout();
+		const { visible, rootProps } = useVisibility();
+		const rows = shallowRef(markRaw([]));
+		const documentVersion = shallowRef(0);
+		let builtOnce = false;
+		let rebuildVersion = 0;
+		let alive = true;
+		const parser = shallowRef(markRaw(createTuiMarkdownParser({
+			streaming: props.streaming,
+			customHtmlTags: props.customHtmlTags
+		})));
+		watch(() => `${props.streaming ? 1 : 0}:${(props.customHtmlTags ?? []).join("\0")}`, () => {
+			parser.value = markRaw(createTuiMarkdownParser({
+				streaming: props.streaming,
+				customHtmlTags: props.customHtmlTags
+			}));
+		});
+		function rebuildRows() {
+			rows.value = markRaw(buildMarkdownVisualRows(props.content, props.w, parser.value, {
+				final: props.final,
+				theme: props.theme
+			}));
+			documentVersion.value++;
+		}
+		function scheduleRebuild() {
+			const currentVersion = ++rebuildVersion;
+			if (!builtOnce || !props.streaming) {
+				builtOnce = true;
+				rebuildRows();
+				return;
+			}
+			scheduler.queueFrameTask({
+				id: `TMarkdownText:${(instance === null || instance === void 0 ? void 0 : 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();
+				}
+			});
+		}
+		watch([
+			() => props.content,
+			() => props.w,
+			() => parser.value,
+			() => props.final,
+			() => markdownThemeSignature(props.theme)
+		], () => {
+			scheduleRebuild();
+		}, { immediate: true });
+		onBeforeUnmount(() => {
+			alive = false;
+			rebuildVersion++;
+		});
+		const fullRect = computed(() => {
+			const height = props.h ?? Math.max(1, rows.value.length);
+			return translateRect({
+				x: props.x,
+				y: props.y,
+				w: props.w,
+				h: height
+			}, 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
+			};
+		});
+		useRenderNode(() => ({
+			zIndex: props.zIndex,
+			rect: visible.value ? absRect.value : {
+				x: 0,
+				y: 0,
+				w: 0,
+				h: 0
+			},
+			deps: [
+				visible.value,
+				absRect.value,
+				fullRect.value,
+				props.style,
+				props.clear,
+				documentVersion.value,
+				defaultStyle.value
+			],
+			paint: (dirtyRows) => {
+				if (!visible.value) return;
+				const r = absRect.value;
+				const full = fullRect.value;
+				if (r.w <= 0 || r.h <= 0) return;
+				const baseStyle = props.style ?? defaultStyle.value;
+				const clipStart = Math.max(0, Math.floor(r.x - full.x));
+				const paintRow = (y) => {
+					if (y < r.y || y >= r.y + r.h) return;
+					const rowIndex = Math.floor(y - full.y);
+					const row = rows.value[rowIndex];
+					if (!row && !props.clear) return;
+					paintMarkdownVisualRow(terminal, row, {
+						x: r.x,
+						y,
+						w: r.w,
+						clipStart,
+						baseStyle,
+						clear: props.clear
+					});
+				};
+				if (dirtyRows === null || dirtyRows === void 0 ? void 0 : 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/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)}`).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"
+	};
+}
+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
+		}
+	},
+	emits: [
+		"update:scrollTop",
+		"scroll",
+		"focus",
+		"blur",
+		"keydown"
+	],
+	setup(props, { emit }) {
+		const instance = getCurrentInstance();
+		const { terminal, defaultStyle, events, scheduler } = 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([]));
+		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
+		})));
+		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 blocks = props.blocks ?? buildMarkdownBlocks(props.content, parser.value, {
+				final: props.final,
+				theme: props.theme
+			}).blocks;
+			const nextLayout = 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 visibleChanged = prevVisibleRows.length !== nextVisibleRows.length || prevVisibleRows.some((row, index) => row !== nextVisibleRows[index]);
+			if (!builtOnce || prevScrollTop !== nextScrollTop || visibleChanged) documentVersion.value++;
+		}
+		function scheduleRebuild() {
+			const currentVersion = ++rebuildVersion;
+			if (!builtOnce || !props.streaming) {
+				builtOnce = true;
+				rebuildRows();
+				return;
+			}
+			scheduler.queueFrameTask({
+				id: `TVirtualMarkdown:${(instance === null || instance === void 0 ? void 0 : 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 hasControlledScrollTop() {
+			return Object.prototype.hasOwnProperty.call((instance === null || instance === void 0 ? void 0 : instance.vnode.props) ?? {}, "scrollTop");
+		}
+		function setScrollTop(next, emitChange = true) {
+			const clamped = clamp(Math.floor(Number(next) || 0), 0, maxScrollTop());
+			if (internalScrollTop.value === clamped) return;
+			internalScrollTop.value = clamped;
+			if (emitChange) {
+				emit("update:scrollTop", clamped);
+				emit("scroll", clamped);
+			}
+		}
+		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);
+			}
+		}
+		watch(() => props.scrollTop, () => {
+			if (!hasControlledScrollTop()) return;
+			const desired = Math.floor(Number(props.scrollTop) || 0);
+			const clamped = clamp(desired, 0, maxScrollTop());
+			internalScrollTop.value = clamped;
+			if (desired !== clamped) {
+				emit("update:scrollTop", clamped);
+				emit("scroll", clamped);
+			}
+		});
+		watch([
+			() => props.content,
+			() => props.blocks,
+			() => props.w,
+			() => parser.value,
+			() => props.final,
+			() => markdownThemeSignature(props.theme)
+		], () => {
+			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 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 eventNode = useTerminalNode(() => ({
+			rect: normalizedRect(),
+			zIndex: eventZ.value,
+			visible: visible.value,
+			focusable: true,
+			selectable: props.selectable,
+			handlers: {
+				click: (_event) => {},
+				wheel: (event) => {
+					var _event$preventDefault;
+					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 = event.preventDefault) === null || _event$preventDefault === void 0 || _event$preventDefault.call(event);
+					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++;
+		});
+		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
+			],
+			paint: (dirtyRows) => {
+				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 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
+					});
+				};
+				if (dirtyRows === null || dirtyRows === void 0 ? void 0 : 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 "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 === null || options === void 0 ? void 0 : options.parser) ?? createTuiMarkdownParser({
+		streaming: true,
+		customHtmlTags: options === null || options === void 0 ? void 0 : options.customHtmlTags
+	});
+	const theme = options === null || options === void 0 ? void 0 : 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 { TMarkdownText, TVirtualMarkdown, buildMarkdownBlocks, buildMarkdownVisualRows, createMarkdownBlockSource, createTuiMarkdownParser, isSafeMarkdownLink, layoutMarkdownBlocks };