fumadocs-core 16.15.1 → 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/i18n/middleware.js

@@ -1,4 +1,3 @@
-import { t as getNegotiator } from "../negotiation-DAsKgSvF.js";
 import { NextResponse } from "next/server.js";
 //#region ../../node_modules/.pnpm/@formatjs+fast-memoize@3.1.7/node_modules/@formatjs/fast-memoize/index.js
 function memoize(fn, options) {
@@ -3738,6 +3737,70 @@ function match(requestedLocales, availableLocales, defaultLocale, opts) {
 	return ResolveLocale(availableLocales, CanonicalizeLocaleList(requestedLocales), { localeMatcher: opts?.algorithm || "best fit" }, [], {}, () => defaultLocale).locale;
 }
 //#endregion
+//#region src/utils/accept-language.ts
+function parseAcceptLanguage(header) {
+	const specs = [];
+	for (const section of header.split(",")) {
+		const [rawTag, ...params] = section.split(";");
+		const full = rawTag.trim().toLowerCase();
+		if (full.length === 0) continue;
+		let quality = 1;
+		for (const param of params) {
+			const separator = param.indexOf("=");
+			if (separator === -1 || param.slice(0, separator).trim().toLowerCase() !== "q") continue;
+			const parsed = Number.parseFloat(param.slice(separator + 1));
+			if (!Number.isNaN(parsed)) quality = parsed;
+		}
+		const dash = full.indexOf("-");
+		specs.push({
+			prefix: dash === -1 ? full : full.slice(0, dash),
+			full,
+			quality,
+			order: specs.length
+		});
+	}
+	return specs;
+}
+function matchLanguage(language, specs) {
+	const full = language.trim().toLowerCase();
+	const dash = full.indexOf("-");
+	const prefix = dash === -1 ? full : full.slice(0, dash);
+	const best = {
+		language,
+		quality: 0,
+		specificity: 0,
+		order: -1
+	};
+	for (const spec of specs) {
+		let specificity;
+		if (spec.full === full) specificity = 4;
+		else if (spec.prefix === full) specificity = 2;
+		else if (spec.full === prefix) specificity = 1;
+		else if (spec.full === "*") specificity = 0;
+		else continue;
+		if ((specificity - best.specificity || spec.quality - best.quality || spec.order - best.order) > 0) {
+			best.quality = spec.quality;
+			best.specificity = specificity;
+			best.order = spec.order;
+		}
+	}
+	if (best.quality > 0) return best;
+}
+/**
+* Filter `available` down to the languages the `Accept-Language` header accepts, ordered by
+* client preference. A missing (`null`) header accepts everything.
+*/
+function negotiateLanguages(header, available) {
+	const specs = parseAcceptLanguage(header ?? "*");
+	const matches = [];
+	for (const language of available) {
+		const match = matchLanguage(language, specs);
+		if (match) matches.push(match);
+	}
+	matches.sort((a, b) => b.quality - a.quality || b.specificity - a.specificity || a.order - b.order);
+	return matches.map((match) => match.language);
+}
+//#endregion
 //#region src/i18n/middleware.ts
 const DefaultFormatter = {
 	get(url) {
@@ -3773,7 +3836,7 @@ function createI18nMiddleware({ languages, defaultLanguage, format = DefaultForm
 		if (pathLocale && !languages.includes(pathLocale)) pathLocale = void 0;
 		if (!pathLocale) {
 			if (hideLocale === "default-locale") return NextResponse.rewrite(formatter.add(url, defaultLanguage));
-			const preferred = match(getNegotiator(request).languages(languages), languages, defaultLanguage);
+			const preferred = match(negotiateLanguages(request.headers.get("accept-language"), languages), languages, defaultLanguage);
 			if (hideLocale === "always") {
 				const locale = request.cookies.get(cookieName)?.value ?? preferred;
 				return NextResponse.rewrite(formatter.add(url, locale));

package/dist/{index-DQWu2opy2.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/negotiation/index.d.ts

@@ -1,6 +1,4 @@
-import Negotiator from "negotiator";
 //#region src/negotiation/index.d.ts
-declare function getNegotiator(request: Request): Negotiator;
 /**
  * Rewrite incoming path matching the `source` pattern into the `destination` pattern.
  *
@@ -16,4 +14,4 @@ declare function isMarkdownPreferred(request: Request, options?: {
   markdownMediaTypes?: string[];
 }): boolean;
 //#endregion
-export { getNegotiator, isMarkdownPreferred, rewritePath };
+export { isMarkdownPreferred, rewritePath };