@wingleeio/mugen-markdown 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1861 @@
+import { Fragment, createElement, useEffect, useLayoutEffect, useRef } from "react";
+import { HStack, HStack as HStack$1, Text, VStack, VStack as VStack$1, assertMeasurableFont, definePrimitive, definePrimitive as definePrimitive$1, fontEpoch, fontLonghands, fontWithLineHeight, markPrimitive, naturalWidthOf } from "@wingleeio/mugen";
+import { createIncremarkParser } from "@incremark/core";
+import { measureRichInlineStats, prepareRichInline } from "@chenglou/pretext/rich-inline";
+//#region src/parse.ts
+const DEFAULTS = { gfm: true };
+function optionsKey(opts) {
+	return JSON.stringify([
+		opts.gfm ?? true,
+		typeof opts.math === "object" ? opts.math : opts.math ?? false,
+		typeof opts.containers === "object" ? true : opts.containers ?? false
+	]);
+}
+function makeParser(opts) {
+	return createIncremarkParser({
+		gfm: opts.gfm ?? true,
+		math: opts.math ?? false,
+		containers: opts.containers ?? false
+	});
+}
+const MAX_AST_CACHE = 512;
+const astCache = /* @__PURE__ */ new Map();
+function readAst(cacheKey) {
+	const cached = astCache.get(cacheKey);
+	if (cached === void 0) return void 0;
+	astCache.delete(cacheKey);
+	astCache.set(cacheKey, cached);
+	return cached;
+}
+function writeAst(cacheKey, ast) {
+	if (astCache.has(cacheKey)) astCache.delete(cacheKey);
+	else if (astCache.size >= MAX_AST_CACHE) {
+		const oldest = astCache.keys().next().value;
+		if (oldest !== void 0) astCache.delete(oldest);
+	}
+	astCache.set(cacheKey, ast);
+}
+const MAX_LIVE = 16;
+const live = [];
+/** Find the live parser (same options) whose source is the longest proper prefix of `source`. */
+function findExtensible(key, source) {
+	let bestIdx = -1;
+	let bestLen = -1;
+	for (let i = 0; i < live.length; i++) {
+		const e = live[i];
+		if (e.key !== key) continue;
+		const len = e.lastSource.length;
+		if (len < source.length && len > bestLen && source.startsWith(e.lastSource)) {
+			bestIdx = i;
+			bestLen = len;
+		}
+	}
+	return bestIdx;
+}
+function promote(idx) {
+	const [entry] = live.splice(idx, 1);
+	live.unshift(entry);
+	return entry;
+}
+/**
+* Parse markdown into an mdast `Root` with incremark, memoized by
+* `(source, options)` and parsed **incrementally** when the source grows.
+*
+* Pure and synchronous — safe to call inside mugen's measure walk. Growing the
+* same source (a streaming row) appends only the new text to a retained parser;
+* an unchanged source is served from the AST cache; a non-extending change parses
+* fresh.
+*/
+function parseMarkdown(source, options = DEFAULTS) {
+	const key = optionsKey(options);
+	const cacheKey = `${key} ${source}`;
+	const cached = readAst(cacheKey);
+	if (cached !== void 0) return cached;
+	let ast;
+	const idx = findExtensible(key, source);
+	if (idx >= 0) {
+		const entry = promote(idx);
+		const delta = source.slice(entry.lastSource.length);
+		ast = entry.parser.append(delta).ast;
+		entry.lastSource = source;
+	} else {
+		const parser = makeParser(options);
+		ast = parser.append(source).ast;
+		live.unshift({
+			key,
+			parser,
+			lastSource: source
+		});
+		if (live.length > MAX_LIVE) live.pop();
+	}
+	writeAst(cacheKey, ast);
+	return ast;
+}
+/** Drop the parse caches and retained parsers (tests / memory pressure). */
+function clearParseCache() {
+	astCache.clear();
+	live.length = 0;
+}
+//#endregion
+//#region src/highlight/types.ts
+/**
+* Default palette: mid-tone colours chosen to stay legible on both light and
+* dark page backgrounds, since the default theme inherits the page colours.
+*/
+const defaultTokenColors = {
+	keyword: "#a855f7",
+	string: "#059669",
+	comment: "#8a919e",
+	number: "#d97706",
+	constant: "#ea580c",
+	function: "#3b82f6",
+	type: "#0d9488",
+	property: "#db2777",
+	operator: "#64748b",
+	punctuation: "currentColor"
+};
+//#endregion
+//#region src/theme.ts
+const defaultTheme = {
+	fontFamily: "sans-serif",
+	monoFamily: "monospace",
+	fontSize: 16,
+	lineHeight: 26,
+	color: "inherit",
+	blockGap: 16,
+	heading: {
+		weight: 650,
+		color: "inherit",
+		sizes: {
+			1: 32,
+			2: 26,
+			3: 21,
+			4: 18,
+			5: 16,
+			6: 15
+		},
+		lineHeights: {
+			1: 40,
+			2: 34,
+			3: 28,
+			4: 26,
+			5: 24,
+			6: 22
+		}
+	},
+	strongWeight: 700,
+	emphasisItalic: true,
+	link: {
+		color: "#2563eb",
+		underline: true
+	},
+	inlineCode: {
+		color: "inherit",
+		background: "rgba(127, 127, 127, 0.16)",
+		sizeScale: .9
+	},
+	code: {
+		fontSize: 13.5,
+		lineHeight: 21,
+		padding: 14,
+		background: "rgba(127, 127, 127, 0.12)",
+		color: "inherit",
+		radius: 8,
+		highlight: defaultTokenColors
+	},
+	blockquote: {
+		padding: 14,
+		gap: 12,
+		borderWidth: 3,
+		borderColor: "rgba(127, 127, 127, 0.4)",
+		color: "inherit"
+	},
+	list: {
+		gap: 6,
+		indent: 28,
+		markerColor: "inherit"
+	},
+	table: {
+		cellPadding: 8,
+		gap: 1,
+		headerWeight: 650,
+		headerBackground: "rgba(127, 127, 127, 0.12)",
+		borderColor: "rgba(127, 127, 127, 0.35)",
+		radius: 8
+	},
+	rule: {
+		thickness: 1,
+		color: "rgba(127, 127, 127, 0.4)",
+		gap: 8
+	},
+	image: {
+		placeholderHeight: 0,
+		color: "rgba(127, 127, 127, 0.7)"
+	}
+};
+function isObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function deepMerge(base, patch) {
+	if (!isObject(patch)) return base;
+	const out = { ...base };
+	for (const key of Object.keys(patch)) {
+		const b = base[key];
+		const p = patch[key];
+		out[key] = isObject(b) && isObject(p) ? deepMerge(b, p) : p;
+	}
+	return out;
+}
+const resolveCache = /* @__PURE__ */ new WeakMap();
+/** Merge a partial theme over the defaults into a fully-resolved theme. */
+function resolveTheme(theme) {
+	if (theme == null) return defaultTheme;
+	const cached = resolveCache.get(theme);
+	if (cached !== void 0) return cached;
+	const resolved = deepMerge(defaultTheme, theme);
+	resolveCache.set(theme, resolved);
+	return resolved;
+}
+//#endregion
+//#region src/inline.ts
+/** A base format for body text at a given size/weight/colour. */
+function baseFormat(theme, opts = {}) {
+	return {
+		family: theme.fontFamily,
+		monoFamily: theme.monoFamily,
+		size: opts.size ?? theme.fontSize,
+		weight: opts.weight ?? 400,
+		italic: false,
+		mono: false,
+		underline: false,
+		strike: false,
+		color: opts.color ?? (theme.color !== "inherit" ? theme.color : void 0)
+	};
+}
+/** Compose a measurable `Font` shorthand from a format. */
+function composeFont(fmt) {
+	const family = fmt.mono ? fmt.monoFamily : fmt.family;
+	return `${fmt.italic ? "italic " : ""}${fmt.weight} ${fmt.size}px ${family}`;
+}
+function pushRun(out, text, fmt) {
+	if (text.length === 0) return;
+	const run = {
+		text,
+		font: composeFont(fmt)
+	};
+	if (fmt.color != null) run.color = fmt.color;
+	if (fmt.background != null) run.background = fmt.background;
+	const decoration = [fmt.underline ? "underline" : "", fmt.strike ? "line-through" : ""].filter(Boolean).join(" ");
+	if (decoration) run.decoration = decoration;
+	if (fmt.href != null) {
+		run.href = fmt.href;
+		run.as = "a";
+	} else if (fmt.mono) run.as = "code";
+	out.push(run);
+}
+/**
+* Flatten phrasing content into styled runs. Recursive over the inline marks;
+* the result feeds a single `<RichText>` so the whole paragraph wraps as one
+* flow and measures exactly.
+*/
+function flattenInline(nodes, fmt, theme, out) {
+	for (const node of nodes) switch (node.type) {
+		case "text":
+			pushRun(out, node.value, fmt);
+			break;
+		case "strong":
+			flattenInline(node.children, {
+				...fmt,
+				weight: theme.strongWeight
+			}, theme, out);
+			break;
+		case "emphasis":
+			flattenInline(node.children, {
+				...fmt,
+				italic: theme.emphasisItalic ? true : fmt.italic
+			}, theme, out);
+			break;
+		case "delete":
+			flattenInline(node.children, {
+				...fmt,
+				strike: true
+			}, theme, out);
+			break;
+		case "inlineCode":
+			pushRun(out, node.value, {
+				...fmt,
+				mono: true,
+				size: Math.round(fmt.size * theme.inlineCode.sizeScale),
+				color: theme.inlineCode.color !== "inherit" ? theme.inlineCode.color : fmt.color,
+				background: theme.inlineCode.background
+			});
+			break;
+		case "link":
+			flattenInline(node.children, {
+				...fmt,
+				href: node.url,
+				color: theme.link.color,
+				underline: theme.link.underline ? true : fmt.underline
+			}, theme, out);
+			break;
+		case "linkReference":
+			flattenInline(node.children, fmt, theme, out);
+			break;
+		case "break":
+			out.push({
+				text: "",
+				break: true
+			});
+			break;
+		case "image":
+			if (node.alt) pushRun(out, node.alt, {
+				...fmt,
+				color: theme.image.color
+			});
+			break;
+		case "imageReference":
+			if (node.alt) pushRun(out, node.alt, {
+				...fmt,
+				color: theme.image.color
+			});
+			break;
+		case "footnoteReference":
+			pushRun(out, `[${node.label ?? node.identifier}]`, {
+				...fmt,
+				color: theme.link.color
+			});
+			break;
+		default:
+			if ("children" in node && Array.isArray(node.children)) flattenInline(node.children, fmt, theme, out);
+			break;
+	}
+}
+//#endregion
+//#region src/primitives/rich-text.tsx
+function resolveRunFont(run, fallback) {
+	const font = run.font ?? fallback;
+	if (font == null) throw new Error("mugen-markdown: <RichText> run needs a font — set `font` on the run or on <RichText>.");
+	assertMeasurableFont(font);
+	return font;
+}
+/** Split runs into hard-break-delimited segments, each a list of rich-inline items. */
+function segmentItems(runs, fallback) {
+	const segments = [];
+	let cur = [];
+	for (const run of runs) {
+		if (run.break) {
+			segments.push(cur);
+			cur = [];
+			continue;
+		}
+		if (run.text.length === 0) continue;
+		const item = {
+			text: run.text,
+			font: resolveRunFont(run, fallback)
+		};
+		if (run.letterSpacing != null) item.letterSpacing = run.letterSpacing;
+		if (run.noBreak) item.break = "never";
+		cur.push(item);
+	}
+	segments.push(cur);
+	return segments;
+}
+const MAX_CACHE = 4096;
+const prepCache = /* @__PURE__ */ new Map();
+let cacheEpoch = -1;
+function segmentKey(items) {
+	let key = "";
+	for (const it of items) key += `${it.font}
${it.letterSpacing ?? ""}
${it.break ?? ""}
${it.text}`;
+	return key;
+}
+function prepareCached(items) {
+	const epoch = fontEpoch();
+	if (epoch !== cacheEpoch) {
+		prepCache.clear();
+		cacheEpoch = epoch;
+	}
+	const key = segmentKey(items);
+	let prepared = prepCache.get(key);
+	if (prepared === void 0) {
+		if (prepCache.size >= MAX_CACHE) prepCache.clear();
+		prepared = prepareRichInline(items);
+		prepCache.set(key, prepared);
+	}
+	return prepared;
+}
+function measureRichText(props, ctx) {
+	const { runs, lineHeight } = props;
+	if (runs.length === 0) return 0;
+	const segments = segmentItems(runs, props.font);
+	const hasText = segments.some((s) => s.length > 0);
+	const hasBreak = runs.some((r) => r.break);
+	if (!hasText && !hasBreak) return 0;
+	const width = Math.max(0, ctx.width);
+	let lines = 0;
+	for (const seg of segments) {
+		if (seg.length === 0) {
+			lines += 1;
+			continue;
+		}
+		lines += Math.max(1, measureRichInlineStats(prepareCached(seg), width).lineCount);
+	}
+	return lines * lineHeight;
+}
+function renderRichText(props) {
+	const lh = props.lineHeight;
+	const containerStyle = {
+		...props.font != null ? fontLonghands(props.font, lh) : { lineHeight: `${lh}px` },
+		whiteSpace: "normal",
+		overflowWrap: "anywhere",
+		margin: 0,
+		padding: 0,
+		...props.color != null ? { color: props.color } : null,
+		...props.align != null ? { textAlign: props.align } : null,
+		...props.style
+	};
+	const children = props.runs.map((run, i) => {
+		if (run.break) return createElement("br", { key: i });
+		const tag = run.as ?? (run.href != null ? "a" : "span");
+		const elementProps = {
+			key: i,
+			style: {
+				...fontLonghands(resolveRunFont(run, props.font), 0),
+				fontVariantLigatures: "normal",
+				fontFeatureSettings: "normal",
+				letterSpacing: run.letterSpacing != null ? `${run.letterSpacing}px` : "normal",
+				...run.color != null ? { color: run.color } : null,
+				...run.background != null ? { background: run.background } : null,
+				...run.decoration != null ? { textDecoration: run.decoration } : null,
+				...run.noBreak ? { whiteSpace: "nowrap" } : null
+			}
+		};
+		if (run.href != null) elementProps.href = run.href;
+		if (run.title != null) elementProps.title = run.title;
+		if (run.onClick != null) elementProps.onClick = run.onClick;
+		if (run.className != null) elementProps.className = run.className;
+		return createElement(tag, elementProps, run.text);
+	});
+	return createElement("div", {
+		className: props.className,
+		style: containerStyle
+	}, children);
+}
+/**
+* A measurable rich inline-text primitive: a paragraph of mixed-font runs that
+* wrap as one flow. Its height is `lines × lineHeight`, where `lines` comes from
+* pretext's rich-inline layout at the row's width — the same layout the browser
+* performs over the rendered spans, so the analytic height matches the paint.
+*/
+const RichText = markPrimitive(renderRichText, {
+	name: "RichText",
+	measure: (props, ctx) => measureRichText(props, ctx),
+	naturalWidth: (props) => {
+		const p = props;
+		if (p.runs.length === 0) return 0;
+		const segments = segmentItems(p.runs, p.font);
+		let max = 0;
+		for (const seg of segments) {
+			if (seg.length === 0) continue;
+			max = Math.max(max, measureRichInlineStats(prepareCached(seg), 1e7).maxLineWidth);
+		}
+		return max;
+	}
+});
+/** Drop the rich-inline prepare cache (tests / memory pressure). */
+function clearRichTextCache() {
+	prepCache.clear();
+	cacheEpoch = -1;
+}
+//#endregion
+//#region src/highlight/languages.ts
+function words(s) {
+	return new Set(s.split(" "));
+}
+const NONE = /* @__PURE__ */ new Set();
+function profile(p) {
+	return {
+		lineComments: p.lineComments ?? [],
+		blockComments: p.blockComments ?? [],
+		quotes: p.quotes ?? ["\"", "'"],
+		multilineQuotes: p.multilineQuotes ?? [],
+		keywords: p.keywords ?? NONE,
+		constants: p.constants ?? NONE,
+		capitalTypes: p.capitalTypes ?? false,
+		identExtra: p.identExtra ?? "",
+		...p.caseInsensitive ? { caseInsensitive: true } : null,
+		...p.stringKeys ? { stringKeys: true } : null,
+		...p.colonProps ? { colonProps: true } : null,
+		...p.eqProps ? { eqProps: true } : null,
+		...p.tags ? { tags: true } : null
+	};
+}
+const jsTs = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	multilineQuotes: ["`"],
+	keywords: words("abstract any as asserts async await bigint boolean break case catch class const continue debugger declare default delete do else enum export extends finally for from function get if implements import in infer instanceof interface is keyof let namespace never new number object of out override package private protected public readonly return satisfies set static string super switch symbol this throw try type typeof unique unknown var void while with yield"),
+	constants: words("true false null undefined NaN Infinity globalThis"),
+	capitalTypes: true,
+	colonProps: true
+});
+const python = profile({
+	lineComments: ["#"],
+	multilineQuotes: ["\"\"\"", "'''"],
+	keywords: words("and as assert async await break class continue def del elif else except finally for from global if import in is lambda match nonlocal not or pass raise return try while with yield"),
+	constants: words("True False None self cls"),
+	capitalTypes: true
+});
+const rust = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	quotes: ["\""],
+	keywords: words("as async await break const continue crate dyn else enum extern fn for if impl in let loop macro match mod move mut pub ref return self Self static struct super trait type union unsafe use where while"),
+	constants: words("true false"),
+	capitalTypes: true
+});
+const go = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	multilineQuotes: ["`"],
+	keywords: words("any break case chan const continue default defer else error fallthrough for func go goto if import interface map package range return select string struct switch type var int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64 float32 float64 byte rune bool"),
+	constants: words("true false nil iota")
+});
+const cLike = (extra) => profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	keywords: words("auto break case char const continue default do double else enum extern float for goto if inline int long register restrict return short signed sizeof static struct switch typedef union unsigned void volatile while " + extra),
+	constants: words("true false NULL nullptr"),
+	capitalTypes: true
+});
+const c = cLike("");
+const cpp = cLike("alignas alignof bool catch class concept constexpr consteval constinit decltype delete dynamic_cast explicit export friend mutable namespace new noexcept operator private protected public reinterpret_cast requires static_assert static_cast template this thread_local throw try typeid typename using virtual wchar_t co_await co_return co_yield");
+const java = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	keywords: words("abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for goto if implements import instanceof int interface long native new package permits private protected public record return sealed short static strictfp super switch synchronized this throw throws transient try var void volatile while yield"),
+	constants: words("true false null"),
+	capitalTypes: true
+});
+const csharp = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	keywords: words("abstract as async await base bool break byte case catch char checked class const continue decimal default delegate do double else enum event explicit extern finally fixed float for foreach goto if implicit in int interface internal is lock long namespace new object operator out override params private protected public readonly record ref return sbyte sealed short sizeof stackalloc static string struct switch this throw try typeof uint ulong unchecked unsafe ushort using var virtual void volatile when where while yield"),
+	constants: words("true false null"),
+	capitalTypes: true
+});
+const php = profile({
+	lineComments: ["//", "#"],
+	blockComments: [["/*", "*/"]],
+	keywords: words("abstract and array as break callable case catch class clone const continue declare default do echo else elseif empty enum extends final finally fn for foreach function global goto if implements include include_once instanceof insteadof interface isset list match namespace new or print private protected public readonly require require_once return static switch throw trait try unset use var while xor yield"),
+	constants: words("true false null TRUE FALSE NULL"),
+	capitalTypes: true
+});
+const ruby = profile({
+	lineComments: ["#"],
+	keywords: words("alias and begin break case class def defined? do else elsif end ensure for if in module next not or redo rescue retry return super then undef unless until when while yield require require_relative attr_accessor attr_reader attr_writer"),
+	constants: words("true false nil self"),
+	capitalTypes: true
+});
+const swift = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	multilineQuotes: ["\"\"\""],
+	keywords: words("as associatedtype await break case catch class continue convenience default defer deinit didSet do dynamic else enum extension fallthrough fileprivate final for func get guard if import in indirect infix init inout internal is lazy let mutating nonmutating open operator optional override postfix prefix private protocol public repeat required rethrows return set some static struct subscript super switch throw throws try typealias unowned var weak where while willSet"),
+	constants: words("true false nil"),
+	capitalTypes: true
+});
+const kotlin = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	multilineQuotes: ["\"\"\""],
+	keywords: words("abstract actual annotation as break by catch class companion const constructor continue crossinline data do else enum expect external final finally for fun get if import in infix init inline inner interface internal is lateinit noinline object open operator out override package private protected public reified return sealed set super suspend tailrec this throw try typealias val var vararg when where while"),
+	constants: words("true false null"),
+	capitalTypes: true
+});
+const shell = profile({
+	lineComments: ["#"],
+	keywords: words("if then else elif fi for while until do done case esac function in select time return exit export local readonly declare unset shift break continue eval exec set source alias trap")
+});
+const sql = profile({
+	lineComments: ["--"],
+	blockComments: [["/*", "*/"]],
+	quotes: [
+		"\"",
+		"'",
+		"`"
+	],
+	caseInsensitive: true,
+	keywords: words("select from where insert into values update delete set create table alter drop index view as join inner left right full outer on group by order having limit offset union all distinct and or not is in like between exists case when then else end primary key foreign references default constraint unique check if begin commit rollback transaction with returning cascade"),
+	constants: words("null true false")
+});
+const css = profile({
+	blockComments: [["/*", "*/"]],
+	identExtra: "-@#",
+	keywords: words("@media @import @charset @namespace @supports @document @page @font-face @keyframes @counter-style @font-feature-values @layer @container @property @scope"),
+	constants: words("inherit initial unset revert auto none important"),
+	colonProps: true
+});
+const scss = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	identExtra: "-@#$",
+	keywords: words("@media @import @use @forward @mixin @include @function @return @if @else @each @for @while @extend @keyframes @supports @layer @container @font-face @charset @debug @warn @error"),
+	constants: words("inherit initial unset revert auto none important"),
+	colonProps: true
+});
+const html = profile({
+	blockComments: [["<!--", "-->"]],
+	identExtra: "-",
+	tags: true,
+	eqProps: true
+});
+const json = profile({
+	lineComments: ["//"],
+	blockComments: [["/*", "*/"]],
+	stringKeys: true,
+	constants: words("true false null")
+});
+const yaml = profile({
+	lineComments: ["#"],
+	colonProps: true,
+	constants: words("true false null yes no on off True False Null Yes No On Off")
+});
+const toml = profile({
+	lineComments: ["#"],
+	multilineQuotes: ["\"\"\"", "'''"],
+	eqProps: true,
+	constants: words("true false")
+});
+const ini = profile({
+	lineComments: ["#", ";"],
+	eqProps: true
+});
+const dockerfile = profile({
+	lineComments: ["#"],
+	caseInsensitive: true,
+	keywords: words("from run cmd copy add env arg workdir expose entrypoint volume user label onbuild stopsignal healthcheck shell as")
+});
+const registry = /* @__PURE__ */ new Map();
+/**
+* Register a profile under one or more fence info-string names (lower-cased).
+* Use this to add or override languages for the built-in highlighter.
+*/
+function registerLanguage(names, p) {
+	for (const name of typeof names === "string" ? [names] : names) registry.set(name.toLowerCase(), p);
+}
+registerLanguage([
+	"javascript",
+	"js",
+	"jsx",
+	"mjs",
+	"cjs"
+], jsTs);
+registerLanguage([
+	"typescript",
+	"ts",
+	"tsx",
+	"mts",
+	"cts"
+], jsTs);
+registerLanguage([
+	"python",
+	"py",
+	"python3"
+], python);
+registerLanguage(["rust", "rs"], rust);
+registerLanguage(["go", "golang"], go);
+registerLanguage(["java"], java);
+registerLanguage(["c", "h"], c);
+registerLanguage([
+	"cpp",
+	"c++",
+	"cc",
+	"cxx",
+	"hpp",
+	"hxx",
+	"objc",
+	"objective-c"
+], cpp);
+registerLanguage([
+	"csharp",
+	"cs",
+	"c#"
+], csharp);
+registerLanguage(["php"], php);
+registerLanguage(["ruby", "rb"], ruby);
+registerLanguage(["swift"], swift);
+registerLanguage([
+	"kotlin",
+	"kt",
+	"kts"
+], kotlin);
+registerLanguage([
+	"shell",
+	"bash",
+	"sh",
+	"zsh",
+	"fish",
+	"console",
+	"shellsession"
+], shell);
+registerLanguage([
+	"sql",
+	"mysql",
+	"postgres",
+	"postgresql",
+	"sqlite",
+	"plsql"
+], sql);
+registerLanguage(["css"], css);
+registerLanguage([
+	"scss",
+	"sass",
+	"less"
+], scss);
+registerLanguage([
+	"html",
+	"xml",
+	"svg",
+	"xhtml",
+	"markup",
+	"vue",
+	"astro"
+], html);
+registerLanguage([
+	"json",
+	"jsonc",
+	"json5"
+], json);
+registerLanguage(["yaml", "yml"], yaml);
+registerLanguage(["toml"], toml);
+registerLanguage(["ini"], ini);
+registerLanguage(["dockerfile", "docker"], dockerfile);
+/** The profile for a fence language, or `null` when the language is unknown. */
+function profileFor(lang) {
+	if (lang == null || lang.length === 0) return null;
+	return registry.get(lang.trim().toLowerCase()) ?? null;
+}
+//#endregion
+//#region src/highlight/tokenize.ts
+const INITIAL_STATE = {
+	mode: "plain",
+	close: ""
+};
+const OPERATORS = "+-*/%=<>!&|^~?";
+const PUNCTUATION = "()[]{};,.:";
+function isDigit(c) {
+	return c >= "0" && c <= "9";
+}
+function isIdentStart(c, extra) {
+	return c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_" || c === "$" || c > "" || extra.length > 0 && extra.includes(c);
+}
+function isIdentPart(c, extra) {
+	return isIdentStart(c, extra) || isDigit(c);
+}
+/** Scan a string body from `from` to its closing delimiter (or end-of-line). */
+function scanStringBody(line, from, close) {
+	const n = line.length;
+	let j = from;
+	while (j < n) {
+		if (line.charCodeAt(j) === 92) {
+			j += 2;
+			continue;
+		}
+		if (line.startsWith(close, j)) return {
+			end: j + close.length,
+			closed: true
+		};
+		j++;
+	}
+	return {
+		end: n,
+		closed: false
+	};
+}
+/** Loose number scan: digits, radix prefixes, separators, exponents, suffixes. */
+function scanNumber(line, start) {
+	const n = line.length;
+	let j = start;
+	while (j < n) {
+		const c = line[j];
+		if (isDigit(c) || c === "." || c === "_" || c >= "a" && c <= "z" || c >= "A" && c <= "Z") {
+			j++;
+			continue;
+		}
+		const prev = line[j - 1];
+		if ((c === "+" || c === "-") && (prev === "e" || prev === "E" || prev === "p" || prev === "P")) {
+			j++;
+			continue;
+		}
+		break;
+	}
+	return j;
+}
+function nextNonSpaceIdx(line, j) {
+	const n = line.length;
+	while (j < n) {
+		const c = line[j];
+		if (c !== " " && c !== "	") return j;
+		j++;
+	}
+	return -1;
+}
+function classifyWord(line, start, end, prev, p) {
+	const word = line.slice(start, end);
+	const key = p.caseInsensitive === true ? word.toLowerCase() : word;
+	if (p.keywords.has(key)) return "keyword";
+	if (p.constants.has(key)) return "constant";
+	if (p.tags === true && (prev === "<" || prev === "/")) return "keyword";
+	const ni = nextNonSpaceIdx(line, end);
+	const next = ni < 0 ? "" : line[ni];
+	if (next === "(") return "function";
+	if (p.eqProps === true && next === "=" && line[ni + 1] !== "=") return "property";
+	if (p.colonProps === true && line[end] === ":" && line[end + 1] !== ":") return "property";
+	if (prev === ".") return "property";
+	if (p.capitalTypes) {
+		const c0 = line[start];
+		if (c0 >= "A" && c0 <= "Z") return "type";
+	}
+	return null;
+}
+/**
+* Tokenize one line given the state the previous line ended in. Returns the
+* coloured tokens (sorted, non-overlapping) and the state this line ends in.
+*/
+function tokenizeLine(line, state, p) {
+	const tokens = [];
+	const n = line.length;
+	let i = 0;
+	const push = (start, end, type) => {
+		if (end > start) tokens.push({
+			start,
+			end,
+			type
+		});
+	};
+	if (state.mode === "comment") {
+		const j = line.indexOf(state.close);
+		if (j < 0) {
+			push(0, n, "comment");
+			return {
+				tokens,
+				end: state
+			};
+		}
+		i = j + state.close.length;
+		push(0, i, "comment");
+	} else if (state.mode === "string") {
+		const r = scanStringBody(line, 0, state.close);
+		push(0, r.end, "string");
+		if (!r.closed) return {
+			tokens,
+			end: state
+		};
+		i = r.end;
+	}
+	let prev = "";
+	outer: while (i < n) {
+		const ch = line[i];
+		if (ch === " " || ch === "	") {
+			i++;
+			continue;
+		}
+		for (const lc of p.lineComments) if (line.startsWith(lc, i)) {
+			push(i, n, "comment");
+			i = n;
+			break outer;
+		}
+		for (const bc of p.blockComments) if (line.startsWith(bc[0], i)) {
+			const j = line.indexOf(bc[1], i + bc[0].length);
+			if (j < 0) {
+				push(i, n, "comment");
+				return {
+					tokens,
+					end: {
+						mode: "comment",
+						close: bc[1]
+					}
+				};
+			}
+			push(i, j + bc[1].length, "comment");
+			i = j + bc[1].length;
+			prev = "";
+			continue outer;
+		}
+		for (const q of p.multilineQuotes) if (line.startsWith(q, i)) {
+			const r = scanStringBody(line, i + q.length, q);
+			push(i, r.end, "string");
+			if (!r.closed) return {
+				tokens,
+				end: {
+					mode: "string",
+					close: q
+				}
+			};
+			i = r.end;
+			prev = q[0];
+			continue outer;
+		}
+		if (p.quotes.includes(ch)) {
+			const r = scanStringBody(line, i + 1, ch);
+			push(i, r.end, p.stringKeys === true && line[r.end] === ":" ? "property" : "string");
+			i = r.end;
+			prev = ch;
+			continue;
+		}
+		if (isDigit(ch) || ch === "." && i + 1 < n && isDigit(line[i + 1])) {
+			const j = scanNumber(line, i);
+			push(i, j, "number");
+			i = j;
+			prev = "0";
+			continue;
+		}
+		if (isIdentStart(ch, p.identExtra)) {
+			let j = i + 1;
+			while (j < n && isIdentPart(line[j], p.identExtra)) j++;
+			const type = classifyWord(line, i, j, prev, p);
+			if (type != null) push(i, j, type);
+			i = j;
+			prev = "a";
+			continue;
+		}
+		if (OPERATORS.includes(ch)) {
+			let j = i + 1;
+			while (j < n && OPERATORS.includes(line[j])) j++;
+			push(i, j, "operator");
+			prev = line[j - 1];
+			i = j;
+			continue;
+		}
+		if (PUNCTUATION.includes(ch)) {
+			push(i, i + 1, "punctuation");
+			prev = ch;
+			i++;
+			continue;
+		}
+		prev = ch;
+		i++;
+	}
+	return {
+		tokens,
+		end: INITIAL_STATE
+	};
+}
+const TILE_LINES = 96;
+const SYNC_BUDGET_MS = 4;
+const CHUNK_BUDGET_MS = 6;
+/** Dirty-line count beyond which we show the DOM text while re-tokenizing. */
+const REVEAL_THRESHOLD = 512;
+let sharedMeasure;
+function measureCtx() {
+	if (sharedMeasure === void 0) {
+		sharedMeasure = typeof document === "undefined" ? null : document.createElement("canvas").getContext("2d", { willReadFrequently: false });
+		if (sharedMeasure != null && typeof sharedMeasure.measureText !== "function") sharedMeasure = null;
+	}
+	return sharedMeasure;
+}
+/** Visible lines, matching the measure's `lineCount` (trailing `\n` is silent). */
+function splitLines(value) {
+	const parts = value.split("\n");
+	if (parts.length > 0 && parts[parts.length - 1] === "") parts.pop();
+	return parts;
+}
+var HighlightSession = class {
+	input = null;
+	lines = [];
+	tokens = [];
+	ends = [];
+	widths = [];
+	/** Number of lines tokenized so far (a prefix of `lines`). */
+	done = 0;
+	tiles = [];
+	/** Scrollable ancestors of the block (visibility window + scroll signals). */
+	scrollers = [];
+	/** True while the DOM text is visible and the overlay hidden. */
+	revealed = true;
+	plainColor = null;
+	metrics = null;
+	pending = null;
+	io = null;
+	unlisten = [];
+	update(next) {
+		if (measureCtx() == null) return;
+		const prev = this.input;
+		this.input = next;
+		if (prev == null) this.listen();
+		const fontChanged = prev == null || prev.font !== next.font || prev.lineHeight !== next.lineHeight;
+		const profileChanged = prev == null || prev.profile !== next.profile;
+		const colorsChanged = prev == null || prev.colors !== next.colors;
+		const lines = splitLines(next.value);
+		let dirty = 0;
+		if (!profileChanged) {
+			const max = Math.min(this.lines.length, lines.length);
+			while (dirty < max && this.lines[dirty] === lines[dirty]) dirty++;
+			if (dirty === max && this.lines.length === lines.length) dirty = lines.length;
+		}
+		this.lines = lines;
+		if (this.done > dirty) this.done = dirty;
+		this.widths.length = Math.min(this.widths.length, dirty);
+		if (fontChanged) {
+			this.metrics = null;
+			this.widths.length = 0;
+		}
+		this.layoutTiles();
+		const invalidateFrom = fontChanged || colorsChanged ? 0 : dirty;
+		for (const t of this.tiles) t.dirtyFrom = Math.min(t.dirtyFrom, Math.max(invalidateFrom, t.start));
+		if (colorsChanged) this.plainColor = null;
+		if (!this.revealed && this.lines.length - this.done > REVEAL_THRESHOLD) this.reveal();
+		if (this.lines.length === 0) this.reveal();
+		if (this.pending != null) {
+			clearTimeout(this.pending);
+			this.pending = null;
+		}
+		this.work(SYNC_BUDGET_MS);
+	}
+	destroy() {
+		if (this.pending != null) clearTimeout(this.pending);
+		this.pending = null;
+		this.io?.disconnect();
+		this.io = null;
+		for (const u of this.unlisten) u();
+		this.unlisten = [];
+		if (this.input != null) this.reveal();
+		for (const t of this.tiles) t.canvas.remove();
+		this.tiles = [];
+		this.scrollers = [];
+		this.input = null;
+	}
+	work(budget) {
+		const { profile } = this.input;
+		const t0 = performance.now();
+		while (this.done < this.lines.length) {
+			const i = this.done;
+			const st = i === 0 ? INITIAL_STATE : this.ends[i - 1];
+			const r = tokenizeLine(this.lines[i], st, profile);
+			this.tokens[i] = r.tokens;
+			this.ends[i] = r.end;
+			this.done++;
+			if ((this.done & 31) === 0 && performance.now() - t0 > budget) break;
+		}
+		this.syncVisibility();
+		if (this.done < this.lines.length) this.pending = setTimeout(() => {
+			this.pending = null;
+			this.work(CHUNK_BUDGET_MS);
+		}, 0);
+	}
+	/**
+	* Recompute which tiles are near the visible window, paint the dirty ones
+	* (tokens permitting), free the far ones, and conceal/reveal accordingly.
+	* Runs synchronously on scroll/resize, so a tile entering the window is
+	* painted before the browser paints that frame — never a blank flash.
+	*/
+	syncVisibility() {
+		const input = this.input;
+		if (input == null) return;
+		if (this.tiles.length > 0) {
+			const codeTop = input.codeEl.getBoundingClientRect().top;
+			let top = 0;
+			let bottom = window.innerHeight;
+			for (const sc of this.scrollers) {
+				const r = sc.getBoundingClientRect();
+				if (r.top > top) top = r.top;
+				if (r.bottom < bottom) bottom = r.bottom;
+			}
+			const margin = Math.max(400, bottom - top);
+			const { lineHeight } = input;
+			for (const t of this.tiles) {
+				const tileTop = codeTop + t.start * lineHeight;
+				const tileBottom = codeTop + this.tileEnd(t) * lineHeight;
+				if (tileBottom > top - margin && tileTop < bottom + margin) {
+					t.visible = true;
+					const end = this.tileEnd(t);
+					if (t.dirtyFrom < end && this.done >= end) this.paintTile(t);
+				} else {
+					t.visible = false;
+					if ((tileBottom < top - 2 * margin || tileTop > bottom + 2 * margin) && t.canvas.width !== 0) {
+						t.canvas.width = 0;
+						t.canvas.height = 0;
+						t.cssWidth = 0;
+						t.dirtyFrom = t.start;
+					}
+				}
+			}
+		}
+		this.maybeConceal();
+	}
+	/** Swap DOM glyphs for canvas glyphs, atomically within the current task. */
+	maybeConceal() {
+		if (!this.revealed || this.lines.length === 0) return;
+		if (this.done < this.lines.length) return;
+		for (const t of this.tiles) if (t.visible && t.dirtyFrom < this.tileEnd(t)) return;
+		const { codeEl, overlayEl } = this.input;
+		this.revealed = false;
+		codeEl.style.color = "transparent";
+		overlayEl.style.visibility = "visible";
+	}
+	reveal() {
+		if (this.revealed) return;
+		this.revealed = true;
+		const { codeEl, overlayEl } = this.input;
+		codeEl.style.color = "";
+		overlayEl.style.visibility = "hidden";
+	}
+	tileEnd(t) {
+		return Math.min(t.start + TILE_LINES, this.lines.length);
+	}
+	layoutTiles() {
+		const { overlayEl, lineHeight } = this.input;
+		const count = Math.ceil(this.lines.length / TILE_LINES);
+		while (this.tiles.length > count) {
+			const t = this.tiles.pop();
+			this.io?.unobserve(t.canvas);
+			t.canvas.remove();
+		}
+		while (this.tiles.length < count) {
+			const start = this.tiles.length * TILE_LINES;
+			const canvas = document.createElement("canvas");
+			canvas.width = 0;
+			canvas.height = 0;
+			Object.assign(canvas.style, {
+				position: "absolute",
+				left: "0px",
+				top: `${start * lineHeight}px`,
+				width: "0px",
+				height: "0px",
+				pointerEvents: "none"
+			});
+			overlayEl.appendChild(canvas);
+			const tile = {
+				canvas,
+				start,
+				dirtyFrom: start,
+				visible: false,
+				cssWidth: 0,
+				dpr: 0
+			};
+			this.tiles.push(tile);
+			this.io?.observe(canvas);
+		}
+		for (const t of this.tiles) t.canvas.style.top = `${t.start * lineHeight}px`;
+	}
+	ensureMetrics(ctx) {
+		if (this.metrics != null) return this.metrics;
+		const { font } = this.input;
+		ctx.font = font;
+		const probe = ctx.measureText("Mg");
+		const sizeMatch = /(\d+(?:\.\d+)?)px/.exec(font);
+		const size = sizeMatch != null ? parseFloat(sizeMatch[1]) : 16;
+		this.metrics = {
+			ascent: probe.fontBoundingBoxAscent ?? size * .8,
+			descent: probe.fontBoundingBoxDescent ?? size * .2,
+			tabAdvance: ctx.measureText(" ").width * 8
+		};
+		return this.metrics;
+	}
+	ensurePlainColor() {
+		if (this.plainColor != null) return this.plainColor;
+		const { codeEl } = this.input;
+		const inline = codeEl.style.color;
+		if (!this.revealed) codeEl.style.color = "";
+		this.plainColor = getComputedStyle(codeEl).color || "#888";
+		if (!this.revealed) codeEl.style.color = inline;
+		return this.plainColor;
+	}
+	/** Draw (or just measure, when `y` is null) `text` from `x`, honouring tabs. */
+	runText(ctx, text, x, tabAdvance, y) {
+		let from = 0;
+		for (;;) {
+			const t = text.indexOf("	", from);
+			const seg = t < 0 ? text.slice(from) : text.slice(from, t);
+			if (seg.length > 0) {
+				if (y != null) ctx.fillText(seg, x, y);
+				x += ctx.measureText(seg).width;
+			}
+			if (t < 0) return x;
+			x = (Math.floor(x / tabAdvance + 1e-6) + 1) * tabAdvance;
+			from = t + 1;
+		}
+	}
+	paintTile(t) {
+		const { lineHeight, font, colors } = this.input;
+		const mctx = measureCtx();
+		mctx.font = font;
+		const m = this.ensureMetrics(mctx);
+		const end = this.tileEnd(t);
+		let maxW = 0;
+		for (let i = t.start; i < end; i++) {
+			const w = this.widths[i] ??= this.runText(mctx, this.lines[i], 0, m.tabAdvance, null);
+			if (w > maxW) maxW = w;
+		}
+		const dpr = typeof devicePixelRatio === "number" && devicePixelRatio > 0 ? devicePixelRatio : 1;
+		const cssH = (end - t.start) * lineHeight;
+		let from = Math.max(t.dirtyFrom, t.start);
+		const needResize = t.dpr !== dpr || maxW > t.cssWidth || from <= t.start || Math.ceil(cssH * dpr) !== t.canvas.height;
+		if (needResize) {
+			from = t.start;
+			t.cssWidth = maxW;
+			t.dpr = dpr;
+			t.canvas.width = Math.ceil(maxW * dpr);
+			t.canvas.height = Math.ceil(cssH * dpr);
+			t.canvas.style.width = `${maxW}px`;
+			t.canvas.style.height = `${cssH}px`;
+		}
+		const ctx = t.canvas.getContext("2d");
+		if (ctx == null) {
+			t.dirtyFrom = end;
+			return;
+		}
+		ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+		ctx.font = font;
+		ctx.textBaseline = "alphabetic";
+		if (!needResize) {
+			const yTop = (from - t.start) * lineHeight;
+			ctx.clearRect(0, yTop, t.cssWidth + 1, cssH - yTop);
+		}
+		const plain = this.ensurePlainColor();
+		const half = (lineHeight - (m.ascent + m.descent)) / 2;
+		for (let i = from; i < end; i++) {
+			const y = (i - t.start) * lineHeight + half + m.ascent;
+			this.paintLine(ctx, this.lines[i], this.tokens[i], y, m.tabAdvance, colors, plain);
+		}
+		t.dirtyFrom = end;
+	}
+	paintLine(ctx, line, tokens, y, tabAdvance, colors, plain) {
+		let x = 0;
+		let pos = 0;
+		let fill = "";
+		const setFill = (c) => {
+			if (c !== fill) {
+				fill = c;
+				ctx.fillStyle = c;
+			}
+		};
+		for (let k = 0; k <= tokens.length; k++) {
+			const tok = k < tokens.length ? tokens[k] : null;
+			const gapEnd = tok != null ? tok.start : line.length;
+			if (gapEnd > pos) {
+				setFill(plain);
+				x = this.runText(ctx, line.slice(pos, gapEnd), x, tabAdvance, y);
+				pos = gapEnd;
+			}
+			if (tok == null) break;
+			const c = colors[tok.type];
+			setFill(c === "currentColor" || c === "inherit" ? plain : c);
+			x = this.runText(ctx, line.slice(tok.start, tok.end), x, tabAdvance, y);
+			pos = tok.end;
+		}
+	}
+	listen() {
+		const onSignal = () => this.syncVisibility();
+		const { codeEl } = this.input;
+		this.scrollers = [];
+		for (let el = codeEl.parentElement; el != null; el = el.parentElement) {
+			const s = getComputedStyle(el);
+			const o = `${s.overflowY} ${s.overflowX}`;
+			if (o.includes("auto") || o.includes("scroll") || o.includes("overlay")) {
+				this.scrollers.push(el);
+				el.addEventListener("scroll", onSignal, { passive: true });
+				const target = el;
+				this.unlisten.push(() => target.removeEventListener("scroll", onSignal));
+			}
+		}
+		window.addEventListener("scroll", onSignal, { passive: true });
+		window.addEventListener("resize", onSignal);
+		this.unlisten.push(() => {
+			window.removeEventListener("scroll", onSignal);
+			window.removeEventListener("resize", onSignal);
+		});
+		if (typeof IntersectionObserver !== "undefined") this.io = new IntersectionObserver(onSignal, { rootMargin: "50%" });
+		const fonts = typeof document !== "undefined" ? document.fonts : void 0;
+		if (fonts != null && typeof fonts.addEventListener === "function") {
+			const onFonts = () => {
+				this.metrics = null;
+				this.widths.length = 0;
+				for (const t of this.tiles) {
+					t.dirtyFrom = t.start;
+					t.dpr = 0;
+				}
+				this.syncVisibility();
+			};
+			fonts.addEventListener("loadingdone", onFonts);
+			this.unlisten.push(() => fonts.removeEventListener("loadingdone", onFonts));
+		}
+		this.watchDpr();
+	}
+	watchDpr() {
+		if (typeof matchMedia !== "function" || typeof devicePixelRatio !== "number") return;
+		const mq = matchMedia(`(resolution: ${devicePixelRatio}dppx)`);
+		if (typeof mq.addEventListener !== "function") return;
+		const onChange = () => {
+			stop();
+			this.unlisten = this.unlisten.filter((u) => u !== stop);
+			for (const t of this.tiles) t.dirtyFrom = t.start;
+			this.syncVisibility();
+			this.watchDpr();
+		};
+		const stop = () => mq.removeEventListener("change", onChange);
+		mq.addEventListener("change", onChange);
+		this.unlisten.push(stop);
+	}
+};
+//#endregion
+//#region src/primitives/code-block.tsx
+function lineCount(value) {
+	if (value.length === 0) return 0;
+	let lines = 1;
+	for (let i = 0; i < value.length; i++) if (value.charCodeAt(i) === 10) lines++;
+	if (value.charCodeAt(value.length - 1) === 10) lines--;
+	return Math.max(1, lines);
+}
+function measureCodeBlock(props, ctx) {
+	assertMeasurableFont(props.font);
+	const pad = props.padding ?? 0;
+	return lineCount(props.value) * props.lineHeight + 2 * pad;
+}
+const colorsCache = /* @__PURE__ */ new WeakMap();
+function resolveTokenColors(overrides) {
+	if (overrides == null) return defaultTokenColors;
+	let full = colorsCache.get(overrides);
+	if (full === void 0) {
+		full = {
+			...defaultTokenColors,
+			...overrides
+		};
+		colorsCache.set(overrides, full);
+	}
+	return full;
+}
+const useIsoLayoutEffect = typeof window === "undefined" ? useEffect : useLayoutEffect;
+function HighlightedCode(props) {
+	const codeRef = useRef(null);
+	const overlayRef = useRef(null);
+	const sessionRef = useRef(null);
+	const { value, font, lineHeight, profile, colors } = props;
+	useIsoLayoutEffect(() => {
+		const codeEl = codeRef.current;
+		const overlayEl = overlayRef.current;
+		if (codeEl == null || overlayEl == null) return;
+		(sessionRef.current ??= new HighlightSession()).update({
+			codeEl,
+			overlayEl,
+			value,
+			font,
+			lineHeight,
+			profile,
+			colors
+		});
+	}, [
+		value,
+		font,
+		lineHeight,
+		profile,
+		colors
+	]);
+	useEffect(() => () => {
+		sessionRef.current?.destroy();
+		sessionRef.current = null;
+	}, []);
+	const overlayStyle = {
+		position: "absolute",
+		top: `${props.padding}px`,
+		left: `${props.padding}px`,
+		width: 0,
+		height: 0,
+		visibility: "hidden",
+		pointerEvents: "none"
+	};
+	return createElement(Fragment, null, createElement("code", {
+		ref: codeRef,
+		style: props.codeStyle,
+		...props.lang != null ? { "data-lang": props.lang } : null
+	}, props.value), createElement("div", {
+		ref: overlayRef,
+		"aria-hidden": true,
+		style: overlayStyle
+	}));
+}
+function renderCodeBlock(props) {
+	const pad = props.padding ?? 0;
+	const profile = props.highlight === false ? null : profileFor(props.lang);
+	const preStyle = {
+		margin: 0,
+		padding: `${pad}px`,
+		overflowX: "auto",
+		font: fontWithLineHeight(props.font, props.lineHeight),
+		boxSizing: "border-box",
+		...props.background != null ? { background: props.background } : null,
+		...props.color != null ? { color: props.color } : null,
+		...props.radius != null ? { borderRadius: `${props.radius}px` } : null,
+		...profile != null ? {
+			position: "relative",
+			tabSize: 8
+		} : null,
+		...props.style
+	};
+	const codeStyle = {
+		font: "inherit",
+		whiteSpace: "pre",
+		margin: 0,
+		padding: 0
+	};
+	if (profile == null) return createElement("pre", {
+		className: props.className,
+		style: preStyle
+	}, createElement("code", {
+		style: codeStyle,
+		...props.lang ? { "data-lang": props.lang } : null
+	}, props.value));
+	return createElement("pre", {
+		className: props.className,
+		style: preStyle
+	}, createElement(HighlightedCode, {
+		value: props.value,
+		lang: props.lang,
+		font: props.font,
+		lineHeight: props.lineHeight,
+		padding: pad,
+		profile,
+		colors: resolveTokenColors(props.highlight === false ? void 0 : props.highlight),
+		codeStyle
+	}));
+}
+/** A measurable fenced-code primitive (no wrapping; height from line count). */
+const CodeBlock = markPrimitive(renderCodeBlock, {
+	name: "CodeBlock",
+	measure: (props, ctx) => measureCodeBlock(props, ctx)
+});
+//#endregion
+//#region src/primitives/table-block.tsx
+/**
+* Floor for a column's content share, so a short column ("1k") beside a prose
+* column keeps a readable width instead of wrapping per character.
+*/
+const MIN_COLUMN_CONTENT = 48;
+const STUB_CTX = {
+	defaults: {},
+	width: 0,
+	measure: () => 0
+};
+function columnCount(rows) {
+	let n = 0;
+	for (const row of rows) n = Math.max(n, row.length);
+	return n;
+}
+/**
+* Per-column flex ratios: max-content width of the column (plus padding), or
+* `null` when some cell's natural width is unknowable (→ equal columns).
+*/
+function columnRatios(p, ctx) {
+	const cols = columnCount(p.rows);
+	const ratios = new Array(cols).fill(MIN_COLUMN_CONTENT);
+	for (const row of p.rows) for (let c = 0; c < row.length; c++) {
+		const cell = row[c];
+		if (cell == null) continue;
+		let w;
+		try {
+			w = naturalWidthOf(cell, ctx);
+		} catch {
+			return null;
+		}
+		if (w == null) return null;
+		if (w > ratios[c]) ratios[c] = w;
+	}
+	return ratios.map((r) => r + 2 * p.cellPadding);
+}
+function ratiosOrEqual(p, ctx) {
+	return columnRatios(p, ctx) ?? new Array(columnCount(p.rows)).fill(1);
+}
+function measureTable(p, ctx) {
+	const rows = p.rows;
+	const cols = columnCount(rows);
+	if (rows.length === 0 || cols === 0) return 0;
+	const ratios = ratiosOrEqual(p, ctx);
+	const total = ratios.reduce((a, b) => a + b, 0);
+	let height = (rows.length - 1) * p.divider;
+	for (const row of rows) {
+		let rowH = 2 * p.cellPadding;
+		for (let c = 0; c < cols; c++) {
+			const cell = row[c];
+			if (cell == null) continue;
+			const colW = total > 0 ? ctx.width * ratios[c] / total : 0;
+			const inner = Math.max(0, colW - 2 * p.cellPadding);
+			rowH = Math.max(rowH, ctx.measure(cell, inner) + 2 * p.cellPadding);
+		}
+		height += rowH;
+	}
+	return height;
+}
+function renderTableBlock(p) {
+	const cols = columnCount(p.rows);
+	const ratios = ratiosOrEqual(p, STUB_CTX);
+	const outer = {
+		display: "flex",
+		flexDirection: "column",
+		margin: 0,
+		...p.radius > 0 ? {
+			borderRadius: `${p.radius}px`,
+			overflow: "hidden"
+		} : null,
+		...p.divider > 0 ? { boxShadow: `inset 0 0 0 ${p.divider}px ${p.borderColor}` } : null,
+		...p.style
+	};
+	const children = [];
+	p.rows.forEach((row, r) => {
+		if (r > 0 && p.divider > 0) children.push(createElement("div", {
+			key: `d${r}`,
+			style: {
+				height: `${p.divider}px`,
+				background: p.borderColor,
+				flex: "none"
+			}
+		}));
+		children.push(createElement("div", {
+			key: r,
+			style: {
+				display: "flex",
+				...r === 0 ? { background: p.headerBackground } : null
+			}
+		}, Array.from({ length: cols }, (_, c) => createElement("div", {
+			key: c,
+			style: {
+				flex: `${ratios[c]} ${ratios[c]} 0px`,
+				minWidth: 0,
+				boxSizing: "border-box",
+				padding: `${p.cellPadding}px`
+			}
+		}, row[c] ?? null))));
+	});
+	return createElement("div", {
+		className: p.className,
+		style: outer
+	}, children);
+}
+/** A measurable GFM-table primitive with aligned, content-proportional columns. */
+const TableBlock = markPrimitive(renderTableBlock, {
+	name: "TableBlock",
+	measure: (props, ctx) => measureTable(props, ctx),
+	naturalWidth: (props, ctx) => {
+		const ratios = columnRatios(props, ctx);
+		if (ratios == null) return null;
+		return ratios.reduce((a, b) => a + b, 0);
+	}
+});
+//#endregion
+//#region src/components.tsx
+/** A `<blockquote>`-backed vertical box, so the default quote is semantic. */
+const Blockquote = definePrimitive$1("blockquote", { name: "Blockquote" });
+function bodyFont(theme) {
+	return `${theme.fontSize}px ${theme.fontFamily}`;
+}
+function renderList(node, ctx) {
+	const theme = ctx.theme;
+	const ordered = node.ordered === true;
+	const start = node.start ?? 1;
+	const font = bodyFont(theme);
+	const markerColor = theme.list.markerColor !== "inherit" ? theme.list.markerColor : void 0;
+	const items = node.children.map((item, i) => {
+		const markerText = item.checked != null ? item.checked ? "☑" : "☐" : ordered ? `${start + i}.` : "•";
+		return ctx.memo(item, `li:${i}:${markerText}`, () => {
+			const content = ctx.renderBlocks(item.children, theme.list.gap);
+			const markerRun = {
+				text: markerText,
+				font
+			};
+			if (markerColor != null) markerRun.color = markerColor;
+			const marker = createElement(RichText, {
+				runs: [markerRun],
+				font,
+				lineHeight: theme.lineHeight
+			});
+			return createElement(HStack$1, {
+				key: i,
+				align: "flex-start"
+			}, createElement(VStack$1, { width: theme.list.indent }, marker), createElement(VStack$1, {}, content));
+		});
+	});
+	return createElement(VStack$1, { gap: theme.list.gap }, items);
+}
+function renderTable(node, ctx) {
+	const theme = ctx.theme;
+	const align = node.align ?? [];
+	return createElement(TableBlock, {
+		rows: node.children.map((row, ri) => row.children.map((cell, ci) => ctx.memo(cell, `td:${ri}:${ci}:${ri === 0 ? "h" : ""}:${align[ci] ?? ""}`, () => ctx.inlineText(cell.children, {
+			lineHeight: theme.lineHeight,
+			weight: ri === 0 ? theme.table.headerWeight : void 0,
+			align: align[ci] ?? void 0
+		})))),
+		cellPadding: theme.table.cellPadding,
+		divider: theme.table.gap,
+		borderColor: theme.table.borderColor,
+		headerBackground: theme.table.headerBackground,
+		radius: theme.table.radius
+	});
+}
+function renderImage(node, ctx) {
+	const theme = ctx.theme;
+	if (theme.image.placeholderHeight > 0) return createElement(VStack$1, { height: theme.image.placeholderHeight });
+	const font = bodyFont(theme);
+	return createElement(RichText, {
+		runs: [{
+			text: `\u{1F5BC} ${node.alt || node.title || node.url}`,
+			font,
+			color: theme.image.color
+		}],
+		font,
+		lineHeight: theme.lineHeight,
+		color: theme.image.color
+	});
+}
+const defaultComponents = {
+	paragraph: ({ children }) => children,
+	heading: ({ children }) => children,
+	blockquote: ({ children, ctx }) => {
+		const bq = ctx.theme.blockquote;
+		return createElement(Blockquote, {
+			padding: bq.padding,
+			style: {
+				boxShadow: `inset ${bq.borderWidth}px 0 0 ${bq.borderColor}`,
+				...bq.color !== "inherit" ? { color: bq.color } : null
+			}
+		}, children);
+	},
+	code: ({ node, ctx }) => {
+		const c = ctx.theme.code;
+		const font = `${c.fontSize}px ${ctx.theme.monoFamily}`;
+		return createElement(CodeBlock, {
+			value: node.value,
+			...node.lang ? { lang: node.lang } : null,
+			font,
+			lineHeight: c.lineHeight,
+			padding: c.padding,
+			background: c.background,
+			radius: c.radius,
+			highlight: c.highlight,
+			...c.color !== "inherit" ? { color: c.color } : null
+		});
+	},
+	list: ({ node, ctx }) => renderList(node, ctx),
+	table: ({ node, ctx }) => renderTable(node, ctx),
+	image: ({ node, ctx }) => renderImage(node, ctx),
+	thematicBreak: ({ ctx }) => {
+		const r = ctx.theme.rule;
+		return createElement(VStack$1, { padding: r.gap }, createElement(VStack$1, {
+			height: r.thickness,
+			style: { background: r.color }
+		}));
+	},
+	html: () => null
+};
+const mergeCache = /* @__PURE__ */ new WeakMap();
+/** Merge a partial component set over the defaults. */
+function mergeComponents(components) {
+	if (components == null) return defaultComponents;
+	const cached = mergeCache.get(components);
+	if (cached !== void 0) return cached;
+	const merged = {
+		...defaultComponents,
+		...components
+	};
+	mergeCache.set(components, merged);
+	return merged;
+}
+//#endregion
+//#region src/render.tsx
+/** The default inner rendering for a node — inline `RichText` or rendered child blocks. */
+function renderChildren(node, ctx) {
+	const theme = ctx.theme;
+	switch (node.type) {
+		case "paragraph": return ctx.inlineText(node.children, { lineHeight: theme.lineHeight });
+		case "heading": {
+			const d = node.depth;
+			return ctx.inlineText(node.children, {
+				size: theme.heading.sizes[d],
+				weight: theme.heading.weight,
+				lineHeight: theme.heading.lineHeights[d],
+				...theme.heading.color !== "inherit" ? { color: theme.heading.color } : null
+			});
+		}
+		case "blockquote": return ctx.renderBlocks(node.children, theme.blockquote.gap);
+		default: return null;
+	}
+}
+const blockCache = /* @__PURE__ */ new WeakMap();
+const MAX_CONTENT_CACHE = 4096;
+const contentCache = /* @__PURE__ */ new Map();
+let optIdSeq = 0;
+const optId = /* @__PURE__ */ new WeakMap();
+function idOf(o) {
+	let id = optId.get(o);
+	if (id === void 0) {
+		id = ++optIdSeq;
+		optId.set(o, id);
+	}
+	return id;
+}
+/** Structural signature of a node — content + shape, position-independent. */
+function blockSig(node) {
+	return JSON.stringify(node, (k, v) => k === "position" ? void 0 : v);
+}
+/**
+* Memoize an element by its node's content. `variant` distinguishes renderings
+* of the same node that differ by sibling context (a list item's index/marker, a
+* table cell's column). First tries the node-reference cache (completed blocks
+* outside the re-parsed tail), then the content signature (unchanged sub-blocks
+* inside the streaming block), and only then runs `build`.
+*/
+function memoElement(node, ctx, variant, build) {
+	const byRef = blockCache.get(node);
+	if (byRef !== void 0 && byRef.theme === ctx.theme && byRef.components === ctx.components && byRef.variant === variant) return byRef.el;
+	const sigKey = `${idOf(ctx.theme)}:${idOf(ctx.components)}:${variant}:${blockSig(node)}`;
+	const byContent = contentCache.get(sigKey);
+	if (byContent !== void 0) {
+		contentCache.delete(sigKey);
+		contentCache.set(sigKey, byContent);
+		blockCache.set(node, {
+			el: byContent,
+			theme: ctx.theme,
+			components: ctx.components,
+			variant
+		});
+		return byContent;
+	}
+	const el = build();
+	blockCache.set(node, {
+		el,
+		theme: ctx.theme,
+		components: ctx.components,
+		variant
+	});
+	if (contentCache.size >= MAX_CONTENT_CACHE) {
+		const oldest = contentCache.keys().next().value;
+		if (oldest !== void 0) contentCache.delete(oldest);
+	}
+	contentCache.set(sigKey, el);
+	return el;
+}
+function memoDispatch(node, ctx, key) {
+	return memoElement(node, ctx, `b:${key}`, () => dispatch(node, ctx, key));
+}
+function dispatch(node, ctx, key) {
+	if (node.type === "paragraph" && node.children.length === 1 && node.children[0]?.type === "image") {
+		const image = node.children[0];
+		return createElement(ctx.components.image, {
+			key,
+			node: image,
+			ctx,
+			children: null
+		});
+	}
+	const Comp = ctx.components[node.type];
+	if (Comp == null) return null;
+	return createElement(Comp, {
+		key,
+		node,
+		ctx,
+		children: renderChildren(node, ctx)
+	});
+}
+function createContext(theme, components) {
+	const ctx = {
+		theme,
+		components,
+		renderBlocks(nodes, gap = theme.blockGap) {
+			const kids = [];
+			for (let i = 0; i < nodes.length; i++) {
+				const el = ctx.renderBlock(nodes[i], i);
+				if (el != null) kids.push(el);
+			}
+			if (kids.length === 0) return null;
+			return createElement(VStack$1, { gap }, kids);
+		},
+		renderBlock(node, key) {
+			return memoDispatch(node, ctx, key);
+		},
+		memo(node, variant, build) {
+			return memoElement(node, ctx, variant, build);
+		},
+		renderChildren(node) {
+			return renderChildren(node, ctx);
+		},
+		inlineRuns(nodes, base) {
+			const fmt = {
+				...baseFormat(theme),
+				...base
+			};
+			const out = [];
+			flattenInline(nodes, fmt, theme, out);
+			return out;
+		},
+		inlineText(nodes, opts = {}) {
+			const fmt = baseFormat(theme, {
+				...opts.size != null ? { size: opts.size } : null,
+				...opts.weight != null ? { weight: opts.weight } : null,
+				...opts.color != null ? { color: opts.color } : null
+			});
+			const out = [];
+			flattenInline(nodes, fmt, theme, out);
+			return createElement(RichText, {
+				runs: out,
+				font: composeFont(fmt),
+				lineHeight: opts.lineHeight ?? theme.lineHeight,
+				...opts.color != null ? { color: opts.color } : null,
+				...opts.align != null ? { align: opts.align } : null
+			});
+		}
+	};
+	return ctx;
+}
+/**
+* Parse `source` and render it into a tree of mugen primitives. The result is
+* pure and hook-free, so it can be returned straight from a `<MugenVList>`
+* `render` and measured by the walker. Memoization of parsing/theme/components
+* keeps the measure and render passes cheap.
+*/
+function renderMarkdown(source, options = {}) {
+	const ast = parseMarkdown(source, options.parserOptions);
+	return createContext(resolveTheme(options.theme), mergeComponents(options.components)).renderBlocks(ast.children);
+}
+//#endregion
+//#region src/markdown.tsx
+/**
+* Render markdown as a tree of mugen primitives.
+*
+* `<Markdown>` is a **pure, hook-free** component: it parses `source` with
+* incremark and maps the AST to mugen primitives, producing the identical tree
+* in mugen's measure walk and in React's render. Drop it straight into a
+* `<MugenVList>` `render` and every row — on- or off-screen — gets an exact,
+* analytic height.
+*
+* ```tsx
+* <MugenVList
+*   instance={list}
+*   getKey={(m) => m.id}
+*   render={(m) => <Markdown source={m.body} />}
+* />
+* ```
+*
+* Extend it with typed, per-node `components` (built from the same primitives)
+* and a deep-partial `theme`.
+*/
+function Markdown(props) {
+	return renderMarkdown(props.source, props);
+}
+Markdown.displayName = "Markdown";
+//#endregion
+//#region src/types.ts
+/**
+* Identity helper for authoring a typed component set with full inference and
+* `node` narrowing per key:
+*
+* ```tsx
+* const components = defineMarkdownComponents({
+*   heading: ({ node, children }) => // node is Heading, node.depth is 1..6
+*     <VStack>{children}</VStack>,
+* });
+* ```
+*/
+function defineMarkdownComponents(components) {
+	return components;
+}
+//#endregion
+export { CodeBlock, HStack, Markdown, RichText, TableBlock, Text, VStack, baseFormat, clearParseCache, clearRichTextCache, composeFont, defaultComponents, defaultTheme, defaultTokenColors, defineMarkdownComponents, definePrimitive, flattenInline, parseMarkdown, profileFor, registerLanguage, renderMarkdown, resolveTheme };