@hanzo/docs-core 16.4.3 → 16.5.3

package/dist/highlight/config.js

@@ -0,0 +1,18 @@
+//#region src/highlight/config.ts
+/** define shared configurations for Shiki */
+function defineShikiConfig(config) {
+	let created;
+	return {
+		id: Symbol(),
+		defaultThemes: config.defaultThemes,
+		createHighlighter() {
+			if (created) return created;
+			created = config.createHighlighter();
+			if ("then" in created) created = created.then((v) => created = v);
+			return created;
+		}
+	};
+}
+
+//#endregion
+export { defineShikiConfig };

package/dist/highlight/core/client.d.ts

@@ -0,0 +1,31 @@
+import { r as MakeOptional } from "../../types-BSnJn7kF.js";
+import { ResolvedShikiConfig } from "../config.js";
+import { CoreHighlightOptions } from "./index.js";
+import { DependencyList, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/highlight/core/client.d.ts
+declare function useShikiConfigOptional(): ResolvedShikiConfig | null;
+declare function useShikiConfig(forced?: ResolvedShikiConfig): ResolvedShikiConfig;
+declare function ShikiConfigProvider({
+  config,
+  children
+}: {
+  config: ResolvedShikiConfig;
+  children: ReactNode;
+}): react_jsx_runtime0.JSX.Element;
+type UseShikiOptions = MakeOptional<CoreHighlightOptions, 'config'>;
+/**
+ * get highlighted results (uncached), use `useEffect` instead of React 19 APIs.
+ */
+declare function useShikiDynamic(code: string, options: UseShikiOptions & {
+  defaultValue?: ReactNode;
+}, deps: DependencyList): ReactNode;
+/**
+ * get highlighted results, should be used with React Suspense API.
+ *
+ * note: results are cached with (lang, code) as keys, if this is not the desired behaviour, pass a `deps` instead.
+ */
+declare function useShiki(code: string, options: UseShikiOptions, deps?: DependencyList): ReactNode;
+//#endregion
+export { ShikiConfigProvider, UseShikiOptions, useShiki, useShikiConfig, useShikiConfigOptional, useShikiDynamic };

package/dist/highlight/core/client.js

@@ -0,0 +1,68 @@
+'use client';
+
+import { highlight } from "./index.js";
+import { createContext, use, useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/highlight/core/client.tsx
+const ShikiConfigContext = createContext(null);
+function useShikiConfigOptional() {
+	return use(ShikiConfigContext);
+}
+function useShikiConfig(forced) {
+	if (forced) return forced;
+	const ctx = use(ShikiConfigContext);
+	if (!ctx) throw new Error(`missing <ShikiConfigProvider />`);
+	return ctx;
+}
+function ShikiConfigProvider({ config, children }) {
+	return /* @__PURE__ */ jsx(ShikiConfigContext, {
+		value: config,
+		children
+	});
+}
+const promises = {};
+/**
+* get highlighted results (uncached), use `useEffect` instead of React 19 APIs.
+*/
+function useShikiDynamic(code, options, deps) {
+	const [node, setNode] = useState(options.defaultValue);
+	const config = useShikiConfig(options.config);
+	const lastTask = useRef(null);
+	useEffect(() => {
+		const promise = highlight(code, {
+			...options,
+			config
+		});
+		lastTask.current = promise;
+		promise.then((res) => {
+			if (lastTask.current === promise) setNode(res);
+		});
+		return () => {
+			lastTask.current = null;
+		};
+	}, deps);
+	return node;
+}
+/**
+* get highlighted results, should be used with React Suspense API.
+*
+* note: results are cached with (lang, code) as keys, if this is not the desired behaviour, pass a `deps` instead.
+*/
+function useShiki(code, options, deps) {
+	const config = useShikiConfig(options.config);
+	const key = useMemo(() => {
+		return deps ? JSON.stringify(deps) : `${options.lang}:${code}`;
+	}, [
+		code,
+		deps,
+		options.lang
+	]);
+	return use(promises[key] ??= highlight(code, {
+		...options,
+		config
+	}));
+}
+
+//#endregion
+export { ShikiConfigProvider, useShiki, useShikiConfig, useShikiConfigOptional, useShikiDynamic };

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

@@ -0,0 +1,27 @@
+import { n as DistributiveOmit } from "../../types-BSnJn7kF.js";
+import { ResolvedShikiConfig } from "../config.js";
+import { ReactNode } from "react";
+import { Components } from "hast-util-to-jsx-runtime";
+import { BundledLanguage, BundledTheme, CodeOptionsMeta, CodeOptionsThemes, CodeToHastOptionsCommon, HighlighterCore, LanguageRegistration, ThemeRegistrationAny } from "shiki";
+import { Root } from "hast";
+
+//#region src/highlight/core/index.d.ts
+type CoreHighlightOptions = CodeToHastOptionsCommon<BundledLanguage> & CodeOptionsMeta & {
+  config: ResolvedShikiConfig;
+  components?: Partial<Components>;
+  fallbackLanguage?: BundledLanguage;
+} & (CodeOptionsThemes<BundledTheme> | Record<never, never>);
+declare function highlightHast(code: string, options: DistributiveOmit<CoreHighlightOptions, 'components'>): Promise<Root>;
+/**
+ * Get Shiki highlighter instance of Hanzo Docs (mostly for internal use, you should use Shiki directly over this).
+ *
+ * @param engineType - Shiki Regex engine to use.
+ * @param options - Shiki options.
+ */
+declare function getHighlighter(config: ResolvedShikiConfig, options?: {
+  langs?: (BundledLanguage | LanguageRegistration)[];
+  themes?: (BundledTheme | ThemeRegistrationAny)[];
+}): Promise<HighlighterCore>;
+declare function highlight(code: string, options: CoreHighlightOptions): Promise<ReactNode>;
+//#endregion
+export { CoreHighlightOptions, getHighlighter, highlight, highlightHast };

package/dist/highlight/core/index.js

@@ -0,0 +1,69 @@
+import { Fragment } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { toJsxRuntime } from "hast-util-to-jsx-runtime";
+
+//#region src/highlight/core/index.ts
+async function highlightHast(code, options) {
+	const { fallbackLanguage = "text", config, ...resolved } = options;
+	let themesToLoad;
+	if (!("theme" in resolved) && !("themes" in resolved)) Object.assign(resolved, config.defaultThemes);
+	if ("theme" in resolved) themesToLoad = [resolved.theme];
+	else if ("themes" in resolved) {
+		themesToLoad = Object.values(resolved.themes).filter((v) => v !== void 0);
+		resolved.defaultColor ??= false;
+	} else throw new Error("impossible");
+	const { isSpecialLang } = await import("shiki/core");
+	const highlighter = await config.createHighlighter();
+	if (!isSpecialLang(resolved.lang) && !(resolved.lang in highlighter.getBundledLanguages()) && !highlighter.getLoadedLanguages().includes(resolved.lang)) resolved.lang = fallbackLanguage;
+	await Promise.all([loadMissingTheme(highlighter, ...themesToLoad), loadMissingLanguage(highlighter, resolved.lang)]);
+	return highlighter.codeToHast(code, resolved);
+}
+async function loadMissingTheme(highlighter, ...themes) {
+	const { isSpecialTheme } = await import("shiki/core");
+	const missingThemes = themes.filter((theme) => {
+		if (isSpecialTheme(theme)) return false;
+		try {
+			highlighter.getTheme(theme);
+			return false;
+		} catch {
+			return true;
+		}
+	});
+	if (missingThemes.length > 0) await highlighter.loadTheme(...missingThemes);
+}
+async function loadMissingLanguage(highlighter, ...langs) {
+	const { isSpecialLang } = await import("shiki/core");
+	const missingLangs = langs.filter((lang) => {
+		if (isSpecialLang(lang)) return false;
+		try {
+			highlighter.getLanguage(lang);
+			return false;
+		} catch {
+			return true;
+		}
+	});
+	if (missingLangs.length > 0) await highlighter.loadLanguage(...missingLangs);
+}
+/**
+* Get Shiki highlighter instance of Hanzo Docs (mostly for internal use, you should use Shiki directly over this).
+*
+* @param engineType - Shiki Regex engine to use.
+* @param options - Shiki options.
+*/
+async function getHighlighter(config, options) {
+	const highlighter = await config.createHighlighter();
+	await Promise.all([options?.langs && loadMissingLanguage(highlighter, ...options.langs), options?.themes && loadMissingTheme(highlighter, ...options.themes)]);
+	return highlighter;
+}
+async function highlight(code, options) {
+	return toJsxRuntime(await highlightHast(code, options), {
+		jsx,
+		jsxs,
+		development: false,
+		Fragment,
+		components: options.components
+	});
+}
+
+//#endregion
+export { getHighlighter, highlight, highlightHast };

package/dist/highlight/index.d.ts

@@ -1,2 +1,34 @@
-import { a as hastToJsx, i as getHighlighter, n as HighlightOptionsCommon, o as highlight, r as HighlightOptionsThemes, s as highlightHast, t as HighlightOptions } from "../shiki-CIBQys54.js";
-export { type HighlightOptions, type HighlightOptionsCommon, type HighlightOptionsThemes, getHighlighter, hastToJsx, highlight, highlightHast };
+import { n as DistributiveOmit } from "../types-BSnJn7kF.js";
+import { ResolvedShikiConfig } from "./config.js";
+import { CoreHighlightOptions } from "./core/index.js";
+import { ReactNode } from "react";
+import * as shiki from "shiki";
+import { BundledLanguage, BundledTheme, LanguageRegistration, ThemeRegistrationAny } from "shiki";
+import { Root } from "hast";
+
+//#region src/highlight/index.d.ts
+type HighlightOptions = DistributiveOmit<CoreHighlightOptions, 'config'> & {
+  /**
+   * The Regex Engine for Shiki
+   *
+   * @defaultValue 'js'
+   */
+  engine?: 'js' | 'oniguruma';
+};
+declare function highlightHast(code: string, options: HighlightOptions): Promise<Root>;
+/**
+ * Get Shiki highlighter instance of Hanzo Docs (mostly for internal use, you should use Shiki directly over this).
+ *
+ * @param engineType - Shiki Regex engine to use.
+ * @param options - Shiki options.
+ */
+declare function getHighlighter(engineType: 'js' | 'oniguruma', options?: {
+  langs?: (BundledLanguage | LanguageRegistration)[];
+  themes?: (BundledTheme | ThemeRegistrationAny)[];
+}): Promise<shiki.HighlighterCore>;
+declare function highlight(code: string, options: HighlightOptions): Promise<ReactNode>;
+declare const configDefault: ResolvedShikiConfig;
+/** config using the WASM powered Regex engine */
+declare const configWASM: ResolvedShikiConfig;
+//#endregion
+export { HighlightOptions, configDefault, configWASM, getHighlighter, highlight, highlightHast };

package/dist/highlight/index.js

@@ -1,3 +1,58 @@
-import { a as highlightHast, i as highlight, n as getHighlighter, r as hastToJsx } from "../shiki-4oMYwHED.js";
+import { getHighlighter as getHighlighter$1, highlight as highlight$1, highlightHast as highlightHast$1 } from "./core/index.js";
+import { defineShikiConfig } from "./config.js";
 
-export { getHighlighter, hastToJsx, highlight, highlightHast };
+//#region src/highlight/index.ts
+async function highlightHast(code, options) {
+	const engine = options.engine ?? "js";
+	return highlightHast$1(code, {
+		...options,
+		config: engine === "js" ? configDefault : configWASM
+	});
+}
+/**
+* Get Shiki highlighter instance of Hanzo Docs (mostly for internal use, you should use Shiki directly over this).
+*
+* @param engineType - Shiki Regex engine to use.
+* @param options - Shiki options.
+*/
+async function getHighlighter(engineType, options) {
+	return getHighlighter$1(engineType === "js" ? configDefault : configWASM, options);
+}
+async function highlight(code, options) {
+	const engine = options.engine ?? "js";
+	return highlight$1(code, {
+		...options,
+		config: engine === "js" ? configDefault : configWASM
+	});
+}
+const defaultThemes = { themes: {
+	light: "github-light",
+	dark: "github-dark"
+} };
+const configDefault = defineShikiConfig({
+	defaultThemes,
+	async createHighlighter() {
+		const { createHighlighter } = await import("shiki");
+		const { createJavaScriptRegexEngine } = await import("shiki/engine/javascript");
+		return createHighlighter({
+			langs: [],
+			themes: [],
+			engine: createJavaScriptRegexEngine()
+		});
+	}
+});
+/** config using the WASM powered Regex engine */
+const configWASM = defineShikiConfig({
+	defaultThemes,
+	async createHighlighter() {
+		const { createHighlighter, createOnigurumaEngine } = await import("shiki");
+		return createHighlighter({
+			langs: [],
+			themes: [],
+			engine: createOnigurumaEngine(import("shiki/wasm"))
+		});
+	}
+});
+
+//#endregion
+export { configDefault, configWASM, getHighlighter, highlight, highlightHast };

package/dist/i18n/index.d.ts

@@ -1,2 +1,40 @@
-import { n as defineI18n, t as I18nConfig } from "../index-Bw-DCOra.js";
+//#region src/i18n/index.d.ts
+interface I18nConfig<Languages extends string = string> {
+  /**
+   * Supported locale codes.
+   *
+   * A page tree will be built for each language.
+   */
+  languages: Languages[];
+  /**
+   * Default locale if not specified
+   */
+  defaultLanguage: Languages;
+  /**
+   * Don't show the locale prefix on URL.
+   *
+   * - `always`: Always hide the prefix
+   * - `default-locale`: Only hide the default locale
+   * - `never`: Never hide the prefix
+   *
+   * This API uses `NextResponse.rewrite`.
+   *
+   * @defaultValue 'never'
+   */
+  hideLocale?: 'always' | 'default-locale' | 'never';
+  /**
+   * Used by `loader()`, specify the way to parse i18n file structure.
+   *
+   * @defaultValue 'dot'
+   */
+  parser?: 'dot' | 'dir' | 'none';
+  /**
+   * the fallback language when the page has no translations available for a given locale.
+   *
+   * Default to `defaultLanguage`, no fallback when set to `null`.
+   */
+  fallbackLanguage?: Languages | null;
+}
+declare function defineI18n<Languages extends string>(config: I18nConfig<Languages>): I18nConfig<Languages>;
+//#endregion
 export { I18nConfig, defineI18n };

package/dist/i18n/index.js

@@ -4,5 +4,4 @@ function defineI18n(config) {
 }
 
 //#endregion
-export { defineI18n };
-//# sourceMappingURL=index.js.map
+export { defineI18n };

package/dist/i18n/middleware.d.ts

@@ -1,4 +1,4 @@
-import { t as I18nConfig } from "../index-Bw-DCOra.js";
+import { I18nConfig } from "./index.js";
 import { NextProxy } from "next/server";
 import { NextURL } from "next/dist/server/web/next-url";
 
@@ -38,5 +38,4 @@ declare function createI18nMiddleware({
   hideLocale
 }: MiddlewareOptions): NextProxy;
 //#endregion
-export { DefaultFormatter, URLFormatter, createI18nMiddleware };
-//# sourceMappingURL=middleware.d.ts.map
+export { DefaultFormatter, URLFormatter, createI18nMiddleware };

package/dist/i18n/middleware.js

@@ -54,5 +54,4 @@ function createI18nMiddleware({ languages, defaultLanguage, format = DefaultForm
 }
 
 //#endregion
-export { DefaultFormatter, createI18nMiddleware };
-//# sourceMappingURL=middleware.js.map
+export { DefaultFormatter, createI18nMiddleware };

package/dist/{icon-BWwSDabM.js → icon-OtPFhyk1.js}

@@ -15,5 +15,4 @@ function iconPlugin(resolveIcon) {
 }
 
 //#endregion
-export { iconPlugin as t };
-//# sourceMappingURL=icon-BWwSDabM.js.map
+export { iconPlugin as t };

package/dist/link.d.ts

@@ -1,4 +1,4 @@
-import * as react6 from "react";
+import * as react from "react";
 import { AnchorHTMLAttributes } from "react";
 
 //#region src/link.d.ts
@@ -14,7 +14,6 @@ interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
    */
   prefetch?: boolean;
 }
-declare const Link: react6.ForwardRefExoticComponent<LinkProps & react6.RefAttributes<HTMLAnchorElement>>;
+declare const Link: react.ForwardRefExoticComponent<LinkProps & react.RefAttributes<HTMLAnchorElement>>;
 //#endregion
-export { LinkProps, Link as default };
-//# sourceMappingURL=link.d.ts.map
+export { LinkProps, Link as default };

package/dist/link.js

@@ -25,5 +25,4 @@ const Link = forwardRef(({ href = "#", external = href.match(/^\w+:/) || href.st
 Link.displayName = "Link";
 
 //#endregion
-export { Link as default };
-//# sourceMappingURL=link.js.map
+export { Link as default };

package/dist/{mdast-utils-mc9-X-PK.js → mdast-utils-gJMY143g.js}

@@ -36,5 +36,4 @@ function toMdxExport(name, value) {
 }
 
 //#endregion
-export { toMdxExport as n, flattenNode as t };
-//# sourceMappingURL=mdast-utils-mc9-X-PK.js.map
+export { toMdxExport as n, flattenNode as t };

package/dist/mdx-plugins/codeblock-utils.d.ts

@@ -1,2 +1,36 @@
-import { i as parseCodeBlockAttributes, n as CodeBlockTabsOptions, r as generateCodeBlockTabs, t as CodeBlockAttributes } from "../codeblock-utils-lld8UiQo.js";
+import { BlockContent, Text } from "mdast";
+import { MdxJsxAttribute, MdxJsxFlowElement } from "mdast-util-mdx-jsx";
+
+//#region src/mdx-plugins/codeblock-utils.d.ts
+interface CodeBlockTabsOptions {
+  attributes?: MdxJsxAttribute[];
+  defaultValue?: string;
+  persist?: {
+    id: string;
+  } | false;
+  triggers: {
+    value: string;
+    children: (BlockContent | Text)[];
+  }[];
+  tabs: {
+    value: string;
+    children: BlockContent[];
+  }[];
+}
+declare function generateCodeBlockTabs({
+  persist,
+  defaultValue,
+  triggers,
+  tabs,
+  ...options
+}: CodeBlockTabsOptions): MdxJsxFlowElement;
+interface CodeBlockAttributes<Name extends string = string> {
+  attributes: Partial<Record<Name, string | null>>;
+  rest: string;
+}
+/**
+ * Parse Hanzo Docs-style code block attributes from meta string, like `title="hello world"`
+ */
+declare function parseCodeBlockAttributes<Name extends string = string>(meta: string, allowedNames?: Name[]): CodeBlockAttributes<Name>;
+//#endregion
 export { CodeBlockAttributes, CodeBlockTabsOptions, generateCodeBlockTabs, parseCodeBlockAttributes };

package/dist/mdx-plugins/codeblock-utils.js

@@ -49,7 +49,7 @@ function generateCodeBlockTabs({ persist = false, defaultValue, triggers, tabs,
 	};
 }
 /**
-* Parse Fumadocs-style code block attributes from meta string, like `title="hello world"`
+* Parse Hanzo Docs-style code block attributes from meta string, like `title="hello world"`
 */
 function parseCodeBlockAttributes(meta, allowedNames) {
 	let str = meta;
@@ -67,5 +67,4 @@ function parseCodeBlockAttributes(meta, allowedNames) {
 }
 
 //#endregion
-export { generateCodeBlockTabs, parseCodeBlockAttributes };
-//# sourceMappingURL=codeblock-utils.js.map
+export { generateCodeBlockTabs, parseCodeBlockAttributes };

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

@@ -1,15 +1,18 @@
-import { n as remarkGfm, t as RemarkGfmOptions } from "../remark-gfm-CeWpMwyk.js";
-import { a as CodeBlockIcon, i as transformerTab, n as rehypeCode, o as transformerIcon, r as rehypeCodeDefaultOptions, t as RehypeCodeOptions } from "../rehype-code-vVWG4-ej.js";
-import { n as remarkImage, t as RemarkImageOptions } from "../remark-image-CvUis4R1.js";
-import { a as structure, i as remarkStructureDefaultOptions, n as StructuredData, r as remarkStructure, t as StructureOptions } from "../remark-structure-RZD2gGKp.js";
-import { n as remarkHeading, t as RemarkHeadingOptions } from "../remark-heading-CXvCY0go.js";
-import { n as remarkAdmonition, t as RemarkAdmonitionOptions } from "../remark-admonition-DOwBWzsH.js";
-import { n as remarkDirectiveAdmonition, t as RemarkDirectiveAdmonitionOptions } from "../remark-directive-admonition-BCm_yiU9.js";
-import { n as rehypeToc, t as RehypeTocOptions } from "../rehype-toc-DJvSyE0o.js";
-import { n as remarkCodeTab, t as RemarkCodeTabOptions } from "../remark-code-tab-CXsYlims.js";
-import { n as remarkSteps, t as RemarkStepsOptions } from "../remark-steps-CHJN-rtm.js";
-import { n as remarkNpm, t as RemarkNpmOptions } from "../remark-npm-BIvIEKT2.js";
-import { i as parseCodeBlockAttributes, n as CodeBlockTabsOptions, r as generateCodeBlockTabs, t as CodeBlockAttributes } from "../codeblock-utils-lld8UiQo.js";
-import { n as remarkMdxFiles, t as RemarkMdxFilesOptions } from "../remark-mdx-files-DOYafA4x.js";
-import { n as remarkMdxMermaid, t as RemarkMdxMermaidOptions } from "../remark-mdx-mermaid-BdSUUiCG.js";
-export { CodeBlockAttributes, CodeBlockIcon, CodeBlockTabsOptions, RehypeCodeOptions, RehypeTocOptions, RemarkAdmonitionOptions, RemarkCodeTabOptions, RemarkDirectiveAdmonitionOptions, RemarkGfmOptions, RemarkHeadingOptions, RemarkImageOptions, RemarkMdxFilesOptions, RemarkMdxMermaidOptions, RemarkNpmOptions, RemarkStepsOptions, StructureOptions, StructuredData, generateCodeBlockTabs, parseCodeBlockAttributes, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkCodeTab, remarkDirectiveAdmonition, remarkGfm, remarkHeading, remarkImage, remarkMdxFiles, remarkMdxMermaid, remarkNpm, remarkSteps, remarkStructure, remarkStructureDefaultOptions, structure, transformerIcon, transformerTab };
+import { RemarkGfmOptions, remarkGfm } from "./remark-gfm.js";
+import { r as transformerIcon, t as CodeBlockIcon } from "../transformer-icon-D7-6aFzt.js";
+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, 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";
+import { RehypeTocOptions, rehypeToc } from "./rehype-toc.js";
+import { RemarkCodeTabOptions, remarkCodeTab } from "./remark-code-tab.js";
+import { RemarkStepsOptions, remarkSteps } from "./remark-steps.js";
+import { RemarkNpmOptions, remarkNpm } from "./remark-npm.js";
+import { CodeBlockAttributes, CodeBlockTabsOptions, generateCodeBlockTabs, parseCodeBlockAttributes } from "./codeblock-utils.js";
+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, 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

@@ -1,18 +1,20 @@
-import "../mdast-utils-mc9-X-PK.js";
+import "../mdast-utils-gJMY143g.js";
 import { remarkHeading } from "./remark-heading.js";
-import "../shiki-4oMYwHED.js";
 import { generateCodeBlockTabs, parseCodeBlockAttributes } from "./codeblock-utils.js";
 import { remarkGfm } from "./remark-gfm.js";
-import { i as transformerIcon, n as rehypeCodeDefaultOptions, r as transformerTab, t as rehypeCode } from "../rehype-code-CdiZ1Y6P.js";
+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 { remarkStructure, remarkStructureDefaultOptions, structure } from "./remark-structure.js";
 import { remarkAdmonition } from "./remark-admonition.js";
 import { remarkDirectiveAdmonition } from "./remark-directive-admonition.js";
-import { t as rehypeToc } from "../rehype-toc-DVwJcwvA.js";
+import { rehypeToc } from "./rehype-toc.js";
 import { remarkCodeTab } from "./remark-code-tab.js";
 import { remarkSteps } from "./remark-steps.js";
 import { remarkNpm } from "./remark-npm.js";
 import { remarkMdxFiles } from "./remark-mdx-files.js";
 import { remarkMdxMermaid } from "./remark-mdx-mermaid.js";
+import { remarkFeedbackBlock } from "./remark-feedback-block.js";
 
-export { generateCodeBlockTabs, parseCodeBlockAttributes, rehypeCode, rehypeCodeDefaultOptions, rehypeToc, remarkAdmonition, remarkCodeTab, remarkDirectiveAdmonition, remarkGfm, remarkHeading, remarkImage, remarkMdxFiles, remarkMdxMermaid, remarkNpm, remarkSteps, remarkStructure, remarkStructureDefaultOptions, structure, transformerIcon, transformerTab };
+export { 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/rehype-code.core.d.ts

@@ -0,0 +1,38 @@
+import { n as IconOptions, r as transformerIcon, t as CodeBlockIcon } from "../transformer-icon-D7-6aFzt.js";
+import { n as DistributiveOmit } from "../types-BSnJn7kF.js";
+import { ResolvedShikiConfig } from "../highlight/config.js";
+import { ShikiTransformer } from "shiki";
+import { Processor, Transformer } from "unified";
+import { Root } from "hast";
+import { RehypeShikiOptions } from "@shikijs/rehype";
+
+//#region src/mdx-plugins/rehype-code.core.d.ts
+declare function rehypeCodeDefaultOptions(config: ResolvedShikiConfig): RehypeCodeOptionsCommon;
+type RehypeCodeOptionsCommon = DistributiveOmit<RehypeShikiOptions, 'lazy'> & {
+  /**
+   * Load languages and themes on-demand.
+   * @defaultValue true
+   */
+  lazy?: boolean;
+  /**
+   * Filter meta string before processing
+   */
+  filterMetaString?: (metaString: 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>>(configFactory: ResolvedShikiConfig | ((options?: Options) => {
+  config: ResolvedShikiConfig;
+  options: RehypeCodeOptionsCommon;
+})): (this: Processor, _options: Options | undefined) => Transformer<Root, Root>;
+declare function transformerTab(): ShikiTransformer;
+//#endregion
+export { type CodeBlockIcon, RehypeCodeOptionsCommon, createRehypeCode, rehypeCodeDefaultOptions, transformerIcon, transformerTab };