@ox-content/vite-plugin 2.3.0 → 2.5.0

package/dist/index.mjs

@@ -4,18 +4,20 @@ import { n as transformYouTube, t as extractVideoId } from "./youtube2.mjs";
 import { i as transformGitHub, n as fetchRepoData, r as prefetchGitHubRepos, t as collectGitHubRepos } from "./github2.mjs";
 import { i as transformOgp, n as fetchOgpData, r as prefetchOgpData, t as collectOgpUrls } from "./ogp2.mjs";
 import { createRequire } from "node:module";
-import * as path$1 from "path";
+import * as path$2 from "path";
 import path from "path";
 import { unified } from "unified";
 import rehypeParse from "rehype-parse";
 import rehypeStringify from "rehype-stringify";
 import { createHighlighter } from "shiki";
+import * as path$1 from "node:path";
 import { dirname, join } from "node:path";
-import * as fs$1 from "fs";
+import * as fs$2 from "fs";
 import { createHash } from "node:crypto";
-import * as fs from "fs/promises";
+import * as fs$1 from "fs/promises";
 import { glob } from "glob";
 import * as crypto from "crypto";
+import * as fs from "node:fs/promises";
 import { mkdir, writeFile } from "node:fs/promises";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
@@ -7655,12 +7657,12 @@ async function findFiles(dir, options) {
 	async function walk(currentDir) {
 		let entries;
 		try {
-			entries = await fs$1.promises.readdir(currentDir, { withFileTypes: true });
+			entries = await fs$2.promises.readdir(currentDir, { withFileTypes: true });
 		} catch {
 			return;
 		}
 		for (const entry of entries) {
-			const fullPath = path$1.join(currentDir, entry.name);
+			const fullPath = path$2.join(currentDir, entry.name);
 			if (entry.isDirectory()) {
 				if (!isExcluded(fullPath, options.exclude)) await walk(fullPath);
 			} else if (entry.isFile()) {
@@ -7817,7 +7819,7 @@ function generateMarkdown(docs, options) {
 	if (options.groupBy === "file") {
 		const docToFile = /* @__PURE__ */ new Map();
 		for (const doc of sortedDocs) {
-			let fileName = path$1.basename(doc.file, path$1.extname(doc.file));
+			let fileName = path$2.basename(doc.file, path$2.extname(doc.file));
 			if (fileName === "index") fileName = "index-module";
 			docToFile.set(doc, fileName);
 			const markdown = generateFileMarkdown(doc, options, fileName, symbolMap);
@@ -7850,10 +7852,10 @@ function sortExtractedDocs(docs) {
 	return [...docs].map((doc) => ({
 		...doc,
 		entries: [...doc.entries].sort(compareEntriesByName)
-	})).sort((a, b) => compareStrings(path$1.basename(a.file), path$1.basename(b.file)));
+	})).sort((a, b) => compareStrings(path$2.basename(a.file), path$2.basename(b.file)));
 }
 function generateFileMarkdown(doc, options, currentFileName, symbolMap) {
-	let md = `# ${path$1.basename(doc.file)}\n\n`;
+	let md = `# ${path$2.basename(doc.file)}\n\n`;
 	if (options.githubUrl) {
 		const sourceLink = generateSourceLink(doc.file, options.githubUrl);
 		if (sourceLink) md += sourceLink + "\n\n";
@@ -7956,7 +7958,7 @@ function generateIndex(docs, docToFile) {
 	md += "## Modules\n\n";
 	if (docs.length > 1) md += renderDetailsControlsHtml(".ox-api-module") + "\n\n";
 	for (const doc of docs) {
-		const displayName = path$1.basename(doc.file, path$1.extname(doc.file));
+		const displayName = path$2.basename(doc.file, path$2.extname(doc.file));
 		let fileName = displayName;
 		if (docToFile && docToFile.has(doc)) fileName = docToFile.get(doc);
 		else if (fileName === "index") fileName = "index-module";
@@ -8037,7 +8039,7 @@ function convertSymbolLinks(text, currentFileName, symbolMap) {
 function buildSymbolMap(docs) {
 	const map = /* @__PURE__ */ new Map();
 	for (const doc of docs) {
-		let fileName = path$1.basename(doc.file, path$1.extname(doc.file));
+		let fileName = path$2.basename(doc.file, path$2.extname(doc.file));
 		if (fileName === "index") fileName = "index-module";
 		for (const entry of doc.entries) map.set(entry.name, {
 			name: entry.name,
@@ -8051,32 +8053,32 @@ function buildSymbolMap(docs) {
 * Writes generated documentation to the output directory.
 */
 async function writeDocs(docs, outDir, extractedDocs, options) {
-	await fs$1.promises.mkdir(outDir, { recursive: true });
+	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);
+	const manifestPath = path$2.join(outDir, DOCS_MANIFEST_FILE);
 	let previousFiles = [];
 	try {
-		previousFiles = JSON.parse(await fs$1.promises.readFile(manifestPath, "utf-8"));
+		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$1.promises.rm(path$1.join(outDir, staleFile), { force: true });
+		await fs$2.promises.rm(path$2.join(outDir, staleFile), { force: true });
 	}
 	for (const [fileName, content] of Object.entries(docs)) {
-		const filePath = path$1.join(outDir, fileName);
-		await fs$1.promises.writeFile(filePath, content, "utf-8");
+		const filePath = path$2.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$1.promises.writeFile(navFilePath, navCode, "utf-8");
+		const navFilePath = path$2.join(outDir, "nav.ts");
+		await fs$2.promises.writeFile(navFilePath, navCode, "utf-8");
 	}
-	if (extractedDocs) await fs$1.promises.writeFile(path$1.join(outDir, DOCS_DATA_FILE), JSON.stringify(buildDocsData(extractedDocs), null, 2), "utf-8");
-	await fs$1.promises.writeFile(manifestPath, JSON.stringify([...generatedFiles].sort(), null, 2), "utf-8");
+	if (extractedDocs) await fs$2.promises.writeFile(path$2.join(outDir, DOCS_DATA_FILE), JSON.stringify(buildDocsData(extractedDocs), null, 2), "utf-8");
+	await fs$2.promises.writeFile(manifestPath, JSON.stringify([...generatedFiles].sort(), null, 2), "utf-8");
 }
 /**
 * Resolves docs options with defaults.
@@ -8161,10 +8163,10 @@ async function renderHtmlToPng(page, html, width, height, publicDir) {
 				await route.continue();
 				return;
 			}
-			const filePath = path$1.join(publicDir, url.pathname);
+			const filePath = path$2.join(publicDir, url.pathname);
 			try {
 				const body = await fs.readFile(filePath);
-				const ext = path$1.extname(filePath).toLowerCase();
+				const ext = path$2.extname(filePath).toLowerCase();
 				await route.fulfill({
 					body,
 					contentType: {
@@ -8349,9 +8351,9 @@ function computeCacheKey(templateSource, props, width, height) {
 * Returns the cached file path if found, null otherwise.
 */
 async function getCached(cacheDir, key) {
-	const filePath = path$1.join(cacheDir, `${key}.png`);
+	const filePath = path$2.join(cacheDir, `${key}.png`);
 	try {
-		return await fs.readFile(filePath);
+		return await fs$1.readFile(filePath);
 	} catch {
 		return null;
 	}
@@ -8360,9 +8362,9 @@ async function getCached(cacheDir, key) {
 * Writes a PNG buffer to the cache.
 */
 async function writeCache(cacheDir, key, png) {
-	await fs.mkdir(cacheDir, { recursive: true });
-	const filePath = path$1.join(cacheDir, `${key}.png`);
-	await fs.writeFile(filePath, png);
+	await fs$1.mkdir(cacheDir, { recursive: true });
+	const filePath = path$2.join(cacheDir, `${key}.png`);
+	await fs$1.writeFile(filePath, png);
 }
 //#endregion
 //#region \0@oxc-project+runtime@0.115.0/helpers/usingCtx.js
@@ -8452,14 +8454,14 @@ function resolveOgImageOptions(options) {
 */
 async function resolveTemplate(options, root) {
 	if (!options.template) return getDefaultTemplate();
-	const templatePath = path$1.resolve(root, options.template);
+	const templatePath = path$2.resolve(root, options.template);
 	const fs = await import("fs/promises");
 	try {
 		await fs.access(templatePath);
 	} catch {
 		throw new Error(`[ox-content:og-image] Template file not found: ${templatePath}`);
 	}
-	switch (path$1.extname(templatePath).toLowerCase()) {
+	switch (path$2.extname(templatePath).toLowerCase()) {
 		case ".vue": return resolveVueTemplate(templatePath, options, root);
 		case ".svelte": return resolveSvelteTemplate(templatePath, root);
 		case ".tsx":
@@ -8473,9 +8475,9 @@ async function resolveTemplate(options, root) {
 async function resolveTsTemplate(templatePath, options, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$1.join(root, ".cache", "og-images");
+	const cacheDir = path$2.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$1.join(cacheDir, "_template.mjs");
+	const outfile = path$2.join(cacheDir, "_template.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node"
@@ -8498,9 +8500,9 @@ async function resolveTsTemplate(templatePath, options, root) {
 async function resolveVueTemplate(templatePath, options, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$1.join(root, ".cache", "og-images");
+	const cacheDir = path$2.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$1.join(cacheDir, "_template_vue.mjs");
+	const outfile = path$2.join(cacheDir, "_template_vue.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node",
@@ -8596,9 +8598,9 @@ async function getVizejsPlugin() {
 async function resolveSvelteTemplate(templatePath, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$1.join(root, ".cache", "og-images");
+	const cacheDir = path$2.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$1.join(cacheDir, "_template_svelte.mjs");
+	const outfile = path$2.join(cacheDir, "_template_svelte.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node",
@@ -8654,9 +8656,9 @@ function createSvelteCompilerPlugin() {
 async function resolveReactTemplate(templatePath, root) {
 	const fs = await import("fs/promises");
 	const { rolldown } = await import("rolldown");
-	const cacheDir = path$1.join(root, ".cache", "og-images");
+	const cacheDir = path$2.join(root, ".cache", "og-images");
 	await fs.mkdir(cacheDir, { recursive: true });
-	const outfile = path$1.join(cacheDir, "_template_react.mjs");
+	const outfile = path$2.join(cacheDir, "_template_react.mjs");
 	const bundle = await rolldown({
 		input: templatePath,
 		platform: "node",
@@ -8706,7 +8708,7 @@ async function resolveReactTemplate(templatePath, root) {
 async function computeTemplateSource(options, root) {
 	if (!options.template) return "__default__";
 	const fs = await import("fs/promises");
-	const templatePath = path$1.resolve(root, options.template);
+	const templatePath = path$2.resolve(root, options.template);
 	const content = await fs.readFile(templatePath, "utf-8");
 	return crypto.createHash("sha256").update(content).digest("hex");
 }
@@ -8724,7 +8726,7 @@ async function generateOgImages(pages, options, root) {
 		if (pages.length === 0) return [];
 		const templateFn = await resolveTemplate(options, root);
 		const templateSource = await computeTemplateSource(options, root);
-		const cacheDir = path$1.join(root, ".cache", "og-images");
+		const cacheDir = path$2.join(root, ".cache", "og-images");
 		if (options.cache) {
 			const allCached = await tryServeAllFromCache(pages, templateSource, options, cacheDir);
 			if (allCached) return allCached;
@@ -8736,7 +8738,7 @@ async function generateOgImages(pages, options, root) {
 			error: "Chromium not available"
 		}));
 		const results = [];
-		const publicDir = path$1.join(root, "public");
+		const publicDir = path$2.join(root, "public");
 		const concurrency = Math.max(1, options.concurrency);
 		for (let i = 0; i < pages.length; i += concurrency) {
 			const batch = pages.slice(i, i + concurrency);
@@ -8760,7 +8762,7 @@ async function tryServeAllFromCache(pages, templateSource, options, cacheDir) {
 	for (const entry of pages) {
 		const cached = await getCached(cacheDir, computeCacheKey(templateSource, entry.props, options.width, options.height));
 		if (!cached) return null;
-		await fs.mkdir(path$1.dirname(entry.outputPath), { recursive: true });
+		await fs.mkdir(path$2.dirname(entry.outputPath), { recursive: true });
 		await fs.writeFile(entry.outputPath, cached);
 		results.push({
 			outputPath: entry.outputPath,
@@ -8778,7 +8780,7 @@ async function renderSinglePage(entry, templateFn, templateSource, options, cach
 		if (options.cache) {
 			const cached = await getCached(cacheDir, computeCacheKey(templateSource, entry.props, options.width, options.height));
 			if (cached) {
-				await fs.mkdir(path$1.dirname(entry.outputPath), { recursive: true });
+				await fs.mkdir(path$2.dirname(entry.outputPath), { recursive: true });
 				await fs.writeFile(entry.outputPath, cached);
 				return {
 					outputPath: entry.outputPath,
@@ -8788,7 +8790,7 @@ async function renderSinglePage(entry, templateFn, templateSource, options, cach
 		}
 		const html = await templateFn(entry.props);
 		const png = await session.renderPage(html, options.width, options.height, publicDir);
-		await fs.mkdir(path$1.dirname(entry.outputPath), { recursive: true });
+		await fs.mkdir(path$2.dirname(entry.outputPath), { recursive: true });
 		await fs.writeFile(entry.outputPath, png);
 		if (options.cache) await writeCache(cacheDir, computeCacheKey(templateSource, entry.props, options.width, options.height), png);
 		return {
@@ -10668,7 +10670,7 @@ function createSharedAssetChunk(type, label, content, outDir, base) {
 	const hash = createContentHash(content);
 	const fileName = `ox-content-${sanitizeChunkLabel(label)}-${hash}.${type}`;
 	return {
-		outputPath: path$1.join(outDir, "assets", fileName),
+		outputPath: path$2.join(outDir, "assets", fileName),
 		publicPath: toPublicAssetPath(base, fileName),
 		content
 	};
@@ -10758,8 +10760,8 @@ async function externalizeSharedPageAssets(pages, outDir, base) {
 	});
 	const chunks = [...cssChunks.values(), ...jsChunks.values()];
 	await Promise.all(chunks.map(async (chunk) => {
-		await fs.mkdir(path$1.dirname(chunk.outputPath), { recursive: true });
-		await fs.writeFile(chunk.outputPath, chunk.content, "utf-8");
+		await fs$1.mkdir(path$2.dirname(chunk.outputPath), { recursive: true });
+		await fs$1.writeFile(chunk.outputPath, chunk.content, "utf-8");
 	}));
 	return {
 		pages: optimizedPages,
@@ -10770,16 +10772,16 @@ async function externalizeSharedPageAssets(pages, outDir, base) {
 * Converts a markdown file path to its corresponding HTML output path.
 */
 function getOutputPath(inputPath, srcDir, outDir, extension) {
-	const baseName = path$1.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, extension);
-	if (baseName.endsWith(`index${extension}`)) return path$1.join(outDir, baseName);
+	const baseName = path$2.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, extension);
+	if (baseName.endsWith(`index${extension}`)) return path$2.join(outDir, baseName);
 	const dirName = baseName.replace(new RegExp(`\\${extension}$`), "");
-	return path$1.join(outDir, dirName, `index${extension}`);
+	return path$2.join(outDir, dirName, `index${extension}`);
 }
 /**
 * Converts a markdown file path to a relative URL path.
 */
 function getUrlPath$1(inputPath, srcDir) {
-	const baseName = path$1.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, "");
+	const baseName = path$2.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, "");
 	if (baseName === "index" || baseName.endsWith("/index")) return baseName.replace(/\/?index$/, "") || "/";
 	return baseName;
 }
@@ -10795,12 +10797,12 @@ function getHref(inputPath, srcDir, base, extension) {
 * Gets the OG image output path for a given markdown file.
 */
 function getOgImagePath(inputPath, srcDir, outDir) {
-	const baseName = path$1.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, "");
+	const baseName = path$2.relative(srcDir, inputPath).replace(/\.(?:md|markdown)$/i, "");
 	if (baseName === "index" || baseName.endsWith("/index")) {
 		const dirPath = baseName.replace(/\/?index$/, "") || "";
-		return path$1.join(outDir, dirPath, "og-image.png");
+		return path$2.join(outDir, dirPath, "og-image.png");
 	}
-	return path$1.join(outDir, baseName, "og-image.png");
+	return path$2.join(outDir, baseName, "og-image.png");
 }
 /**
 * Gets the OG image URL for use in meta tags.
@@ -10818,9 +10820,9 @@ function getOgImageUrl(inputPath, srcDir, base, siteUrl) {
 * Gets display title from file path.
 */
 function getDisplayTitle(filePath) {
-	const fileName = path$1.basename(filePath, path$1.extname(filePath));
+	const fileName = path$2.basename(filePath, path$2.extname(filePath));
 	if (fileName === "index") {
-		const dirName = path$1.basename(path$1.dirname(filePath));
+		const dirName = path$2.basename(path$2.dirname(filePath));
 		if (dirName && dirName !== ".") return formatTitle(dirName);
 		return "Home";
 	}
@@ -10836,7 +10838,7 @@ function formatTitle(name) {
 * Collects all markdown files from the source directory.
 */
 async function collectMarkdownFiles$1(srcDir) {
-	return (await glob(path$1.join(srcDir, "**/*.{md,markdown}"), {
+	return (await glob(path$2.join(srcDir, "**/*.{md,markdown}"), {
 		nodir: true,
 		ignore: [
 			"**/node_modules/**",
@@ -10857,7 +10859,7 @@ function buildNavItems(markdownFiles, srcDir, base, extension) {
 		"api"
 	];
 	for (const file of markdownFiles) {
-		const parts = path$1.relative(srcDir, file).split(path$1.sep);
+		const parts = path$2.relative(srcDir, file).split(path$2.sep);
 		let groupKey = "";
 		if (parts.length > 1) groupKey = parts[0];
 		if (!groups.has(groupKey)) groups.set(groupKey, []);
@@ -10906,14 +10908,14 @@ async function buildSsg(options, root) {
 		files: [],
 		errors: []
 	};
-	const srcDir = path$1.resolve(root, options.srcDir);
-	const outDir = path$1.resolve(root, options.outDir);
+	const srcDir = path$2.resolve(root, options.srcDir);
+	const outDir = path$2.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.rm(outDir, {
+		await fs$1.rm(outDir, {
 			recursive: true,
 			force: true
 		});
@@ -10922,8 +10924,8 @@ async function buildSsg(options, root) {
 	const navItems = buildNavItems(markdownFiles, srcDir, base, ssgOptions.extension);
 	let siteName = ssgOptions.siteName ?? "Documentation";
 	if (!ssgOptions.siteName) try {
-		const pkgPath = path$1.join(root, "package.json");
-		const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+		const pkgPath = path$2.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 = [];
@@ -10932,7 +10934,7 @@ async function buildSsg(options, root) {
 	const shouldGenerateOgImages = (options.ogImage || ssgOptions.generateOgImage) && !ssgOptions.bare;
 	const pageResults = [];
 	for (const inputPath of markdownFiles) try {
-		const result = await transformMarkdown(await fs.readFile(inputPath, "utf-8"), inputPath, options, {
+		const result = await transformMarkdown(await fs$1.readFile(inputPath, "utf-8"), inputPath, options, {
 			convertMdLinks: true,
 			baseUrl: base,
 			sourcePath: inputPath
@@ -11036,8 +11038,8 @@ async function buildSsg(options, root) {
 	const optimizedOutput = await externalizeSharedPageAssets(generatedPages, outDir, base);
 	generatedFiles.push(...optimizedOutput.assets);
 	for (const page of optimizedOutput.pages) {
-		await fs.mkdir(path$1.dirname(page.outputPath), { recursive: true });
-		await fs.writeFile(page.outputPath, page.html, "utf-8");
+		await fs$1.mkdir(path$2.dirname(page.outputPath), { recursive: true });
+		await fs$1.writeFile(page.outputPath, page.html, "utf-8");
 		generatedFiles.push(page.outputPath);
 	}
 	return {
@@ -11089,9 +11091,9 @@ async function collectMarkdownFiles(dir) {
 	const files = [];
 	async function walk(currentDir) {
 		try {
-			const entries = await fs.readdir(currentDir, { withFileTypes: true });
+			const entries = await fs$1.readdir(currentDir, { withFileTypes: true });
 			for (const entry of entries) {
-				const fullPath = path$1.join(currentDir, entry.name);
+				const fullPath = path$2.join(currentDir, entry.name);
 				if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") await walk(fullPath);
 				else if (entry.isFile() && entry.name.endsWith(".md")) files.push(fullPath);
 			}
@@ -11115,8 +11117,8 @@ async function buildSearchIndex(srcDir, base) {
 	const files = await collectMarkdownFiles(srcDir);
 	const documents = [];
 	for (const file of files) try {
-		const content = await fs.readFile(file, "utf-8");
-		const relativePath = path$1.relative(srcDir, file);
+		const content = await fs$1.readFile(file, "utf-8");
+		const relativePath = path$2.relative(srcDir, file);
 		const url = base + relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
 		const id = relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
 		const extractSearchContent = napi.extractSearchContent;
@@ -11145,9 +11147,9 @@ async function buildSearchIndex(srcDir, base) {
 * Writes the search index to a file.
 */
 async function writeSearchIndex(indexJson, outDir) {
-	const indexPath = path$1.join(outDir, "search-index.json");
-	await fs.mkdir(outDir, { recursive: true });
-	await fs.writeFile(indexPath, indexJson, "utf-8");
+	const indexPath = path$2.join(outDir, "search-index.json");
+	await fs$1.mkdir(outDir, { recursive: true });
+	await fs$1.writeFile(indexPath, indexJson, "utf-8");
 }
 /**
 * Client-side search module code.
@@ -11447,14 +11449,14 @@ async function resolveMarkdownFile(url, srcDir) {
 	let relativePath;
 	if (pathname === "/") relativePath = "index.md";
 	else relativePath = pathname.slice(1) + ".md";
-	const filePath = path$1.join(srcDir, relativePath);
+	const filePath = path$2.join(srcDir, relativePath);
 	try {
-		await fs.access(filePath);
+		await fs$1.access(filePath);
 		return filePath;
 	} catch {
-		const indexPath = path$1.join(srcDir, pathname === "/" ? "" : pathname.slice(1), "index.md");
+		const indexPath = path$2.join(srcDir, pathname === "/" ? "" : pathname.slice(1), "index.md");
 		try {
-			await fs.access(indexPath);
+			await fs$1.access(indexPath);
 			return indexPath;
 		} catch {
 			return null;
@@ -11496,8 +11498,8 @@ function invalidatePageCache(cache, filePath) {
 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.readFile(pkgPath, "utf-8"));
+		const pkgPath = path$2.join(root, "package.json");
+		const pkg = JSON.parse(await fs$1.readFile(pkgPath, "utf-8"));
 		if (pkg.name) return formatTitle(pkg.name);
 	} catch {}
 	return "Documentation";
@@ -11506,10 +11508,10 @@ async function resolveSiteName(options, root) {
 * Render a single markdown page to full HTML.
 */
 async function renderPage$1(filePath, options, navGroups, siteName, base, root) {
-	const srcDir = path$1.resolve(root, options.srcDir);
+	const srcDir = path$2.resolve(root, options.srcDir);
 	resetTabGroupCounter();
 	resetIslandCounter();
-	const result = await transformMarkdown(await fs.readFile(filePath, "utf-8"), filePath, options, {
+	const result = await transformMarkdown(await fs$1.readFile(filePath, "utf-8"), filePath, options, {
 		convertMdLinks: true,
 		baseUrl: base,
 		sourcePath: filePath
@@ -11551,7 +11553,7 @@ async function renderPage$1(filePath, options, navGroups, siteName, base, root)
 * Create the dev server middleware for SSG page serving.
 */
 function createDevServerMiddleware(options, root, cache) {
-	const srcDir = path$1.resolve(root, options.srcDir);
+	const srcDir = path$2.resolve(root, options.srcDir);
 	const base = options.base.endsWith("/") ? options.base : options.base + "/";
 	return async (req, res, next) => {
 		const url = req.url;
@@ -11616,7 +11618,7 @@ function extractTitle(content, frontmatter) {
 	return match ? match[1].trim() : "";
 }
 function getUrlPath(filePath, srcDir) {
-	let rel = path$1.relative(srcDir, filePath).replace(/\\/g, "/");
+	let rel = path$2.relative(srcDir, filePath).replace(/\\/g, "/");
 	rel = rel.replace(/\.md$/, "");
 	if (rel === "index") return "/";
 	if (rel.endsWith("/index")) rel = rel.slice(0, -6);
@@ -11656,7 +11658,7 @@ function validatePage(page, options) {
 	return warnings;
 }
 async function collectPages(options, root) {
-	const srcDir = path$1.resolve(root, options.srcDir);
+	const srcDir = path$2.resolve(root, options.srcDir);
 	const files = await glob("**/*.md", {
 		cwd: srcDir,
 		absolute: true
@@ -11664,7 +11666,7 @@ async function collectPages(options, root) {
 	const pages = [];
 	const generateOgImage = options.ogImage || options.ssg.generateOgImage;
 	for (const file of files.sort()) {
-		const content = fs$1.readFileSync(file, "utf-8");
+		const content = fs$2.readFileSync(file, "utf-8");
 		const frontmatter = parseFrontmatter(content);
 		if (frontmatter.layout === "entry") continue;
 		const title = extractTitle(content, frontmatter);
@@ -11674,7 +11676,7 @@ async function collectPages(options, root) {
 		const urlPath = getUrlPath(file, srcDir);
 		const ogImageUrl = computeOgImageUrl(urlPath, options.base, options.ssg.siteUrl, generateOgImage, options.ssg.ogImage);
 		const page = {
-			path: path$1.relative(srcDir, file),
+			path: path$2.relative(srcDir, file),
 			urlPath,
 			title,
 			description,
@@ -11987,8 +11989,8 @@ function createI18nPlugin(resolvedOptions) {
 		},
 		async buildStart() {
 			if (!i18nOptions || !i18nOptions.check) return;
-			const dictDir = path$1.resolve(root, i18nOptions.dir);
-			if (!fs$1.existsSync(dictDir)) {
+			const dictDir = path$2.resolve(root, i18nOptions.dir);
+			if (!fs$2.existsSync(dictDir)) {
 				console.warn(`[ox-content:i18n] Dictionary directory not found: ${dictDir}`);
 				return;
 			}
@@ -12009,8 +12011,8 @@ function createI18nPlugin(resolvedOptions) {
 		},
 		configureServer(server) {
 			if (!i18nOptions) return;
-			const dictDir = path$1.resolve(root, i18nOptions.dir);
-			if (fs$1.existsSync(dictDir)) {
+			const dictDir = path$2.resolve(root, i18nOptions.dir);
+			if (fs$2.existsSync(dictDir)) {
 				server.watcher.add(dictDir);
 				server.watcher.on("change", (filePath) => {
 					if (!filePath.startsWith(dictDir)) return;
@@ -12036,7 +12038,7 @@ function createI18nPlugin(resolvedOptions) {
 * Generates the virtual module for i18n configuration.
 */
 function generateI18nModule(options, root) {
-	const dictDir = path$1.resolve(root, options.dir);
+	const dictDir = path$2.resolve(root, options.dir);
 	const localesJson = JSON.stringify(options.locales);
 	const defaultLocale = JSON.stringify(options.defaultLocale);
 	let dictionariesCode = "{}";
@@ -12119,15 +12121,15 @@ function flattenObject(obj, prefix, result) {
 function loadDictionariesFallback(options, dictDir) {
 	const dictData = {};
 	for (const locale of options.locales) {
-		const localeDir = path$1.join(dictDir, locale.code);
-		if (!fs$1.existsSync(localeDir)) continue;
-		const files = fs$1.readdirSync(localeDir);
+		const localeDir = path$2.join(dictDir, locale.code);
+		if (!fs$2.existsSync(localeDir)) continue;
+		const files = fs$2.readdirSync(localeDir);
 		const localeDict = {};
 		for (const file of files) {
 			if (!file.endsWith(".json")) continue;
-			const filePath = path$1.join(localeDir, file);
-			const content = fs$1.readFileSync(filePath, "utf-8");
-			const namespace = path$1.basename(file, ".json");
+			const filePath = path$2.join(localeDir, file);
+			const content = fs$2.readFileSync(filePath, "utf-8");
+			const namespace = path$2.basename(file, ".json");
 			try {
 				flattenObject(JSON.parse(content), namespace, localeDict);
 			} catch {}
@@ -12140,17 +12142,17 @@ function loadDictionariesFallback(options, dictDir) {
 * Collects translation keys from source files using NAPI extractTranslationKeys.
 */
 function collectKeysFromSource(root, extractTranslationKeys, options) {
-	const srcDir = path$1.resolve(root, "src");
+	const srcDir = path$2.resolve(root, "src");
 	const keys = /* @__PURE__ */ new Set();
-	if (fs$1.existsSync(srcDir)) walkDir(srcDir, /\.(ts|tsx|js|jsx)$/, (filePath) => {
-		const usages = extractTranslationKeys(fs$1.readFileSync(filePath, "utf-8"), filePath, options.functionNames);
+	if (fs$2.existsSync(srcDir)) walkDir(srcDir, /\.(ts|tsx|js|jsx)$/, (filePath) => {
+		const usages = extractTranslationKeys(fs$2.readFileSync(filePath, "utf-8"), filePath, options.functionNames);
 		for (const usage of usages) keys.add(usage.key);
 	});
-	const contentDir = path$1.resolve(root, "content");
-	if (fs$1.existsSync(contentDir)) {
+	const contentDir = path$2.resolve(root, "content");
+	if (fs$2.existsSync(contentDir)) {
 		const tPattern = /\{\{t\(['"]([^'"]+)['"]\)\}\}/g;
 		walkDir(contentDir, /\.(md|mdx)$/, (filePath) => {
-			const content = fs$1.readFileSync(filePath, "utf-8");
+			const content = fs$2.readFileSync(filePath, "utf-8");
 			let match;
 			while ((match = tPattern.exec(content)) !== null) keys.add(match[1]);
 			tPattern.lastIndex = 0;
@@ -12162,9 +12164,9 @@ function collectKeysFromSource(root, extractTranslationKeys, options) {
 * Recursively walks a directory, calling the callback for files matching the pattern.
 */
 function walkDir(dir, pattern, callback) {
-	const entries = fs$1.readdirSync(dir, { withFileTypes: true });
+	const entries = fs$2.readdirSync(dir, { withFileTypes: true });
 	for (const entry of entries) {
-		const fullPath = path$1.join(dir, entry.name);
+		const fullPath = path$2.join(dir, entry.name);
 		if (entry.isDirectory()) {
 			if (entry.name === "node_modules" || entry.name === ".git") continue;
 			walkDir(fullPath, pattern, callback);
@@ -12172,6 +12174,358 @@ function walkDir(dir, pattern, callback) {
 	}
 }
 //#endregion
+//#region src/lint.ts
+const require$1 = createRequire(import.meta.url);
+const SUPPORTED_MARKDOWN_LINT_LANGUAGES = [
+	"en",
+	"ja",
+	"zh",
+	"fr",
+	"de",
+	"pl"
+];
+const DEFAULT_LANGUAGES = ["en"];
+const DEFAULT_RULES = {
+	duplicateHeadings: true,
+	headingIncrement: true,
+	maxConsecutiveBlankLines: 1,
+	repeatedPunctuation: true,
+	repeatedWords: true,
+	spellcheck: true,
+	trailingSpaces: true
+};
+const DEFAULT_CSPELL_IMPORTS = {
+	de: "@cspell/dict-de-de/cspell-ext.json",
+	en: "@cspell/dict-en_us/cspell-ext.json",
+	fr: "@cspell/dict-fr-fr/cspell-ext.json",
+	pl: "@cspell/dict-pl_pl/cspell-ext.json"
+};
+let napiBinding;
+let cspellLibPromise;
+/**
+* Lints Markdown prose with the Rust-backed built-in rule engine.
+*/
+function lintMarkdown(source, options = {}) {
+	return lintMarkdownWithNormalizedOptions(source, normalizeLintOptions(options));
+}
+/**
+* Async Markdown linter that supports opt-in standard dictionaries.
+*/
+async function lintMarkdownAsync(source, options = {}) {
+	const normalizedOptions = normalizeLintOptions(options);
+	const [result] = await lintMarkdownDocumentsWithNormalizedOptions([source], normalizedOptions);
+	return result ?? createEmptyLintResult$1();
+}
+/**
+* Internal batched Markdown linting entry point used by file-based workflows.
+*/
+async function lintMarkdownDocumentsAsync(sources, options = {}) {
+	return lintMarkdownDocumentsWithNormalizedOptions(sources, normalizeLintOptions(options));
+}
+function lintMarkdownWithNormalizedOptions(source, normalizedOptions) {
+	if (normalizedOptions.dictionary.standard) throw new Error("[ox-content] lintMarkdownAsync is required when dictionary.standard is enabled.");
+	return stripMaskedDocument(loadNapiBindingSync().lintMarkdown(source, toNapiMarkdownLintOptions(normalizedOptions)));
+}
+async function lintMarkdownDocumentsWithNormalizedOptions(sources, normalizedOptions) {
+	if (sources.length === 0) return [];
+	const napi = loadNapiBindingSync();
+	const napiOptions = toNapiMarkdownLintOptions(normalizedOptions, Boolean(normalizedOptions.dictionary.standard));
+	const builtInResults = typeof napi.lintMarkdownDocuments === "function" ? napi.lintMarkdownDocuments(sources, napiOptions) : sources.map((source) => napi.lintMarkdown(source, napiOptions));
+	if (!normalizedOptions.rules.spellcheck || !normalizedOptions.dictionary.standard) return builtInResults.map(stripMaskedDocument);
+	const standardDiagnostics = await runStandardSpellcheckDocuments(builtInResults.map((result) => result.maskedDocument), normalizedOptions);
+	return builtInResults.map((result, index) => summarizeDiagnostics(sortDiagnostics(result.diagnostics.concat(standardDiagnostics[index] ?? []))));
+}
+function loadNapiBindingSync() {
+	if (napiBinding) return napiBinding;
+	if (napiBinding === null) throw new Error("[ox-content] @ox-content/napi is required for Markdown linting. Please ensure the NAPI module is built.");
+	try {
+		const loaded = require$1("@ox-content/napi");
+		napiBinding = loaded.default && typeof loaded.default === "object" ? {
+			...loaded.default,
+			...loaded
+		} : loaded;
+		return napiBinding;
+	} catch {
+		napiBinding = null;
+		throw new Error("[ox-content] @ox-content/napi is required for Markdown linting. Please ensure the NAPI module is built.");
+	}
+}
+function toNapiMarkdownLintOptions(options, disableBuiltinSpellcheck = false) {
+	return {
+		dictionary: {
+			byLanguage: Object.entries(options.dictionary.byLanguage ?? {}).map(([language, words]) => ({
+				language,
+				words
+			})),
+			ignoredWords: options.dictionary.ignoredWords,
+			words: options.dictionary.words
+		},
+		languages: options.languages,
+		rules: {
+			...options.rules,
+			spellcheck: disableBuiltinSpellcheck ? false : options.rules.spellcheck
+		}
+	};
+}
+function stripMaskedDocument(result) {
+	return {
+		diagnostics: result.diagnostics,
+		errorCount: result.errorCount,
+		infoCount: result.infoCount,
+		warningCount: result.warningCount
+	};
+}
+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 standard = normalizeStandardDictionaryOptions(options.dictionary?.standard, languages);
+	return {
+		dictionary: {
+			...options.dictionary,
+			standard
+		},
+		languages: [...new Set(languages)],
+		rules: {
+			duplicateHeadings: options.rules?.duplicateHeadings ?? DEFAULT_RULES.duplicateHeadings,
+			headingIncrement: options.rules?.headingIncrement ?? DEFAULT_RULES.headingIncrement,
+			maxConsecutiveBlankLines: options.rules?.maxConsecutiveBlankLines ?? DEFAULT_RULES.maxConsecutiveBlankLines,
+			repeatedPunctuation: options.rules?.repeatedPunctuation ?? DEFAULT_RULES.repeatedPunctuation,
+			repeatedWords: options.rules?.repeatedWords ?? DEFAULT_RULES.repeatedWords,
+			spellcheck: options.rules?.spellcheck ?? DEFAULT_RULES.spellcheck,
+			trailingSpaces: options.rules?.trailingSpaces ?? DEFAULT_RULES.trailingSpaces
+		}
+	};
+}
+function normalizeStandardDictionaryOptions(standard, fallbackLanguages) {
+	if (!standard) return false;
+	const languages = standard.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? fallbackLanguages;
+	const customImports = standard.imports ?? [];
+	const missingPresetLanguages = languages.filter((language) => !DEFAULT_CSPELL_IMPORTS[language]);
+	if (missingPresetLanguages.length > 0 && customImports.length === 0) throw new Error(`[ox-content] No bundled standard dictionary preset exists for ${missingPresetLanguages.join(", ")}. Provide dictionary.standard.imports to enable those languages.`);
+	const imports = [...languages.map((language) => DEFAULT_CSPELL_IMPORTS[language]).filter((value) => Boolean(value)), ...customImports];
+	if (imports.length === 0) throw new Error("[ox-content] dictionary.standard requires at least one bundled preset language or custom import.");
+	return {
+		imports: [...new Set(imports)],
+		languages: [...new Set(languages)],
+		provider: standard.provider ?? "cspell",
+		resolveImportsRelativeTo: standard.resolveImportsRelativeTo ?? new URL(".", import.meta.url)
+	};
+}
+async function runStandardSpellcheckDocuments(maskedDocuments, options) {
+	const standard = options.dictionary.standard;
+	if (!standard || maskedDocuments.length === 0) return maskedDocuments.map(() => []);
+	try {
+		const { spellCheckDocument } = await loadCspellLib();
+		const locale = standard.languages.join(",");
+		const settings = createStandardSpellcheckSettings(options, locale);
+		return Promise.all(maskedDocuments.map(async (maskedDocument, index) => {
+			if (maskedDocument.trim().length === 0) return [];
+			return (await spellCheckDocument({
+				languageId: "plaintext",
+				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));
+		}));
+	} catch (error) {
+		const imports = standard.imports.join(", ");
+		const message = imports.length > 0 ? `[ox-content] Failed to load standard dictionaries from ${imports}. Verify the imports and install the referenced CSpell packages.` : "[ox-content] Failed to load the configured standard dictionaries.";
+		throw new Error(message, { cause: error });
+	}
+}
+function createStandardSpellcheckSettings(options, locale) {
+	return {
+		import: options.dictionary.standard ? options.dictionary.standard.imports : [],
+		ignoreWords: options.dictionary.ignoredWords,
+		language: locale,
+		version: "0.2",
+		words: [...options.dictionary.words ?? [], ...Object.values(options.dictionary.byLanguage ?? {}).flat()]
+	};
+}
+async function loadCspellLib() {
+	cspellLibPromise ??= import("cspell-lib");
+	return cspellLibPromise;
+}
+function mapStandardIssueToDiagnostic(issue, languages) {
+	const line = issue.line.position.line + 1;
+	const column = issue.offset - issue.line.offset + 1;
+	return {
+		column,
+		endColumn: column + (issue.length ?? issue.text.length),
+		endLine: line,
+		language: inferStandardIssueLanguage(issue.text, languages),
+		line,
+		message: `Unknown word "${issue.text}".`,
+		ruleId: "spellcheck",
+		severity: "warning",
+		suggestions: issue.suggestions?.slice(0, 3)
+	};
+}
+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)) {
+		if (languages.includes("zh") && !languages.includes("ja")) return "zh";
+		if (languages.includes("ja") && !languages.includes("zh")) return "ja";
+	}
+	if (/[\p{Script=Latin}]/u.test(word)) {
+		const latinLanguages = languages.filter((language) => language !== "ja" && language !== "zh");
+		if (latinLanguages.length === 1) return latinLanguages[0];
+		return inferLatinLanguageFromCharacters(word, latinLanguages);
+	}
+}
+function inferLatinLanguageFromCharacters(word, languages) {
+	if (languages.includes("pl") && /[ąćęłńóśźż]/iu.test(word)) return "pl";
+	if (languages.includes("de") && /[äöüß]/iu.test(word)) return "de";
+	if (languages.includes("fr") && /[àâæçéèêëîïôœùûüÿ]/iu.test(word)) return "fr";
+}
+function summarizeDiagnostics(diagnostics) {
+	let errorCount = 0;
+	let warningCount = 0;
+	let infoCount = 0;
+	for (const diagnostic of diagnostics) if (diagnostic.severity === "error") errorCount += 1;
+	else if (diagnostic.severity === "warning") warningCount += 1;
+	else infoCount += 1;
+	return {
+		diagnostics,
+		errorCount,
+		infoCount,
+		warningCount
+	};
+}
+function createEmptyLintResult$1() {
+	return summarizeDiagnostics([]);
+}
+function sortDiagnostics(diagnostics) {
+	return [...diagnostics].sort((left, right) => {
+		if (left.line !== right.line) return left.line - right.line;
+		if (left.column !== right.column) return left.column - right.column;
+		return left.ruleId.localeCompare(right.ruleId);
+	});
+}
+//#endregion
+//#region src/lint-files.ts
+const DEFAULT_LINT_FILE_INCLUDE = ["**/*.md", "**/*.markdown"];
+const DEFAULT_LINT_FILE_EXCLUDE = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/dist/**"
+];
+/**
+* Returns true if the file path is included by the configured glob filters.
+*/
+function shouldLintMarkdownFile(filePath, options = {}) {
+	const resolvedOptions = resolveMarkdownLintFileOptions(options);
+	return shouldLintAbsoluteFile(path$1.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
+}
+/**
+* Lints a single Markdown file using project-style include/exclude settings.
+*
+* If the file is filtered out by `include` / `exclude`, the returned result is
+* marked as `skipped` and contains no diagnostics.
+*/
+async function lintMarkdownFile(filePath, options = {}) {
+	const resolvedOptions = resolveMarkdownLintFileOptions(options);
+	return lintMarkdownFileWithResolvedOptions(path$1.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
+}
+/**
+* Lints all Markdown files matched by the configured include/exclude patterns.
+*/
+async function lintMarkdownFiles(options = {}) {
+	const resolvedOptions = resolveMarkdownLintFileOptions(options);
+	const matchedFiles = await collectMarkdownLintFileEntries(resolvedOptions);
+	const results = await lintMarkdownDocumentsAsync(await Promise.all(matchedFiles.map((file) => fs.readFile(file.filePath, "utf-8"))), resolvedOptions.lintOptions);
+	const files = matchedFiles.map((file, index) => ({
+		...results[index] ?? createEmptyLintResult(),
+		filePath: file.filePath,
+		relativePath: file.relativePath,
+		skipped: false
+	}));
+	const diagnostics = files.flatMap((fileResult) => fileResult.diagnostics.map((diagnostic) => ({
+		...diagnostic,
+		filePath: fileResult.filePath,
+		relativePath: fileResult.relativePath
+	})));
+	return {
+		checkedFileCount: files.length,
+		diagnostics,
+		errorCount: files.reduce((count, fileResult) => count + fileResult.errorCount, 0),
+		files,
+		infoCount: files.reduce((count, fileResult) => count + fileResult.infoCount, 0),
+		warningCount: files.reduce((count, fileResult) => count + fileResult.warningCount, 0)
+	};
+}
+function resolveMarkdownLintFileOptions(options) {
+	return {
+		cwd: path$1.resolve(options.cwd ?? process.cwd()),
+		exclude: [...new Set([...options.exclude ?? DEFAULT_LINT_FILE_EXCLUDE, ...options.ignore ?? []])],
+		include: [...new Set(options.include ?? DEFAULT_LINT_FILE_INCLUDE)],
+		lintOptions: {
+			dictionary: options.dictionary,
+			languages: options.languages,
+			rules: options.rules
+		}
+	};
+}
+async function lintMarkdownFileWithResolvedOptions(filePath, options) {
+	const absoluteFilePath = path$1.resolve(filePath);
+	const relativePath = normalizePath(path$1.relative(options.cwd, absoluteFilePath));
+	if (!shouldLintAbsoluteFile(absoluteFilePath, options)) return {
+		...createEmptyLintResult(),
+		filePath: absoluteFilePath,
+		relativePath,
+		skipped: true
+	};
+	return {
+		...await lintMarkdownAsync(await fs.readFile(absoluteFilePath, "utf-8"), options.lintOptions),
+		filePath: absoluteFilePath,
+		relativePath,
+		skipped: false
+	};
+}
+async function collectMarkdownLintFileEntries(options) {
+	const files = /* @__PURE__ */ new Map();
+	for (const pattern of options.include) {
+		const matches = await glob(pattern, {
+			absolute: true,
+			cwd: options.cwd,
+			ignore: options.exclude,
+			nodir: true
+		});
+		for (const filePath of matches) {
+			const absoluteFilePath = path$1.resolve(filePath);
+			if (shouldLintAbsoluteFile(absoluteFilePath, options)) files.set(absoluteFilePath, {
+				filePath: absoluteFilePath,
+				relativePath: normalizePath(path$1.relative(options.cwd, absoluteFilePath))
+			});
+		}
+	}
+	return [...files.values()].sort((left, right) => left.filePath.localeCompare(right.filePath));
+}
+function shouldLintAbsoluteFile(filePath, options) {
+	const absolutePath = normalizePath(path$1.resolve(filePath));
+	const relativePath = normalizePath(path$1.relative(options.cwd, absolutePath));
+	const matches = (patterns) => patterns.some((pattern) => {
+		const normalizedPattern = normalizePath(pattern);
+		return path$1.matchesGlob(relativePath, normalizedPattern) || path$1.matchesGlob(absolutePath, normalizedPattern);
+	});
+	return matches(options.include) && !matches(options.exclude);
+}
+function normalizePath(value) {
+	return value.split(path$1.sep).join("/");
+}
+function createEmptyLintResult() {
+	return {
+		diagnostics: [],
+		errorCount: 0,
+		infoCount: 0,
+		warningCount: 0
+	};
+}
+//#endregion
 //#region src/jsx-runtime.ts
 /**
 * Custom JSX Runtime for Static HTML Generation
@@ -12744,8 +13098,8 @@ function oxContent(options = {}) {
 	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 srcDirs = docsOptions.src.map((src) => path$2.resolve(root, src));
+		const outDir = path$2.resolve(root, docsOptions.out);
 		const extracted = await extractDocs(srcDirs, docsOptions);
 		const generated = generateMarkdown(extracted, docsOptions);
 		await writeDocs(generated, outDir, extracted, docsOptions);
@@ -12814,7 +13168,7 @@ function oxContent(options = {}) {
 			const docsOptions = resolvedOptions.docs;
 			if (!docsOptions || !docsOptions.enabled) return;
 			const root = config?.root || process.cwd();
-			const srcDirs = docsOptions.src.map((src) => path$1.resolve(root, src));
+			const srcDirs = docsOptions.src.map((src) => path$2.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;
@@ -12830,7 +13184,7 @@ function oxContent(options = {}) {
 		configureServer(devServer) {
 			if (!resolvedOptions.ssg.enabled) return;
 			const root = config?.root || process.cwd();
-			const srcDir = path$1.resolve(root, resolvedOptions.srcDir);
+			const srcDir = path$2.resolve(root, resolvedOptions.srcDir);
 			devServer.middlewares.use(createDevServerMiddleware(resolvedOptions, root, ssgDevCache));
 			devServer.watcher.on("add", (file) => {
 				if (file.startsWith(srcDir) && file.endsWith(".md")) {
@@ -12897,7 +13251,7 @@ function oxContent(options = {}) {
 			async buildStart() {
 				if (!resolvedOptions.search.enabled) return;
 				const root = config?.root || process.cwd();
-				const srcDir = path$1.resolve(root, resolvedOptions.srcDir);
+				const srcDir = path$2.resolve(root, resolvedOptions.srcDir);
 				try {
 					searchIndexJson = await buildSearchIndex(srcDir, resolvedOptions.base);
 					console.log("[ox-content] Search index built");
@@ -12908,10 +13262,10 @@ function oxContent(options = {}) {
 			async closeBundle() {
 				if (!resolvedOptions.search.enabled || !searchIndexJson) return;
 				const root = config?.root || process.cwd();
-				const outDir = path$1.resolve(root, resolvedOptions.outDir);
+				const outDir = path$2.resolve(root, resolvedOptions.outDir);
 				try {
 					await writeSearchIndex(searchIndexJson, outDir);
-					console.log("[ox-content] Search index written to", path$1.join(outDir, "search-index.json"));
+					console.log("[ox-content] Search index written to", path$2.join(outDir, "search-index.json"));
 				} catch (err) {
 					console.warn("[ox-content] Failed to write search index:", err);
 				}
@@ -12991,6 +13345,6 @@ function generateVirtualModule(path, options) {
 	return "export default {};";
 }
 //#endregion
-export { DEFAULT_HTML_TEMPLATE, DefaultTheme, Fragment, buildSearchIndex, buildSsg, clearRenderContext, collectGitHubRepos, collectOgpUrls, createI18nPlugin, createMarkdownEnvironment, createTheme, defaultTheme, defineTheme, each, extractDocs, extractIslandInfo, extractVideoId, fetchOgpData, fetchRepoData, generateFrontmatterTypes, generateHydrationScript, generateMarkdown, generateOgImages, generateTabsCSS, generateTypes, hasIslands, inferType, jsx, jsxs, mergeThemes, mermaidClientScript, oxContent, prefetchGitHubRepos, prefetchOgpData, raw, renderAllPages, renderPage, renderToString, resolveDocsOptions, resolveI18nOptions, resolveOgImageOptions, resolveSearchOptions, resolveSsgOptions, resolveTheme, setRenderContext, transformAllPlugins, transformGitHub, transformIslands, transformMarkdown, transformMermaidStatic, transformOgp, transformTabs, transformYouTube, useIsActive, useNav, usePageProps, useRenderContext, useSiteConfig, when, writeDocs, writeSearchIndex };
+export { DEFAULT_HTML_TEMPLATE, DefaultTheme, Fragment, buildSearchIndex, buildSsg, clearRenderContext, collectGitHubRepos, collectOgpUrls, createI18nPlugin, createMarkdownEnvironment, createTheme, defaultTheme, defineTheme, each, extractDocs, extractIslandInfo, extractVideoId, fetchOgpData, fetchRepoData, generateFrontmatterTypes, generateHydrationScript, generateMarkdown, generateOgImages, generateTabsCSS, generateTypes, hasIslands, inferType, jsx, jsxs, lintMarkdown, lintMarkdownAsync, lintMarkdownFile, lintMarkdownFiles, mergeThemes, mermaidClientScript, oxContent, prefetchGitHubRepos, prefetchOgpData, raw, renderAllPages, renderPage, renderToString, resolveDocsOptions, resolveI18nOptions, resolveOgImageOptions, resolveSearchOptions, resolveSsgOptions, resolveTheme, setRenderContext, shouldLintMarkdownFile, transformAllPlugins, transformGitHub, transformIslands, transformMarkdown, transformMermaidStatic, transformOgp, transformTabs, transformYouTube, useIsActive, useNav, usePageProps, useRenderContext, useSiteConfig, when, writeDocs, writeSearchIndex };
 
 //# sourceMappingURL=index.mjs.map