vde-open 0.1.4 → 0.1.6

package/dist/print-CR5-GDjQ.js

@@ -0,0 +1,1779 @@
+import { D as escapeAttr, E as parseMarkdown, O as escapeHtml$2, k as footnoteReferenceId, n as renderedLinkOf, p as parseMarkdownDocument, r as MARKDOWN_PARSE_OPTIONS, t as localImagePath } from "./rendering-rules-DiE2jI7I.js";
+//#region ../../node_modules/.pnpm/@tanstack+markdown@1.0.0_react@19.3.0/node_modules/@tanstack/markdown/dist/html.js
+function renderHtml(input, options = {}) {
+	return (typeof input === "string" ? parseMarkdown(input, options) : input).children.map((node) => renderBlock(node, options)).join("\n");
+}
+function renderBlock(node, options = {}) {
+	const extension = renderExtension(node, options);
+	if (extension !== void 0) return extension;
+	switch (node.type) {
+		case "heading": {
+			const id = node.id ? ` id="${escapeAttr(node.id)}"` : "";
+			const framework = node.framework ? ` data-framework="${escapeAttr(node.framework)}"` : "";
+			return `<h${node.depth}${id}${framework}>${renderInlines(node.children, options)}${renderHeadingAnchor(node.id, options)}</h${node.depth}>`;
+		}
+		case "paragraph": return `<p>${renderInlines(node.children, options)}</p>`;
+		case "code": return renderCodeBlock(node, options);
+		case "list": {
+			const tag = node.ordered ? "ol" : "ul";
+			return `<${tag}${node.ordered && node.start !== void 0 && node.start !== 1 ? ` start="${node.start}"` : ""}>\n${node.items.map((item) => `<li>${renderListItemChildren(item.children, item.checked, node.loose, options)}</li>`).join("\n")}\n</${tag}>`;
+		}
+		case "blockquote": return `<blockquote>\n${node.children.map((child) => renderBlock(child, options)).join("\n")}\n</blockquote>`;
+		case "table": return `<table>${`<thead><tr>${node.header.map((cell, index) => renderTableCell("th", cell, node.align[index], options)).join("")}</tr></thead>`}${node.rows.length ? `<tbody>${node.rows.map((row) => `<tr>${row.map((cell, index) => renderTableCell("td", cell, node.align[index], options)).join("")}</tr>`).join("")}</tbody>` : ""}</table>`;
+		case "footnotes": return renderFootnotes(node.items, options);
+		case "thematicBreak": return "<hr>";
+		case "html": return options.allowHtml ? node.value : escapeHtml$2(node.value);
+		case "callout": return renderCallout(node, options);
+		case "component": return renderComponent(node, options);
+	}
+}
+function renderInline(node, options = {}) {
+	const extension = renderExtension(node, options);
+	if (extension !== void 0) return extension;
+	switch (node.type) {
+		case "text": return escapeHtml$2(node.value);
+		case "inlineCode": return `<code>${escapeHtml$2(node.value)}</code>`;
+		case "strong": return `<strong>${renderInlines(node.children, options)}</strong>`;
+		case "emphasis": return `<em>${renderInlines(node.children, options)}</em>`;
+		case "strike": return `<del>${renderInlines(node.children, options)}</del>`;
+		case "footnoteReference": return `<sup><a id="user-content-fnref-${escapeAttr(footnoteReferenceId(node.id, node.referenceIndex))}" data-footnote-ref="" aria-describedby="footnote-label" href="#user-content-fn-${escapeAttr(node.id)}">${node.number}</a></sup>`;
+		case "link": return `<a href="${escapeAttr(node.href)}"${node.title ? ` title="${escapeAttr(node.title)}"` : ""}>${renderInlines(node.children, options)}</a>`;
+		case "image": return `<img src="${escapeAttr(node.src)}" alt="${escapeAttr(node.alt)}"${node.title ? ` title="${escapeAttr(node.title)}"` : ""}>`;
+		case "break": return "<br>";
+		case "inlineHtml": return options.allowHtml ? node.value : escapeHtml$2(node.value);
+		case "inlineComponent": return renderComponent(node, options);
+	}
+}
+function renderDocument(document, options = {}) {
+	return renderHtml(document, options);
+}
+function renderInlines(nodes, options) {
+	return nodes.map((node) => renderInline(node, options)).join("");
+}
+function renderCodeBlock(node, options) {
+	const lang = node.lang ?? "plaintext";
+	const preAttrs = `class="tm-code${options.codeLineNumbers ? " tm-code--line-numbers" : ""}" data-lang="${escapeAttr(lang)}"` + (node.meta ? ` data-meta="${escapeAttr(node.meta)}"` : "") + (node.title ? ` data-code-title="${escapeAttr(node.title)}"` : "") + (node.file ? ` data-filename="${escapeAttr(node.file)}"` : "") + (node.framework ? ` data-framework="${escapeAttr(node.framework)}"` : "");
+	const html = options.highlighter?.(node.value, lang, {
+		...node.meta && { meta: node.meta },
+		...node.highlightLines && { highlightLines: node.highlightLines },
+		...options.codeLineNumbers !== void 0 && { lineNumbers: options.codeLineNumbers }
+	}) ?? escapeHtml$2(node.value);
+	const pre = `<pre ${preAttrs}><code class="language-${escapeAttr(lang)}">${html}</code></pre>`;
+	if (!node.title) return pre;
+	return `<figure class="tm-code-frame" data-lang="${escapeAttr(lang)}"><figcaption>${escapeHtml$2(node.title)}</figcaption>${pre}</figure>`;
+}
+function renderListItemChildren(children, checked, loose, options) {
+	let result = checked === void 0 ? "" : `<input type="checkbox" disabled${checked ? " checked" : ""}> `;
+	for (let index = 0; index < children.length; index++) {
+		const child = children[index];
+		if (child.type === "paragraph" && (!loose || index === 0)) {
+			result += renderInlines(child.children, options);
+			if (loose) result = `<p>${result}</p>`;
+		} else result += (index ? "\n" : "") + renderBlock(child, options);
+	}
+	return result;
+}
+function renderCallout(node, options) {
+	const kind = node.kind.toLowerCase();
+	const children = node.children.map((child) => renderBlock(child, options)).join("\n");
+	return `<div class="markdown-alert markdown-alert-${escapeAttr(kind)}"><p class="markdown-alert-title">${escapeHtml$2(node.title)}</p><div class="markdown-alert-content">${children}</div></div>`;
+}
+function renderFootnotes(items, options) {
+	const renderedItems = items.map((item) => `<li id="user-content-fn-${escapeAttr(item.id)}">\n${renderFootnoteItem(item, options)}\n</li>`).join("\n");
+	return `<section data-footnotes="" class="footnotes"><h2 id="footnote-label" class="sr-only">Footnotes${renderHeadingAnchor("footnote-label", options)}</h2>\n<ol>\n${renderedItems}\n</ol>\n</section>`;
+}
+function renderFootnoteItem(item, options) {
+	const backref = renderFootnoteBackrefs(item);
+	const lastIndex = item.children.length - 1;
+	const result = item.children.map((child, index) => {
+		if (index === lastIndex && child.type === "paragraph") return `<p>${renderInlines(child.children, options)}${backref}</p>`;
+		return renderBlock(child, options);
+	});
+	if (item.children[lastIndex]?.type !== "paragraph") result.push(`<p>${backref.trimStart()}</p>`);
+	return result.join("\n");
+}
+function renderFootnoteBackrefs(item) {
+	let result = "";
+	for (let index = 1; index <= (item.referenceCount ?? 1); index++) {
+		const referenceId = footnoteReferenceId(item.id, index);
+		const label = index === 1 ? `${item.number}` : `${item.number}-${index}`;
+		result += ` <a data-footnote-backref="" aria-label="Back to reference ${label}" class="data-footnote-backref" href="#user-content-fnref-${escapeAttr(referenceId)}">&#8617;</a>`;
+	}
+	return result;
+}
+function renderComponent(node, options) {
+	const tag = node.tagName ?? (node.type === "inlineComponent" ? "span" : "md-comment-component");
+	return `<${tag}${renderComponentAttrs(node)}>${node.type === "inlineComponent" ? renderInlines(node.children, options) : node.children.map((child) => renderBlock(child, options)).join("\n")}</${tag}>`;
+}
+function renderTableCell(tag, cell, align, options) {
+	return `<${tag}${align ? ` style="text-align:${align}"` : ""}>${renderInlines(cell.children, options)}</${tag}>`;
+}
+function renderExtension(node, options) {
+	for (const extension of options.extensions ?? []) {
+		const rendered = extension.renderHtml?.(node, {
+			options,
+			renderBlock: (block) => renderBlock(block, options),
+			renderInline: (inline) => renderInline(inline, options)
+		});
+		if (rendered !== void 0) return rendered;
+	}
+}
+function renderHeadingAnchor(id, options) {
+	const headingAnchors = options.headingAnchors;
+	if (!id || !headingAnchors) return "";
+	const anchorOptions = typeof headingAnchors === "object" ? headingAnchors : {};
+	return `<a href="#${escapeAttr(id)}" aria-hidden="${anchorOptions.ariaHidden ?? true}" class="${escapeAttr(anchorOptions.className ?? "anchor-heading anchor-heading-link")}" tabindex="${anchorOptions.tabIndex ?? -1}">${escapeHtml$2(anchorOptions.content ?? "#")}</a>`;
+}
+function renderComponentAttrs(node) {
+	const props = { ...node.properties };
+	if (!node.tagName) {
+		props["data-component"] = node.name;
+		if (!props["data-attributes"]) props["data-attributes"] = JSON.stringify(node.attributes);
+	}
+	return Object.entries(props).map(([key, value]) => ` ${key}="${escapeAttr(value)}"`).join("");
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/core.js
+function defineLanguage(definition) {
+	return definition;
+}
+function createHighlighter({ fallbackLanguage = "plaintext", languages }) {
+	const definitions = /* @__PURE__ */ new Map();
+	const aliases = /* @__PURE__ */ new Map();
+	for (const definition of languages) {
+		const name = normalizeName(definition.name);
+		definitions.set(name, definition);
+		aliases.set(name, name);
+		for (const alias of definition.aliases || []) aliases.set(normalizeName(alias), name);
+	}
+	const fallback = normalizeName(fallbackLanguage);
+	function normalizeLanguage(lang) {
+		return aliases.get(normalizeName(lang || fallback)) || fallback;
+	}
+	function tokenizeRanges(code, lang, depth = 0) {
+		const definition = definitions.get(normalizeLanguage(lang));
+		if (!definition || depth > 24) return [];
+		return normalizeTokenRanges(code.length, definition.tokenize(code, {
+			hasLanguage(candidate) {
+				const resolved = aliases.get(normalizeName(candidate));
+				return Boolean(resolved && definitions.has(resolved));
+			},
+			tokenize(embeddedCode, embeddedLanguage) {
+				return tokenizeRanges(embeddedCode, embeddedLanguage, depth + 1);
+			}
+		}));
+	}
+	function tokenize(code, options = {}) {
+		const lang = normalizeLanguage(options.lang);
+		const ranges = tokenizeRanges(code, lang);
+		return {
+			code,
+			lang,
+			tokens: ranges.length ? rangesToTokens(code, ranges) : [{ value: code }]
+		};
+	}
+	function highlight(code, options = {}) {
+		const result = tokenize(code, options);
+		const innerHtml = renderNodesToHtml(renderTokens(result.tokens, options));
+		return {
+			...result,
+			html: `<pre class="th-code th-code--${escapeHtml$1(result.lang)}${options.lineNumbers ? " th-code--line-numbers" : ""}" data-language="${escapeHtml$1(result.lang)}"><code>${innerHtml}</code></pre>`
+		};
+	}
+	function renderCodeBlockData({ code, decorations, lang, lineNumbers, title }) {
+		const copyText = code.trimEnd();
+		const result = highlight(copyText, {
+			decorations,
+			lang,
+			lineNumbers
+		});
+		return {
+			copyText,
+			htmlMarkup: result.html,
+			lang: result.lang,
+			title,
+			tokens: result.tokens
+		};
+	}
+	return {
+		highlight,
+		highlightToHtml(code, options = {}) {
+			return highlight(code, options).html;
+		},
+		listLanguages() {
+			return [...definitions.keys()];
+		},
+		normalizeLanguage,
+		renderCodeBlockData,
+		tokenize
+	};
+}
+function renderTokens(tokens, options = {}) {
+	const rangeDecorations = [];
+	const lineDecorations = [];
+	for (const decoration of options.decorations || []) if (decoration.range) rangeDecorations.push(decoration);
+	else lineDecorations.push(decoration);
+	const wrapLines = Boolean(options.lineNumbers || lineDecorations.length);
+	const cursor = {
+		index: 0,
+		offset: 0
+	};
+	if (!wrapLines) return renderTokenSlice(tokens, 0, Infinity, rangeDecorations, cursor);
+	const code = tokens.map((token) => token.value).join("");
+	const nodes = [];
+	const lineStarts = getLineStarts(code);
+	for (let index = 0; index < lineStarts.length; index++) {
+		const line = index + 1;
+		const start = lineStarts[index];
+		const nextStart = lineStarts[index + 1] ?? code.length;
+		const hasNewline = nextStart > start && code[nextStart - 1] === "\n";
+		const end = hasNewline ? nextStart - 1 : nextStart;
+		const active = lineDecorations.filter((decoration) => includesLine(decoration.lines, line));
+		nodes.push({
+			type: "element",
+			classNames: ["th-line", ...active.flatMap((decoration) => splitClassNames(decoration.className))],
+			data: {
+				...mergeData(active),
+				line: String(line)
+			},
+			children: renderTokenSlice(tokens, start, end, rangeDecorations, cursor)
+		});
+		if (hasNewline) nodes.push({
+			type: "text",
+			value: "\n"
+		});
+	}
+	return nodes;
+}
+function renderNodesToHtml(nodes) {
+	let html = "";
+	for (const node of nodes) {
+		if (node.type === "text") {
+			html += escapeHtml$1(node.value);
+			continue;
+		}
+		const className = escapeHtml$1(node.classNames.join(" "));
+		let data = "";
+		if (node.data) for (const [key, value] of Object.entries(node.data)) data += ` data-${normalizeDataKey(key)}="${escapeHtml$1(value)}"`;
+		html += `<span${className ? ` class="${className}"` : ""}${data}>${renderNodesToHtml(node.children)}</span>`;
+	}
+	return html;
+}
+const htmlEscapes = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+function escapeHtml$1(value) {
+	return value.replace(/[&<>"']/g, (character) => htmlEscapes[character]);
+}
+function normalizeName(value) {
+	return value.trim().toLowerCase();
+}
+function normalizeTokenRanges(codeLength, input) {
+	const ranges = [];
+	let sorted = true;
+	let previousStart = 0;
+	for (const candidate of input) {
+		if (!Number.isInteger(candidate.start) || !Number.isInteger(candidate.end)) continue;
+		const start = Math.max(0, Math.min(codeLength, candidate.start));
+		const end = Math.max(0, Math.min(codeLength, candidate.end));
+		if (start >= end) continue;
+		if (start < previousStart) sorted = false;
+		previousStart = start;
+		ranges.push({
+			className: candidate.className,
+			start,
+			end
+		});
+	}
+	if (!sorted) ranges.sort((a, b) => a.start - b.start);
+	let end = 0;
+	let count = 0;
+	for (const candidate of ranges) {
+		if (candidate.start < end) continue;
+		ranges[count++] = candidate;
+		end = candidate.end;
+	}
+	ranges.length = count;
+	return ranges;
+}
+function rangesToTokens(code, ranges) {
+	const tokens = [];
+	let index = 0;
+	for (const range of ranges) {
+		if (range.start > index) tokens.push({ value: code.slice(index, range.start) });
+		tokens.push({
+			className: range.className,
+			value: code.slice(range.start, range.end)
+		});
+		index = range.end;
+	}
+	if (index < code.length) tokens.push({ value: code.slice(index) });
+	return tokens;
+}
+function renderTokenSlice(tokens, start, end, decorations, cursor) {
+	const nodes = [];
+	for (; cursor.index < tokens.length; cursor.index++) {
+		const token = tokens[cursor.index];
+		const tokenStart = cursor.offset;
+		const tokenEnd = tokenStart + token.value.length;
+		const sliceStart = Math.max(start, tokenStart);
+		const sliceEnd = Math.min(end, tokenEnd);
+		if (sliceStart < sliceEnd) {
+			let sorted = [sliceStart, sliceEnd];
+			if (decorations.length) {
+				const boundaries = new Set(sorted);
+				for (const decoration of decorations) {
+					const [decorationStart, decorationEnd] = decoration.range;
+					if (decorationEnd <= sliceStart || decorationStart >= sliceEnd) continue;
+					boundaries.add(Math.max(sliceStart, decorationStart));
+					boundaries.add(Math.min(sliceEnd, decorationEnd));
+				}
+				sorted = [...boundaries].sort((a, b) => a - b);
+			}
+			for (let index = 0; index < sorted.length - 1; index++) {
+				const segmentStart = sorted[index];
+				const segmentEnd = sorted[index + 1];
+				let node = {
+					type: "text",
+					value: token.value.slice(segmentStart - tokenStart, segmentEnd - tokenStart)
+				};
+				if (token.className) node = {
+					type: "element",
+					classNames: ["th-token", `th-${token.className}`],
+					children: [node]
+				};
+				for (const decoration of decorations) {
+					if (decoration.range[0] > segmentStart || decoration.range[1] < segmentEnd) continue;
+					node = {
+						type: "element",
+						classNames: ["th-decoration", ...splitClassNames(decoration.className)],
+						data: stringifyData(decoration.data),
+						children: [node]
+					};
+				}
+				nodes.push(node);
+			}
+		}
+		if (tokenEnd > end) break;
+		cursor.offset = tokenEnd;
+	}
+	return nodes;
+}
+function getLineStarts(code) {
+	const starts = [0];
+	for (let index = 0; index < code.length; index++) if (code[index] === "\n" && index + 1 < code.length) starts.push(index + 1);
+	return starts;
+}
+function includesLine(lines, line) {
+	return typeof lines === "number" ? lines === line : line >= lines[0] && line <= lines[1];
+}
+function mergeData(decorations) {
+	const data = {};
+	for (const decoration of decorations) Object.assign(data, stringifyData(decoration.data));
+	return data;
+}
+function stringifyData(data) {
+	if (!data) return void 0;
+	return Object.fromEntries(Object.entries(data).map(([key, value]) => [normalizeDataKey(key), String(value)]));
+}
+function normalizeDataKey(value) {
+	return toKebabCase(value).replace(/[^a-z0-9_.:-]/gi, "-");
+}
+function splitClassNames(className) {
+	return className?.trim().split(/\s+/).filter(Boolean) || [];
+}
+function toKebabCase(value) {
+	return value.replace(/[A-Z]/g, (character) => `-${character.toLowerCase()}`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/internal/patterns.js
+function patternTokenizer(patterns) {
+	return (code) => collectPatternRanges(code, patterns);
+}
+function collectPatternRanges(code, patterns, initial = [], occupied = new Uint8Array(code.length)) {
+	const ranges = [...initial];
+	for (const range of initial) occupied.fill(1, range.start, range.end);
+	for (const pattern of patterns) {
+		if ("collect" in pattern) {
+			for (const range of pattern.collect(code)) addRange(ranges, occupied, range);
+			continue;
+		}
+		const regex = cloneRegex(pattern.regex);
+		let match;
+		while (match = regex.exec(code)) {
+			const value = pattern.group ? match[pattern.group] : match[0];
+			if (!value) {
+				if (!match[0].length) regex.lastIndex++;
+				continue;
+			}
+			const offset = pattern.group ? match[0].length - value.length : 0;
+			const start = match.index + offset;
+			addRange(ranges, occupied, {
+				start,
+				end: start + value.length,
+				className: typeof pattern.className === "function" ? pattern.className(match) : pattern.className
+			});
+		}
+	}
+	return ranges;
+}
+function offsetRanges(ranges, offset) {
+	return ranges.map((range) => ({
+		...range,
+		start: range.start + offset,
+		end: range.end + offset
+	}));
+}
+function addRange(ranges, occupied, range) {
+	if (range.start >= range.end || range.start < 0 || range.end > occupied.length || hasOverlap(occupied, range.start, range.end)) return false;
+	ranges.push(range);
+	occupied.fill(1, range.start, range.end);
+	return true;
+}
+function cloneRegex(regex) {
+	return new RegExp(regex.source, regex.global ? regex.flags : `${regex.flags}g`);
+}
+function hasOverlap(occupied, start, end) {
+	for (let index = start; index < end; index++) if (occupied[index]) return true;
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/css.js
+const css = defineLanguage({
+	name: "css",
+	tokenize: patternTokenizer([
+		{
+			className: (match) => match[0].startsWith("/*") ? "comment" : "string",
+			regex: /\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g
+		},
+		{
+			className: "variable",
+			regex: /--[A-Za-z0-9_-]+/g
+		},
+		{
+			className: "selector",
+			regex: /(^|[}\n])\s*([^@{}\n][^{}\n]*)(?=\s*\{)/g,
+			group: 2
+		},
+		{
+			className: "property",
+			regex: /(?:^|[;{]\s*)([A-Za-z-]+)(?=\s*:)/gm,
+			group: 1
+		},
+		{
+			className: "function",
+			regex: /\b[A-Za-z-]+(?=\()/g
+		},
+		{
+			className: "number",
+			regex: /\b\d+(?:\.\d+)?(?:px|rem|em|%|s|ms|vh|vw|deg)?\b/g
+		}
+	])
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/internal/markup.js
+const rawTextClosing = {
+	script: /<\/script(?=[\s/>])/gi,
+	style: /<\/style(?=[\s/>])/gi
+};
+function collectMarkupRanges(code, context, mode = "html") {
+	const ranges = [];
+	const regions = [];
+	let index = 0;
+	while ((index = code.indexOf("<", index)) >= 0) {
+		if (code.startsWith("<!--", index)) {
+			const close = code.indexOf("-->", index + 4);
+			const end = close < 0 ? code.length : close + 3;
+			ranges.push({
+				start: index,
+				end,
+				className: "comment"
+			});
+			index = end;
+			continue;
+		}
+		if (mode === "ejs" && code.startsWith("<%", index)) {
+			const close = code.indexOf("%>", index + 2);
+			const end = close < 0 ? code.length : close;
+			regions.push({
+				start: index + 2,
+				end,
+				lang: "js"
+			});
+			index = close < 0 ? code.length : close + 2;
+			continue;
+		}
+		const closing = code[index + 1] === "/";
+		const nameStart = index + (closing ? 2 : 1);
+		const nameMatch = /^[A-Za-z][\w:.-]*/.exec(code.slice(nameStart));
+		if (!nameMatch) {
+			index++;
+			continue;
+		}
+		const tagEnd = findTagEnd(code, nameStart + nameMatch[0].length);
+		if (tagEnd < 0) {
+			index++;
+			continue;
+		}
+		const tagName = nameMatch[0].toLowerCase();
+		ranges.push({
+			start: nameStart,
+			end: nameStart + nameMatch[0].length,
+			className: "tag"
+		});
+		if (!closing) collectAttributes(code, nameStart + nameMatch[0].length, tagEnd, ranges);
+		if (!closing && (tagName === "script" || tagName === "style")) {
+			const rawTextClose = rawTextClosing[tagName];
+			rawTextClose.lastIndex = tagEnd + 1;
+			const contentEnd = rawTextClose.exec(code)?.index ?? code.length;
+			const lang = getEmbeddedLanguage(tagName, code.slice(index, tagEnd + 1));
+			regions.push({
+				start: tagEnd + 1,
+				end: contentEnd,
+				lang
+			});
+			index = contentEnd;
+			continue;
+		}
+		index = tagEnd + 1;
+	}
+	if (mode === "vue") collectDelimitedRegions(code, "{{", "}}", "js", regions);
+	if (mode === "svelte") collectBraceRegions(code, regions);
+	for (const region of regions) {
+		if (region.start >= region.end || !context.hasLanguage(region.lang)) continue;
+		ranges.push(...offsetRanges(context.tokenize(code.slice(region.start, region.end), region.lang), region.start));
+	}
+	return ranges;
+}
+function collectAttributes(code, start, end, ranges) {
+	const source = code.slice(start, end);
+	const attributes = /\s([:@A-Za-z_][\w:.-]*)(?=\s*(?:=|\/?>))/g;
+	let match;
+	while (match = attributes.exec(source)) {
+		const offset = match[0].indexOf(match[1]);
+		const attributeStart = start + match.index + offset;
+		ranges.push({
+			start: attributeStart,
+			end: attributeStart + match[1].length,
+			className: "attr"
+		});
+	}
+	let index = start;
+	while (index < end) {
+		const quote = code[index];
+		if (quote !== "\"" && quote !== "'") {
+			index++;
+			continue;
+		}
+		const close = findQuoteEnd(code, index, quote, end);
+		ranges.push({
+			start: index,
+			end: close,
+			className: "string"
+		});
+		index = close;
+	}
+}
+function getEmbeddedLanguage(tag, openingTag) {
+	if (tag === "style") return "css";
+	const lang = /\blang\s*=\s*["']?([\w-]+)/i.exec(openingTag)?.[1];
+	return lang === "ts" || lang === "typescript" ? "ts" : "js";
+}
+function collectDelimitedRegions(code, open, close, lang, regions) {
+	let index = 0;
+	while ((index = code.indexOf(open, index)) >= 0) {
+		const end = code.indexOf(close, index + open.length);
+		if (end < 0) return;
+		regions.push({
+			start: index + open.length,
+			end,
+			lang
+		});
+		index = end + close.length;
+	}
+}
+function collectBraceRegions(code, regions) {
+	let index = 0;
+	while (index < code.length) {
+		if (code[index] !== "{" || code[index + 1] === "#") {
+			index++;
+			continue;
+		}
+		const end = code.indexOf("}", index + 1);
+		if (end < 0) return;
+		regions.push({
+			start: index + 1,
+			end,
+			lang: "js"
+		});
+		index = end + 1;
+	}
+}
+function findTagEnd(code, start) {
+	let index = start;
+	while (index < code.length) if (code[index] === "\"" || code[index] === "'") index = findQuoteEnd(code, index, code[index], code.length);
+	else if (code[index] === ">") return index;
+	else index++;
+	return -1;
+}
+function findQuoteEnd(code, start, quote, limit) {
+	let index = start + 1;
+	while (index < limit) if (code[index] === "\\") index += 2;
+	else if (code[index] === quote) return index + 1;
+	else index++;
+	return limit;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/html.js
+const html = defineLanguage({
+	name: "html",
+	aliases: [
+		"htm",
+		"xml",
+		"angular-html"
+	],
+	tokenize: (code, context) => collectMarkupRanges(code, context)
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/internal/script.js
+const semanticPatterns = [
+	{
+		className: "property",
+		regex: /(?<!\.)\.([A-Za-z_$][\w$]*)/g,
+		group: 1
+	},
+	{
+		className: "function",
+		regex: /@[A-Za-z_$][\w$]*/g
+	},
+	{
+		className: "keyword",
+		regex: new RegExp(`\\b(?:abstract|as|asserts|async|await|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|module|namespace|new|of|override|package|private|protected|public|readonly|return|satisfies|set|static|super|switch|this|throw|try|type|typeof|using|var|while|with|yield)\\b`, "g")
+	},
+	{
+		className: "literal",
+		regex: /\b(?:false|null|true|undefined|NaN|Infinity)\b/g
+	},
+	{
+		className: "number",
+		regex: /\b(?:0x[\da-f](?:_?[\da-f])*n?|0b[01](?:_?[01])*n?|0o[0-7](?:_?[0-7])*n?|\d(?:_?\d)*(?:\.\d(?:_?\d)*)?(?:e[+-]?\d(?:_?\d)*)?n?)\b/gi
+	},
+	{
+		className: "function",
+		regex: /\bfunction\s*\*?\s*([A-Za-z_$][\w$]*)/g,
+		group: 1
+	},
+	{
+		className: "function",
+		regex: /(^|[^.A-Za-z0-9_$])([A-Za-z_$][\w$]*)(?=\s*\()/g,
+		group: 2
+	},
+	{
+		className: "type",
+		regex: /\b(?:Array|Record|Promise|Readonly|Set|Map|WeakMap|WeakSet|string|number|boolean|bigint|symbol|object|unknown|never|void|any|[A-Z][A-Za-z0-9_$]*)\b/g
+	}
+];
+function collectScriptRanges(code, jsx = false, jsxAtLineStart = false) {
+	const jsxText = jsx ? new Uint8Array(code.length) : void 0;
+	const initial = [];
+	collectScriptInitialRanges(code, jsx, jsxAtLineStart, jsxText, initial);
+	return collectPatternRanges(code, semanticPatterns, initial, jsxText);
+}
+function collectScriptInitialRanges(code, jsx, jsxAtLineStart, jsxText, ranges, index = 0, limit = code.length, tagBody = false) {
+	const objectBraces = [];
+	const expressions = [];
+	let jsxDepth = 0;
+	while (index < limit) {
+		const expression = expressions.at(-1);
+		const inJsxText = jsxDepth > (expression || 0);
+		const character = code[index];
+		const next = code[index + 1];
+		if (inJsxText) {
+			if (character === "{") {
+				expressions.push(jsxDepth);
+				index++;
+				continue;
+			}
+			if (character !== "<") {
+				const start = index;
+				while (index < code.length && code[index] !== "<" && code[index] !== "{") index++;
+				jsxText.fill(1, start, index);
+				continue;
+			}
+		}
+		if (tagBody && !expressions.length && !jsxDepth && character === ">") return index;
+		if (character === "/" && next === "/") {
+			const end = findLineEnd(code, index + 2);
+			ranges.push({
+				start: index,
+				end,
+				className: "comment"
+			});
+			index = end;
+			continue;
+		}
+		if (character === "/" && next === "*") {
+			const close = code.indexOf("*/", index + 2);
+			const end = close < 0 ? code.length : close + 2;
+			ranges.push({
+				start: index,
+				end,
+				className: "comment"
+			});
+			index = end;
+			continue;
+		}
+		if (character === "'" || character === "\"") {
+			const end = findQuotedEnd(code, index, character, tagBody && !expressions.length);
+			ranges.push({
+				start: index,
+				end,
+				className: "string"
+			});
+			index = end;
+			continue;
+		}
+		if (character === "`") {
+			index = collectTemplateRanges(code, index, ranges, jsx, jsxAtLineStart);
+			continue;
+		}
+		if (character === "/" && !(jsx && code[index - 1] === "<") && isRegexStart(code, index)) {
+			const end = findRegexEnd(code, index);
+			if (end > index + 1) {
+				ranges.push({
+					start: index,
+					end,
+					className: "literal"
+				});
+				index = end;
+				continue;
+			}
+		}
+		if (character === "{") {
+			const before = previousCodeIndex(code, index, ranges);
+			let wordStart = before;
+			while (wordStart >= 0 && /[\w$]/.test(code[wordStart])) wordStart--;
+			const word = code.slice(wordStart + 1, before + 1);
+			objectBraces.push("=(:,[".includes(code[before] || "\0") || /^(?:return|yield|const|let|var)$/.test(word));
+		} else if (character === "}") objectBraces.pop();
+		else if (objectBraces.at(-1) && /[A-Za-z_$]/.test(character)) {
+			const before = previousCodeIndex(code, index, ranges);
+			if ("{,;".includes(code[before] || "\0")) {
+				let end = index + 1;
+				while (end < limit && /[\w$]/.test(code[end])) end++;
+				if (code[end + (code.slice(end).match(/^(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*(?:\n|$))*/)?.[0].length || 0)] === ":") {
+					ranges.push({
+						start: index,
+						end,
+						className: "property"
+					});
+					index = end;
+					continue;
+				}
+			}
+		}
+		if (!jsx) {
+			index++;
+			continue;
+		}
+		if (!inJsxText && character === "{" && (expressions.length || tagBody)) {
+			expressions.push(expressions.length ? expression : jsxDepth);
+			index++;
+			continue;
+		}
+		if (!inJsxText && expressions.length && character === "}") {
+			expressions.pop();
+			index++;
+			continue;
+		}
+		if (character !== "<") {
+			index++;
+			continue;
+		}
+		if (code.startsWith("</>", index)) {
+			jsxDepth--;
+			index += 3;
+			continue;
+		}
+		if (code.startsWith("<>", index) && (inJsxText || isJsxStart(code, index, jsxAtLineStart))) {
+			jsxDepth++;
+			index += 2;
+			continue;
+		}
+		const closing = code[index + 1] === "/";
+		const nameStart = index + (closing ? 2 : 1);
+		const nameMatch = /^[A-Za-z][\w:.-]*/.exec(code.slice(nameStart));
+		if (!nameMatch || !closing && !inJsxText && !isJsxStart(code, index, jsxAtLineStart)) {
+			index++;
+			continue;
+		}
+		const end = collectScriptInitialRanges(code, true, jsxAtLineStart, jsxText, ranges, nameStart + nameMatch[0].length, limit, true);
+		if (end < 0 || isTypeParameter(code, index, end, closing)) {
+			index++;
+			continue;
+		}
+		ranges.push({
+			start: nameStart,
+			end: nameStart + nameMatch[0].length,
+			className: "tag"
+		});
+		if (!closing) collectJsxAttributes(code, nameStart + nameMatch[0].length, end, ranges);
+		const selfClosing = /\/\s*$/.test(code.slice(nameStart, end));
+		if (closing) jsxDepth--;
+		else if (!selfClosing) jsxDepth++;
+		index = end + 1;
+	}
+	return -1;
+}
+function collectTemplateRanges(code, start, ranges, jsx, jsxAtLineStart) {
+	let segmentStart = start;
+	let index = start + 1;
+	while (index < code.length) {
+		if (code[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (code[index] === "`") {
+			ranges.push({
+				start: segmentStart,
+				end: index + 1,
+				className: "string"
+			});
+			return index + 1;
+		}
+		if (code[index] === "$" && code[index + 1] === "{") {
+			if (segmentStart < index) ranges.push({
+				start: segmentStart,
+				end: index,
+				className: "string"
+			});
+			ranges.push({
+				start: index,
+				end: index + 2,
+				className: "operator"
+			});
+			const end = findInterpolationEnd(code, index + 2);
+			const expressionEnd = end < 0 ? code.length : end;
+			const expression = code.slice(index + 2, expressionEnd);
+			ranges.push(...offsetRanges(collectScriptRanges(expression, jsx, jsxAtLineStart), index + 2));
+			if (end < 0) return code.length;
+			ranges.push({
+				start: end,
+				end: end + 1,
+				className: "operator"
+			});
+			index = end + 1;
+			segmentStart = index;
+			continue;
+		}
+		index++;
+	}
+	if (segmentStart < code.length) ranges.push({
+		start: segmentStart,
+		end: code.length,
+		className: "string"
+	});
+	return code.length;
+}
+function findInterpolationEnd(code, start) {
+	let depth = 1;
+	let index = start;
+	while (index < code.length) {
+		const character = code[index];
+		const next = code[index + 1];
+		if (character === "'" || character === "\"") {
+			index = findQuotedEnd(code, index, character);
+			continue;
+		}
+		if (character === "`") {
+			index = skipTemplate(code, index);
+			continue;
+		}
+		if (character === "/" && next === "/") {
+			index = findLineEnd(code, index + 2);
+			continue;
+		}
+		if (character === "/" && next === "*") {
+			const close = code.indexOf("*/", index + 2);
+			index = close < 0 ? code.length : close + 2;
+			continue;
+		}
+		if (character === "/" && isRegexStart(code, index)) {
+			index = findRegexEnd(code, index);
+			continue;
+		}
+		if (character === "{") depth++;
+		if (character === "}" && --depth === 0) return index;
+		index++;
+	}
+	return -1;
+}
+function skipTemplate(code, start) {
+	let index = start + 1;
+	while (index < code.length) if (code[index] === "\\") index += 2;
+	else if (code[index] === "`") return index + 1;
+	else if (code[index] === "$" && code[index + 1] === "{") {
+		const end = findInterpolationEnd(code, index + 2);
+		index = end < 0 ? code.length : end + 1;
+	} else index++;
+	return code.length;
+}
+function collectJsxAttributes(code, start, end, ranges) {
+	const source = code.slice(start, end);
+	const regex = /\s([:@A-Za-z_$][\w$:.-]*)(?=\s*(?:=|\/?>))/g;
+	let match;
+	while (match = regex.exec(source)) {
+		const attributeStart = start + match.index + 1;
+		ranges.push({
+			start: attributeStart,
+			end: attributeStart + match[1].length,
+			className: "attr"
+		});
+	}
+}
+function isJsxStart(code, index, jsxAtLineStart) {
+	if (jsxAtLineStart && /^\s*$/.test(code.slice(code.lastIndexOf("\n", index - 1) + 1, index))) return true;
+	const before = code.slice(0, index).trimEnd();
+	if (!before) return true;
+	if (/\b(?:return|case|yield)$/.test(before)) return true;
+	return /(?:[=([{,:;!&|?]|>)$/.test(before);
+}
+function isTypeParameter(code, start, end, closing) {
+	if (closing) return false;
+	const inside = code.slice(start + 1, end);
+	const after = code.slice(end + 1).trimStart();
+	return /\s+extends\s+/.test(inside) || after[0] === "(" && !inside.trimEnd().endsWith("/");
+}
+function isRegexStart(code, index) {
+	const before = code.slice(0, index).trimEnd();
+	if (!before) return true;
+	if (/\b(?:case|delete|in|instanceof|of|return|throw|typeof|void|yield)$/.test(before)) return true;
+	return /[=([{,:;!&|?~+*%^<>-]$/.test(before);
+}
+function findRegexEnd(code, start) {
+	let inClass = false;
+	let index = start + 1;
+	while (index < code.length && code[index] !== "\n") if (code[index] === "\\") index += 2;
+	else if (code[index] === "[") {
+		inClass = true;
+		index++;
+	} else if (code[index] === "]") {
+		inClass = false;
+		index++;
+	} else if (code[index] === "/" && !inClass) {
+		index++;
+		while (/[a-z]/i.test(code[index] || "")) index++;
+		return index;
+	} else index++;
+	return start + 1;
+}
+function findQuotedEnd(code, start, quote, multiline = false) {
+	let index = start + 1;
+	while (index < code.length) if (code[index] === "\\") index += 2;
+	else if (code[index] === quote) return index + 1;
+	else if (!multiline && code[index] === "\n") return index;
+	else index++;
+	return code.length;
+}
+function findLineEnd(code, start) {
+	const end = code.indexOf("\n", start);
+	return end < 0 ? code.length : end;
+}
+function previousCodeIndex(code, index, ranges) {
+	let before = index - 1;
+	let rangeIndex = ranges.length - 1;
+	while (before >= 0) {
+		if (/\s/.test(code[before])) {
+			before--;
+			continue;
+		}
+		const range = ranges[rangeIndex];
+		if (range && range.end > before) {
+			rangeIndex--;
+			if (range.className === "comment" && range.start <= before) {
+				before = range.start - 1;
+				continue;
+			}
+		} else break;
+	}
+	return before;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/js.js
+const js = defineLanguage({
+	name: "js",
+	aliases: [
+		"javascript",
+		"mjs",
+		"cjs",
+		"js-vue"
+	],
+	tokenize: (code) => collectScriptRanges(code)
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/json.js
+const json = defineLanguage({
+	name: "json",
+	aliases: ["jsonc", "json5"],
+	tokenize: patternTokenizer([
+		{
+			className: (match) => match[0].startsWith("//") || match[0].startsWith("/*") ? "comment" : match[1] ? "property" : "string",
+			regex: /\/\/[^\n]*|\/\*[\s\S]*?\*\/|("(?:\\.|[^"\\])*")(?=\s*:)|"(?:\\.|[^"\\])*"/g
+		},
+		{
+			className: "literal",
+			regex: /\b(?:false|null|true)\b/g
+		},
+		{
+			className: "number",
+			regex: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/gi
+		}
+	])
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/jsx.js
+const jsx = defineLanguage({
+	name: "jsx",
+	tokenize: (code) => collectScriptRanges(code, true)
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/markdown.js
+const markdown = defineLanguage({
+	name: "markdown",
+	aliases: ["md"],
+	tokenize(code, context) {
+		return collectPatternRanges(code, [
+			{
+				className: "heading",
+				regex: /^#{1,6}\s.*$/gm
+			},
+			{
+				className: "heading",
+				regex: /^.+\n(?:=+|-+)\s*$/gm
+			},
+			{
+				className: "code-inline",
+				regex: /`[^`\n]+`/g
+			},
+			{
+				className: "link",
+				regex: /!?\[[^\]]+\]\([^)]+\)/g
+			},
+			{
+				className: "meta",
+				regex: /^\s{0,3}(?:>|[-*+] |\d+\. )/gm
+			}
+		], collectFencedCode(code, context));
+	}
+});
+function collectFencedCode(code, context) {
+	const ranges = [];
+	const opening = /^( {0,3})(`{3,}|~{3,})\s*([^\n]*)$/gm;
+	let match;
+	while (match = opening.exec(code)) {
+		const marker = match[2];
+		const contentStart = code.indexOf("\n", match.index + match[0].length);
+		if (contentStart < 0) break;
+		const closing = new RegExp(`^ {0,3}${marker[0]}{${marker.length},}\\s*$`, "gm");
+		closing.lastIndex = contentStart + 1;
+		const close = closing.exec(code);
+		const contentEnd = close?.index ?? code.length;
+		const info = match[3].trim().split(/\s+/)[0];
+		const embedded = info && context.hasLanguage(info) ? offsetRanges(context.tokenize(code.slice(contentStart + 1, contentEnd), info), contentStart + 1) : [];
+		ranges.push({
+			start: match.index,
+			end: contentStart,
+			className: "meta"
+		});
+		ranges.push(...fillCodeRange(contentStart + 1, contentEnd, embedded));
+		if (close) ranges.push({
+			start: close.index,
+			end: close.index + close[0].length,
+			className: "meta"
+		});
+		opening.lastIndex = close ? close.index + close[0].length : code.length;
+	}
+	return ranges;
+}
+function fillCodeRange(start, end, embedded) {
+	const ranges = [];
+	let index = start;
+	for (const range of embedded) {
+		if (range.start > index) ranges.push({
+			start: index,
+			end: range.start,
+			className: "code-inline"
+		});
+		ranges.push(range);
+		index = range.end;
+	}
+	if (index < end) ranges.push({
+		start: index,
+		end,
+		className: "code-inline"
+	});
+	return ranges;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/plaintext.js
+const plaintext = defineLanguage({
+	name: "plaintext",
+	aliases: [
+		"text",
+		"txt",
+		"-->"
+	],
+	tokenize: () => []
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/shell.js
+const shell = defineLanguage({
+	name: "shell",
+	aliases: [
+		"bash",
+		"sh",
+		"zsh",
+		"cmd",
+		"console"
+	],
+	tokenize: patternTokenizer([
+		{ collect: collectShellLexicalRanges },
+		{
+			className: "variable",
+			regex: /\$[A-Za-z_][A-Za-z0-9_]*|\b[A-Z_][A-Z0-9_]*(?==)/g
+		},
+		{
+			className: "keyword",
+			regex: /\b(?:case|do|done|elif|else|esac|export|fi|for|function|if|in|select|then|time|until|while)\b/g
+		},
+		{
+			className: "command",
+			regex: /(^|[\n;|&])\s*([A-Za-z0-9_./-]+)(?=\s|$)/g,
+			group: 2
+		}
+	])
+});
+function collectShellLexicalRanges(code) {
+	const heredocs = [];
+	collectHeredocs(code, heredocs);
+	const ranges = [...heredocs];
+	let heredocIndex = 0;
+	let index = 0;
+	while (index < code.length) {
+		while (heredocIndex < heredocs.length && heredocs[heredocIndex].end <= index) heredocIndex++;
+		const heredoc = heredocs[heredocIndex];
+		if (heredoc && heredoc.start <= index) {
+			index = heredoc.end;
+			continue;
+		}
+		const character = code[index];
+		if (character === "\"" || character === "'") {
+			const quote = character;
+			let end = index + 1;
+			while (end < code.length) if (code[end] === "\\" && quote === "\"") end += 2;
+			else if (code[end] === quote) {
+				end++;
+				break;
+			} else end++;
+			end = Math.min(end, code.length);
+			ranges.push({
+				start: index,
+				end,
+				className: "string"
+			});
+			index = end;
+			continue;
+		}
+		if (character === "$" && code[index + 1] === "{") {
+			const close = code.indexOf("}", index + 2);
+			const end = close < 0 ? code.length : close + 1;
+			ranges.push({
+				start: index,
+				end,
+				className: "variable"
+			});
+			index = end;
+			continue;
+		}
+		if (character === "#" && (index === 0 || code[index - 1] === "\n" || /[\s;|&()]/.test(code[index - 1]))) {
+			const newline = code.indexOf("\n", index);
+			const end = newline < 0 ? code.length : newline;
+			ranges.push({
+				start: index,
+				end,
+				className: "comment"
+			});
+			index = end;
+			continue;
+		}
+		index++;
+	}
+	return ranges;
+}
+function collectHeredocs(code, ranges) {
+	const regex = /<<-?\s*(['"]?)([A-Za-z_][A-Za-z0-9_]*)\1/g;
+	let match;
+	while (match = regex.exec(code)) {
+		if (code[match.index - 1] === "<" || isInsideQuote(code, match.index)) continue;
+		const bodyStartLine = code.indexOf("\n", match.index + match[0].length);
+		if (bodyStartLine < 0) continue;
+		const bodyStart = bodyStartLine + 1;
+		const closingMatch = new RegExp(`^\\t*${match[2]}\\s*$`, "m").exec(code.slice(bodyStart));
+		if (!closingMatch) {
+			ranges.push({
+				start: bodyStart,
+				end: code.length,
+				className: "string"
+			});
+			continue;
+		}
+		const end = bodyStart + closingMatch.index;
+		if (end > bodyStart) ranges.push({
+			start: bodyStart,
+			end,
+			className: "string"
+		});
+		const closingStart = bodyStart + closingMatch.index;
+		ranges.push({
+			start: closingStart,
+			end: closingStart + closingMatch[0].length,
+			className: "meta"
+		});
+	}
+}
+function isInsideQuote(code, index) {
+	const lineStart = code.lastIndexOf("\n", index - 1) + 1;
+	let quote = "";
+	for (let cursor = lineStart; cursor < index; cursor++) if (code[cursor] === "\\" && quote !== "'") cursor++;
+	else if (quote && code[cursor] === quote) quote = "";
+	else if (!quote && (code[cursor] === "\"" || code[cursor] === "'")) quote = code[cursor];
+	return Boolean(quote);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/ts.js
+const ts = defineLanguage({
+	name: "ts",
+	aliases: ["typescript", "angular-ts"],
+	tokenize: (code) => collectScriptRanges(code)
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/tsx.js
+const tsx = defineLanguage({
+	name: "tsx",
+	tokenize: (code) => collectScriptRanges(code, true)
+});
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/languages/yaml.js
+const yaml = defineLanguage({
+	name: "yaml",
+	aliases: ["yml"],
+	tokenize(code) {
+		const lexical = [...collectYamlBlockScalars(code), ...collectYamlLexicalRanges(code)];
+		return collectPatternRanges(code, [
+			{
+				className: "property",
+				regex: /^[ \t-]*([A-Za-z0-9_.-]+)(?=\s*:)/gm,
+				group: 1
+			},
+			{ collect: collectYamlValues },
+			{
+				className: "literal",
+				regex: /\b(?:false|null|true|yes|no|on|off|~)\b/gi
+			},
+			{
+				className: "number",
+				regex: /\b\d+(?:\.\d+)?\b/g
+			}
+		], lexical);
+	}
+});
+function collectYamlBlockScalars(code) {
+	const ranges = [];
+	const opening = /^(\s*)[\w.-]+:\s*[>|][+-]?\s*(?:#.*)?$/gm;
+	let match;
+	while (match = opening.exec(code)) {
+		const start = code.indexOf("\n", match.index + match[0].length);
+		if (start < 0) continue;
+		const indentation = match[1].length;
+		let end = start + 1;
+		while (end < code.length) {
+			const lineEnd = code.indexOf("\n", end);
+			const next = lineEnd < 0 ? code.length : lineEnd;
+			const line = code.slice(end, next);
+			if (line.trim() && (line.match(/^\s*/)?.[0].length || 0) <= indentation) break;
+			end = lineEnd < 0 ? code.length : lineEnd + 1;
+		}
+		if (end > start + 1) ranges.push({
+			start: start + 1,
+			end,
+			className: "string"
+		});
+	}
+	return ranges;
+}
+function collectYamlLexicalRanges(code) {
+	const ranges = [];
+	let index = 0;
+	while (index < code.length) {
+		const character = code[index];
+		if (character === "\"" || character === "'") {
+			const quote = character;
+			let end = index + 1;
+			while (end < code.length && code[end] !== "\n") if (code[end] === "\\" && quote === "\"") end += 2;
+			else if (code[end] === quote) {
+				end++;
+				break;
+			} else end++;
+			ranges.push({
+				start: index,
+				end,
+				className: "string"
+			});
+			index = end;
+			continue;
+		}
+		if (character === "#" && (index === 0 || code[index - 1] === "\n" || /\s/.test(code[index - 1]))) {
+			const newline = code.indexOf("\n", index);
+			const end = newline < 0 ? code.length : newline;
+			ranges.push({
+				start: index,
+				end,
+				className: "comment"
+			});
+			index = end;
+			continue;
+		}
+		index++;
+	}
+	return ranges;
+}
+function collectYamlValues(code) {
+	const ranges = [];
+	const regex = /:\s*([^\n]*)/g;
+	let match;
+	while (match = regex.exec(code)) {
+		const value = match[1];
+		const trimmed = value.trimEnd();
+		if (!trimmed) continue;
+		const start = match.index + match[0].indexOf(value);
+		let end = start + trimmed.length;
+		const comment = /\s+#/.exec(trimmed);
+		if (comment) end = start + comment.index;
+		while (end > start && /\s/.test(code[end - 1])) end--;
+		if (end > start) ranges.push({
+			start,
+			end,
+			className: "string"
+		});
+	}
+	return ranges;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/internal/code-fence.js
+const codeDiffNotation = /(?:(?:\/\/|#)[ \t]*\[!code[ \t]+(\+\+|--)\]|\/\*[ \t]*\[!code[ \t]+(\+\+|--)\][ \t]*\*\/|<!--[ \t]*\[!code[ \t]+(\+\+|--)\][ \t]*-->)[ \t]*\r?$/;
+function parseCodeDiffNotation(code) {
+	const decorations = [];
+	if (!code.includes("[!code")) return {
+		code,
+		decorations
+	};
+	const lines = code.split("\n");
+	for (let index = 0; index < lines.length; index++) {
+		const line = lines[index];
+		const match = codeDiffNotation.exec(line);
+		if (!match) continue;
+		const notation = match[1] || match[2] || match[3];
+		decorations.push({
+			className: notation === "++" ? "th-line--inserted" : "th-line--deleted",
+			lines: index + 1
+		});
+		lines[index] = line.slice(0, match.index).replace(/[ \t]+$/, "") + (line.endsWith("\r") ? "\r" : "");
+	}
+	return {
+		code: lines.join("\n"),
+		decorations
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+highlight@1.0.0/node_modules/@tanstack/highlight/dist/markdown.js
+function createTanStackMarkdownHighlighter(highlighter) {
+	return (code, lang = "plaintext", options = {}) => {
+		const annotated = parseCodeDiffNotation(code);
+		const result = highlighter.tokenize(annotated.code, { lang });
+		for (const lines of options.highlightLines || []) annotated.decorations.push({
+			className: "th-line--highlighted",
+			lines
+		});
+		return renderNodesToHtml(renderTokens(result.tokens, {
+			lineNumbers: options.lineNumbers,
+			decorations: annotated.decorations
+		}));
+	};
+}
+//#endregion
+//#region ../../packages/document/src/highlight.ts
+const MAX_HIGHLIGHT_CHARS = 262144;
+const highlighter = createHighlighter({ languages: [
+	js,
+	jsx,
+	ts,
+	tsx,
+	json,
+	yaml,
+	html,
+	css,
+	shell,
+	markdown,
+	plaintext
+] });
+const registered = new Set(highlighter.listLanguages());
+const highlightAdapter = createTanStackMarkdownHighlighter(highlighter);
+const safeHighlighter = (code, lang, options) => {
+	const normalized = lang ? highlighter.normalizeLanguage(lang) : "plaintext";
+	const usable = registered.has(normalized) && code.length <= MAX_HIGHLIGHT_CHARS;
+	return highlightAdapter(code, usable ? normalized : "plaintext", options);
+};
+//#endregion
+//#region ../../packages/document/src/print-style.ts
+const SANS = [
+	"-apple-system",
+	"BlinkMacSystemFont",
+	"'Hiragino Sans'",
+	"'Hiragino Kaku Gothic ProN'",
+	"'Segoe UI'",
+	"'Yu Gothic Medium'",
+	"'Yu Gothic'",
+	"Meiryo",
+	"'Noto Sans CJK JP'",
+	"'Noto Sans JP'",
+	"sans-serif"
+].join(", ");
+const MONO = [
+	"ui-monospace",
+	"'SF Mono'",
+	"SFMono-Regular",
+	"Menlo",
+	"Consolas",
+	"'Liberation Mono'",
+	"'Hiragino Sans'",
+	"'Yu Gothic Medium'",
+	"'Noto Sans CJK JP'",
+	"monospace"
+].join(", ");
+function printPageStyle(cssTitle) {
+	return `@page {
+  size: A4;
+  margin: 20mm;
+  @top-left {
+    content: ${cssTitle};
+    vertical-align: bottom;
+    padding-bottom: 6mm;
+    font: 8pt/1.4 ${SANS};
+    color: #57606a;
+  }
+  @bottom-center {
+    content: counter(page) " / " counter(pages);
+    vertical-align: top;
+    padding-top: 6mm;
+    font: 8pt/1.4 ${SANS};
+    color: #57606a;
+  }
+}`;
+}
+const PRINT_STYLE = `
+:root {
+  color-scheme: light;
+  print-color-adjust: exact;
+  -webkit-print-color-adjust: exact;
+}
+*, *::before, *::after {
+  box-sizing: border-box;
+}
+html, body {
+  margin: 0;
+  padding: 0;
+  background: #ffffff;
+}
+body {
+  font-family: ${SANS};
+  font-size: 10.5pt;
+  line-height: 1.75;
+  color: #1f2328;
+  font-kerning: normal;
+  overflow-wrap: anywhere;
+}
+.document > :first-child {
+  margin-top: 0;
+}
+h1, h2, h3, h4, h5, h6 {
+  margin: 1.7em 0 0.6em;
+  font-weight: 600;
+  line-height: 1.35;
+  color: #111418;
+  break-after: avoid;
+}
+h1 {
+  font-size: 20pt;
+  font-weight: 700;
+  padding-bottom: 0.3em;
+  border-bottom: 1.5pt solid #1f2328;
+}
+h2 {
+  font-size: 14.5pt;
+  padding-bottom: 0.25em;
+  border-bottom: 0.75pt solid #d0d7de;
+}
+h3 {
+  font-size: 12pt;
+}
+h4 {
+  font-size: 10.5pt;
+}
+h5, h6 {
+  font-size: 10pt;
+  color: #57606a;
+}
+p, ul, ol, table, pre, blockquote, figure, .keep-together {
+  margin: 0.8em 0;
+}
+p, li, blockquote {
+  orphans: 3;
+  widows: 3;
+}
+ul, ol {
+  padding-left: 1.6em;
+}
+ul {
+  list-style: disc;
+}
+ol {
+  list-style: decimal;
+}
+li + li, li > ul, li > ol {
+  margin-top: 0.2em;
+}
+li > ul, li > ol, li > p:last-child {
+  margin-bottom: 0;
+}
+li > p:first-child {
+  margin-top: 0;
+}
+li:has(> input[type='checkbox']), li:has(> p:first-child > input[type='checkbox']) {
+  list-style: none;
+  margin-left: -1.4em;
+}
+input[type='checkbox'] {
+  appearance: none;
+  width: 0.95em;
+  height: 0.95em;
+  margin: 0 0.45em 0 0;
+  border: 1pt solid #57606a;
+  border-radius: 2pt;
+  vertical-align: -0.12em;
+  background: #ffffff;
+}
+input[type='checkbox']:checked {
+  border-color: #1f2328;
+  background: #1f2328 url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Cpath d='M3.5 8.5l3 3 6-7' fill='none' stroke='%23ffffff' stroke-width='2.2' stroke-linecap='round' stroke-linejoin='round'/%3E%3C/svg%3E") center / 90% no-repeat;
+}
+a {
+  color: #0969da;
+  text-decoration: underline;
+  text-decoration-color: #9cc3ec;
+  text-underline-offset: 2px;
+}
+strong {
+  font-weight: 600;
+}
+hr {
+  margin: 1.8em 0;
+  border: 0;
+  border-top: 0.75pt solid #d0d7de;
+}
+img {
+  display: block;
+  max-width: 100%;
+  max-height: 230mm;
+  height: auto;
+  margin: 0 auto;
+  break-inside: avoid;
+}
+.blocked-image {
+  color: #57606a;
+  font-size: 0.9em;
+}
+blockquote {
+  margin-left: 0;
+  margin-right: 0;
+  padding: 0.1em 1em;
+  border-left: 3pt solid #d0d7de;
+  color: #57606a;
+}
+blockquote > :first-child {
+  margin-top: 0;
+}
+blockquote > :last-child {
+  margin-bottom: 0;
+}
+table {
+  display: table;
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 9.5pt;
+  line-height: 1.55;
+}
+thead {
+  display: table-header-group;
+}
+tr {
+  break-inside: avoid;
+}
+th, td {
+  padding: 0.45em 0.75em;
+  border: 0.75pt solid #d0d7de;
+  text-align: left;
+  vertical-align: top;
+}
+th {
+  background: #f3f5f7;
+  font-weight: 600;
+}
+code, pre {
+  font-family: ${MONO};
+}
+:not(pre) > code {
+  padding: 0.1em 0.35em;
+  border-radius: 3pt;
+  background: #eff2f5;
+  font-size: 0.88em;
+}
+pre {
+  padding: 0.8em 1em;
+  border: 0.75pt solid #d8dee4;
+  border-radius: 4pt;
+  background: #f6f8fa;
+  font-size: 8.8pt;
+  line-height: 1.55;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  box-decoration-break: clone;
+  -webkit-box-decoration-break: clone;
+}
+.keep-together {
+  break-inside: avoid;
+}
+.keep-together > pre, .keep-together > figure {
+  margin: 0;
+}
+figure.tm-code-frame > figcaption {
+  margin-bottom: 0.3em;
+  break-after: avoid;
+  font-family: ${MONO};
+  font-size: 8.5pt;
+  color: #57606a;
+}
+figure.tm-code-frame > pre {
+  margin: 0;
+}
+.th-keyword { color: #cf222e; font-weight: 600; }
+.th-string, .th-code-inline, .th-inserted { color: #0a3069; }
+.th-number, .th-literal { color: #0550ae; }
+.th-comment, .th-meta { color: #59636e; }
+.th-function, .th-command, .th-property, .th-link { color: #6639ba; }
+.th-tag { color: #116329; }
+.th-type, .th-attr, .th-selector, .th-variable { color: #953800; }
+.th-heading { color: #0550ae; font-weight: 600; }
+.th-deleted { color: #82071e; }
+.footnotes {
+  margin-top: 2em;
+  padding-top: 0.6em;
+  border-top: 0.75pt solid #d0d7de;
+  font-size: 9pt;
+  color: #57606a;
+}
+.footnotes ol {
+  margin: 0;
+}
+/* The hidden "Footnotes" heading of the renderer would appear in the PDF outline. */
+.sr-only {
+  display: none;
+}
+.data-footnote-backref {
+  text-decoration: none;
+  font-variant-emoji: text;
+}
+`;
+//#endregion
+//#region ../../packages/document/src/print.ts
+const PRINT_CSP = "default-src 'none'; img-src data:; style-src 'unsafe-inline'; base-uri 'none'; form-action 'none'";
+const KANA = /[\u3041-\u3096\u30a1-\u30fa]/;
+const HANGUL = /[\uac00-\ud7af]/;
+const IMAGE_SLOT = /^[0-9a-f]{32,}$/;
+const KEEP_TOGETHER_LINES = 25;
+const HEADER_TITLE_LENGTH = 60;
+function escapeHtml(value) {
+	return value.replace(/[&<>"'`]/g, (character) => `&#${String(character.charCodeAt(0))};`);
+}
+function cssString(value) {
+	let escaped = "";
+	for (const character of value) escaped += /^[A-Za-z0-9 ]$/.test(character) ? character : `\\${(character.codePointAt(0) ?? 65533).toString(16)} `;
+	return `"${escaped}"`;
+}
+function headerTitle(title) {
+	const characters = Array.from(title);
+	return characters.length > HEADER_TITLE_LENGTH ? `${characters.slice(0, 59).join("")}…` : title;
+}
+function printNodes(input, baseOptions) {
+	const images = new Map(input.images.map((logicalPath, index) => [logicalPath, index]));
+	return {
+		name: "vde-open-print",
+		renderHtml(node, context) {
+			if (node.type === "image") {
+				const logicalPath = localImagePath(node.src, input.documentLogicalPath);
+				const index = logicalPath === null ? void 0 : images.get(logicalPath);
+				if (index === void 0) return `<span class="blocked-image">${escapeHtml(node.alt ? `[image: ${node.alt}]` : "[image]")}</span>`;
+				const title = node.title ? ` title="${escapeHtml(node.title)}"` : "";
+				return `<img src="${input.imageSlot}-${String(index)}" alt="${escapeHtml(node.alt)}"${title}>`;
+			}
+			if (node.type === "link") {
+				const children = node.children.map((child) => context.renderInline(child)).join("");
+				const kind = renderedLinkOf(node.href);
+				if (kind !== "fragment" && kind !== "external") return children;
+				const title = node.title ? ` title="${escapeHtml(node.title)}"` : "";
+				return `<a href="${escapeHtml(node.href)}"${title}>${children}</a>`;
+			}
+			if (node.type === "code" && node.value.split("\n").length <= KEEP_TOGETHER_LINES) return `<div class="keep-together">${renderBlock(node, baseOptions)}</div>`;
+		}
+	};
+}
+function renderPrintDocument(input) {
+	if (!IMAGE_SLOT.test(input.imageSlot)) throw new Error("The image slot must be random hexadecimal.");
+	const baseOptions = {
+		...MARKDOWN_PARSE_OPTIONS,
+		allowHtml: false,
+		highlighter: safeHighlighter
+	};
+	const body = renderDocument(parseMarkdownDocument(input.source), {
+		...baseOptions,
+		extensions: [printNodes(input, baseOptions)]
+	});
+	return [
+		"<!doctype html>",
+		`<html${KANA.test(input.source) ? " lang=\"ja\"" : HANGUL.test(input.source) ? " lang=\"ko\"" : ""}>`,
+		"<head>",
+		"<meta charset=\"utf-8\">",
+		`<meta http-equiv="Content-Security-Policy" content="${PRINT_CSP}">`,
+		`<title>${escapeHtml(input.title)}</title>`,
+		`<style>${printPageStyle(cssString(headerTitle(input.title)))}${PRINT_STYLE}</style>`,
+		"</head>",
+		`<body><main class="document">${body}</main></body>`,
+		"</html>",
+		""
+	].join("\n");
+}
+//#endregion
+export { cssString, headerTitle, renderPrintDocument };