@ox-content/vite-plugin 2.80.0 → 2.82.0

package/dist/index.cjs

@@ -1,37 +1,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_chunk = require("./chunk.cjs");
+const require_vitepress = require("./vitepress.cjs");
 const require_interop = require("./interop.cjs");
-const require_napi = require("./napi.cjs");
-const require_mermaid = require("./mermaid.cjs");
 const require_tabs = require("./tabs.cjs");
-require("./pm.cjs");
-const require_youtube = require("./youtube.cjs");
-require("./media.cjs");
-const require_github = require("./github.cjs");
-const require_ogp = require("./ogp.cjs");
-const require_vitepress = require("./vitepress.cjs");
 let path = require("path");
-path = require_chunk.__toESM(path, 1);
+path = require_vitepress.__toESM(path, 1);
 let unified = require("unified");
 let rehype_parse = require("rehype-parse");
-rehype_parse = require_chunk.__toESM(rehype_parse, 1);
+rehype_parse = require_vitepress.__toESM(rehype_parse, 1);
 let rehype_stringify = require("rehype-stringify");
-rehype_stringify = require_chunk.__toESM(rehype_stringify, 1);
+rehype_stringify = require_vitepress.__toESM(rehype_stringify, 1);
 let shiki = require("shiki");
 let node_module = require("node:module");
+let node_fs = require("node:fs");
 let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path, 1);
+node_path = require_vitepress.__toESM(node_path, 1);
 let node_fs_promises = require("node:fs/promises");
-node_fs_promises = require_chunk.__toESM(node_fs_promises, 1);
+node_fs_promises = require_vitepress.__toESM(node_fs_promises, 1);
+let node_buffer = require("node:buffer");
 let node_os = require("node:os");
 let node_util = require("node:util");
 let node_child_process = require("node:child_process");
 let fs_promises = require("fs/promises");
-fs_promises = require_chunk.__toESM(fs_promises, 1);
+fs_promises = require_vitepress.__toESM(fs_promises, 1);
 let crypto = require("crypto");
-crypto = require_chunk.__toESM(crypto, 1);
+crypto = require_vitepress.__toESM(crypto, 1);
 let fs = require("fs");
-fs = require_chunk.__toESM(fs, 1);
+fs = require_vitepress.__toESM(fs, 1);
 let glob = require("glob");
 //#region src/markdown.ts
 const DEFAULT_MARKDOWN_EXTENSIONS = [
@@ -118,8 +112,8 @@ function createMarkdownEnvironment(options) {
 /**
 * Syntax highlighting with Shiki via rehype.
 */
-const rehypeParse$1 = require_interop.interopDefault(rehype_parse.default);
-const rehypeStringify$1 = require_interop.interopDefault(rehype_stringify.default);
+const rehypeParse$3 = require_interop.interopDefault(rehype_parse.default);
+const rehypeStringify$3 = require_interop.interopDefault(rehype_stringify.default);
 const BUILTIN_LANGS = [
 	"javascript",
 	"typescript",
@@ -198,7 +192,7 @@ function rehypeShikiHighlight(options) {
 					lang,
 					theme: themeName
 				});
-				const parsed = (0, unified.unified)().use(rehypeParse$1, { fragment: true }).parse(highlighted);
+				const parsed = (0, unified.unified)().use(rehypeParse$3, { fragment: true }).parse(highlighted);
 				if (parsed.children[0]?.type === "element") {
 					const highlightedPre = parsed.children[0];
 					highlightedPre.properties ??= {};
@@ -220,13 +214,13 @@ function rehypeShikiHighlight(options) {
 					lang,
 					theme: themeName
 				});
-				const parsed = (0, unified.unified)().use(rehypeParse$1, { fragment: true }).parse(highlighted);
+				const parsed = (0, unified.unified)().use(rehypeParse$3, { fragment: true }).parse(highlighted);
 				if (parsed.children[0]?.type === "element") {
 					const highlightedCode = parsed.children[0].children.find((child) => child.type === "element" && child.tagName === "code");
 					if (highlightedCode) {
 						highlightedCode.properties ??= {};
 						const highlightedClasses = normalizeClassName(highlightedCode.properties.className);
-						highlightedCode.properties.className = [...new Set([
+						highlightedCode.properties.className = [.../* @__PURE__ */ new Set([
 							...originalCodeClasses,
 							...highlightedClasses,
 							"shiki-inline"
@@ -276,42 +270,1433 @@ function normalizeClassName(className) {
 * Apply syntax highlighting to HTML using Shiki.
 */
 async function highlightCode(html, theme = "github-dark", langs = []) {
-	const result = await (0, unified.unified)().use(rehypeParse$1, { fragment: true }).use(rehypeShikiHighlight, {
+	const result = await (0, unified.unified)().use(rehypeParse$3, { fragment: true }).use(rehypeShikiHighlight, {
 		theme,
 		langs
-	}).use(rehypeStringify$1).process(html);
+	}).use(rehypeStringify$3).process(html);
+	return String(result);
+}
+//#endregion
+//#region src/plugins/mermaid.ts
+/**
+* Mermaid Plugin - Native Rust renderer via NAPI
+*
+* Renders mermaid code blocks to SVG using the native Rust renderer
+* via NAPI. Delegates to the NAPI `transformMermaid` function which
+* extracts mermaid code blocks from HTML and renders them using mmdc.
+*/
+var mermaid_exports = /* @__PURE__ */ require_vitepress.__exportAll({
+	mermaidClientScript: () => "",
+	transformMermaidStatic: () => transformMermaidStatic
+});
+/** Cached NAPI bindings */
+let napiBindings$1 = null;
+let napiLoadAttempted$1 = false;
+async function loadNapi() {
+	if (napiLoadAttempted$1) return napiBindings$1;
+	napiLoadAttempted$1 = true;
+	try {
+		const binding = await require_vitepress.importNapiModule();
+		if (typeof binding.transformMermaid !== "function") {
+			napiBindings$1 = null;
+			return null;
+		}
+		napiBindings$1 = binding;
+		return binding;
+	} catch {
+		napiBindings$1 = null;
+		return null;
+	}
+}
+let cachedMmdcPath;
+let missingMmdcWarned = false;
+function resolveMmdcPath() {
+	if (cachedMmdcPath !== void 0) return cachedMmdcPath;
+	for (const resolver of createMmdcResolvers()) try {
+		const entry = resolver.resolve("@mermaid-js/mermaid-cli");
+		const cliPath = (0, node_path.join)((0, node_path.dirname)(entry), "cli.js");
+		if ((0, node_fs.existsSync)(cliPath)) {
+			cachedMmdcPath = cliPath;
+			return cachedMmdcPath;
+		}
+	} catch {}
+	const binPath = (0, node_path.join)(process.cwd(), "node_modules", ".bin", "mmdc");
+	if ((0, node_fs.existsSync)(binPath)) {
+		cachedMmdcPath = binPath;
+		return cachedMmdcPath;
+	}
+	cachedMmdcPath = null;
+	return null;
+}
+function createMmdcResolvers() {
+	const consumerRequire = (0, node_module.createRequire)((0, node_path.join)(process.cwd(), "noop.js"));
+	const resolvers = [consumerRequire];
+	try {
+		resolvers.push((0, node_module.createRequire)(consumerRequire.resolve("@ox-content/vite-plugin")));
+	} catch {}
+	return resolvers;
+}
+/**
+* Transforms mermaid code blocks in HTML to rendered SVG diagrams.
+* Uses the native Rust NAPI transformMermaid function.
+*/
+async function transformMermaidStatic(html, _options) {
+	const napi = await loadNapi();
+	if (!napi) return html;
+	const mmdcPath = resolveMmdcPath();
+	if (!mmdcPath) {
+		warnMissingMmdcOnce();
+		return html;
+	}
+	try {
+		const result = napi.transformMermaid(html, mmdcPath);
+		for (const error of result.errors) console.warn("[ox-content] Mermaid render error:", error);
+		return result.html;
+	} catch (err) {
+		console.warn("[ox-content] Mermaid transform error:", err);
+		return html;
+	}
+}
+function warnMissingMmdcOnce() {
+	if (missingMmdcWarned) return;
+	missingMmdcWarned = true;
+	console.warn("[ox-content] mmdc not found; skipping Mermaid rendering.");
+}
+/**
+* @deprecated No longer used. Mermaid rendering is now done at build time via NAPI.
+*/
+const mermaidClientScript = "";
+//#endregion
+//#region src/plugins/pm.ts
+/**
+* Package Manager Tabs Plugin
+*
+* Transforms <pm>npm install …</pm> blocks into a tab group with one tab per
+* package manager (npm/pnpm/yarn/bun). The single npm-style command is converted
+* to each package manager's equivalent natively in Rust (`transformPmEmbeds` in
+* @ox-content/napi), and the result reuses the same `ox-tabs` widget markup as
+* the generic `<tabs>` plugin so styling and keyboard navigation are consistent.
+*
+* Syncing is opt-in (off by default): when enabled, the rendered group carries a
+* `data-ox-tab-group="pkg-manager"` attribute so the client runtime can keep
+* every package-manager group on the page in sync via localStorage.
+*
+* Package-manager groups share the tab-group counter with the `<tabs>` plugin so
+* `data-group` ids (and the CSS produced by `generateTabsCSS`) stay unique.
+*/
+var pm_exports = /* @__PURE__ */ require_vitepress.__exportAll({ transformPm: () => transformPm });
+/**
+* Transform `<pm>` package-manager blocks in HTML into install tabs.
+*
+* @param html - Rendered HTML potentially containing `<pm>` blocks.
+* @param options - Package-manager tab options (syncing is opt-in).
+* @returns The rewritten HTML.
+*/
+async function transformPm(html, options) {
+	if (!/<pm[\s/>]/i.test(html)) return html;
+	const mod = await require_vitepress.importNapiModule();
+	const startGroup = require_tabs.getTabGroupCounter();
+	const result = mod.transformPmEmbeds(html, startGroup, { sync: options?.sync ?? false });
+	require_tabs.setTabGroupCounter(startGroup + result.groupCount);
+	return result.html;
+}
+//#endregion
+//#region src/plugins/youtube.ts
+/**
+* YouTube Plugin - Privacy-enhanced iframe embedding
+*
+* Transforms <YouTube> components into responsive iframe embeds using
+* youtube-nocookie.com for enhanced privacy.
+*
+* The HTML rewrite is performed in Rust (`transformYoutubeEmbeds` in
+* @ox-content/napi), replacing the previous rehype parse/stringify
+* round-trip. This module keeps the public TS surface and a cheap marker
+* check so pages without a `<youtube>` element never cross the NAPI boundary.
+*/
+var youtube_exports = /* @__PURE__ */ require_vitepress.__exportAll({
+	extractVideoId: () => extractVideoId,
+	transformYouTube: () => transformYouTube
+});
+/**
+* Extract YouTube video ID from various URL formats.
+*/
+function extractVideoId(input) {
+	if (/^[a-zA-Z0-9_-]{11}$/.test(input)) return input;
+	for (const pattern of [/(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/|youtube\.com\/v\/)([a-zA-Z0-9_-]{11})/, /youtube\.com\/shorts\/([a-zA-Z0-9_-]{11})/]) {
+		const match = input.match(pattern);
+		if (match) return match[1];
+	}
+	return null;
+}
+/**
+* Transform YouTube components in HTML.
+*/
+async function transformYouTube(html, options) {
+	if (!/<youtube/i.test(html)) return html;
+	return (await require_vitepress.importNapiModule()).transformYoutubeEmbeds(html, options);
+}
+//#endregion
+//#region src/plugins/twitter/url.ts
+const STATUS_PATH = /^\/(?:[^/]+|i\/web)\/status\/(\d+)(?:\/.*)?$/;
+function createSyndicationToken(id) {
+	return (Number(id) / 0x38d7ea4c68000 * Math.PI).toString(36).replaceAll(/(0+|\.)/g, "");
+}
+function parseTweetReference(value) {
+	const trimmed = value.trim();
+	if (/^\d+$/.test(trimmed)) return {
+		id: trimmed,
+		url: `https://x.com/i/web/status/${trimmed}`
+	};
+	try {
+		const url = new URL(trimmed);
+		const hostname = url.hostname.toLowerCase().replace(/^(?:www\.|mobile\.)/, "");
+		if (url.protocol !== "https:" || hostname !== "x.com" && hostname !== "twitter.com") return null;
+		const match = url.pathname.match(STATUS_PATH);
+		if (!match) return null;
+		const screenName = url.pathname.startsWith("/i/web/status/") ? "i/web" : url.pathname.split("/")[1];
+		return {
+			id: match[1],
+			url: `https://x.com/${screenName}/status/${match[1]}`
+		};
+	} catch {
+		return null;
+	}
+}
+function referenceFromAttributes(attributes) {
+	const values = /* @__PURE__ */ new Map();
+	for (const match of attributes.matchAll(/\b(url|href|id)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gi)) values.set(match[1].toLowerCase(), match[2] ?? match[3] ?? match[4] ?? "");
+	return parseTweetReference(values.get("url") ?? values.get("href") ?? values.get("id") ?? "");
+}
+//#endregion
+//#region src/plugins/twitter/fetch.ts
+const tweetCache = /* @__PURE__ */ new Map();
+async function fetchTweetData(id, options) {
+	const key = `${id}-${sanitizeSegment(options.lang)}`;
+	if (options.cache) {
+		const memory = tweetCache.get(key);
+		if (memory) return memory;
+		const disk = await readCachedTweet(key, options.cacheDir);
+		if (disk) {
+			tweetCache.set(key, disk);
+			return disk;
+		}
+	}
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), options.timeout);
+	const endpoint = new URL("https://cdn.syndication.twimg.com/tweet-result");
+	endpoint.searchParams.set("id", id);
+	endpoint.searchParams.set("lang", options.lang);
+	endpoint.searchParams.set("token", createSyndicationToken(id));
+	try {
+		const response = await fetch(endpoint, {
+			headers: { Accept: "application/json" },
+			signal: controller.signal
+		});
+		if (!response.ok) return null;
+		const data = await response.json();
+		if (!isTweetData(data)) return null;
+		if (options.cache) {
+			tweetCache.set(key, data);
+			await writeCachedTweet(key, data, options.cacheDir);
+		}
+		return data;
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+async function materializeTweetAssets(id, data, options) {
+	const assets = { media: [] };
+	const avatarUrl = data.user.profile_image_url_https?.replace(/_normal(?=\.[^.]+$)/, "_bigger");
+	if (avatarUrl) assets.avatar = await downloadAsset(avatarUrl, `${id}-avatar`, options);
+	const media = data.mediaDetails ?? data.entities?.media ?? [];
+	for (const [index, item] of media.entries()) {
+		if (item.type && item.type !== "photo") continue;
+		if (!item.media_url_https) continue;
+		const src = await downloadAsset(item.media_url_https, `${id}-media-${index + 1}`, options);
+		if (src) assets.media.push(assetRecord(src, item));
+	}
+	return assets;
+}
+async function downloadAsset(source, basename, options) {
+	let url;
+	try {
+		url = new URL(source);
+	} catch {
+		return;
+	}
+	if (url.protocol !== "https:" || url.hostname.toLowerCase() !== "pbs.twimg.com") return;
+	const filename = `${basename}${extensionFromUrl(url)}`;
+	const output = node_path.default.join(options.mediaOutputDir, filename);
+	try {
+		await (0, node_fs_promises.access)(output);
+		return joinPublicPath(options.mediaPublicPath, filename);
+	} catch {}
+	try {
+		const response = await fetch(url, { headers: { Accept: "image/*" } });
+		if (!response.ok) return void 0;
+		await (0, node_fs_promises.mkdir)(options.mediaOutputDir, { recursive: true });
+		await (0, node_fs_promises.writeFile)(output, new Uint8Array(await response.arrayBuffer()));
+		return joinPublicPath(options.mediaPublicPath, filename);
+	} catch {
+		return;
+	}
+}
+async function readCachedTweet(key, directory) {
+	try {
+		const data = JSON.parse(await (0, node_fs_promises.readFile)(node_path.default.join(directory, `${key}.json`), "utf8"));
+		return isTweetData(data) ? data : null;
+	} catch {
+		return null;
+	}
+}
+async function writeCachedTweet(key, data, directory) {
+	try {
+		await (0, node_fs_promises.mkdir)(directory, { recursive: true });
+		await (0, node_fs_promises.writeFile)(node_path.default.join(directory, `${key}.json`), `${JSON.stringify(data)}\n`);
+	} catch {}
+}
+function isTweetData(data) {
+	if (!data || typeof data !== "object") return false;
+	const value = data;
+	return typeof value.text === "string" && Boolean(value.user) && typeof value.user?.name === "string" && typeof value.user.screen_name === "string";
+}
+function extensionFromUrl(url) {
+	const match = url.pathname.match(/\.(jpe?g|png|webp|gif)$/i);
+	return match ? `.${match[1].toLowerCase().replace("jpeg", "jpg")}` : ".jpg";
+}
+function joinPublicPath(prefix, filename) {
+	return `${prefix.replace(/\/$/, "")}/${filename}`;
+}
+function sanitizeSegment(value) {
+	return value.replaceAll(/[^a-zA-Z0-9_-]/g, "-");
+}
+function assetRecord(src, media) {
+	return {
+		src,
+		alt: media.ext_alt_text,
+		width: media.original_info?.width,
+		height: media.original_info?.height
+	};
+}
+//#endregion
+//#region src/plugins/twitter/render.ts
+function renderFetchedTweet(permalink, data, assets, options) {
+	const profile = `https://x.com/${encodeURIComponent(data.user.screen_name)}`;
+	const author = escapeHtml$3(data.user.name);
+	const handle = escapeHtml$3(data.user.screen_name);
+	const avatar = assets.avatar ? `<img class="ox-tweet__avatar" src="${escapeAttribute(assets.avatar)}" alt="" width="48" height="48" loading="lazy" decoding="async">` : "";
+	const media = renderMedia(assets);
+	const footer = renderFooter(permalink, data.created_at, options.lang);
+	return [
+		"<figure class=\"ox-tweet ox-tweet--fetched\">",
+		"<header class=\"ox-tweet__header\">",
+		`<a class="ox-tweet__profile" href="${escapeAttribute(profile)}" target="_blank" rel="noopener noreferrer">`,
+		avatar,
+		`<span class="ox-tweet__author-name">${author}</span>`,
+		`<span class="ox-tweet__author-handle">@${handle}</span>`,
+		"</a></header>",
+		`<div class="ox-tweet__body">${renderTweetText(data)}</div>`,
+		media,
+		footer,
+		"</figure>"
+	].join("");
+}
+function renderTweetText(data) {
+	const [start, end] = data.display_text_range ?? [0, data.text.length];
+	const entities = collectEntities(data).filter((entity) => validRange(entity.indices, start, end)).sort((left, right) => left.indices[0] - right.indices[0]);
+	let cursor = start;
+	let output = "";
+	for (const entity of entities) {
+		const [entityStart, entityEnd] = entity.indices;
+		if (entityStart < cursor) continue;
+		output += escapeText(data.text.slice(cursor, entityStart));
+		if (entity.kind === "url") {
+			const href = entity.expanded_url ?? entity.url;
+			const label = entity.display_url ?? href;
+			output += `<a href="${escapeAttribute(href)}" target="_blank" rel="noopener noreferrer">${escapeHtml$3(label)}</a>`;
+		}
+		cursor = entityEnd;
+	}
+	output += escapeText(data.text.slice(cursor, end));
+	return output.trim();
+}
+function collectEntities(data) {
+	return [...(data.entities?.urls ?? []).map((entity) => ({
+		...entity,
+		kind: "url"
+	})), ...(data.entities?.media ?? []).map((entity) => ({
+		...entity,
+		kind: "media"
+	}))];
+}
+function validRange(indices, start, end) {
+	return Boolean(indices && indices[0] >= start && indices[1] <= end && indices[0] < indices[1]);
+}
+function renderMedia(assets) {
+	if (assets.media.length === 0) return "";
+	const images = assets.media.map((item) => {
+		const size = [item.width ? ` width="${item.width}"` : "", item.height ? ` height="${item.height}"` : ""].join("");
+		return `<img class="ox-tweet__media-item" src="${escapeAttribute(item.src)}" alt="${escapeAttribute(item.alt ?? "")}"${size} loading="lazy" decoding="async">`;
+	}).join("");
+	return `<div class="ox-tweet__media" data-count="${assets.media.length}">${images}</div>`;
+}
+function renderFooter(permalink, createdAt, lang) {
+	if (!createdAt) return `<footer class="ox-tweet__footer"><a class="ox-tweet__permalink" href="${escapeAttribute(permalink)}" target="_blank" rel="noopener noreferrer">View on X</a></footer>`;
+	const date = new Date(createdAt);
+	if (Number.isNaN(date.valueOf())) return renderFooter(permalink, void 0, lang);
+	const iso = date.toISOString();
+	let label;
+	try {
+		label = new Intl.DateTimeFormat(lang, {
+			dateStyle: "medium",
+			timeZone: "UTC"
+		}).format(date);
+	} catch {
+		label = new Intl.DateTimeFormat("en", {
+			dateStyle: "medium",
+			timeZone: "UTC"
+		}).format(date);
+	}
+	return `<footer class="ox-tweet__footer"><a class="ox-tweet__permalink" href="${escapeAttribute(permalink)}" target="_blank" rel="noopener noreferrer"><time datetime="${iso}">${escapeHtml$3(label)}</time></a></footer>`;
+}
+function escapeText(value) {
+	return escapeHtml$3(value).replaceAll("\n", "<br>");
+}
+function escapeAttribute(value) {
+	return escapeHtml$3(value).replaceAll("`", "&#96;");
+}
+function escapeHtml$3(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+//#endregion
+//#region src/plugins/twitter/transform.ts
+const TWEET_ELEMENT = /<(tweet|xpost)\b([^>]*?)(?:\/\s*>|>[\s\S]*?<\/\1\s*>)/gi;
+function resolveTwitterEmbedOptions$1(options) {
+	return {
+		fetch: options.fetch ?? false,
+		lang: options.lang ?? "en",
+		timeout: options.timeout ?? 1e4,
+		cache: options.cache ?? true,
+		cacheDir: node_path.default.resolve(options.cacheDir ?? ".cache/ox-content/twitter"),
+		mediaOutputDir: node_path.default.resolve(options.mediaOutputDir ?? "public/ox-content/twitter"),
+		mediaPublicPath: options.mediaPublicPath ?? "/ox-content/twitter"
+	};
+}
+async function transformFetchedTweets(html, options) {
+	const resolved = resolveTwitterEmbedOptions$1(options);
+	if (!resolved.fetch) return html;
+	let output = "";
+	let cursor = 0;
+	for (const match of html.matchAll(TWEET_ELEMENT)) {
+		const index = match.index ?? 0;
+		output += html.slice(cursor, index);
+		const reference = referenceFromAttributes(match[2]);
+		if (!reference) {
+			output += match[0];
+			cursor = index + match[0].length;
+			continue;
+		}
+		const data = await fetchTweetData(reference.id, resolved);
+		if (!data) {
+			output += match[0];
+			cursor = index + match[0].length;
+			continue;
+		}
+		const assets = await materializeTweetAssets(reference.id, data, resolved);
+		output += renderFetchedTweet(reference.url, data, assets, resolved);
+		cursor = index + match[0].length;
+	}
+	return output + html.slice(cursor);
+}
+//#endregion
+//#region src/plugins/media.ts
+var media_exports = /* @__PURE__ */ require_vitepress.__exportAll({ transformMediaEmbeds: () => transformMediaEmbeds });
+async function transformMediaEmbeds(html, options) {
+	if (!hasEnabledMediaEmbed(options) || !hasMediaMarker(html)) return html;
+	let result = html;
+	if (typeof options.twitter === "object") result = await transformFetchedTweets(result, options.twitter);
+	if (!hasMediaMarker(result)) return result;
+	return (await require_vitepress.importNapiModule()).transformMediaEmbeds(result, {
+		spotify: options.spotify,
+		stackBlitz: options.stackBlitz,
+		twitter: Boolean(options.twitter),
+		bluesky: options.bluesky,
+		webContainer: options.webContainer
+	});
+}
+function hasEnabledMediaEmbed(options) {
+	return Boolean(options.spotify || options.stackBlitz || options.twitter || options.bluesky || options.webContainer);
+}
+function hasMediaMarker(html) {
+	return /<(spotify|stackblitz|tweet|xpost|bluesky|webcontainer)[\s/>]/i.test(html);
+}
+//#endregion
+//#region src/plugins/github/validation.ts
+const GITHUB_REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+function hasControlChar(value) {
+	for (let index = 0; index < value.length; index++) {
+		const code = value.charCodeAt(index);
+		if (code <= 31 || code === 127) return true;
+	}
+	return false;
+}
+function isSafeGitHubRepo(repo) {
+	return GITHUB_REPO_RE.test(repo) && !repo.split("/").some((part) => part === "." || part === "..");
+}
+function isSafeGitHubRef(ref) {
+	return Boolean(ref) && !hasControlChar(ref) && !hasUnsafePathSegment(ref);
+}
+function isSafeGitHubPath(path) {
+	return Boolean(path) && !hasControlChar(path) && !hasUnsafePathSegment(path);
+}
+function hasUnsafePathSegment(value) {
+	return value.split("/").some((part) => !part || part === "." || part === ".." || part.includes("\\"));
+}
+function encodePath(path) {
+	return path.split("/").map(encodeURIComponent).join("/");
+}
+//#endregion
+//#region src/plugins/github/source.ts
+const EXTENSION_LANGUAGE_MAP = /* @__PURE__ */ new Map([
+	["cjs", "javascript"],
+	["css", "css"],
+	["go", "go"],
+	["html", "html"],
+	["js", "javascript"],
+	["json", "json"],
+	["jsx", "jsx"],
+	["md", "markdown"],
+	["mdx", "mdx"],
+	["mjs", "javascript"],
+	["py", "python"],
+	["rb", "ruby"],
+	["rs", "rust"],
+	["sh", "shell"],
+	["svelte", "svelte"],
+	["toml", "toml"],
+	["ts", "typescript"],
+	["tsx", "tsx"],
+	["vue", "vue"],
+	["yaml", "yaml"],
+	["yml", "yaml"]
+]);
+function sourceKey(source) {
+	return `${source.repo}@${source.ref}:${source.path}`;
+}
+function formatLineRange(lines) {
+	return lines.start === lines.end ? `L${lines.start}` : `L${lines.start}-L${lines.end}`;
+}
+function parseGitHubLineRange(value) {
+	if (!value) return void 0;
+	const match = value.trim().match(/^#?L?(\d+)(?:-L?(\d+))?$/i);
+	if (!match) return void 0;
+	const start = Number.parseInt(match[1], 10);
+	const end = match[2] ? Number.parseInt(match[2], 10) : start;
+	if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 1 || end < start) return;
+	return {
+		start,
+		end
+	};
+}
+function createGitHubPermalink(source) {
+	const fragment = source.lines ? `#${formatLineRange(source.lines)}` : "";
+	return `https://github.com/${source.repo}/blob/${encodeURIComponent(source.ref)}/${encodePath(source.path)}${fragment}`;
+}
+function parseGitHubPermalink(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "https:" || url.hostname !== "github.com") return null;
+	let parts;
+	try {
+		parts = url.pathname.split("/").filter(Boolean).map((part) => decodeURIComponent(part));
+	} catch {
+		return null;
+	}
+	if (parts.length < 5 || parts[2] !== "blob") return null;
+	const repo = `${parts[0]}/${parts[1]}`;
+	const ref = parts[3];
+	const path = parts.slice(4).join("/");
+	if (!isSafeGitHubRepo(repo) || !isSafeGitHubRef(ref) || !isSafeGitHubPath(path)) return null;
+	const source = {
+		repo,
+		ref,
+		path,
+		lines: parseGitHubLineRange(url.hash)
+	};
+	return {
+		...source,
+		permalink: createGitHubPermalink(source)
+	};
+}
+function inferLanguage(path) {
+	const fileName = path.split("/").at(-1)?.toLowerCase() ?? "";
+	if (fileName === "dockerfile") return "dockerfile";
+	if (fileName === "makefile") return "makefile";
+	const extension = fileName.includes(".") ? fileName.split(".").at(-1) : void 0;
+	return extension ? EXTENSION_LANGUAGE_MAP.get(extension) ?? extension : null;
+}
+//#endregion
+//#region src/plugins/github/types.ts
+const defaultOptions$1 = {
+	token: "",
+	cache: true,
+	cacheTTL: 36e5,
+	maxSourceBytes: 2e5,
+	maxSourceLines: 120
+};
+//#endregion
+//#region src/plugins/github/api.ts
+const repoCache = /* @__PURE__ */ new Map();
+const sourceCache = /* @__PURE__ */ new Map();
+function githubHeaders(options) {
+	const headers = {
+		Accept: "application/vnd.github.v3+json",
+		"User-Agent": "ox-content-github-plugin"
+	};
+	if (options.token) headers.Authorization = `Bearer ${options.token}`;
+	return headers;
+}
+/**
+* Fetch repository data from GitHub API.
+*/
+async function fetchRepoData(repo, options) {
+	if (!isSafeGitHubRepo(repo)) return null;
+	if (options.cache) {
+		const cached = repoCache.get(repo);
+		if (cached && Date.now() - cached.timestamp < options.cacheTTL) return cached.data;
+	}
+	try {
+		const response = await fetch(`https://api.github.com/repos/${repo}`, { headers: githubHeaders(options) });
+		if (!response.ok) {
+			console.warn(`Failed to fetch GitHub repo ${repo}: ${response.status}`);
+			return null;
+		}
+		const data = await response.json();
+		if (options.cache) repoCache.set(repo, {
+			data,
+			timestamp: Date.now()
+		});
+		return data;
+	} catch (error) {
+		console.warn(`Error fetching GitHub repo ${repo}:`, error);
+		return null;
+	}
+}
+/**
+* Fetch source file data from GitHub API.
+*/
+async function fetchGitHubSource(source, options) {
+	if (!isSafeGitHubRepo(source.repo) || !isSafeGitHubRef(source.ref) || !isSafeGitHubPath(source.path)) return null;
+	const key = sourceKey(source);
+	if (options.cache) {
+		const cached = sourceCache.get(key);
+		if (cached && Date.now() - cached.timestamp < options.cacheTTL) return cached.data;
+	}
+	try {
+		const apiUrl = `https://api.github.com/repos/${source.repo}/contents/${encodePath(source.path)}?ref=${encodeURIComponent(source.ref)}`;
+		const response = await fetch(apiUrl, { headers: githubHeaders(options) });
+		if (!response.ok) {
+			console.warn(`Failed to fetch GitHub source ${source.permalink}: ${response.status}`);
+			return null;
+		}
+		const data = await response.json();
+		if (data.type !== "file" || data.encoding !== "base64" || !data.content || (data.size ?? 0) > options.maxSourceBytes) return null;
+		const content = node_buffer.Buffer.from(data.content.replace(/\s/g, ""), "base64").toString("utf8");
+		if (node_buffer.Buffer.byteLength(content) > options.maxSourceBytes) return null;
+		const sourceData = {
+			repo: source.repo,
+			ref: source.ref,
+			path: source.path,
+			permalink: source.permalink,
+			content,
+			size: data.size ?? node_buffer.Buffer.byteLength(content),
+			html_url: data.html_url ?? source.permalink,
+			language: inferLanguage(source.path)
+		};
+		if (options.cache) sourceCache.set(key, {
+			data: sourceData,
+			timestamp: Date.now()
+		});
+		return sourceData;
+	} catch (error) {
+		console.warn(`Error fetching GitHub source ${source.permalink}:`, error);
+		return null;
+	}
+}
+/**
+* Pre-fetch all GitHub repos data.
+*/
+async function prefetchGitHubRepos(repos, options) {
+	const mergedOptions = {
+		...defaultOptions$1,
+		...options
+	};
+	const results = /* @__PURE__ */ new Map();
+	await Promise.all(Array.from(new Set(repos)).map(async (repo) => {
+		const data = await fetchRepoData(repo, mergedOptions);
+		results.set(repo, data);
+	}));
+	return results;
+}
+/**
+* Pre-fetch all GitHub source files.
+*/
+async function prefetchGitHubSources(sources, options) {
+	const mergedOptions = {
+		...defaultOptions$1,
+		...options
+	};
+	const results = /* @__PURE__ */ new Map();
+	const uniqueSources = Array.from(new Map(sources.map((source) => [sourceKey(source), source])).values());
+	await Promise.all(uniqueSources.map(async (source) => {
+		const data = await fetchGitHubSource(source, mergedOptions);
+		results.set(sourceKey(source), data);
+	}));
+	return results;
+}
+//#endregion
+//#region src/plugins/github/attributes.ts
+const GITHUB_COMPONENT_RE = /<github\b([^>]*)>/gi;
+const ATTRIBUTE_RE = /([:\w-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>/]+)))?/g;
+/**
+* Collect all GitHub repos from HTML for pre-fetching.
+*/
+async function collectGitHubRepos(html) {
+	const repos = [];
+	GITHUB_COMPONENT_RE.lastIndex = 0;
+	let match;
+	while ((match = GITHUB_COMPONENT_RE.exec(html)) !== null) {
+		const attrs = parseAttributes(match[1]);
+		if (attrs.path || attrs.file || attrs.permalink || attrs.url || attrs.href) continue;
+		const repo = attrs.repo;
+		if (repo && isSafeGitHubRepo(repo)) repos.push(repo);
+	}
+	return repos;
+}
+/**
+* Collect all GitHub source references from HTML for pre-fetching.
+*/
+async function collectGitHubSources(html) {
+	const sources = [];
+	GITHUB_COMPONENT_RE.lastIndex = 0;
+	let match;
+	while ((match = GITHUB_COMPONENT_RE.exec(html)) !== null) {
+		const source = sourceRefFromAttributes(parseAttributes(match[1]));
+		if (source) sources.push(source);
+	}
+	return sources;
+}
+function parseAttributes(raw) {
+	const attrs = {};
+	ATTRIBUTE_RE.lastIndex = 0;
+	let match;
+	while ((match = ATTRIBUTE_RE.exec(raw)) !== null) attrs[match[1].toLowerCase()] = match[2] ?? match[3] ?? match[4] ?? "";
+	return attrs;
+}
+function attributesFromElement(el) {
+	const attrs = {};
+	for (const name of [
+		"permalink",
+		"url",
+		"href",
+		"repo",
+		"path",
+		"file",
+		"ref",
+		"sha",
+		"branch",
+		"loc",
+		"lines",
+		"line"
+	]) {
+		const value = getAttribute$2(el, name);
+		if (value !== void 0) attrs[name] = value;
+	}
+	return attrs;
+}
+function getAttribute$2(el, name) {
+	const value = el.properties?.[name];
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.join(" ");
+}
+function sourceRefFromAttributes(attrs) {
+	const permalink = attrs.permalink ?? attrs.url ?? attrs.href;
+	if (permalink) return parseGitHubPermalink(permalink);
+	const repo = attrs.repo;
+	const path = attrs.path ?? attrs.file;
+	if (!repo || !path || !isSafeGitHubRepo(repo) || !isSafeGitHubPath(path)) return null;
+	const ref = attrs.ref ?? attrs.sha ?? attrs.branch ?? "main";
+	if (!isSafeGitHubRef(ref)) return null;
+	const source = {
+		repo,
+		ref,
+		path,
+		lines: parseGitHubLineRange(attrs.loc ?? attrs.lines ?? attrs.line)
+	};
+	return {
+		...source,
+		permalink: createGitHubPermalink(source)
+	};
+}
+//#endregion
+//#region src/plugins/github/fallback-card.ts
+/**
+* Create fallback element when repo data is unavailable.
+*/
+function createFallbackCard$1(repo) {
+	return {
+		type: "element",
+		tagName: "a",
+		properties: {
+			className: ["ox-github-card", "error"],
+			href: isSafeGitHubRepo(repo) ? `https://github.com/${repo}` : "#",
+			target: "_blank",
+			rel: "noopener noreferrer"
+		},
+		children: [{
+			type: "element",
+			tagName: "div",
+			properties: { className: ["ox-github-header"] },
+			children: [{
+				type: "element",
+				tagName: "svg",
+				properties: {
+					className: ["ox-github-icon"],
+					viewBox: "0 0 16 16",
+					fill: "currentColor"
+				},
+				children: [{
+					type: "element",
+					tagName: "path",
+					properties: { d: "M8 0c4.42 0 8 3.58 8 8a8.013 8.013 0 0 1-5.45 7.59c-.4.08-.55-.17-.55-.38 0-.27.01-1.13.01-2.2 0-.75-.25-1.23-.54-1.48 1.78-.2 3.65-.88 3.65-3.95 0-.88-.31-1.59-.82-2.15.08-.2.36-1.02-.08-2.12 0 0-.67-.22-2.2.82-.64-.18-1.32-.27-2-.27-.68 0-1.36.09-2 .27-1.53-1.03-2.2-.82-2.2-.82-.44 1.1-.16 1.92-.08 2.12-.51.56-.82 1.28-.82 2.15 0 3.06 1.86 3.75 3.64 3.95-.23.2-.44.55-.51 1.07-.46.21-1.61.55-2.33-.66-.15-.24-.6-.83-1.23-.82-.67.01-.27.38.01.53.34.19.73.9.82 1.13.16.45.68 1.31 2.69.94 0 .67.01 1.3.01 1.49 0 .21-.15.45-.55.38A7.995 7.995 0 0 1 0 8c0-4.42 3.58-8 8-8Z" },
+					children: []
+				}]
+			}, {
+				type: "element",
+				tagName: "span",
+				properties: { className: ["ox-github-repo"] },
+				children: [{
+					type: "text",
+					value: repo
+				}]
+			}]
+		}]
+	};
+}
+//#endregion
+//#region src/plugins/github/repo-card.ts
+function formatNumber(num) {
+	if (num >= 1e6) return `${(num / 1e6).toFixed(1)}M`;
+	if (num >= 1e3) return `${(num / 1e3).toFixed(1)}k`;
+	return String(num);
+}
+function iconPath(d) {
+	return {
+		type: "element",
+		tagName: "svg",
+		properties: {
+			viewBox: "0 0 16 16",
+			fill: "currentColor"
+		},
+		children: [{
+			type: "element",
+			tagName: "path",
+			properties: { d },
+			children: []
+		}]
+	};
+}
+function createStatsChildren(repoData) {
+	const statsChildren = [];
+	if (repoData.language) statsChildren.push({
+		type: "element",
+		tagName: "span",
+		properties: { className: ["ox-github-language"] },
+		children: [{
+			type: "element",
+			tagName: "span",
+			properties: {
+				className: ["ox-github-language-color"],
+				"data-lang": repoData.language.toLowerCase()
+			},
+			children: []
+		}, {
+			type: "text",
+			value: repoData.language
+		}]
+	});
+	statsChildren.push({
+		type: "element",
+		tagName: "span",
+		properties: { className: ["ox-github-stat"] },
+		children: [iconPath("M8 .25a.75.75 0 0 1 .673.418l1.882 3.815 4.21.612a.75.75 0 0 1 .416 1.279l-3.046 2.97.719 4.192a.751.751 0 0 1-1.088.791L8 12.347l-3.766 1.98a.75.75 0 0 1-1.088-.79l.72-4.194L.818 6.374a.75.75 0 0 1 .416-1.28l4.21-.611L7.327.668A.75.75 0 0 1 8 .25Z"), {
+			type: "text",
+			value: formatNumber(repoData.stargazers_count)
+		}]
+	});
+	statsChildren.push({
+		type: "element",
+		tagName: "span",
+		properties: { className: ["ox-github-stat"] },
+		children: [iconPath("M5 5.372v.878c0 .414.336.75.75.75h4.5a.75.75 0 0 0 .75-.75v-.878a2.25 2.25 0 1 1 1.5 0v.878a2.25 2.25 0 0 1-2.25 2.25h-1.5v2.128a2.251 2.251 0 1 1-1.5 0V8.5h-1.5A2.25 2.25 0 0 1 3.5 6.25v-.878a2.25 2.25 0 1 1 1.5 0ZM5 3.25a.75.75 0 1 0-1.5 0 .75.75 0 0 0 1.5 0Zm6.75.75a.75.75 0 1 0 0-1.5.75.75 0 0 0 0 1.5Zm-3 8.75a.75.75 0 1 0-1.5 0 .75.75 0 0 0 1.5 0Z"), {
+			type: "text",
+			value: formatNumber(repoData.forks_count)
+		}]
+	});
+	return statsChildren;
+}
+/**
+* Create GitHub card element from repo data.
+*/
+function createGitHubCard(repoData) {
+	return {
+		type: "element",
+		tagName: "a",
+		properties: {
+			className: ["ox-github-card"],
+			href: repoData.html_url,
+			target: "_blank",
+			rel: "noopener noreferrer"
+		},
+		children: [
+			{
+				type: "element",
+				tagName: "div",
+				properties: { className: ["ox-github-header"] },
+				children: [{
+					...iconPath("M2 2.5A2.5 2.5 0 0 1 4.5 0h8.75a.75.75 0 0 1 .75.75v12.5a.75.75 0 0 1-.75.75h-2.5a.75.75 0 0 1 0-1.5h1.75v-2h-8a1 1 0 0 0-.714 1.7.75.75 0 1 1-1.072 1.05A2.495 2.495 0 0 1 2 11.5Zm10.5-1h-8a1 1 0 0 0-1 1v6.708A2.486 2.486 0 0 1 4.5 9h8ZM5 12.25a.25.25 0 0 1 .25-.25h3.5a.25.25 0 0 1 .25.25v3.25a.25.25 0 0 1-.4.2l-1.45-1.087a.249.249 0 0 0-.3 0L5.4 15.7a.25.25 0 0 1-.4-.2Z"),
+					properties: {
+						className: ["ox-github-icon"],
+						viewBox: "0 0 16 16",
+						fill: "currentColor"
+					}
+				}, {
+					type: "element",
+					tagName: "span",
+					properties: { className: ["ox-github-repo"] },
+					children: [{
+						type: "text",
+						value: repoData.full_name
+					}]
+				}]
+			},
+			...repoData.description ? [{
+				type: "element",
+				tagName: "p",
+				properties: { className: ["ox-github-description"] },
+				children: [{
+					type: "text",
+					value: repoData.description
+				}]
+			}] : [],
+			{
+				type: "element",
+				tagName: "div",
+				properties: { className: ["ox-github-stats"] },
+				children: createStatsChildren(repoData)
+			}
+		]
+	};
+}
+//#endregion
+//#region src/plugins/github/source-card.ts
+function normalizeSourceLines(content) {
+	const lines = content.replace(/\r\n?/g, "\n").split("\n");
+	if (lines.length > 1 && lines.at(-1) === "") lines.pop();
+	return lines.length > 0 ? lines : [""];
+}
+function createGitHubSourceCard(source, lines, options) {
+	const allLines = normalizeSourceLines(source.content);
+	const start = Math.min(lines?.start ?? 1, allLines.length);
+	const end = lines ? Math.min(lines.end, allLines.length) : Math.min(allLines.length, options.maxSourceLines);
+	const selectedLines = allLines.slice(start - 1, end);
+	const lineRange = {
+		start,
+		end
+	};
+	const loc = selectedLines.length;
+	const rangeLabel = formatLineRange(lineRange);
+	const locLabel = !lines && end < allLines.length ? `${rangeLabel} of ${allLines.length} LOC` : `${rangeLabel} - ${loc} LOC`;
+	const languageClass = source.language ? [`language-${source.language}`] : [];
+	return {
+		type: "element",
+		tagName: "figure",
+		properties: {
+			className: ["ox-github-code"],
+			"data-loc": String(loc),
+			"data-source": source.permalink
+		},
+		children: [{
+			type: "element",
+			tagName: "figcaption",
+			properties: { className: ["ox-github-code-header"] },
+			children: [{
+				type: "element",
+				tagName: "a",
+				properties: {
+					className: ["ox-github-code-title"],
+					href: source.permalink,
+					target: "_blank",
+					rel: "noopener noreferrer"
+				},
+				children: [{
+					type: "text",
+					value: `${source.repo}/${source.path}`
+				}]
+			}, {
+				type: "element",
+				tagName: "span",
+				properties: { className: ["ox-github-code-loc"] },
+				children: [{
+					type: "text",
+					value: locLabel
+				}]
+			}]
+		}, {
+			type: "element",
+			tagName: "pre",
+			properties: {
+				className: ["ox-github-code-block", ...languageClass],
+				...source.language ? { "data-language": source.language } : {}
+			},
+			children: [{
+				type: "element",
+				tagName: "code",
+				properties: { className: languageClass },
+				children: selectedLines.map((line, index) => {
+					const lineNumber = start + index;
+					return {
+						type: "element",
+						tagName: "span",
+						properties: {
+							className: ["line", "ox-github-code-line"],
+							"data-line": String(lineNumber)
+						},
+						children: [{
+							type: "element",
+							tagName: "span",
+							properties: { className: ["ox-github-code-line-number"] },
+							children: [{
+								type: "text",
+								value: String(lineNumber)
+							}]
+						}, {
+							type: "element",
+							tagName: "span",
+							properties: { className: ["ox-github-code-line-content"] },
+							children: [{
+								type: "text",
+								value: line || " "
+							}]
+						}]
+					};
+				})
+			}]
+		}]
+	};
+}
+//#endregion
+//#region src/plugins/github/transform.ts
+const rehypeParse$2 = require_interop.interopDefault(rehype_parse.default);
+const rehypeStringify$2 = require_interop.interopDefault(rehype_stringify.default);
+/**
+* Rehype plugin to transform GitHub components.
+*/
+function rehypeGitHub(repoDataMap, sourceDataMap, options) {
+	return (tree) => {
+		const visit = (node) => {
+			if ("children" in node) for (let i = 0; i < node.children.length; i++) {
+				const child = node.children[i];
+				if (child.type !== "element") continue;
+				if (child.tagName.toLowerCase() !== "github") {
+					visit(child);
+					continue;
+				}
+				const attrs = attributesFromElement(child);
+				const source = sourceRefFromAttributes(attrs);
+				if (source) {
+					const sourceData = sourceDataMap.get(sourceKey(source));
+					node.children[i] = sourceData ? createGitHubSourceCard(sourceData, source.lines, options) : createFallbackCard$1(source.permalink);
+					continue;
+				}
+				const repo = attrs.repo;
+				if (repo) {
+					const repoData = repoDataMap.get(repo);
+					node.children[i] = repoData ? createGitHubCard(repoData) : createFallbackCard$1(repo);
+				}
+			}
+		};
+		visit(tree);
+	};
+}
+/**
+* Transform GitHub components in HTML.
+*/
+async function transformGitHub(html, repoDataMap, options) {
+	const mergedOptions = {
+		...defaultOptions$1,
+		...options
+	};
+	let dataMap = repoDataMap;
+	if (!dataMap) dataMap = await prefetchGitHubRepos(await collectGitHubRepos(html), mergedOptions);
+	const sourceDataMap = await prefetchGitHubSources(await collectGitHubSources(html), mergedOptions);
+	const result = await (0, unified.unified)().use(rehypeParse$2, { fragment: true }).use(rehypeGitHub, dataMap, sourceDataMap, mergedOptions).use(rehypeStringify$2).process(html);
+	return String(result);
+}
+//#endregion
+//#region src/plugins/github.ts
+var github_exports = /* @__PURE__ */ require_vitepress.__exportAll({ transformGitHub: () => transformGitHub });
+//#endregion
+//#region src/plugins/ogp.ts
+/**
+* OGP Card Plugin - Link card embedding
+*
+* Transforms <OgCard> components into static link preview cards
+* by fetching OGP metadata at build time.
+*/
+var ogp_exports = /* @__PURE__ */ require_vitepress.__exportAll({
+	collectOgpUrls: () => collectOgpUrls,
+	fetchOgpData: () => fetchOgpData,
+	isSafeOgpUrl: () => isSafeOgpUrl,
+	prefetchOgpData: () => prefetchOgpData,
+	transformOgp: () => transformOgp
+});
+const rehypeParse$1 = require_interop.interopDefault(rehype_parse.default);
+const rehypeStringify$1 = require_interop.interopDefault(rehype_stringify.default);
+const defaultOptions = {
+	timeout: 1e4,
+	cache: true,
+	cacheTTL: 36e5,
+	userAgent: "ox-content-ogp-bot/1.0 (compatible; +https://github.com/ubugeeei-prod/ox-content)"
+};
+const ogpCache = /* @__PURE__ */ new Map();
+function isPrivateIPv4(hostname) {
+	const parts = hostname.split(".").map(Number);
+	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return false;
+	const [a, b] = parts;
+	return a === 10 || a === 127 || a === 0 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 169 && b === 254;
+}
+function isSafeOgpUrl(value) {
+	try {
+		const url = new URL(value);
+		const host = url.hostname.toLowerCase();
+		const ipv6 = host.replace(/^\[|\]$/g, "");
+		if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+		if (host === "localhost" || host.endsWith(".localhost")) return false;
+		if (ipv6.includes(":") && (ipv6 === "::1" || ipv6.startsWith("fc") || ipv6.startsWith("fd") || ipv6.startsWith("fe80"))) return false;
+		return !isPrivateIPv4(host);
+	} catch {
+		return false;
+	}
+}
+/**
+* Get element attribute value.
+*/
+function getAttribute$1(el, name) {
+	const value = el.properties?.[name];
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.join(" ");
+}
+/**
+* Extract domain from URL.
+*/
+function extractDomain(url) {
+	try {
+		return new URL(url).hostname;
+	} catch {
+		return url;
+	}
+}
+/**
+* Get favicon URL for a domain.
+*/
+function getFaviconUrl(url) {
+	try {
+		return `https://www.google.com/s2/favicons?domain=${new URL(url).hostname}&sz=32`;
+	} catch {
+		return "";
+	}
+}
+/**
+* Parse OGP metadata from HTML.
+*/
+function parseOgpFromHtml(html, url) {
+	const result = {
+		url,
+		title: ""
+	};
+	const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+	result.title = (html.match(/<meta[^>]*property=["']og:title["'][^>]*content=["']([^"']+)["']/i) || html.match(/<meta[^>]*content=["']([^"']+)["'][^>]*property=["']og:title["']/i))?.[1] || titleMatch?.[1] || extractDomain(url);
+	const descMatch = html.match(/<meta[^>]*property=["']og:description["'][^>]*content=["']([^"']+)["']/i) || html.match(/<meta[^>]*content=["']([^"']+)["'][^>]*property=["']og:description["']/i) || html.match(/<meta[^>]*name=["']description["'][^>]*content=["']([^"']+)["']/i) || html.match(/<meta[^>]*content=["']([^"']+)["'][^>]*name=["']description["']/i);
+	if (descMatch) result.description = descMatch[1];
+	const imageMatch = html.match(/<meta[^>]*property=["']og:image["'][^>]*content=["']([^"']+)["']/i) || html.match(/<meta[^>]*content=["']([^"']+)["'][^>]*property=["']og:image["']/i);
+	if (imageMatch) {
+		let imageUrl = imageMatch[1];
+		if (imageUrl.startsWith("/")) try {
+			const urlObj = new URL(url);
+			imageUrl = `${urlObj.protocol}//${urlObj.host}${imageUrl}`;
+		} catch {}
+		result.image = imageUrl;
+	}
+	const siteNameMatch = html.match(/<meta[^>]*property=["']og:site_name["'][^>]*content=["']([^"']+)["']/i) || html.match(/<meta[^>]*content=["']([^"']+)["'][^>]*property=["']og:site_name["']/i);
+	if (siteNameMatch) result.siteName = siteNameMatch[1];
+	result.favicon = getFaviconUrl(url);
+	return result;
+}
+/**
+* Fetch OGP data for a URL.
+*/
+async function fetchOgpData(url, options) {
+	if (!isSafeOgpUrl(url)) return null;
+	if (options.cache) {
+		const cached = ogpCache.get(url);
+		if (cached && Date.now() - cached.timestamp < options.cacheTTL) return cached.data;
+	}
+	try {
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), options.timeout);
+		const response = await fetch(url, {
+			headers: {
+				"User-Agent": options.userAgent,
+				Accept: "text/html,application/xhtml+xml"
+			},
+			signal: controller.signal
+		});
+		clearTimeout(timeoutId);
+		if (!response.ok) {
+			console.warn(`Failed to fetch OGP for ${url}: ${response.status}`);
+			return null;
+		}
+		const data = parseOgpFromHtml(await response.text(), url);
+		if (options.cache) ogpCache.set(url, {
+			data,
+			timestamp: Date.now()
+		});
+		return data;
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") console.warn(`Timeout fetching OGP for ${url}`);
+		else console.warn(`Error fetching OGP for ${url}:`, error);
+		return null;
+	}
+}
+/**
+* Create OGP card element.
+*/
+function createOgpCard(data) {
+	const children = [];
+	const contentChildren = [];
+	contentChildren.push({
+		type: "element",
+		tagName: "div",
+		properties: { className: ["ox-ogp-title"] },
+		children: [{
+			type: "text",
+			value: data.title
+		}]
+	});
+	if (data.description) contentChildren.push({
+		type: "element",
+		tagName: "div",
+		properties: { className: ["ox-ogp-description"] },
+		children: [{
+			type: "text",
+			value: data.description
+		}]
+	});
+	const metaChildren = [];
+	if (data.favicon) metaChildren.push({
+		type: "element",
+		tagName: "img",
+		properties: {
+			className: ["ox-ogp-favicon"],
+			src: data.favicon,
+			alt: "",
+			loading: "lazy"
+		},
+		children: []
+	});
+	metaChildren.push({
+		type: "element",
+		tagName: "span",
+		properties: { className: ["ox-ogp-domain"] },
+		children: [{
+			type: "text",
+			value: data.siteName || extractDomain(data.url)
+		}]
+	});
+	contentChildren.push({
+		type: "element",
+		tagName: "div",
+		properties: { className: ["ox-ogp-meta"] },
+		children: metaChildren
+	});
+	children.push({
+		type: "element",
+		tagName: "div",
+		properties: { className: ["ox-ogp-content"] },
+		children: contentChildren
+	});
+	if (data.image) children.push({
+		type: "element",
+		tagName: "img",
+		properties: {
+			className: ["ox-ogp-image"],
+			src: data.image,
+			alt: "",
+			loading: "lazy"
+		},
+		children: []
+	});
+	return {
+		type: "element",
+		tagName: "a",
+		properties: {
+			className: ["ox-ogp-card"],
+			href: isSafeOgpUrl(data.url) ? data.url : "#",
+			target: "_blank",
+			rel: "noopener noreferrer"
+		},
+		children
+	};
+}
+/**
+* Create fallback element when OGP data is unavailable.
+*/
+function createFallbackCard(url) {
+	return {
+		type: "element",
+		tagName: "a",
+		properties: {
+			className: ["ox-ogp-simple"],
+			href: isSafeOgpUrl(url) ? url : "#",
+			target: "_blank",
+			rel: "noopener noreferrer"
+		},
+		children: [{
+			type: "element",
+			tagName: "svg",
+			properties: {
+				viewBox: "0 0 24 24",
+				fill: "none",
+				stroke: "currentColor",
+				"stroke-width": "2"
+			},
+			children: [{
+				type: "element",
+				tagName: "path",
+				properties: { d: "M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6M15 3h6v6M10 14L21 3" },
+				children: []
+			}]
+		}, {
+			type: "text",
+			value: extractDomain(url)
+		}]
+	};
+}
+/**
+* Collect all OGP URLs from HTML for pre-fetching.
+*/
+async function collectOgpUrls(html) {
+	const urls = [];
+	const urlPattern = /<ogcard[^>]*\s+url=["']([^"']+)["']/gi;
+	let match;
+	while ((match = urlPattern.exec(html)) !== null) if (isSafeOgpUrl(match[1])) urls.push(match[1]);
+	return urls;
+}
+/**
+* Pre-fetch all OGP data.
+*/
+async function prefetchOgpData(urls, options) {
+	const mergedOptions = {
+		...defaultOptions,
+		...options
+	};
+	const results = /* @__PURE__ */ new Map();
+	await Promise.all(urls.map(async (url) => {
+		const data = await fetchOgpData(url, mergedOptions);
+		results.set(url, data);
+	}));
+	return results;
+}
+/**
+* Rehype plugin to transform OgCard components.
+*/
+function rehypeOgp(ogpDataMap) {
+	return (tree) => {
+		const visit = (node) => {
+			if ("children" in node) for (let i = 0; i < node.children.length; i++) {
+				const child = node.children[i];
+				if (child.type === "element") if (child.tagName.toLowerCase() === "ogcard") {
+					const url = getAttribute$1(child, "url");
+					if (url) {
+						const ogpData = ogpDataMap.get(url);
+						const cardElement = ogpData ? createOgpCard(ogpData) : createFallbackCard(url);
+						node.children[i] = cardElement;
+					}
+				} else visit(child);
+			}
+		};
+		visit(tree);
+	};
+}
+/**
+* Transform OgCard components in HTML.
+*/
+async function transformOgp(html, ogpDataMap, options) {
+	let dataMap = ogpDataMap;
+	if (!dataMap) dataMap = await prefetchOgpData(await collectOgpUrls(html), options);
+	const result = await (0, unified.unified)().use(rehypeParse$1, { fragment: true }).use(rehypeOgp, dataMap).use(rehypeStringify$1).process(html);
 	return String(result);
 }
 //#endregion
 //#region src/plugins/index.ts
+const SELF_CLOSING_EMBED_TAG = /<(GitHub|OgCard|Tweet|XPost|Bluesky|Spotify|StackBlitz|WebContainer|YouTube)((?:[^>"']|"[^"]*"|'[^']*')*?)\s*\/>/gi;
+/**
+* Custom embed tags are not HTML void elements, so a self-closing authoring
+* form like `<GitHub ... />` reaches the HTML re-parsers (Shiki highlighting,
+* embed transforms) as an unclosed element that swallows the rest of the
+* document. Normalize to an explicit open/close pair before any rehype pass
+* runs.
+*/
+function normalizeSelfClosingEmbeds(html) {
+	return html.replace(SELF_CLOSING_EMBED_TAG, (_match, tag, attrs) => {
+		return `<${tag}${attrs}></${tag}>`;
+	});
+}
 /**
 * Transform all enabled plugins in HTML content.
 */
 async function transformAllPlugins(html, options = {}) {
 	const { tabs = true, pm = false, youtube = true, github = true, ogp, openGraph, mermaid = true, githubToken, spotify = false, stackBlitz = false, twitter = false, bluesky = false, webContainer = false } = options;
-	let result = html;
+	let result = normalizeSelfClosingEmbeds(html);
 	const ogpOptions = openGraph ?? ogp ?? true;
 	if (tabs) {
 		const { transformTabs } = await Promise.resolve().then(() => require("./tabs.cjs")).then((n) => n.tabs_exports);
 		result = await transformTabs(result);
 	}
 	if (pm) {
-		const { transformPm } = await Promise.resolve().then(() => require("./pm.cjs")).then((n) => n.pm_exports);
+		const { transformPm } = await Promise.resolve().then(() => pm_exports);
 		result = await transformPm(result, typeof pm === "object" ? pm : {});
 	}
 	if (youtube) {
-		const { transformYouTube } = await Promise.resolve().then(() => require("./youtube.cjs")).then((n) => n.youtube_exports);
+		const { transformYouTube } = await Promise.resolve().then(() => youtube_exports);
 		result = await transformYouTube(result);
 	}
 	if (github !== false) {
-		const { transformGitHub } = await Promise.resolve().then(() => require("./github.cjs")).then((n) => n.github_exports);
+		const { transformGitHub } = await Promise.resolve().then(() => github_exports);
 		result = await transformGitHub(result, void 0, {
 			token: githubToken,
 			...typeof github === "object" ? github : {}
 		});
 	}
 	if (ogpOptions !== false) {
-		const { transformOgp } = await Promise.resolve().then(() => require("./ogp.cjs")).then((n) => n.ogp_exports);
+		const { transformOgp } = await Promise.resolve().then(() => ogp_exports);
 		result = await transformOgp(result, void 0, typeof ogpOptions === "object" ? ogpOptions : {});
 	}
 	const mediaOptions = {
@@ -322,11 +1707,11 @@ async function transformAllPlugins(html, options = {}) {
 		webContainer
 	};
 	if (Object.values(mediaOptions).some(Boolean)) {
-		const { transformMediaEmbeds } = await Promise.resolve().then(() => require("./media.cjs")).then((n) => n.media_exports);
+		const { transformMediaEmbeds } = await Promise.resolve().then(() => media_exports);
 		result = await transformMediaEmbeds(result, mediaOptions);
 	}
 	if (mermaid) {
-		const { transformMermaidStatic } = await Promise.resolve().then(() => require("./mermaid.cjs")).then((n) => n.mermaid_exports);
+		const { transformMermaidStatic } = await Promise.resolve().then(() => mermaid_exports);
 		result = await transformMermaidStatic(result);
 	}
 	return result;
@@ -335,20 +1720,20 @@ async function transformAllPlugins(html, options = {}) {
 * Transform built-in embed components in HTML content.
 */
 async function transformBuiltinEmbeds(html, options) {
-	let result = html;
+	let result = normalizeSelfClosingEmbeds(html);
 	if (options.github) {
-		const { transformGitHub } = await Promise.resolve().then(() => require("./github.cjs")).then((n) => n.github_exports);
+		const { transformGitHub } = await Promise.resolve().then(() => github_exports);
 		result = await transformGitHub(result, void 0, {
 			token: process.env.GITHUB_TOKEN,
 			...options.github
 		});
 	}
 	if (options.openGraph) {
-		const { transformOgp } = await Promise.resolve().then(() => require("./ogp.cjs")).then((n) => n.ogp_exports);
+		const { transformOgp } = await Promise.resolve().then(() => ogp_exports);
 		result = await transformOgp(result, void 0, options.openGraph);
 	}
 	if (options.pm) {
-		const { transformPm } = await Promise.resolve().then(() => require("./pm.cjs")).then((n) => n.pm_exports);
+		const { transformPm } = await Promise.resolve().then(() => pm_exports);
 		result = await transformPm(result, typeof options.pm === "object" ? options.pm : {});
 	}
 	const mediaOptions = {
@@ -359,7 +1744,7 @@ async function transformBuiltinEmbeds(html, options) {
 		webContainer: options.webContainer
 	};
 	if (Object.values(mediaOptions).some(Boolean)) {
-		const { transformMediaEmbeds } = await Promise.resolve().then(() => require("./media.cjs")).then((n) => n.media_exports);
+		const { transformMediaEmbeds } = await Promise.resolve().then(() => media_exports);
 		result = await transformMediaEmbeds(result, mediaOptions);
 	}
 	return result;
@@ -422,10 +1807,10 @@ function restoreMermaidSvgs(html, svgs) {
 //#region src/code-blocks.ts
 const execFileAsync = (0, node_util.promisify)(node_child_process.execFile);
 async function extractCodeBlocks(source) {
-	return (await require_napi.importNapiModule()).extractCodeBlocks(source).map(normalizeBlock);
+	return (await require_vitepress.importNapiModule()).extractCodeBlocks(source).map(normalizeBlock);
 }
 async function lintCodeBlocks(source, options = {}) {
-	return (await require_napi.importNapiModule()).lintCodeBlocks(source, {
+	return (await require_vitepress.importNapiModule()).lintCodeBlocks(source, {
 		enabled: true,
 		languages: options.languages,
 		requireLanguage: options.requireLanguage,
@@ -433,7 +1818,7 @@ async function lintCodeBlocks(source, options = {}) {
 	}).map(normalizeDiagnostic);
 }
 async function extractDocsTests(source, options = {}) {
-	return (await require_napi.importNapiModule()).extractDocsTests(source, {
+	return (await require_vitepress.importNapiModule()).extractDocsTests(source, {
 		enabled: true,
 		languages: options.languages,
 		requireMeta: options.requireMeta
@@ -451,7 +1836,8 @@ async function typecheckCodeBlocks(source, options = {}) {
 	try {
 		const files = [];
 		await Promise.all(blocks.map(async (block, index) => {
-			const file = (0, node_path.join)(temp, `snippet-${index}.${block.language.toLowerCase() === "tsx" ? "tsx" : "ts"}`);
+			const extension = block.language.toLowerCase() === "tsx" ? "tsx" : "ts";
+			const file = (0, node_path.join)(temp, `snippet-${index}.${extension}`);
 			files.push(file);
 			await (0, node_fs_promises.writeFile)(file, block.code);
 		}));
@@ -463,7 +1849,7 @@ async function typecheckCodeBlocks(source, options = {}) {
 				...files
 			], {
 				cwd: process.cwd(),
-				maxBuffer: 1024 * 1024 * 4
+				maxBuffer: 4194304
 			});
 			return [];
 		} catch (error) {
@@ -561,7 +1947,7 @@ async function loadNapiBindings() {
 	if (napiLoadAttempted) return napiBindings ?? null;
 	napiLoadAttempted = true;
 	try {
-		const mod = await require_napi.importNapiModule();
+		const mod = await require_vitepress.importNapiModule();
 		napiBindings = mod;
 		return mod;
 	} catch (error) {
@@ -616,10 +2002,10 @@ async function transformMarkdown(source, filePath, options, ssgOptions) {
 		} : void 0
 	});
 	if (result.errors.length > 0) console.warn("[ox-content] Transform warnings:", result.errors);
-	let html = result.html;
+	let html = normalizeSelfClosingEmbeds(result.html);
 	const frontmatter = parseFrontmatterJson(result.frontmatter);
 	const toc = options.toc ? result.toc.map(normalizeTocEntry) : [];
-	if (options.mermaid) html = await require_mermaid.transformMermaidStatic(html);
+	if (options.mermaid) html = await transformMermaidStatic(html);
 	const { html: protectedHtml, svgs } = protectMermaidSvgs(html);
 	html = protectedHtml;
 	if (options.highlight) {
@@ -815,7 +2201,7 @@ const DEFAULT_DOCS_INCLUDE = [
 * ```
 */
 async function extractDocs(srcDirs, options) {
-	const napi = await require_napi.importNapiModule();
+	const napi = await require_vitepress.importNapiModule();
 	if (options.entryPoints?.length) {
 		const extractDocsFromEntryPoints = napi.extractDocsFromEntryPoints;
 		if (!extractDocsFromEntryPoints) throw new Error("[ox-content] extractDocsFromEntryPoints is not available from @ox-content/napi.");
@@ -844,7 +2230,7 @@ async function extractDocs(srcDirs, options) {
 * Generates Markdown documentation from extracted docs.
 */
 function generateMarkdown(docs, options) {
-	const napi = require_napi.importNapiModuleSync();
+	const napi = require_vitepress.importNapiModuleSync();
 	if (typeof napi.generateDocsMarkdown !== "function") throw new Error("[ox-content] generateDocsMarkdown is not available from @ox-content/napi. Please rebuild the NAPI package.");
 	return napi.generateDocsMarkdown(toRustDocsModules(docs), {
 		groupBy: options.groupBy,
@@ -874,7 +2260,7 @@ function generateMarkdown(docs, options) {
 * Writes generated documentation to the output directory.
 */
 async function writeDocs(docs, outDir, extractedDocs, options) {
-	const napi = require_napi.importNapiModuleSync();
+	const napi = require_vitepress.importNapiModuleSync();
 	if (typeof napi.writeGeneratedDocs !== "function") throw new Error("[ox-content] writeGeneratedDocs is not available from @ox-content/napi. Please rebuild the NAPI package.");
 	napi.writeGeneratedDocs(docs, outDir, extractedDocs ? toRustDocsModules(extractedDocs) : void 0, {
 		generateNav: options?.generateNav ?? false,
@@ -1171,7 +2557,7 @@ function getDefaultTemplate() {
 		const { title, description, siteName } = props;
 		const rawBrand = siteName?.trim() ? siteName : "Ox Content";
 		const isBrandCard = normalizeBrandValue(title) === normalizeBrandValue(rawBrand);
-		const heroTitle = isBrandCard ? "cargo doc for JavaScript" : title;
+		const heroTitle = isBrandCard ? "High-performance Markdown toolkit" : title;
 		const heroDescription = isBrandCard ? "Rust-powered docs and high-performance Markdown tooling." : description && description.trim().length > 0 ? description : "Rust-powered docs and Markdown tooling.";
 		const descriptionHtml = heroDescription.trim().length > 0 ? `<p style="max-width:760px;font-size:28px;color:#93a4c3;line-height:1.45;margin:0;overflow:hidden;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;">${escapeHtml$2(heroDescription)}</p>` : "";
 		return `<div style="width:100%;height:100%;position:relative;overflow:hidden;box-sizing:border-box;padding:56px 64px 52px;background:#0b1220;font-family:'IBM Plex Sans','Avenir Next','Segoe UI',system-ui,sans-serif;color:#eff6ff;border:1px solid #223252;border-top:4px solid #4f6fae;">
@@ -1226,7 +2612,7 @@ async function writeCache(cacheDir, key, png) {
 	await fs_promises.writeFile(filePath, png);
 }
 //#endregion
-//#region \0@oxc-project+runtime@0.129.0/helpers/usingCtx.js
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
 		var n = Error();
@@ -1393,7 +2779,8 @@ async function resolveVueTemplate(templatePath, options, root) {
 	const { createSSRApp } = await import("vue");
 	const { renderToString } = await import("vue/server-renderer");
 	return async (props) => {
-		const html = await renderToString(createSSRApp(Component, props));
+		const app = createSSRApp(Component, props);
+		const html = await renderToString(app);
 		if (extractedCss) return `<style>${extractedCss}</style>${html}`;
 		return html;
 	};
@@ -1908,13 +3295,13 @@ function resolveSsgOptions(ssg) {
 * Extracts title from content or frontmatter.
 */
 function extractTitle$1(content, frontmatter) {
-	return require_napi.importNapiModuleSync().extractSsgTitle(content, typeof frontmatter.title === "string" ? frontmatter.title : void 0);
+	return require_vitepress.importNapiModuleSync().extractSsgTitle(content, typeof frontmatter.title === "string" ? frontmatter.title : void 0);
 }
 /**
 * Generates bare HTML page (no navigation, no styles).
 */
 function generateBareHtmlPage(content, title) {
-	return require_napi.importNapiModuleSync().generateSsgBareHtml(content, title);
+	return require_vitepress.importNapiModuleSync().generateSsgBareHtml(content, title);
 }
 /**
 * Per-build cache for the Rust-facing nav conversion. `navGroups` is the same
@@ -1991,7 +3378,7 @@ function localeCodesFor(locales) {
 * Generates HTML page with navigation using Rust NAPI bindings.
 */
 async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, theme, locale, availableLocales) {
-	const mod = await require_napi.importNapiModule();
+	const mod = await require_vitepress.importNapiModule();
 	const tocForRust = pageData.toc.map(toRustTocEntry);
 	const navGroupsForRust = convertNavGroupsForRust(navGroups);
 	const themeForRust = theme ? require_vitepress.themeToNapi(theme) : void 0;
@@ -2044,7 +3431,7 @@ async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, th
 	});
 }
 async function externalizeSharedPageAssets(pages, outDir, base) {
-	const optimized = (await require_napi.importNapiModule()).externalizeSsgAssets(pages, outDir, base);
+	const optimized = (await require_vitepress.importNapiModule()).externalizeSsgAssets(pages, outDir, base);
 	await Promise.all(optimized.assets.map(async (asset) => {
 		await fs_promises.mkdir(path.dirname(asset.outputPath), { recursive: true });
 		await fs_promises.writeFile(asset.outputPath, asset.content, "utf-8");
@@ -2058,45 +3445,45 @@ async function externalizeSharedPageAssets(pages, outDir, base) {
 * Converts a markdown file path to a relative URL path.
 */
 function getUrlPath$1(inputPath, srcDir) {
-	return require_napi.importNapiModuleSync().getSsgUrlPath(inputPath, srcDir);
+	return require_vitepress.importNapiModuleSync().getSsgUrlPath(inputPath, srcDir);
 }
 /**
 * Resolves manual navigation config to the format used by the built-in SSG renderer.
 */
 function resolveNavigationGroups(navigation, base, extension) {
 	if (!navigation) return;
-	return require_napi.importNapiModuleSync().resolveSsgNavigationGroups(navigation, base, extension);
+	return require_vitepress.importNapiModuleSync().resolveSsgNavigationGroups(navigation, base, extension);
 }
 function getPageLocale(urlPath, i18n) {
 	if (!i18n) return void 0;
-	return require_napi.importNapiModuleSync().getSsgPageLocale(urlPath, i18n.defaultLocale, localeCodesFor(i18n.locales)) ?? void 0;
+	return require_vitepress.importNapiModuleSync().getSsgPageLocale(urlPath, i18n.defaultLocale, localeCodesFor(i18n.locales)) ?? void 0;
 }
 function getRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl) {
-	return require_napi.importNapiModuleSync().resolveSsgRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl);
+	return require_vitepress.importNapiModuleSync().resolveSsgRoutePaths(inputPath, srcDir, outDir, base, extension, siteUrl);
 }
 /**
 * Formats a file/dir name as a title.
 */
 function formatTitle(name) {
-	return require_napi.importNapiModuleSync().formatSsgTitle(name);
+	return require_vitepress.importNapiModuleSync().formatSsgTitle(name);
 }
 /**
 * Collects all markdown files from the source directory.
 */
 async function collectMarkdownFiles(srcDir, extensions = DEFAULT_MARKDOWN_EXTENSIONS) {
-	return require_napi.importNapiModuleSync().collectSsgMarkdownFiles(srcDir, [...extensions]);
+	return require_vitepress.importNapiModuleSync().collectSsgMarkdownFiles(srcDir, [...extensions]);
 }
 /**
 * Builds navigation items from markdown files, grouped by directory.
 */
 function buildNavItems(markdownFiles, srcDir, base, extension) {
-	return require_napi.importNapiModuleSync().buildSsgNavItems(markdownFiles, srcDir, base, extension);
+	return require_vitepress.importNapiModuleSync().buildSsgNavItems(markdownFiles, srcDir, base, extension);
 }
 /**
 * Builds navigation items from an explicit theme sidebar tree.
 */
 function buildThemeNavItems(sidebar, base, extension) {
-	return require_napi.importNapiModuleSync().buildSsgThemeNavItems(sidebar, base, extension);
+	return require_vitepress.importNapiModuleSync().buildSsgThemeNavItems(sidebar, base, extension);
 }
 /**
 * Builds all markdown files to static HTML.
@@ -2145,7 +3532,7 @@ async function createBuildSsgContext(options, root, srcDir, outDir, markdownFile
 		navItems: resolveNavigationGroups(ssgOptions.navigation, base, ssgOptions.extension) ?? (ssgOptions.theme?.sidebar.length ? buildThemeNavItems(ssgOptions.theme.sidebar, base, ssgOptions.extension) : buildNavItems(markdownFiles, srcDir, base, ssgOptions.extension)),
 		siteName: await resolveSiteName$1(root, ssgOptions),
 		shouldGenerateOgImages: (options.ogImage || ssgOptions.generateOgImage) && !ssgOptions.bare,
-		napi: ssgOptions.lastUpdated ? await require_napi.importNapiModule() : void 0
+		napi: ssgOptions.lastUpdated ? await require_vitepress.importNapiModule() : void 0
 	};
 }
 async function resolveSiteName$1(root, ssgOptions) {
@@ -2321,7 +3708,7 @@ async function writeGeneratedPages(generatedPages, context, generatedFiles) {
 let oxContent$1 = null;
 async function getOxContent() {
 	if (!oxContent$1) try {
-		oxContent$1 = await require_napi.importNapiModule();
+		oxContent$1 = await require_vitepress.importNapiModule();
 	} catch {
 		console.warn("[ox-content] Native bindings not available, search disabled");
 		return null;
@@ -2375,7 +3762,7 @@ async function writeSearchIndex(indexJson, outDir) {
 * This is injected into the bundle as a virtual module.
 */
 function generateSearchModule(options, indexPath) {
-	return require_napi.importNapiModuleSync().generateSearchModuleFromOptions(options, indexPath);
+	return require_vitepress.importNapiModuleSync().generateSearchModuleFromOptions(options, indexPath);
 }
 //#endregion
 //#region src/dev-server.ts
@@ -2386,7 +3773,7 @@ function generateSearchModule(options, indexPath) {
 * during `vite dev`, matching the SSG build output.
 */
 /** File extensions to skip in the middleware. */
-const SKIP_EXTENSIONS = new Set([
+const SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
 	".js",
 	".ts",
 	".css",
@@ -2995,7 +4382,7 @@ function createI18nPlugin(resolvedOptions) {
 				return;
 			}
 			try {
-				const { checkI18nProject } = await require_napi.importNapiModule();
+				const { checkI18nProject } = await require_vitepress.importNapiModule();
 				const checkResult = checkI18nProject(dictDir, [path.resolve(root, "src"), path.resolve(root, "content")], i18nOptions.functionNames, i18nOptions.defaultLocale);
 				if (checkResult.errorCount > 0 || checkResult.warningCount > 0) {
 					for (const diag of checkResult.diagnostics) if (diag.severity === "error") console.error(`[ox-content:i18n] ${diag.message}`);
@@ -3288,7 +4675,7 @@ function resolveCollectionsOptions(options) {
 }
 async function buildCollectionManifest(root, options) {
 	if (!options.collections.enabled) return { collections: {} };
-	return parseCollectionManifest((await require_napi.importNapiModule()).buildCollectionManifest({
+	return parseCollectionManifest((await require_vitepress.importNapiModule()).buildCollectionManifest({
 		srcDir: node_path.resolve(root, options.srcDir),
 		extensions: [...options.extensions],
 		frontmatter: options.frontmatter,
@@ -3386,7 +4773,7 @@ var IncrementalMarkdownParser = class {
 	#includePendingAst;
 	#completeInline;
 	constructor(options = {}) {
-		const napi = require_napi.importNapiModuleSync();
+		const napi = require_vitepress.importNapiModuleSync();
 		this.#native = new napi.IncrementalMarkdownParser(toNativeParserOptions(options));
 		this.#includePendingAst = options.includePendingAst ?? false;
 		this.#completeInline = options.completeInline ?? true;
@@ -3422,7 +4809,7 @@ var IncrementalMarkdownRenderer = class {
 	#renderPending;
 	#completeInline;
 	constructor(options = {}) {
-		const napi = require_napi.importNapiModuleSync();
+		const napi = require_vitepress.importNapiModuleSync();
 		this.#native = new napi.IncrementalMarkdownRenderer(toNativeParserOptions(options));
 		this.#renderPending = options.renderPending ?? true;
 		this.#completeInline = options.completeInline ?? true;
@@ -3575,7 +4962,7 @@ function renderHtmlToVueH(html, islands = []) {
 	return renderHtmlToFrameworkCode(html, "vue", "expression", islands);
 }
 function renderHtmlToFrameworkCode(html, target, mode, islands = []) {
-	return require_napi.importNapiModuleSync().renderFrameworkComponentCode(html, target, toNapiIslands(islands), mode);
+	return require_vitepress.importNapiModuleSync().renderFrameworkComponentCode(html, target, toNapiIslands(islands), mode);
 }
 function renderHtmlToReactComponent(html, islands = []) {
 	return renderHtmlToFrameworkCode(html, "react", "component", islands);
@@ -3587,7 +4974,7 @@ function renderHtmlToSvelteComponent(html) {
 	return renderHtmlToFrameworkCode(html, "svelte", "component");
 }
 function escapeSvelteMarkup(html) {
-	return require_napi.importNapiModuleSync().escapeSvelteMarkup(html);
+	return require_vitepress.importNapiModuleSync().escapeSvelteMarkup(html);
 }
 function toNapiIslands(islands) {
 	return islands.map((island) => ({
@@ -4237,7 +5624,7 @@ async function lintMarkdownFiles(options = {}) {
 function resolveMarkdownLintFileOptions(options) {
 	return {
 		cwd: node_path.resolve(options.cwd ?? process.cwd()),
-		exclude: [...new Set([...options.exclude ?? DEFAULT_LINT_FILE_EXCLUDE, ...options.ignore ?? []])],
+		exclude: [.../* @__PURE__ */ new Set([...options.exclude ?? DEFAULT_LINT_FILE_EXCLUDE, ...options.ignore ?? []])],
 		include: [...new Set(options.include ?? DEFAULT_LINT_FILE_INCLUDE)],
 		lintOptions: {
 			dictionary: options.dictionary,
@@ -4329,7 +5716,7 @@ function createEmptyLintResult() {
 * }
 * ```
 */
-const VOID_ELEMENTS = new Set([
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
 	"area",
 	"base",
 	"br",
@@ -4345,7 +5732,7 @@ const VOID_ELEMENTS = new Set([
 	"track",
 	"wbr"
 ]);
-const BOOLEAN_ATTRS = new Set([
+const BOOLEAN_ATTRS = /* @__PURE__ */ new Set([
 	"allowfullscreen",
 	"async",
 	"autofocus",
@@ -4492,7 +5879,7 @@ function each(items, render) {
 }
 //#endregion
 //#region src/page-context.ts
-var page_context_exports = /* @__PURE__ */ require_chunk.__exportAll({
+var page_context_exports = /* @__PURE__ */ require_vitepress.__exportAll({
 	clearRenderContext: () => clearRenderContext,
 	generateFrontmatterTypes: () => generateFrontmatterTypes,
 	inferType: () => inferType,
@@ -4677,7 +6064,7 @@ function generateFrontmatterTypes(samples, interfaceName = "PageFrontmatter") {
 	return lines.join("\n");
 }
 var currentContext;
-var init_page_context = require_chunk.__esmMin((() => {
+var init_page_context = require_vitepress.__esmMin((() => {
 	currentContext = null;
 }));
 //#endregion
@@ -4771,7 +6158,7 @@ async function generateTypes(pages, outDir) {
 * A minimal theme that renders page content with basic styling.
 */
 function DefaultTheme({ children }) {
-	const { usePageProps, useSiteConfig } = (init_page_context(), require_chunk.__toCommonJS(page_context_exports));
+	const { usePageProps, useSiteConfig } = (init_page_context(), require_vitepress.__toCommonJS(page_context_exports));
 	const page = usePageProps();
 	const site = useSiteConfig();
 	return { __html: `<!DOCTYPE html>
@@ -4835,7 +6222,7 @@ function escapeHtml(str) {
 function createTheme(config) {
 	const { layouts, defaultLayout = "default" } = config;
 	return function ThemeWithLayouts({ children }) {
-		const { usePageProps } = (init_page_context(), require_chunk.__toCommonJS(page_context_exports));
+		const { usePageProps } = (init_page_context(), require_vitepress.__toCommonJS(page_context_exports));
 		const layoutName = usePageProps().layout ?? defaultLayout;
 		const Layout = layouts[layoutName] ?? layouts[defaultLayout];
 		if (!Layout) throw new Error(`[ox-content] Layout "${layoutName}" not found. Available layouts: ${Object.keys(layouts).join(", ")}`);
@@ -5359,9 +6746,9 @@ function resolveCodeAnnotationsOptions(options) {
 /**
 * Generates virtual module content.
 */
-function generateVirtualModule(path$1, options) {
-	if (path$1 === "config") return `export default ${JSON.stringify(options)};`;
-	if (path$1 === "runtime") {
+function generateVirtualModule(path$3, options) {
+	if (path$3 === "config") return `export default ${JSON.stringify(options)};`;
+	if (path$3 === "runtime") {
 		const base = normalizeRuntimeBase(options.base);
 		return `
       export const base = ${JSON.stringify(base)};
@@ -5420,9 +6807,9 @@ exports.buildSearchIndex = buildSearchIndex;
 exports.buildSsg = buildSsg;
 exports.clearRenderContext = clearRenderContext;
 exports.collectDocsTests = collectDocsTests;
-exports.collectGitHubRepos = require_github.collectGitHubRepos;
-exports.collectGitHubSources = require_github.collectGitHubSources;
-exports.collectOgpUrls = require_ogp.collectOgpUrls;
+exports.collectGitHubRepos = collectGitHubRepos;
+exports.collectGitHubSources = collectGitHubSources;
+exports.collectOgpUrls = collectOgpUrls;
 exports.convertVitePressNav = require_vitepress.convertVitePressNav;
 exports.convertVitePressSidebar = require_vitepress.convertVitePressSidebar;
 exports.createFrameworkMarkdownOptions = createFrameworkMarkdownOptions;
@@ -5441,10 +6828,10 @@ exports.extractCodeBlocks = extractCodeBlocks;
 exports.extractDocs = extractDocs;
 exports.extractDocsTests = extractDocsTests;
 exports.extractIslandInfo = extractIslandInfo;
-exports.extractVideoId = require_youtube.extractVideoId;
-exports.fetchGitHubSource = require_github.fetchGitHubSource;
-exports.fetchOgpData = require_ogp.fetchOgpData;
-exports.fetchRepoData = require_github.fetchRepoData;
+exports.extractVideoId = extractVideoId;
+exports.fetchGitHubSource = fetchGitHubSource;
+exports.fetchOgpData = fetchOgpData;
+exports.fetchRepoData = fetchRepoData;
 exports.fromVitePressConfig = require_vitepress.fromVitePressConfig;
 exports.generateCollectionsVirtualModule = generateCollectionsVirtualModule;
 exports.generateFrontmatterTypes = generateFrontmatterTypes;
@@ -5466,15 +6853,15 @@ exports.lintMarkdownAsync = lintMarkdownAsync;
 exports.lintMarkdownFile = lintMarkdownFile;
 exports.lintMarkdownFiles = lintMarkdownFiles;
 exports.mergeThemes = require_vitepress.mergeThemes;
-exports.mermaidClientScript = require_mermaid.mermaidClientScript;
+exports.mermaidClientScript = mermaidClientScript;
 exports.normalizeMarkdownExtensions = normalizeMarkdownExtensions;
 exports.normalizeVitePressFrontmatter = require_vitepress.normalizeVitePressFrontmatter;
 exports.oxContent = oxContent;
-exports.parseGitHubLineRange = require_github.parseGitHubLineRange;
-exports.parseGitHubPermalink = require_github.parseGitHubPermalink;
-exports.prefetchGitHubRepos = require_github.prefetchGitHubRepos;
-exports.prefetchGitHubSources = require_github.prefetchGitHubSources;
-exports.prefetchOgpData = require_ogp.prefetchOgpData;
+exports.parseGitHubLineRange = parseGitHubLineRange;
+exports.parseGitHubPermalink = parseGitHubPermalink;
+exports.prefetchGitHubRepos = prefetchGitHubRepos;
+exports.prefetchGitHubSources = prefetchGitHubSources;
+exports.prefetchOgpData = prefetchOgpData;
 exports.raw = raw;
 exports.renderAllPages = renderAllPages;
 exports.renderHtmlToFrameworkCode = renderHtmlToFrameworkCode;
@@ -5499,13 +6886,13 @@ exports.setRenderContext = setRenderContext;
 exports.shouldLintMarkdownFile = shouldLintMarkdownFile;
 exports.stripMarkdownExtension = stripMarkdownExtension;
 exports.transformAllPlugins = transformAllPlugins;
-exports.transformGitHub = require_github.transformGitHub;
+exports.transformGitHub = transformGitHub;
 exports.transformIslands = transformIslands;
 exports.transformMarkdown = transformMarkdown;
-exports.transformMermaidStatic = require_mermaid.transformMermaidStatic;
-exports.transformOgp = require_ogp.transformOgp;
+exports.transformMermaidStatic = transformMermaidStatic;
+exports.transformOgp = transformOgp;
 exports.transformTabs = require_tabs.transformTabs;
-exports.transformYouTube = require_youtube.transformYouTube;
+exports.transformYouTube = transformYouTube;
 exports.typecheckCodeBlocks = typecheckCodeBlocks;
 exports.useIsActive = useIsActive;
 exports.useNav = useNav;