fumadocs-mdx 11.6.11 → 11.7.1

package/dist/runtime/async.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,134 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/mdx-plugins/remark-exports.ts
+function remarkMdxExport({ values }) {
+  return (tree, vfile) => {
+    for (const name of values) {
+      if (!(name in vfile.data)) return;
+      tree.children.unshift(getMdastExport(name, vfile.data[name]));
+    }
+  };
+}
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "let",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: (0, import_estree_util_value_to_estree.valueToEstree)(value)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+var import_estree_util_value_to_estree;
+var init_remark_exports = __esm({
+  "src/mdx-plugins/remark-exports.ts"() {
+    "use strict";
+    import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+  }
+});
+
+// src/utils/mdx-options.ts
+var mdx_options_exports = {};
+__export(mdx_options_exports, {
+  getDefaultMDXOptions: () => getDefaultMDXOptions
+});
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function getDefaultMDXOptions({
+  valueToExport = [],
+  rehypeCodeOptions,
+  remarkImageOptions,
+  remarkHeadingOptions,
+  remarkStructureOptions,
+  remarkCodeTabOptions,
+  remarkNpmOptions,
+  ...mdxOptions
+}) {
+  const mdxExports = [
+    "structuredData",
+    "frontmatter",
+    "lastModified",
+    ...valueToExport
+  ];
+  const remarkPlugins = pluginOption(
+    (v) => [
+      plugins.remarkGfm,
+      [
+        plugins.remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
+      remarkImageOptions !== false && [plugins.remarkImage, remarkImageOptions],
+      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+        plugins.remarkCodeTab,
+        remarkCodeTabOptions
+      ],
+      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+      ...v,
+      remarkStructureOptions !== false && [
+        plugins.remarkStructure,
+        remarkStructureOptions
+      ],
+      [remarkMdxExport, { values: mdxExports }]
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [
+      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+      ...v,
+      plugins.rehypeToc
+    ],
+    mdxOptions.rehypePlugins
+  );
+  return {
+    ...mdxOptions,
+    remarkPlugins,
+    rehypePlugins
+  };
+}
+var plugins;
+var init_mdx_options = __esm({
+  "src/utils/mdx-options.ts"() {
+    "use strict";
+    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
+    init_remark_exports();
+  }
+});
+
 // src/runtime/async.ts
 var async_exports = {};
 __export(async_exports, {
@@ -231,34 +362,55 @@ function buildConfig(config) {
       null
     ];
   }
+  let cachedMdxOptions;
   return [
     null,
     {
       global: globalConfig,
-      collections
+      collections,
+      async getDefaultMDXOptions() {
+        if (cachedMdxOptions) return cachedMdxOptions;
+        const input = this.global?.mdxOptions;
+        async function uncached() {
+          const options = typeof input === "function" ? await input() : input;
+          const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_mdx_options(), mdx_options_exports));
+          if (options?.preset === "minimal") return options;
+          return getDefaultMDXOptions2(options ?? {});
+        }
+        return cachedMdxOptions = uncached();
+      }
     }
   ];
 }
 
 // src/runtime/async.ts
 async function initCompiler(config, collection) {
-  let mdxOptions;
   const col = config.collections.get(collection);
-  if (col?.type === "doc") mdxOptions = col.mdxOptions;
-  else if (col?.type === "docs")
-    mdxOptions = col.docs?.mdxOptions;
-  if (!mdxOptions) {
-    config._mdx_async ??= {};
-    const async = config._mdx_async;
-    const globalConfig = config.global;
-    if (globalConfig && !async.cachedMdxOptions) {
-      async.cachedMdxOptions = typeof globalConfig.mdxOptions === "function" ? await globalConfig.mdxOptions() : globalConfig.mdxOptions;
-    }
-    mdxOptions = async.cachedMdxOptions;
+  switch (col?.type) {
+    case "doc":
+      if (col.mdxOptions)
+        return (0, import_mdx_remote.createCompiler)({
+          preset: "minimal",
+          ...col.mdxOptions
+        });
+      break;
+    case "docs":
+      if (col.docs.mdxOptions)
+        return (0, import_mdx_remote.createCompiler)({
+          preset: "minimal",
+          ...col.docs.mdxOptions
+        });
+      break;
+  }
+  let defaultMdxOptions = config.global?.mdxOptions;
+  if (typeof defaultMdxOptions === "function")
+    defaultMdxOptions = await defaultMdxOptions();
+  if (defaultMdxOptions?.preset === "minimal") {
+    return (0, import_mdx_remote.createCompiler)(defaultMdxOptions);
   }
-  const remarkPlugins = mdxOptions?.remarkPlugins ?? [];
+  const remarkPlugins = defaultMdxOptions?.remarkPlugins ?? [];
   return (0, import_mdx_remote.createCompiler)({
-    ...mdxOptions,
+    ...defaultMdxOptions,
     remarkPlugins: (v) => typeof remarkPlugins === "function" ? [remarkInclude, ...remarkPlugins(v), import_mdx_plugins.remarkStructure] : [remarkInclude, ...v, ...remarkPlugins, import_mdx_plugins.remarkStructure]
   });
 }

package/dist/runtime/async.d.cts

@@ -1,15 +1,14 @@
-import { a as RuntimeAsync } from '../types-BcUhOIxN.cjs';
-import { L as LoadedConfig } from '../types-DVeuYiq5.cjs';
+import { L as LoadedConfig, a as RuntimeAsync } from '../types-CnslxmoO.cjs';
 import '@standard-schema/spec';
 import 'fumadocs-core/source';
-import 'mdx/types';
+import '../define-CCrinVBZ.cjs';
+import 'zod';
 import 'fumadocs-core/mdx-plugins';
-import 'fumadocs-core/server';
 import '@mdx-js/mdx';
 import 'unified';
 import 'react';
-import 'zod';
-import '@fumadocs/mdx-remote';
+import 'mdx/types';
+import 'fumadocs-core/server';
 
 declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];
 

package/dist/runtime/async.d.ts

@@ -1,15 +1,14 @@
-import { a as RuntimeAsync } from '../types-HIdjlLo0.js';
-import { L as LoadedConfig } from '../types-DVeuYiq5.js';
+import { L as LoadedConfig, a as RuntimeAsync } from '../types-C0bKwtAx.js';
 import '@standard-schema/spec';
 import 'fumadocs-core/source';
-import 'mdx/types';
+import '../define-CCrinVBZ.js';
+import 'zod';
 import 'fumadocs-core/mdx-plugins';
-import 'fumadocs-core/server';
 import '@mdx-js/mdx';
 import 'unified';
 import 'react';
-import 'zod';
-import '@fumadocs/mdx-remote';
+import 'mdx/types';
+import 'fumadocs-core/server';
 
 declare function buildConfig(config: Record<string, unknown>): [err: string, value: null] | [err: null, value: LoadedConfig];
 

package/dist/runtime/async.js

@@ -4,7 +4,7 @@ import {
 } from "../chunk-NUDEC6C5.js";
 import {
   buildConfig
-} from "../chunk-DRVUBK5B.js";
+} from "../chunk-GWR7KMRU.js";
 import {
   remarkInclude
 } from "../chunk-AVMO2SRO.js";
@@ -16,23 +16,32 @@ import {
   remarkStructure
 } from "fumadocs-core/mdx-plugins";
 async function initCompiler(config, collection) {
-  let mdxOptions;
   const col = config.collections.get(collection);
-  if (col?.type === "doc") mdxOptions = col.mdxOptions;
-  else if (col?.type === "docs")
-    mdxOptions = col.docs?.mdxOptions;
-  if (!mdxOptions) {
-    config._mdx_async ??= {};
-    const async = config._mdx_async;
-    const globalConfig = config.global;
-    if (globalConfig && !async.cachedMdxOptions) {
-      async.cachedMdxOptions = typeof globalConfig.mdxOptions === "function" ? await globalConfig.mdxOptions() : globalConfig.mdxOptions;
-    }
-    mdxOptions = async.cachedMdxOptions;
+  switch (col?.type) {
+    case "doc":
+      if (col.mdxOptions)
+        return createCompiler({
+          preset: "minimal",
+          ...col.mdxOptions
+        });
+      break;
+    case "docs":
+      if (col.docs.mdxOptions)
+        return createCompiler({
+          preset: "minimal",
+          ...col.docs.mdxOptions
+        });
+      break;
   }
-  const remarkPlugins = mdxOptions?.remarkPlugins ?? [];
+  let defaultMdxOptions = config.global?.mdxOptions;
+  if (typeof defaultMdxOptions === "function")
+    defaultMdxOptions = await defaultMdxOptions();
+  if (defaultMdxOptions?.preset === "minimal") {
+    return createCompiler(defaultMdxOptions);
+  }
+  const remarkPlugins = defaultMdxOptions?.remarkPlugins ?? [];
   return createCompiler({
-    ...mdxOptions,
+    ...defaultMdxOptions,
     remarkPlugins: (v) => typeof remarkPlugins === "function" ? [remarkInclude, ...remarkPlugins(v), remarkStructure] : [remarkInclude, ...v, ...remarkPlugins, remarkStructure]
   });
 }

package/dist/runtime/vite.cjs

@@ -0,0 +1,150 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime/vite.ts
+var vite_exports = {};
+__export(vite_exports, {
+  createClientLoader: () => createClientLoader,
+  fromConfig: () => fromConfig,
+  toClientRenderer: () => toClientRenderer
+});
+module.exports = __toCommonJS(vite_exports);
+var import_react = require("react");
+function fromConfig() {
+  function normalize(entries) {
+    const out = {};
+    for (const k in entries) {
+      const mappedK = k.startsWith("./") ? k.slice(2) : k;
+      out[mappedK] = entries[k];
+    }
+    return out;
+  }
+  function mapPageData(entry) {
+    const { toc, structuredData } = entry;
+    return {
+      ...entry.frontmatter,
+      default: entry.default,
+      toc,
+      structuredData,
+      _exports: entry
+    };
+  }
+  return {
+    doc(_, glob) {
+      return normalize(glob);
+    },
+    meta(_, glob) {
+      return normalize(glob);
+    },
+    docs(_, { doc, meta }) {
+      return {
+        doc: normalize(doc),
+        meta: normalize(meta)
+      };
+    },
+    source(doc, meta) {
+      const virtualFiles = [];
+      for (const [file, content] of Object.entries(doc)) {
+        virtualFiles.push({
+          type: "page",
+          path: file,
+          data: mapPageData(content)
+        });
+      }
+      for (const [file, content] of Object.entries(meta)) {
+        virtualFiles.push({
+          type: "meta",
+          path: file,
+          data: content
+        });
+      }
+      return {
+        files: virtualFiles
+      };
+    },
+    async sourceAsync(doc, meta) {
+      const virtualFiles = [];
+      for (const [file, content] of Object.entries(doc)) {
+        virtualFiles.push({
+          type: "page",
+          path: file,
+          data: mapPageData(await content())
+        });
+      }
+      for (const [file, content] of Object.entries(meta)) {
+        virtualFiles.push({
+          type: "meta",
+          path: file,
+          data: await content()
+        });
+      }
+      return {
+        files: virtualFiles
+      };
+    }
+  };
+}
+var loaderStore = /* @__PURE__ */ new Map();
+function createClientLoader(files, options) {
+  const { id = "", component } = options;
+  const store = loaderStore.get(id) ?? {
+    preloaded: /* @__PURE__ */ new Map()
+  };
+  loaderStore.set(id, store);
+  let renderer;
+  return {
+    async preload(path) {
+      const loaded = await files[path]();
+      store.preloaded.set(path, loaded);
+      return loaded;
+    },
+    getComponent(path) {
+      renderer ??= toClientRenderer(files, component, {
+        cache: store.preloaded
+      });
+      return renderer[path];
+    }
+  };
+}
+function toClientRenderer(files, component, options = {}) {
+  const { cache } = options;
+  const renderer = {};
+  for (const k in files) {
+    const OnDemand = (0, import_react.lazy)(async () => {
+      const loaded = await files[k]();
+      return { default: (props) => component(loaded, props) };
+    });
+    if (cache) {
+      renderer[k] = (props) => {
+        const cached = cache.get(k);
+        if (!cached) return (0, import_react.createElement)(OnDemand, props);
+        return component(cached, props);
+      };
+    } else {
+      renderer[k] = OnDemand;
+    }
+  }
+  return renderer;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createClientLoader,
+  fromConfig,
+  toClientRenderer
+});

package/dist/runtime/vite.d.cts

@@ -0,0 +1,71 @@
+import { TableOfContents } from 'fumadocs-core/server';
+import { FC, ReactNode } from 'react';
+import { MDXProps } from 'mdx/types';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { D as DocCollection, M as MetaCollection, a as DocsCollection } from '../define-CCrinVBZ.cjs';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import 'zod';
+import '@mdx-js/mdx';
+import 'unified';
+
+type CompiledMDXFile<Frontmatter> = {
+    frontmatter: Frontmatter;
+    toc: TableOfContents;
+    default: FC<MDXProps>;
+    structuredData: StructuredData;
+} & Record<string, unknown>;
+type MDXFileToPageData<Frontmatter> = Frontmatter & {
+    toc: TableOfContents;
+    default: FC<MDXProps>;
+    structuredData: StructuredData;
+    _exports: Record<string, unknown>;
+};
+type AttachGlobValue<GlobValue, Attach> = GlobValue extends () => Promise<unknown> ? () => Promise<Attach> : Attach;
+declare function fromConfig<Config>(): {
+    doc: <Name extends keyof Config, GlobValue>(name: Name, glob: Record<string, GlobValue>) => Config[Name] extends DocCollection<infer Schema> ? Record<string, AttachGlobValue<GlobValue, CompiledMDXFile<StandardSchemaV1.InferOutput<Schema>>>> : never;
+    meta: <Name extends keyof Config, GlobValue>(name: Name, glob: Record<string, GlobValue>) => Config[Name] extends MetaCollection<infer Schema> ? AttachGlobValue<GlobValue, StandardSchemaV1.InferOutput<Schema>> : never;
+    docs: <Name extends keyof Config, DocGlobValue, MetaGlobValue>(name: Name, options: {
+        meta: Record<string, MetaGlobValue>;
+        doc: Record<string, DocGlobValue>;
+    }) => Config[Name] extends DocsCollection<infer DocSchema, infer MetaSchema> ? {
+        doc: Record<string, AttachGlobValue<DocGlobValue, CompiledMDXFile<StandardSchemaV1.InferOutput<DocSchema>>>>;
+        meta: Record<string, AttachGlobValue<MetaGlobValue, StandardSchemaV1.InferOutput<MetaSchema>>>;
+    } : never;
+    source: <DocOut extends PageData, MetaOut extends MetaData>(doc: Record<string, CompiledMDXFile<DocOut>>, meta: Record<string, MetaOut>) => Source<{
+        pageData: MDXFileToPageData<DocOut>;
+        metaData: MetaOut;
+    }>;
+    sourceAsync: <DocOut extends PageData, MetaOut extends MetaData>(doc: Record<string, () => Promise<CompiledMDXFile<DocOut>>>, meta: Record<string, () => Promise<MetaOut>>) => Promise<Source<{
+        pageData: MDXFileToPageData<DocOut>;
+        metaData: MetaOut;
+    }>>;
+};
+interface ClientLoaderOptions<Frontmatter, Props> {
+    /**
+     * Loader ID (usually your collection name)
+     *
+     * The code splitting strategy of frameworks like Tanstack Start may duplicate `createClientLoader()` into different chunks.
+     *
+     * We use loader ID to share cache between multiple instances of client loader.
+     *
+     * @defaultValue ''
+     */
+    id?: string;
+    component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode;
+}
+interface ClientLoader<Frontmatter, Props> {
+    preload: (path: string) => Promise<CompiledMDXFile<Frontmatter>>;
+    /**
+     * Get a component that renders content with `React.lazy`
+     */
+    getComponent: (path: string) => FC<Props>;
+}
+declare function createClientLoader<Frontmatter, Props = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, options: ClientLoaderOptions<Frontmatter, Props>): ClientLoader<Frontmatter, Props>;
+interface ClientRendererOptions<Frontmatter> {
+    cache?: Map<string, CompiledMDXFile<Frontmatter>>;
+}
+type ClientRenderer<Props> = Record<string, FC<Props>>;
+declare function toClientRenderer<Frontmatter, Props = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode, options?: ClientRendererOptions<Frontmatter>): ClientRenderer<Props>;
+
+export { type ClientLoader, type ClientLoaderOptions, type ClientRendererOptions, type CompiledMDXFile, createClientLoader, fromConfig, toClientRenderer };

package/dist/runtime/vite.d.ts

@@ -0,0 +1,71 @@
+import { TableOfContents } from 'fumadocs-core/server';
+import { FC, ReactNode } from 'react';
+import { MDXProps } from 'mdx/types';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { D as DocCollection, M as MetaCollection, a as DocsCollection } from '../define-CCrinVBZ.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { PageData, MetaData, Source } from 'fumadocs-core/source';
+import 'zod';
+import '@mdx-js/mdx';
+import 'unified';
+
+type CompiledMDXFile<Frontmatter> = {
+    frontmatter: Frontmatter;
+    toc: TableOfContents;
+    default: FC<MDXProps>;
+    structuredData: StructuredData;
+} & Record<string, unknown>;
+type MDXFileToPageData<Frontmatter> = Frontmatter & {
+    toc: TableOfContents;
+    default: FC<MDXProps>;
+    structuredData: StructuredData;
+    _exports: Record<string, unknown>;
+};
+type AttachGlobValue<GlobValue, Attach> = GlobValue extends () => Promise<unknown> ? () => Promise<Attach> : Attach;
+declare function fromConfig<Config>(): {
+    doc: <Name extends keyof Config, GlobValue>(name: Name, glob: Record<string, GlobValue>) => Config[Name] extends DocCollection<infer Schema> ? Record<string, AttachGlobValue<GlobValue, CompiledMDXFile<StandardSchemaV1.InferOutput<Schema>>>> : never;
+    meta: <Name extends keyof Config, GlobValue>(name: Name, glob: Record<string, GlobValue>) => Config[Name] extends MetaCollection<infer Schema> ? AttachGlobValue<GlobValue, StandardSchemaV1.InferOutput<Schema>> : never;
+    docs: <Name extends keyof Config, DocGlobValue, MetaGlobValue>(name: Name, options: {
+        meta: Record<string, MetaGlobValue>;
+        doc: Record<string, DocGlobValue>;
+    }) => Config[Name] extends DocsCollection<infer DocSchema, infer MetaSchema> ? {
+        doc: Record<string, AttachGlobValue<DocGlobValue, CompiledMDXFile<StandardSchemaV1.InferOutput<DocSchema>>>>;
+        meta: Record<string, AttachGlobValue<MetaGlobValue, StandardSchemaV1.InferOutput<MetaSchema>>>;
+    } : never;
+    source: <DocOut extends PageData, MetaOut extends MetaData>(doc: Record<string, CompiledMDXFile<DocOut>>, meta: Record<string, MetaOut>) => Source<{
+        pageData: MDXFileToPageData<DocOut>;
+        metaData: MetaOut;
+    }>;
+    sourceAsync: <DocOut extends PageData, MetaOut extends MetaData>(doc: Record<string, () => Promise<CompiledMDXFile<DocOut>>>, meta: Record<string, () => Promise<MetaOut>>) => Promise<Source<{
+        pageData: MDXFileToPageData<DocOut>;
+        metaData: MetaOut;
+    }>>;
+};
+interface ClientLoaderOptions<Frontmatter, Props> {
+    /**
+     * Loader ID (usually your collection name)
+     *
+     * The code splitting strategy of frameworks like Tanstack Start may duplicate `createClientLoader()` into different chunks.
+     *
+     * We use loader ID to share cache between multiple instances of client loader.
+     *
+     * @defaultValue ''
+     */
+    id?: string;
+    component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode;
+}
+interface ClientLoader<Frontmatter, Props> {
+    preload: (path: string) => Promise<CompiledMDXFile<Frontmatter>>;
+    /**
+     * Get a component that renders content with `React.lazy`
+     */
+    getComponent: (path: string) => FC<Props>;
+}
+declare function createClientLoader<Frontmatter, Props = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, options: ClientLoaderOptions<Frontmatter, Props>): ClientLoader<Frontmatter, Props>;
+interface ClientRendererOptions<Frontmatter> {
+    cache?: Map<string, CompiledMDXFile<Frontmatter>>;
+}
+type ClientRenderer<Props> = Record<string, FC<Props>>;
+declare function toClientRenderer<Frontmatter, Props = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode, options?: ClientRendererOptions<Frontmatter>): ClientRenderer<Props>;
+
+export { type ClientLoader, type ClientLoaderOptions, type ClientRendererOptions, type CompiledMDXFile, createClientLoader, fromConfig, toClientRenderer };