@ox-content/vite-plugin 2.16.0 → 2.26.0

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import { i as importNapiModuleSync, n as transformMermaidStatic, r as importNapiModule, t as mermaidClientScript } from "./mermaid.mjs";
+import { n as importNapiModuleSync, t as importNapiModule } from "./napi.mjs";
+import { n as transformMermaidStatic, t as mermaidClientScript } from "./mermaid2.mjs";
 import { n as resetTabGroupCounter, r as transformTabs, t as generateTabsCSS } from "./tabs2.mjs";
 import { n as transformYouTube, t as extractVideoId } from "./youtube2.mjs";
 import { a as fetchRepoData, c as parseGitHubPermalink, d as transformGitHub, i as fetchGitHubSource, l as prefetchGitHubRepos, n as collectGitHubSources, s as parseGitHubLineRange, t as collectGitHubRepos, u as prefetchGitHubSources } from "./github2.mjs";
@@ -12,9 +13,9 @@ import rehypeStringify from "rehype-stringify";
 import { createHighlighter } from "shiki";
 import * as path from "node:path";
 import { dirname, join } from "node:path";
-import * as fs$2 from "fs";
-import * as fs$1 from "fs/promises";
+import * as fs$2 from "fs/promises";
 import * as crypto from "crypto";
+import * as fs$1 from "fs";
 import { glob } from "glob";
 import * as fs from "node:fs/promises";
 import { mkdir, writeFile } from "node:fs/promises";
@@ -322,7 +323,7 @@ async function transformAllPlugins(html, options = {}) {
 		result = await transformOgp(result, void 0, typeof ogpOptions === "object" ? ogpOptions : {});
 	}
 	if (mermaid) {
-		const { transformMermaidStatic } = await import("./mermaid2.mjs");
+		const { transformMermaidStatic } = await import("./mermaid.mjs");
 		result = await transformMermaidStatic(result);
 	}
 	return result;
@@ -393,9 +394,11 @@ function protectMermaidSvgs(html) {
 * Restore protected mermaid SVG blocks from placeholders.
 */
 function restoreMermaidSvgs(html, svgs) {
-	let result = html;
-	for (const [placeholder, content] of svgs) result = result.replace(placeholder, content);
-	return result;
+	if (svgs.size === 0) return html;
+	return html.replace(/<!--ox-mermaid-\d+-->/g, (placeholder) => {
+		const content = svgs.get(placeholder);
+		return content !== void 0 ? content : placeholder;
+	});
 }
 //#endregion
 //#region src/transform.ts
@@ -565,67 +568,7 @@ if (import.meta.hot) {
 `;
 }
 //#endregion
-//#region src/nav-generator.ts
-function generateNavMetadata(docs, basePath = "/api") {
-	return importNapiModuleSync().generateDocsNavMetadata(docs.map((doc) => doc.file), basePath);
-}
-function generateNavCode(navItems, exportName = "apiNav") {
-	return importNapiModuleSync().generateDocsNavCode(navItems, exportName);
-}
-//#endregion
 //#region src/docs.ts
-/**
-* Source Documentation Extraction and Generation
-*
-* This module provides comprehensive tools for extracting JSDoc/TSDoc comments
-* from TypeScript/JavaScript source files and automatically generating Markdown
-* documentation.
-*
-* ## Features
-*
-* - **Automatic Extraction**: Parses JSDoc comments from functions, classes, interfaces, and types
-* - **Flexible Filtering**: Include/exclude patterns for selective documentation
-* - **Markdown Generation**: Converts extracted docs to organized Markdown files
-* - **Navigation Generation**: Auto-generates sidebar navigation metadata
-* - **GitHub Links**: Includes clickable links to source code on GitHub
-*
-* ## Supported JSDoc Tags
-*
-* - `@param {type} name - description` - Function parameter documentation
-* - `@returns {type} description` - Return value documentation
-* - `@example` - Code examples (multi-line blocks)
-* - `@private` - Mark item as private (excluded from docs if private=false)
-* - `@default value` - Default parameter value
-* - Custom tags are preserved in the `tags` field
-*
-* ## Usage Flow
-*
-* 1. Call `extractDocs()` to parse source files
-* 2. Call `generateMarkdown()` to create Markdown content
-* 3. Call `writeDocs()` to write files to output directory
-* 4. Generated nav.ts can be imported for sidebar navigation
-*
-* @example
-* ```typescript
-* import { extractDocs, generateMarkdown, writeDocs } from './docs';
-*
-* const docsOptions = {
-*   enabled: true,
-*   src: ['./src'],
-*   out: './docs/api',
-*   include: ['**\/*.ts'],
-*   exclude: ['**\/*.test.ts'],
-*   groupBy: 'file',
-*   githubUrl: 'https://github.com/user/project',
-* };
-*
-* const extracted = await extractDocs(['./src'], docsOptions);
-* const markdown = generateMarkdown(extracted, docsOptions);
-* await writeDocs(markdown, './docs/api', extracted, docsOptions);
-* ```
-*/
-const DOCS_MANIFEST_FILE = ".ox-content-docs-manifest.json";
-const DOCS_DATA_FILE = "docs.json";
 const DEFAULT_DOCS_INCLUDE = [
 	"**/*.ts",
 	"**/*.tsx",
@@ -715,20 +658,12 @@ async function extractDocs(srcDirs, options) {
 			entries: doc.entries
 		}));
 	}
-	const extractFileDocEntries = napi.extractFileDocEntries;
-	if (!extractFileDocEntries) throw new Error("[ox-content] extractFileDocEntries is not available from @ox-content/napi.");
-	const results = [];
-	for (const srcDir of srcDirs) {
-		const files = napi.collectDocsSourceFiles(srcDir, options.include, options.exclude);
-		for (const file of files) {
-			const entries = extractFileDocEntries(file, options.private, options.internal);
-			if (entries.length > 0) results.push({
-				file,
-				entries
-			});
-		}
-	}
-	return results;
+	const extractDocsFromDirectories = napi.extractDocsFromDirectories;
+	if (!extractDocsFromDirectories) throw new Error("[ox-content] extractDocsFromDirectories is not available from @ox-content/napi.");
+	return extractDocsFromDirectories(srcDirs, options.include, options.exclude, options.private, options.internal).map((doc) => ({
+		file: doc.file,
+		entries: doc.entries
+	}));
 }
 /**
 * Generates Markdown documentation from extracted docs.
@@ -738,42 +673,25 @@ function generateMarkdown(docs, options) {
 	if (typeof napi.generateDocsMarkdown !== "function") throw new Error("[ox-content] generateDocsMarkdown is not available from @ox-content/napi. Please rebuild the NAPI package.");
 	return napi.generateDocsMarkdown(toRustDocsModules(docs), {
 		groupBy: options.groupBy,
-		githubUrl: options.githubUrl
+		githubUrl: options.githubUrl,
+		linkStyle: options.linkStyle,
+		basePath: options.basePath,
+		pathStrategy: options.pathStrategy
 	});
 }
 /**
 * Writes generated documentation to the output directory.
 */
 async function writeDocs(docs, outDir, extractedDocs, options) {
-	await fs$2.promises.mkdir(outDir, { recursive: true });
-	const generatedFiles = new Set(Object.keys(docs));
-	if (extractedDocs && options?.generateNav && options.groupBy === "file") generatedFiles.add("nav.ts");
-	if (extractedDocs) generatedFiles.add(DOCS_DATA_FILE);
-	const manifestPath = path$1.join(outDir, DOCS_MANIFEST_FILE);
-	let previousFiles = [];
-	try {
-		previousFiles = JSON.parse(await fs$2.promises.readFile(manifestPath, "utf-8"));
-	} catch {
-		previousFiles = [];
-	}
-	for (const staleFile of previousFiles) {
-		if (generatedFiles.has(staleFile)) continue;
-		await fs$2.promises.rm(path$1.join(outDir, staleFile), { force: true });
-	}
-	for (const [fileName, content] of Object.entries(docs)) {
-		const filePath = path$1.join(outDir, fileName);
-		await fs$2.promises.writeFile(filePath, content, "utf-8");
-	}
-	if (extractedDocs && options?.generateNav && options.groupBy === "file") {
-		const navCode = generateNavCode(generateNavMetadata(extractedDocs, "/api"), "apiNav");
-		const navFilePath = path$1.join(outDir, "nav.ts");
-		await fs$2.promises.writeFile(navFilePath, navCode, "utf-8");
-	}
-	if (extractedDocs) {
-		const napi = importNapiModuleSync();
-		await fs$2.promises.writeFile(path$1.join(outDir, DOCS_DATA_FILE), napi.generateDocsDataJson(toRustDocsModules(extractedDocs), (/* @__PURE__ */ new Date()).toISOString()), "utf-8");
-	}
-	await fs$2.promises.writeFile(manifestPath, JSON.stringify([...generatedFiles].sort(), null, 2), "utf-8");
+	const napi = importNapiModuleSync();
+	if (typeof napi.writeGeneratedDocs !== "function") throw new Error("[ox-content] writeGeneratedDocs is not available from @ox-content/napi. Please rebuild the NAPI package.");
+	napi.writeGeneratedDocs(docs, outDir, extractedDocs ? toRustDocsModules(extractedDocs) : void 0, {
+		generateNav: options?.generateNav ?? false,
+		groupBy: options?.groupBy ?? "file",
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		basePath: options?.basePath,
+		pathStrategy: options?.pathStrategy
+	});
 }
 function toRustDocsModules(docs) {
 	return docs.map((doc) => ({
@@ -798,9 +716,6 @@ function toRustDocsModules(docs) {
 		}))
 	}));
 }
-/**
-* Resolves docs options with defaults.
-*/
 function resolveDocsOptions(options) {
 	if (options === false) return false;
 	const opts = options || {};
@@ -821,6 +736,9 @@ function resolveDocsOptions(options) {
 		toc: false,
 		groupBy: opts.groupBy ?? "file",
 		githubUrl: opts.githubUrl,
+		linkStyle: opts.linkStyle ?? "markdown",
+		basePath: opts.basePath,
+		pathStrategy: opts.pathStrategy ?? "flat",
 		generateNav: opts.generateNav ?? true
 	};
 }
@@ -908,6 +826,8 @@ async function renderHtmlToPng(page, html, width, height, publicDir) {
 }
 //#endregion
 //#region src/og-image/browser.ts
+const PLAYWRIGHT_BROWSER_INSTALL_HINT = "Install Playwright browsers with `npx playwright install chromium` to enable OG image generation.";
+let chromiumUnavailableWarned = false;
 /**
 * Opens a Chromium browser and returns a session for rendering OG images.
 * Returns null if Playwright/Chromium is not available.
@@ -947,10 +867,20 @@ async function openBrowser() {
 			}
 		};
 	} catch (err) {
-		console.warn("[ox-content:og-image] Chromium not available, skipping OG image generation.", err instanceof Error ? err.message : err);
+		warnChromiumUnavailableOnce(err);
 		return null;
 	}
 }
+function warnChromiumUnavailableOnce(err) {
+	if (chromiumUnavailableWarned) return;
+	chromiumUnavailableWarned = true;
+	console.warn(`[ox-content:og-image] Chromium not available, skipping OG image generation. ${formatChromiumUnavailableDetail(err)}`);
+}
+function formatChromiumUnavailableDetail(err) {
+	const message = err instanceof Error ? err.message : String(err);
+	if (message.includes("Executable doesn't exist") || message.includes("Please run the following command to download new browsers")) return PLAYWRIGHT_BROWSER_INSTALL_HINT;
+	return message.split(/\r?\n/).find((line) => line.trim())?.trim() ?? "Unknown launch error.";
+}
 //#endregion
 //#region src/og-image/template.ts
 /**
@@ -1058,7 +988,7 @@ function computeCacheKey(templateSource, props, width, height) {
 async function getCached(cacheDir, key) {
 	const filePath = path$1.join(cacheDir, `${key}.png`);
 	try {
-		return await fs$1.readFile(filePath);
+		return await fs$2.readFile(filePath);
 	} catch {
 		return null;
 	}
@@ -1067,9 +997,9 @@ async function getCached(cacheDir, key) {
 * Writes a PNG buffer to the cache.
 */
 async function writeCache(cacheDir, key, png) {
-	await fs$1.mkdir(cacheDir, { recursive: true });
+	await fs$2.mkdir(cacheDir, { recursive: true });
 	const filePath = path$1.join(cacheDir, `${key}.png`);
-	await fs$1.writeFile(filePath, png);
+	await fs$2.writeFile(filePath, png);
 }
 //#endregion
 //#region \0@oxc-project+runtime@0.129.0/helpers/usingCtx.js
@@ -1761,6 +1691,32 @@ function generateBareHtmlPage(content, title) {
 	return importNapiModuleSync().generateSsgBareHtml(content, title);
 }
 /**
+* Per-build cache for the Rust-facing nav conversion. `navGroups` is the same
+* `context.navItems` reference for every page in a build, so the deep recursive
+* copy below only needs to run once per build instead of once per page.
+*/
+const navGroupsForRustCache = /* @__PURE__ */ new WeakMap();
+function toRustNavItem(item) {
+	return {
+		title: item.title,
+		path: item.path,
+		href: item.href,
+		children: item.children?.map(toRustNavItem),
+		collapsed: item.collapsed
+	};
+}
+function convertNavGroupsForRust(navGroups) {
+	const cached = navGroupsForRustCache.get(navGroups);
+	if (cached) return cached;
+	const converted = navGroups.map((group) => ({
+		title: group.title,
+		collapsed: group.collapsed,
+		items: group.items.map(toRustNavItem)
+	}));
+	navGroupsForRustCache.set(navGroups, converted);
+	return converted;
+}
+/**
 * Generates HTML page with navigation using Rust NAPI bindings.
 */
 async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, theme, locale, availableLocales) {
@@ -1772,18 +1728,7 @@ async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, th
 		children: entry.children?.map(toRustTocEntry) ?? []
 	});
 	const tocForRust = pageData.toc.map(toRustTocEntry);
-	const toRustNavItem = (item) => ({
-		title: item.title,
-		path: item.path,
-		href: item.href,
-		children: item.children?.map(toRustNavItem),
-		collapsed: item.collapsed
-	});
-	const navGroupsForRust = navGroups.map((group) => ({
-		title: group.title,
-		collapsed: group.collapsed,
-		items: group.items.map(toRustNavItem)
-	}));
+	const navGroupsForRust = convertNavGroupsForRust(navGroups);
 	const themeForRust = theme ? themeToNapi(theme) : void 0;
 	const entryPageForRust = pageData.entryPage ? {
 		hero: pageData.entryPage.hero ? {
@@ -1840,8 +1785,8 @@ async function generateHtmlPage(pageData, navGroups, siteName, base, ogImage, th
 async function externalizeSharedPageAssets(pages, outDir, base) {
 	const optimized = (await importNapiModule()).externalizeSsgAssets(pages, outDir, base);
 	await Promise.all(optimized.assets.map(async (asset) => {
-		await fs$1.mkdir(path$1.dirname(asset.outputPath), { recursive: true });
-		await fs$1.writeFile(asset.outputPath, asset.content, "utf-8");
+		await fs$2.mkdir(path$1.dirname(asset.outputPath), { recursive: true });
+		await fs$2.writeFile(asset.outputPath, asset.content, "utf-8");
 	}));
 	return {
 		pages: optimized.pages,
@@ -1903,149 +1848,201 @@ async function buildSsg(options, root) {
 	};
 	const srcDir = path$1.resolve(root, options.srcDir);
 	const outDir = path$1.resolve(root, options.outDir);
-	const base = options.base.endsWith("/") ? options.base : options.base + "/";
 	const generatedFiles = [];
-	const generatedPages = [];
 	const errors = [];
-	if (ssgOptions.clean) try {
-		await fs$1.rm(outDir, {
+	await cleanOutputDirectory(ssgOptions, outDir);
+	const markdownFiles = await collectMarkdownFiles(srcDir, options.extensions);
+	const context = await createBuildSsgContext(options, root, srcDir, outDir, markdownFiles);
+	const collected = await collectPageResults(context, markdownFiles);
+	errors.push(...collected.errors);
+	await generateOgImageAssets(context, collected, generatedFiles, errors);
+	await writeGeneratedPages(await generateHtmlPages(context, collected.pageResults, collected, errors), context, generatedFiles);
+	return {
+		files: generatedFiles,
+		errors
+	};
+}
+async function cleanOutputDirectory(ssgOptions, outDir) {
+	if (!ssgOptions.clean) return;
+	try {
+		await fs$2.rm(outDir, {
 			recursive: true,
 			force: true
 		});
 	} catch {}
-	const markdownFiles = await collectMarkdownFiles(srcDir, options.extensions);
-	const navItems = resolveNavigationGroups(ssgOptions.navigation, base, ssgOptions.extension) ?? (ssgOptions.theme?.sidebar.length ? buildThemeNavItems(ssgOptions.theme.sidebar, base, ssgOptions.extension) : buildNavItems(markdownFiles, srcDir, base, ssgOptions.extension));
-	let siteName = ssgOptions.siteName ?? "Documentation";
-	if (!ssgOptions.siteName) try {
+}
+async function createBuildSsgContext(options, root, srcDir, outDir, markdownFiles) {
+	const ssgOptions = options.ssg;
+	const base = options.base.endsWith("/") ? options.base : options.base + "/";
+	return {
+		options,
+		ssgOptions,
+		root,
+		srcDir,
+		outDir,
+		base,
+		navItems: resolveNavigationGroups(ssgOptions.navigation, base, ssgOptions.extension) ?? (ssgOptions.theme?.sidebar.length ? buildThemeNavItems(ssgOptions.theme.sidebar, base, ssgOptions.extension) : buildNavItems(markdownFiles, srcDir, base, ssgOptions.extension)),
+		siteName: await resolveSiteName$1(root, ssgOptions),
+		shouldGenerateOgImages: (options.ogImage || ssgOptions.generateOgImage) && !ssgOptions.bare,
+		napi: ssgOptions.lastUpdated ? await importNapiModule() : void 0
+	};
+}
+async function resolveSiteName$1(root, ssgOptions) {
+	if (ssgOptions.siteName) return ssgOptions.siteName;
+	try {
 		const pkgPath = path$1.join(root, "package.json");
-		const pkg = JSON.parse(await fs$1.readFile(pkgPath, "utf-8"));
-		if (pkg.name) siteName = formatTitle(pkg.name);
-	} catch {}
-	const ogImageEntries = [];
-	const ogImageInputPaths = [];
-	const ogImageUrlMap = /* @__PURE__ */ new Map();
-	const shouldGenerateOgImages = (options.ogImage || ssgOptions.generateOgImage) && !ssgOptions.bare;
-	const pageResults = [];
-	const napi = ssgOptions.lastUpdated ? await importNapiModule() : void 0;
+		const pkg = JSON.parse(await fs$2.readFile(pkgPath, "utf-8"));
+		return pkg.name ? formatTitle(pkg.name) : "Documentation";
+	} catch {
+		return "Documentation";
+	}
+}
+async function collectPageResults(context, markdownFiles) {
+	const collected = {
+		pageResults: [],
+		ogImageEntries: [],
+		ogImageInputPaths: [],
+		ogImageUrlMap: /* @__PURE__ */ new Map(),
+		errors: []
+	};
 	for (const inputPath of markdownFiles) try {
-		const result = await transformMarkdown(await fs$1.readFile(inputPath, "utf-8"), inputPath, options, {
-			convertMdLinks: true,
-			baseUrl: base,
-			sourcePath: inputPath
-		});
-		const frontmatter = normalizeVitePressFrontmatter(result.frontmatter);
-		let transformedHtml = result.html;
-		const { html: protectedHtml, svgs: mermaidSvgs } = protectMermaidSvgs(transformedHtml);
-		transformedHtml = protectedHtml;
-		const pluginOptions = {
-			tabs: true,
-			youtube: true,
-			github: options.embeds.github,
-			openGraph: options.embeds.openGraph,
-			mermaid: true,
-			githubToken: process.env.GITHUB_TOKEN
-		};
-		transformedHtml = await transformAllPlugins(transformedHtml, pluginOptions);
-		if (hasIslands(transformedHtml)) transformedHtml = (await transformIslands(transformedHtml)).html;
-		transformedHtml = restoreMermaidSvgs(transformedHtml, mermaidSvgs);
-		const title = extractTitle$1(transformedHtml, frontmatter);
-		const description = frontmatter.description;
-		const routePaths = getRoutePaths(inputPath, srcDir, outDir, base, ssgOptions.extension, ssgOptions.siteUrl);
-		pageResults.push({
-			inputPath,
-			routePaths,
-			transformedHtml,
-			title,
-			description,
-			lastUpdated: napi?.getGitLastUpdated(inputPath, root) ?? void 0,
-			frontmatter,
-			toc: result.toc
-		});
-		if (shouldGenerateOgImages) {
-			const { layout: _layout, ...frontmatterRest } = frontmatter;
-			ogImageEntries.push({
-				props: {
-					...frontmatterRest,
-					title,
-					description,
-					siteName
-				},
-				outputPath: routePaths.ogImagePath
-			});
-			ogImageInputPaths.push(inputPath);
-			ogImageUrlMap.set(inputPath, routePaths.ogImageUrl);
-		}
+		const pageResult = await transformSsgPage(context, inputPath);
+		collected.pageResults.push(pageResult);
+		collectOgImageEntry(context, pageResult, collected);
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
-		errors.push(`Failed to process ${inputPath}: ${errorMessage}`);
+		collected.errors.push(`Failed to process ${inputPath}: ${errorMessage}`);
 	}
-	if (shouldGenerateOgImages && ogImageEntries.length > 0) try {
-		const ogResults = await generateOgImages(ogImageEntries, options.ogImageOptions, root);
-		let ogSuccessCount = 0;
-		for (let i = 0; i < ogResults.length; i++) {
-			const result = ogResults[i];
-			if (result.error) {
-				errors.push(`OG image failed for ${result.outputPath}: ${result.error}`);
-				ogImageUrlMap.delete(ogImageInputPaths[i]);
-			} else {
-				generatedFiles.push(result.outputPath);
-				ogSuccessCount++;
-			}
-		}
-		if (ogSuccessCount > 0) {
-			const cachedCount = ogResults.filter((r) => r.cached && !r.error).length;
-			console.log(`[ox-content:og-image] Generated ${ogSuccessCount} OG images` + (cachedCount > 0 ? ` (${cachedCount} from cache)` : ""));
-		}
+	return collected;
+}
+async function transformSsgPage(context, inputPath) {
+	const result = await transformMarkdown(await fs$2.readFile(inputPath, "utf-8"), inputPath, context.options, {
+		convertMdLinks: true,
+		baseUrl: context.base,
+		sourcePath: inputPath
+	});
+	const frontmatter = normalizeVitePressFrontmatter(result.frontmatter);
+	const transformedHtml = await transformSsgHtml(result.html, context.options);
+	const title = extractTitle$1(transformedHtml, frontmatter);
+	return {
+		inputPath,
+		routePaths: getRoutePaths(inputPath, context.srcDir, context.outDir, context.base, context.ssgOptions.extension, context.ssgOptions.siteUrl),
+		transformedHtml,
+		title,
+		description: frontmatter.description,
+		lastUpdated: context.napi?.getGitLastUpdated(inputPath, context.root) ?? void 0,
+		frontmatter,
+		toc: result.toc
+	};
+}
+async function transformSsgHtml(html, options) {
+	const { html: protectedHtml, svgs: mermaidSvgs } = protectMermaidSvgs(html);
+	let transformedHtml = await transformAllPlugins(protectedHtml, {
+		tabs: true,
+		youtube: true,
+		github: options.embeds.github,
+		openGraph: options.embeds.openGraph,
+		mermaid: true,
+		githubToken: process.env.GITHUB_TOKEN
+	});
+	if (hasIslands(transformedHtml)) transformedHtml = (await transformIslands(transformedHtml)).html;
+	return restoreMermaidSvgs(transformedHtml, mermaidSvgs);
+}
+function collectOgImageEntry(context, pageResult, collected) {
+	if (!context.shouldGenerateOgImages) return;
+	const { layout: _layout, ...frontmatterRest } = pageResult.frontmatter;
+	collected.ogImageEntries.push({
+		props: {
+			...frontmatterRest,
+			title: pageResult.title,
+			description: pageResult.description,
+			siteName: context.siteName
+		},
+		outputPath: pageResult.routePaths.ogImagePath
+	});
+	collected.ogImageInputPaths.push(pageResult.inputPath);
+	collected.ogImageUrlMap.set(pageResult.inputPath, pageResult.routePaths.ogImageUrl);
+}
+async function generateOgImageAssets(context, collected, generatedFiles, errors) {
+	if (!context.shouldGenerateOgImages || collected.ogImageEntries.length === 0) return;
+	try {
+		const ogResults = await generateOgImages(collected.ogImageEntries, context.options.ogImageOptions, context.root);
+		if (clearMissingBrowserOgImages(ogResults, collected)) return;
+		reportOgImageResults(ogResults, collected, generatedFiles, errors);
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
 		console.warn(`[ox-content:og-image] Batch generation failed: ${errorMessage}`);
-		ogImageUrlMap.clear();
+		collected.ogImageUrlMap.clear();
 	}
-	for (const pageResult of pageResults) try {
-		const { inputPath, routePaths, transformedHtml, title, description, lastUpdated, frontmatter, toc } = pageResult;
-		let pageOgImage = ssgOptions.ogImage;
-		if (shouldGenerateOgImages && ogImageUrlMap.has(inputPath)) pageOgImage = ogImageUrlMap.get(inputPath);
-		let entryPage;
-		if (frontmatter.layout === "entry") entryPage = {
-			hero: frontmatter.hero,
-			features: frontmatter.features
-		};
-		let html;
-		if (ssgOptions.bare) html = generateBareHtmlPage(transformedHtml, title);
-		else {
-			const pageData = {
-				title,
-				description,
-				content: transformedHtml,
-				toc,
-				lastUpdated,
-				frontmatter,
-				path: routePaths.urlPath,
-				href: routePaths.href,
-				entryPage
-			};
-			html = await generateHtmlPage(pageData, navItems, siteName, base, pageOgImage, ssgOptions.theme, getPageLocale(pageData.path, options.i18n), options.i18n ? options.i18n.locales : void 0);
+}
+function clearMissingBrowserOgImages(ogResults, collected) {
+	if (!(ogResults.length > 0 && ogResults.every((result) => result.error === "Chromium not available"))) return false;
+	for (const inputPath of collected.ogImageInputPaths) collected.ogImageUrlMap.delete(inputPath);
+	return true;
+}
+function reportOgImageResults(ogResults, collected, generatedFiles, errors) {
+	let ogSuccessCount = 0;
+	for (let i = 0; i < ogResults.length; i++) {
+		const result = ogResults[i];
+		if (result.error) {
+			errors.push(`OG image failed for ${result.outputPath}: ${result.error}`);
+			collected.ogImageUrlMap.delete(collected.ogImageInputPaths[i]);
+		} else {
+			generatedFiles.push(result.outputPath);
+			ogSuccessCount++;
 		}
+	}
+	if (ogSuccessCount > 0) {
+		const cachedCount = ogResults.filter((result) => result.cached && !result.error).length;
+		console.log(`[ox-content:og-image] Generated ${ogSuccessCount} OG images` + (cachedCount > 0 ? ` (${cachedCount} from cache)` : ""));
+	}
+}
+async function generateHtmlPages(context, pageResults, collected, errors) {
+	const generatedPages = [];
+	for (const pageResult of pageResults) try {
 		generatedPages.push({
-			inputPath,
-			outputPath: routePaths.outputPath,
-			html
+			inputPath: pageResult.inputPath,
+			outputPath: pageResult.routePaths.outputPath,
+			html: await renderSsgPage(context, pageResult, collected.ogImageUrlMap)
 		});
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
 		errors.push(`Failed to generate HTML for ${pageResult.inputPath}: ${errorMessage}`);
 	}
-	const optimizedOutput = await externalizeSharedPageAssets(generatedPages, outDir, base);
+	return generatedPages;
+}
+async function renderSsgPage(context, pageResult, ogImageUrlMap) {
+	if (context.ssgOptions.bare) return generateBareHtmlPage(pageResult.transformedHtml, pageResult.title);
+	const pageData = createSsgPageData(pageResult);
+	const pageOgImage = context.shouldGenerateOgImages && ogImageUrlMap.has(pageResult.inputPath) ? ogImageUrlMap.get(pageResult.inputPath) : context.ssgOptions.ogImage;
+	return generateHtmlPage(pageData, context.navItems, context.siteName, context.base, pageOgImage, context.ssgOptions.theme, getPageLocale(pageData.path, context.options.i18n), context.options.i18n ? context.options.i18n.locales : void 0);
+}
+function createSsgPageData(pageResult) {
+	const { frontmatter } = pageResult;
+	const entryPage = frontmatter.layout === "entry" ? {
+		hero: frontmatter.hero,
+		features: frontmatter.features
+	} : void 0;
+	return {
+		title: pageResult.title,
+		description: pageResult.description,
+		content: pageResult.transformedHtml,
+		toc: pageResult.toc,
+		lastUpdated: pageResult.lastUpdated,
+		frontmatter,
+		path: pageResult.routePaths.urlPath,
+		href: pageResult.routePaths.href,
+		entryPage
+	};
+}
+async function writeGeneratedPages(generatedPages, context, generatedFiles) {
+	const optimizedOutput = await externalizeSharedPageAssets(generatedPages, context.outDir, context.base);
 	generatedFiles.push(...optimizedOutput.assets);
 	for (const page of optimizedOutput.pages) {
-		await fs$1.mkdir(path$1.dirname(page.outputPath), { recursive: true });
-		await fs$1.writeFile(page.outputPath, page.html, "utf-8");
+		await fs$2.mkdir(path$1.dirname(page.outputPath), { recursive: true });
+		await fs$2.writeFile(page.outputPath, page.html, "utf-8");
 		generatedFiles.push(page.outputPath);
 	}
-	return {
-		files: generatedFiles,
-		errors
-	};
 }
 //#endregion
 //#region src/search.ts
@@ -2179,14 +2176,14 @@ async function resolveMarkdownFile(url, srcDir, extensions) {
 	for (const relativePath of directCandidates) {
 		const filePath = path$1.join(srcDir, relativePath);
 		try {
-			await fs$1.access(filePath);
+			await fs$2.access(filePath);
 			return filePath;
 		} catch {}
 	}
 	for (const extension of extensions) {
 		const indexPath = path$1.join(srcDir, routePath, `index${extension}`);
 		try {
-			await fs$1.access(indexPath);
+			await fs$2.access(indexPath);
 			return indexPath;
 		} catch {}
 	}
@@ -2228,7 +2225,7 @@ async function resolveSiteName(options, root) {
 	if (options.ssg.siteName) return options.ssg.siteName;
 	try {
 		const pkgPath = path$1.join(root, "package.json");
-		const pkg = JSON.parse(await fs$1.readFile(pkgPath, "utf-8"));
+		const pkg = JSON.parse(await fs$2.readFile(pkgPath, "utf-8"));
 		if (pkg.name) return formatTitle(pkg.name);
 	} catch {}
 	return "Documentation";
@@ -2240,7 +2237,7 @@ async function renderPage$1(filePath, options, navGroups, siteName, base, root)
 	const srcDir = path$1.resolve(root, options.srcDir);
 	resetTabGroupCounter();
 	resetIslandCounter();
-	const result = await transformMarkdown(await fs$1.readFile(filePath, "utf-8"), filePath, options, {
+	const result = await transformMarkdown(await fs$2.readFile(filePath, "utf-8"), filePath, options, {
 		convertMdLinks: true,
 		baseUrl: base,
 		sourcePath: filePath
@@ -2396,7 +2393,7 @@ async function collectPages(options, root) {
 	const pages = [];
 	const generateOgImage = options.ogImage || options.ssg.generateOgImage;
 	for (const file of files.sort()) {
-		const content = fs$2.readFileSync(file, "utf-8");
+		const content = fs$1.readFileSync(file, "utf-8");
 		const frontmatter = normalizeVitePressFrontmatter(parseFrontmatter(content));
 		if (frontmatter.layout === "entry") continue;
 		const title = extractTitle(content, frontmatter);
@@ -2720,7 +2717,7 @@ function createI18nPlugin(resolvedOptions) {
 		async buildStart() {
 			if (!i18nOptions || !i18nOptions.check) return;
 			const dictDir = path$1.resolve(root, i18nOptions.dir);
-			if (!fs$2.existsSync(dictDir)) {
+			if (!fs$1.existsSync(dictDir)) {
 				console.warn(`[ox-content:i18n] Dictionary directory not found: ${dictDir}`);
 				return;
 			}
@@ -2736,7 +2733,7 @@ function createI18nPlugin(resolvedOptions) {
 		configureServer(server) {
 			if (!i18nOptions) return;
 			const dictDir = path$1.resolve(root, i18nOptions.dir);
-			if (fs$2.existsSync(dictDir)) {
+			if (fs$1.existsSync(dictDir)) {
 				server.watcher.add(dictDir);
 				server.watcher.on("change", (filePath) => {
 					if (!filePath.startsWith(dictDir)) return;
@@ -2879,7 +2876,10 @@ function stripMaskedDocument(result) {
 	};
 }
 function normalizeLintOptions(options) {
-	const languages = options.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? options.dictionary?.standard?.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? [...DEFAULT_LANGUAGES];
+	const standardDictionary = options.dictionary?.standard && typeof options.dictionary.standard === "object" ? options.dictionary.standard : void 0;
+	const optionLanguages = options.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language));
+	const standardLanguages = standardDictionary?.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language));
+	const languages = optionLanguages ?? standardLanguages ?? [...DEFAULT_LANGUAGES];
 	const standard = normalizeStandardDictionaryOptions(options.dictionary?.standard, languages);
 	return {
 		dictionary: {
@@ -2920,6 +2920,12 @@ async function runStandardSpellcheckDocuments(maskedDocuments, options) {
 		const { spellCheckDocument } = await loadCspellLib();
 		const locale = standard.languages.join(",");
 		const settings = createStandardSpellcheckSettings(options, locale);
+		const spellCheckOptions = {
+			generateSuggestions: true,
+			noConfigSearch: true,
+			numSuggestions: 3,
+			resolveImportsRelativeTo: standard.resolveImportsRelativeTo
+		};
 		return Promise.all(maskedDocuments.map(async (maskedDocument, index) => {
 			if (maskedDocument.trim().length === 0) return [];
 			return (await spellCheckDocument({
@@ -2927,12 +2933,7 @@ async function runStandardSpellcheckDocuments(maskedDocuments, options) {
 				locale,
 				text: maskedDocument,
 				uri: `file:///ox-content-lint-${index}.md`
-			}, {
-				generateSuggestions: true,
-				noConfigSearch: true,
-				numSuggestions: 3,
-				resolveImportsRelativeTo: standard.resolveImportsRelativeTo
-			}, settings)).issues.map((issue) => mapStandardIssueToDiagnostic(issue, standard.languages));
+			}, spellCheckOptions, settings)).issues.map((issue) => mapStandardIssueToDiagnostic(issue, standard.languages, maskedDocument));
 		}));
 	} catch (error) {
 		const imports = standard.imports.join(", ");
@@ -2953,8 +2954,8 @@ async function loadCspellLib() {
 	cspellLibPromise ??= import("cspell-lib");
 	return cspellLibPromise;
 }
-function mapStandardIssueToDiagnostic(issue, languages) {
-	const line = issue.line.position.line + 1;
+function mapStandardIssueToDiagnostic(issue, languages, documentText) {
+	const line = getLineNumberAtOffset(documentText, issue.line.offset);
 	const column = issue.offset - issue.line.offset + 1;
 	return {
 		column,
@@ -2968,6 +2969,11 @@ function mapStandardIssueToDiagnostic(issue, languages) {
 		suggestions: issue.suggestions?.slice(0, 3)
 	};
 }
+function getLineNumberAtOffset(text, offset) {
+	let line = 1;
+	for (let index = 0; index < offset && index < text.length; index++) if (text.charCodeAt(index) === 10) line++;
+	return line;
+}
 function inferStandardIssueLanguage(word, languages) {
 	if (/[\p{Script=Hiragana}\p{Script=Katakana}]/u.test(word) && languages.includes("ja")) return "ja";
 	if (/[\p{Script=Han}]/u.test(word)) {
@@ -3704,21 +3710,35 @@ init_page_context();
 function oxContent(options = {}) {
 	const resolvedOptions = resolveOptions(options);
 	let config;
-	async function regenerateDocs(root) {
-		const docsOptions = resolvedOptions.docs;
-		if (!docsOptions || !docsOptions.enabled) return 0;
-		const srcDirs = docsOptions.src.map((src) => path$1.resolve(root, src));
-		const outDir = path$1.resolve(root, docsOptions.out);
-		const extracted = await extractDocs(srcDirs, docsOptions);
-		const generated = generateMarkdown(extracted, docsOptions);
-		await writeDocs(generated, outDir, extracted, docsOptions);
-		return Object.keys(generated).length;
-	}
-	const mainPlugin = {
-		name: "ox-content",
-		configResolved(resolvedConfig) {
+	const getRoot = () => config?.root || process.cwd();
+	const ssgDevCache = createDevServerCache();
+	const plugins = [
+		createMainPlugin(resolvedOptions, (resolvedConfig) => {
 			config = resolvedConfig;
-		},
+		}),
+		createEnvironmentPlugin(resolvedOptions),
+		createDocsPlugin(resolvedOptions, getRoot),
+		createSsgPlugin(resolvedOptions, getRoot, ssgDevCache),
+		createSearchPlugin(resolvedOptions, getRoot)
+	];
+	if (resolvedOptions.i18n) plugins.push(createI18nPlugin(resolvedOptions));
+	if (resolvedOptions.ogViewer) plugins.push(createOgViewerPlugin(resolvedOptions));
+	return plugins;
+}
+async function regenerateDocs(resolvedOptions, root) {
+	const docsOptions = resolvedOptions.docs;
+	if (!docsOptions || !docsOptions.enabled) return 0;
+	const srcDirs = docsOptions.src.map((src) => path$1.resolve(root, src));
+	const outDir = path$1.resolve(root, docsOptions.out);
+	const extracted = await extractDocs(srcDirs, docsOptions);
+	const generated = generateMarkdown(extracted, docsOptions);
+	await writeDocs(generated, outDir, extracted, docsOptions);
+	return Object.keys(generated).length;
+}
+function createMainPlugin(resolvedOptions, setConfig) {
+	return {
+		name: "ox-content",
+		configResolved: setConfig,
 		configureServer(devServer) {
 			devServer.middlewares.use(async (req, res, next) => {
 				const url = req.url;
@@ -3743,31 +3763,33 @@ function oxContent(options = {}) {
 			};
 		},
 		async handleHotUpdate({ file, server }) {
-			if (isMarkdownFilePath(file, resolvedOptions.extensions)) {
-				server.ws.send({
-					type: "custom",
-					event: "ox-content:update",
-					data: { file }
-				});
-				const modules = server.moduleGraph.getModulesByFile(file);
-				return modules ? Array.from(modules) : [];
-			}
+			if (!isMarkdownFilePath(file, resolvedOptions.extensions)) return;
+			server.ws.send({
+				type: "custom",
+				event: "ox-content:update",
+				data: { file }
+			});
+			const modules = server.moduleGraph.getModulesByFile(file);
+			return modules ? Array.from(modules) : [];
 		}
 	};
-	const environmentPlugin = {
+}
+function createEnvironmentPlugin(resolvedOptions) {
+	return {
 		name: "ox-content:environment",
 		config() {
 			return { environments: { markdown: createMarkdownEnvironment(resolvedOptions) } };
 		}
 	};
-	const docsPlugin = {
+}
+function createDocsPlugin(resolvedOptions, getRoot) {
+	return {
 		name: "ox-content:docs",
 		async buildStart() {
 			const docsOptions = resolvedOptions.docs;
 			if (!docsOptions || !docsOptions.enabled) return;
-			const root = config?.root || process.cwd();
 			try {
-				const count = await regenerateDocs(root);
+				const count = await regenerateDocs(resolvedOptions, getRoot());
 				console.log(`[ox-content] Generated ${count} documentation files to ${docsOptions.out}`);
 			} catch (err) {
 				console.warn("[ox-content] Failed to generate documentation:", err);
@@ -3776,50 +3798,32 @@ function oxContent(options = {}) {
 		configureServer(devServer) {
 			const docsOptions = resolvedOptions.docs;
 			if (!docsOptions || !docsOptions.enabled) return;
-			const root = config?.root || process.cwd();
+			const root = getRoot();
 			const srcDirs = docsOptions.src.map((src) => path$1.resolve(root, src));
 			for (const srcDir of srcDirs) devServer.watcher.add(srcDir);
 			devServer.watcher.on("all", async (event, file) => {
 				if (event !== "add" && event !== "change" && event !== "unlink") return;
-				if (srcDirs.some((srcDir) => file.startsWith(srcDir) && (file.endsWith(".ts") || file.endsWith(".tsx")))) try {
-					await regenerateDocs(root);
+				if (!srcDirs.some((srcDir) => file.startsWith(srcDir) && (file.endsWith(".ts") || file.endsWith(".tsx")))) return;
+				try {
+					await regenerateDocs(resolvedOptions, root);
 				} catch {}
 			});
 		}
 	};
-	const ssgDevCache = createDevServerCache();
-	const ssgPlugin = {
+}
+function createSsgPlugin(resolvedOptions, getRoot, ssgDevCache) {
+	return {
 		name: "ox-content:ssg",
 		configureServer(devServer) {
 			if (!resolvedOptions.ssg.enabled) return;
-			const root = config?.root || process.cwd();
+			const root = getRoot();
 			const srcDir = path$1.resolve(root, resolvedOptions.srcDir);
 			devServer.middlewares.use(createDevServerMiddleware(resolvedOptions, root, ssgDevCache));
 			devServer.watcher.on("add", (file) => {
-				if (file.startsWith(srcDir) && isMarkdownFilePath(file, resolvedOptions.extensions)) {
-					invalidateNavCache(ssgDevCache);
-					devServer.ws.send({
-						type: "custom",
-						event: "ox-content:update",
-						data: {
-							file,
-							type: "add"
-						}
-					});
-				}
+				notifySsgFileAddedOrRemoved(devServer, resolvedOptions, ssgDevCache, srcDir, file, "add");
 			});
 			devServer.watcher.on("unlink", (file) => {
-				if (file.startsWith(srcDir) && isMarkdownFilePath(file, resolvedOptions.extensions)) {
-					invalidateNavCache(ssgDevCache);
-					devServer.ws.send({
-						type: "custom",
-						event: "ox-content:update",
-						data: {
-							file,
-							type: "unlink"
-						}
-					});
-				}
+				notifySsgFileAddedOrRemoved(devServer, resolvedOptions, ssgDevCache, srcDir, file, "unlink");
 			});
 			devServer.watcher.on("change", (file) => {
 				if (file.startsWith(srcDir) && isMarkdownFilePath(file, resolvedOptions.extensions)) invalidatePageCache(ssgDevCache, file);
@@ -3827,63 +3831,63 @@ function oxContent(options = {}) {
 		},
 		async closeBundle() {
 			if (!resolvedOptions.ssg.enabled) return;
-			const root = config?.root || process.cwd();
 			try {
-				const result = await buildSsg(resolvedOptions, root);
+				const result = await buildSsg(resolvedOptions, getRoot());
 				if (result.files.length > 0) console.log(`[ox-content] Generated ${result.files.length} output files`);
-				if (result.errors.length > 0) for (const error of result.errors) console.warn(`[ox-content] ${error}`);
+				for (const error of result.errors) console.warn(`[ox-content] ${error}`);
 			} catch (err) {
 				console.error("[ox-content] SSG build failed:", err);
 			}
 		}
 	};
+}
+function notifySsgFileAddedOrRemoved(devServer, resolvedOptions, ssgDevCache, srcDir, file, type) {
+	if (!file.startsWith(srcDir) || !isMarkdownFilePath(file, resolvedOptions.extensions)) return;
+	invalidateNavCache(ssgDevCache);
+	devServer.ws.send({
+		type: "custom",
+		event: "ox-content:update",
+		data: {
+			file,
+			type
+		}
+	});
+}
+function createSearchPlugin(resolvedOptions, getRoot) {
 	let searchIndexJson = "";
-	const plugins = [
-		mainPlugin,
-		environmentPlugin,
-		docsPlugin,
-		ssgPlugin,
-		{
-			name: "ox-content:search",
-			resolveId(id) {
-				if (id === "virtual:ox-content/search") return "\0virtual:ox-content/search";
-				return null;
-			},
-			async load(id) {
-				if (id === "\0virtual:ox-content/search") {
-					const searchOptions = resolvedOptions.search;
-					if (!searchOptions.enabled) return "export const search = () => []; export const searchOptions = { enabled: false }; export default { search, searchOptions };";
-					return generateSearchModule(searchOptions, resolvedOptions.base + "search-index.json");
-				}
-				return null;
-			},
-			async buildStart() {
-				if (!resolvedOptions.search.enabled) return;
-				const root = config?.root || process.cwd();
-				const srcDir = path$1.resolve(root, resolvedOptions.srcDir);
-				try {
-					searchIndexJson = await buildSearchIndex(srcDir, resolvedOptions.base, resolvedOptions.extensions);
-					console.log("[ox-content] Search index built");
-				} catch (err) {
-					console.warn("[ox-content] Failed to build search index:", err);
-				}
-			},
-			async closeBundle() {
-				if (!resolvedOptions.search.enabled || !searchIndexJson) return;
-				const root = config?.root || process.cwd();
-				const outDir = path$1.resolve(root, resolvedOptions.outDir);
-				try {
-					await writeSearchIndex(searchIndexJson, outDir);
-					console.log("[ox-content] Search index written to", path$1.join(outDir, "search-index.json"));
-				} catch (err) {
-					console.warn("[ox-content] Failed to write search index:", err);
-				}
+	return {
+		name: "ox-content:search",
+		resolveId(id) {
+			if (id === "virtual:ox-content/search") return "\0virtual:ox-content/search";
+			return null;
+		},
+		async load(id) {
+			if (id !== "\0virtual:ox-content/search") return null;
+			const searchOptions = resolvedOptions.search;
+			if (!searchOptions.enabled) return "export const search = () => []; export const searchOptions = { enabled: false }; export default { search, searchOptions };";
+			return generateSearchModule(searchOptions, resolvedOptions.base + "search-index.json");
+		},
+		async buildStart() {
+			if (!resolvedOptions.search.enabled) return;
+			const srcDir = path$1.resolve(getRoot(), resolvedOptions.srcDir);
+			try {
+				searchIndexJson = await buildSearchIndex(srcDir, resolvedOptions.base, resolvedOptions.extensions);
+				console.log("[ox-content] Search index built");
+			} catch (err) {
+				console.warn("[ox-content] Failed to build search index:", err);
+			}
+		},
+		async closeBundle() {
+			if (!resolvedOptions.search.enabled || !searchIndexJson) return;
+			const outDir = path$1.resolve(getRoot(), resolvedOptions.outDir);
+			try {
+				await writeSearchIndex(searchIndexJson, outDir);
+				console.log("[ox-content] Search index written to", path$1.join(outDir, "search-index.json"));
+			} catch (err) {
+				console.warn("[ox-content] Failed to write search index:", err);
 			}
 		}
-	];
-	if (resolvedOptions.i18n) plugins.push(createI18nPlugin(resolvedOptions));
-	if (resolvedOptions.ogViewer) plugins.push(createOgViewerPlugin(resolvedOptions));
-	return plugins;
+	};
 }
 /**
 * Resolves plugin options with defaults.