mdzilla 0.0.0 → 0.0.2

package/dist/_chunks/exporter.mjs

@@ -0,0 +1,787 @@
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join } from "node:path";
+import { parseMeta, renderToText } from "md4x";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+//#region src/docs/manager.ts
+var DocsManager = class {
+	source;
+	tree = [];
+	flat = [];
+	_fileMap = /* @__PURE__ */ new Map();
+	_contentCache = /* @__PURE__ */ new Map();
+	constructor(source) {
+		this.source = source;
+	}
+	async load() {
+		const { tree, fileMap } = await this.source.load();
+		this.tree = tree;
+		this._fileMap = fileMap;
+		this.flat = flattenTree(this.tree, 0, this._fileMap);
+		this._contentCache.clear();
+	}
+	async reload() {
+		return this.load();
+	}
+	/** Get raw file content for a flat entry (cached). */
+	async getContent(entry) {
+		if (!entry.filePath || entry.entry.page === false) return void 0;
+		const cached = this._contentCache.get(entry.filePath);
+		if (cached !== void 0) return cached;
+		const raw = await this.source.readContent(entry.filePath);
+		this._contentCache.set(entry.filePath, raw);
+		return raw;
+	}
+	/** Invalidate cached content for a specific file path. */
+	invalidate(filePath) {
+		this._contentCache.delete(filePath);
+	}
+	/** Fuzzy filter flat entries by query string. */
+	filter(query) {
+		return fuzzyFilter(this.flat, query, ({ entry }) => [entry.title, entry.path]);
+	}
+	/** Flat entries that are navigable pages (excludes directory stubs). */
+	get pages() {
+		return this.flat.filter((f) => f.entry.page !== false);
+	}
+	/** Find a flat entry by path (exact or with trailing slash). */
+	findByPath(path) {
+		return this.flat.find((f) => f.entry.page !== false && (f.entry.path === path || f.entry.path === path + "/"));
+	}
+	/**
+	* Resolve a page path to its content, trying:
+	* 1. Exact match in the navigation tree
+	* 2. Stripped common prefix (e.g., /docs/guide/... → /guide/...)
+	* 3. Direct source fetch (for HTTP sources with uncrawled paths)
+	*/
+	async resolvePage(path) {
+		const normalized = path.startsWith("/") ? path : "/" + path;
+		const entry = this.findByPath(normalized);
+		if (entry) {
+			const raw = await this.getContent(entry);
+			if (raw) return {
+				entry,
+				raw
+			};
+		}
+		const prefixed = normalized.match(/^\/[^/]+(\/.+)$/);
+		if (prefixed) {
+			const stripped = this.findByPath(prefixed[1]);
+			if (stripped) {
+				const raw = await this.getContent(stripped);
+				if (raw) return {
+					entry: stripped,
+					raw
+				};
+			}
+		}
+		const raw = await this.source.readContent(normalized).catch(() => void 0);
+		if (raw) return { raw };
+		return {};
+	}
+	/** Return indices of matching flat entries (case-insensitive substring). */
+	matchIndices(query) {
+		if (!query) return [];
+		const lower = query.toLowerCase();
+		const matched = /* @__PURE__ */ new Set();
+		for (let i = 0; i < this.flat.length; i++) {
+			const { entry } = this.flat[i];
+			if (entry.title.toLowerCase().includes(lower) || entry.path.toLowerCase().includes(lower)) {
+				matched.add(i);
+				const parentDepth = this.flat[i].depth;
+				for (let j = i + 1; j < this.flat.length; j++) {
+					if (this.flat[j].depth <= parentDepth) break;
+					matched.add(j);
+				}
+			}
+		}
+		return [...matched].sort((a, b) => a - b);
+	}
+};
+function flattenTree(entries, depth, fileMap) {
+	const result = [];
+	for (const entry of entries) {
+		result.push({
+			entry,
+			depth,
+			filePath: fileMap.get(entry.path)
+		});
+		if (entry.children) result.push(...flattenTree(entry.children, depth + 1, fileMap));
+	}
+	return result;
+}
+/**
+* Fuzzy match: checks if all characters of `query` appear in `target` in order.
+* Returns a score (lower is better) or -1 if no match.
+*/
+function fuzzyMatch(query, target) {
+	const q = query.toLowerCase();
+	const t = target.toLowerCase();
+	if (q.length === 0) return 0;
+	if (q.length > t.length) return -1;
+	let score = 0;
+	let qi = 0;
+	let prevMatchIdx = -1;
+	for (let ti = 0; ti < t.length && qi < q.length; ti++) if (t[ti] === q[qi]) {
+		if (prevMatchIdx === ti - 1) score -= 5;
+		if (ti === 0 || "/\\-_. ".includes(t[ti - 1])) score -= 10;
+		if (prevMatchIdx >= 0) score += ti - prevMatchIdx - 1;
+		prevMatchIdx = ti;
+		qi++;
+	}
+	if (qi < q.length) return -1;
+	score += t.length * .1;
+	return score;
+}
+/**
+* Fuzzy filter + sort a list of items.
+* Returns items that match, sorted by best score (lowest first).
+*/
+function fuzzyFilter(items, query, getText) {
+	if (!query) return items;
+	const scored = [];
+	for (const item of items) {
+		let best = Infinity;
+		for (const text of getText(item)) {
+			const s = fuzzyMatch(query, text);
+			if (s >= 0 && s < best) best = s;
+		}
+		if (best < Infinity) scored.push({
+			item,
+			score: best
+		});
+	}
+	scored.sort((a, b) => a.score - b.score);
+	return scored.map((s) => s.item);
+}
+//#endregion
+//#region src/docs/sources/_base.ts
+var DocsSource = class {};
+//#endregion
+//#region src/docs/nav.ts
+/**
+* Parse a numbered filename/dirname like "1.guide" or "3.middleware.md"
+* into { order, slug }. Also strips `.draft` suffix.
+*/
+function parseNumberedName(name) {
+	let base = name.endsWith(".md") ? name.slice(0, -3) : name;
+	const draft = base.endsWith(".draft");
+	if (draft) base = base.slice(0, -6);
+	const match = base.match(/^(\d+)\.(.+)$/);
+	if (match) return {
+		order: Number(match[1]),
+		slug: match[2],
+		draft
+	};
+	return {
+		order: Infinity,
+		slug: base,
+		draft
+	};
+}
+/**
+* Convert a slug like "getting-started" to "Getting Started".
+*/
+function humanizeSlug(slug) {
+	return slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+/**
+* Read and parse a .navigation.yml file as simple key: value pairs.
+*/
+async function readNavigation(dirPath) {
+	try {
+		const { headings: _headings, ...rest } = parseMeta(`---\n${await readFile(join(dirPath, ".navigation.yml"), "utf8")}\n---\n`);
+		return rest;
+	} catch {
+		return {};
+	}
+}
+const _knownKeys = new Set([
+	"slug",
+	"path",
+	"title",
+	"order",
+	"icon",
+	"description",
+	"page",
+	"children",
+	"headings"
+]);
+/**
+* Extract navigation overrides from frontmatter `navigation` field.
+* Returns merged meta with navigation fields taking priority.
+*/
+function applyNavigationOverride(meta) {
+	const nav = meta.navigation;
+	if (nav === false) return {
+		...meta,
+		navigation: false
+	};
+	if (typeof nav === "object" && nav !== null) {
+		const { navigation: _nav, ...rest } = meta;
+		return {
+			...rest,
+			...nav
+		};
+	}
+	return meta;
+}
+/**
+* Extract extra meta fields (non-known keys) from a record.
+*/
+function extraMeta(record) {
+	const extra = {};
+	let hasExtra = false;
+	for (const [key, value] of Object.entries(record)) if (!_knownKeys.has(key) && key !== "navigation") {
+		extra[key] = value;
+		hasExtra = true;
+	}
+	return hasExtra ? extra : void 0;
+}
+/**
+* Scan a docs directory and build a navigation tree
+* using md4x parseMeta for extracting markdown metadata.
+*/
+async function scanNav(dirPath, options) {
+	return _scanNav(dirPath, "/", options || {});
+}
+async function _scanNav(dirPath, parentPath, options) {
+	const dirEntries = await readdir(dirPath);
+	const entries = [];
+	for (const entry of dirEntries) {
+		if (entry.startsWith(".") || entry.startsWith("_") || entry === "package.json" || entry === "pnpm-lock.yaml" || entry === "pnpm-workspace.yaml") continue;
+		const fullPath = join(dirPath, entry);
+		let stats;
+		try {
+			stats = await stat(fullPath);
+		} catch {
+			continue;
+		}
+		if (stats.isDirectory()) {
+			const { order, slug } = parseNumberedName(entry);
+			const nav = await readNavigation(fullPath);
+			if (nav.navigation === false) continue;
+			const children = await _scanNav(fullPath, parentPath === "/" ? `/${slug}` : `${parentPath}/${slug}`, options);
+			const hasIndex = children.some((c) => c.slug === "");
+			const navEntry = {
+				slug,
+				path: parentPath === "/" ? `/${slug}` : `${parentPath}/${slug}`,
+				title: nav.title || humanizeSlug(slug),
+				order,
+				...nav.icon ? { icon: nav.icon } : {},
+				...nav.description ? { description: nav.description } : {},
+				...!hasIndex ? { page: false } : {},
+				...children.length > 0 ? { children } : {}
+			};
+			entries.push(navEntry);
+		} else if (extname(entry) === ".md") {
+			const { order, slug, draft } = parseNumberedName(basename(entry));
+			if (draft && !options.drafts) continue;
+			const meta = applyNavigationOverride(parseMeta(await readFile(fullPath, "utf8")));
+			if (meta.navigation === false) continue;
+			const resolvedSlug = slug === "index" ? "" : slug;
+			const title = meta.title || humanizeSlug(slug) || "index";
+			const entryPath = resolvedSlug === "" ? parentPath === "/" ? "/" : parentPath : parentPath === "/" ? `/${resolvedSlug}` : `${parentPath}/${resolvedSlug}`;
+			const extra = extraMeta(meta);
+			const navEntry = {
+				slug: resolvedSlug,
+				path: entryPath,
+				title,
+				order,
+				...meta.icon ? { icon: meta.icon } : {},
+				...meta.description ? { description: meta.description } : {},
+				...draft ? { draft: true } : {},
+				...extra
+			};
+			entries.push(navEntry);
+		}
+	}
+	entries.sort((a, b) => a.order - b.order || a.slug.localeCompare(b.slug));
+	return entries;
+}
+//#endregion
+//#region src/docs/sources/fs.ts
+var DocsSourceFS = class extends DocsSource {
+	dir;
+	constructor(dir) {
+		super();
+		this.dir = dir;
+	}
+	async load() {
+		return {
+			tree: await scanNav(this.dir),
+			fileMap: await buildFileMap("/", this.dir)
+		};
+	}
+	async readContent(filePath) {
+		return readFile(filePath, "utf8");
+	}
+};
+function parseSlug(name) {
+	const base = name.endsWith(".draft") ? name.slice(0, -6) : name;
+	const match = base.match(/^(\d+)\.(.+)$/);
+	return match ? match[2] : base;
+}
+async function buildFileMap(parentPath, dirPath) {
+	const map = /* @__PURE__ */ new Map();
+	const entries = await readdir(dirPath, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.name.startsWith(".") || entry.name.startsWith("_")) continue;
+		const fullPath = join(dirPath, entry.name);
+		if (entry.isDirectory()) {
+			const slug = parseSlug(entry.name);
+			const childMap = await buildFileMap(parentPath === "/" ? `/${slug}` : `${parentPath}/${slug}`, fullPath);
+			for (const [k, v] of childMap) map.set(k, v);
+		} else if (extname(entry.name) === ".md") {
+			const slug = parseSlug(entry.name.replace(/\.md$/, ""));
+			const resolvedSlug = slug === "index" ? "" : slug;
+			const entryPath = resolvedSlug === "" ? parentPath === "/" ? "/" : parentPath : parentPath === "/" ? `/${resolvedSlug}` : `${parentPath}/${resolvedSlug}`;
+			map.set(entryPath, fullPath);
+		}
+	}
+	return map;
+}
+//#endregion
+//#region src/docs/sources/git.ts
+var DocsSourceGit = class extends DocsSource {
+	src;
+	options;
+	_fs;
+	constructor(src, options = {}) {
+		super();
+		this.src = src;
+		this.options = options;
+	}
+	async load() {
+		const source = this.options.subdir ? `${this.src}/${this.options.subdir}` : this.src;
+		const id = source.replace(/[/#:]/g, "_");
+		const dir = join(tmpdir(), "mdzilla", "gh", id);
+		const { downloadTemplate } = await import("giget");
+		await downloadTemplate(source, {
+			dir,
+			auth: this.options.auth,
+			force: true,
+			install: false
+		});
+		let docsDir = dir;
+		for (const sub of ["docs/content", "docs"]) {
+			const candidate = join(dir, sub);
+			if (existsSync(candidate)) {
+				docsDir = candidate;
+				break;
+			}
+		}
+		this._fs = new DocsSourceFS(docsDir);
+		return this._fs.load();
+	}
+	async readContent(filePath) {
+		if (!this._fs) throw new Error("DocsSourceGit: call load() before readContent()");
+		return this._fs.readContent(filePath);
+	}
+};
+//#endregion
+//#region src/docs/sources/_npm.ts
+/**
+* Parse an npm package spec: `[@scope/]name[@version][/subdir]`
+*/
+function parseNpmSpec(input) {
+	let rest = input;
+	let subdir = "";
+	if (rest.startsWith("@")) {
+		const secondSlash = rest.indexOf("/", rest.indexOf("/") + 1);
+		if (secondSlash > 0) {
+			subdir = rest.slice(secondSlash);
+			rest = rest.slice(0, secondSlash);
+		}
+	} else {
+		const firstSlash = rest.indexOf("/");
+		if (firstSlash > 0) {
+			subdir = rest.slice(firstSlash);
+			rest = rest.slice(0, firstSlash);
+		}
+	}
+	const versionSep = rest.startsWith("@") ? rest.indexOf("@", 1) : rest.indexOf("@");
+	const hasVersion = versionSep > 0;
+	return {
+		name: hasVersion ? rest.slice(0, versionSep) : rest,
+		version: hasVersion ? rest.slice(versionSep + 1) : "latest",
+		subdir
+	};
+}
+/**
+* Fetch package metadata from the npm registry.
+* When `version` is provided, fetches that specific version.
+* Otherwise fetches the full package document.
+*/
+async function fetchNpmInfo(name, version) {
+	const registryURL = version ? `https://registry.npmjs.org/${name}/${version}` : `https://registry.npmjs.org/${name}`;
+	const res = await fetch(registryURL);
+	if (!res.ok) throw new Error(`Failed to fetch package info for ${name}${version ? `@${version}` : ""}: ${res.status} ${res.statusText}`);
+	return res.json();
+}
+/**
+* Detect npmjs.com URLs and extract the package name.
+* Supports: npmjs.com/\<pkg\>, npmjs.com/package/\<pkg\>, www.npmjs.com/package/\<pkg\>
+* Also handles scoped packages: npmjs.com/package/@scope/name
+*/
+function parseNpmURL(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		return;
+	}
+	if (parsed.hostname !== "www.npmjs.com" && parsed.hostname !== "npmjs.com") return;
+	const pkgMatch = parsed.pathname.match(/^\/package\/((?:@[^/]+\/)?[^/]+)\/?$/);
+	if (pkgMatch) return pkgMatch[1];
+	const shortMatch = parsed.pathname.match(/^\/((?:@[^/]+\/)?[^/]+)\/?$/);
+	if (shortMatch && !/^(package|settings|signup|login|org|search)$/.test(shortMatch[1])) return shortMatch[1];
+}
+//#endregion
+//#region src/docs/sources/http.ts
+var DocsSourceHTTP = class extends DocsSource {
+	url;
+	options;
+	_contentCache = /* @__PURE__ */ new Map();
+	_tree = [];
+	_fileMap = /* @__PURE__ */ new Map();
+	_npmPackage;
+	constructor(url, options = {}) {
+		super();
+		this.url = url.replace(/\/+$/, "");
+		this._npmPackage = parseNpmURL(this.url);
+		this.options = options;
+	}
+	async load() {
+		if (this._npmPackage) return this._loadNpm(this._npmPackage);
+		const llmsTree = await this._tryLlmsTxt();
+		if (llmsTree) {
+			this._tree = llmsTree;
+			return {
+				tree: this._tree,
+				fileMap: this._fileMap
+			};
+		}
+		const markdown = await this._fetch(this.url);
+		this._contentCache.set("/", markdown);
+		const rootEntry = {
+			slug: "",
+			path: "/",
+			title: parseMeta(markdown).title || _titleFromURL(this.url),
+			order: 0
+		};
+		const { entries: children, tocPaths } = _extractLinks(markdown, this.url);
+		if (children.length > 0) {
+			rootEntry.children = children;
+			for (const child of children) this._fileMap.set(child.path, child.path);
+		}
+		this._tree = [rootEntry];
+		this._fileMap.set("/", "/");
+		if (tocPaths.size > 0) await this._crawlTocPages(children, tocPaths);
+		return {
+			tree: this._tree,
+			fileMap: this._fileMap
+		};
+	}
+	/** Try fetching /llms.txt and parse it into a nav tree */
+	async _tryLlmsTxt() {
+		let origin;
+		try {
+			origin = new URL(this.url).origin;
+		} catch {
+			return;
+		}
+		let text;
+		try {
+			const res = await fetch(`${origin}/llms.txt`, { headers: {
+				accept: "text/plain",
+				...this.options.headers
+			} });
+			if (!res.ok) return void 0;
+			text = await res.text();
+		} catch {
+			return;
+		}
+		if (!text.trimStart().startsWith("#")) return void 0;
+		return _parseLlmsTxt(text, origin, this._fileMap, this._contentCache);
+	}
+	async readContent(filePath) {
+		const cached = this._contentCache.get(filePath);
+		if (cached !== void 0) return cached;
+		const origin = new URL(this.url).origin;
+		const url = filePath === "/" ? this.url : `${origin}${filePath}`;
+		const markdown = await this._fetch(url);
+		this._contentCache.set(filePath, markdown);
+		return markdown;
+	}
+	/** Crawl index.md pages and attach their links as children */
+	async _crawlTocPages(entries, tocPaths, depth = 0) {
+		if (depth > 3) return;
+		const origin = new URL(this.url).origin;
+		await Promise.all(entries.map(async (entry) => {
+			if (!tocPaths.has(entry.path)) return;
+			const url = `${origin}${entry.path}`;
+			const markdown = await this._fetch(url);
+			this._contentCache.set(entry.path, markdown);
+			const { entries: children, tocPaths: subTocPaths } = _extractLinks(markdown, url);
+			if (children.length > 0) {
+				entry.children = children;
+				for (const child of children) this._fileMap.set(child.path, child.path);
+				if (subTocPaths.size > 0) await this._crawlTocPages(children, subTocPaths, depth + 1);
+			}
+		}));
+	}
+	/** Load an npm package README from the registry */
+	async _loadNpm(pkg) {
+		let markdown;
+		try {
+			const data = await fetchNpmInfo(pkg);
+			markdown = data.readme || `# ${data.name || pkg}\n\n${data.description || "No README available."}`;
+		} catch (err) {
+			markdown = `# Fetch Error\n\nFailed to fetch package \`${pkg}\`\n\n> ${err instanceof Error ? err.message : String(err)}`;
+		}
+		this._contentCache.set("/", markdown);
+		this._fileMap.set("/", "/");
+		this._tree = [{
+			slug: "",
+			path: "/",
+			title: parseMeta(markdown).title || pkg,
+			order: 0
+		}];
+		return {
+			tree: this._tree,
+			fileMap: this._fileMap
+		};
+	}
+	async _fetch(url) {
+		let res;
+		try {
+			res = await fetch(url, { headers: {
+				accept: "text/markdown, text/plain;q=0.9, text/html;q=0.8",
+				...this.options.headers
+			} });
+		} catch (err) {
+			return `# Fetch Error\n\nFailed to fetch \`${url}\`\n\n> ${err instanceof Error ? err.message : String(err)}`;
+		}
+		if (!res.ok) return `# ${res.status} ${res.statusText}\n\nFailed to fetch \`${url}\``;
+		const contentType = res.headers.get("content-type") || "";
+		const text = await res.text();
+		if (_isHTML(contentType, text)) {
+			const { htmlToMarkdown } = await import("mdream");
+			return htmlToMarkdown(text, { origin: url });
+		}
+		return text;
+	}
+};
+/** Check if a response is HTML by content-type or content sniffing */
+function _isHTML(contentType, body) {
+	if (contentType.includes("text/html") || contentType.includes("application/xhtml")) return true;
+	const trimmed = body.trimStart();
+	return trimmed.startsWith("<!") || trimmed.startsWith("<html");
+}
+/** Extract a readable title from a URL */
+function _titleFromURL(url) {
+	try {
+		return new URL(url).hostname;
+	} catch {
+		return url;
+	}
+}
+/**
+* Parse llms.txt content into a nav tree.
+* Format: `# Title`, `> Description`, `## Section`, `- [Title](url): description`
+*/
+function _parseLlmsTxt(text, origin, fileMap, contentCache) {
+	const lines = text.split("\n");
+	const tree = [];
+	let siteTitle = "";
+	let siteDescription = "";
+	let currentSection;
+	let order = 0;
+	let childOrder = 0;
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!siteTitle && trimmed.startsWith("# ") && !trimmed.startsWith("## ")) {
+			siteTitle = trimmed.slice(2).trim();
+			continue;
+		}
+		if (!siteDescription && trimmed.startsWith("> ")) {
+			siteDescription = trimmed.slice(2).trim();
+			continue;
+		}
+		if (trimmed.startsWith("## ")) {
+			currentSection = {
+				slug: _slugify(trimmed.slice(3).trim()),
+				path: `/_section/${order}`,
+				title: trimmed.slice(3).trim(),
+				order: order++,
+				page: false,
+				children: []
+			};
+			childOrder = 0;
+			tree.push(currentSection);
+			continue;
+		}
+		const linkMatch = trimmed.match(/^-\s*\[([^\]]+)]\(([^)]+)\)(?::\s*(.+))?$/);
+		if (linkMatch) {
+			const title = linkMatch[1];
+			const href = linkMatch[2];
+			const description = linkMatch[3]?.trim();
+			let resolved;
+			try {
+				resolved = new URL(href, origin);
+				if (resolved.origin !== origin) continue;
+			} catch {
+				continue;
+			}
+			const path = resolved.pathname.replace(/\/+$/, "") || "/";
+			const entry = {
+				slug: path.split("/").pop() || path,
+				path,
+				title,
+				order: childOrder++,
+				...description ? { description } : {}
+			};
+			fileMap.set(path, path);
+			if (currentSection) currentSection.children.push(entry);
+			else tree.push(entry);
+			continue;
+		}
+	}
+	if (tree.length === 0) return [];
+	const root = {
+		slug: "",
+		path: "/",
+		title: siteTitle || _titleFromURL(origin),
+		order: 0,
+		...siteDescription ? { description: siteDescription } : {},
+		...tree.length > 0 ? { children: tree } : {}
+	};
+	fileMap.set("/", "/");
+	contentCache.set("/", text);
+	return [root];
+}
+function _slugify(text) {
+	return text.toLowerCase().replace(/[^a-z\d]+/g, "-").replace(/^-|-$/g, "");
+}
+/** Extract internal links from markdown content to build nav children */
+function _extractLinks(markdown, baseURL) {
+	const seen = /* @__PURE__ */ new Set();
+	const entries = [];
+	const tocPaths = /* @__PURE__ */ new Set();
+	let order = 0;
+	const linkRe = /\[([^\]]+)]\(([^)]+)\)/g;
+	let match;
+	while ((match = linkRe.exec(markdown)) !== null) {
+		const title = match[1];
+		const href = match[2];
+		const resolved = _resolveHref(href, baseURL);
+		if (!resolved) continue;
+		let path = resolved.pathname.replace(/\/+$/, "") || "/";
+		const isToc = /\/index\.md$/i.test(path) || path.endsWith("/index");
+		path = path.replace(/\/index\.md$/i, "").replace(/\/index$/, "").replace(/\.md$/i, "");
+		path = path || "/";
+		if (path === "/") continue;
+		if (seen.has(path)) continue;
+		seen.add(path);
+		if (isToc) tocPaths.add(path);
+		const slug = path.split("/").pop() || path;
+		entries.push({
+			slug,
+			path,
+			title,
+			order: order++
+		});
+	}
+	return {
+		entries,
+		tocPaths
+	};
+}
+/** Resolve an href relative to a base URL, returning null for external links */
+function _resolveHref(href, baseURL) {
+	try {
+		const base = new URL(baseURL);
+		const resolved = new URL(href, baseURL);
+		if (resolved.origin !== base.origin) return void 0;
+		if (href.startsWith("#")) return void 0;
+		if (/\.(png|jpg|jpeg|gif|svg|css|js|ico|woff2?)$/i.test(resolved.pathname)) return void 0;
+		return resolved;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/docs/sources/npm.ts
+var DocsSourceNpm = class extends DocsSource {
+	src;
+	options;
+	_fs;
+	constructor(src, options = {}) {
+		super();
+		this.src = src;
+		this.options = options;
+	}
+	async load() {
+		const pkg = this.src.startsWith("npm:") ? this.src : `npm:${this.src}`;
+		const source = this.options.subdir ? `${pkg}/${this.options.subdir}` : pkg;
+		const id = source.replace(/[/#:@]/g, "_");
+		const dir = join(tmpdir(), "mdzilla", "npm", id);
+		const { downloadTemplate } = await import("giget");
+		await downloadTemplate(source, {
+			dir,
+			force: true,
+			install: false,
+			providers: { npm: npmProvider },
+			registry: false
+		});
+		let docsDir = dir;
+		for (const sub of ["docs/content", "docs"]) {
+			const candidate = join(dir, sub);
+			if (existsSync(candidate)) {
+				docsDir = candidate;
+				break;
+			}
+		}
+		this._fs = new DocsSourceFS(docsDir);
+		return this._fs.load();
+	}
+	async readContent(filePath) {
+		if (!this._fs) throw new Error("DocsSourceNpm: call load() before readContent()");
+		return this._fs.readContent(filePath);
+	}
+};
+async function npmProvider(input) {
+	const { name, version, subdir } = parseNpmSpec(input);
+	const info = await fetchNpmInfo(name, version);
+	return {
+		name: info.name,
+		version: info.version,
+		subdir,
+		tar: info.dist.tarball
+	};
+}
+//#endregion
+//#region src/docs/exporter.ts
+var DocsExporter = class {};
+var DocsExporterFS = class extends DocsExporter {
+	dir;
+	constructor(dir) {
+		super();
+		this.dir = dir;
+	}
+	async export(manager, options = {}) {
+		for (const flat of manager.flat) {
+			if (!options.includeStubs && flat.entry.page === false) continue;
+			let content = await manager.getContent(flat);
+			if (content === void 0) continue;
+			if (options.plainText) content = renderToText(content);
+			const filePath = flat.entry.path === "/" ? "/index.md" : `${flat.entry.path}.md`;
+			const dest = join(this.dir, filePath);
+			await mkdir(dirname(dest), { recursive: true });
+			await writeFile(dest, content, "utf8");
+		}
+	}
+};
+//#endregion
+export { DocsSourceGit as a, DocsManager as c, DocsSourceHTTP as i, DocsExporterFS as n, DocsSourceFS as o, DocsSourceNpm as r, DocsSource as s, DocsExporter as t };