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

package/dist/vitepress.cjs

@@ -37,8 +37,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+let node_module = require("node:module");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_fs_promises = require("node:fs/promises");
+let node_crypto = require("node:crypto");
+let glob = require("glob");
 //#region src/napi.ts
-const requireNapi = (0, require("node:module").createRequire)(require("url").pathToFileURL(__filename).href);
+const requireNapi = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
 function getDefaultExport(value) {
 	if (!value || typeof value !== "object" || !("default" in value)) return;
 	const defaultExport = value.default;
@@ -67,6 +74,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 ?? (0, node_path.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 (0, node_fs_promises.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 (0, node_fs_promises.readFile)(file)
+	};
+}
+function resolveLocalPath(root, spec) {
+	if ((0, node_path.isAbsolute)(spec)) return spec;
+	if (spec.startsWith("@") || !spec.startsWith(".")) return (0, node_path.resolve)(root, "node_modules", spec);
+	return (0, node_path.resolve)(root, spec);
+}
+async function findDirectoryFont(dir, face) {
+	const filesDir = (0, node_fs.existsSync)((0, node_path.join)(dir, "files")) ? (0, node_path.join)(dir, "files") : dir;
+	const names = (await (0, node_fs_promises.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 (0, node_path.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 (0, node_fs_promises.mkdir)(cacheDir, { recursive: true });
+	const dest = (0, node_path.join)(cacheDir, `${(0, node_crypto.createHash)("sha256").update(url).digest("hex").slice(0, 16)}${ext}`);
+	if ((0, node_fs.existsSync)(dest)) return (0, node_fs_promises.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 (0, node_fs_promises.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 = (0, node_path.join)(options.outDir, FONT_ASSET_DIR);
+	await (0, node_fs_promises.mkdir)(destDir, { recursive: true });
+	const written = [];
+	for (const face of acquired) {
+		const dest = (0, node_path.join)(destDir, face.fileName);
+		await (0, node_fs_promises.writeFile)(dest, face.bytes);
+		written.push(dest);
+	}
+	const cssPath = (0, node_path.join)(destDir, FONT_CSS_NAME);
+	await (0, node_fs_promises.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 = [(0, node_path.join)(root, "node_modules", "@iconify-json", prefix, "icons.json"), (0, node_path.join)(root, "node_modules", "@iconify", "json", "json", `${prefix}.json`)];
+	for (const file of files) if ((0, node_fs.existsSync)(file)) return file;
+	return resolveViaNode(prefix, root);
+}
+function resolveViaNode(prefix, root) {
+	try {
+		return (0, node_module.createRequire)((0, node_path.join)(root, "package.json")).resolve(`@iconify-json/${prefix}/icons.json`);
+	} catch {
+		try {
+			return (0, node_module.createRequire)((0, node_path.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 (0, node_fs_promises.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 = (0, node_path.join)(input.outDir, ICON_ASSET_DIR);
+	await (0, node_fs_promises.mkdir)(destDir, { recursive: true });
+	const cssPath = (0, node_path.join)(destDir, ICON_CSS_NAME);
+	await (0, node_fs_promises.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 (0, glob.glob)(pattern, {
+			cwd: input.root,
+			nodir: true,
+			absolute: true,
+			ignore: ["**/node_modules/**"]
+		});
+		for (const file of files) collectIconNamesFromText(await (0, node_fs_promises.readFile)(file, "utf8"), names);
+	}
+	if (input.srcDir) {
+		const files = await (0, glob.glob)("**/*.{md,mdx,markdown}", {
+			cwd: input.srcDir,
+			nodir: true,
+			absolute: true,
+			ignore: ["**/node_modules/**"]
+		});
+		for (const file of files) collectIconFieldNames(await (0, node_fs_promises.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-]*$/;
@@ -99,16 +732,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",
@@ -246,12 +878,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 ?? [],
@@ -296,9 +934,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,
@@ -323,10 +965,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,
@@ -341,12 +980,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
 	};
@@ -356,9 +997,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)) {
@@ -378,6 +1019,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) {
@@ -717,6 +1361,36 @@ Object.defineProperty(exports, "normalizeVitePressFrontmatter", {
 		return normalizeVitePressFrontmatter;
 	}
 });
+Object.defineProperty(exports, "parsePageChromeFlags", {
+	enumerable: true,
+	get: function() {
+		return parsePageChromeFlags;
+	}
+});
+Object.defineProperty(exports, "resolveHeaderNavItems", {
+	enumerable: true,
+	get: function() {
+		return resolveHeaderNavItems;
+	}
+});
+Object.defineProperty(exports, "resolveIconsOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveIconsOptions;
+	}
+});
+Object.defineProperty(exports, "resolveLocaleLabel", {
+	enumerable: true,
+	get: function() {
+		return resolveLocaleLabel;
+	}
+});
+Object.defineProperty(exports, "resolvePageChromeOption", {
+	enumerable: true,
+	get: function() {
+		return resolvePageChromeOption;
+	}
+});
 Object.defineProperty(exports, "resolveTheme", {
 	enumerable: true,
 	get: function() {
@@ -729,5 +1403,23 @@ Object.defineProperty(exports, "themeToNapi", {
 		return themeToNapi;
 	}
 });
+Object.defineProperty(exports, "withSelfHostedIconHead", {
+	enumerable: true,
+	get: function() {
+		return withSelfHostedIconHead;
+	}
+});
+Object.defineProperty(exports, "writeSelfHostedIcons", {
+	enumerable: true,
+	get: function() {
+		return writeSelfHostedIcons;
+	}
+});
+Object.defineProperty(exports, "writeSelfHostedThemeFonts", {
+	enumerable: true,
+	get: function() {
+		return writeSelfHostedThemeFonts;
+	}
+});
 
 //# sourceMappingURL=vitepress.cjs.map