@minidocs/astro 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,262 @@
+import { t as contentOptions } from "./routing-TMqRCY2Q.mjs";
+import { a as renderConfigTypes, i as registry, n as remarkContentLinks, r as satteriContentLinks } from "./links-UTLyoo_o.mjs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseFilePath } from "@minidocs/core";
+import remarkDirective from "remark-directive";
+//#region src/callouts.ts
+/** Callout types, shared by `:::type` directives, `> [!TYPE]` alerts and the `Callout` component. */
+const CALLOUT_TYPES = [
+	"note",
+	"tip",
+	"important",
+	"warning",
+	"caution"
+];
+const isType = (name) => CALLOUT_TYPES.includes(name);
+/** Same markup as the Callout component renders, as mdast data for the HTML conversion. */
+const calloutData = (type) => ({
+	hName: "div",
+	hProperties: {
+		className: ["md-callout"],
+		dataType: type,
+		role: "note"
+	}
+});
+const titleData = {
+	hName: "p",
+	hProperties: { className: ["md-callout-title"] }
+};
+const ALERT = /^\[!(\w+)\][ \t]*(?:\n|$)/;
+function unknownDirective(name) {
+	return /* @__PURE__ */ new Error(`[minidocs] Unknown callout type ":::${name}". Use one of ${CALLOUT_TYPES.join(", ")}, or handle it with your own plugin.`);
+}
+/** Reads the type of a `> [!TYPE]` alert and what is left of its first line, or `undefined` for plain blockquotes. */
+function parseAlert(blockquote) {
+	const paragraph = blockquote.children?.[0];
+	const text = paragraph?.type === "paragraph" ? paragraph.children?.[0] : void 0;
+	const match = text?.type === "text" ? ALERT.exec(text.value ?? "") : null;
+	const type = match?.[1]?.toLowerCase();
+	if (!match || !type || !isType(type)) return void 0;
+	const rest = text.value.slice(match[0].length);
+	return {
+		type,
+		paragraph,
+		text,
+		rest,
+		empty: !rest && paragraph.children.length === 1
+	};
+}
+/**
+* Turning on directives also parses `:name` in text and `::name` lines, which would silently drop `10:30` or `a:hover`.
+* Only `:::` blocks are callouts, so the others go back to their source text.
+*/
+function restoreSatteri(block) {
+	return (node, context) => {
+		const text = {
+			type: "text",
+			value: context.source.slice(node.position.start.offset, node.position.end.offset)
+		};
+		context.replaceNode(node, block ? {
+			type: "paragraph",
+			children: [text]
+		} : text);
+	};
+}
+/** Plugin for Sätteri, Astro's default Markdown processor. */
+function satteriCallouts(options) {
+	return {
+		name: "minidocs-callouts",
+		options: { position: true },
+		...options.directives && {
+			containerDirective(node, context) {
+				if (node.data?.hName) return;
+				const name = node.name ?? "";
+				if (!isType(name)) throw unknownDirective(name);
+				const label = node.children?.[0];
+				if (label?.type === "paragraph" && label.data?.directiveLabel) context.setProperty(label, "data", titleData);
+				context.setProperty(node, "data", calloutData(name));
+			},
+			leafDirective: restoreSatteri(true),
+			textDirective: restoreSatteri(false)
+		},
+		...options.alerts && { blockquote(node, context) {
+			const alert = parseAlert(node);
+			if (!alert) return;
+			if (alert.empty) context.removeNode(alert.paragraph);
+			else context.setProperty(alert.text, "value", alert.rest);
+			context.setProperty(node, "data", calloutData(alert.type));
+		} }
+	};
+}
+/** Remark plugin for the unified processor. Directive parsing comes from `remark-directive`, added before it. */
+function remarkCallouts(options) {
+	return () => (tree, file) => {
+		const source = String(file.value ?? "");
+		const visit = (node) => {
+			const children = node.children ?? [];
+			for (let index = 0; index < children.length; index++) {
+				const child = children[index];
+				if (options.directives && (child.type === "textDirective" || child.type === "leafDirective")) {
+					const text = {
+						type: "text",
+						value: source.slice(child.position?.start.offset, child.position?.end.offset)
+					};
+					children[index] = child.type === "leafDirective" ? {
+						type: "paragraph",
+						children: [text]
+					} : text;
+					continue;
+				}
+				if (options.directives && child.type === "containerDirective" && !child.data?.hName) {
+					const name = child.name ?? "";
+					if (!isType(name)) throw unknownDirective(name);
+					const label = child.children?.[0];
+					if (label?.type === "paragraph" && label.data?.directiveLabel) label.data = {
+						...label.data,
+						...titleData
+					};
+					child.data = {
+						...child.data,
+						...calloutData(name)
+					};
+				}
+				if (options.alerts && child.type === "blockquote") {
+					const alert = parseAlert(child);
+					if (alert) {
+						if (alert.empty) child.children.shift();
+						else alert.text.value = alert.rest;
+						child.data = {
+							...child.data,
+							...calloutData(alert.type)
+						};
+					}
+				}
+				visit(child);
+			}
+		};
+		visit(tree);
+	};
+}
+//#endregion
+//#region src/markdown.ts
+/**
+* Adds minidocs' Markdown features to the configured processor, which MDX uses too unless given its own.
+* Processors are meant to be extended in place. Returns `false` for processors minidocs does not know.
+*/
+function extendProcessor(processor, callouts) {
+	const options = processor.options;
+	if (processor.name === "satteri") {
+		if (callouts.directives) options.features = {
+			...options.features,
+			directive: true
+		};
+		options.mdastPlugins = [
+			...options.mdastPlugins ?? [],
+			satteriContentLinks,
+			satteriCallouts(callouts)
+		];
+		return true;
+	}
+	if (processor.name === "unified") {
+		options.remarkPlugins = [
+			...options.remarkPlugins ?? [],
+			...callouts.directives ? [remarkDirective] : [],
+			remarkContentLinks,
+			remarkCallouts(callouts)
+		];
+		return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/settings.ts
+const trim = (path) => path.replace(/^\/+|\/+$/g, "");
+function resolveSettings(config, options) {
+	return {
+		prefix: trim(options.prefix ?? ""),
+		base: trim(config.base),
+		trailingSlash: config.trailingSlash === "always" || config.trailingSlash === "ignore" && config.build.format === "directory",
+		i18n: resolveI18n(config.i18n, options),
+		site: config.site ? config.site.replace(/\/+$/, "") : null
+	};
+}
+function resolveI18n(i18n, options) {
+	if (!i18n) {
+		if (options.fallback) throw new Error("[minidocs] `fallback` requires `i18n` in your Astro config.");
+		return null;
+	}
+	if (i18n.fallback && Object.keys(i18n.fallback).length > 0) throw new Error("[minidocs] Astro's `i18n.fallback` works per route file and produces wrong pages for content-driven docs routes in static builds. Remove it and declare fallback with `minidocs({ fallback })` instead.");
+	if (i18n.routing === "manual") throw new Error("[minidocs] `i18n.routing: \"manual\"` is not supported yet.");
+	const locales = i18n.locales.map((locale) => {
+		if (typeof locale !== "string") throw new Error("[minidocs] Locales with custom paths are not supported yet. Use plain locale strings.");
+		return locale;
+	});
+	const fallback = options.fallback ?? {};
+	for (const [locale, targets] of Object.entries(fallback)) for (const target of [locale, ...[targets].flat()]) if (!locales.includes(target)) throw new Error(`[minidocs] Fallback refers to "${target}", which is not one of i18n.locales (${locales.join(", ")}).`);
+	return {
+		locales,
+		defaultLocale: i18n.defaultLocale,
+		prefixDefaultLocale: i18n.routing?.prefixDefaultLocale ?? false,
+		fallback
+	};
+}
+//#endregion
+//#region src/index.ts
+const CONFIG_ID = "virtual:minidocs/config";
+const RENDERERS_ID = "virtual:minidocs/renderers";
+function minidocs(options = {}) {
+	let hasMdx = false;
+	return {
+		name: "minidocs",
+		hooks: {
+			"astro:config:setup"({ config, updateConfig, logger }) {
+				const callouts = {
+					directives: options.markdown?.directives ?? true,
+					alerts: options.markdown?.alerts ?? true
+				};
+				if (!extendProcessor(config.markdown.processor, callouts)) logger.warn(`Content links and callouts are not supported with the "${config.markdown.processor.name}" Markdown processor.`);
+				updateConfig({ vite: {
+					plugins: [{
+						name: "minidocs:config",
+						resolveId: (id) => id === CONFIG_ID ? `\0${CONFIG_ID}` : void 0,
+						load: (id) => id === `\0${CONFIG_ID}` ? `export default ${JSON.stringify({
+							...registry.settings,
+							bases: Object.fromEntries(Object.entries(registry.collections).map(([name, { base }]) => [name, base])),
+							pageIds: Object.fromEntries(Object.entries(registry.collections).map(([name, collection]) => [name, pageIds(collection)]))
+						})};` : void 0
+					}, {
+						name: "minidocs:renderers",
+						resolveId: (id) => id === RENDERERS_ID ? `\0${RENDERERS_ID}` : void 0,
+						load: (id) => id === `\0${RENDERERS_ID}` ? hasMdx ? `import { getContainerRenderer } from '@astrojs/mdx';\nexport default [getContainerRenderer()];` : "export default [];" : void 0
+					}],
+					ssr: { noExternal: ["@minidocs/astro", "@minidocs/core"] }
+				} });
+			},
+			"astro:config:done"({ config, injectTypes }) {
+				registry.settings = resolveSettings(config, options);
+				registry.root = fileURLToPath(config.root);
+				hasMdx = config.integrations.some(({ name }) => name === "@astrojs/mdx");
+				const injected = injectTypes({
+					filename: "types.d.ts",
+					content: renderConfigTypes(registry.settings)
+				});
+				registry.typesFile = new URL("./collections.d.ts", injected);
+				const path = fileURLToPath(registry.typesFile);
+				if (!existsSync(path)) {
+					mkdirSync(dirname(path), { recursive: true });
+					writeFileSync(path, "export {};\n");
+				}
+			}
+		}
+	};
+}
+/** Ids of every page in a collection, in any locale. */
+function pageIds({ base, filePaths }) {
+	if (!registry.settings) return [];
+	const { locales, localeDirs } = contentOptions(registry.settings, base);
+	return [...new Set(filePaths.map((filePath) => parseFilePath(filePath, base, locales, localeDirs).id))];
+}
+//#endregion
+export { minidocs as default };

package/dist/links-UTLyoo_o.mjs

@@ -0,0 +1,177 @@
+import { n as href, t as contentOptions } from "./routing-TMqRCY2Q.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, posix, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { listPages, parseFilePath } from "@minidocs/core";
+//#region src/codegen.ts
+const union = (values) => {
+	const list = [...new Set(values)].sort().map((value) => JSON.stringify(value));
+	return list.length > 0 ? list.join(" | ") : "never";
+};
+/** Renders the site-wide types, known as soon as the config is resolved. */
+function renderConfigTypes(settings) {
+	return [
+		"// Generated by minidocs. Do not edit.",
+		"/// <reference path=\"./collections.d.ts\" />",
+		"declare module '@minidocs/astro/runtime' {",
+		`\tinterface Config { ${settings.i18n ? `i18n: true; locale: ${union(settings.i18n.locales)};` : "i18n: false;"} }`,
+		"}",
+		"export {};",
+		""
+	].join("\n");
+}
+/** Renders the declaration file that types page ids and directories per collection, and per locale for multilingual sites. */
+function renderTypes(settings, collections) {
+	const lines = [
+		"// Generated by minidocs. Do not edit.",
+		"declare module '@minidocs/astro/runtime' {",
+		"	interface Collections {"
+	];
+	for (const [name, { base, filePaths }] of Object.entries(collections).sort(([a], [b]) => a < b ? -1 : 1)) {
+		const options = contentOptions(settings, base);
+		const pages = listPages(filePaths.map((filePath) => ({ filePath })), options);
+		const idsAndDirs = (locale) => {
+			const inLocale = pages.filter((page) => page.locale === locale);
+			const dirs = /* @__PURE__ */ new Set([""]);
+			for (const page of inLocale) {
+				const { dir } = parseFilePath(page.entry.filePath, base, options.locales, options.localeDirs);
+				const segments = dir.split("/").filter(Boolean);
+				for (let i = 1; i <= segments.length; i++) dirs.add(segments.slice(0, i).join("/"));
+			}
+			return {
+				ids: union(inLocale.map((page) => page.id)),
+				dirs: union(dirs)
+			};
+		};
+		lines.push(`\t\t${JSON.stringify(name)}: {`);
+		if (settings.i18n) {
+			const perLocale = settings.i18n.locales.map((locale) => [JSON.stringify(locale), idsAndDirs(locale)]);
+			lines.push("			pages: {", ...perLocale.map(([locale, { ids }]) => `\t\t\t\t${locale}: ${ids};`), "			};");
+			lines.push("			dirs: {", ...perLocale.map(([locale, { dirs }]) => `\t\t\t\t${locale}: ${dirs};`), "			};");
+		} else {
+			const { ids, dirs } = idsAndDirs(options.locales[0]);
+			lines.push(`\t\t\tpages: ${ids};`, `\t\t\tdirs: ${dirs};`);
+		}
+		lines.push("		};");
+	}
+	lines.push("	}", "}", "export {};", "");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/registry.ts
+const key = Symbol.for("minidocs.registry");
+const scope = globalThis;
+scope[key] ??= { collections: {} };
+const registry = scope[key];
+//#endregion
+//#region src/links.ts
+/** Link to another page from a page in the same locale, relative so it stays in whatever locale the page is shown in. */
+function relativeHref(settings, fromId, toId, locale) {
+	const from = href(settings, fromId, locale);
+	const to = href(settings, toId, locale);
+	const fromDir = from.slice(0, from.lastIndexOf("/") + 1);
+	if (to.endsWith("/")) return `${posix.relative(fromDir, to) || "."}/`;
+	return posix.join(posix.relative(fromDir, posix.dirname(to)), posix.basename(to));
+}
+const EXCLUDED = "points to a page that the collection's filter excludes.";
+/**
+* Rewrites a relative link to a content file into the URL of its page.
+* Links within one locale become relative URLs, so pages shown through fallback keep linking within the shown locale.
+* Returns `undefined` for links that are not to `.md` or `.mdx` files. Throws when the target does not exist.
+*/
+function resolveContentLink(settings, source, url, root) {
+	const match = /^([^#?]+\.mdx?)(#.*)?$/i.exec(url);
+	if (!match || /^([a-z][a-z\d+.-]*:|\/)/i.test(url)) return void 0;
+	const [, path, hash = ""] = match;
+	const absolute = resolve(root, dirname(source.file), decodeURI(path));
+	const target = relative(root, absolute).split(sep).join("/");
+	if (!target.startsWith(`${source.base}/`)) throw new Error(`"${url}" points outside the content collection, so it has no page.`);
+	if (!existsSync(absolute)) throw new Error(`"${url}" points to a file that does not exist.`);
+	if (source.isExcluded?.(target)) throw new Error(`"${url}" ${EXCLUDED}`);
+	const { locales, localeDirs } = contentOptions(settings, source.base);
+	const from = parseFilePath(source.file, source.base, locales, localeDirs);
+	const to = parseFilePath(target, source.base, locales, localeDirs);
+	return (from.locale === to.locale ? relativeHref(settings, from.id, to.id, settings.i18n ? from.locale : void 0) : href(settings, to.id, to.locale)) + hash;
+}
+/**
+* Resolves a link found in a Markdown file, or returns `undefined` to leave it alone.
+* Only files inside a collection loaded with minidocs' glob are rewritten.
+*/
+function rewrite(filePath, url) {
+	const { settings, root } = registry;
+	if (!settings || !root) return void 0;
+	const file = relative(root, filePath).split(sep).join("/");
+	const collection = Object.values(registry.collections).find(({ base }) => file.startsWith(`${base}/`));
+	if (!collection) return void 0;
+	const isExcluded = (target) => {
+		if (collection.loading) {
+			collection.pendingLinks.push({
+				file,
+				url,
+				target
+			});
+			return false;
+		}
+		return collection.excluded.has(target);
+	};
+	return resolveContentLink(settings, {
+		file,
+		base: collection.base,
+		isExcluded
+	}, url, root);
+}
+/** Checks links that Markdown rendered during a load, now that every entry has been filtered. */
+function checkPendingLinks(collection) {
+	const pending = collection.pendingLinks;
+	collection.pendingLinks = [];
+	const broken = pending.filter(({ file, target }) => !collection.excluded.has(file) && collection.excluded.has(target));
+	if (broken.length === 0) return;
+	const root = registry.root ?? "";
+	throw new Error(broken.map(({ file, url }) => failure(resolve(root, file), url, /* @__PURE__ */ new Error(`"${url}" ${EXCLUDED}`)).message).join("\n"));
+}
+/** Points at the line of the source file with the link. Processors may count lines from after the frontmatter. */
+function failure(filePath, url, error) {
+	let line;
+	try {
+		const index = readFileSync(filePath, "utf8").split("\n").findIndex((text) => text.includes(url));
+		if (index !== -1) line = index + 1;
+	} catch {}
+	const location = `${relative(registry.root ?? "", filePath)}${line ? `:${line}` : ""}`;
+	return /* @__PURE__ */ new Error(`[minidocs] ${location}: ${error.message}`);
+}
+/** Plugin for Sätteri, Astro's default Markdown processor. */
+const satteriContentLinks = (() => {
+	const visit = (node, context) => {
+		if (!context.fileURL) return;
+		const filePath = fileURLToPath(context.fileURL);
+		try {
+			const url = rewrite(filePath, node.url);
+			if (url !== void 0) context.setProperty(node, "url", url);
+		} catch (error) {
+			throw failure(filePath, node.url, error);
+		}
+	};
+	return {
+		name: "minidocs-content-links",
+		link: visit,
+		definition: visit
+	};
+})();
+/** Remark plugin for the unified processor from `@astrojs/markdown-remark`. */
+function remarkContentLinks() {
+	return (tree, file) => {
+		const filePath = file.path;
+		if (!filePath) return;
+		const visit = (node) => {
+			if ((node.type === "link" || node.type === "definition") && node.url) try {
+				node.url = rewrite(filePath, node.url) ?? node.url;
+			} catch (error) {
+				throw failure(filePath, node.url, error);
+			}
+			for (const child of node.children ?? []) visit(child);
+		};
+		visit(tree);
+	};
+}
+//#endregion
+export { renderConfigTypes as a, registry as i, remarkContentLinks as n, renderTypes as o, satteriContentLinks as r, checkPendingLinks as t };

package/dist/loaders.d.mts

@@ -0,0 +1,20 @@
+import { Loader, glob as glob$1 } from "astro/loaders";
+//#region src/loaders.d.ts
+type GlobOptions = Parameters<typeof glob$1>[0];
+/** An entry as the filter sees it, after the collection schema has parsed its data. */
+export interface FilterEntry {
+  id: string;
+  data: Record<string, unknown>;
+  filePath?: string | undefined;
+}
+/**
+ * Astro's `glob()` loader, plus recording of the collection root so minidocs can
+ * derive locales and page ids, and generate types for them.
+ * Entries rejected by `filter` never reach the collection, so types, links and pages all agree on what exists.
+ */
+export declare function glob({ filter, ...options }: GlobOptions & {
+  base: string | URL;
+  filter?: (entry: FilterEntry) => boolean;
+}): Loader;
+//#endregion
+export {};

package/dist/loaders.mjs

@@ -0,0 +1,76 @@
+import { i as registry, o as renderTypes, t as checkPendingLinks } from "./links-UTLyoo_o.mjs";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob as glob$1 } from "astro/loaders";
+//#region src/loaders.ts
+/**
+* Astro's `glob()` loader, plus recording of the collection root so minidocs can
+* derive locales and page ids, and generate types for them.
+* Entries rejected by `filter` never reach the collection, so types, links and pages all agree on what exists.
+*/
+function glob({ filter, ...options }) {
+	const inner = glob$1(options);
+	return {
+		...inner,
+		name: "minidocs-glob",
+		async load(context) {
+			const baseUrl = options.base instanceof URL ? options.base : new URL(options.base, context.config.root);
+			const base = relative(fileURLToPath(context.config.root), fileURLToPath(baseUrl)).replaceAll("\\", "/");
+			let scheduled;
+			const update = () => {
+				clearTimeout(scheduled);
+				scheduled = setTimeout(() => writeTypes(context), 50);
+			};
+			registry.collections[context.collection] ??= {
+				base,
+				filePaths: [],
+				excluded: /* @__PURE__ */ new Set(),
+				loading: false,
+				pendingLinks: []
+			};
+			const state = registry.collections[context.collection];
+			state.base = base;
+			const store = new Proxy(context.store, { get(target, property, receiver) {
+				const value = Reflect.get(target, property, receiver);
+				if (property !== "set" && property !== "delete" && property !== "clear") return value;
+				return (...args) => {
+					update();
+					if (property === "set" && filter) {
+						const entry = args[0];
+						if (!filter(entry)) {
+							if (entry.filePath) state.excluded.add(entry.filePath);
+							if (target.has(entry.id)) target.delete(entry.id);
+							return false;
+						}
+						if (entry.filePath) state.excluded.delete(entry.filePath);
+					}
+					return value.apply(target, args);
+				};
+			} });
+			state.loading = true;
+			try {
+				await inner.load({
+					...context,
+					store
+				});
+			} finally {
+				state.loading = false;
+			}
+			clearTimeout(scheduled);
+			writeTypes(context);
+			checkPendingLinks(state);
+		}
+	};
+}
+function writeTypes(context) {
+	const { settings, typesFile } = registry;
+	if (!settings || !typesFile) throw new Error("[minidocs] Add the minidocs() integration to your Astro config to use glob from '@minidocs/astro/loaders'.");
+	const filePaths = context.store.values().map((entry) => entry.filePath).filter((filePath) => Boolean(filePath));
+	registry.collections[context.collection].filePaths = filePaths;
+	const path = fileURLToPath(typesFile);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, renderTypes(settings, registry.collections));
+}
+//#endregion
+export { glob };

package/dist/routing-TMqRCY2Q.mjs

@@ -0,0 +1,48 @@
+//#region src/routing.ts
+/** The locale every page of a single-language site belongs to inside core. Never exposed to users. */
+const SINGLE_LOCALE = "default";
+/** Options for core: locale directories for multilingual sites, one implicit locale otherwise. */
+function contentOptions(settings, base) {
+	return settings.i18n ? {
+		base,
+		locales: settings.i18n.locales,
+		fallback: settings.i18n.fallback
+	} : {
+		base,
+		locales: [SINGLE_LOCALE],
+		localeDirs: false
+	};
+}
+/** The URL segment of a page id: the root index page has none. */
+function slugOf(id) {
+	return id === "index" ? "" : id;
+}
+const normalizeLocale = (locale) => locale.replaceAll("_", "-").toLowerCase();
+/**
+* Route parameter for a page, e.g. `en/docs/getting-started`, without `base` or slashes around it.
+* `undefined` stands for the site root, as Astro expects for rest parameters.
+*/
+function routePath(settings, id, locale) {
+	const { i18n } = settings;
+	return [
+		!i18n || locale === void 0 || locale === i18n.defaultLocale && !i18n.prefixDefaultLocale ? "" : normalizeLocale(locale),
+		settings.prefix,
+		slugOf(id)
+	].filter(Boolean).join("/") || void 0;
+}
+/** Link to a page, including `base` and the trailing slash Astro would use. */
+function href(settings, id, locale) {
+	const path = [settings.base, routePath(settings, id, locale)].filter(Boolean).join("/");
+	if (!path) return "/";
+	return `/${path}${settings.trailingSlash ? "/" : ""}`;
+}
+/** Route parameter for a page in `src/pages/[...path].md.ts`. The site root has no segment of its own, so it becomes `index`. */
+function markdownPath(settings, id, locale) {
+	return routePath(settings, id, locale) ?? "index";
+}
+/** Link to the Markdown version of a page, including `base`. */
+function markdownHref(settings, id, locale) {
+	return `/${[settings.base, markdownPath(settings, id, locale)].filter(Boolean).join("/")}.md`;
+}
+//#endregion
+export { routePath as a, markdownPath as i, href as n, markdownHref as r, contentOptions as t };