fumadocs-core 16.15.2 → 16.15.3

package/dist/{build-doc-SC7P37WG.js → build-doc-CX-PNB-q.js}

@@ -51,7 +51,7 @@ function buildDocuments(indexes) {
 			locale: page.locale
 		});
 		const nextId = () => `${page.id}-${id++}`;
-		if (page.description) docs.push({
+		if (page.description && !data.contents.some((item) => item.content === page.description)) docs.push({
 			id: nextId(),
 			page_id: page.id,
 			tags,

package/dist/content/mdx/preset-bundler.d.ts

@@ -4,7 +4,7 @@ import { r as StructureOptions } from "../../remark-structure-CnHwvNZr.js";
 import { t as RemarkHeadingOptions } from "../../remark-heading-DEIzTkU5.js";
 import { t as RemarkCodeTabOptions } from "../../remark-code-tab-DE_4bdnu.js";
 import { t as RemarkNpmOptions } from "../../remark-npm-BbpvkJaT.js";
-import "../../index-C-fnVAhi.js";
+import "../../index-BhgPrb5p.js";
 import { t as ResolvePlugins } from "../../util-BDsqOxh3.js";
 import { Pluggable } from "unified";
 import { ProcessorOptions } from "@mdx-js/mdx";

package/dist/content/mdx/preset-runtime.d.ts

@@ -4,7 +4,7 @@ import { r as StructureOptions } from "../../remark-structure-CnHwvNZr.js";
 import { t as RemarkHeadingOptions } from "../../remark-heading-DEIzTkU5.js";
 import { t as RemarkCodeTabOptions } from "../../remark-code-tab-DE_4bdnu.js";
 import { t as RemarkNpmOptions } from "../../remark-npm-BbpvkJaT.js";
-import "../../index-C-fnVAhi.js";
+import "../../index-BhgPrb5p.js";
 import { t as ResolvePlugins } from "../../util-BDsqOxh3.js";
 import { ProcessorOptions } from "@mdx-js/mdx";
 //#region src/content/mdx/preset-runtime.d.ts

package/dist/{index-DQWu2opy.d.ts → index-19nHQs6M.d.ts}

@@ -1,7 +1,7 @@
 import { a as Separator, i as Root, n as Item, r as Node, t as Folder } from "./definitions-D8-KI7Uy.js";
 import { t as Awaitable } from "./types-D89QoQR-.js";
 import { i as StructuredData } from "./remark-structure-CnHwvNZr.js";
-import "./index-C-fnVAhi.js";
+import "./index-BhgPrb5p.js";
 import { n as I18nConfig } from "./index-DydiXvgS.js";
 import "./index-DZN5OrTa.js";
 import { n as SerializedPageTree } from "./index-CdZGMKDG.js";

package/dist/{index-C-fnVAhi.d.ts → index-BhgPrb5p.d.ts}

@@ -13,4 +13,4 @@ import "./codeblock-utils-CyP8qsYv.js";
 import "./remark-mdx-files-Buvxc-sa.js";
 import "./remark-mdx-mermaid-C1bCHHc6.js";
 import "./remark-feedback-block-BxtINXN-.js";
-import "./remark-llms-BF5SHW_O.js";
+import "./remark-llms-DxglVo94.js";

package/dist/mdx-plugins/index.d.ts

@@ -15,6 +15,6 @@ import { i as parseCodeBlockAttributes, n as CodeBlockTabsOptions, r as generate
 import { a as remarkMdxFiles, r as RemarkMdxFilesOptions } from "../remark-mdx-files-Buvxc-sa.js";
 import { n as remarkMdxMermaid, t as RemarkMdxMermaidOptions } from "../remark-mdx-mermaid-C1bCHHc6.js";
 import { n as RemarkFeedbackBlockOptions, r as remarkFeedbackBlock, t as FeedbackBlockProps } from "../remark-feedback-block-BxtINXN-.js";
-import { t as LLMsOptions } from "../remark-llms-BF5SHW_O.js";
-import "../index-C-fnVAhi.js";
+import { t as LLMsOptions } from "../remark-llms-DxglVo94.js";
+import "../index-BhgPrb5p.js";
 export { CodeBlockAttributes, type CodeBlockIcon, CodeBlockTabsOptions, FeedbackBlockProps, type LLMsOptions, RehypeCodeOptions, RehypeTOCItemType, RehypeTocOptions, RemarkAdmonitionOptions, RemarkCodeTabOptions, RemarkDirectiveAdmonitionOptions, RemarkFeedbackBlockOptions, type RemarkGfmOptions, RemarkHeadingOptions, RemarkImageOptions, type RemarkMdxFilesOptions, RemarkMdxMermaidOptions, RemarkNpmOptions, RemarkStepsOptions, Stringifier, StringifyOptions, StructureOptions, StructuredData, defaultStringifier, generateCodeBlockTabs, parseCodeBlockAttributes, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkCodeTab, remarkDirectiveAdmonition, remarkFeedbackBlock, remarkGfm, remarkHeading, remarkImage, remarkMdxFiles, remarkMdxMermaid, remarkNpm, remarkSteps, remarkStructure, remarkStructureDefaultOptions, structure, transformerIcon, transformerTab };

package/dist/mdx-plugins/remark-llms.d.ts

@@ -1,2 +1,2 @@
-import { n as placeholder, r as remarkLLMs, t as LLMsOptions } from "../remark-llms-BF5SHW_O.js";
+import { n as placeholder, r as remarkLLMs, t as LLMsOptions } from "../remark-llms-DxglVo94.js";
 export { LLMsOptions, placeholder, remarkLLMs };

package/dist/mdx-plugins/remark-llms.js

@@ -5,7 +5,8 @@ import { defaultHandlers } from "mdast-util-to-markdown";
 /**
 * generate `llms.txt` for markdown.
 */
-function remarkLLMs({ as = "_markdown", headingIds = true, _data = false, mdxAsPlaceholder, ...rest } = {}) {
+function remarkLLMs({ as = "_markdown", headingIds = true, _data = false, mdxAsPlaceholder, output = "string", ...rest } = {}) {
+	const jsx = output === "function";
 	const stringifier = defaultStringifier({
 		...rest,
 		filterElement(node) {
@@ -14,12 +15,14 @@ function remarkLLMs({ as = "_markdown", headingIds = true, _data = false, mdxAsP
 				default: return true;
 			}
 		},
-		stringify(node, parent, state, info, ctx) {
-			if (mdxAsPlaceholder) switch (node.type) {
+		stringify(node, parent, state, info, collect) {
+			if (mdxAsPlaceholder && !collect) switch (node.type) {
 				case "mdxJsxFlowElement":
 				case "mdxJsxTextElement": if (node.name && mdxAsPlaceholder.includes(node.name)) return placeholder(node, parent, state, info);
 			}
-			return rest.stringify?.(node, parent, state, info, ctx);
+			const custom = rest.stringify?.(node, parent, state, info, void 0);
+			if (custom) return custom;
+			if (collect) return collectJsx(node, state, info, collect);
 		},
 		handlers: {
 			heading(node, _p, state, info) {
@@ -31,6 +34,12 @@ function remarkLLMs({ as = "_markdown", headingIds = true, _data = false, mdxAsP
 		}
 	});
 	return (node, file) => {
+		if (jsx) {
+			const collect = [];
+			const text = stringifier.call(this, node, collect);
+			node.children.unshift(jsxToEstree(as, toJsxChunks(text, collect)));
+			return;
+		}
 		const value = stringifier.call(this, node, void 0);
 		node.children.unshift(toMdxExport(as, value));
 		if (_data) file.data.markdown = value;
@@ -51,5 +60,279 @@ function placeholder(node, _parent, state, info) {
 		attributes
 	})}\0`;
 }
+/**
+* `stringify` branch for the `function` output: collect the element and return a marker,
+* resolved later by `toJsxChunks()`. Only components (capitalized names) are kept.
+*/
+function collectJsx(node, state, info, collect) {
+	switch (node.type) {
+		case "mdxJsxFlowElement":
+		case "mdxJsxTextElement": {
+			if (!node.name || !/^[A-Z][\w$]*$/.test(node.name)) return;
+			const entry = {
+				node,
+				children: ""
+			};
+			const marker = `\0${collect.push(entry) - 1}\0`;
+			entry.children = node.type === "mdxJsxTextElement" ? state.containerPhrasing(node, info) : state.containerFlow(node, info);
+			return marker;
+		}
+	}
+}
+const Marker = /\0(\d+)\0/g;
+/**
+* Split stringified Markdown on the markers emitted by `collectJsx()` into
+* alternating text chunks and kept JSX elements, recursively for their children.
+*/
+function toJsxChunks(text, collect) {
+	const out = [];
+	let idx = 0;
+	for (const match of text.matchAll(Marker)) {
+		if (match.index > idx) out.push(text.slice(idx, match.index));
+		const { node, children } = collect[Number(match[1])];
+		out.push({
+			node,
+			children: toJsxChunks(children, collect)
+		});
+		idx = match.index + match[0].length;
+	}
+	if (idx < text.length) out.push(text.slice(idx));
+	return out;
+}
+/**
+* Generate the component export as an ESM node with estree, for the MDX.js compiler.
+*/
+function jsxToEstree(as, chunks) {
+	const hasJsx = chunks.some((chunk) => typeof chunk !== "string");
+	let value;
+	if (chunks.length === 0) value = literal("");
+	else if (typeof chunks[0] === "string" && chunks.length === 1) value = literal(chunks[0]);
+	else if (chunks.length === 1) value = elementToEstree(chunks[0]);
+	else value = {
+		type: "JSXFragment",
+		openingFragment: { type: "JSXOpeningFragment" },
+		closingFragment: { type: "JSXClosingFragment" },
+		children: childrenToEstree(chunks)
+	};
+	const body = [{
+		type: "IfStatement",
+		test: {
+			type: "UnaryExpression",
+			operator: "!",
+			prefix: true,
+			argument: {
+				type: "CallExpression",
+				callee: {
+					type: "Identifier",
+					name: "_asMarkdown"
+				},
+				arguments: [],
+				optional: false
+			}
+		},
+		consequent: {
+			type: "ReturnStatement",
+			argument: literal(null)
+		},
+		alternate: null
+	}];
+	if (hasJsx) body.push({
+		type: "VariableDeclaration",
+		kind: "const",
+		declarations: [{
+			type: "VariableDeclarator",
+			id: {
+				type: "Identifier",
+				name: "_c"
+			},
+			init: {
+				type: "CallExpression",
+				callee: {
+					type: "Identifier",
+					name: "_jsxComponents"
+				},
+				arguments: [{
+					type: "MemberExpression",
+					object: {
+						type: "Identifier",
+						name: "props"
+					},
+					property: {
+						type: "Identifier",
+						name: "components"
+					},
+					computed: false,
+					optional: false
+				}],
+				optional: false
+			}
+		}]
+	});
+	body.push({
+		type: "ReturnStatement",
+		argument: value
+	});
+	return {
+		type: "mdxjsEsm",
+		value: "",
+		data: { estree: {
+			type: "Program",
+			sourceType: "module",
+			body: [{
+				type: "ImportDeclaration",
+				attributes: [],
+				specifiers: [{
+					type: "ImportSpecifier",
+					imported: {
+						type: "Identifier",
+						name: "asMarkdown"
+					},
+					local: {
+						type: "Identifier",
+						name: "_asMarkdown"
+					}
+				}, ...hasJsx ? [{
+					type: "ImportSpecifier",
+					imported: {
+						type: "Identifier",
+						name: "jsxComponents"
+					},
+					local: {
+						type: "Identifier",
+						name: "_jsxComponents"
+					}
+				}] : []],
+				source: literal("fumadocs-core/server")
+			}, {
+				type: "ExportNamedDeclaration",
+				attributes: [],
+				specifiers: [],
+				declaration: {
+					type: "FunctionDeclaration",
+					id: {
+						type: "Identifier",
+						name: as
+					},
+					params: [{
+						type: "Identifier",
+						name: "props"
+					}],
+					body: {
+						type: "BlockStatement",
+						body
+					}
+				}
+			}]
+		} }
+	};
+}
+function literal(value) {
+	return {
+		type: "Literal",
+		value
+	};
+}
+function childrenToEstree(chunks) {
+	const out = [];
+	for (const chunk of chunks) out.push(typeof chunk === "string" ? {
+		type: "JSXExpressionContainer",
+		expression: literal(chunk)
+	} : elementToEstree(chunk));
+	return out;
+}
+function elementToEstree({ node, children }) {
+	const attributes = [];
+	for (const attr of node.attributes) {
+		if (attr.type === "mdxJsxExpressionAttribute") {
+			const expression = programExpression(attr.data?.estree);
+			if (expression?.type === "ObjectExpression" && expression.properties.length === 1 && expression.properties[0].type === "SpreadElement") attributes.push({
+				type: "JSXSpreadAttribute",
+				argument: expression.properties[0].argument
+			});
+			continue;
+		}
+		let value = null;
+		if (typeof attr.value === "string") value = {
+			type: "Literal",
+			value: attr.value
+		};
+		else if (attr.value) {
+			const expression = programExpression(attr.value.data?.estree);
+			if (!expression) continue;
+			value = {
+				type: "JSXExpressionContainer",
+				expression
+			};
+		}
+		attributes.push({
+			type: "JSXAttribute",
+			name: attr.name.includes(":") ? {
+				type: "JSXNamespacedName",
+				namespace: {
+					type: "JSXIdentifier",
+					name: attr.name.slice(0, attr.name.indexOf(":"))
+				},
+				name: {
+					type: "JSXIdentifier",
+					name: attr.name.slice(attr.name.indexOf(":") + 1)
+				}
+			} : {
+				type: "JSXIdentifier",
+				name: attr.name
+			},
+			value
+		});
+	}
+	const name = {
+		type: "JSXMemberExpression",
+		object: {
+			type: "JSXIdentifier",
+			name: "_c"
+		},
+		property: {
+			type: "JSXIdentifier",
+			name: node.name
+		}
+	};
+	const element = {
+		type: "JSXElement",
+		openingElement: {
+			type: "JSXOpeningElement",
+			name,
+			attributes,
+			selfClosing: children.length === 0
+		},
+		closingElement: children.length === 0 ? null : {
+			type: "JSXClosingElement",
+			name
+		},
+		children: childrenToEstree(children)
+	};
+	if (node.type === "mdxJsxFlowElement") return element;
+	return {
+		type: "JSXElement",
+		openingElement: {
+			type: "JSXOpeningElement",
+			name: {
+				type: "JSXIdentifier",
+				name: "span"
+			},
+			attributes: [],
+			selfClosing: false
+		},
+		closingElement: {
+			type: "JSXClosingElement",
+			name: {
+				type: "JSXIdentifier",
+				name: "span"
+			}
+		},
+		children: [element]
+	};
+}
+function programExpression(program) {
+	const statement = program?.body[0];
+	if (statement?.type === "ExpressionStatement") return statement.expression;
+}
 //#endregion
 export { placeholder, remarkLLMs };

package/dist/{remark-llms-BF5SHW_O.d.ts → remark-llms-DxglVo94.d.ts}

@@ -40,17 +40,31 @@ interface LLMsOptions extends StringifyOptions {
   filterElement?: StringifyOptions['filterElement'];
   /**
    * Tag names of MDX components to be stringified as `placeholder()`, you can also use `placeholder()` directly in `stringify` callback.
+   *
+   * Ignored with `output: 'function'`.
    */
   mdxAsPlaceholder?: string[];
   /**
-   * @private output in file data
+   * Form of the export:
+   *
+   * - `string`: the output Markdown.
+   * - `function`: a component: Markdown content is still stringified at compile time, while JSX
+   *   elements are kept as JSX, receiving their original props and resolving from `props.components`.
+   *   Render it with `renderToMarkdown` from `fumadocs-core/server`, where a component
+   *   can call `asMarkdown()` to define its own Markdown form.
+   *
+   * @default string
+   */
+  output?: 'function' | 'string';
+  /**
+   * @private output in file data, unavailable with `output: 'function'`
    */
   _data?: boolean;
 }
 /**
  * generate `llms.txt` for markdown.
  */
-declare function remarkLLMs(this: Processor, { as, headingIds, _data, mdxAsPlaceholder, ...rest }?: LLMsOptions): Transformer<Root, Root>;
+declare function remarkLLMs(this: Processor, { as, headingIds, _data, mdxAsPlaceholder, output, ...rest }?: LLMsOptions): Transformer<Root, Root>;
 /**
  * Preserve AST data to render the MDX component at runtime, use `renderPlaceholder()` to render the placeholders.
  */

package/dist/search/flexsearch.d.ts

@@ -1,8 +1,8 @@
 import { t as Awaitable } from "../types-D89QoQR-.js";
 import { n as I18nConfig } from "../index-DydiXvgS.js";
 import "../index-BM36H-xw.js";
-import { m as SharedIndex, n as SearchAPI, t as QueryOptions } from "../server-BoDPRfLi.js";
-import { b as LoaderOutput, v as LoaderConfig } from "../index-DQWu2opy.js";
+import { m as SharedIndex, n as SearchAPI, t as QueryOptions } from "../server-C8FDQbVc.js";
+import { b as LoaderOutput, v as LoaderConfig } from "../index-19nHQs6M.js";
 import { DocumentData, DocumentOptions } from "flexsearch";
 //#region src/search/server/build-doc.d.ts
 interface SharedDocument {

package/dist/search/flexsearch.js

@@ -1,5 +1,5 @@
 import { t as createEndpoint } from "../endpoint-MyoBU5IC.js";
-import { n as buildBreadcrumbs, r as buildIndexDefault, t as buildDocuments } from "../build-doc-SC7P37WG.js";
+import { n as buildBreadcrumbs, r as buildIndexDefault, t as buildDocuments } from "../build-doc-CX-PNB-q.js";
 import { n as search, t as createDocument } from "../utils-Bvy3V-fv.js";
 import Search from "flexsearch";
 //#region src/search/flexsearch.ts

package/dist/search/mixedbread.d.ts

@@ -1,5 +1,5 @@
 import { r as SortedResult } from "../index-BM36H-xw.js";
-import { n as SearchAPI } from "../server-BoDPRfLi.js";
+import { n as SearchAPI } from "../server-C8FDQbVc.js";
 import Mixedbread from "@mixedbread/sdk";
 import { StoreSearchResponse } from "@mixedbread/sdk/resources/stores";
 //#region src/search/mixedbread.d.ts

package/dist/search/orama-cloud-legacy.d.ts

@@ -1,5 +1,5 @@
 import { i as StructuredData } from "../remark-structure-CnHwvNZr.js";
-import "../index-C-fnVAhi.js";
+import "../index-BhgPrb5p.js";
 import { CloudManager } from "@oramacloud/client";
 //#region src/search/orama-cloud-legacy.d.ts
 interface SyncOptions {

package/dist/search/orama-cloud.d.ts

@@ -1,5 +1,5 @@
 import { i as StructuredData } from "../remark-structure-CnHwvNZr.js";
-import "../index-C-fnVAhi.js";
+import "../index-BhgPrb5p.js";
 import { OramaCloud } from "@orama/core";
 //#region src/search/orama-cloud.d.ts
 interface SyncOptions {

package/dist/search/server.d.ts

@@ -1,2 +1,2 @@
-import { a as AdvancedOptions, c as SimpleOptions, d as createSearchAPI, f as initAdvancedSearch, i as AdvancedIndex, l as createFromSource, n as SearchAPI, o as ExportedData, p as initSimpleSearch, r as SearchServer, s as Index, t as QueryOptions, u as createI18nSearchAPI } from "../server-BoDPRfLi.js";
+import { a as AdvancedOptions, c as SimpleOptions, d as createSearchAPI, f as initAdvancedSearch, i as AdvancedIndex, l as createFromSource, n as SearchAPI, o as ExportedData, p as initSimpleSearch, r as SearchServer, s as Index, t as QueryOptions, u as createI18nSearchAPI } from "../server-C8FDQbVc.js";
 export { AdvancedIndex, AdvancedOptions, ExportedData, Index, QueryOptions, SearchAPI, SearchServer, SimpleOptions, createFromSource, createI18nSearchAPI, createSearchAPI, initAdvancedSearch, initSimpleSearch };

package/dist/search/server.js

@@ -1,5 +1,5 @@
 import { n as defaultReadOptions, t as createEndpoint } from "../endpoint-MyoBU5IC.js";
-import { n as buildBreadcrumbs, r as buildIndexDefault, t as buildDocuments } from "../build-doc-SC7P37WG.js";
+import { n as buildBreadcrumbs, r as buildIndexDefault, t as buildDocuments } from "../build-doc-CX-PNB-q.js";
 import { n as searchSimple, t as searchAdvanced } from "../advanced-Ct13khZr.js";
 import { create, insertMultipleAsync, save } from "zbsearch";
 //#region src/search/zbsearch/create-db.ts

package/dist/{server-BoDPRfLi.d.ts → server-C8FDQbVc.d.ts}

@@ -2,7 +2,7 @@ import { t as Awaitable } from "./types-D89QoQR-.js";
 import { i as StructuredData } from "./remark-structure-CnHwvNZr.js";
 import { n as I18nConfig } from "./index-DydiXvgS.js";
 import { r as SortedResult } from "./index-BM36H-xw.js";
-import { b as LoaderOutput, v as LoaderConfig } from "./index-DQWu2opy.js";
+import { b as LoaderOutput, v as LoaderConfig } from "./index-19nHQs6M.js";
 import { Language, RawData, SearchParams, TypedDocument, ZBSearch, create } from "zbsearch";
 //#region src/search/zbsearch/create-db.d.ts
 type SimpleDocument = TypedDocument<ZBSearch<typeof simpleSchema>>;

package/dist/server.browser.d.ts

@@ -0,0 +1,13 @@
+import { ElementType, ReactElement } from "react";
+//#region src/server.browser.d.ts
+/**
+ * Browser stub: Markdown rendering is server-only, components generated by
+ * `remarkLLMs` with `output: 'function'` render `null` in the browser.
+ */
+declare function asMarkdown(): boolean;
+declare function jsxComponents(components: Record<string, ElementType> | undefined): Record<string, ElementType>;
+declare function renderToMarkdown(): Promise<string>;
+declare function renderRoute(_element: ReactElement): Promise<string | undefined>;
+declare const md: () => never;
+//#endregion
+export { asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };

package/dist/server.browser.js

@@ -0,0 +1,22 @@
+//#region src/server.browser.ts
+/**
+* Browser stub: Markdown rendering is server-only, components generated by
+* `remarkLLMs` with `output: 'function'` render `null` in the browser.
+*/
+function asMarkdown() {
+	return false;
+}
+function jsxComponents(components) {
+	return components ?? {};
+}
+async function renderToMarkdown() {
+	throw new Error("`renderToMarkdown` is only available on the server.");
+}
+async function renderRoute(_element) {
+	throw new Error("`renderRoute` is only available on the server.");
+}
+const md = () => {
+	throw new Error("`md` is only available on the server.");
+};
+//#endregion
+export { asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };

package/dist/server.d.ts

@@ -0,0 +1,42 @@
+import { ElementType, ReactElement, ReactNode } from "react";
+//#region src/server.d.ts
+/**
+ * Whether the current component is being rendered into Markdown, calling it opts the component in.
+ */
+declare function asMarkdown(): boolean;
+/**
+ * Render a React tree into a Markdown document.
+ */
+declare function renderToMarkdown(node: ReactNode): Promise<string>;
+/**
+ * Render a page element into Markdown, `undefined` when its component doesn't call `asMarkdown()`.
+ */
+declare function renderRoute(element: ReactElement): Promise<string | undefined>;
+/**
+ * Resolve the MDX components of a generated Markdown component (`remarkLLMs` with `output: 'function'`):
+ * a missing component becomes a stub that `renderToMarkdown` serializes as JSX syntax.
+ */
+declare function jsxComponents(components: Record<string, ElementType> | undefined): Record<string, ElementType>;
+type MarkdownTag = (strings: TemplateStringsArray, ...values: ReactNode[]) => Promise<string>;
+/**
+ * Tagged template for Markdown, interpolated values can be strings, React nodes, promises, or arrays of them.
+ *
+ * Use `md\`${children}\`` inside a component to stringify its children before manipulating them, the result is not
+ * trimmed so block-level output keeps its trailing blank line.
+ *
+ * Formatters (Prettier, oxfmt) format `md` templates as Markdown and may move the content onto its own indented lines,
+ * so a leading empty line, the indentation before the closing backtick and the common indentation are removed.
+ */
+declare const md: MarkdownTag & {
+  /**
+   * Like `md`, but trims the result, prefixes every line (empty lines receive the trimmed prefix, e.g. `>` instead of
+   * `> `) and returns it as a block.
+   */
+  linePrefix: (prefix: string) => MarkdownTag;
+  /**
+   * Like `md`, but trims the result, indents every non-empty line and returns it as a block.
+   */
+  indent: (size?: number) => MarkdownTag;
+};
+//#endregion
+export { MarkdownTag, asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };

package/dist/server.js

@@ -0,0 +1,398 @@
+import { isValidElement } from "react";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/server.ts
+const ROOT_STATE = {
+	pre: false,
+	inline: false,
+	heading: false
+};
+const CLIENT_REFERENCE = Symbol.for("react.client.reference");
+const REACT_LAZY = Symbol.for("react.lazy");
+const REACT_MEMO = Symbol.for("react.memo");
+const REACT_FORWARD_REF = Symbol.for("react.forward_ref");
+const NOT_OPTED_IN = Symbol();
+const store = new AsyncLocalStorage({ name: "fumadocs:markdown" });
+/**
+* Whether the current component is being rendered into Markdown, calling it opts the component in.
+*/
+function asMarkdown() {
+	const frame = store.getStore();
+	if (!frame) return false;
+	frame.optedIn = true;
+	return true;
+}
+/**
+* Render a React tree into a Markdown document.
+*/
+async function renderToMarkdown(node) {
+	return collapse(await walk(node, ROOT_STATE)).trim();
+}
+/**
+* Render a page element into Markdown, `undefined` when its component doesn't call `asMarkdown()`.
+*/
+async function renderRoute(element) {
+	if (typeof element.type !== "function") return;
+	const result = await optIn(element.type, element.props);
+	if (result !== NOT_OPTED_IN) return renderToMarkdown(result);
+}
+/**
+* Resolve the MDX components of a generated Markdown component (`remarkLLMs` with `output: 'function'`):
+* a missing component becomes a stub that `renderToMarkdown` serializes as JSX syntax.
+*/
+function jsxComponents(components) {
+	return new Proxy(components ?? {}, { get(target, key) {
+		const value = target[key];
+		if (value !== void 0 || typeof key !== "string") return value;
+		const stub = () => null;
+		stub.displayName = key;
+		return stub;
+	} });
+}
+/**
+* Tagged template for Markdown, interpolated values can be strings, React nodes, promises, or arrays of them.
+*
+* Use `md\`${children}\`` inside a component to stringify its children before manipulating them, the result is not
+* trimmed so block-level output keeps its trailing blank line.
+*
+* Formatters (Prettier, oxfmt) format `md` templates as Markdown and may move the content onto its own indented lines,
+* so a leading empty line, the indentation before the closing backtick and the common indentation are removed.
+*/
+const md = Object.assign(async function md(strings, ...values) {
+	const parts = dedent(strings);
+	const resolved = await Promise.all(values.map(render));
+	let out = parts[0];
+	for (let i = 0; i < resolved.length; i++) out += resolved[i] + parts[i + 1];
+	return out;
+}, {
+	linePrefix(prefix) {
+		return async (strings, ...values) => {
+			const text = (await md(strings, ...values)).trim();
+			return text.length === 0 ? "" : `\n${prefixLines(text, prefix)}\n\n`;
+		};
+	},
+	indent(size = 2) {
+		return md.linePrefix(" ".repeat(size));
+	}
+});
+/** stands in for interpolations while dedenting, so their lines count as content */
+const PLACEHOLDER = "\0";
+function dedent(strings) {
+	const lines = strings.join(PLACEHOLDER).split("\n");
+	if (lines.length === 1) return [...strings];
+	if (lines[0].trim().length === 0) lines.shift();
+	const last = lines[lines.length - 1];
+	if (lines.length > 1 && last.length > 0 && last.trim().length === 0) lines.pop();
+	let indent = Infinity;
+	for (const line of lines) if (line.trim().length > 0) indent = Math.min(indent, /^[ \t]*/.exec(line)[0].length);
+	let out = "";
+	for (let i = 0; i < lines.length; i++) {
+		if (i > 0) out += "\n";
+		out += indent === Infinity ? lines[i] : lines[i].slice(Math.min(indent, lines[i].length));
+	}
+	return out.split(PLACEHOLDER);
+}
+async function render(node) {
+	return collapse(await walk(node, ROOT_STATE));
+}
+/**
+* Prefix every line, empty lines receive the trimmed prefix (e.g. `>` instead of `> `).
+*/
+function prefixLines(text, prefix) {
+	const empty = prefix.trimEnd();
+	return text.replace(/^.*$/gm, (line) => line.length === 0 ? empty : prefix + line);
+}
+function collapse(text) {
+	return text.replace(/\n{3,}/g, "\n\n");
+}
+/**
+* Render a component in its own frame, `NOT_OPTED_IN` when it never calls `asMarkdown()`.
+*
+* A component that throws before opting in (e.g. it needs a context that only exists on its own route) is treated the
+* same, it has no Markdown form.
+*/
+async function optIn(component, props) {
+	const frame = { optedIn: false };
+	try {
+		const result = await store.run(frame, () => component(props));
+		return frame.optedIn ? result : NOT_OPTED_IN;
+	} catch (e) {
+		if (frame.optedIn) throw e;
+		return NOT_OPTED_IN;
+	}
+}
+async function walk(node, state) {
+	if (node === null || node === void 0 || typeof node === "boolean") return "";
+	if (typeof node === "string") return node;
+	if (typeof node === "number" || typeof node === "bigint") return String(node);
+	if (isThenable(node)) return walk(await node, state);
+	if (isValidElement(node)) return element(node.type, node.props, state);
+	if (typeof node === "object" && Symbol.iterator in node) return (await Promise.all(Array.from(node, (child) => walk(child, state)))).join("");
+	return "";
+}
+async function element(type, props, state) {
+	if (typeof type === "string") return host(type, props, state);
+	if (isClientReference(type)) return jsx(clientReferenceName(type.$$id), props, state);
+	if (typeof type === "function") return component(type, props, state);
+	if (typeof type === "symbol") return walk(props.children, state);
+	if (typeof type === "object" && type !== null) {
+		const special = type;
+		switch (special.$$typeof) {
+			case REACT_LAZY: return element(await resolveLazy(special), props, state);
+			case REACT_MEMO: return element(special.type, props, state);
+			case REACT_FORWARD_REF: return component(special.render, props, state);
+		}
+	}
+	return "";
+}
+async function component(fn, props, state) {
+	const result = await optIn(fn, props);
+	if (result === NOT_OPTED_IN) return jsx(componentName(fn), props, state);
+	return walk(result, state);
+}
+function componentName(fn) {
+	const { displayName, name } = fn;
+	return typeof displayName === "string" && displayName ? displayName : name || "Component";
+}
+async function resolveLazy(type) {
+	for (;;) try {
+		return type._init(type._payload);
+	} catch (e) {
+		if (!isThenable(e)) throw e;
+		await e;
+	}
+}
+/**
+* The export name of a client reference, or a PascalCase name from its file for default exports.
+*/
+function clientReferenceName(id) {
+	if (typeof id !== "string") return "Component";
+	try {
+		id = decodeURIComponent(id);
+	} catch {}
+	const hash = id.lastIndexOf("#");
+	const exportName = hash === -1 ? "" : id.slice(hash + 1);
+	if (exportName && exportName !== "default") return exportName;
+	const file = (hash === -1 ? id : id.slice(0, hash)).split(/[\\/]/).pop();
+	let name = "";
+	for (const part of file.replace(/\.[^.]+$/, "").split(/[^\w$]+/)) if (part) name += part[0].toUpperCase() + part.slice(1);
+	return name || "Component";
+}
+const MAX_ATTRIBUTE_LENGTH = 1024;
+const PRESENTATIONAL_PROPS = /* @__PURE__ */ new Set([
+	"children",
+	"className",
+	"style",
+	"tabIndex"
+]);
+/**
+* Serialize a component as JSX syntax, for components without a Markdown form.
+*/
+async function jsx(name, props, state) {
+	let open = `<${name}`;
+	for (const key in props) {
+		if (PRESENTATIONAL_PROPS.has(key)) continue;
+		const attr = attribute(key, props[key]);
+		if (attr !== void 0) open += ` ${attr}`;
+	}
+	const children = await walk(props.children, state);
+	if (state.inline) return children.trim().length === 0 ? `${open} />` : `${open}>${children}</${name}>`;
+	const body = children.trim();
+	if (body.length === 0) return `\n${open} />\n\n`;
+	return `\n${open}>\n${body}\n</${name}>\n\n`;
+}
+function attribute(key, value) {
+	if (value === true) return key;
+	if (value === false || value === null || value === void 0) return;
+	if (typeof value === "string") return value.length > MAX_ATTRIBUTE_LENGTH ? void 0 : `${key}=${JSON.stringify(value)}`;
+	if (typeof value === "number" || typeof value === "bigint") return `${key}={${value}}`;
+	if (typeof value === "function" || typeof value === "symbol" || isValidElement(value)) return;
+	try {
+		const json = JSON.stringify(value, (_, v) => isValidElement(v) ? void 0 : v);
+		if (json === void 0 || json.length > MAX_ATTRIBUTE_LENGTH) return;
+		return `${key}={${json}}`;
+	} catch {
+		return;
+	}
+}
+const INLINE_TAGS = /* @__PURE__ */ new Set([
+	"a",
+	"abbr",
+	"b",
+	"cite",
+	"code",
+	"del",
+	"em",
+	"i",
+	"kbd",
+	"label",
+	"mark",
+	"q",
+	"s",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"time",
+	"u"
+]);
+const DROP_TAGS = /* @__PURE__ */ new Set([
+	"head",
+	"link",
+	"meta",
+	"noscript",
+	"script",
+	"style",
+	"svg",
+	"template",
+	"title"
+]);
+async function host(tag, props, state) {
+	if (DROP_TAGS.has(tag)) return "";
+	if (state.pre) {
+		if (tag === "br") return "\n";
+		return walk(props.children, state);
+	}
+	const children = (override) => walk(props.children, {
+		...state,
+		...override
+	});
+	switch (tag) {
+		case "p": {
+			const c = (await children({ inline: true })).trim();
+			return state.inline ? `${c} ` : `\n${c}\n\n`;
+		}
+		case "h1":
+		case "h2":
+		case "h3":
+		case "h4":
+		case "h5":
+		case "h6": {
+			const c = (await children({
+				inline: true,
+				heading: true
+			})).trim().replace(/\s*\n\s*/g, " ");
+			return `\n${"#".repeat(Number(tag[1]))} ${c}\n\n`;
+		}
+		case "a": {
+			const href = typeof props.href === "string" ? props.href : void 0;
+			const c = await children({ inline: true });
+			if (!href || state.heading && href.startsWith("#")) return c;
+			const text = c.trim();
+			return text.length === 0 ? `<${href}>` : `[${text}](${href})`;
+		}
+		case "strong":
+		case "b": return wrap(await children({ inline: true }), "**");
+		case "em":
+		case "i": return wrap(await children({ inline: true }), "*");
+		case "del":
+		case "s": return wrap(await children({ inline: true }), "~~");
+		case "code":
+		case "kbd": {
+			const c = await children({ inline: true });
+			if (c.includes("\n") && !state.inline) return codeFence(detectLang(props), c);
+			return inlineCode(c);
+		}
+		case "pre": return codeFence(detectLang(props), await children({ pre: true }));
+		case "blockquote": return `\n${prefixLines(collapse(await children({ inline: false })).trim(), "> ")}\n\n`;
+		case "ul":
+		case "ol": {
+			const ordered = tag === "ol";
+			let index = typeof props.start === "number" ? props.start : 1;
+			return `\n${(await Promise.all(flatten(props.children).map((child) => {
+				if (!isValidElement(child)) return typeof child === "string" ? child.trim() : "";
+				return walk(child, {
+					...state,
+					inline: false,
+					list: {
+						ordered,
+						index: index++
+					}
+				});
+			}))).join("")}\n`;
+		}
+		case "li": {
+			const marker = state.list?.ordered ? `${state.list.index}. ` : "- ";
+			return `${marker}${prefixLines((await children({ inline: false })).trim().replace(/\n{2,}(?=(?:[-*+] |\d+\. ))/g, "\n"), " ".repeat(marker.length)).slice(marker.length)}\n`;
+		}
+		case "img": {
+			if (typeof props.src !== "string") return "";
+			const alt = typeof props.alt === "string" ? props.alt : "";
+			return state.inline ? `![${alt}](${props.src})` : `\n![${alt}](${props.src})\n\n`;
+		}
+		case "hr": return "\n---\n\n";
+		case "br": return "\n";
+		case "table": {
+			const rows = (await children({ inline: false })).replace(/\n\s*\n/g, "\n").trim();
+			if (rows.length === 0) return "";
+			const end = rows.indexOf("\n");
+			const first = end === -1 ? rows : rows.slice(0, end);
+			return `\n${first}\n${separatorRow(first)}${end === -1 ? "" : rows.slice(end)}\n\n`;
+		}
+		case "tr": return `|${await children({ inline: false })}\n`;
+		case "th":
+		case "td": return ` ${(await children({ inline: true })).trim().replace(/\s*\n\s*/g, " ").replaceAll("|", "\\|")} |`;
+	}
+	if (INLINE_TAGS.has(tag)) return children({ inline: true });
+	const c = (await children({ inline: false })).trim();
+	return c.length === 0 ? "" : `\n${c}\n\n`;
+}
+function separatorRow(row) {
+	const cells = Math.max(1, (row.match(/(?<!\\)\|/g)?.length ?? 2) - 1);
+	return `|${" --- |".repeat(cells)}`;
+}
+function wrap(text, marker) {
+	const [, lead, core, trail] = /^(\s*)([\s\S]*?)(\s*)$/.exec(text);
+	return core ? `${lead}${marker}${core}${marker}${trail}` : text;
+}
+function codeFence(lang, code) {
+	const text = code.replace(/\n$/, "");
+	const fence = "`".repeat(Math.max(3, longestRun(text, "`") + 1));
+	return `\n${fence}${lang}\n${text}\n${fence}\n\n`;
+}
+function inlineCode(text) {
+	const fence = "`".repeat(longestRun(text, "`") + 1);
+	const pad = text.startsWith("`") || text.endsWith("`") ? " " : "";
+	return `${fence}${pad}${text}${pad}${fence}`;
+}
+function longestRun(text, char) {
+	let max = 0;
+	let current = 0;
+	for (const c of text) {
+		current = c === char ? current + 1 : 0;
+		if (current > max) max = current;
+	}
+	return max;
+}
+/** from `data-lang` or a `language-*` class name, of the element or its `<code>` child */
+function detectLang(props) {
+	const lang = props["data-lang"] ?? props.lang;
+	if (typeof lang === "string" && lang.length > 0) return lang;
+	const fromClass = (className) => typeof className === "string" ? /(?:^|\s)(?:language|lang)-([\w+#.-]+)/.exec(className)?.[1] : void 0;
+	let out = fromClass(props.className);
+	for (const child of flatten(props.children)) {
+		if (out) break;
+		if (isValidElement(child) && child.type === "code") out = fromClass(child.props.className);
+	}
+	return out ?? "";
+}
+/**
+* Direct children, flattened through arrays and fragments.
+*/
+function flatten(node, out = []) {
+	if (node === null || node === void 0 || typeof node === "boolean") return out;
+	if (isValidElement(node)) {
+		if (typeof node.type === "symbol") flatten(node.props.children, out);
+		else out.push(node);
+	} else if (typeof node === "object" && Symbol.iterator in node) for (const child of node) flatten(child, out);
+	else out.push(node);
+	return out;
+}
+function isClientReference(type) {
+	return (typeof type === "function" || typeof type === "object" && type !== null) && type.$$typeof === CLIENT_REFERENCE;
+}
+function isThenable(value) {
+	return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+//#endregion
+export { asMarkdown, jsxComponents, md, renderRoute, renderToMarkdown };

package/dist/source/dynamic.d.ts

@@ -1,2 +1,2 @@
-import { h as dynamicLoader, m as DynamicLoaderConfig, p as DynamicLoader } from "../index-DQWu2opy.js";
+import { h as dynamicLoader, m as DynamicLoaderConfig, p as DynamicLoader } from "../index-19nHQs6M.js";
 export { DynamicLoader, DynamicLoaderConfig, dynamicLoader };

package/dist/source/index.d.ts

@@ -1,2 +1,2 @@
-import { B as ContentStoragePageFile, C as Meta, D as loader, E as createGetUrl, F as PageTreeBuilderContext, I as PageTreeOptions, L as PageTreeTransformer, O as types_d_exports, P as PageTreeBuilder, R as ContentStorage, S as LoaderPluginOption, T as ResolvedLoaderConfig, V as FileSystem, _ as InferPageType, a as MetaData, b as LoaderOutput, c as SourceUnion, d as multiple, f as update, g as InferMetaType, h as dynamicLoader, i as DynamicSource, j as getSlugs, l as StaticSource, m as DynamicLoaderConfig, n as llms, o as PageData, p as DynamicLoader, r as path_d_exports, s as Source, t as LLMsConfig, u as VirtualFile, v as LoaderConfig, w as Page, x as LoaderPlugin, y as LoaderOptions, z as ContentStorageMetaFile } from "../index-DQWu2opy.js";
+import { B as ContentStoragePageFile, C as Meta, D as loader, E as createGetUrl, F as PageTreeBuilderContext, I as PageTreeOptions, L as PageTreeTransformer, O as types_d_exports, P as PageTreeBuilder, R as ContentStorage, S as LoaderPluginOption, T as ResolvedLoaderConfig, V as FileSystem, _ as InferPageType, a as MetaData, b as LoaderOutput, c as SourceUnion, d as multiple, f as update, g as InferMetaType, h as dynamicLoader, i as DynamicSource, j as getSlugs, l as StaticSource, m as DynamicLoaderConfig, n as llms, o as PageData, p as DynamicLoader, r as path_d_exports, s as Source, t as LLMsConfig, u as VirtualFile, v as LoaderConfig, w as Page, x as LoaderPlugin, y as LoaderOptions, z as ContentStorageMetaFile } from "../index-19nHQs6M.js";
 export { type ContentStorage, type ContentStorageMetaFile, type ContentStoragePageFile, type DynamicLoader, type DynamicLoaderConfig, type DynamicSource, FileSystem, InferMetaType, InferPageType, LLMsConfig, LoaderConfig, LoaderOptions, LoaderOutput, LoaderPlugin, LoaderPluginOption, Meta, type MetaData, Page, type PageData, type PageTreeBuilder, type PageTreeBuilderContext, type PageTreeOptions, type PageTreeTransformer, path_d_exports as PathUtils, ResolvedLoaderConfig, type Source, type SourceUnion, type StaticSource, type VirtualFile, type types_d_exports as _Internal, createGetUrl, dynamicLoader, getSlugs, llms, loader, multiple, update };

package/dist/source/llms.d.ts

@@ -1,2 +1,2 @@
-import { n as llms, t as LLMsConfig } from "../index-DQWu2opy.js";
+import { n as llms, t as LLMsConfig } from "../index-19nHQs6M.js";
 export { LLMsConfig, llms };

package/dist/source/plugins/lucide-icons.d.ts

@@ -1,4 +1,4 @@
-import { x as LoaderPlugin } from "../../index-DQWu2opy.js";
+import { x as LoaderPlugin } from "../../index-19nHQs6M.js";
 import { icons } from "lucide-react";
 //#region src/source/plugins/lucide-icons.d.ts
 /**

package/dist/source/plugins/slugs.d.ts

@@ -1,2 +1,2 @@
-import { A as SlugsPluginOptions, M as slugsFromData, N as slugsPlugin, j as getSlugs, k as SlugFn } from "../../index-DQWu2opy.js";
+import { A as SlugsPluginOptions, M as slugsFromData, N as slugsPlugin, j as getSlugs, k as SlugFn } from "../../index-19nHQs6M.js";
 export { SlugFn, SlugsPluginOptions, getSlugs, slugsFromData, slugsPlugin };

package/dist/source/plugins/status-badges.d.ts

@@ -1,5 +1,5 @@
 import { a as Separator$1, n as Item$1, t as Folder$1 } from "../../definitions-D8-KI7Uy.js";
-import { x as LoaderPlugin } from "../../index-DQWu2opy.js";
+import { x as LoaderPlugin } from "../../index-19nHQs6M.js";
 import { ReactNode } from "react";
 //#region src/source/plugins/status-badges.d.ts
 interface Item extends Item$1 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-core",
-  "version": "16.15.2",
+  "version": "16.15.3",
   "description": "The React.js library for building a documentation website",
   "keywords": [
     "Docs",
@@ -82,6 +82,11 @@
     "./search/orama-cloud": "./dist/search/orama-cloud.js",
     "./search/orama-cloud-legacy": "./dist/search/orama-cloud-legacy.js",
     "./search/server": "./dist/search/server.js",
+    "./server": {
+      "browser": "./dist/server.browser.js",
+      "import": "./dist/server.js"
+    },
+    "./server.browser": "./dist/server.browser.js",
     "./source": "./dist/source/index.js",
     "./source/client": "./dist/source/client/index.js",
     "./source/dynamic": "./dist/source/dynamic.js",