@ox-content/vite-plugin 2.80.0 → 2.82.0

package/dist/index.mjs

@@ -1,23 +1,18 @@
+import { c as __exportAll, i as setTabGroupCounter, l as __require, n as getTabGroupCounter, o as transformTabs, r as resetTabGroupCounter, s as __esmMin, t as generateTabsCSS, u as __toCommonJS } from "./tabs.mjs";
 import { t as interopDefault } from "./interop.mjs";
-import { n as importNapiModuleSync, t as importNapiModule } from "./napi.mjs";
-import { n as transformMermaidStatic, t as mermaidClientScript } from "./mermaid2.mjs";
-import { a as transformTabs, r as resetTabGroupCounter, t as generateTabsCSS } from "./tabs2.mjs";
-import "./pm2.mjs";
-import { n as transformYouTube, t as extractVideoId } from "./youtube2.mjs";
-import "./media.mjs";
-import { a as fetchRepoData, i as fetchGitHubSource, l as parseGitHubLineRange, n as collectGitHubRepos, o as prefetchGitHubRepos, r as collectGitHubSources, s as prefetchGitHubSources, t as transformGitHub, u as parseGitHubPermalink } from "./github.mjs";
-import { a as transformOgp, i as prefetchOgpData, n as fetchOgpData, t as collectOgpUrls } from "./ogp2.mjs";
-import { a as normalizeVitePressFrontmatter, c as mergeThemes, i as generateVitePressMigrationConfig, l as resolveTheme, n as convertVitePressSidebar, o as defaultTheme, r as fromVitePressConfig, s as defineTheme, t as convertVitePressNav, u as themeToNapi } from "./vitepress.mjs";
+import { a as normalizeVitePressFrontmatter, c as mergeThemes, d as importNapiModule, f as importNapiModuleSync, i as generateVitePressMigrationConfig, l as resolveTheme, n as convertVitePressSidebar, o as defaultTheme, r as fromVitePressConfig, s as defineTheme, t as convertVitePressNav, u as themeToNapi } from "./vitepress.mjs";
 import { createRequire } from "node:module";
 import * as path$2 from "path";
 import { unified } from "unified";
 import rehypeParsePlugin from "rehype-parse";
 import rehypeStringifyPlugin from "rehype-stringify";
 import { createHighlighter } from "shiki";
+import { existsSync } from "node:fs";
 import * as path$1 from "node:path";
-import { dirname, join } from "node:path";
+import path, { dirname, join } from "node:path";
 import * as fs from "node:fs/promises";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { Buffer as Buffer$1 } from "node:buffer";
 import { tmpdir } from "node:os";
 import { promisify } from "node:util";
 import { execFile, spawn } from "node:child_process";
@@ -25,34 +20,6 @@ import * as fs$2 from "fs/promises";
 import * as crypto from "crypto";
 import * as fs$1 from "fs";
 import { glob } from "glob";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
 //#region src/markdown.ts
 const DEFAULT_MARKDOWN_EXTENSIONS = [
 	".md",
@@ -138,8 +105,8 @@ function createMarkdownEnvironment(options) {
 /**
 * Syntax highlighting with Shiki via rehype.
 */
-const rehypeParse$1 = interopDefault(rehypeParsePlugin);
-const rehypeStringify$1 = interopDefault(rehypeStringifyPlugin);
+const rehypeParse$3 = interopDefault(rehypeParsePlugin);
+const rehypeStringify$3 = interopDefault(rehypeStringifyPlugin);
 const BUILTIN_LANGS = [
 	"javascript",
 	"typescript",
@@ -218,7 +185,7 @@ function rehypeShikiHighlight(options) {
 					lang,
 					theme: themeName
 				});
-				const parsed = unified().use(rehypeParse$1, { fragment: true }).parse(highlighted);
+				const parsed = unified().use(rehypeParse$3, { fragment: true }).parse(highlighted);
 				if (parsed.children[0]?.type === "element") {
 					const highlightedPre = parsed.children[0];
 					highlightedPre.properties ??= {};
@@ -240,13 +207,13 @@ function rehypeShikiHighlight(options) {
 					lang,
 					theme: themeName
 				});
-				const parsed = unified().use(rehypeParse$1, { fragment: true }).parse(highlighted);
+				const parsed = 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"
@@ -296,42 +263,1433 @@ function normalizeClassName(className) {
 * Apply syntax highlighting to HTML using Shiki.
 */
 async function highlightCode(html, theme = "github-dark", langs = []) {
-	const result = await unified().use(rehypeParse$1, { fragment: true }).use(rehypeShikiHighlight, {
+	const result = await 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__ */ __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 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 = join(dirname(entry), "cli.js");
+		if (existsSync(cliPath)) {
+			cachedMmdcPath = cliPath;
+			return cachedMmdcPath;
+		}
+	} catch {}
+	const binPath = join(process.cwd(), "node_modules", ".bin", "mmdc");
+	if (existsSync(binPath)) {
+		cachedMmdcPath = binPath;
+		return cachedMmdcPath;
+	}
+	cachedMmdcPath = null;
+	return null;
+}
+function createMmdcResolvers() {
+	const consumerRequire = createRequire(join(process.cwd(), "noop.js"));
+	const resolvers = [consumerRequire];
+	try {
+		resolvers.push(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__ */ __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 importNapiModule();
+	const startGroup = getTabGroupCounter();
+	const result = mod.transformPmEmbeds(html, startGroup, { sync: options?.sync ?? false });
+	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__ */ __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 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 = path.join(options.mediaOutputDir, filename);
+	try {
+		await access(output);
+		return joinPublicPath(options.mediaPublicPath, filename);
+	} catch {}
+	try {
+		const response = await fetch(url, { headers: { Accept: "image/*" } });
+		if (!response.ok) return void 0;
+		await mkdir(options.mediaOutputDir, { recursive: true });
+		await 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 readFile(path.join(directory, `${key}.json`), "utf8"));
+		return isTweetData(data) ? data : null;
+	} catch {
+		return null;
+	}
+}
+async function writeCachedTweet(key, data, directory) {
+	try {
+		await mkdir(directory, { recursive: true });
+		await writeFile(path.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: path.resolve(options.cacheDir ?? ".cache/ox-content/twitter"),
+		mediaOutputDir: path.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__ */ __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 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 = Buffer$1.from(data.content.replace(/\s/g, ""), "base64").toString("utf8");
+		if (Buffer$1.byteLength(content) > options.maxSourceBytes) return null;
+		const sourceData = {
+			repo: source.repo,
+			ref: source.ref,
+			path: source.path,
+			permalink: source.permalink,
+			content,
+			size: data.size ?? Buffer$1.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 = interopDefault(rehypeParsePlugin);
+const rehypeStringify$2 = interopDefault(rehypeStringifyPlugin);
+/**
+* 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 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__ */ __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__ */ __exportAll({
+	collectOgpUrls: () => collectOgpUrls,
+	fetchOgpData: () => fetchOgpData,
+	isSafeOgpUrl: () => isSafeOgpUrl,
+	prefetchOgpData: () => prefetchOgpData,
+	transformOgp: () => transformOgp
+});
+const rehypeParse$1 = interopDefault(rehypeParsePlugin);
+const rehypeStringify$1 = interopDefault(rehypeStringifyPlugin);
+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 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 import("./tabs.mjs");
+		const { transformTabs } = await import("./tabs.mjs").then((n) => n.a);
 		result = await transformTabs(result);
 	}
 	if (pm) {
-		const { transformPm } = await import("./pm.mjs");
+		const { transformPm } = await Promise.resolve().then(() => pm_exports);
 		result = await transformPm(result, typeof pm === "object" ? pm : {});
 	}
 	if (youtube) {
-		const { transformYouTube } = await import("./youtube.mjs");
+		const { transformYouTube } = await Promise.resolve().then(() => youtube_exports);
 		result = await transformYouTube(result);
 	}
 	if (github !== false) {
-		const { transformGitHub } = await import("./github2.mjs");
+		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 import("./ogp.mjs");
+		const { transformOgp } = await Promise.resolve().then(() => ogp_exports);
 		result = await transformOgp(result, void 0, typeof ogpOptions === "object" ? ogpOptions : {});
 	}
 	const mediaOptions = {
@@ -342,11 +1700,11 @@ async function transformAllPlugins(html, options = {}) {
 		webContainer
 	};
 	if (Object.values(mediaOptions).some(Boolean)) {
-		const { transformMediaEmbeds } = await import("./media2.mjs");
+		const { transformMediaEmbeds } = await Promise.resolve().then(() => media_exports);
 		result = await transformMediaEmbeds(result, mediaOptions);
 	}
 	if (mermaid) {
-		const { transformMermaidStatic } = await import("./mermaid.mjs");
+		const { transformMermaidStatic } = await Promise.resolve().then(() => mermaid_exports);
 		result = await transformMermaidStatic(result);
 	}
 	return result;
@@ -355,20 +1713,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 import("./github2.mjs");
+		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 import("./ogp.mjs");
+		const { transformOgp } = await Promise.resolve().then(() => ogp_exports);
 		result = await transformOgp(result, void 0, options.openGraph);
 	}
 	if (options.pm) {
-		const { transformPm } = await import("./pm.mjs");
+		const { transformPm } = await Promise.resolve().then(() => pm_exports);
 		result = await transformPm(result, typeof options.pm === "object" ? options.pm : {});
 	}
 	const mediaOptions = {
@@ -379,7 +1737,7 @@ async function transformBuiltinEmbeds(html, options) {
 		webContainer: options.webContainer
 	};
 	if (Object.values(mediaOptions).some(Boolean)) {
-		const { transformMediaEmbeds } = await import("./media2.mjs");
+		const { transformMediaEmbeds } = await Promise.resolve().then(() => media_exports);
 		result = await transformMediaEmbeds(result, mediaOptions);
 	}
 	return result;
@@ -471,7 +1829,8 @@ async function typecheckCodeBlocks(source, options = {}) {
 	try {
 		const files = [];
 		await Promise.all(blocks.map(async (block, index) => {
-			const file = join(temp, `snippet-${index}.${block.language.toLowerCase() === "tsx" ? "tsx" : "ts"}`);
+			const extension = block.language.toLowerCase() === "tsx" ? "tsx" : "ts";
+			const file = join(temp, `snippet-${index}.${extension}`);
 			files.push(file);
 			await writeFile(file, block.code);
 		}));
@@ -483,7 +1842,7 @@ async function typecheckCodeBlocks(source, options = {}) {
 				...files
 			], {
 				cwd: process.cwd(),
-				maxBuffer: 1024 * 1024 * 4
+				maxBuffer: 4194304
 			});
 			return [];
 		} catch (error) {
@@ -636,7 +1995,7 @@ 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 transformMermaidStatic(html);
@@ -1191,7 +2550,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;">
@@ -1246,7 +2605,7 @@ async function writeCache(cacheDir, key, png) {
 	await fs$2.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();
@@ -1413,7 +2772,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;
 	};
@@ -2406,7 +3766,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",
@@ -4257,7 +5617,7 @@ async function lintMarkdownFiles(options = {}) {
 function resolveMarkdownLintFileOptions(options) {
 	return {
 		cwd: path$1.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,
@@ -4349,7 +5709,7 @@ function createEmptyLintResult() {
 * }
 * ```
 */
-const VOID_ELEMENTS = new Set([
+const VOID_ELEMENTS = /* @__PURE__ */ new Set([
 	"area",
 	"base",
 	"br",
@@ -4365,7 +5725,7 @@ const VOID_ELEMENTS = new Set([
 	"track",
 	"wbr"
 ]);
-const BOOLEAN_ATTRS = new Set([
+const BOOLEAN_ATTRS = /* @__PURE__ */ new Set([
 	"allowfullscreen",
 	"async",
 	"autofocus",