lildocs 0.0.0 → 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,2315 @@
+#!/usr/bin/env node
+import { n as renderGitHubPagesWorkflow, r as repoRelativeInputPath, t as normalizeBasePath } from "./github-pages-0s3VHkYL.mjs";
+import { createRequire } from "node:module";
+import { spawn } from "node:child_process";
+import { command, flag, option, optional, positional, run, string, subcommands } from "cmd-ts";
+import { createReadStream, existsSync, watch } from "node:fs";
+import { access, copyFile, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import matter from "gray-matter";
+import { Marked, Parser, Renderer, marked } from "marked";
+import markedShiki from "marked-shiki";
+import { bundledThemes, codeToHtml } from "shiki";
+import { renderMermaidSVG } from "beautiful-mermaid";
+import os from "node:os";
+import { generateMarkdownForModule } from "exports-md";
+import { clampGamut, converter, formatHex, parse, wcagContrast } from "culori";
+import { createJiti } from "jiti";
+import { render } from "preact-render-to-string";
+import { jsx, jsxs } from "preact/jsx-runtime";
+import http from "node:http";
+//#region src/core/errors.ts
+var LildocsError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "LildocsError";
+	}
+};
+//#endregion
+//#region src/core/config.ts
+async function readDocsConfig(docsRoot) {
+	const configPath = path.join(docsRoot, "config.json");
+	let rawConfig;
+	try {
+		rawConfig = await readFile(configPath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return {};
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(rawConfig);
+	} catch (error) {
+		throw new LildocsError(`Invalid docs config JSON at ${configPath}: ${errorMessage$3(error)}`);
+	}
+	return validateDocsConfig(parsed, configPath);
+}
+function mergeConfigOptions(options) {
+	return {
+		projectName: options.config.projectName,
+		theme: options.theme ?? options.config.theme,
+		fonts: {
+			heading: options.fonts?.heading ?? options.config.font?.heading,
+			body: options.fonts?.body ?? options.config.font?.body,
+			code: options.fonts?.code ?? options.config.font?.code
+		},
+		favicon: options.favicon ?? options.config.favicon,
+		logo: {
+			image: options.logo?.image ?? options.config.logo?.image,
+			text: options.logo?.text ?? options.config.logo?.text,
+			font: options.logo?.font ?? options.config.logo?.font
+		},
+		background: {
+			image: options.background?.image ?? options.config.background?.image,
+			gradient: options.background?.gradient ?? options.config.background?.gradient,
+			blendMode: options.background?.blendMode ?? options.config.background?.blendMode
+		},
+		link: { underline: options.link?.underline ?? options.config.link?.underline },
+		reference: { packageJson: options.config.reference?.packageJson },
+		navigation: {
+			transition: options.navigation?.transition ?? options.config.navigation?.transition,
+			duration: options.navigation?.duration ?? options.config.navigation?.duration,
+			easing: options.navigation?.easing ?? options.config.navigation?.easing,
+			order: options.config.navigation?.order
+		}
+	};
+}
+function validateDocsConfig(value, configPath) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new LildocsError(`Docs config must be a JSON object: ${configPath}`);
+	const config = value;
+	assertOptionalString(config.$schema, "$schema", configPath);
+	assertOptionalString(config.projectName, "projectName", configPath);
+	assertOptionalThemeConfig(config.theme, configPath);
+	assertOptionalString(config.favicon, "favicon", configPath);
+	if (config.font !== void 0) {
+		if (!config.font || typeof config.font !== "object" || Array.isArray(config.font)) throw new LildocsError(`Docs config "font" must be an object: ${configPath}`);
+		assertOptionalString(config.font.heading, "font.heading", configPath);
+		assertOptionalString(config.font.body, "font.body", configPath);
+		assertOptionalString(config.font.code, "font.code", configPath);
+	}
+	if (config.logo !== void 0) {
+		if (!config.logo || typeof config.logo !== "object" || Array.isArray(config.logo)) throw new LildocsError(`Docs config "logo" must be an object: ${configPath}`);
+		assertOptionalString(config.logo.image, "logo.image", configPath);
+		assertOptionalString(config.logo.text, "logo.text", configPath);
+		assertOptionalString(config.logo.font, "logo.font", configPath);
+	}
+	if (config.background !== void 0) {
+		if (!config.background || typeof config.background !== "object" || Array.isArray(config.background)) throw new LildocsError(`Docs config "background" must be an object: ${configPath}`);
+		assertOptionalString(config.background.image, "background.image", configPath);
+		assertOptionalString(config.background.gradient, "background.gradient", configPath);
+		assertOptionalString(config.background.blendMode, "background.blendMode", configPath);
+	}
+	if (config.link !== void 0) {
+		if (!config.link || typeof config.link !== "object" || Array.isArray(config.link)) throw new LildocsError(`Docs config "link" must be an object: ${configPath}`);
+		assertOptionalEnum(config.link.underline, "link.underline", [
+			"always",
+			"hover",
+			"none"
+		], configPath);
+	}
+	if (config.navigation !== void 0) {
+		if (!config.navigation || typeof config.navigation !== "object" || Array.isArray(config.navigation)) throw new LildocsError(`Docs config "navigation" must be an object: ${configPath}`);
+		assertOptionalEnum(config.navigation.transition, "navigation.transition", [
+			"fade",
+			"slide",
+			"scale",
+			"instant"
+		], configPath);
+		assertOptionalNumber(config.navigation.duration, "navigation.duration", configPath);
+		assertOptionalString(config.navigation.easing, "navigation.easing", configPath);
+		assertOptionalStringArray(config.navigation.order, "navigation.order", configPath);
+	}
+	if (config.reference !== void 0) {
+		if (!config.reference || typeof config.reference !== "object" || Array.isArray(config.reference)) throw new LildocsError(`Docs config "reference" must be an object: ${configPath}`);
+		assertOptionalString(config.reference.packageJson, "reference.packageJson", configPath);
+	}
+	return {
+		projectName: config.projectName,
+		theme: config.theme,
+		favicon: config.favicon,
+		font: config.font ? {
+			heading: config.font.heading,
+			body: config.font.body,
+			code: config.font.code
+		} : void 0,
+		logo: config.logo ? {
+			image: config.logo.image,
+			text: config.logo.text,
+			font: config.logo.font
+		} : void 0,
+		background: config.background ? {
+			image: config.background.image,
+			gradient: config.background.gradient,
+			blendMode: config.background.blendMode
+		} : void 0,
+		link: config.link ? { underline: config.link.underline } : void 0,
+		reference: config.reference ? { packageJson: config.reference.packageJson } : void 0,
+		navigation: config.navigation ? {
+			transition: config.navigation.transition,
+			duration: config.navigation.duration,
+			easing: config.navigation.easing,
+			order: config.navigation.order
+		} : void 0
+	};
+}
+function assertOptionalString(value, name, configPath) {
+	if (value !== void 0 && (typeof value !== "string" || value.length === 0)) throw new LildocsError(`Docs config "${name}" must be a non-empty string: ${configPath}`);
+}
+function assertOptionalThemeConfig(value, configPath) {
+	if (value === void 0) return;
+	if (typeof value === "string") {
+		assertOptionalString(value, "theme", configPath);
+		return;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new LildocsError(`Docs config "theme" must be a string or an object: ${configPath}`);
+	const theme = value;
+	assertOptionalString(theme.light, "theme.light", configPath);
+	assertOptionalString(theme.dark, "theme.dark", configPath);
+}
+function assertOptionalEnum(value, name, allowed, configPath) {
+	if (value !== void 0 && !allowed.includes(String(value))) throw new LildocsError(`Docs config "${name}" must be one of ${allowed.join(", ")}: ${configPath}`);
+}
+function assertOptionalNumber(value, name, configPath) {
+	if (value !== void 0 && (typeof value !== "number" || !Number.isFinite(value) || value < 0)) throw new LildocsError(`Docs config "${name}" must be a non-negative finite number: ${configPath}`);
+}
+function assertOptionalStringArray(value, name, configPath) {
+	if (value === void 0) return;
+	if (!Array.isArray(value)) throw new LildocsError(`Docs config "${name}" must be an array: ${configPath}`);
+	for (const [index, item] of value.entries()) assertOptionalString(item, `${name}[${index}]`, configPath);
+}
+function isMissingFileError(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function errorMessage$3(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/core/paths.ts
+function toPosixPath(value) {
+	return value.split(path.sep).join("/");
+}
+function isHiddenOrSystemPath(relativePath) {
+	return toPosixPath(relativePath).split("/").some((part) => part.startsWith(".") || part === "node_modules" || part === ".DS_Store");
+}
+function relativeUrl(fromRoute, toRoute) {
+	const fromDir = path.posix.dirname(fromRoute);
+	const relative = path.posix.relative(fromDir, toRoute);
+	return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function isExternalOrAnchorUrl(href) {
+	return /^(?:[a-z]+:)?\/\//i.test(href) || href.startsWith("#") || href.startsWith("mailto:");
+}
+function resolveMarkdownDocumentPath(fromRelativePath, href) {
+	if (isExternalOrAnchorUrl(href)) return;
+	const [hrefPath] = href.split("#");
+	if (!hrefPath?.toLowerCase().endsWith(".md")) return;
+	return path.posix.normalize(path.posix.join(path.posix.dirname(fromRelativePath), hrefPath.replace(/\\/g, "/")));
+}
+function pageDepth(route) {
+	const dir = path.posix.dirname(route);
+	return dir === "." ? 0 : dir.split("/").length;
+}
+function rootRelativeUrl(route, target) {
+	return `${pageDepth(route) === 0 ? "." : Array.from({ length: pageDepth(route) }, () => "..").join("/")}/${target}`;
+}
+//#endregion
+//#region src/core/input.ts
+const HOME_PAGE_CANDIDATES = [
+	"index.md",
+	"intro.md",
+	"introduction.md",
+	"getting-started.md",
+	"quickstart.md",
+	"readme.md",
+	"README.md"
+];
+const README_FIRST_HOME_PAGE_CANDIDATES = ["README.md", ...HOME_PAGE_CANDIDATES.filter((candidate) => candidate !== "README.md")];
+async function resolveInput(input, cwd, options = {}) {
+	const inputPath = path.resolve(cwd, input);
+	let inputStat;
+	try {
+		inputStat = await stat(inputPath);
+	} catch {
+		throw new LildocsError(`Input path does not exist: ${input}`);
+	}
+	if (inputStat.isFile()) {
+		if (path.extname(inputPath).toLowerCase() !== ".md") throw new LildocsError(`Input file must be Markdown: ${input}`);
+		return {
+			docsRoot: path.dirname(inputPath),
+			homePage: inputPath
+		};
+	}
+	if (!inputStat.isDirectory()) throw new LildocsError(`Input path must be a Markdown file or directory: ${input}`);
+	const homePage = await findHomePage(inputPath, options.homePagePreference);
+	if (!homePage) throw new LildocsError(`No Markdown files found in docs directory: ${input}`);
+	return {
+		docsRoot: inputPath,
+		homePage
+	};
+}
+async function findHomePage(docsRoot, preference = "default") {
+	const homePageCandidates = preference === "readme-first" ? README_FIRST_HOME_PAGE_CANDIDATES : HOME_PAGE_CANDIDATES;
+	const homePage = (await Promise.all(homePageCandidates.map(async (candidate) => {
+		const candidatePath = path.join(docsRoot, candidate);
+		try {
+			return (await stat(candidatePath)).isFile() ? candidatePath : void 0;
+		} catch {
+			return;
+		}
+	}))).find(Boolean);
+	if (homePage) return homePage;
+	return (await collectMarkdownPaths(docsRoot, docsRoot))[0];
+}
+async function collectMarkdownPaths(docsRoot, currentDir = docsRoot) {
+	const entries = await readdir(currentDir, { withFileTypes: true });
+	return (await Promise.all(entries.toSorted((a, b) => a.name.localeCompare(b.name)).map(async (entry) => {
+		const fullPath = path.join(currentDir, entry.name);
+		if (isHiddenOrSystemPath(path.relative(docsRoot, fullPath))) return [];
+		if (entry.isDirectory()) return collectMarkdownPaths(docsRoot, fullPath);
+		if (entry.isFile() && path.extname(entry.name).toLowerCase() === ".md") return [fullPath];
+		return [];
+	}))).flat();
+}
+//#endregion
+//#region src/core/content.ts
+async function buildContentModel(input, outDirName, navigationOrder = [], additionalPages = []) {
+	const paths = await collectMarkdownPaths(input.docsRoot);
+	const pages = [...await Promise.all(paths.map((sourcePath) => readPage(input, sourcePath))), ...additionalPages.map((page) => pageFromMarkdown(input, page))];
+	const orderEntries = normalizeNavigationOrder(navigationOrder);
+	const visiblePages = pages.filter((page) => !isInsideOutput(page.relativePath, outDirName));
+	const entryPointOrder = entryPointLinkOrder(visiblePages, input.homePage, orderEntries);
+	const sortedPages = visiblePages.toSorted((a, b) => navigationRank(a, orderEntries) - navigationRank(b, orderEntries) || routeRank(a, input.homePage) - routeRank(b, input.homePage) || entryPointLinkRank(a, entryPointOrder) - entryPointLinkRank(b, entryPointOrder) || a.route.localeCompare(b.route));
+	validateNavigationOrder(orderEntries, sortedPages);
+	ensureUniqueRoutes(sortedPages);
+	return {
+		docsRoot: input.docsRoot,
+		homePage: input.homePage,
+		pages: sortedPages,
+		bySourcePath: new Map(sortedPages.map((page) => [page.sourcePath, page])),
+		byRelativePath: new Map(sortedPages.map((page) => [page.relativePath, page]))
+	};
+}
+async function readPage(input, sourcePath) {
+	const rawMarkdown = await readFile(sourcePath, "utf8");
+	return pageFromMarkdown(input, {
+		sourcePath,
+		relativePath: toPosixPath(path.relative(input.docsRoot, sourcePath)),
+		rawMarkdown
+	});
+}
+function pageFromMarkdown(input, page) {
+	const parsed = matter(page.rawMarkdown);
+	const relativePath = toPosixPath(page.relativePath);
+	const route = page.sourcePath === input.homePage ? "index.html" : markdownPathToRoute(relativePath);
+	const headings = extractHeadings(parsed.content);
+	const title = inferTitle(parsed.data, parsed.content, page.sourcePath);
+	return {
+		sourcePath: page.sourcePath,
+		relativePath,
+		route,
+		outputPath: route,
+		title,
+		rawMarkdown: page.rawMarkdown,
+		markdown: parsed.content,
+		metadata: parsed.data,
+		headings
+	};
+}
+function inferTitle(metadata, markdown, sourcePath) {
+	if (typeof metadata.title === "string" && metadata.title.trim()) return metadata.title.trim();
+	const h1 = markdown.match(/^#\s+(.+)$/m);
+	if (h1?.[1]) return stripMarkdownInline(h1[1]).trim();
+	return formatFilename(path.basename(sourcePath, path.extname(sourcePath)));
+}
+function slugify(value) {
+	return value.toLowerCase().trim().replace(/[`*_~[\]()]/g, "").replace(/&/g, " and ").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "section";
+}
+function extractHeadings(markdown) {
+	const seen = /* @__PURE__ */ new Map();
+	const headings = [];
+	for (const line of markdown.split(/\r?\n/)) {
+		const match = line.match(/^(#{1,6})\s+(.+)$/);
+		if (!match?.[1] || !match[2]) continue;
+		const baseId = slugify(stripMarkdownInline(match[2]));
+		const count = seen.get(baseId) ?? 0;
+		seen.set(baseId, count + 1);
+		headings.push({
+			depth: match[1].length,
+			text: stripMarkdownInline(match[2]).trim(),
+			id: count === 0 ? baseId : `${baseId}-${count + 1}`
+		});
+	}
+	return headings;
+}
+function stripMarkdownInline(value) {
+	return value.replace(/[`*_~]/g, "").replace(/\[(.*?)\]\(.*?\)/g, "$1");
+}
+function formatFilename(value) {
+	return value.replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase()).trim();
+}
+function markdownPathToRoute(relativePath) {
+	const parsed = path.posix.parse(relativePath);
+	const slug = slugify(parsed.name);
+	return `${parsed.dir ? `${parsed.dir}/` : ""}${slug}.html`;
+}
+function routeRank(page, homePage) {
+	return page.sourcePath === homePage ? -1 : 0;
+}
+function entryPointLinkOrder(pages, homePage, navigationOrder) {
+	const home = pages.find((page) => page.sourcePath === homePage);
+	if (!home) return /* @__PURE__ */ new Map();
+	const byRelativePath = new Map(pages.map((page) => [page.relativePath, page]));
+	const ordered = /* @__PURE__ */ new Map();
+	for (const href of markdownLinkHrefs(home.markdown)) {
+		const targetPath = resolveMarkdownDocumentPath(home.relativePath, href);
+		if (!targetPath) continue;
+		const target = byRelativePath.get(targetPath);
+		if (!target || target.sourcePath === homePage || navigationOrder.some((entry) => navigationOrderEntryMatchesPage(entry, target)) || ordered.has(target.relativePath)) continue;
+		ordered.set(target.relativePath, ordered.size);
+	}
+	return ordered;
+}
+function markdownLinkHrefs(markdown) {
+	const hrefs = [];
+	marked.walkTokens(marked.lexer(markdown), (token) => {
+		if (token.type === "link") hrefs.push(token.href);
+	});
+	return hrefs;
+}
+function entryPointLinkRank(page, order) {
+	return order.get(page.relativePath) ?? order.size;
+}
+function normalizeNavigationOrder(order) {
+	const seen = /* @__PURE__ */ new Map();
+	return order.map((value, index) => {
+		const normalized = normalizeNavigationOrderPath(value);
+		const previous = seen.get(normalized);
+		if (previous !== void 0) throw new LildocsError(`Docs config "navigation.order[${index}]" duplicates "navigation.order[${previous}]"`);
+		seen.set(normalized, index);
+		return {
+			value: normalized,
+			index,
+			kind: normalized.endsWith("/") ? "directory" : "file"
+		};
+	});
+}
+function normalizeNavigationOrderPath(value) {
+	return value.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function navigationRank(page, order) {
+	return order.find((item) => navigationOrderEntryMatchesPage(item, page))?.index ?? order.length;
+}
+function validateNavigationOrder(order, pages) {
+	for (const entry of order) {
+		if (pages.some((page) => navigationOrderEntryMatchesPage(entry, page))) continue;
+		throw new LildocsError(`Docs config "navigation.order[${entry.index}]" does not match a page or folder`);
+	}
+}
+function navigationOrderEntryMatchesPage(entry, page) {
+	if (entry.kind === "directory") return page.relativePath.startsWith(entry.value);
+	return page.relativePath === entry.value;
+}
+function isInsideOutput(relativePath, outDirName) {
+	return relativePath === outDirName || relativePath.startsWith(`${outDirName}/`);
+}
+function ensureUniqueRoutes(pages) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const page of pages) {
+		const count = seen.get(page.route) ?? 0;
+		seen.set(page.route, count + 1);
+		if (count === 0) continue;
+		const parsed = path.posix.parse(page.route);
+		page.route = `${parsed.dir ? `${parsed.dir}/` : ""}${parsed.name}-${count + 1}.html`;
+		page.outputPath = page.route;
+	}
+}
+//#endregion
+//#region src/vendor/marked-alert/index.ts
+const defaultAlertVariants = [
+	{
+		type: "note",
+		icon: materialSymbol("info")
+	},
+	{
+		type: "tip",
+		icon: materialSymbol("lightbulb")
+	},
+	{
+		type: "important",
+		icon: materialSymbol("feedback")
+	},
+	{
+		type: "warning",
+		icon: materialSymbol("warning")
+	},
+	{
+		type: "caution",
+		icon: materialSymbol("dangerous")
+	}
+];
+function markedAlert(options = {}) {
+	const { className = "markdown-alert", variants = [] } = options;
+	const resolvedVariants = resolveVariants(variants);
+	return {
+		walkTokens(token) {
+			if (token.type !== "blockquote") return;
+			const matchedVariant = resolvedVariants.find(({ type }) => new RegExp(createSyntaxPattern(type)).test(token.text));
+			if (!matchedVariant) return;
+			const { type: variant, icon, title = capitalize$1(matchedVariant.type), titleClassName = `${className}-title` } = matchedVariant;
+			const syntaxPattern = new RegExp(createSyntaxPattern(variant));
+			Object.assign(token, {
+				type: "alert",
+				meta: {
+					className,
+					variant,
+					icon,
+					title,
+					titleClassName
+				}
+			});
+			const firstLine = token.tokens?.[0];
+			const firstLineText = firstLine?.raw?.replace(syntaxPattern, "").trim();
+			if (!firstLine || !firstLineText) {
+				token.tokens?.shift();
+				return;
+			}
+			const markerToken = firstLine.tokens[0];
+			if (markerToken) Object.assign(markerToken, {
+				raw: markerToken.raw.replace(syntaxPattern, ""),
+				text: markerToken.text.replace(syntaxPattern, "")
+			});
+			if (firstLine.tokens[1]?.type === "br") firstLine.tokens.splice(1, 1);
+		},
+		extensions: [{
+			name: "alert",
+			level: "block",
+			renderer(token) {
+				const { meta, tokens = [] } = token;
+				let html = `<div class="${meta.className} ${meta.className}-${meta.variant}">\n`;
+				html += `<p class="${meta.titleClassName}">`;
+				html += meta.icon;
+				html += meta.title;
+				html += "</p>\n";
+				html += this.parser.parse(tokens);
+				html += "</div>\n";
+				return html;
+			}
+		}]
+	};
+}
+function resolveVariants(variants) {
+	if (!variants.length) return defaultAlertVariants;
+	return Object.values([...defaultAlertVariants, ...variants].reduce((map, item) => {
+		map[item.type] = item;
+		return map;
+	}, {}));
+}
+function createSyntaxPattern(type) {
+	return `^(?:\\[!${escapeRegExp(type.toUpperCase())}]\\s*?)\\n*`;
+}
+function capitalize$1(value) {
+	return value.slice(0, 1).toUpperCase() + value.slice(1).toLowerCase();
+}
+function materialSymbol(name) {
+	return `<span class="material-symbols-rounded markdown-alert-icon" aria-hidden="true">${name}</span>`;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/core/search.ts
+function buildSearchIndex(pages) {
+	return pages.flatMap((page) => [{
+		kind: "page",
+		title: page.title,
+		pageTitle: page.title,
+		route: page.route,
+		headings: page.headings.map((heading) => heading.text),
+		text: normalizeSearchText(page.searchText ?? page.markdown)
+	}, ...buildSectionEntries(page)]);
+}
+function normalizeSearchText(value) {
+	return value.replace(/<[^>]+>/g, " ").replace(/[^\p{L}\p{N}]+/gu, " ").replace(/\s+/g, " ").trim();
+}
+function buildSectionEntries(page) {
+	const entries = [];
+	const headingQueue = [...page.headings];
+	const headingPath = [];
+	let activeSection;
+	const pushActiveSection = () => {
+		if (!activeSection) return;
+		entries.push({
+			kind: "section",
+			title: activeSection.heading.text,
+			pageTitle: page.title,
+			route: `${page.route}#${activeSection.heading.id}`,
+			headings: activeSection.path.map((heading) => heading.text),
+			text: normalizeSearchText(activeSection.lines.join("\n")),
+			depth: activeSection.heading.depth
+		});
+	};
+	for (const line of page.markdown.split(/\r?\n/)) {
+		if (!line.match(/^(#{1,6})\s+(.+)$/)?.[1]) {
+			activeSection?.lines.push(line);
+			continue;
+		}
+		const heading = headingQueue.shift();
+		if (!heading) {
+			activeSection?.lines.push(line);
+			continue;
+		}
+		while (headingPath.at(-1) && headingPath.at(-1).depth >= heading.depth) headingPath.pop();
+		headingPath.push(heading);
+		if (heading.depth === 2 || heading.depth === 3) {
+			pushActiveSection();
+			activeSection = {
+				heading,
+				path: [...headingPath],
+				lines: []
+			};
+			continue;
+		}
+		if (activeSection && heading.depth <= activeSection.heading.depth) {
+			pushActiveSection();
+			activeSection = void 0;
+			continue;
+		}
+		activeSection?.lines.push(line);
+	}
+	pushActiveSection();
+	return entries;
+}
+//#endregion
+//#region src/core/markdown.ts
+async function renderMarkdownPage(model, page, outDir, options = {}) {
+	const assets = [];
+	const headingIds = [...page.headings];
+	let mermaidDiagramIndex = 0;
+	const renderer = new Renderer();
+	renderer.heading = ({ tokens, depth }) => {
+		const text = Parser.parseInline(tokens);
+		return `<h${depth} id="${nextHeading(headingIds, depth, stripHtml(text))?.id ?? ""}">${text}</h${depth}>`;
+	};
+	renderer.link = ({ href, title, tokens }) => {
+		const text = Parser.parseInline(tokens);
+		const rewritten = rewriteLink(model, page, href);
+		const titleAttribute = title ? ` title="${escapeHtml$1(title)}"` : "";
+		return `<a href="${escapeHtml$1(rewritten)}"${titleAttribute}>${text}</a>`;
+	};
+	renderer.image = ({ href, title, text }) => {
+		const rewritten = registerAsset(model, page, outDir, href, assets);
+		const titleAttribute = title ? ` title="${escapeHtml$1(title)}"` : "";
+		return `<img src="${escapeHtml$1(rewritten)}" alt="${escapeHtml$1(text)}"${titleAttribute}>`;
+	};
+	return {
+		html: await new Marked({
+			async: true,
+			gfm: true,
+			renderer
+		}).use(markedAlert(), markedShiki({ async highlight(code, lang, props) {
+			if (lang?.toLowerCase() === "mermaid") {
+				mermaidDiagramIndex += 1;
+				if (!options.mermaid) throw new LildocsError(`No Mermaid renderer configured for ${page.relativePath}`);
+				try {
+					return await options.mermaid.render(code, `mermaid-${stableIdPart(page.route)}-${mermaidDiagramIndex}`);
+				} catch (error) {
+					throw new LildocsError(`Failed to render Mermaid diagram ${mermaidDiagramIndex} in ${page.relativePath}: ${errorMessage$2(error)}`);
+				}
+			}
+			return highlightCode(code, lang, props, options.shikiTheme);
+		} })).parse(page.markdown),
+		assets,
+		text: normalizeSearchText(page.markdown)
+	};
+}
+async function highlightCode(code, lang, props, theme = {}) {
+	const lightTheme = theme.light ?? "github-light";
+	const darkTheme = theme.dark;
+	const themeOptions = darkTheme ? {
+		themes: {
+			light: lightTheme,
+			dark: darkTheme
+		},
+		defaultColor: false
+	} : { theme: lightTheme };
+	try {
+		return normalizeShikiBackground(await codeToHtml(code, {
+			lang: lang || "text",
+			...themeOptions,
+			meta: { __raw: props.join(" ") }
+		}));
+	} catch {
+		return normalizeShikiBackground(await codeToHtml(code, {
+			lang: "text",
+			...themeOptions
+		}));
+	}
+}
+function normalizeShikiBackground(html) {
+	return html.replace(/background-color:[^;"]+;?/, "background-color:var(--ld-color-code-background);").replace(/--shiki-light-bg:[^;"]+/, "--shiki-light-bg:var(--ld-color-code-background)").replace(/--shiki-dark-bg:[^;"]+/, "--shiki-dark-bg:var(--ld-color-code-background)");
+}
+async function copyAssets(assets) {
+	const uniqueAssets = new Map(assets.map((asset) => [asset.to, asset]));
+	await Promise.all([...uniqueAssets.values()].map(async (asset) => {
+		let assetStat;
+		try {
+			assetStat = await stat(asset.from);
+		} catch {
+			throw new LildocsError(`Referenced asset does not exist: ${asset.from}`);
+		}
+		if (!assetStat.isFile()) throw new LildocsError(`Referenced asset is not a file: ${asset.from}`);
+		await mkdir(path.dirname(asset.to), { recursive: true });
+		await copyFile(asset.from, asset.to);
+	}));
+}
+function nextHeading(headings, depth, text) {
+	const index = headings.findIndex((heading) => heading.depth === depth && heading.text === text);
+	if (index === -1) return;
+	return headings.splice(index, 1)[0];
+}
+function rewriteLink(model, page, href) {
+	const targetPath = resolveMarkdownDocumentPath(page.relativePath, href);
+	if (!targetPath) return href;
+	const targetPage = model.byRelativePath.get(targetPath);
+	if (!targetPage) return href;
+	const relative = path.posix.relative(path.posix.dirname(page.route), targetPage.route);
+	const url = relative.startsWith(".") ? relative : `./${relative}`;
+	const hash = href.includes("#") ? href.slice(href.indexOf("#") + 1) : void 0;
+	return hash ? `${url}#${hash}` : url;
+}
+function registerAsset(model, page, outDir, href, assets) {
+	if (isExternalOrAnchorUrl(href)) return href;
+	const source = path.resolve(model.docsRoot, path.dirname(page.relativePath), href);
+	const outputRelativePath = `assets/${toPosixPath(path.relative(model.docsRoot, source))}`;
+	assets.push({
+		from: source,
+		to: path.join(outDir, outputRelativePath)
+	});
+	return rootRelativeUrl(page.route, outputRelativePath);
+}
+function stripHtml(value) {
+	return value.replace(/<[^>]*>/g, "");
+}
+function stableIdPart(value) {
+	return value.replace(/\.[^.]+$/, "").replace(/[^a-z0-9_-]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+function errorMessage$2(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function escapeHtml$1(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+//#endregion
+//#region src/core/mermaid.ts
+async function createMermaidRenderer(options) {
+	return {
+		async render(source, idHint) {
+			try {
+				const svg = addImageRole(renderMermaidSVG(source, toRenderOptions(options.themeConfig)));
+				return `<figure class="mermaidDiagram" id="${escapeHtml(idHint)}">${svg}</figure>`;
+			} catch (error) {
+				throw new LildocsError(`Failed to render Mermaid diagram ${idHint}: ${errorMessage$1(error)}`);
+			}
+		},
+		async close() {}
+	};
+}
+function toRenderOptions(themeConfig) {
+	return {
+		bg: themeConfig.bg,
+		fg: themeConfig.fg,
+		accent: themeConfig.accent,
+		muted: themeConfig.muted,
+		surface: themeConfig.surface,
+		border: themeConfig.border,
+		font: themeConfig.fontFamily
+	};
+}
+function addImageRole(svg) {
+	return svg.replace("<svg", "<svg role=\"img\"");
+}
+function errorMessage$1(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+//#endregion
+//#region src/core/nav.ts
+function buildNavigation(model, activePage) {
+	return nestNavItems(model.pages.map((page) => pageToNavItem(page, activePage)));
+}
+function pageToNavItem(page, activePage) {
+	return {
+		title: page.title,
+		route: page.route,
+		active: page.route === activePage.route,
+		hasPage: true,
+		children: []
+	};
+}
+function nestNavItems(items) {
+	const topLevel = [];
+	const byDir = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const dir = path.posix.dirname(item.route);
+		if (dir === ".") {
+			topLevel.push(item);
+			continue;
+		}
+		const parts = dir.split("/");
+		let currentChildren = topLevel;
+		let currentPath = "";
+		for (const part of parts) {
+			currentPath = currentPath ? `${currentPath}/${part}` : part;
+			let group = byDir.get(currentPath);
+			if (!group) {
+				group = {
+					title: titleFromDir(part),
+					route: `${currentPath}/index.html`,
+					active: false,
+					hasPage: false,
+					children: []
+				};
+				byDir.set(currentPath, group);
+				currentChildren.push(group);
+			}
+			currentChildren = group.children;
+		}
+		const group = byDir.get(dir);
+		if (group && item.route === group.route) {
+			group.active = item.active;
+			group.hasPage = true;
+			continue;
+		}
+		currentChildren.push(item);
+	}
+	return topLevel;
+}
+function titleFromDir(dir) {
+	return dir.replace(/[-_]+/g, " ").replace(/\S+/g, (word) => `${word[0]?.toLocaleUpperCase() ?? ""}${word.slice(1)}`);
+}
+//#endregion
+//#region src/core/reference.ts
+async function buildReferencePages(options) {
+	const packageJson = await resolveReferencePackageJson(options);
+	if (!packageJson) return [];
+	const packageJsonData = await readPackageJson(packageJson.packagePath);
+	if (!packageJson.configured && packageJsonData.exports === void 0) return [];
+	const tempDir = await mkdtemp(path.join(os.tmpdir(), "lildocs-reference-"));
+	try {
+		await generateMarkdownForModule(packageJson.packagePath, {
+			cwd: options.cwd,
+			outDir: tempDir
+		});
+		const markdownPaths = await collectMarkdownPaths(tempDir);
+		return Promise.all(markdownPaths.map(async (sourcePath) => {
+			const generatedPath = toPosixPath(path.relative(tempDir, sourcePath));
+			return {
+				sourcePath,
+				relativePath: toPosixPath(path.posix.join("reference", generatedPath)),
+				rawMarkdown: await readFile(sourcePath, "utf8")
+			};
+		}));
+	} catch (error) {
+		throw new LildocsError(`Failed to generate API reference: ${errorMessage(error)}`);
+	} finally {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function resolveReferencePackageJson(options) {
+	const configuredPath = options.reference?.packageJson;
+	if (configuredPath) {
+		const packagePath = path.resolve(options.docsRoot, configuredPath);
+		if (!existsSync(packagePath)) throw new LildocsError(`Configured reference package.json does not exist: ${packagePath}`);
+		return {
+			packagePath,
+			configured: true
+		};
+	}
+	const siblingPackageJson = path.join(path.dirname(options.docsRoot), "package.json");
+	if (existsSync(siblingPackageJson)) return {
+		packagePath: siblingPackageJson,
+		configured: false
+	};
+}
+async function readPackageJson(packagePath) {
+	try {
+		return JSON.parse(await readFile(packagePath, "utf8"));
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new LildocsError(`Invalid package.json for API reference: ${packagePath}`);
+		throw error;
+	}
+}
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+//#endregion
+//#region src/core/logo.ts
+async function resolveLogoOptions(options) {
+	const assets = [];
+	const css = [];
+	const logo = {};
+	if (options.logo?.text) logo.text = options.logo.text;
+	else if (!options.logo?.image && options.defaultText) logo.text = options.defaultText;
+	if (options.logo?.image) logo.image = imageAssetValue(options.logo.image, options, assets);
+	if (options.logo?.font) {
+		const localFontPath = await resolveLocalFontPath$1(options.logo.font, options);
+		if (localFontPath) {
+			const family = "Lildocs Logo Font";
+			assets.push({
+				from: localFontPath,
+				to: path.join(options.outDir, "assets", "fonts", path.basename(localFontPath))
+			});
+			css.push(`@font-face {
+  font-family: ${quoteCssString$1(family)};
+  src: url("./fonts/${path.basename(localFontPath)}") format("${fontFormat$1(localFontPath)}");
+  font-display: swap;
+}`);
+			css.push(`:root {
+  --ld-font-logo: ${quoteCssString$1(family)};
+}`);
+		} else {
+			css.push(`@import url("${googleFontsCssUrl$1(options.logo.font, "400;500;600;700")}");`);
+			css.push(`:root {
+  --ld-font-logo: ${quoteCssString$1(options.logo.font)};
+}`);
+		}
+	}
+	return {
+		assets,
+		css: css.length > 0 ? `${css.join("\n")}\n` : "",
+		logo,
+		favicon: options.favicon ? imageAssetValue(options.favicon, options, assets) : void 0
+	};
+}
+function imageAssetValue(value, options, assets) {
+	const trimmed = value.trim();
+	if (isRemoteImage(trimmed)) return trimmed;
+	const source = path.resolve(options.docsRoot, trimmed);
+	const assetRelativePath = path.relative(options.docsRoot, source).split(path.sep).join("/");
+	assets.push({
+		from: source,
+		to: path.join(options.outDir, "assets", assetRelativePath)
+	});
+	return `assets/${assetRelativePath}`;
+}
+async function resolveLocalFontPath$1(value, options) {
+	const candidates = [path.resolve(options.cwd, value), path.resolve(options.docsRoot, value)];
+	const existingCandidate = (await Promise.all(candidates.map(async (candidate) => ({
+		candidate,
+		exists: isFontFile$1(candidate) && await exists$1(candidate)
+	})))).find((candidate) => candidate.exists);
+	if (existingCandidate) return existingCandidate.candidate;
+	if (isFontFile$1(value) && path.basename(value) !== value) throw new LildocsError(`Logo font file does not exist: ${value}`);
+}
+function isRemoteImage(value) {
+	return /^(?:[a-z]+:)?\/\//i.test(value) || value.startsWith("data:") || value.startsWith("/");
+}
+function isFontFile$1(value) {
+	return /\.(?:woff2?|ttf|otf)$/i.test(value);
+}
+function fontFormat$1(value) {
+	const extension = path.extname(value).toLowerCase();
+	if (extension === ".woff2") return "woff2";
+	if (extension === ".woff") return "woff";
+	if (extension === ".ttf") return "truetype";
+	if (extension === ".otf") return "opentype";
+	return "woff2";
+}
+function googleFontsCssUrl$1(fontName, weights) {
+	return `https://fonts.googleapis.com/css2?family=${fontName.trim().replace(/\s+/g, "+")}:wght@${weights}&display=swap`;
+}
+function quoteCssString$1(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+async function exists$1(filePath) {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/core/theme.ts
+const MIN_BACKGROUND_CONTRAST = 1.08;
+const PREFERRED_BACKGROUND_CONTRAST = 1.14;
+const MAX_BACKGROUND_CONTRAST_STEPS = 12;
+const BACKGROUND_LIGHTNESS_STEP = .015;
+const MAX_BACKGROUND_CHROMA = .03;
+const toOklch = converter("oklch");
+const clampToRgb = clampGamut("rgb");
+const themes = {
+	default: {
+		color: {
+			background: "#ffffff",
+			text: "#171717",
+			mutedText: "#666666",
+			border: "#e5e5e5",
+			link: "#2563eb",
+			codeBackground: "#f6f8fa",
+			sidebarBackground: "#fafafa"
+		},
+		font: {
+			heading: "system-ui, sans-serif",
+			body: "system-ui, sans-serif",
+			code: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace"
+		},
+		shiki: { theme: "github-light" }
+	},
+	minimal: {
+		color: {
+			background: "#ffffff",
+			text: "#111111",
+			mutedText: "#707070",
+			border: "#dddddd",
+			link: "#0f766e",
+			codeBackground: "#f7f7f7",
+			sidebarBackground: "#ffffff"
+		},
+		font: {
+			heading: "Arial, sans-serif",
+			body: "Arial, sans-serif",
+			code: "Menlo, Consolas, monospace"
+		},
+		shiki: { theme: "github-light" }
+	}
+};
+async function resolveTheme(options) {
+	if (options.requestedTheme) {
+		if (typeof options.requestedTheme === "string") return { light: await resolveThemeName(options.requestedTheme) };
+		return {
+			light: await resolveThemeName(options.requestedTheme.light ?? "default"),
+			dark: await resolveThemeName(options.requestedTheme.dark ?? "github-dark")
+		};
+	}
+	const localThemePath = path.join(options.docsRoot, "theme.ts");
+	if (await exists(localThemePath)) return { light: validateTheme(await createJiti(pathToFileURL(options.cwd).href).import(localThemePath, { default: true }), localThemePath) };
+	return {
+		light: themes.default,
+		dark: await resolveThemeName("github-dark")
+	};
+}
+async function resolveThemeName(themeName) {
+	const theme = themes[themeName];
+	if (theme) return theme;
+	return resolveShikiTheme(themeName);
+}
+async function resolveShikiTheme(themeName) {
+	const themeLoader = bundledThemes[themeName];
+	if (!themeLoader) throw new LildocsError(`Unknown theme "${themeName}". Use a built-in lildocs theme (${Object.keys(themes).join(", ")}) or a bundled Shiki theme.`);
+	const themeModule = await themeLoader();
+	return mapShikiThemeToTheme("default" in themeModule ? themeModule.default : themeModule, themeName);
+}
+async function resolveFontOverrides(options) {
+	const css = [];
+	const assets = [];
+	const themeFonts = {};
+	const resolved = await Promise.all([
+		"heading",
+		"body",
+		"code"
+	].map(async (target) => {
+		const value = options.fonts?.[target];
+		return {
+			target,
+			value,
+			localFontPath: value ? await resolveLocalFontPath(value, options) : void 0
+		};
+	}));
+	for (const { target, value, localFontPath } of resolved) {
+		if (!value) continue;
+		if (localFontPath) {
+			const family = `Lildocs ${capitalize(target)} Font`;
+			const outputRelativePath = `assets/fonts/${path.basename(localFontPath)}`;
+			assets.push({
+				from: localFontPath,
+				to: path.join(options.outDir, outputRelativePath)
+			});
+			css.push(`@font-face {
+  font-family: ${quoteCssString(family)};
+  src: url("./fonts/${path.basename(localFontPath)}") format("${fontFormat(localFontPath)}");
+  font-display: swap;
+}`);
+			themeFonts[target] = quoteCssString(family);
+			continue;
+		}
+		css.push(`@import url("${googleFontsCssUrl(value, target === "code" ? "400" : "400;500;600;700")}");`);
+		themeFonts[target] = quoteCssString(value);
+	}
+	return {
+		assets,
+		css: css.length > 0 ? `${css.join("\n")}\n` : "",
+		themeFonts
+	};
+}
+function themeToCssVariables(theme, fontOverrides = {}, linkOptions = {}, navigationOptions = {}) {
+	const linkDecoration = linkTextDecoration(linkOptions.underline);
+	const navigationDuration = navigationOptions.duration ?? 180;
+	const rootVariables = themeToCssVariableBlock(theme.light, fontOverrides);
+	const darkVariables = theme.dark ? themeToCssVariableBlock(theme.dark, fontOverrides) : void 0;
+	return `:root {
+${theme.dark ? "  color-scheme: light dark;\n" : ""}${rootVariables}
+  --ld-background-image: none;
+  --ld-background-blend-mode: normal;
+  --ld-font-logo: var(--ld-font-heading);
+  --ld-link-text-decoration: ${linkDecoration.default};
+  --ld-link-hover-text-decoration: ${linkDecoration.hover};
+  --ld-navigation-duration: ${navigationDuration}ms;
+  --ld-navigation-easing: ${navigationOptions.easing ?? "ease"};
+}${darkVariables ? `
+
+@media (prefers-color-scheme: dark) {
+  :root {
+${darkVariables}    color-scheme: dark;
+  }
+}` : ""}`;
+}
+function resolveBackgroundOptions(options) {
+	const assets = [];
+	const layers = [];
+	if (options.background?.gradient) layers.push(options.background.gradient);
+	if (options.background?.image) layers.push(backgroundImageValue(options.background.image, options, assets));
+	if (layers.length === 0 && !options.background?.blendMode) return {
+		assets,
+		css: ""
+	};
+	return {
+		assets,
+		css: `:root {
+  --ld-background-image: ${layers.length > 0 ? layers.join(", ") : "none"};
+  --ld-background-blend-mode: ${options.background?.blendMode ?? "normal"};
+}
+`
+	};
+}
+function themeToMermaidConfig(theme, fontOverrides = {}) {
+	const fonts = resolveThemeFonts(theme.light, fontOverrides);
+	return {
+		bg: theme.light.color.background,
+		fg: theme.light.color.text,
+		accent: theme.light.color.link,
+		muted: theme.light.color.mutedText,
+		surface: theme.light.color.codeBackground,
+		border: theme.light.color.border,
+		fontFamily: fonts.body
+	};
+}
+function themeToCssVariableBlock(theme, fontOverrides) {
+	const fonts = resolveThemeFonts(theme, fontOverrides);
+	const color = normalizeThemeColors(theme.color);
+	return `  --ld-color-background: ${color.background};
+  --ld-color-text: ${color.text};
+  --ld-color-muted-text: ${color.mutedText};
+  --ld-color-border: ${color.border};
+  --ld-color-link: ${color.link};
+  --ld-color-code-background: ${color.codeBackground};
+  --ld-color-sidebar-background: ${color.sidebarBackground ?? color.background};
+  --ld-font-heading: ${fonts.heading};
+  --ld-font-body: ${fonts.body};
+  --ld-font-code: ${fonts.code};
+`;
+}
+function normalizeThemeColors(color) {
+	return {
+		...color,
+		border: ensureDarkBorderLightness({
+			background: color.background,
+			text: color.text,
+			candidate: color.border
+		})
+	};
+}
+function validateTheme(value, themePath) {
+	if (!value || typeof value !== "object") throw new LildocsError(`Local theme must export an object: ${themePath}`);
+	const theme = value;
+	if ([
+		theme.color?.background,
+		theme.color?.text,
+		theme.color?.mutedText,
+		theme.color?.border,
+		theme.color?.link,
+		theme.color?.codeBackground,
+		theme.font?.body,
+		theme.font?.code ?? theme.font?.mono
+	].some((item) => typeof item !== "string" || item.length === 0)) throw new LildocsError(`Local theme is missing required color or font string values: ${themePath}`);
+	return theme;
+}
+function mapShikiThemeToTheme(shikiTheme, themeName) {
+	const colors = shikiTheme.colors ?? {};
+	const tokenColors = shikiTheme.tokenColors ?? [];
+	const background = pickColor(colors, [
+		"editor.background",
+		"background",
+		"sideBar.background"
+	], shikiTheme.bg ?? (shikiTheme.type === "dark" ? "#111111" : "#ffffff"));
+	const text = pickColor(colors, [
+		"editor.foreground",
+		"foreground",
+		"sideBar.foreground"
+	], shikiTheme.fg ?? (shikiTheme.type === "dark" ? "#f5f5f5" : "#111111"));
+	return {
+		color: {
+			background,
+			text,
+			mutedText: pickColor(colors, [
+				"descriptionForeground",
+				"breadcrumb.foreground",
+				"editorLineNumber.foreground",
+				"sideBar.foreground"
+			], tokenForeground(tokenColors, "comment") ?? text),
+			border: pickColor(colors, [
+				"panel.border",
+				"sideBar.border",
+				"editorGroup.border",
+				"tab.border"
+			], shikiTheme.type === "dark" ? "#333333" : "#e5e5e5"),
+			link: pickColor(colors, [
+				"textLink.foreground",
+				"terminal.ansiBlue",
+				"activityBarBadge.background"
+			], tokenForeground(tokenColors, "markup.inline.raw") ?? (shikiTheme.type === "dark" ? "#79b8ff" : "#2563eb")),
+			codeBackground: ensureBackgroundContrast({
+				background,
+				candidate: pickColor(colors, [
+					"textCodeBlock.background",
+					"editorWidget.background",
+					"editor.lineHighlightBackground",
+					"editor.background"
+				], background),
+				isDark: shikiTheme.type === "dark"
+			}),
+			sidebarBackground: pickColor(colors, [
+				"sideBar.background",
+				"activityBar.background",
+				"editorGroupHeader.tabsBackground"
+			], background)
+		},
+		font: {
+			heading: "system-ui, sans-serif",
+			body: "system-ui, sans-serif",
+			code: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace"
+		},
+		shiki: { theme: themeName }
+	};
+}
+function pickColor(colors, keys, fallback) {
+	for (const key of keys) {
+		const value = colors[key];
+		if (typeof value === "string" && value.trim()) return normalizeColor(value);
+	}
+	return normalizeColor(fallback);
+}
+function tokenForeground(tokenColors, scope) {
+	return tokenColors.find((item) => {
+		return (Array.isArray(item.scope) ? item.scope : [item.scope]).includes(scope);
+	})?.settings?.foreground;
+}
+function normalizeColor(value) {
+	if (/^#[0-9a-f]{3,8}$/i.test(value)) return value;
+	return value;
+}
+function linkTextDecoration(underline = "always") {
+	if (underline === "hover") return {
+		default: "none",
+		hover: "underline"
+	};
+	if (underline === "none") return {
+		default: "none",
+		hover: "none"
+	};
+	return {
+		default: "underline",
+		hover: "underline"
+	};
+}
+function backgroundImageValue(value, options, assets) {
+	const trimmed = value.trim();
+	if (isCssImageFunction(trimmed)) return trimmed;
+	if (/^(?:[a-z]+:)?\/\//i.test(trimmed) || trimmed.startsWith("data:") || trimmed.startsWith("/")) return `url(${quoteCssString(trimmed)})`;
+	const source = path.resolve(options.docsRoot, trimmed);
+	const assetRelativePath = path.relative(options.docsRoot, source).split(path.sep).join("/");
+	assets.push({
+		from: source,
+		to: path.join(options.outDir, "assets", assetRelativePath)
+	});
+	return `url(${quoteCssString(`./${assetRelativePath}`)})`;
+}
+function isCssImageFunction(value) {
+	return /^(?:url|linear-gradient|radial-gradient|conic-gradient|repeating-linear-gradient|repeating-radial-gradient|repeating-conic-gradient)\(/i.test(value);
+}
+function ensureBackgroundContrast(options) {
+	const background = parse(options.background);
+	const candidate = parse(options.candidate);
+	if (!background || !candidate) return options.candidate;
+	const currentContrast = wcagContrast(background, candidate);
+	if (currentContrast >= MIN_BACKGROUND_CONTRAST) return options.candidate;
+	const candidateOklch = toOklch(candidate);
+	if (!candidateOklch || typeof candidateOklch.l !== "number") return options.candidate;
+	const direction = options.isDark ? 1 : -1;
+	let bestColor = options.candidate;
+	let bestContrast = currentContrast;
+	for (let step = 1; step <= MAX_BACKGROUND_CONTRAST_STEPS; step += 1) {
+		const clampedColor = clampToRgb({
+			...candidateOklch,
+			l: clamp(candidateOklch.l + direction * BACKGROUND_LIGHTNESS_STEP * step, 0, 1),
+			c: typeof candidateOklch.c === "number" ? Math.min(candidateOklch.c, MAX_BACKGROUND_CHROMA) : candidateOklch.c
+		});
+		if (!clampedColor) continue;
+		const adjustedColor = formatHex(clampedColor);
+		const adjustedParsedColor = parse(adjustedColor);
+		if (!adjustedParsedColor) continue;
+		const adjustedContrast = wcagContrast(background, adjustedParsedColor);
+		if (adjustedContrast > bestContrast) {
+			bestColor = adjustedColor;
+			bestContrast = adjustedContrast;
+		}
+		if (adjustedContrast >= PREFERRED_BACKGROUND_CONTRAST) return adjustedColor;
+	}
+	return bestColor;
+}
+function ensureDarkBorderLightness(options) {
+	const background = parse(options.background);
+	const text = parse(options.text);
+	const candidate = parse(options.candidate);
+	if (!background || !text || !candidate) return options.candidate;
+	const backgroundOklch = toOklch(background);
+	const textOklch = toOklch(text);
+	const candidateOklch = toOklch(candidate);
+	if (!backgroundOklch || !textOklch || !candidateOklch || typeof backgroundOklch.l !== "number" || typeof textOklch.l !== "number" || typeof candidateOklch.l !== "number") return options.candidate;
+	if (backgroundOklch.l >= textOklch.l || candidateOklch.l > backgroundOklch.l) return options.candidate;
+	let bestColor = options.candidate;
+	let bestLightness = candidateOklch.l;
+	for (let step = 1; step <= MAX_BACKGROUND_CONTRAST_STEPS; step += 1) {
+		const clampedColor = clampToRgb({
+			...candidateOklch,
+			l: clamp(candidateOklch.l + BACKGROUND_LIGHTNESS_STEP * step, 0, 1),
+			c: typeof candidateOklch.c === "number" ? Math.min(candidateOklch.c, MAX_BACKGROUND_CHROMA) : candidateOklch.c
+		});
+		if (!clampedColor) continue;
+		const adjustedColor = formatHex(clampedColor);
+		const adjustedParsedColor = parse(adjustedColor);
+		const adjustedOklch = adjustedParsedColor ? toOklch(adjustedParsedColor) : void 0;
+		if (!adjustedOklch || typeof adjustedOklch.l !== "number") continue;
+		if (adjustedOklch.l > bestLightness) {
+			bestColor = adjustedColor;
+			bestLightness = adjustedOklch.l;
+		}
+		if (adjustedOklch.l > backgroundOklch.l) return adjustedColor;
+	}
+	return bestColor;
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function resolveThemeFonts(theme, overrides) {
+	const body = overrides.body ?? theme.font.body;
+	return {
+		heading: overrides.heading ?? theme.font.heading ?? body,
+		body,
+		code: overrides.code ?? theme.font.code ?? theme.font.mono ?? "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace"
+	};
+}
+async function resolveLocalFontPath(value, options) {
+	const candidates = [path.resolve(options.cwd, value), path.resolve(options.docsRoot, value)];
+	const existingCandidate = (await Promise.all(candidates.map(async (candidate) => ({
+		candidate,
+		exists: isFontFile(candidate) && await exists(candidate)
+	})))).find((candidate) => candidate.exists);
+	if (existingCandidate) return existingCandidate.candidate;
+	if (isFontFile(value) && path.basename(value) !== value) throw new LildocsError(`Font file does not exist: ${value}`);
+}
+function isFontFile(value) {
+	return /\.(?:woff2?|ttf|otf)$/i.test(value);
+}
+function fontFormat(value) {
+	const extension = path.extname(value).toLowerCase();
+	if (extension === ".woff2") return "woff2";
+	if (extension === ".woff") return "woff";
+	if (extension === ".ttf") return "truetype";
+	if (extension === ".otf") return "opentype";
+	return "woff2";
+}
+function googleFontsCssUrl(fontName, weights) {
+	return `https://fonts.googleapis.com/css2?family=${fontName.trim().replace(/\s+/g, "+")}:wght@${weights}&display=swap`;
+}
+function quoteCssString(value) {
+	return `"${value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+function capitalize(value) {
+	return `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+async function exists(filePath) {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/render/Layout.tsx
+function Layout({ page, nav, pageNavigation, css, searchIndexJson, logo, favicon, repositoryUrl, projectName, navigation, dev }) {
+	const transition = navigation?.transition ?? "fade";
+	const documentTitle = projectName ? `${page.title} • ${projectName}` : page.title;
+	const repoIconUrl = rootRelativeUrl(page.route, "assets/github-icon.svg");
+	return /* @__PURE__ */ jsxs("html", {
+		lang: "en",
+		children: [/* @__PURE__ */ jsxs("head", { children: [
+			/* @__PURE__ */ jsx("meta", { charSet: "utf-8" }),
+			/* @__PURE__ */ jsx("meta", {
+				name: "viewport",
+				content: "width=device-width, initial-scale=1"
+			}),
+			/* @__PURE__ */ jsx("title", { children: documentTitle }),
+			favicon ? /* @__PURE__ */ jsx("link", {
+				rel: "icon",
+				href: assetSrc(page.route, favicon)
+			}) : null,
+			/* @__PURE__ */ jsx("link", {
+				rel: "stylesheet",
+				href: "https://fonts.googleapis.com/css2?family=Material+Symbols+Rounded:opsz,wght,FILL,GRAD@20,400,0,0&display=block"
+			}),
+			/* @__PURE__ */ jsx("link", {
+				rel: "stylesheet",
+				href: rootRelativeUrl(page.route, "assets/lildocs.css")
+			})
+		] }), /* @__PURE__ */ jsxs("body", { children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "pageShell",
+				children: [/* @__PURE__ */ jsxs("header", {
+					className: "siteHeader",
+					children: [/* @__PURE__ */ jsxs("a", {
+						className: "brand",
+						href: relativeUrl(page.route, "index.html"),
+						children: [logo.image ? /* @__PURE__ */ jsx("img", {
+							className: "brandLogo",
+							src: assetSrc(page.route, logo.image),
+							alt: ""
+						}) : null, logo.text ? /* @__PURE__ */ jsx("span", { children: logo.text }) : null]
+					}), /* @__PURE__ */ jsxs("div", {
+						className: "headerActions",
+						children: [repositoryUrl ? /* @__PURE__ */ jsx("a", {
+							className: "repoButton",
+							href: repositoryUrl,
+							"aria-label": "View repository on GitHub",
+							title: "View repository on GitHub",
+							children: /* @__PURE__ */ jsx("span", {
+								className: "repoIcon",
+								"aria-hidden": "true",
+								style: `--ld-repo-icon: url(${repoIconUrl})`
+							})
+						}) : null, /* @__PURE__ */ jsxs("div", {
+							id: "lildocs-search-root",
+							className: "searchBox",
+							children: [/* @__PURE__ */ jsx("span", {
+								className: "searchIcon material-symbols-rounded",
+								"aria-hidden": "true",
+								children: "search"
+							}), /* @__PURE__ */ jsx("input", {
+								id: "lildocs-search-input",
+								type: "search",
+								placeholder: "Search docs",
+								"aria-label": "Search docs"
+							})]
+						})]
+					})]
+				}), /* @__PURE__ */ jsxs("div", {
+					id: "swup",
+					className: "contentGrid",
+					children: [
+						/* @__PURE__ */ jsx("aside", {
+							className: "sidebar",
+							children: /* @__PURE__ */ jsx("nav", {
+								"aria-label": "Documentation navigation",
+								children: /* @__PURE__ */ jsx(NavList, {
+									items: nav,
+									currentRoute: page.route,
+									pageRoute: page.route
+								})
+							})
+						}),
+						/* @__PURE__ */ jsxs("main", {
+							className: `content transition-${transition}`,
+							children: [/* @__PURE__ */ jsx("article", { dangerouslySetInnerHTML: { __html: page.html ?? "" } }), /* @__PURE__ */ jsx(PageNav, { pageNavigation })]
+						}),
+						/* @__PURE__ */ jsx("aside", {
+							className: `toc transition-${transition}`,
+							children: /* @__PURE__ */ jsx(Toc, { headings: page.headings })
+						})
+					]
+				})]
+			}),
+			/* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: `window.lildocsSearchUrl = ${JSON.stringify(rootRelativeUrl(page.route, "search-index.json"))};` } }),
+			/* @__PURE__ */ jsx("script", {
+				type: "application/json",
+				id: "lildocs-search-index",
+				dangerouslySetInnerHTML: { __html: searchIndexJson }
+			}),
+			/* @__PURE__ */ jsx("div", { id: "lildocs-overlay-root" }),
+			/* @__PURE__ */ jsx("script", {
+				type: "module",
+				src: rootRelativeUrl(page.route, "assets/search.js")
+			}),
+			/* @__PURE__ */ jsx("script", { src: rootRelativeUrl(page.route, "assets/copy-code.js") }),
+			/* @__PURE__ */ jsx("script", { src: rootRelativeUrl(page.route, "assets/swup.umd.js") }),
+			/* @__PURE__ */ jsx("script", { src: rootRelativeUrl(page.route, "assets/navigation.js") }),
+			dev ? /* @__PURE__ */ jsx("script", {
+				type: "module",
+				src: dev.clientScriptPath
+			}) : null,
+			/* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: css } })
+		] })]
+	});
+}
+function assetSrc(pageRoute, image) {
+	if (/^(?:[a-z]+:)?\/\//i.test(image) || image.startsWith("data:") || image.startsWith("/")) return image;
+	return rootRelativeUrl(pageRoute, image);
+}
+function PageNav({ pageNavigation }) {
+	if (!pageNavigation?.previous && !pageNavigation?.next) return null;
+	return /* @__PURE__ */ jsxs("nav", {
+		className: "pageNav",
+		"aria-label": "Page navigation",
+		children: [pageNavigation.previous ? /* @__PURE__ */ jsxs("a", {
+			className: "pageNavLink pageNavPrevious",
+			rel: "prev",
+			href: pageNavigation.previous.href,
+			children: [/* @__PURE__ */ jsx("span", { children: "Previous" }), pageNavigation.previous.title]
+		}) : /* @__PURE__ */ jsx("span", {}), pageNavigation.next ? /* @__PURE__ */ jsxs("a", {
+			className: "pageNavLink pageNavNext",
+			rel: "next",
+			href: pageNavigation.next.href,
+			children: [/* @__PURE__ */ jsx("span", { children: "Next" }), pageNavigation.next.title]
+		}) : null]
+	});
+}
+function NavList({ items, currentRoute, pageRoute }) {
+	return /* @__PURE__ */ jsx("ul", {
+		className: "navList",
+		children: items.map((item) => /* @__PURE__ */ jsxs("li", {
+			className: item.children.length > 0 ? "navGroup" : void 0,
+			children: [item.children.length > 0 && item.hasPage ? /* @__PURE__ */ jsxs("details", {
+				className: "navDisclosure",
+				open: isActiveBranch(item, currentRoute),
+				children: [/* @__PURE__ */ jsx("summary", {
+					className: item.route === currentRoute ? "active" : void 0,
+					children: item.title
+				}), /* @__PURE__ */ jsx(NavList, {
+					items: item.children,
+					currentRoute,
+					pageRoute
+				})]
+			}) : item.children.length > 0 ? /* @__PURE__ */ jsx("span", {
+				className: "navFolder",
+				children: item.title
+			}) : /* @__PURE__ */ jsx("a", {
+				className: item.route === currentRoute ? "active" : void 0,
+				href: relativeUrl(pageRoute, item.route),
+				children: item.title
+			}), item.children.length > 0 && !item.hasPage ? /* @__PURE__ */ jsx(NavList, {
+				items: item.children,
+				currentRoute,
+				pageRoute
+			}) : null]
+		}))
+	});
+}
+function isActiveBranch(item, currentRoute) {
+	return item.route === currentRoute || item.children.some((child) => isActiveBranch(child, currentRoute));
+}
+function Toc({ headings }) {
+	const tocHeadings = headings.filter((heading) => heading.depth > 1 && heading.depth < 4);
+	if (tocHeadings.length === 0) return null;
+	return /* @__PURE__ */ jsxs("nav", {
+		"aria-label": "Table of contents",
+		children: [/* @__PURE__ */ jsx("p", { children: "On this page" }), /* @__PURE__ */ jsx("ul", { children: tocHeadings.map((heading) => /* @__PURE__ */ jsx("li", {
+			className: `tocDepth${heading.depth}`,
+			children: /* @__PURE__ */ jsx("a", {
+				href: `#${heading.id}`,
+				children: heading.text
+			})
+		})) })]
+	});
+}
+//#endregion
+//#region src/render/renderPage.tsx
+function renderPage(page, nav, pageNavigation, css, searchIndexJson, logo, favicon, repositoryUrl, projectName, navigation, dev) {
+	return `<!doctype html>${render(/* @__PURE__ */ jsx(Layout, {
+		page,
+		nav,
+		pageNavigation,
+		css,
+		searchIndexJson,
+		logo,
+		favicon,
+		repositoryUrl,
+		projectName,
+		navigation,
+		dev
+	}))}`;
+}
+//#endregion
+//#region src/core/build.ts
+const sourceDir = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+async function buildSite(options) {
+	const input = await resolveInput(options.input, options.cwd, { homePagePreference: options.homePagePreference });
+	const configOptions = mergeConfigOptions({
+		config: await readDocsConfig(input.docsRoot),
+		theme: options.theme,
+		fonts: options.fonts,
+		favicon: options.favicon,
+		logo: options.logo,
+		background: options.background,
+		link: options.link,
+		navigation: options.navigation
+	});
+	const outDir = path.resolve(options.cwd, options.outDir);
+	const outDirName = path.basename(outDir);
+	const referencePages = await buildReferencePages({
+		cwd: options.cwd,
+		docsRoot: input.docsRoot,
+		reference: configOptions.reference
+	});
+	const model = await buildContentModel(input, outDirName, configOptions.navigation.order, referencePages);
+	const packagePath = await findNearestPackageJson(input.docsRoot, options.cwd);
+	const repositoryUrl = await resolveRepositoryUrl(packagePath);
+	const packageName = await resolvePackageName(packagePath);
+	const projectName = configOptions.projectName ?? packageName;
+	const theme = await resolveTheme({
+		cwd: options.cwd,
+		docsRoot: input.docsRoot,
+		requestedTheme: configOptions.theme
+	});
+	const fontResolution = await resolveFontOverrides({
+		cwd: options.cwd,
+		docsRoot: input.docsRoot,
+		outDir,
+		fonts: configOptions.fonts
+	});
+	const baseCss = await readRenderAsset("styles.css");
+	const searchScript = await readRenderAsset("search.js");
+	const copyCodeScript = await readRenderAsset("copy-code.js");
+	const navigationScript = await readRenderAsset("navigation.js");
+	const githubIcon = await readRenderAsset("github-icon.svg");
+	const swupScript = await readSwupAsset();
+	const backgroundResolution = resolveBackgroundOptions({
+		cwd: options.cwd,
+		docsRoot: input.docsRoot,
+		outDir,
+		background: configOptions.background
+	});
+	const logoResolution = await resolveLogoOptions({
+		cwd: options.cwd,
+		docsRoot: input.docsRoot,
+		outDir,
+		logo: configOptions.logo,
+		defaultText: packageName,
+		favicon: configOptions.favicon
+	});
+	const css = `${fontResolution.css}${themeToCssVariables(theme, fontResolution.themeFonts, configOptions.link, configOptions.navigation)}\n${backgroundResolution.css}${logoResolution.css}${baseCss}`;
+	const assets = [
+		...fontResolution.assets,
+		...backgroundResolution.assets,
+		...logoResolution.assets
+	];
+	const mermaid = await createMermaidRenderer({ themeConfig: themeToMermaidConfig(theme, fontResolution.themeFonts) });
+	await rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(path.join(outDir, "assets"), { recursive: true });
+	try {
+		const renderedPages = await Promise.all(model.pages.map((page) => renderMarkdownPage(model, page, outDir, {
+			mermaid,
+			shikiTheme: {
+				light: theme.light.shiki?.theme,
+				dark: theme.dark?.shiki?.theme
+			}
+		})));
+		for (const [index, rendered] of renderedPages.entries()) {
+			const page = model.pages[index];
+			if (!page) continue;
+			page.html = rendered.html;
+			page.searchText = rendered.text;
+			assets.push(...rendered.assets);
+		}
+		const searchIndexJson = JSON.stringify(buildSearchIndex(model.pages), null, 2);
+		const pageNavigation = buildPageNavigation(model.pages);
+		await Promise.all(model.pages.map(async (page) => {
+			const html = renderPage(page, buildNavigation(model, page), pageNavigation.get(page.route), css, searchIndexJson, logoResolution.logo, logoResolution.favicon, repositoryUrl, projectName, configOptions.navigation, options.dev);
+			const outputPath = path.join(outDir, page.outputPath);
+			await mkdir(path.dirname(outputPath), { recursive: true });
+			await writeFile(outputPath, html);
+		}));
+		await writeFile(path.join(outDir, "assets", "lildocs.css"), css);
+		await writeFile(path.join(outDir, "assets", "search.js"), searchScript);
+		await writeFile(path.join(outDir, "assets", "copy-code.js"), copyCodeScript);
+		await writeFile(path.join(outDir, "assets", "swup.umd.js"), swupScript);
+		await writeFile(path.join(outDir, "assets", "navigation.js"), navigationScript);
+		await writeFile(path.join(outDir, "assets", "github-icon.svg"), githubIcon);
+		await writeFile(path.join(outDir, "search-index.json"), searchIndexJson);
+		await copyAssets(assets);
+	} finally {
+		await mermaid.close();
+	}
+	return {
+		outDir,
+		pages: model.pages
+	};
+}
+async function resolveRepositoryUrl(packagePath) {
+	const envRepository = process.env.GITHUB_REPOSITORY?.trim();
+	if (envRepository) return `https://github.com/${envRepository}`;
+	if (!packagePath) return;
+	return normalizePackageRepository(JSON.parse(await readFile(packagePath, "utf8")).repository);
+}
+async function resolvePackageName(packagePath) {
+	if (!packagePath) return;
+	const packageJson = JSON.parse(await readFile(packagePath, "utf8"));
+	return typeof packageJson.name === "string" && packageJson.name.trim() ? packageJson.name.trim() : void 0;
+}
+async function findNearestPackageJson(start, stop) {
+	let current = path.resolve(start);
+	const root = path.parse(current).root;
+	const stopDir = path.resolve(stop);
+	while (true) {
+		const packagePath = path.join(current, "package.json");
+		if (existsSync(packagePath)) return packagePath;
+		if (current === stopDir || current === root) return;
+		current = path.dirname(current);
+	}
+}
+function normalizePackageRepository(repository) {
+	if (typeof repository === "string") return normalizeGitHubRepository(repository);
+	if (repository && typeof repository === "object" && "url" in repository) {
+		const { url } = repository;
+		if (typeof url === "string") return normalizeGitHubRepository(url);
+	}
+}
+function normalizeGitHubRepository(value) {
+	const repository = value.trim();
+	if (!repository) return;
+	const shorthandMatch = /^(?:github:)?([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)$/.exec(repository);
+	if (shorthandMatch?.[1]) return `https://github.com/${shorthandMatch[1].replace(/\.git$/, "")}`;
+	const sshMatch = /^git@github\.com:([^/]+\/[^/]+?)(?:\.git)?$/.exec(repository);
+	if (sshMatch?.[1]) return `https://github.com/${sshMatch[1]}`;
+	const urlMatch = /^(?:git\+)?https:\/\/github\.com\/([^/]+\/[^/#?]+?)(?:\.git)?(?:[#?].*)?$/.exec(repository);
+	if (urlMatch?.[1]) return `https://github.com/${urlMatch[1]}`;
+}
+async function readRenderAsset(name) {
+	const bundledPath = path.resolve(sourceDir, "render", name);
+	try {
+		return await readFile(bundledPath, "utf8");
+	} catch {
+		return readFile(path.resolve(sourceDir, "../render", name), "utf8");
+	}
+}
+async function readSwupAsset() {
+	return readFile(path.join(path.dirname(require.resolve("swup")), "Swup.umd.js"), "utf8");
+}
+function buildPageNavigation(pages) {
+	const navigation = /* @__PURE__ */ new Map();
+	if (pages.length < 2) return navigation;
+	for (const [index, page] of pages.entries()) {
+		const previous = pages[index - 1];
+		const next = pages[index + 1];
+		navigation.set(page.route, {
+			previous: previous ? {
+				title: previous.title,
+				href: relativeUrl(page.route, previous.route)
+			} : void 0,
+			next: next ? {
+				title: next.title,
+				href: relativeUrl(page.route, next.route)
+			} : void 0
+		});
+	}
+	return navigation;
+}
+//#endregion
+//#region src/core/server.ts
+const MIME_TYPES = new Map([
+	[".html", "text/html; charset=utf-8"],
+	[".css", "text/css; charset=utf-8"],
+	[".js", "text/javascript; charset=utf-8"],
+	[".json", "application/json; charset=utf-8"],
+	[".svg", "image/svg+xml"],
+	[".png", "image/png"],
+	[".jpg", "image/jpeg"],
+	[".jpeg", "image/jpeg"],
+	[".gif", "image/gif"],
+	[".webp", "image/webp"],
+	[".avif", "image/avif"],
+	[".ico", "image/x-icon"],
+	[".txt", "text/plain; charset=utf-8"],
+	[".woff", "font/woff"],
+	[".woff2", "font/woff2"],
+	[".ttf", "font/ttf"],
+	[".otf", "font/otf"],
+	[".eot", "application/vnd.ms-fontobject"]
+]);
+async function serveStaticFile(req, res, outDir) {
+	if (req.method !== "GET" && req.method !== "HEAD") {
+		res.writeHead(405, { allow: "GET, HEAD" });
+		res.end("Method Not Allowed");
+		return;
+	}
+	const pathname = requestPathname$1(req);
+	if (!pathname) {
+		res.writeHead(400);
+		res.end("Bad Request");
+		return;
+	}
+	const relativePath = pathname === "/" ? "index.html" : pathname.slice(1);
+	const filePath = path.resolve(outDir, relativePath);
+	if (!isInside$1(outDir, filePath)) {
+		res.writeHead(404);
+		res.end("Not Found");
+		return;
+	}
+	let fileStat;
+	try {
+		fileStat = await stat(filePath);
+	} catch {
+		res.writeHead(404);
+		res.end("Not Found");
+		return;
+	}
+	if (!fileStat.isFile()) {
+		res.writeHead(404);
+		res.end("Not Found");
+		return;
+	}
+	res.writeHead(200, {
+		"content-length": fileStat.size,
+		"content-type": MIME_TYPES.get(path.extname(filePath).toLowerCase()) ?? "application/octet-stream"
+	});
+	if (req.method === "HEAD") {
+		res.end();
+		return;
+	}
+	createReadStream(filePath).pipe(res);
+}
+function requestPathname$1(req) {
+	try {
+		return decodeURIComponent(new URL(req.url ?? "/", "http://lildocs.local").pathname);
+	} catch {
+		return;
+	}
+}
+function isInside$1(root, candidate) {
+	const relative = path.relative(root, candidate);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+//#endregion
+//#region src/core/dev.ts
+const DEV_CLIENT_PATH = "/__lildocs/client.js";
+const DEV_EVENTS_PATH = "/__lildocs/events";
+const DEV_CLIENT_SCRIPT = `
+const events = new EventSource("${DEV_EVENTS_PATH}");
+events.addEventListener("reload", () => location.reload());
+events.onerror = () => console.debug("[lildocs] live reload disconnected");
+`;
+async function startDevServer(options) {
+	const input = await resolveInput(options.input, options.cwd, { homePagePreference: "readme-first" });
+	const outDir = path.resolve(options.cwd, options.outDir);
+	validateDevOutDir(options.cwd, input.docsRoot, outDir, options.outDir);
+	const clients = /* @__PURE__ */ new Set();
+	let watchers = [];
+	let rebuildTimer;
+	let rebuilding = false;
+	let pending = false;
+	let lastSuccessfulBuild;
+	async function rebuild(emitReload, throwOnFailure = false) {
+		if (rebuilding) {
+			pending = true;
+			return;
+		}
+		rebuilding = true;
+		const started = performance.now();
+		try {
+			lastSuccessfulBuild = await buildSite({
+				input: options.input,
+				outDir,
+				cwd: options.cwd,
+				theme: options.theme,
+				fonts: options.fonts,
+				background: options.background,
+				link: options.link,
+				homePagePreference: "readme-first",
+				dev: { clientScriptPath: DEV_CLIENT_PATH }
+			});
+			await refreshWatchers();
+			const elapsed = Math.round(performance.now() - started);
+			console.log(`Rebuilt ${lastSuccessfulBuild.pages.length} page${lastSuccessfulBuild.pages.length === 1 ? "" : "s"} in ${elapsed}ms`);
+			if (emitReload) sendReload(clients);
+		} catch (error) {
+			if (throwOnFailure) throw error;
+			const message = error instanceof Error ? error.message : String(error);
+			console.error(`lildocs: rebuild failed: ${message}`);
+		} finally {
+			rebuilding = false;
+			if (pending) {
+				pending = false;
+				await rebuild(true);
+			}
+		}
+	}
+	function scheduleRebuild() {
+		if (rebuildTimer) clearTimeout(rebuildTimer);
+		rebuildTimer = setTimeout(() => {
+			rebuild(true);
+		}, 150);
+	}
+	async function refreshWatchers() {
+		for (const watcher of watchers) watcher.close();
+		watchers = [];
+		const directories = await collectWatchDirectories(input.docsRoot, outDir);
+		for (const directory of directories) watchers.push(watch(directory, { persistent: true }, (_event, filename) => {
+			if (filename && shouldIgnore(path.join(directory, filename.toString()), input.docsRoot, outDir)) return;
+			scheduleRebuild();
+		}));
+	}
+	await rebuild(false, true);
+	const server = http.createServer((req, res) => {
+		const pathname = requestPathname(req.url);
+		if (pathname === DEV_CLIENT_PATH) {
+			res.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
+			res.end(DEV_CLIENT_SCRIPT);
+			return;
+		}
+		if (pathname === DEV_EVENTS_PATH) {
+			connectEvents(res, clients);
+			return;
+		}
+		serveStaticFile(req, res, outDir);
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(options.port, options.host, () => {
+			server.off("error", reject);
+			resolve();
+		});
+	});
+	const address = server.address();
+	const actualPort = typeof address === "object" && address ? address.port : options.port;
+	const url = `http://${options.host}:${actualPort}/`;
+	console.log(`lildocs dev server listening at ${url}`);
+	return {
+		url,
+		close: async () => {
+			if (rebuildTimer) clearTimeout(rebuildTimer);
+			for (const watcher of watchers) watcher.close();
+			for (const client of clients) client.end();
+			await new Promise((resolve, reject) => {
+				server.close((error) => error ? reject(error) : resolve());
+			});
+		}
+	};
+}
+function validateDevOutDir(cwd, docsRoot, outDir, requestedOutDir) {
+	const root = path.resolve(cwd);
+	if (!path.isAbsolute(requestedOutDir) && !isInside(root, outDir)) throw new LildocsError("Relative dev output directory must stay inside the current workspace.");
+	if (outDir === root) throw new LildocsError("Dev output directory cannot be the repository root.");
+	if (outDir === docsRoot) throw new LildocsError("Dev output directory cannot be the docs root.");
+	if (isAncestor(outDir, docsRoot)) throw new LildocsError("Dev output directory cannot contain the docs root.");
+}
+async function collectWatchDirectories(docsRoot, outDir) {
+	const directories = /* @__PURE__ */ new Set();
+	async function walk(directory) {
+		if (shouldIgnore(directory, docsRoot, outDir)) return;
+		directories.add(directory);
+		const entries = await readdir(directory, { withFileTypes: true });
+		await Promise.all(entries.map(async (entry) => {
+			if (!entry.isDirectory()) return;
+			await walk(path.join(directory, entry.name));
+		}));
+	}
+	await walk(docsRoot);
+	return [...directories];
+}
+function shouldIgnore(candidate, docsRoot, outDir) {
+	const resolved = path.resolve(candidate);
+	if (resolved === outDir || isAncestor(outDir, resolved)) return true;
+	const relative = path.relative(docsRoot, resolved);
+	return relative === "dist" || relative.startsWith(`dist${path.sep}`) || relative === "node_modules" || relative.startsWith(`node_modules${path.sep}`) || isHiddenOrSystemPath(relative);
+}
+function connectEvents(res, clients) {
+	res.writeHead(200, {
+		"cache-control": "no-cache",
+		connection: "keep-alive",
+		"content-type": "text/event-stream"
+	});
+	res.write(": connected\n\n");
+	clients.add(res);
+	res.on("close", () => clients.delete(res));
+}
+function sendReload(clients) {
+	for (const client of clients) client.write("event: reload\ndata: {}\n\n");
+}
+function requestPathname(url) {
+	try {
+		return new URL(url ?? "/", "http://lildocs.local").pathname;
+	} catch {
+		return;
+	}
+}
+function isAncestor(parent, child) {
+	const relative = path.relative(parent, child);
+	return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function isInside(parent, child) {
+	const relative = path.relative(parent, child);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+//#endregion
+//#region src/core/deploy.ts
+async function deployGitHubPages(options) {
+	const basePath = normalizeBasePath(options.basePath);
+	const result = await buildSite({
+		...options,
+		basePath
+	});
+	await writeFile(path.join(result.outDir, ".nojekyll"), "");
+	await writeFile(path.join(result.outDir, "lildocs-deploy.json"), `${JSON.stringify({
+		target: "github-pages",
+		basePath,
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2)}\n`);
+	return {
+		...result,
+		basePath
+	};
+}
+async function initGitHubPagesWorkflow(options) {
+	const workflow = await prepareWorkflow(options);
+	await mkdir(path.dirname(workflow.path), { recursive: true });
+	await writeFile(workflow.path, workflow.contents);
+	return workflow.path;
+}
+async function prepareWorkflow(options) {
+	const workflowPath = path.join(options.cwd, ".github", "workflows", "lildocs-pages.yml");
+	if (await pathExists(workflowPath)) throw new Error(`Refusing to overwrite existing workflow at ${workflowPath}.`);
+	return {
+		path: workflowPath,
+		contents: renderGitHubPagesWorkflow({
+			input: repoRelativeInputPath(options.input, options.cwd),
+			outDir: path.relative(options.cwd, path.resolve(options.cwd, options.outDir)) || ".",
+			basePath: options.basePath
+		})
+	};
+}
+async function pathExists(filePath) {
+	try {
+		await access(filePath);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+//#endregion
+//#region src/cli.ts
+const outOption = option({
+	type: optional(string),
+	long: "out",
+	description: "Output directory for the generated site."
+});
+const themeOption = option({
+	type: optional(string),
+	long: "theme",
+	description: "Built-in lildocs theme or bundled Shiki theme name to use."
+});
+const fontHeadingOption = option({
+	type: optional(string),
+	long: "font.heading",
+	description: "Heading font name from Google Fonts or local font file path."
+});
+const fontBodyOption = option({
+	type: optional(string),
+	long: "font.body",
+	description: "Body font name from Google Fonts or local font file path."
+});
+const fontCodeOption = option({
+	type: optional(string),
+	long: "font.code",
+	description: "Code font name from Google Fonts or local font file path."
+});
+const backgroundImageOption = option({
+	type: optional(string),
+	long: "background.image",
+	description: "Background image URL or docs-relative image path."
+});
+const backgroundGradientOption = option({
+	type: optional(string),
+	long: "background.gradient",
+	description: "CSS background gradient, such as linear-gradient(...)."
+});
+const backgroundBlendModeOption = option({
+	type: optional(string),
+	long: "background.blendMode",
+	description: "CSS background-blend-mode for the theme color and background layers."
+});
+const linkUnderlineOption = option({
+	type: optional(string),
+	long: "link.underline",
+	description: "Link underline behavior: always, hover, or none."
+});
+const hostOption = option({
+	type: optional(string),
+	long: "host",
+	description: "Host address for the local development server."
+});
+const portOption = option({
+	type: optional(string),
+	long: "port",
+	description: "Port for the local development server."
+});
+const openOption = flag({
+	long: "open",
+	description: "Open the local development server in the default browser."
+});
+const baseOption = option({
+	type: optional(string),
+	long: "base",
+	description: "GitHub Pages base path, such as /repo/ for project pages."
+});
+const inputArgument = positional({
+	type: string,
+	displayName: "path",
+	description: "Markdown file or docs folder to build."
+});
+async function runBuild(options) {
+	const result = await buildSite({
+		input: options.input,
+		outDir: options.out ?? "dist",
+		theme: options.theme,
+		fonts: {
+			heading: options.fontHeading,
+			body: options.fontBody,
+			code: options.fontCode
+		},
+		background: {
+			image: options.backgroundImage,
+			gradient: options.backgroundGradient,
+			blendMode: options.backgroundBlendMode
+		},
+		link: { underline: parseLinkUnderline(options.linkUnderline) },
+		cwd: process.cwd()
+	});
+	console.log(`Built ${result.pages.length} page${result.pages.length === 1 ? "" : "s"} to ${result.outDir}`);
+}
+async function runDeploy(options) {
+	const result = await deployGitHubPages({
+		input: options.input,
+		outDir: options.out ?? "dist",
+		theme: options.theme,
+		fonts: {
+			heading: options.fontHeading,
+			body: options.fontBody,
+			code: options.fontCode
+		},
+		background: {
+			image: options.backgroundImage,
+			gradient: options.backgroundGradient,
+			blendMode: options.backgroundBlendMode
+		},
+		link: { underline: parseLinkUnderline(options.linkUnderline) },
+		basePath: options.base,
+		cwd: process.cwd()
+	});
+	console.log(`Built GitHub Pages site to ${result.outDir}`);
+	console.log(`Upload ${result.outDir} with actions/upload-pages-artifact or run init github-pages.`);
+}
+async function runInitGitHubPages(options) {
+	const workflowPath = await initGitHubPagesWorkflow({
+		input: options.input,
+		outDir: options.out ?? "dist",
+		basePath: options.base,
+		cwd: process.cwd()
+	});
+	console.log(`Created GitHub Pages workflow at ${workflowPath}`);
+}
+const buildCommand = command({
+	name: "build",
+	description: "Build a static documentation site.",
+	args: {
+		input: inputArgument,
+		out: outOption,
+		theme: themeOption,
+		fontHeading: fontHeadingOption,
+		fontBody: fontBodyOption,
+		fontCode: fontCodeOption,
+		backgroundImage: backgroundImageOption,
+		backgroundGradient: backgroundGradientOption,
+		backgroundBlendMode: backgroundBlendModeOption,
+		linkUnderline: linkUnderlineOption
+	},
+	handler: runBuild
+});
+const devCommand = command({
+	name: "dev",
+	description: "Start a local documentation development server.",
+	args: {
+		input: inputArgument,
+		out: outOption,
+		theme: themeOption,
+		fontHeading: fontHeadingOption,
+		fontBody: fontBodyOption,
+		fontCode: fontCodeOption,
+		backgroundImage: backgroundImageOption,
+		backgroundGradient: backgroundGradientOption,
+		backgroundBlendMode: backgroundBlendModeOption,
+		linkUnderline: linkUnderlineOption,
+		host: hostOption,
+		port: portOption,
+		open: openOption
+	},
+	handler: async (options) => {
+		const port = parsePort(options.port ?? "3000");
+		const server = await startDevServer({
+			input: options.input,
+			outDir: options.out ?? ".lildocs",
+			theme: options.theme,
+			fonts: {
+				heading: options.fontHeading,
+				body: options.fontBody,
+				code: options.fontCode
+			},
+			background: {
+				image: options.backgroundImage,
+				gradient: options.backgroundGradient,
+				blendMode: options.backgroundBlendMode
+			},
+			link: { underline: parseLinkUnderline(options.linkUnderline) },
+			cwd: process.cwd(),
+			host: options.host ?? "127.0.0.1",
+			port
+		});
+		if (options.open) await openBrowser(server.url);
+		await new Promise(() => {});
+	}
+});
+function parsePort(value) {
+	const port = Number(value);
+	if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`Invalid port: ${value}`);
+	return port;
+}
+function parseLinkUnderline(value) {
+	if (value === void 0 || value === "always" || value === "hover" || value === "none") return value;
+	throw new Error(`Invalid link underline style: ${value}`);
+}
+async function openBrowser(url) {
+	const [opener, args] = browserOpenCommand(url);
+	try {
+		await new Promise((resolve, reject) => {
+			const child = spawn(opener, args, {
+				detached: true,
+				stdio: "ignore"
+			});
+			child.once("error", reject);
+			child.once("spawn", () => {
+				child.unref();
+				resolve();
+			});
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`lildocs: failed to open browser: ${message}`);
+	}
+}
+function browserOpenCommand(url) {
+	if (process.platform === "darwin") return ["open", [url]];
+	if (process.platform === "win32") return ["cmd", [
+		"/c",
+		"start",
+		"",
+		url
+	]];
+	return ["xdg-open", [url]];
+}
+const deployCommand = command({
+	name: "deploy",
+	description: "Build GitHub Pages-ready documentation output.",
+	args: {
+		input: inputArgument,
+		out: outOption,
+		theme: themeOption,
+		fontHeading: fontHeadingOption,
+		fontBody: fontBodyOption,
+		fontCode: fontCodeOption,
+		backgroundImage: backgroundImageOption,
+		backgroundGradient: backgroundGradientOption,
+		backgroundBlendMode: backgroundBlendModeOption,
+		linkUnderline: linkUnderlineOption,
+		base: baseOption
+	},
+	handler: runDeploy
+});
+const initCommand = subcommands({
+	name: "init",
+	description: "Initialize lildocs integration files.",
+	cmds: { "github-pages": command({
+		name: "github-pages",
+		description: "Create a GitHub Actions workflow for GitHub Pages deployment.",
+		args: {
+			input: inputArgument,
+			out: outOption,
+			base: baseOption
+		},
+		handler: runInitGitHubPages
+	}) }
+});
+const bareBuildCommand = command({
+	name: "lildocs",
+	description: "Build a static documentation site from Markdown files.",
+	args: {
+		input: inputArgument,
+		out: outOption,
+		theme: themeOption,
+		fontHeading: fontHeadingOption,
+		fontBody: fontBodyOption,
+		fontCode: fontCodeOption,
+		backgroundImage: backgroundImageOption,
+		backgroundGradient: backgroundGradientOption,
+		backgroundBlendMode: backgroundBlendModeOption,
+		linkUnderline: linkUnderlineOption
+	},
+	handler: runBuild
+});
+const app = subcommands({
+	name: "lildocs",
+	description: "Turn Markdown docs into a static searchable documentation site.",
+	cmds: {
+		build: buildCommand,
+		deploy: deployCommand,
+		dev: devCommand,
+		init: initCommand
+	}
+});
+function isKnownTopLevelArg(arg) {
+	return arg === void 0 || arg === "build" || arg === "deploy" || arg === "dev" || arg === "init" || arg === "--help" || arg === "-h";
+}
+async function main() {
+	const args = process.argv.slice(2);
+	await run(isKnownTopLevelArg(args[0]) ? app : bareBuildCommand, args);
+}
+try {
+	await main();
+} catch (error) {
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`lildocs: ${message}`);
+	process.exitCode = 1;
+}
+//#endregion
+export {};