@ox-content/vite-plugin 2.90.0 → 3.0.0-alpha.10

package/dist/vitepress.mjs

@@ -1,4 +1,9 @@
 import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { glob } from "glob";
 //#region src/napi.ts
 const requireNapi = createRequire(import.meta.url);
 function getDefaultExport(value) {
@@ -29,6 +34,632 @@ function importNapiModuleSync() {
 	}
 }
 //#endregion
+//#region src/theme-fonts-acquire.ts
+/**
+* Resolve self-hosted faces from a local file / `@fontsource` directory or
+* Google Fonts. Downloads are cached; tests inject `fetch` so CI never hits
+* the network.
+*/
+const GOOGLE_CSS = "https://fonts.googleapis.com/css2";
+const GOOGLE_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";
+const ALLOWED_HOSTS = /* @__PURE__ */ new Set(["fonts.googleapis.com", "fonts.gstatic.com"]);
+function fontMime(fileName) {
+	if (fileName.endsWith(".woff")) return "font/woff";
+	if (fileName.endsWith(".ttf")) return "font/ttf";
+	if (fileName.endsWith(".otf")) return "font/otf";
+	return "font/woff2";
+}
+function renderFontFaceCss(faces) {
+	return faces.map((face) => {
+		const range = face.unicodeRange ? `\n  unicode-range: ${face.unicodeRange};` : "";
+		const fileName = face.fileName;
+		const format = fileName.endsWith(".woff") ? "woff" : fileName.endsWith(".ttf") ? "truetype" : fileName.endsWith(".otf") ? "opentype" : "woff2";
+		return `@font-face {
+  font-family: ${/^[a-zA-Z_-][\w-]*$/.test(face.family) ? face.family : `"${face.family.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`};
+  font-style: ${face.style};
+  font-weight: ${face.weight};
+  font-display: ${face.display};
+  src: url(./${fileName}) format("${format}");${range}
+}`;
+	}).join("\n\n");
+}
+function resolveFontCacheDir(root, cacheDir) {
+	return cacheDir ?? join(root, "node_modules", ".cache", "ox-content", "fonts");
+}
+async function acquireSelfHostedFaces(faces, options) {
+	const cacheDir = resolveFontCacheDir(options.root, options.cacheDir);
+	const acquired = [];
+	for (const face of faces) acquired.push(face.provider === "local" ? await acquireLocalFace(face, options.root) : await acquireGoogleFace(face, cacheDir, options.fetch ?? fetch));
+	return acquired;
+}
+async function acquireLocalFace(face, root) {
+	if (!face.path) throw new Error(`Theme font "${face.family}" uses provider "local" but has no path.`);
+	if (face.path.includes("\0")) throw new Error(`Theme font "${face.family}" path must not contain NUL.`);
+	const resolved = resolveLocalPath(root, face.path);
+	const info = await stat(resolved).catch(() => void 0);
+	if (!info) throw new Error(`Theme font "${face.family}" was not found at ${resolved}.`);
+	const file = info.isDirectory() ? await findDirectoryFont(resolved, face) : resolved;
+	return {
+		...face,
+		bytes: await readFile(file)
+	};
+}
+function resolveLocalPath(root, spec) {
+	if (isAbsolute(spec)) return spec;
+	if (spec.startsWith("@") || !spec.startsWith(".")) return resolve(root, "node_modules", spec);
+	return resolve(root, spec);
+}
+async function findDirectoryFont(dir, face) {
+	const filesDir = existsSync(join(dir, "files")) ? join(dir, "files") : dir;
+	const names = (await readdir(filesDir)).filter((name) => /\.(woff2|woff|ttf|otf)$/i.test(name));
+	const weight = String(face.weight);
+	const wantItalic = face.style === "italic";
+	const match = names.find((name) => {
+		const lower = name.toLowerCase();
+		const hasWeight = lower.includes(weight);
+		const italic = lower.includes("italic");
+		const subset = face.subset === "all" || lower.includes(face.subset.toLowerCase());
+		return hasWeight && subset && italic === wantItalic;
+	});
+	const fallback = names[0];
+	const chosen = match ?? (names.length === 1 ? fallback : void 0);
+	if (!chosen) throw new Error(`Theme font "${face.family}" has no ${face.weight} ${face.style} ${face.subset} file in ${filesDir}.`);
+	return join(filesDir, chosen);
+}
+async function acquireGoogleFace(face, cacheDir, fetchFn) {
+	const parsed = parseGoogleCss(await cachedText(googleCssUrl(face), cacheDir, fetchFn, ".css")).find((entry) => entry.weight === face.weight && entry.style === face.style && (entry.subset === face.subset || !entry.subset));
+	if (!parsed) throw new Error(`Google Fonts CSS for "${face.family}" has no ${face.weight} ${face.style} ${face.subset} face.`);
+	const bytes = await cachedBytes(parsed.url, cacheDir, fetchFn, ".woff2");
+	return {
+		...face,
+		bytes,
+		unicodeRange: face.unicodeRange ?? parsed.unicodeRange
+	};
+}
+function googleCssUrl(face) {
+	const italic = face.style === "italic";
+	const axis = italic ? "ital,wght" : "wght";
+	const spec = italic ? `1,${face.weight}` : `${face.weight}`;
+	const family = `${face.family.replace(/ /g, "+")}:${axis}@${spec}`;
+	return `${GOOGLE_CSS}?family=${family}&display=${encodeURIComponent(face.display)}`;
+}
+function parseGoogleCss(css) {
+	const faces = [];
+	const blocks = css.matchAll(/\/\*\s*([a-z0-9-]+)\s*\*\/\s*@font-face\s*\{([^}]+)\}/gi);
+	for (const match of blocks) {
+		const parsed = parseGoogleBlock(match[2] ?? "", match[1]?.toLowerCase() ?? "");
+		if (parsed) faces.push(parsed);
+	}
+	if (faces.length === 0) for (const match of css.matchAll(/@font-face\s*\{([^}]+)\}/gi)) {
+		const parsed = parseGoogleBlock(match[1] ?? "", "");
+		if (parsed) faces.push(parsed);
+	}
+	return faces;
+}
+function parseGoogleBlock(body, subset) {
+	const url = body.match(/url\((['"]?)(https?:\/\/[^'")]+)\1\)/)?.[2];
+	if (!url || !isAllowedFontUrl(url)) return;
+	return {
+		subset,
+		weight: Number(body.match(/font-weight:\s*(\d+)/i)?.[1] ?? 400),
+		style: /font-style:\s*italic/i.test(body) ? "italic" : "normal",
+		url,
+		unicodeRange: body.match(/unicode-range:\s*([^;]+)/i)?.[1]?.trim()
+	};
+}
+function isAllowedFontUrl(url) {
+	try {
+		const parsed = new URL(url);
+		return parsed.protocol === "https:" && ALLOWED_HOSTS.has(parsed.hostname);
+	} catch {
+		return false;
+	}
+}
+async function cachedText(url, cacheDir, fetchFn, ext) {
+	const bytes = await cachedBytes(url, cacheDir, fetchFn, ext);
+	return new TextDecoder().decode(bytes);
+}
+async function cachedBytes(url, cacheDir, fetchFn, ext) {
+	if (!isAllowedFontUrl(url)) throw new Error(`Refusing to download font from ${url}.`);
+	await mkdir(cacheDir, { recursive: true });
+	const dest = join(cacheDir, `${createHash("sha256").update(url).digest("hex").slice(0, 16)}${ext}`);
+	if (existsSync(dest)) return readFile(dest);
+	const response = await fetchFn(url, { headers: { "User-Agent": GOOGLE_UA } });
+	if (!response.ok) throw new Error(`Failed to download ${url}: ${response.status}`);
+	const bytes = new Uint8Array(await response.arrayBuffer());
+	await writeFile(dest, bytes);
+	return bytes;
+}
+//#endregion
+//#region src/theme-fonts.ts
+/**
+* Opt-in web-font objects for `theme.fonts`, plus SSG self-host emission.
+*
+* NAPI still receives flattened CSS stacks (`JsThemeFonts`). File acquisition
+* and `@font-face` generation stay in TypeScript so other PRs can keep landing
+* NAPI theme-type changes independently.
+*/
+const FONT_ASSET_DIR = "__ox_fonts__";
+const FONT_CSS_NAME = "fonts.css";
+const NAMED_FONT_PATTERN = /^[a-z][a-z0-9-]*$/;
+const GENERIC_FOR = {
+	sans: "sans-serif",
+	mono: "monospace",
+	named: "sans-serif"
+};
+function isThemeWebFont(value) {
+	return typeof value === "object" && value !== null && typeof value.family === "string";
+}
+/** CSS `font-family` identifier; quotes names that are not a single ident. */
+function cssFamilyName(family) {
+	const trimmed = family.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed;
+	if (/^[a-zA-Z_-][\w-]*$/.test(trimmed)) return trimmed;
+	return `"${trimmed.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function flattenThemeFont(value, generic) {
+	if (value === void 0) return;
+	if (typeof value === "string") return value;
+	const fallbacks = value.fallbacks?.length ? value.fallbacks.join(", ") : generic;
+	return `${cssFamilyName(value.family)}, ${fallbacks}`;
+}
+/** Flatten object fonts so `JsThemeFonts` stays `{ sans?: string; mono?: string }`. */
+function flattenThemeFonts(fonts) {
+	const sans = flattenThemeFont(fonts.sans, GENERIC_FOR.sans);
+	const mono = flattenThemeFont(fonts.mono, GENERIC_FOR.mono);
+	if (!sans && !mono) return;
+	return {
+		sans,
+		mono
+	};
+}
+function namedFontToken(name) {
+	if (!NAMED_FONT_PATTERN.test(name)) throw new Error(`Invalid theme font name: ${JSON.stringify(name)}. Named fonts are lowercase kebab-case (e.g. "code").`);
+	return name;
+}
+/** Extra `--octc-font-*` variables for `fonts.named`. Roles stay in Rust theme CSS. */
+function namedFontVarsCss(fonts) {
+	const entries = Object.entries(fonts.named ?? {});
+	if (entries.length === 0) return "";
+	return `:root {\n${entries.map(([name, value]) => {
+		const stack = flattenThemeFont(value, GENERIC_FOR.named);
+		return `  --octc-font-${namedFontToken(name)}: ${stack};`;
+	}).join("\n")}\n}`;
+}
+function normalizeBasePath(base) {
+	if (!base || base === "/") return "/";
+	return base.endsWith("/") ? base : `${base}/`;
+}
+function plannedFontFileName(family, weight, style, subset, extension) {
+	const ext = extension.startsWith(".") ? extension : `.${extension}`;
+	return `${slugify(family)}-${weight}-${style}-${slugify(subset)}${ext}`;
+}
+function plannedFontExtension(font) {
+	if (font.provider === "local" && font.path && /\.\w+$/.test(font.path) && !font.path.endsWith("/")) return font.path.match(/(\.\w+)$/)?.[1] ?? ".woff2";
+	return ".woff2";
+}
+function planSelfHostedFaces(fonts) {
+	const faces = [];
+	for (const value of themeFontValues(fonts)) {
+		if (!isThemeWebFont(value) || !value.selfHost) continue;
+		const font = normalizeWebFont(value);
+		const extension = plannedFontExtension(font);
+		for (const weight of font.weights) for (const style of font.styles) for (const subset of font.subsets) faces.push({
+			family: font.family,
+			weight,
+			style,
+			subset,
+			display: font.display,
+			preload: shouldPreload(font.preload, weight),
+			provider: font.provider,
+			path: font.path,
+			fileName: plannedFontFileName(font.family, weight, style, subset, extension),
+			unicodeRange: font.unicodeRange
+		});
+	}
+	const unique = /* @__PURE__ */ new Map();
+	for (const face of faces) {
+		const existing = unique.get(face.fileName);
+		if (existing) existing.preload ||= face.preload;
+		else unique.set(face.fileName, face);
+	}
+	return [...unique.values()];
+}
+function themeFontHeadHtml(fonts, base) {
+	const faces = planSelfHostedFaces(fonts);
+	if (faces.length === 0) return "";
+	const root = normalizeBasePath(base);
+	const tags = [`<link rel="stylesheet" href="${root}${FONT_ASSET_DIR}/${FONT_CSS_NAME}">`];
+	for (const face of faces) {
+		if (!face.preload) continue;
+		tags.push(`<link rel="preload" href="${root}${FONT_ASSET_DIR}/${face.fileName}" as="font" type="${fontMime(face.fileName)}" crossorigin>`);
+	}
+	return tags.join("\n");
+}
+function withSelfHostedFontHead(embed, fonts, base) {
+	const extra = themeFontHeadHtml(fonts, base);
+	const keys = Object.keys(embed);
+	if (!extra && keys.length === 0) return;
+	if (!extra) return embed;
+	return {
+		...embed,
+		head: embed.head ? `${extra}\n${embed.head}` : extra
+	};
+}
+/** Copy self-hosted faces into `outDir` and write `@font-face` CSS. */
+async function writeSelfHostedThemeFonts(options) {
+	const faces = planSelfHostedFaces(options.fonts);
+	if (faces.length === 0) return [];
+	const acquired = await acquireSelfHostedFaces(faces, options);
+	const destDir = join(options.outDir, FONT_ASSET_DIR);
+	await mkdir(destDir, { recursive: true });
+	const written = [];
+	for (const face of acquired) {
+		const dest = join(destDir, face.fileName);
+		await writeFile(dest, face.bytes);
+		written.push(dest);
+	}
+	const cssPath = join(destDir, FONT_CSS_NAME);
+	await writeFile(cssPath, renderFontFaceCss(acquired), "utf8");
+	written.push(cssPath);
+	return written;
+}
+function themeFontValues(fonts) {
+	return [
+		fonts.sans,
+		fonts.mono,
+		...Object.values(fonts.named ?? {})
+	].filter((value) => value !== void 0);
+}
+function normalizeWebFont(font) {
+	const provider = font.provider ?? (font.path ? "local" : "google");
+	if (provider === "local" && !font.path) throw new Error(`Theme font "${font.family}" uses provider "local" but has no path.`);
+	return {
+		...font,
+		family: font.family.trim(),
+		provider,
+		weights: font.weights?.length ? font.weights : [400],
+		styles: font.styles?.length ? font.styles : ["normal"],
+		subsets: font.subsets?.length ? font.subsets : ["latin"],
+		display: font.display ?? "swap"
+	};
+}
+function shouldPreload(preload, weight) {
+	if (preload === true) return true;
+	return Array.isArray(preload) && preload.includes(weight);
+}
+function slugify(value) {
+	return value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "font";
+}
+//#endregion
+//#region src/icons-css.ts
+/**
+* Resolve Iconify JSON collections and emit CSS-mask rules.
+*
+* Collections come from installed `@iconify-json/*` or `@iconify/json`.
+* Tests supply fixture JSON under the project `root` — no network.
+*/
+function iconCssSelector(prefix, name) {
+	return `.icon-\\[${prefix}--${name}\\]`;
+}
+function resolveIconCollectionPath(prefix, root) {
+	const files = [join(root, "node_modules", "@iconify-json", prefix, "icons.json"), join(root, "node_modules", "@iconify", "json", "json", `${prefix}.json`)];
+	for (const file of files) if (existsSync(file)) return file;
+	return resolveViaNode(prefix, root);
+}
+function resolveViaNode(prefix, root) {
+	try {
+		return createRequire(join(root, "package.json")).resolve(`@iconify-json/${prefix}/icons.json`);
+	} catch {
+		try {
+			return createRequire(join(root, "package.json")).resolve(`@iconify/json/json/${prefix}.json`);
+		} catch {
+			return;
+		}
+	}
+}
+async function loadIconCollection(prefix, root) {
+	const path = resolveIconCollectionPath(prefix, root);
+	if (!path) return;
+	const raw = await readFile(path, "utf8");
+	return JSON.parse(raw);
+}
+function lookupIcon(collection, name) {
+	const fallback = collection.width ?? 16;
+	const fallbackH = collection.height ?? fallback;
+	const direct = collection.icons[name];
+	if (direct) return {
+		body: direct.body,
+		width: direct.width ?? fallback,
+		height: direct.height ?? fallbackH
+	};
+	const alias = collection.aliases?.[name];
+	if (!alias) return;
+	const parent = collection.icons[alias.parent];
+	if (!parent) return;
+	return {
+		body: parent.body,
+		width: alias.width ?? parent.width ?? fallback,
+		height: alias.height ?? parent.height ?? fallbackH
+	};
+}
+function isMulticolorIcon(body) {
+	return /(?:fill|stroke)=["'](?!currentColor|none)[^"']+["']/i.test(body);
+}
+function renderIconsCss(icons) {
+	return `/* ox-content self-hosted Iconify icons */\n${icons.map(renderOneIconCss).join("\n")}\n`;
+}
+function renderOneIconCss(icon) {
+	const selector = iconCssSelector(icon.prefix, icon.name);
+	const url = svgToDataUrl(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${icon.width} ${icon.height}">${maskBody(icon)}</svg>`);
+	if (icon.multicolor) return `${selector}{display:inline-block;width:1em;height:1em;background-color:transparent;background-image:${url};background-repeat:no-repeat;background-size:100% 100%}`;
+	return `${selector}{display:inline-block;width:1em;height:1em;background-color:currentColor;-webkit-mask-image:${url};mask-image:${url};-webkit-mask-repeat:no-repeat;mask-repeat:no-repeat;-webkit-mask-size:100% 100%;mask-size:100% 100%}`;
+}
+function maskBody(icon) {
+	return icon.multicolor ? icon.body : icon.body.replace(/currentColor/g, "black");
+}
+function svgToDataUrl(svg) {
+	return `url("data:image/svg+xml,${svg.replace(/"/g, "'").replace(/%/g, "%25").replace(/#/g, "%23").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\s+/g, " ")}")`;
+}
+//#endregion
+//#region src/icons.ts
+/**
+* Opt-in self-hosted Iconify CSS for used and safelisted icons.
+*
+* Collection lookup stays on disk (`@iconify-json/*` / `@iconify/json`).
+* Theme embed injection composes with self-hosted font `<link>` tags.
+*/
+const ICON_ASSET_DIR = "__ox_icons__";
+const ICON_CSS_NAME = "icons.css";
+const URL_SCHEMES = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"data",
+	"mailto",
+	"file",
+	"javascript",
+	"vscode",
+	"tel",
+	"blob"
+]);
+const COLON_ICON = /(?<![A-Za-z0-9_-])([a-z][a-z0-9-]*):([a-z0-9][a-z0-9-]*)/gi;
+const CLASS_ICON = /icon-\[([a-z][a-z0-9-]*)--([a-z0-9][a-z0-9-]*)\]/gi;
+const ICON_FIELD = /(?:^|[\s,{])icon\s*:\s*["']([^"']+)["']/g;
+function resolveIconsOptions(value) {
+	if (!value) return {
+		enabled: false,
+		mode: "css-mask",
+		syntax: "unocss",
+		include: [],
+		safelist: []
+	};
+	if (value === true) return {
+		enabled: true,
+		mode: "css-mask",
+		syntax: "unocss",
+		include: [],
+		safelist: []
+	};
+	return {
+		enabled: true,
+		mode: value.mode ?? "css-mask",
+		syntax: value.syntax ?? "unocss",
+		include: value.include ?? [],
+		safelist: value.safelist ?? []
+	};
+}
+function parseIconName(value) {
+	const trimmed = value.trim();
+	const classMatch = /^icon-\[(.+)\]$/.exec(trimmed);
+	if (classMatch?.[1]) {
+		const inner = classMatch[1];
+		const sep = inner.indexOf("--");
+		if (sep <= 0) return;
+		return tokenPair(inner.slice(0, sep), inner.slice(sep + 2));
+	}
+	const sep = trimmed.indexOf(":");
+	if (sep <= 0) return;
+	return tokenPair(trimmed.slice(0, sep), trimmed.slice(sep + 1));
+}
+function normalizeIconName(value) {
+	const parsed = parseIconName(value);
+	return parsed ? `${parsed.prefix}:${parsed.name}` : value;
+}
+function tokenPair(prefix, name) {
+	if (!/^[a-z][a-z0-9-]*$/i.test(prefix) || !/^[a-z0-9][a-z0-9-]*$/i.test(name)) return;
+	if (URL_SCHEMES.has(prefix.toLowerCase())) return;
+	return {
+		prefix,
+		name
+	};
+}
+function collectIconNamesFromText(text, into = /* @__PURE__ */ new Set()) {
+	COLON_ICON.lastIndex = 0;
+	for (const match of text.matchAll(COLON_ICON)) addParsed(into, match[1], match[2]);
+	CLASS_ICON.lastIndex = 0;
+	for (const match of text.matchAll(CLASS_ICON)) addParsed(into, match[1], match[2]);
+	return into;
+}
+function collectIconFieldNames(text, into = /* @__PURE__ */ new Set()) {
+	ICON_FIELD.lastIndex = 0;
+	for (const match of text.matchAll(ICON_FIELD)) {
+		const parsed = match[1] ? parseIconName(match[1]) : void 0;
+		if (parsed) into.add(`${parsed.prefix}:${parsed.name}`);
+	}
+	return into;
+}
+function collectThemeIconNames(socialLinks) {
+	if (!Array.isArray(socialLinks)) return [];
+	const names = [];
+	for (const link of socialLinks) {
+		if (!link || typeof link !== "object") continue;
+		const icon = link.icon;
+		if (typeof icon === "string" && parseIconName(icon)) names.push(normalizeIconName(icon));
+	}
+	return names;
+}
+function addParsed(into, prefix, name) {
+	if (!prefix || !name) return;
+	const parsed = tokenPair(prefix, name);
+	if (parsed) into.add(`${parsed.prefix}:${parsed.name}`);
+}
+function iconStylesheetHref(base) {
+	return `${normalizeBasePath(base)}${ICON_ASSET_DIR}/${ICON_CSS_NAME}`;
+}
+function iconStylesheetLink(base) {
+	return `<link rel="stylesheet" href="${iconStylesheetHref(base)}">`;
+}
+function withSelfHostedIconHead(embed, enabled, base) {
+	if (!enabled) return embed;
+	const extra = iconStylesheetLink(base);
+	if (!embed) return { head: extra };
+	return {
+		...embed,
+		head: embed.head ? `${extra}\n${embed.head}` : extra
+	};
+}
+/** Copy resolved icon CSS into `outDir`. Missing collections or names become errors. */
+async function writeSelfHostedIcons(input) {
+	if (!input.options.enabled) return {
+		files: [],
+		errors: [],
+		names: []
+	};
+	const names = await collectResolvedIconNames(input);
+	const { icons, errors } = await resolveIconBodies(names, input.root);
+	const destDir = join(input.outDir, ICON_ASSET_DIR);
+	await mkdir(destDir, { recursive: true });
+	const cssPath = join(destDir, ICON_CSS_NAME);
+	await writeFile(cssPath, renderIconsCss(icons), "utf8");
+	return {
+		files: [cssPath],
+		errors,
+		names
+	};
+}
+async function collectResolvedIconNames(input) {
+	const names = /* @__PURE__ */ new Set();
+	for (const item of input.options.safelist) addName(names, item);
+	for (const item of collectThemeIconNames(input.socialLinks)) names.add(item);
+	const { names: includeNames, globs } = partitionInclude(input.options.include);
+	for (const item of includeNames) names.add(item);
+	for (const pattern of globs) {
+		const files = await glob(pattern, {
+			cwd: input.root,
+			nodir: true,
+			absolute: true,
+			ignore: ["**/node_modules/**"]
+		});
+		for (const file of files) collectIconNamesFromText(await readFile(file, "utf8"), names);
+	}
+	if (input.srcDir) {
+		const files = await glob("**/*.{md,mdx,markdown}", {
+			cwd: input.srcDir,
+			nodir: true,
+			absolute: true,
+			ignore: ["**/node_modules/**"]
+		});
+		for (const file of files) collectIconFieldNames(await readFile(file, "utf8"), names);
+	}
+	return [...names].sort();
+}
+function partitionInclude(include) {
+	const names = [];
+	const globs = [];
+	for (const entry of include) if (parseIconName(entry)) names.push(normalizeIconName(entry));
+	else globs.push(entry);
+	return {
+		names,
+		globs
+	};
+}
+function addName(into, value) {
+	const parsed = parseIconName(value);
+	if (parsed) into.add(`${parsed.prefix}:${parsed.name}`);
+}
+async function resolveIconBodies(names, root) {
+	const icons = [];
+	const errors = [];
+	const collections = /* @__PURE__ */ new Map();
+	for (const id of names) {
+		const parsed = parseIconName(id);
+		if (!parsed) continue;
+		if (!collections.has(parsed.prefix)) collections.set(parsed.prefix, await loadIconCollection(parsed.prefix, root));
+		const collection = collections.get(parsed.prefix);
+		if (!collection) {
+			errors.push(`[ox-content] icons: missing Iconify collection "${parsed.prefix}". Install @iconify-json/${parsed.prefix} or @iconify/json.`);
+			continue;
+		}
+		const found = lookupIcon(collection, parsed.name);
+		if (!found) {
+			errors.push(`[ox-content] icons: missing icon "${parsed.prefix}:${parsed.name}" in collection "${parsed.prefix}".`);
+			continue;
+		}
+		icons.push({
+			prefix: parsed.prefix,
+			name: parsed.name,
+			body: found.body,
+			width: found.width,
+			height: found.height,
+			multicolor: isMulticolorIcon(found.body)
+		});
+	}
+	return {
+		icons,
+		errors
+	};
+}
+//#endregion
+//#region src/header-chrome.ts
+/** `false` or omitted stays off. `true` or `{}` enables default flag reading. */
+function resolvePageChromeOption(value) {
+	return value === true || typeof value === "object" && value !== null;
+}
+/** Reads hide flags from frontmatter. Non-boolean values are ignored. */
+function parsePageChromeFlags(frontmatter) {
+	return {
+		sidebar: readBool(frontmatter.sidebar),
+		outline: readBool(frontmatter.outline),
+		aside: readBool(frontmatter.aside),
+		footer: readBool(frontmatter.footer),
+		navbar: readBool(frontmatter.navbar),
+		lastUpdated: readBool(frontmatter.lastUpdated),
+		editLink: readBool(frontmatter.editLink)
+	};
+}
+function readBool(value) {
+	return typeof value === "boolean" ? value : void 0;
+}
+/**
+* Picks the exact locale, its language, the default locale, then the first
+* non-empty own string in declaration order.
+*/
+function resolveLocaleLabel(text, locale, defaultLocale) {
+	if (typeof text === "string") return text;
+	const candidates = [
+		locale,
+		locale?.split("-")[0],
+		defaultLocale,
+		defaultLocale?.split("-")[0]
+	];
+	for (const candidate of candidates) {
+		if (!candidate || !Object.hasOwn(text, candidate)) continue;
+		const value = text[candidate];
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	for (const value of Object.values(text)) if (typeof value === "string" && value.length > 0) return value;
+	return "";
+}
+/** Resolves locale maps so NAPI always receives string labels. */
+function resolveHeaderNavItems(items, locale, defaultLocale) {
+	if (!items?.length) return;
+	return items.map((item) => ({
+		text: resolveLocaleLabel(item.text, locale, defaultLocale),
+		link: item.link,
+		items: resolveHeaderNavItems(item.items, locale, defaultLocale)
+	}));
+}
+//#endregion
 //#region src/theme-tokens.ts
 const TOKEN_PREFIX = "--octc-";
 const TOKEN_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
@@ -61,16 +692,15 @@ function assertTokenName(name) {
 //#endregion
 //#region src/theme.ts
 /**
-* Theme API for ox-content SSG
-*
-* Provides VitePress-like theming with default theme + customization.
-*/
-/**
 * Default theme configuration.
 * Based on the current ox-content SSG styles.
 */
 const defaultTheme = {
 	name: "default",
+	viewTransitions: true,
+	aside: false,
+	breadcrumbs: false,
+	headingPermalink: "hover",
 	colors: {
 		primary: "#4f6fae",
 		primaryHover: "#425f96",
@@ -208,12 +838,18 @@ function resolveTheme(config) {
 	const merged = mergeThemes(...chain.map(withDerivedCodeBackgroundTop));
 	return {
 		name: merged.name ?? "custom",
+		viewTransitions: merged.viewTransitions ?? defaultTheme.viewTransitions ?? true,
+		aside: merged.aside ?? defaultTheme.aside ?? false,
+		breadcrumbs: resolveThemeFlag(merged.breadcrumbs),
+		headingPermalink: merged.headingPermalink === "always" ? "always" : "hover",
 		colors: merged.colors ?? defaultTheme.colors,
 		darkColors: merged.darkColors ?? defaultTheme.darkColors,
 		fonts: merged.fonts ?? defaultTheme.fonts,
 		entryPage: merged.entryPage ?? defaultTheme.entryPage,
 		layout: merged.layout ?? defaultTheme.layout,
 		header: merged.header ?? defaultTheme.header,
+		nav: merged.nav,
+		announcement: merged.announcement,
 		footer: merged.footer ?? defaultTheme.footer,
 		socialLinks: merged.socialLinks ?? defaultTheme.socialLinks,
 		sidebar: merged.sidebar ?? [],
@@ -258,9 +894,13 @@ function withDerivedCodeBackgroundTop(theme) {
 /**
 * Converts resolved theme to the format expected by Rust NAPI.
 */
-function themeToNapi(theme) {
+function themeToNapi(theme, locale, base, iconsEnabled = false) {
 	const socialLinks = socialLinksToNapi(theme.socialLinks);
 	return {
+		viewTransitions: theme.viewTransitions,
+		aside: theme.aside,
+		breadcrumbs: theme.breadcrumbs,
+		headingPermalink: theme.headingPermalink,
 		colors: theme.colors.primary ? {
 			primary: theme.colors.primary,
 			primaryHover: theme.colors.primaryHover,
@@ -285,10 +925,7 @@ function themeToNapi(theme) {
 			codeBackgroundTop: theme.darkColors.codeBackgroundTop,
 			codeText: theme.darkColors.codeText
 		} : void 0,
-		fonts: theme.fonts.sans ? {
-			sans: theme.fonts.sans,
-			mono: theme.fonts.mono
-		} : void 0,
+		fonts: flattenThemeFonts(theme.fonts),
 		entryPage: theme.entryPage.mode ? { mode: theme.entryPage.mode } : void 0,
 		layout: theme.layout.sidebarWidth ? {
 			sidebarWidth: theme.layout.sidebarWidth,
@@ -303,12 +940,14 @@ function themeToNapi(theme) {
 			logoWidth: theme.header.logoWidth,
 			logoHeight: theme.header.logoHeight
 		} : void 0,
+		nav: resolveHeaderNavItems(theme.nav, locale),
+		announcement: theme.announcement?.text ? theme.announcement : void 0,
 		footer: theme.footer.message || theme.footer.copyright ? {
 			message: theme.footer.message,
 			copyright: theme.footer.copyright
 		} : void 0,
 		socialLinks,
-		embed: Object.keys(theme.embed).length > 0 ? theme.embed : void 0,
+		embed: withSelfHostedIconHead(withSelfHostedFontHead(theme.embed, theme.fonts, base), iconsEnabled, base),
 		css: themeCss(theme) || void 0,
 		js: theme.js || void 0
 	};
@@ -318,9 +957,9 @@ function themeToNapi(theme) {
 * land after the typed color variables the Rust renderer emits.
 */
 function themeCss(theme) {
-	const tokenCss = tokensToCss(theme.tokens, theme.darkTokens);
-	if (!tokenCss) return theme.css;
-	return theme.css ? `${tokenCss}\n${theme.css}` : tokenCss;
+	const prefix = [tokensToCss(theme.tokens, theme.darkTokens), namedFontVarsCss(theme.fonts)].filter(Boolean).join("\n");
+	if (!prefix) return theme.css;
+	return theme.css ? `${prefix}\n${theme.css}` : prefix;
 }
 function socialLinksToNapi(links) {
 	if (Array.isArray(links)) {
@@ -340,6 +979,9 @@ function socialLinksToNapi(links) {
 		discord: links.discord
 	} : void 0;
 }
+function resolveThemeFlag(value) {
+	return value === true || typeof value === "object" && value !== null;
+}
 //#endregion
 //#region src/vitepress.ts
 function isRecord(value) {
@@ -595,6 +1237,6 @@ function normalizeVitePressFrontmatter(frontmatter) {
 	return importNapiModuleSync().normalizeVitePressFrontmatter(frontmatter);
 }
 //#endregion
-export { normalizeVitePressFrontmatter as a, mergeThemes as c, importNapiModule as d, importNapiModuleSync as f, generateVitePressMigrationConfig as i, resolveTheme as l, convertVitePressSidebar as n, defaultTheme as o, fromVitePressConfig as r, defineTheme as s, convertVitePressNav as t, themeToNapi as u };
+export { writeSelfHostedIcons as _, normalizeVitePressFrontmatter as a, importNapiModuleSync as b, mergeThemes as c, parsePageChromeFlags as d, resolveHeaderNavItems as f, withSelfHostedIconHead as g, resolveIconsOptions as h, generateVitePressMigrationConfig as i, resolveTheme as l, resolvePageChromeOption as m, convertVitePressSidebar as n, defaultTheme as o, resolveLocaleLabel as p, fromVitePressConfig as r, defineTheme as s, convertVitePressNav as t, themeToNapi as u, writeSelfHostedThemeFonts as v, importNapiModule as y };
 
 //# sourceMappingURL=vitepress.mjs.map