fumadocs-core 16.17.7 → 16.17.8

package/dist/{algolia-nI8K-5gY.d.ts → algolia-NG5vCx7r.d.ts}

@@ -1,6 +1,6 @@
-import { t as Awaitable } from "./types-D89QoQR-.js";
+import { t as Awaitable } from "./types-D1vp9AYr.js";
 import { n as StructuredData } from "./remark-structure-C4hp7I5L.js";
-import { S as LoaderOutput, b as LoaderConfig } from "./index-B0I6yRlw.js";
+import { S as LoaderOutput, b as LoaderConfig } from "./index-DNo8LS3A.js";
 import { Algoliasearch } from "algoliasearch";
 //#region src/search/algolia.d.ts
 interface DocumentRecord {

package/dist/breadcrumb.d.ts

@@ -1,4 +1,4 @@
-import { i as Root, o as definitions_d_exports, r as Node, t as Folder } from "./definitions-BZlqdyOx.js";
+import { i as Root, r as Node, t as Folder } from "./definitions-CFOhwE1k.js";
 import { ReactNode } from "react";
 //#region src/breadcrumb.d.ts
 export interface BreadcrumbItem {

package/dist/{build-index-Bxu0jldy.js → build-index-a5ygCRBZ.js}

@@ -1,4 +1,4 @@
-import { r as extname, t as basename } from "./path-m9Srg2Jq.js";
+import { r as extname, t as basename } from "./path-UUoiuLiY.js";
 //#region src/search/server/build-index.ts
 async function buildIndexDefault(page) {
 	let structuredData;

package/dist/{client-aul0_BWr.d.ts → client-BAj2KxA7.d.ts}

@@ -1,7 +1,7 @@
-import { t as Awaitable } from "./types-D89QoQR-.js";
+import { t as Awaitable } from "./types-D1vp9AYr.js";
 import { r as SortedResult } from "./index-BbTxYEFm.js";
-import { t as BaseIndex } from "./algolia-nI8K-5gY.js";
-import "./mixedbread-y5oWDuHL.js";
+import { t as BaseIndex } from "./algolia-NG5vCx7r.js";
+import "./mixedbread-2VnWtXx5.js";
 import { DependencyList } from "react";
 import { AnyZBSearch, SearchParams } from "zbsearch";
 import { Root } from "hast";

package/dist/content/md/frontmatter.d.ts

@@ -11,4 +11,5 @@ interface Output {
  * parse frontmatter, it supports only yaml format
  */
 export declare function frontmatter(input: string): Output;
-//#endregion
+//#endregion
+export {};

package/dist/content/md.d.ts

@@ -1,7 +1,7 @@
+import { t as Components } from "../hast-to-jsx-CgR__kSX.js";
 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
 export interface MarkdownRendererOptions {
@@ -15,7 +15,7 @@ export interface MarkdownRenderer {
 }
 export interface MarkdownProps {
   async?: boolean;
-  components?: Components;
+  components?: Partial<Components>;
   children: Compatible;
 }
 export declare function createMarkdownRenderer({ rehypePlugins, remarkPlugins, remarkRehypeOptions }?: MarkdownRendererOptions): MarkdownRenderer;

package/dist/content/md.js

@@ -1,21 +1,12 @@
+import { toJsx } from "../utils/hast-to-jsx.js";
 import { use, useMemo } 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 promises = {};
-	function render(tree, file, props) {
-		return toJsxRuntime(tree, {
-			development: false,
-			filePath: file.path,
-			components: props.components,
-			...JsxRuntime
-		});
-	}
 	function parse(file) {
 		return processor.parse(file);
 	}
@@ -26,13 +17,15 @@ function createMarkdownRenderer({ rehypePlugins = [], remarkPlugins = [], remark
 			const id = `${file.path}:${file.value}`;
 			if (async) {
 				promises[id] ??= processor.run(parse(file), file);
-				return render(use(promises[id]), file, props);
+				const out = use(promises[id]);
+				return toJsx(out, { components: props.components });
 			}
-			return render(useMemo(() => processor.runSync(parse(file), file), [id]), file, props);
+			const v = useMemo(() => processor.runSync(parse(file), file), [id]);
+			return toJsx(v, { components: props.components });
 		},
 		async MarkdownServer(props) {
 			const file = new VFile(props.children);
-			return render(await processor.run(parse(file), file), file, props);
+			return toJsx(await processor.run(parse(file), file), { components: props.components });
 		}
 	};
 }

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

@@ -1,10 +1,10 @@
-import { t as RehypeCodeOptions } from "../../rehype-code-CGahijs1.js";
+import { t as RehypeCodeOptions } from "../../rehype-code-BVf0Uz2w.js";
 import { t as RemarkImageOptions } from "../../remark-image-BI2S9LOb.js";
 import { t as StructureOptions } from "../../remark-structure-C4hp7I5L.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 { t as index_d_exports } from "../../index-B-xgXq2T.js";
+import "../../index-Cr-WMmZN.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

@@ -1,10 +1,10 @@
-import { t as RehypeCodeOptions } from "../../rehype-code-CGahijs1.js";
+import { t as RehypeCodeOptions } from "../../rehype-code-BVf0Uz2w.js";
 import { t as RemarkImageOptions } from "../../remark-image-BI2S9LOb.js";
 import { t as StructureOptions } from "../../remark-structure-C4hp7I5L.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 { t as index_d_exports } from "../../index-B-xgXq2T.js";
+import "../../index-Cr-WMmZN.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/{definitions-BZlqdyOx.d.ts → definitions-CFOhwE1k.d.ts}

@@ -1,7 +1,5 @@
 import { ReactNode } from "react";
-declare namespace definitions_d_exports {
-  export { Folder, Item, Node, Root, Separator };
-}
+//#region src/page-tree/definitions.d.ts
 interface ID {
   /**
    * ID for the node, unique in all page trees (even across different locales)
@@ -71,4 +69,4 @@ interface Folder extends ID {
   children: Node[];
 }
 //#endregion
-export { Separator as a, Root as i, Item as n, definitions_d_exports as o, Node as r, Folder as t };
+export { Separator as a, Root as i, Item as n, Node as r, Folder as t };

package/dist/{dynamic-1an9p9Sx.js → dynamic-CymQi8F2.js}

@@ -1,7 +1,7 @@
 import { r as normalizeUrl } from "./url-BVHvi3_K.js";
 import { l as visit } from "./utils-DEVq3cEC.js";
 import { t as isEqualShallow } from "./is-equal-LdLqRs0o.js";
-import { a as normalize, i as joinPath, n as dirname, r as extname, t as basename } from "./path-m9Srg2Jq.js";
+import { a as normalize, i as joinPath, n as dirname, r as extname, t as basename } from "./path-UUoiuLiY.js";
 import { slugsPlugin } from "./source/plugins/slugs.js";
 import { t as iconPlugin } from "./icon-BILaoXeg.js";
 import { cache } from "react";

package/dist/framework/astro.d.ts

@@ -17,4 +17,5 @@ export interface AstroProviderProps {
  * You can pass `navigate` from `astro:transitions/client` to preserve client navigation.
  */
 export declare function AstroProvider({ children, pathname, params, navigate, Link, Image }: AstroProviderProps): import("react").JSX.Element;
-//#endregion
+//#endregion
+export {};

package/dist/framework/index.d.ts

@@ -36,4 +36,5 @@ export declare function useRouter(): Router;
 export declare function useParams(): Record<string, string | string[]>;
 export declare function Image(props: ImageProps): import("react").JSX.Element;
 export declare function Link(props: LinkProps): import("react").JSX.Element;
-//#endregion
+//#endregion
+export {};

package/dist/hast-to-jsx-CgR__kSX.d.ts

@@ -0,0 +1,21 @@
+import { ComponentType, JSX, ReactNode } from "react";
+import { Nodes } from "hast";
+import { Expression, Program } from "estree-jsx";
+//#region src/utils/hast-to-jsx.d.ts
+type Components = { [Tag in keyof JSX.IntrinsicElements]: ComponentType<JSX.IntrinsicElements[Tag]> | keyof JSX.IntrinsicElements; };
+/** Turns the ESTree of MDX nodes into values. */
+interface Evaluator {
+  evaluateExpression: (expression: Expression) => unknown;
+  evaluateProgram: (program: Program) => unknown;
+}
+interface ToJsxOptions {
+  components?: Partial<Components>;
+  /** Required by MDX expressions, ESM, and JSX elements with expressions or capitalized names. */
+  evaluator?: Evaluator;
+}
+/**
+ * Convert hast, with MDX nodes, into React elements like `toJsxRuntime()` from `hast-util-to-jsx-runtime`, but faster.
+ */
+declare function toJsx(tree: Nodes, { components, evaluator }?: ToJsxOptions): ReactNode;
+//#endregion
+export { toJsx as i, Evaluator as n, ToJsxOptions as r, Components as t };

package/dist/highlight/client.d.ts

@@ -1,4 +1,4 @@
-import { HighlightOptions } from "./index.js";
+import { r as HighlightOptions } from "../index-Bf_V9OZJ.js";
 import { DependencyList, ReactNode } from "react";
 //#region src/highlight/client.d.ts
 /**

package/dist/highlight/client.js

@@ -1,5 +1,5 @@
 "use client";
-import { t as applyDefaultThemes } from "../utils-Cgs-6U-z.js";
+import { i as applyDefaultThemes } from "../shiki-DzWiTQMz.js";
 import { useShiki as useShiki$1 } from "./shiki/react.js";
 import { defaultShikiFactory } from "./shiki/full.js";
 //#region src/highlight/client.ts

package/dist/highlight/highlights.d.ts

@@ -0,0 +1,25 @@
+import { i as Highlighter } from "../index-Bf_V9OZJ.js";
+import { Theme } from "@pierre/highlights";
+import { ShikiTransformer } from "shiki";
+//#region src/highlight/highlights.d.ts
+export interface HighlightsOptions {
+  /**
+   * Themes from `@pierre/highlights/themes`, like `{ light: githubLight, dark: githubDark }`.
+   *
+   * @defaultValue GitHub Light and GitHub Dark
+   */
+  themes?: Record<string, Theme>;
+  /**
+   * Shiki transformers, run on the tokens of Highlights as a compatibility layer.
+   */
+  shikiTransformers?: ShikiTransformer[];
+}
+export interface HighlightsHighlighter extends Highlighter {
+  /** Create a highlighter with `options` in place of its own, like other Shiki transformers. */
+  override: (options: HighlightsOptions) => HighlightsHighlighter;
+}
+/**
+ * A highlighter using `@pierre/highlights`, its languages are built in.
+ */
+export declare function createHighlights(highlightsOptions?: HighlightsOptions): HighlightsHighlighter;
+//#endregion

package/dist/highlight/highlights.js

@@ -0,0 +1,219 @@
+import { codeToTokens, isSupportedLanguage } from "@pierre/highlights";
+import githubLight from "@pierre/highlights/themes/github-light";
+import githubDark from "@pierre/highlights/themes/github-dark";
+//#region src/highlight/highlights.ts
+/**
+* A highlighter using `@pierre/highlights`, its languages are built in.
+*/
+function createHighlights(highlightsOptions = {}) {
+	const { themes = {
+		light: githubLight,
+		dark: githubDark
+	}, shikiTransformers = [] } = highlightsOptions;
+	const themeIds = {};
+	for (const [key, theme] of Object.entries(themes)) themeIds[key] = theme.name.toLowerCase().replaceAll(" ", "-");
+	const themeName = `shiki-themes ${Object.values(themeIds).join(" ")}`;
+	function tokenize(code, lang) {
+		return {
+			...codeToTokens(code, {
+				lang: isSupportedLanguage(lang) ? lang : "text",
+				themes,
+				defaultColor: false,
+				cssVariablePrefix: "--shiki-"
+			}),
+			themeName
+		};
+	}
+	function render(code, options) {
+		const transformers = (options.transformers ?? []).toSorted((a, b) => order(a) - order(b));
+		const context = {
+			meta: {},
+			options,
+			codeToHast: render,
+			codeToTokens: (code, { lang = "text" }) => tokenize(code, lang)
+		};
+		for (const transformer of transformers) code = transformer.preprocess?.call(context, code, options) || code;
+		const result = tokenize(code, options.lang);
+		let tokens = mergeWhitespaces(result.tokens);
+		const source = {
+			...context,
+			source: code
+		};
+		for (const transformer of transformers) tokens = transformer.tokens?.call(source, tokens) || tokens;
+		return tokensToHast(tokens, {
+			...result,
+			...options
+		}, transformers, source);
+	}
+	function getCodeOptions(codeOptions) {
+		return {
+			...codeOptions,
+			themes: themeIds,
+			defaultColor: false,
+			transformers: shikiTransformers
+		};
+	}
+	return {
+		codeToHast: (code, codeOptions) => render(code, getCodeOptions(codeOptions)),
+		override: (options) => createHighlights({
+			...highlightsOptions,
+			...options
+		})
+	};
+}
+function order(transformer) {
+	if (transformer.enforce === "pre") return -1;
+	if (transformer.enforce === "post") return 1;
+	return 0;
+}
+/**
+* White space tokens join the next token, like the default `mergeWhitespaces` of Shiki: its transformers
+* expect it, the notations find comment-only lines as lines of one token.
+*/
+function mergeWhitespaces(lines) {
+	const out = [];
+	for (const line of lines) {
+		const merged = [];
+		let carry = "";
+		let offset = 0;
+		for (let i = 0; i < line.length; i++) {
+			const token = line[i];
+			const mergeable = ((token.fontStyle ?? 0) & 12) === 0;
+			if (mergeable && i < line.length - 1 && /^\s+$/.test(token.content)) {
+				if (!carry) offset = token.offset;
+				carry += token.content;
+			} else if (!carry) merged.push(token);
+			else if (mergeable) {
+				merged.push({
+					...token,
+					offset,
+					content: carry + token.content
+				});
+				carry = "";
+			} else {
+				merged.push({
+					content: carry,
+					offset
+				}, token);
+				carry = "";
+			}
+		}
+		out.push(merged);
+	}
+	return out;
+}
+function getTokenStyle(token) {
+	let style = "";
+	for (const key in token.htmlStyle) style += `${style ? ";" : ""}${key}:${token.htmlStyle[key]}`;
+	return style;
+}
+function addClassToHast(node, className) {
+	if (!className) return node;
+	const current = node.properties.class;
+	const classes = Array.isArray(current) ? current : typeof current === "string" ? current.split(/\s+/) : [];
+	for (const name of Array.isArray(className) ? className : className.split(/\s+/)) if (name && !classes.includes(name)) classes.push(name);
+	node.properties.class = classes;
+	return node;
+}
+/**
+* Render Shiki tokens into Shiki's hast structure, with transformers applied.
+*/
+function tokensToHast(tokens, options, transformers, source) {
+	const { structure = "classic" } = options;
+	const properties = {
+		class: `shiki ${options.themeName ?? ""}`,
+		style: options.rootStyle || `background-color:${options.bg};color:${options.fg}`,
+		tabindex: "0"
+	};
+	for (const [key, value] of Object.entries(options.meta ?? {})) if (!key.startsWith("_")) properties[key] = value;
+	const lines = [];
+	let root = {
+		type: "root",
+		children: []
+	};
+	let pre = {
+		type: "element",
+		tagName: "pre",
+		properties,
+		children: []
+	};
+	let code = {
+		type: "element",
+		tagName: "code",
+		properties: {},
+		children: []
+	};
+	const context = {
+		...source,
+		structure,
+		addClassToHast,
+		get tokens() {
+			return tokens;
+		},
+		get root() {
+			return root;
+		},
+		get pre() {
+			return pre;
+		},
+		get code() {
+			return code;
+		},
+		get lines() {
+			return lines;
+		}
+	};
+	for (let i = 0; i < tokens.length; i++) {
+		let line = {
+			type: "element",
+			tagName: "span",
+			properties: { class: "line" },
+			children: []
+		};
+		let col = 0;
+		for (const token of tokens[i]) {
+			let span = {
+				type: "element",
+				tagName: "span",
+				properties: { ...token.htmlAttrs },
+				children: [{
+					type: "text",
+					value: token.content
+				}]
+			};
+			const style = getTokenStyle(token);
+			if (style) span.properties.style = style;
+			for (const transformer of transformers) span = transformer.span?.call(context, span, i + 1, col, line, token) || span;
+			line.children.push(span);
+			col += token.content.length;
+		}
+		if (structure === "classic") for (const transformer of transformers) line = transformer.line?.call(context, line, i + 1) || line;
+		lines.push(line);
+	}
+	for (let i = 0; i < lines.length; i++) {
+		if (i > 0 && structure === "classic") code.children.push({
+			type: "text",
+			value: "\n"
+		});
+		code.children.push(lines[i]);
+	}
+	for (const transformer of transformers) code = transformer.code?.call(context, code) || code;
+	if (structure === "classic") {
+		pre.children.push(code);
+		for (const transformer of transformers) pre = transformer.pre?.call(context, pre) || pre;
+		root.children.push(pre);
+	} else for (let i = 0; i < code.children.length; i++) {
+		const line = code.children[i];
+		if (i > 0) root.children.push({
+			type: "element",
+			tagName: "br",
+			properties: {},
+			children: []
+		});
+		if (line.type === "element") root.children.push(...line.children);
+	}
+	for (const transformer of transformers) root = transformer.root?.call(context, root) || root;
+	return root;
+}
+//#endregion
+export { createHighlights };

package/dist/highlight/index.d.ts

@@ -1,30 +1,2 @@
-import { ReactNode } from "react";
-import { Components } from "hast-util-to-jsx-runtime";
-import { Root } from "hast";
-import { BundledLanguage, BundledTheme, CodeOptionsMeta, CodeOptionsThemes, CodeToHastOptionsCommon, LanguageRegistration, ThemeRegistrationAny } from "shiki";
-//#region src/highlight/index.d.ts
-export type HighlightOptions = HighlightHastOptions & {
-  components?: Partial<Components>;
-};
-export type HighlightHastOptions = CodeToHastOptionsCommon<BundledLanguage> & CodeOptionsMeta & {
-  fallbackLanguage?: BundledLanguage | (string & {});
-  /**
-   * The Regex Engine for Shiki
-   *
-   * @defaultValue 'js'
-   */
-  engine?: 'js' | 'oniguruma';
-} & (CodeOptionsThemes<BundledTheme> | Record<never, never>);
-export declare function highlightHast(code: string, options: HighlightHastOptions): Promise<Root>;
-/**
- * Get Shiki highlighter instance of Fumadocs (mostly for internal use, you should use Shiki directly over this).
- *
- * @param engineType - Shiki Regex engine to use.
- * @param options - Shiki options.
- */
-export declare function getHighlighter(engineType: 'js' | 'oniguruma', options?: {
-  langs?: (BundledLanguage | LanguageRegistration)[];
-  themes?: (BundledTheme | ThemeRegistrationAny)[];
-}): Promise<import("shiki").HighlighterCore>;
-export declare function highlight(code: string, options: HighlightOptions): Promise<ReactNode>;
-//#endregion
+import { a as getHighlighter, i as Highlighter, n as HighlightHastOptions, o as highlight, r as HighlightOptions, s as highlightHast, t as HighlightCodeOptions } from "../index-Bf_V9OZJ.js";
+export { HighlightCodeOptions, HighlightHastOptions, HighlightOptions, Highlighter, getHighlighter, highlight, highlightHast };

package/dist/highlight/index.js

@@ -1,8 +1,6 @@
-import { a as loadMissingTheme, i as loadMissingLanguage, t as applyDefaultThemes } from "../utils-Cgs-6U-z.js";
-import { highlightHast as highlightHast$1 } from "./shiki/index.js";
+import { toJsx } from "../utils/hast-to-jsx.js";
+import { i as applyDefaultThemes, o as loadMissingLanguage, r as highlightHast$1, s as loadMissingTheme } from "../shiki-DzWiTQMz.js";
 import { defaultShikiFactory, wasmShikiFactory } from "./shiki/full.js";
-import * as JsxRuntime from "react/jsx-runtime";
-import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 //#region src/highlight/index.ts
 async function highlightHast(code, options) {
 	const instance = await ((options.engine ?? "js") === "js" ? defaultShikiFactory : wasmShikiFactory).getOrInit();
@@ -20,11 +18,7 @@ async function getHighlighter(engineType, options = {}) {
 	return instance;
 }
 async function highlight(code, options) {
-	return toJsxRuntime(await highlightHast(code, options), {
-		...JsxRuntime,
-		development: false,
-		components: options.components
-	});
+	return toJsx(await highlightHast(code, options), { components: options.components });
 }
 //#endregion
 export { getHighlighter, highlight, highlightHast };

package/dist/highlight/shiki/full.d.ts

@@ -1,4 +1,4 @@
-import { n as ShikiFactory } from "../../index-BMEUQz-F.js";
+import { n as ShikiFactory } from "../../index-m7W5wflM.js";
 //#region src/highlight/shiki/full.d.ts
 export declare const defaultShikiFactory: ShikiFactory;
 /** factory using the WASM powered Regex engine */

package/dist/highlight/shiki/full.js

@@ -1,4 +1,4 @@
-import { createShikiFactory } from "./index.js";
+import { t as createShikiFactory } from "../../shiki-DzWiTQMz.js";
 //#region src/highlight/shiki/full.ts
 const defaultShikiFactory = createShikiFactory({ async init(options) {
 	const { createHighlighter, createJavaScriptRegexEngine } = await import("shiki");

package/dist/highlight/shiki/index.d.ts

@@ -1,2 +1,2 @@
-import { i as highlightHast, n as ShikiFactory, r as createShikiFactory, t as HighlightHastOptions } from "../../index-BMEUQz-F.js";
-export { HighlightHastOptions, ShikiFactory, createShikiFactory, highlightHast };
+import { a as createShikiFactory, i as ShikiHighlighterOptions, n as ShikiFactory, o as createShikiHighlighter, r as ShikiHighlighter, s as highlightHast, t as HighlightHastOptions } from "../../index-m7W5wflM.js";
+export { HighlightHastOptions, ShikiFactory, ShikiHighlighter, ShikiHighlighterOptions, createShikiFactory, createShikiHighlighter, highlightHast };

package/dist/highlight/shiki/index.js

@@ -1,27 +1 @@
-import { a as loadMissingTheme, r as getRequiredThemes } from "../../utils-Cgs-6U-z.js";
-//#region src/highlight/shiki/index.ts
-function createShikiFactory(config) {
-	let instance;
-	return {
-		init(options) {
-			const created = config.init(options);
-			if (created instanceof Promise) created.catch(() => {
-				if (instance === created) instance = void 0;
-			});
-			return instance = created;
-		},
-		getOrInit() {
-			return instance ?? this.init();
-		}
-	};
-}
-async function highlightHast(highlighter, code, options) {
-	const { fallbackLanguage = "text", ...resolved } = options;
-	const { isSpecialLang } = await import("shiki/core");
-	const loaded = highlighter.getLoadedLanguages();
-	if (!isSpecialLang(resolved.lang) && !(resolved.lang in highlighter.getBundledLanguages()) && !loaded.includes(resolved.lang)) resolved.lang = fallbackLanguage;
-	await Promise.all([loadMissingTheme(highlighter, getRequiredThemes(resolved)), !isSpecialLang(resolved.lang) && !loaded.includes(resolved.lang) && highlighter.loadLanguage(resolved.lang)]);
-	return highlighter.codeToHast(code, resolved);
-}
-//#endregion
-export { createShikiFactory, highlightHast };
+export { t as createShikiFactory, n as createShikiHighlighter, r as highlightHast } from "../../shiki-DzWiTQMz.js";

package/dist/highlight/shiki/react.d.ts

@@ -1,7 +1,7 @@
-import { t as Awaitable } from "../../types-D89QoQR-.js";
-import { t as HighlightHastOptions } from "../../index-BMEUQz-F.js";
+import { t as Components } from "../../hast-to-jsx-CgR__kSX.js";
+import { t as Awaitable } from "../../types-D1vp9AYr.js";
+import { t as HighlightHastOptions } from "../../index-m7W5wflM.js";
 import { DependencyList, ReactNode } from "react";
-import { Components } from "hast-util-to-jsx-runtime";
 import { HighlighterCore } from "shiki";
 //#region src/highlight/shiki/react.d.ts
 export type UseShikiOptions = HighlightHastOptions & {

package/dist/highlight/shiki/react.js

@@ -1,10 +1,13 @@
 "use client";
-import { highlightHast } from "./index.js";
+import { toJsx } from "../../utils/hast-to-jsx.js";
+import { r as highlightHast } from "../../shiki-DzWiTQMz.js";
 import { use, useEffect, useMemo, useRef, useState } from "react";
-import * as JsxRuntime from "react/jsx-runtime";
-import { toJsxRuntime } from "hast-util-to-jsx-runtime";
 //#region src/highlight/shiki/react.ts
 const promises = {};
+async function render(highlighter, code, options) {
+	const instance = typeof highlighter === "function" ? await highlighter() : highlighter;
+	return toJsx(await highlightHast(instance, code, options), { components: options.components });
+}
 /**
 * get highlighted results (uncached), use `useEffect` instead of React 19 APIs.
 */
@@ -12,14 +15,7 @@ function useShikiDynamic(highlighter, code, options, deps) {
 	const [node, setNode] = useState(options.defaultValue);
 	const lastTask = useRef(null);
 	useEffect(() => {
-		async function task() {
-			const instance = typeof highlighter === "function" ? await highlighter() : highlighter;
-			return toJsxRuntime(await highlightHast(instance, code, options), {
-				...JsxRuntime,
-				components: options.components
-			});
-		}
-		const promise = task();
+		const promise = render(highlighter, code, options);
 		lastTask.current = promise;
 		promise.then((res) => {
 			if (lastTask.current === promise) setNode(res);
@@ -37,14 +33,7 @@ function useShikiDynamic(highlighter, code, options, deps) {
 */
 function useShiki(highlighter, code, options, deps = [options.lang, code]) {
 	const key = useMemo(() => JSON.stringify(deps), [deps]);
-	async function run() {
-		const instance = typeof highlighter === "function" ? await highlighter() : highlighter;
-		return toJsxRuntime(await highlightHast(instance, code, options), {
-			...JsxRuntime,
-			components: options.components
-		});
-	}
-	return use(promises[key] ??= run());
+	return use(promises[key] ??= render(highlighter, code, options));
 }
 //#endregion
 export { useShiki, useShikiDynamic };

package/dist/i18n/middleware.d.ts

@@ -30,4 +30,5 @@ export interface URLFormatter {
 }
 export declare const DefaultFormatter: URLFormatter;
 export declare function createI18nMiddleware({ languages, defaultLanguage, format, cookieName, hideLocale }: MiddlewareOptions): NextProxy;
-//#endregion
+//#endregion
+export {};

package/dist/{index-DNn03jFO.d.ts → index-B-0R0VbS.d.ts}

@@ -1,5 +1,5 @@
-import { i as Root } from "./definitions-BZlqdyOx.js";
-import { t as index_d_exports } from "./index-DUWMH-uy.js";
+import { i as Root } from "./definitions-CFOhwE1k.js";
+import "./index-E8Qh_yQs.js";
 //#region src/source/client/index.d.ts
 interface SerializedPageTree {
   $fumadocs_loader: 'page-tree';