fumadocs-core 16.7.13 → 16.7.15

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

@@ -17,17 +17,7 @@ function remarkImage({ placeholder = "none", external = true, useImport = true,
 	return async (tree, file) => {
 		const importsToInject = [];
 		const promises = [];
-		async function onImage(src, node) {
-			const attributes = [{
-				type: "mdxJsxAttribute",
-				name: "alt",
-				value: node.alt ?? "image"
-			}];
-			if (node.title) attributes.push({
-				type: "mdxJsxAttribute",
-				name: "title",
-				value: node.title
-			});
+		async function updateImage(src, node) {
 			if (src.type === "file" && useImport) {
 				const variableName = `__img${importsToInject.length}`;
 				const hasBlur = placeholder === "blur" && VALID_BLUR_EXT.some((ext) => src.file.endsWith(ext));
@@ -36,31 +26,39 @@ function remarkImage({ placeholder = "none", external = true, useImport = true,
 					variableName,
 					importPath: getImportPath(src.file, file.dirname)
 				});
-				attributes.push({
-					type: "mdxJsxAttribute",
-					name: "src",
-					value: {
-						type: "mdxJsxAttributeValueExpression",
-						value: variableName,
-						data: { estree: {
-							body: [{
-								type: "ExpressionStatement",
-								expression: {
-									type: "Identifier",
-									name: variableName
-								}
-							}],
-							type: "Program",
-							sourceType: "script"
-						} }
-					}
-				});
 				const out = {
 					children: [],
 					type: "mdxJsxFlowElement",
 					name: "img",
-					attributes
+					attributes: [{
+						type: "mdxJsxAttribute",
+						name: "alt",
+						value: node.alt ?? "image"
+					}, {
+						type: "mdxJsxAttribute",
+						name: "src",
+						value: {
+							type: "mdxJsxAttributeValueExpression",
+							value: variableName,
+							data: { estree: {
+								body: [{
+									type: "ExpressionStatement",
+									expression: {
+										type: "Identifier",
+										name: variableName
+									}
+								}],
+								type: "Program",
+								sourceType: "script"
+							} }
+						}
+					}]
 				};
+				if (node.title) out.attributes.push({
+					type: "mdxJsxAttribute",
+					name: "title",
+					value: node.title
+				});
 				if (hasBlur) out.attributes.push({
 					type: "mdxJsxAttribute",
 					name: "placeholder",
@@ -72,41 +70,26 @@ function remarkImage({ placeholder = "none", external = true, useImport = true,
 				throw new Error(`[Remark Image] Failed obtain image size for ${node.url} (public directory configured as ${publicDir})`, { cause: e });
 			});
 			if (!size) return;
-			attributes.push({
-				type: "mdxJsxAttribute",
-				name: "src",
-				value: src.type === "url" ? src.url.toString() : node.url
-			}, {
-				type: "mdxJsxAttribute",
-				name: "width",
-				value: size.width.toString()
-			}, {
-				type: "mdxJsxAttribute",
-				name: "height",
-				value: size.height.toString()
-			});
-			return {
-				type: "mdxJsxFlowElement",
-				name: "img",
-				attributes,
-				children: []
-			};
+			node.data ??= {};
+			node.data.hProperties ??= {};
+			node.data.hProperties.src = src.type === "url" ? src.url.href : node.url;
+			node.data.hProperties.width = size.width.toString();
+			node.data.hProperties.height = size.height.toString();
 		}
-		visit(tree, "image", (node) => {
+		visit(tree, "image", (node, idx, parent) => {
+			if (typeof idx !== "number" || !parent) return;
 			const src = parseSrc(decodeURI(node.url), publicDir, file.dirname);
 			if (!src) return;
-			const task = onImage(src, node).catch((e) => {
+			const task = updateImage(src, node).catch((e) => {
 				if (onError === "ignore" || node.url.endsWith(".svg")) return;
-				if (onError === "hide") return {
-					type: "mdxJsxFlowElement",
-					name: null,
-					attributes: [],
-					children: []
-				};
+				if (onError === "hide") {
+					parent.children.splice(idx, 1);
+					return;
+				}
 				if (onError === "error") throw e;
 				onError(e);
 			}).then((res) => {
-				if (res) Object.assign(node, res);
+				if (res) parent.children[idx] = res;
 			});
 			promises.push(task);
 		});
@@ -175,14 +158,14 @@ function parseSrc(src, publicDir, dir) {
 }
 async function getImageSize(src, onExternal) {
 	if (src.type === "file") {
-		const { imageSizeFromFile } = await import("../fromFile-rjAsJGw3.js");
+		const { imageSizeFromFile } = await import("../fromFile-Fn_3e7Ng.js");
 		return imageSizeFromFile(src.file);
 	}
 	if (onExternal === false) return;
 	const { timeout } = typeof onExternal === "object" ? onExternal : {};
 	const res = await fetch(src.url, { signal: typeof timeout === "number" ? AbortSignal.timeout(timeout) : void 0 });
 	if (!res.ok) throw new Error(`[Remark Image] Failed to fetch ${src.url} (${res.status}): ${await res.text()}`);
-	const { imageSize } = await import("../dist-BvsXWCqT.js");
+	const { imageSize } = await import("../dist-BvM8AIGy.js");
 	return imageSize(new Uint8Array(await res.arrayBuffer()));
 }
 //#endregion

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-4bK9f_wN.js";
+import { n as placeholder, r as remarkLLMs, t as LLMsOptions } from "../remark-llms-Dwjerpo2.js";
 export { LLMsOptions, placeholder, remarkLLMs };

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

@@ -1,5 +1,6 @@
-import { r as toMdxExport } from "../utils-C73VXFR0.js";
+import { i as toMdxExport } from "../utils-pSG8hSr9.js";
 import { defaultStringifier } from "./stringifier.js";
+import { defaultHandlers } from "mdast-util-to-markdown";
 //#region src/mdx-plugins/remark-llms.ts
 /**
 * generate `llms.txt` for markdown.
@@ -23,8 +24,8 @@ function remarkLLMs({ as = "_markdown", headingIds = true, _data = false, mdxAsP
 		handlers: {
 			heading(node, _p, state, info) {
 				const id = node.data?.hProperties?.id;
-				const content = state.containerPhrasing(node, info);
-				return headingIds && id ? `${content} [#${id}]` : content;
+				const defaultValue = defaultHandlers.heading(node, _p, state, info);
+				return headingIds && id ? `${defaultValue} [#${id}]` : defaultValue;
 			},
 			...rest.handlers
 		}

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

@@ -1,4 +1,4 @@
-import { t as Awaitable } from "../types-D8S_yMgI.js";
+import { t as Awaitable } from "../types-RCtxugu0.js";
 
 //#region src/mdx-plugins/remark-llms.runtime.d.ts
 interface PlaceholderData {

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

@@ -1,2 +1,2 @@
-import { a as remarkMdxFiles, i as ToMdxOptions, n as FolderNode, r as RemarkMdxFilesOptions, t as FileNode } from "../remark-mdx-files-Ba1Yf3sk.js";
+import { a as remarkMdxFiles, i as ToMdxOptions, n as FolderNode, r as RemarkMdxFilesOptions, t as FileNode } from "../remark-mdx-files-Cv1mLv9_.js";
 export { FileNode, FolderNode, RemarkMdxFilesOptions, ToMdxOptions, remarkMdxFiles };

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

@@ -1,2 +1,2 @@
-import { n as remarkMdxMermaid, t as RemarkMdxMermaidOptions } from "../remark-mdx-mermaid-DPDDbIZJ.js";
+import { n as remarkMdxMermaid, t as RemarkMdxMermaidOptions } from "../remark-mdx-mermaid-DKj2NHxp.js";
 export { RemarkMdxMermaidOptions, remarkMdxMermaid };

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

@@ -18,9 +18,9 @@ function toMDX(code) {
 function remarkMdxMermaid(options = {}) {
 	const { lang = "mermaid" } = options;
 	return (tree) => {
-		visit(tree, "code", (node) => {
-			if (node.lang !== lang || !node.value) return;
-			Object.assign(node, toMDX(node.value));
+		visit(tree, "code", (node, idx, parent) => {
+			if (node.lang !== lang || !node.value || typeof idx !== "number" || !parent) return;
+			parent.children[idx] = toMDX(node.value);
 		});
 	};
 }

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

@@ -1,2 +1,2 @@
-import { n as remarkNpm, t as RemarkNpmOptions } from "../remark-npm-B7OPb7Ze.js";
+import { n as remarkNpm, t as RemarkNpmOptions } from "../remark-npm-BQkE8_Hf.js";
 export { RemarkNpmOptions, remarkNpm };

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

@@ -1,2 +1,2 @@
-import { t as remarkNpm } from "../remark-npm-DIGXA7E3.js";
+import { t as remarkNpm } from "../remark-npm-BWvHn4O3.js";
 export { remarkNpm };

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

@@ -1,2 +1,2 @@
-import { n as remarkSteps, t as RemarkStepsOptions } from "../remark-steps-PxfBg8ws.js";
+import { n as remarkSteps, t as RemarkStepsOptions } from "../remark-steps-BmZAJIGA.js";
 export { RemarkStepsOptions, remarkSteps };

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

@@ -1,4 +1,4 @@
-import { n as handleTag } from "../utils-C73VXFR0.js";
+import { r as handleTag } from "../utils-pSG8hSr9.js";
 import { visit } from "unist-util-visit";
 //#region src/mdx-plugins/remark-steps.ts
 const StepRegex = /^(\d+)\.\s(.+)$/;

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

@@ -1,2 +1,2 @@
-import { a as defaultStringifier, c as structure, i as StructuredData, n as StringifyOptions, o as remarkStructure, r as StructureOptions, s as remarkStructureDefaultOptions, t as Stringifier } from "../remark-structure-DLKk-p9t.js";
+import { a as defaultStringifier, c as structure, i as StructuredData, n as StringifyOptions, o as remarkStructure, r as StructureOptions, s as remarkStructureDefaultOptions, t as Stringifier } from "../remark-structure-BxbC5Buc.js";
 export { Stringifier, StringifyOptions, StructureOptions, StructuredData, defaultStringifier, remarkStructure, remarkStructureDefaultOptions, structure };

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

@@ -1,4 +1,4 @@
-import { r as toMdxExport } from "../utils-C73VXFR0.js";
+import { i as toMdxExport } from "../utils-pSG8hSr9.js";
 import { remarkHeading } from "./remark-heading.js";
 import { defaultStringifier as defaultStringifier$1 } from "./stringifier.js";
 import { remark } from "remark";

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

@@ -1,2 +1,2 @@
-import { n as StringifyOptions, r as defaultStringifier, t as Stringifier } from "../stringifier-D6T4zhkn.js";
+import { n as StringifyOptions, r as defaultStringifier, t as Stringifier } from "../stringifier-B2PmymrT.js";
 export { Stringifier, StringifyOptions, defaultStringifier };

package/dist/negotiation/index.js

@@ -1,2 +1,2 @@
-import { n as isMarkdownPreferred, r as rewritePath, t as getNegotiator } from "../negotiation-CMIpYwJJ.js";
+import { n as isMarkdownPreferred, r as rewritePath, t as getNegotiator } from "../negotiation-BdxTpPs1.js";
 export { getNegotiator, isMarkdownPreferred, rewritePath };

package/dist/page-tree/index.d.ts

@@ -1,3 +1,3 @@
-import { a as Separator, i as Root, n as Item, r as Node, t as Folder } from "../definitions-DH0vdUJV.js";
-import { a as flattenTree, c as visit, i as findSiblings, n as findParent, o as getPageTreePeers, r as findPath, s as getPageTreeRoots, t as findNeighbour } from "../index-C4kyQCbj.js";
+import { a as Separator, i as Root, n as Item, r as Node, t as Folder } from "../definitions-57FFofI9.js";
+import { a as flattenTree, c as visit, i as findSiblings, n as findParent, o as getPageTreePeers, r as findPath, s as getPageTreeRoots, t as findNeighbour } from "../index-B518t-3i.js";
 export { Folder, Item, Node, Root, Separator, findNeighbour, findParent, findPath, findSiblings, flattenTree, getPageTreePeers, getPageTreeRoots, visit };

package/dist/{rehype-code-BceXtwzN.d.ts → rehype-code-DJKXLHtp.d.ts}

@@ -1,4 +1,4 @@
-import { t as RehypeCodeOptionsCommon } from "./rehype-code.core-DfJelVqH.js";
+import { t as RehypeCodeOptionsCommon } from "./rehype-code.core-Cg1anr4H.js";
 import * as _$unified from "unified";
 import * as _$hast from "hast";
 

package/dist/rehype-code.core-Cg1anr4H.d.ts

@@ -0,0 +1,124 @@
+import { t as Awaitable } from "./types-RCtxugu0.js";
+import { n as ShikiFactory } from "./index-DxyTmDjY.js";
+import { Processor, Transformer } from "unified";
+import { Element, Root } from "hast";
+import { BuiltinLanguage, BuiltinTheme, CodeOptionsMeta, CodeOptionsThemes, CodeToHastOptionsCommon, HighlighterCore, LanguageInput, ShikiTransformer, TransformerOptions } from "shiki";
+
+//#region src/mdx-plugins/rehype-code/parsers.d.ts
+type InlineCodeParser = 'tailing-curly-colon';
+//#endregion
+//#region src/mdx-plugins/rehype-code/shiki.d.ts
+interface MapLike<K = unknown, V = unknown> {
+  get: (key: K) => V | undefined;
+  set: (key: K, value: V) => this;
+}
+interface RehypeShikiExtraOptions {
+  /**
+   * Add `language-*` class to code element
+   *
+   * @default false
+   */
+  addLanguageClass?: boolean;
+  /**
+   * The default language to use when is not specified
+   */
+  defaultLanguage?: string;
+  /**
+   * The fallback language to use when specified language is not loaded, or not included in the bundle
+   */
+  fallbackLanguage?: string;
+  /**
+   * Load languages and themes on-demand.
+   *
+   * @default true
+   */
+  lazy?: boolean;
+  /**
+   * `mdast-util-to-hast` adds a newline to the end of code blocks
+   *
+   * This option strips that newline from the code block
+   *
+   * @default true
+   * @see https://github.com/syntax-tree/mdast-util-to-hast/blob/f511a93817b131fb73419bf7d24d73a5b8b0f0c2/lib/handlers/code.js#L22
+   */
+  stripEndNewline?: boolean;
+  /**
+   * Custom meta string parser
+   * Return an object to merge with `meta`
+   */
+  parseMetaString?: (metaString: string, node: Element, tree: Root) => Record<string, unknown> | undefined | null;
+  /**
+   * Filter meta string before processing
+   */
+  filterMetaString?: (metaString: string) => string;
+  /**
+   * Highlight inline code blocks
+   *
+   * - `false`: disable inline code block highlighting
+   * - `tailing-curly-colon`: highlight with `\`code{:lang}\``
+   *
+   * @see https://shiki.style/packages/rehype#inline-code
+   * @default false
+   */
+  inline?: InlineCodeParser | false;
+  /**
+   * Custom map to cache transformed codeToHast result
+   *
+   * @default undefined
+   */
+  cache?: MapLike<string, Root>;
+  /**
+   * Chance to handle the error
+   * If not provided, the error will be thrown
+   */
+  onError?: (error: unknown) => void;
+}
+type RehypeShikiCoreOptions = CodeOptionsThemes<BuiltinTheme> & TransformerOptions & CodeOptionsMeta & RehypeShikiExtraOptions & Omit<CodeToHastOptionsCommon, 'lang'>;
+//#endregion
+//#region src/mdx-plugins/transformer-icon.d.ts
+type CodeBlockIcon = {
+  viewBox: string;
+  fill: string;
+  d: string;
+} | string;
+interface IconOptions {
+  shortcuts?: Record<string, string>;
+  extend?: Record<string, CodeBlockIcon>;
+}
+/**
+ * Inject icons to `icon` property (as HTML)
+ */
+declare function transformerIcon(options?: IconOptions): ShikiTransformer;
+//#endregion
+//#region src/mdx-plugins/rehype-code.core.d.ts
+declare function rehypeCodeDefaultOptions(): RehypeCodeOptionsCommon;
+type RehypeCodeOptionsCommon = RehypeShikiCoreOptions & {
+  /**
+   * Language names to include.
+   *
+   * @default Object.keys(bundledLanguages)
+   */
+  langs?: Array<LanguageInput | BuiltinLanguage>;
+  /**
+   * Alias of languages
+   * @example { 'my-lang': 'javascript' }
+   */
+  langAlias?: Record<string, string>;
+  /**
+   * Add icon to code blocks
+   */
+  icon?: IconOptions | false;
+  /**
+   * Wrap code blocks in `<Tab>` component when "tab" meta string presents
+   *
+   * @defaultValue true
+   */
+  tab?: boolean;
+};
+declare function createRehypeCode<Options extends Partial<RehypeCodeOptionsCommon> = Partial<RehypeCodeOptionsCommon>>(highlighterFactory: ShikiFactory | ((options?: Options) => Awaitable<{
+  highlighter: HighlighterCore;
+  options: RehypeCodeOptionsCommon;
+}>)): (this: Processor, _options?: Options) => Transformer<Root, Root>;
+declare function transformerTab(): ShikiTransformer;
+//#endregion
+export { CodeBlockIcon as a, transformerTab as i, createRehypeCode as n, transformerIcon as o, rehypeCodeDefaultOptions as r, RehypeCodeOptionsCommon as t };

package/dist/{rehype-code.core-B9asBGBz.js → rehype-code.core-Ckq2nRUU.js}

@@ -1,7 +1,110 @@
-import { n as defaultThemes, r as getRequiredThemes } from "./utils-CLsGsTYQ.js";
+import { n as flattenNodeHast } from "./utils-pSG8hSr9.js";
+import { n as defaultThemes, r as getRequiredThemes } from "./utils-tAukrbtB.js";
 import { parseCodeBlockAttributes } from "./mdx-plugins/codeblock-utils.js";
-import rehypeShikiFromHighlighter from "@shikijs/rehype/core";
+import { visit } from "unist-util-visit";
+import { isSpecialLang } from "shiki/core";
 import { transformerNotationDiff, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from "@shikijs/transformers";
+//#region src/mdx-plugins/rehype-code/parsers.ts
+const RE_TAILING_CURLY_COLON = /(.+)\{:([\w-]+)\}$/;
+const InlineCodeParsers = { "tailing-curly-colon": (_tree, node) => {
+	const raw = flattenNodeHast(node);
+	const match = raw.match(RE_TAILING_CURLY_COLON);
+	if (!match) return;
+	return {
+		type: "inline",
+		code: match[1] ?? raw,
+		lang: match.at(2)
+	};
+} };
+const languagePrefix = "language-";
+const PreParser = (_tree, node) => {
+	const head = node.children[0];
+	if (!head || head.type !== "element" || head.tagName !== "code" || !head.properties) return;
+	const classes = head.properties.className;
+	const languageClass = Array.isArray(classes) ? classes.find((d) => typeof d === "string" && d.startsWith(languagePrefix)) : void 0;
+	return {
+		type: "pre",
+		lang: typeof languageClass === "string" ? languageClass.slice(9) : void 0,
+		code: flattenNodeHast(head),
+		meta: head.data?.meta ?? head.properties.metastring?.toString() ?? ""
+	};
+};
+//#endregion
+//#region src/mdx-plugins/rehype-code/shiki.ts
+function rehypeShikiFromHighlighter(highlighter, options) {
+	const { addLanguageClass = false, parseMetaString, filterMetaString, cache, defaultLanguage, fallbackLanguage, onError, stripEndNewline = true, inline = false, lazy = false, ...rest } = options;
+	function highlight(lang, code, metaString = "", tree, node) {
+		if (filterMetaString) metaString = filterMetaString(metaString);
+		const cacheKey = `${lang}:${metaString}:${code}`;
+		const cachedValue = cache?.get(cacheKey);
+		if (cachedValue) return cachedValue;
+		const codeOptions = {
+			...rest,
+			lang,
+			meta: {
+				...rest.meta,
+				__raw: metaString,
+				...parseMetaString?.(metaString, node, tree)
+			}
+		};
+		if (addLanguageClass) codeOptions.transformers = [...codeOptions.transformers ?? [], {
+			name: "rehype-shiki:code-language-class",
+			code(node) {
+				this.addClassToHast(node, `language-${lang}`);
+				return node;
+			}
+		}];
+		if (stripEndNewline && code.endsWith("\n")) code = code.slice(0, -1);
+		try {
+			const fragment = highlighter.codeToHast(code, codeOptions);
+			cache?.set(cacheKey, fragment);
+			return fragment;
+		} catch (error) {
+			if (onError) onError(error);
+			else throw error;
+		}
+	}
+	function isLanguageLoaded(lang) {
+		return isSpecialLang(lang) || highlighter.getLoadedLanguages().includes(lang);
+	}
+	async function onNode(tree, node, parsed) {
+		let lang = parsed.lang ?? defaultLanguage;
+		if (!lang) return;
+		if (!isLanguageLoaded(lang)) {
+			if (lazy && lang in highlighter.getBundledLanguages()) await highlighter.loadLanguage(lang);
+			else if (fallbackLanguage) {
+				lang = fallbackLanguage;
+				if (!isLanguageLoaded(fallbackLanguage)) await highlighter.loadLanguage(fallbackLanguage);
+			}
+		}
+		const fragment = highlight(lang, parsed.code, parsed.meta, tree, node);
+		if (!fragment) return;
+		if (parsed.type === "inline") {
+			const head = fragment.children[0];
+			if (head.type === "element" && head.tagName === "pre") head.tagName = "span";
+		}
+		return fragment;
+	}
+	return async (tree) => {
+		const queue = [];
+		visit(tree, "element", (node, index, parent) => {
+			let parsed;
+			if (!parent || index == null) return;
+			if (node.tagName === "pre") parsed = PreParser(tree, node);
+			else if (node.tagName === "code" && inline) parsed = InlineCodeParsers[inline](tree, node);
+			if (!parsed) return "skip";
+			queue.push(onNode(tree, node, parsed).then((fragment) => {
+				if (fragment) parent.children[index] = fragment;
+			}).catch((error) => {
+				if (onError) onError(error);
+				else throw error;
+			}));
+			return "skip";
+		});
+		if (queue.length > 0) await Promise.all(queue);
+	};
+}
+//#endregion
 //#region src/mdx-plugins/transformer-icon.ts
 const defaultShortcuts = {
 	js: "javascript",
@@ -162,7 +265,7 @@ function rehypeCodeDefaultOptions() {
 			const parsed = parseCodeBlockAttributes(meta, ["title", "tab"]);
 			const data = parsed.attributes;
 			parsed.rest = parseLineNumber(parsed.rest, data);
-			data.__parsed_raw = parsed.rest;
+			data.__raw = parsed.rest;
 			return data;
 		}
 	};
@@ -187,17 +290,6 @@ function createRehypeCode(highlighterFactory) {
 			options = _options ?? {};
 		}
 		const transformers = options.transformers ? [...options.transformers] : [];
-		transformers.unshift({
-			name: "rehype-code:pre-process",
-			preprocess(code, { meta }) {
-				if (meta && "__parsed_raw" in meta) {
-					meta.__raw = meta.__parsed_raw;
-					delete meta.__parsed_raw;
-				}
-				if (meta && options.filterMetaString) meta.__raw = options.filterMetaString(meta.__raw ?? "");
-				return code.replace(/\n$/, "");
-			}
-		});
 		if (options.icon !== false) transformers.push(transformerIcon(options.icon));
 		if (options.tab !== false) transformers.push(transformerTab());
 		const langs = options.langs ?? (options.lazy ? [

package/dist/remark-code-tab-BC5W5GqG.d.ts

@@ -0,0 +1,31 @@
+import { Processor, Transformer } from "unified";
+import { Root } from "mdast";
+
+//#region src/mdx-plugins/remark-code-tab.d.ts
+type TabType = 'CodeBlockTabs' | 'Tabs';
+interface RemarkCodeTabOptions {
+  Tabs?: TabType;
+  /**
+   * Parse MDX in tab values
+   *
+   * @defaultValue false
+   */
+  parseMdx?: boolean;
+}
+declare module 'mdast' {
+  interface CodeData {
+    /**
+     * [Fumadocs: remark-code-tab] the associated tab value
+     */
+    tab?: string;
+  }
+  interface Data {
+    /**
+     * [Fumadocs: remark-code-tab] internal
+     */
+    _code_tab_visited?: true;
+  }
+}
+declare function remarkCodeTab(this: Processor, options?: RemarkCodeTabOptions): Transformer<Root, Root>;
+//#endregion
+export { remarkCodeTab as n, RemarkCodeTabOptions as t };

package/dist/{remark-heading-C3ZesmHL.d.ts → remark-heading-DJvYcq64.d.ts}

@@ -1,4 +1,4 @@
-import { c as TOCItemType } from "./toc-DXlLlbv_.js";
+import { c as TOCItemType } from "./toc-CZK90oS5.js";
 import { Transformer } from "unified";
 import { Heading, Root } from "mdast";
 

package/dist/{remark-llms-4bK9f_wN.d.ts → remark-llms-Dwjerpo2.d.ts}

@@ -1,4 +1,4 @@
-import { n as StringifyOptions } from "./stringifier-D6T4zhkn.js";
+import { n as StringifyOptions } from "./stringifier-B2PmymrT.js";
 import { MdxJsxFlowElement, MdxJsxTextElement } from "mdast-util-mdx";
 import { Info, State } from "mdast-util-to-markdown";
 import { Processor, Transformer } from "unified";

package/dist/{remark-npm-DIGXA7E3.js → remark-npm-BWvHn4O3.js}

@@ -530,33 +530,44 @@ function convert(str, to) {
 }
 //#endregion
 //#region src/mdx-plugins/remark-npm.ts
-const aliases = ["npm", "package-install"];
+function convertLines(cmd, to) {
+	return cmd.split("\n").map((l) => convert(l, to)).join("\n");
+}
 /**
 * It generates multiple tabs of codeblocks for different package managers from a npm command codeblock.
 */
 function remarkNpm({ persist = false, packageManagers = [
 	{
-		command: (cmd) => convert(cmd, "npm"),
+		command: (cmd) => cmd,
 		name: "npm"
 	},
 	{
-		command: (cmd) => convert(cmd, "pnpm"),
+		command: (cmd) => convertLines(cmd, "pnpm"),
 		name: "pnpm"
 	},
 	{
-		command: (cmd) => convert(cmd, "yarn"),
+		command: (cmd) => convertLines(cmd, "yarn"),
 		name: "yarn"
 	},
 	{
-		command: (cmd) => convert(cmd, "bun"),
+		command: (cmd) => convertLines(cmd, "bun"),
 		name: "bun"
 	}
 ] } = {}) {
 	return (tree) => {
-		visit(tree, "code", (node) => {
-			if (!node.lang || !aliases.includes(node.lang)) return;
-			let code = node.value;
-			if (node.lang === "package-install" && !code.startsWith("npm") && !code.startsWith("npx")) code = `npm install ${code}`;
+		visit(tree, "code", (node, idx, parent) => {
+			if (typeof idx !== "number" || !parent) return;
+			let code;
+			switch (node.lang) {
+				case "package-install":
+					code = node.value;
+					if (!code.startsWith("npm") && !code.startsWith("npx")) code = `npm install ${code}`;
+					break;
+				case "npm":
+					code = node.value;
+					break;
+				default: return;
+			}
 			const options = {
 				persist,
 				tabs: [],
@@ -584,7 +595,7 @@ function remarkNpm({ persist = false, packageManagers = [
 					}]
 				});
 			}
-			Object.assign(node, generateCodeBlockTabs(options));
+			parent.children[idx] = generateCodeBlockTabs(options);
 			return "skip";
 		});
 	};

package/dist/{remark-structure-DLKk-p9t.d.ts → remark-structure-BxbC5Buc.d.ts}

@@ -1,4 +1,4 @@
-import { n as StringifyOptions$1, t as Stringifier$1 } from "./stringifier-D6T4zhkn.js";
+import { n as StringifyOptions$1, t as Stringifier$1 } from "./stringifier-B2PmymrT.js";
 import { MdxJsxAttribute, MdxJsxExpressionAttribute, MdxJsxFlowElement, MdxJsxTextElement } from "mdast-util-mdx";
 import { PluggableList, Processor, Transformer } from "unified";
 import { Nodes, Root } from "mdast";

package/dist/search/algolia.d.ts

@@ -1,2 +1,2 @@
-import { a as sync, i as setIndexSettings, n as DocumentRecord, o as updateDocuments, r as SyncOptions, t as BaseIndex } from "../algolia-DphIPKrc.js";
+import { a as sync, i as setIndexSettings, n as DocumentRecord, o as updateDocuments, r as SyncOptions, t as BaseIndex } from "../algolia-ZyQLVdey.js";
 export { BaseIndex, DocumentRecord, SyncOptions, setIndexSettings, sync, updateDocuments };

package/dist/search/client/algolia.d.ts

@@ -1,2 +1,2 @@
-import { m as algoliaClient, p as AlgoliaOptions } from "../../client-D3PZ2z2N.js";
+import { m as algoliaClient, p as AlgoliaOptions } from "../../client-BRJhJ58c.js";
 export { AlgoliaOptions, algoliaClient };