fumadocs-core 16.5.4 → 16.6.0

package/dist/{advanced-3GdE_Q4d.js → advanced-ZOIuXvBJ.js}

@@ -15,9 +15,8 @@ async function searchSimple(db, query, params = {}) {
 		}
 	})).hits.map((hit) => ({
 		type: "page",
-		content: hit.document.title,
+		content: highlighter.highlightMarkdown(hit.document.title),
 		breadcrumbs: hit.document.breadcrumbs,
-		contentWithHighlights: highlighter.highlight(hit.document.title),
 		id: hit.document.url,
 		url: hit.document.url
 	}));
@@ -27,24 +26,24 @@ async function searchSimple(db, query, params = {}) {
 //#region src/search/orama/search/advanced.ts
 async function searchAdvanced(db, query, tag = [], { mode = "fulltext", ...override } = {}) {
 	if (typeof tag === "string") tag = [tag];
-	let params = {
+	const params = {
 		...override,
 		mode,
 		where: removeUndefined({
 			tags: tag.length > 0 ? { containsAll: tag } : void 0,
 			...override.where
 		}),
+		limit: 10,
 		groupBy: {
 			properties: ["page_id"],
 			maxResult: 8,
 			...override.groupBy
 		}
 	};
-	if (query.length > 0) params = {
-		...params,
+	if (query.length > 0) Object.assign(params, {
 		term: query,
 		properties: mode === "fulltext" ? ["content"] : ["content", "embeddings"]
-	};
+	});
 	const highlighter = createContentHighlighter(query);
 	const result = await search(db, params);
 	const list = [];
@@ -55,24 +54,22 @@ async function searchAdvanced(db, query, tag = [], { mode = "fulltext", ...overr
 		list.push({
 			id: pageId,
 			type: "page",
-			content: page.content,
+			content: highlighter.highlightMarkdown(page.content),
 			breadcrumbs: page.breadcrumbs,
-			contentWithHighlights: highlighter.highlight(page.content),
 			url: page.url
 		});
 		for (const hit of item.result) {
 			if (hit.document.type === "page") continue;
 			list.push({
 				id: hit.document.id.toString(),
-				content: hit.document.content,
+				content: highlighter.highlightMarkdown(hit.document.content),
 				breadcrumbs: hit.document.breadcrumbs,
-				contentWithHighlights: highlighter.highlight(hit.document.content),
 				type: hit.document.type,
 				url: hit.document.url
 			});
 		}
 	}
-	return list;
+	return list.length > 80 ? list.slice(0, 80) : list;
 }
 
 //#endregion

package/dist/{algolia-Cx9CqUgE.js → algolia-CfKKhsrI.js}

@@ -38,7 +38,7 @@ async function searchDocs(query, { indexName, onSearch, client, locale, tag }) {
 	return groupResults(result.results[0].hits).flatMap((hit) => {
 		if (hit.type === "page") return {
 			...hit,
-			contentWithHighlights: hit.contentWithHighlights ?? highlighter.highlight(hit.content)
+			content: highlighter.highlightMarkdown(hit.content)
 		};
 		return [];
 	});

package/dist/content/md.d.ts

@@ -0,0 +1,30 @@
+import * as react from "react";
+import { FC } from "react";
+import { Options } from "remark-rehype";
+import { Compatible } from "vfile";
+import { Components } from "hast-util-to-jsx-runtime";
+import { PluggableList } from "unified";
+
+//#region src/content/md.d.ts
+interface MarkdownRendererOptions {
+  remarkPlugins?: PluggableList;
+  rehypePlugins?: PluggableList;
+  remarkRehypeOptions?: Options;
+}
+interface MarkdownRenderer {
+  Markdown: FC<MarkdownProps>;
+  MarkdownServer: FC<Omit<MarkdownProps, 'async'>>;
+}
+interface MarkdownProps {
+  async?: boolean;
+  components?: Components;
+  children: Compatible;
+}
+declare function createMarkdownRenderer({
+  rehypePlugins,
+  remarkPlugins,
+  remarkRehypeOptions
+}?: MarkdownRendererOptions): MarkdownRenderer;
+declare function Markdown(props: MarkdownProps & MarkdownRendererOptions): react.ReactNode | Promise<react.ReactNode>;
+//#endregion
+export { Markdown, MarkdownProps, MarkdownRenderer, MarkdownRendererOptions, createMarkdownRenderer };

package/dist/content/md.js

@@ -0,0 +1,47 @@
+import { use } from "react";
+import * as JsxRuntime from "react/jsx-runtime";
+import { remark } from "remark";
+import remarkRehype from "remark-rehype";
+import { VFile } from "vfile";
+import { toJsxRuntime } from "hast-util-to-jsx-runtime";
+
+//#region src/content/md.ts
+function createMarkdownRenderer({ rehypePlugins = [], remarkPlugins = [], remarkRehypeOptions } = {}) {
+	const processor = remark().use(remarkPlugins).use(remarkRehype, remarkRehypeOptions).use(rehypePlugins);
+	const cache = {};
+	const promises = {};
+	function render(tree, file, props) {
+		return toJsxRuntime(tree, {
+			development: false,
+			filePath: file.path,
+			components: props.components,
+			...JsxRuntime
+		});
+	}
+	function parse(file, _props) {
+		return processor.parse(file);
+	}
+	return {
+		Markdown(props) {
+			const { async = false, children } = props;
+			const file = new VFile(children);
+			const key = String(file.value);
+			if (async) {
+				promises[key] ??= processor.run(parse(file, props), file);
+				return render(use(promises[key]), file, props);
+			}
+			cache[key] ??= processor.runSync(parse(file, props), file);
+			return render(cache[key], file, props);
+		},
+		async MarkdownServer(props) {
+			const file = new VFile(props.children);
+			return render(await processor.run(parse(file, props), file), file, props);
+		}
+	};
+}
+function Markdown(props) {
+	return createMarkdownRenderer(props).MarkdownServer(props);
+}
+
+//#endregion
+export { Markdown, createMarkdownRenderer };

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

@@ -3,7 +3,7 @@ import { r as transformerIcon, t as CodeBlockIcon } from "../transformer-icon-C8
 import { transformerTab } from "./rehype-code.core.js";
 import { RehypeCodeOptions, rehypeCode, rehypeCodeDefaultOptions } from "./rehype-code.js";
 import { RemarkImageOptions, remarkImage } from "./remark-image.js";
-import { StructureOptions, StructuredData, defaultStringify, remarkStructure, remarkStructureDefaultOptions, structure } from "./remark-structure.js";
+import { StringifyOptions, StructureOptions, StructuredData, defaultStringifier, remarkStructure, remarkStructureDefaultOptions, structure } from "./remark-structure.js";
 import { RemarkHeadingOptions, remarkHeading } from "./remark-heading.js";
 import { RemarkAdmonitionOptions, remarkAdmonition } from "./remark-admonition.js";
 import { RemarkDirectiveAdmonitionOptions, remarkDirectiveAdmonition } from "./remark-directive-admonition.js";
@@ -15,4 +15,4 @@ import { CodeBlockAttributes, CodeBlockTabsOptions, generateCodeBlockTabs, parse
 import { RemarkMdxFilesOptions, remarkMdxFiles } from "./remark-mdx-files.js";
 import { RemarkMdxMermaidOptions, remarkMdxMermaid } from "./remark-mdx-mermaid.js";
 import { FeedbackBlockProps, RemarkFeedbackBlockOptions, remarkFeedbackBlock } from "./remark-feedback-block.js";
-export { CodeBlockAttributes, CodeBlockIcon, CodeBlockTabsOptions, FeedbackBlockProps, RehypeCodeOptions, RehypeTocOptions, RemarkAdmonitionOptions, RemarkCodeTabOptions, RemarkDirectiveAdmonitionOptions, RemarkFeedbackBlockOptions, RemarkGfmOptions, RemarkHeadingOptions, RemarkImageOptions, type RemarkMdxFilesOptions, RemarkMdxMermaidOptions, RemarkNpmOptions, RemarkStepsOptions, StructureOptions, StructuredData, defaultStringify, generateCodeBlockTabs, parseCodeBlockAttributes, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkCodeTab, remarkDirectiveAdmonition, remarkFeedbackBlock, remarkGfm, remarkHeading, remarkImage, remarkMdxFiles, remarkMdxMermaid, remarkNpm, remarkSteps, remarkStructure, remarkStructureDefaultOptions, structure, transformerIcon, transformerTab };
+export { CodeBlockAttributes, CodeBlockIcon, CodeBlockTabsOptions, FeedbackBlockProps, RehypeCodeOptions, RehypeTocOptions, RemarkAdmonitionOptions, RemarkCodeTabOptions, RemarkDirectiveAdmonitionOptions, RemarkFeedbackBlockOptions, RemarkGfmOptions, RemarkHeadingOptions, RemarkImageOptions, type RemarkMdxFilesOptions, RemarkMdxMermaidOptions, RemarkNpmOptions, RemarkStepsOptions, 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/index.js

@@ -6,7 +6,7 @@ import { t as transformerIcon } from "../transformer-icon-BYedaeE8.js";
 import { transformerTab } from "./rehype-code.core.js";
 import { rehypeCode, rehypeCodeDefaultOptions } from "./rehype-code.js";
 import { remarkImage } from "./remark-image.js";
-import { defaultStringify, remarkStructure, remarkStructureDefaultOptions, structure } from "./remark-structure.js";
+import { defaultStringifier, remarkStructure, remarkStructureDefaultOptions, structure } from "./remark-structure.js";
 import { remarkAdmonition } from "./remark-admonition.js";
 import { remarkDirectiveAdmonition } from "./remark-directive-admonition.js";
 import { rehypeToc } from "./rehype-toc.js";
@@ -17,4 +17,4 @@ import { remarkMdxFiles } from "./remark-mdx-files.js";
 import { remarkMdxMermaid } from "./remark-mdx-mermaid.js";
 import { remarkFeedbackBlock } from "./remark-feedback-block.js";
 
-export { defaultStringify, generateCodeBlockTabs, parseCodeBlockAttributes, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkCodeTab, remarkDirectiveAdmonition, remarkFeedbackBlock, remarkGfm, remarkHeading, remarkImage, remarkMdxFiles, remarkMdxMermaid, remarkNpm, remarkSteps, remarkStructure, remarkStructureDefaultOptions, structure, transformerIcon, transformerTab };
+export { 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-feedback-block.d.ts

@@ -16,7 +16,7 @@ interface RemarkFeedbackBlockOptions {
   /**
    * determine how the node should be resolved into a feedback block.
    *
-   * scan paragraph, list, and image nodes by default.
+   * default: skip MDX elements, convert paragraph, list item, and image nodes.
    *
    * @returns
    * - `true`: convert the node into a feedback block.

package/dist/mdx-plugins/remark-feedback-block.js

@@ -8,16 +8,24 @@ import { createHash } from "node:crypto";
 *
 * Note: the uniqueness is only guaranteed per MDX file/page.
 */
-function remarkFeedbackBlock({ generateHash = ({ body }) => createHash("md5").update(body).digest("hex").substring(0, 16), tagName = "FeedbackBlock", resolve = (node) => node.type === "paragraph" || node.type === "image" || node.type === "list", generateBody = true } = {}) {
+function remarkFeedbackBlock({ generateHash = ({ body }) => createHash("md5").update(body).digest("hex").substring(0, 16), tagName = "FeedbackBlock", resolve = (node) => {
+	switch (node.type) {
+		case "mdxJsxFlowElement": return "skip";
+		case "paragraph":
+		case "image":
+		case "listItem": return true;
+		default: return false;
+	}
+}, generateBody = true } = {}) {
 	return (tree) => {
 		const counts = /* @__PURE__ */ new Map();
 		visit(tree, (node, index, parent) => {
-			if (node.type === "root") return;
+			if (node.type === "root" || !parent || typeof index !== "number") return;
 			const resolved = resolve(node);
 			if (resolved === false) return;
 			if (resolved === "skip") return "skip";
 			const text = flattenNode(node).trim();
-			if (text.length === 0 || !parent || typeof index !== "number") return;
+			if (text.length === 0) return;
 			let id = generateHash({ body: text });
 			const count = counts.get(id) ?? 0;
 			if (count > 0) id = `${id}-${count}`;

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

@@ -4,49 +4,80 @@ import { Nodes, Root } from "mdast";
 import { MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement } from "mdast-util-mdx";
 
 //#region src/mdx-plugins/remark-structure.d.ts
-interface Heading$1 {
+interface StructuredDataHeading {
   id: string;
   content: string;
 }
-interface Content {
+interface StructuredDataContent {
   heading: string | undefined;
   content: string;
 }
 interface StructuredData {
-  headings: Heading$1[];
+  headings: StructuredDataHeading[];
   /**
    * Refer to paragraphs, a heading may contain multiple contents as well
    */
-  contents: Content[];
+  contents: StructuredDataContent[];
+}
+type Stringifier = (this: Processor, node: Nodes, ctx: StringifierContext) => string;
+interface StringifierContext {
+  addContent: (...content: StructuredDataContent[]) => void;
 }
 interface StringifyOptions {
   /**
-   * Determine whether the element itself should be stringified in content block, only stringify its attributes & children if `false`.
+   * Filter the elements to be included in the output:
+   *
+   * - `true`: include element & its children.
+   * - `children-only`: exclude element but keep its children.
+   * - `false`: exclude element & its children.
+   *
+   * Default:
+   *
+   * ```ts
+   * filterElement = (node) => {
+   *   switch (node.type) {
+   *     case 'mdxJsxFlowElement':
+   *     case 'mdxJsxTextElement':
+   *       switch (node.name) {
+   *         case 'File':
+   *         case 'TypeTable':
+   *         case 'Callout':
+   *         case 'Card':
+   *           return true;
+   *       }
+   *       return 'children-only';
+   *   }
    *
-   * Always return `false` by default.
+   *   return true;
+   * },
+   * ```
+   */
+  filterElement?: (node: Nodes) => boolean | 'children-only';
+  /**
+   * Filter the attributes to stringify.
    */
-  filterMdxElements?: (node: MdxJsxFlowElement | MdxJsxTextElement) => boolean;
   filterMdxAttributes?: (node: MdxJsxFlowElement | MdxJsxTextElement, attribute: MdxJsxAttribute | MdxJsxExpressionAttribute) => boolean;
 }
-interface StructureOptions extends Omit<StringifyOptions, 'filterMdxAttributes'> {
+interface StructureOptions {
   /**
    * MDAST node types to be scanned as a content block.
    *
-   * If a node's type represents in this array, it will be converted into a single content block.
+   * If a node's type is listed in this array, it will be converted into a single content block.
    *
    * @defaultValue ['heading', 'paragraph', 'blockquote', 'tableCell', 'mdxJsxFlowElement']
    */
   types?: string[] | ((node: Nodes) => boolean);
   /**
-   * stringify a given node & its children, you can use something like `mdast-util-to-markdown`.
+   * stringify text content from a MDAST node.
    */
-  stringify?: (this: Processor, node: Nodes) => string;
+  stringify?: Stringifier | StringifyOptions;
   /**
-   * By default, it will not index MDX attributes. You can define a list of MDX attributes to index, either:
+   * Whether the MDX element should be treated as a single content block, only effective if `types` has `mdxJsxFlowElement`.
    *
-   * - an array of attribute names.
-   * - a function that determines if attribute should be indexed.
+   * Default: return `true` if the element is a leaf node, otherwise `false`.
    */
+  mdxTypes?: (node: MdxJsxFlowElement | MdxJsxTextElement) => boolean;
+  /** @deprecated use `stringify.filterMdxAttributes` instead */
   allowedMdxAttributes?: string[] | ((node: MdxJsxFlowElement | MdxJsxTextElement, attribute: MdxJsxAttribute | MdxJsxExpressionAttribute) => boolean);
   /**
    * export as `structuredData` (if true) or specified variable name.
@@ -56,21 +87,28 @@ interface StructureOptions extends Omit<StringifyOptions, 'filterMdxAttributes'>
 declare module 'mdast' {
   interface Data {
     /**
-     * [Fumadocs] Stringified form of node, `remarkStructure` uses it to generate search index.
+     * [Fumadocs: remark-structure] The stringified form of node for generating search index.
+     */
+    _string?: string | (() => string);
+    /**
+     * [Fumadocs: remark-structure] Items to add to the structured data.
      */
-    _string?: string[];
+    structuredData?: {
+      contents: StructuredDataContent[];
+    };
   }
 }
 declare module 'vfile' {
   interface DataMap {
     /**
-     * [Fumadocs] injected by `remarkStructure`
+     * [Fumadocs: remark-structure] output data.
      */
     structuredData: StructuredData;
   }
 }
 declare const remarkStructureDefaultOptions: {
   types: string[];
+  mdxTypes(node: MdxJsxFlowElement | MdxJsxTextElement): boolean;
   exportAs: false;
 };
 /**
@@ -80,15 +118,15 @@ declare const remarkStructureDefaultOptions: {
  */
 declare function remarkStructure(this: Processor, {
   types,
-  stringify,
+  mdxTypes,
+  stringify: stringifyOptions,
   allowedMdxAttributes,
-  exportAs,
-  ...stringifyOptions
+  exportAs
 }?: StructureOptions): Transformer<Root, Root>;
 /**
  * Extract data from markdown/mdx content
  */
 declare function structure(content: string, remarkPlugins?: PluggableList, options?: StructureOptions): StructuredData;
-declare function defaultStringify(config?: Options & StringifyOptions): (this: Processor, node: Nodes) => string;
+declare function defaultStringifier(config?: Options & StringifyOptions): Stringifier;
 //#endregion
-export { StructureOptions, StructuredData, defaultStringify, remarkStructure, remarkStructureDefaultOptions, structure };
+export { StringifyOptions, StructureOptions, StructuredData, defaultStringifier, remarkStructure, remarkStructureDefaultOptions, structure };

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

@@ -1,8 +1,8 @@
-import { n as toMdxExport, t as flattenNode } from "../mdast-utils-gJMY143g.js";
+import { n as toMdxExport } from "../mdast-utils-gJMY143g.js";
 import { remarkHeading } from "./remark-heading.js";
 import { remark } from "remark";
-import remarkGfm from "remark-gfm";
 import { visit } from "unist-util-visit";
+import remarkGfm from "remark-gfm";
 import { toMarkdown } from "mdast-util-to-markdown";
 
 //#region src/mdx-plugins/remark-structure.ts
@@ -14,6 +14,9 @@ const remarkStructureDefaultOptions = {
 		"tableCell",
 		"mdxJsxFlowElement"
 	],
+	mdxTypes(node) {
+		return node.children.length === 0;
+	},
 	exportAs: false
 };
 /**
@@ -21,17 +24,13 @@ const remarkStructureDefaultOptions = {
 *
 * By default, the output is stored into VFile (`vfile.data.structuredData`), you can specify `exportAs` to export it.
 */
-function remarkStructure({ types = remarkStructureDefaultOptions.types, stringify, allowedMdxAttributes, exportAs = remarkStructureDefaultOptions.exportAs, ...stringifyOptions } = {}) {
-	if (Array.isArray(allowedMdxAttributes)) {
-		const arr = allowedMdxAttributes;
-		allowedMdxAttributes = (_node, attribute) => attribute.type === "mdxJsxAttribute" && arr.includes(attribute.name);
-	}
+function remarkStructure({ types = remarkStructureDefaultOptions.types, mdxTypes = remarkStructureDefaultOptions.mdxTypes, stringify: stringifyOptions, allowedMdxAttributes, exportAs = remarkStructureDefaultOptions.exportAs } = {}) {
 	if (Array.isArray(types)) {
 		const arr = types;
 		types = (node) => arr.includes(node.type);
 	}
-	stringify ??= defaultStringify({
-		filterMdxAttributes: allowedMdxAttributes,
+	const stringify = typeof stringifyOptions === "function" ? stringifyOptions : defaultStringifier({
+		filterMdxAttributes: Array.isArray(allowedMdxAttributes) ? (_node, attribute) => attribute.type === "mdxJsxAttribute" && allowedMdxAttributes.includes(attribute.name) : allowedMdxAttributes,
 		...stringifyOptions
 	});
 	return (tree, file) => {
@@ -47,24 +46,38 @@ function remarkStructure({ types = remarkStructureDefaultOptions.types, stringif
 				data.contents.push(...frontmatter._openapi.structuredData.contents);
 			}
 		}
+		const stringifierCtx = { addContent(...content) {
+			for (const item of content) data.contents.push({
+				...item,
+				heading: item.heading ?? lastHeading
+			});
+		} };
 		visit(tree, (element) => {
-			if (element.type === "root" || !types(element)) return;
-			if (element.type === "heading") {
-				element.data ||= {};
-				element.data.hProperties ||= {};
-				const id = element.data.hProperties.id;
-				if (typeof id !== "string") {
-					console.warn("[remark-structure] hProperties.id is missing in heading node, it is required to generate heading data. You can add remark-heading prior to remark-structure to generate heading IDs.");
+			if (!types(element)) return;
+			switch (element.type) {
+				case "root": return;
+				case "mdxJsxFlowElement":
+				case "mdxJsxTextElement":
+					if (!mdxTypes(element)) return;
+					break;
+				case "heading": {
+					element.data ||= {};
+					element.data.hProperties ||= {};
+					const id = element.data.hProperties.id;
+					if (typeof id !== "string") {
+						console.warn("[remark-structure] hProperties.id is missing in heading node, it is required to generate heading data. You can add remark-heading prior to remark-structure to generate heading IDs.");
+						return "skip";
+					}
+					const content = stringify.call(this, element, stringifierCtx).trim();
+					if (content.length > 0) data.headings.push({
+						id,
+						content
+					});
+					lastHeading = id;
 					return "skip";
 				}
-				data.headings.push({
-					id,
-					content: flattenNode(element).trim()
-				});
-				lastHeading = id;
-				return "skip";
 			}
-			const content = stringify.call(this, element).trim();
+			const content = stringify.call(this, element, stringifierCtx).trim();
 			if (content.length > 0) data.contents.push({
 				heading: lastHeading,
 				content
@@ -81,57 +94,81 @@ function remarkStructure({ types = remarkStructureDefaultOptions.types, stringif
 function structure(content, remarkPlugins = [], options = {}) {
 	return remark().use(remarkGfm).use(remarkPlugins).use(remarkHeading).use(remarkStructure, options).processSync(content).data.structuredData;
 }
-function defaultStringify(config = {}) {
-	const { filterMdxAttributes = (node) => {
-		switch (node.name) {
-			case "TypeTable":
-			case "Callout": return true;
-			default: return false;
+function defaultStringifier(config = {}) {
+	const { filterMdxAttributes, filterElement = (node) => {
+		switch (node.type) {
+			case "mdxJsxFlowElement":
+			case "mdxJsxTextElement":
+				switch (node.name) {
+					case "File":
+					case "TypeTable":
+					case "Callout":
+					case "Card": return true;
+				}
+				return "children-only";
 		}
-	}, filterMdxElements = () => false } = config;
-	function modHandler(handler) {
-		return function(node, ...rest) {
-			if (node.data?._string) return node.data._string.join("\n");
+		return true;
+	} } = config;
+	function modHandler(handler, ctx) {
+		return function(node, parent, state, info) {
+			const { structuredData, _string } = node.data ?? {};
+			if (structuredData) ctx.addContent(...structuredData.contents);
+			if (_string) return typeof _string === "function" ? _string() : _string;
+			const visibility = filterElement(node);
+			if (visibility === false) return "";
 			switch (node.type) {
 				case "mdxJsxFlowElement":
 				case "mdxJsxTextElement": {
-					const filteredAttributes = node.attributes.filter((attr) => filterMdxAttributes(node, attr));
-					if (!filterMdxElements(node)) {
-						let attrStr = "";
-						for (const attr of filteredAttributes) {
-							const str = typeof attr.value === "string" ? attr.value : attr.value?.value;
-							if (!str) continue;
-							attrStr += attr.type === "mdxJsxAttribute" ? `(${attr.name}=${str}) ` : `(${str}) `;
-						}
-						if (node.children.length === 0) return attrStr.trimEnd();
-						return attrStr + rest[1].handle({
-							type: "root",
-							children: node.children
-						}, ...rest);
+					if (visibility === "children-only") return node.type === "mdxJsxTextElement" ? state.containerPhrasing(node, info) : state.containerFlow(node, info);
+					const stringifiedAttributes = [];
+					for (const attr of node.attributes) {
+						if (attr.type === "mdxJsxExpressionAttribute") continue;
+						if (filterMdxAttributes && !filterMdxAttributes(node, attr)) continue;
+						const str = typeof attr.value === "string" ? attr.value : attr.value?.value;
+						if (!str) continue;
+						stringifiedAttributes.push({
+							...attr,
+							value: str
+						});
 					}
 					const temp = node.attributes;
-					node.attributes = filteredAttributes;
-					const s = handler(node, ...rest);
+					node.attributes = stringifiedAttributes;
+					const s = handler(node, parent, state, info);
 					node.attributes = temp;
 					return s;
 				}
-				default: return handler(node, ...rest);
+				default:
+					if (visibility === "children-only") return "children" in node ? state.containerFlow({
+						type: "root",
+						children: node.children
+					}, info) : "";
+					return handler(node, parent, state, info);
 			}
 		};
 	}
 	const handlers = {
-		...config.handlers,
+		link(node, _, state, info) {
+			return state.containerPhrasing(node, info);
+		},
+		heading(node, _, state, info) {
+			return state.containerPhrasing(node, info);
+		},
+		image() {
+			return "";
+		},
 		_custom(node, _, state, info) {
 			const handlers = state.handlers;
-			for (const k in handlers) handlers[k] = modHandler(handlers[k]);
+			for (const k in handlers) handlers[k] = modHandler(handlers[k], node.ctx);
 			return state.handle(node.root, void 0, state, info);
-		}
+		},
+		...config.handlers
 	};
-	return function(root) {
+	return function(root, ctx) {
 		const defaultExtensions = this.data("toMarkdownExtensions") ?? [];
 		return toMarkdown({
 			type: "_custom",
-			root
+			root,
+			ctx
 		}, {
 			...this.data("settings"),
 			...config,
@@ -142,4 +179,4 @@ function defaultStringify(config = {}) {
 }
 
 //#endregion
-export { defaultStringify, remarkStructure, remarkStructureDefaultOptions, structure };
+export { defaultStringifier, remarkStructure, remarkStructureDefaultOptions, structure };

package/dist/{orama-cloud-CmYuZkvC.js → orama-cloud-cgTJNLo0.js}

@@ -23,23 +23,22 @@ async function searchDocs(query, options) {
 			list.push({
 				id: hit.id,
 				type: "page",
-				content: doc.title,
-				contentWithHighlights: highlighter.highlight(doc.title),
+				content: highlighter.highlightMarkdown(doc.title),
 				url: doc.path
 			}, {
 				id: "page" + hit.id,
 				type: "text",
-				content: doc.content,
-				contentWithHighlights: highlighter.highlight(doc.content),
+				content: highlighter.highlightMarkdown(doc.content),
 				url: doc.path
 			});
 		}
 		return list;
 	}
-	const params = {
+	const result = await client.search({
 		datasources: [],
 		...extraParams,
 		term: query,
+		limit: 10,
 		where: removeUndefined({
 			tag,
 			...extraParams?.where
@@ -49,8 +48,7 @@ async function searchDocs(query, options) {
 			max_results: 7,
 			...extraParams?.groupBy
 		}
-	};
-	const result = await client.search(params);
+	});
 	if (!result || !result.groups) return list;
 	for (const item of result.groups) {
 		let addedHead = false;
@@ -60,23 +58,21 @@ async function searchDocs(query, options) {
 				list.push({
 					id: doc.page_id,
 					type: "page",
-					content: doc.title,
+					content: highlighter.highlightMarkdown(doc.title),
 					breadcrumbs: doc.breadcrumbs,
-					contentWithHighlights: highlighter.highlight(doc.title),
 					url: doc.url
 				});
 				addedHead = true;
 			}
 			list.push({
 				id: doc.id,
-				content: doc.content,
-				contentWithHighlights: highlighter.highlight(doc.content),
+				content: highlighter.highlightMarkdown(doc.content),
 				type: doc.content === doc.section ? "heading" : "text",
 				url: doc.section_id ? `${doc.url}#${doc.section_id}` : doc.url
 			});
 		}
 	}
-	return list;
+	return list.length > 80 ? list.slice(0, 80) : list;
 }
 
 //#endregion

package/dist/{orama-cloud-legacy-D-cNaYCM.js → orama-cloud-legacy-Caf8mcU9.js}

@@ -22,14 +22,12 @@ async function searchDocs(query, options) {
 			list.push({
 				id: hit.id,
 				type: "page",
-				content: doc.title,
-				contentWithHighlights: highlighter.highlight(doc.title),
+				content: highlighter.highlightMarkdown(doc.title),
 				url: doc.path
 			}, {
 				id: "page" + hit.id,
 				type: "text",
-				content: doc.content,
-				contentWithHighlights: highlighter.highlight(doc.content),
+				content: highlighter.highlightMarkdown(doc.content),
 				url: doc.path
 			});
 		}
@@ -58,17 +56,15 @@ async function searchDocs(query, options) {
 				list.push({
 					id: doc.page_id,
 					type: "page",
-					content: doc.title,
+					content: highlighter.highlightMarkdown(doc.title),
 					breadcrumbs: doc.breadcrumbs,
-					contentWithHighlights: highlighter.highlight(doc.title),
 					url: doc.url
 				});
 				addedHead = true;
 			}
 			list.push({
 				id: doc.id,
-				content: doc.content,
-				contentWithHighlights: highlighter.highlight(doc.content),
+				content: highlighter.highlightMarkdown(doc.content),
 				type: doc.content === doc.section ? "heading" : "text",
 				url: doc.section_id ? `${doc.url}#${doc.section_id}` : doc.url
 			});

package/dist/search/client.js

@@ -58,15 +58,15 @@ function useDocsSearch(clientOptions, deps) {
 					return fetchDocs(debouncedValue, client);
 				}
 				case "algolia": {
-					const { searchDocs } = await import("../algolia-Cx9CqUgE.js");
+					const { searchDocs } = await import("../algolia-CfKKhsrI.js");
 					return searchDocs(debouncedValue, client);
 				}
 				case "orama-cloud": {
-					const { searchDocs } = await import("../orama-cloud-CmYuZkvC.js");
+					const { searchDocs } = await import("../orama-cloud-cgTJNLo0.js");
 					return searchDocs(debouncedValue, client);
 				}
 				case "orama-cloud-legacy": {
-					const { searchDocs } = await import("../orama-cloud-legacy-D-cNaYCM.js");
+					const { searchDocs } = await import("../orama-cloud-legacy-Caf8mcU9.js");
 					return searchDocs(debouncedValue, client);
 				}
 				case "mixedbread": {
@@ -74,7 +74,7 @@ function useDocsSearch(clientOptions, deps) {
 					return search(debouncedValue, client);
 				}
 				case "static": {
-					const { search } = await import("../static-BQOJvapl.js");
+					const { search } = await import("../static-BUXJwBmr.js");
 					return search(debouncedValue, client);
 				}
 				default: throw new Error("unknown search client");

package/dist/search/index.d.ts

@@ -10,6 +10,9 @@ interface SortedResult<Content = string> {
    * breadcrumbs to be displayed on UI
    */
   breadcrumbs?: Content[];
+  /**
+   * @deprecated it is now included in `content` as Markdown using `<mark />`.
+   */
   contentWithHighlights?: HighlightedText<Content>[];
 }
 type ReactSortedResult = SortedResult<ReactNode>;
@@ -22,6 +25,10 @@ interface HighlightedText<Content = string> {
 }
 declare function createContentHighlighter(query: string | RegExp): {
   highlight(content: string): HighlightedText[];
+  /**
+   * @param content - Markdown, it assumes the content is already sanitized & safe, no escape is performed.
+   */
+  highlightMarkdown(content: string): string;
 };
 //#endregion
 export { HighlightedText, ReactSortedResult, SortedResult, createContentHighlighter };

package/dist/search/index.js

@@ -1,3 +1,6 @@
+import { remark } from "remark";
+import { visit } from "unist-util-visit";
+
 //#region src/search/index.ts
 function escapeRegExp(input) {
 	return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -11,32 +14,57 @@ function buildRegexFromQuery(q) {
 	return new RegExp(`(${escaped})`, "gi");
 }
 function createContentHighlighter(query) {
+	let processor = remark();
 	const regex = typeof query === "string" ? buildRegexFromQuery(query) : query;
-	return { highlight(content) {
-		if (!regex) return [{
-			type: "text",
-			content
-		}];
-		const out = [];
-		let i = 0;
-		for (const match of content.matchAll(regex)) {
-			if (i < match.index) out.push({
+	if (regex) processor = processor.use(remarkHighlight, regex);
+	return {
+		highlight(content) {
+			if (!regex) return [{
 				type: "text",
-				content: content.substring(i, match.index)
-			});
-			out.push({
+				content
+			}];
+			const out = [];
+			let i = 0;
+			for (const match of content.matchAll(regex)) {
+				if (i < match.index) out.push({
+					type: "text",
+					content: content.substring(i, match.index)
+				});
+				out.push({
+					type: "text",
+					content: match[0],
+					styles: { highlight: true }
+				});
+				i = match.index + match[0].length;
+			}
+			if (i < content.length) out.push({
 				type: "text",
-				content: match[0],
-				styles: { highlight: true }
+				content: content.substring(i)
 			});
-			i = match.index + match[0].length;
+			return out;
+		},
+		highlightMarkdown(content) {
+			if (!regex) return content;
+			return String(processor.processSync(content).value);
 		}
-		if (i < content.length) out.push({
-			type: "text",
-			content: content.substring(i)
+	};
+}
+function remarkHighlight(regex) {
+	return (tree) => {
+		visit(tree, "text", (node) => {
+			let out = "";
+			const content = node.value;
+			let i = 0;
+			for (const match of content.matchAll(regex)) {
+				if (i < match.index) out += content.substring(i, match.index);
+				out += `<mark>${match[0]}</mark>`;
+				i = match.index + match[0].length;
+			}
+			if (i < content.length) out += content.substring(i);
+			node.type = "html";
+			node.value = out;
 		});
-		return out;
-	} };
+	};
 }
 
 //#endregion

package/dist/search/server.js

@@ -1,7 +1,7 @@
 import { r as findPath } from "../utils-Bc53B3CJ.js";
 import { createContentHighlighter } from "./index.js";
 import { t as createEndpoint } from "../create-endpoint-9PZc4Cmz.js";
-import { n as searchSimple, t as searchAdvanced } from "../advanced-3GdE_Q4d.js";
+import { n as searchSimple, t as searchAdvanced } from "../advanced-ZOIuXvBJ.js";
 import { r as extname, t as basename } from "../path-CfJghBXy.js";
 import { create, insertMultiple, save } from "@orama/orama";
 
@@ -187,6 +187,7 @@ const STEMMERS = {
 	tamil: "ta",
 	turkish: "tr",
 	ukrainian: "uk",
+	vietnamese: "vi",
 	sanskrit: "sk"
 };
 

package/dist/{static-BQOJvapl.js → static-BUXJwBmr.js}

@@ -1,4 +1,4 @@
-import { n as searchSimple, t as searchAdvanced } from "./advanced-3GdE_Q4d.js";
+import { n as searchSimple, t as searchAdvanced } from "./advanced-ZOIuXvBJ.js";
 import { create, load } from "@orama/orama";
 
 //#region src/search/client/static.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-core",
-  "version": "16.5.4",
+  "version": "16.6.0",
   "description": "The React.js library for building a documentation website",
   "keywords": [
     "Docs",
@@ -24,8 +24,8 @@
       "import": "./dist/toc.js"
     },
     "./content": {
-      "types": "./dist/content/index.d.ts",
-      "import": "./dist/content/index.js"
+      "types": "./dist/content/md.d.ts",
+      "import": "./dist/content/md.js"
     },
     "./content/*": {
       "types": "./dist/content/*.d.ts",
@@ -242,7 +242,7 @@
   "scripts": {
     "build": "tsdown",
     "clean": "rimraf dist",
-    "dev": "tsdown --watch",
+    "dev": "tsdown --watch --clean false",
     "lint": "eslint .",
     "types:check": "tsc --noEmit"
   }

package/dist/content/index.d.ts

@@ -1,22 +0,0 @@
-import * as react from "react";
-import { ReactNode } from "react";
-import { Components } from "hast-util-to-jsx-runtime";
-import { Compatible } from "vfile";
-import { PluggableList } from "unified";
-
-//#region src/content/index.d.ts
-interface MarkdownProps {
-  components?: Components;
-}
-declare function Markdown({
-  children: content,
-  remarkPlugins,
-  rehypePlugins,
-  ...options
-}: MarkdownProps & {
-  remarkPlugins?: PluggableList;
-  rehypePlugins?: PluggableList;
-  children: Compatible;
-}): Promise<react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | (string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined)>;
-//#endregion
-export { Markdown, MarkdownProps };

package/dist/content/index.js

@@ -1,23 +0,0 @@
-import * as JsxRuntime from "react/jsx-runtime";
-import { remark } from "remark";
-import remarkGfm from "remark-gfm";
-import remarkRehype from "remark-rehype";
-import { toJsxRuntime } from "hast-util-to-jsx-runtime";
-
-//#region src/content/index.ts
-function rehypeReact(options = {}) {
-	this.compiler = (tree, file) => {
-		return toJsxRuntime(tree, {
-			development: false,
-			filePath: file.path,
-			...JsxRuntime,
-			...options
-		});
-	};
-}
-async function Markdown({ children: content, remarkPlugins = [], rehypePlugins = [], ...options }) {
-	return (await remark().use(remarkGfm).use(remarkPlugins).use(remarkRehype).use(rehypePlugins).use(rehypeReact, options).process(content)).result;
-}
-
-//#endregion
-export { Markdown };