fumadocs-mdx 11.10.1 → 12.0.1

package/dist/bin.cjs

@@ -30,86 +30,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/mdx-plugins/remark-postprocess.ts
-function remarkPostprocess({
-  injectExports
-}) {
-  return (tree, file) => {
-    let title;
-    const urls = [];
-    (0, import_unist_util_visit.visit)(tree, ["heading", "link"], (node) => {
-      if (node.type === "heading" && node.depth === 1) {
-        title = flattenNode(node);
-      }
-      if (node.type !== "link") return;
-      urls.push({
-        href: node.url
-      });
-      return "skip";
-    });
-    if (title) {
-      file.data.frontmatter ??= {};
-      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
-    }
-    file.data.extractedReferences = urls;
-    for (const name of injectExports) {
-      if (!(name in file.data)) continue;
-      tree.children.unshift(getMdastExport(name, file.data[name]));
-    }
-  };
-}
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
-function getMdastExport(name, value) {
-  return {
-    type: "mdxjsEsm",
-    value: "",
-    data: {
-      estree: {
-        type: "Program",
-        sourceType: "module",
-        body: [
-          {
-            type: "ExportNamedDeclaration",
-            attributes: [],
-            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_unist_util_visit, import_estree_util_value_to_estree;
-var init_remark_postprocess = __esm({
-  "src/mdx-plugins/remark-postprocess.ts"() {
-    "use strict";
-    import_unist_util_visit = require("unist-util-visit");
-    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, {
+// src/loaders/mdx/preset.ts
+var preset_exports = {};
+__export(preset_exports, {
   getDefaultMDXOptions: () => getDefaultMDXOptions
 });
 function pluginOption(def, options = []) {
@@ -132,13 +55,6 @@ function getDefaultMDXOptions({
   _withoutBundler = false,
   ...mdxOptions
 }) {
-  const mdxExports = [
-    "structuredData",
-    "extractedReferences",
-    "frontmatter",
-    "lastModified",
-    ...valueToExport
-  ];
   const remarkPlugins = pluginOption(
     (v) => [
       plugins.remarkGfm,
@@ -166,10 +82,15 @@ function getDefaultMDXOptions({
         plugins.remarkStructure,
         remarkStructureOptions
       ],
-      [
-        remarkPostprocess,
-        { injectExports: mdxExports }
-      ]
+      () => {
+        return (_, file) => {
+          file.data["mdx-export"] ??= [];
+          for (const name of valueToExport) {
+            if (name in file.data)
+              file.data["mdx-export"].push({ name, value: file.data[name] });
+          }
+        };
+      }
     ],
     mdxOptions.remarkPlugins
   );
@@ -189,11 +110,10 @@ function getDefaultMDXOptions({
   };
 }
 var plugins;
-var init_mdx_options = __esm({
-  "src/utils/mdx-options.ts"() {
+var init_preset = __esm({
+  "src/loaders/mdx/preset.ts"() {
     "use strict";
     plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-    init_remark_postprocess();
   }
 });
 
@@ -233,7 +153,7 @@ function buildConfig(config) {
       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));
+        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
         if (options?.preset === "minimal") return options;
         return getDefaultMDXOptions2({
           ...options,
@@ -252,39 +172,7 @@ var init_build = __esm({
   }
 });
 
-// src/utils/config.ts
-function findConfigFile() {
-  return path.resolve("source.config.ts");
-}
-async function isZod3() {
-  try {
-    const content = JSON.parse(
-      (await fs.readFile("node_modules/zod/package.json")).toString()
-    );
-    const version = content.version;
-    return typeof version === "string" && version.startsWith("3.");
-  } catch {
-    return false;
-  }
-}
-function createCompatZodPlugin() {
-  return {
-    name: "replace-zod-import",
-    async setup(build) {
-      const usingZod3 = await isZod3();
-      if (!usingZod3) return;
-      console.warn(
-        "[Fumadocs MDX] Noticed Zod v3 in your node_modules, we recommend upgrading to Zod v4 for better compatibility."
-      );
-      build.onResolve({ filter: /^fumadocs-mdx\/config$/ }, () => {
-        return {
-          path: "fumadocs-mdx/config/zod-3",
-          external: true
-        };
-      });
-    }
-  };
-}
+// src/loaders/config/load.ts
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -296,7 +184,6 @@ async function compileConfig(configPath, outDir) {
     platform: "node",
     format: "esm",
     packages: "external",
-    plugins: [createCompatZodPlugin()],
     outExtension: {
       ".js": ".mjs"
     },
@@ -329,8 +216,8 @@ async function getConfigHash(configPath) {
   throw new Error("Cannot find config file");
 }
 var fs, path, import_node_url, cache;
-var init_config = __esm({
-  "src/utils/config.ts"() {
+var init_load = __esm({
+  "src/loaders/config/load.ts"() {
     "use strict";
     fs = __toESM(require("fs/promises"), 1);
     path = __toESM(require("path"), 1);
@@ -384,29 +271,34 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
   }
 });
 
-// src/map/file-cache.ts
-var import_lru_cache, map, fileCache;
+// src/next/map/file-cache.ts
+function toFullPath(file) {
+  if (import_node_path.default.isAbsolute(file)) {
+    return import_node_path.default.relative(process.cwd(), file);
+  }
+  return file;
+}
+async function readFileWithCache(file) {
+  const fullPath = toFullPath(file);
+  const cached = map.get(fullPath);
+  if (cached) return cached;
+  const read = import_promises.default.readFile(fullPath).then((s) => s.toString());
+  map.set(fullPath, read);
+  return read;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
+var import_lru_cache, import_promises, import_node_path, map;
 var init_file_cache = __esm({
-  "src/map/file-cache.ts"() {
+  "src/next/map/file-cache.ts"() {
     "use strict";
     import_lru_cache = require("lru-cache");
+    import_promises = __toESM(require("fs/promises"), 1);
+    import_node_path = __toESM(require("path"), 1);
     map = new import_lru_cache.LRUCache({
-      max: 200
+      max: 100
     });
-    fileCache = {
-      read(namespace, path8) {
-        return map.get(`${namespace}.${path8}`);
-      },
-      write(namespace, path8, data) {
-        map.set(`${namespace}.${path8}`, data);
-      },
-      removeCache(path8) {
-        for (const key of map.keys()) {
-          const keyPath = key.slice(key.indexOf(".") + 1);
-          if (keyPath === path8) map.delete(key);
-        }
-      }
-    };
   }
 });
 
@@ -417,7 +309,7 @@ async function getGitTimestamp(file) {
   try {
     const out = await (0, import_tinyexec.x)(
       "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path.default.relative(process.cwd(), file)],
+      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
       {
         throwOnError: true
       }
@@ -429,11 +321,11 @@ async function getGitTimestamp(file) {
     return;
   }
 }
-var import_node_path, import_tinyexec, cache2;
+var import_node_path2, import_tinyexec, cache2;
 var init_git_timestamp = __esm({
   "src/utils/git-timestamp.ts"() {
     "use strict";
-    import_node_path = __toESM(require("path"), 1);
+    import_node_path2 = __toESM(require("path"), 1);
     import_tinyexec = require("tinyexec");
     cache2 = /* @__PURE__ */ new Map();
   }
@@ -476,7 +368,7 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, config) {
-  const ext = import_node_path2.default.extname(file);
+  const ext = import_node_path3.default.extname(file);
   let filename;
   if (ext === ".ts" && config.jsExtension) {
     filename = file.substring(0, file.length - ext.length) + ".js";
@@ -487,23 +379,23 @@ function toImportPath(file, config) {
   }
   let importPath;
   if ("relativeTo" in config) {
-    importPath = import_node_path2.default.relative(config.relativeTo, filename);
-    if (!import_node_path2.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = import_node_path3.default.relative(config.relativeTo, filename);
+    if (!import_node_path3.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
       importPath = `./${importPath}`;
     }
   } else {
-    importPath = import_node_path2.default.resolve(filename);
+    importPath = import_node_path3.default.resolve(filename);
   }
-  return importPath.replaceAll(import_node_path2.default.sep, "/");
+  return importPath.replaceAll(import_node_path3.default.sep, "/");
 }
 function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-var import_node_path2;
+var import_node_path3;
 var init_import_formatter = __esm({
   "src/utils/import-formatter.ts"() {
     "use strict";
-    import_node_path2 = __toESM(require("path"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
   }
 });
 
@@ -530,12 +422,7 @@ var init_collections = __esm({
   }
 });
 
-// src/map/generate.ts
-async function readFileWithCache(file) {
-  const cached = fileCache.read("read-file", file);
-  if (cached) return cached;
-  return (await fs2.readFile(file)).toString();
-}
+// src/next/map/generate.ts
 async function generateJS(configPath, config, importPath, configHash = false) {
   let asyncInit = false;
   const lines = [
@@ -562,7 +449,7 @@ async function generateJS(configPath, config, importPath, configHash = false) {
         getImportCode({
           type: "namespace",
           name: importId,
-          specifier: `${toImportPath(file.absolutePath, importPath)}?${params.join("&")}`
+          specifier: `${toImportPath(file.fullPath, importPath)}?${params.join("&")}`
         })
       );
       return `{ info: ${JSON.stringify(file)}, data: ${importId} }`;
@@ -571,17 +458,17 @@ async function generateJS(configPath, config, importPath, configHash = false) {
   }
   async function getMetaEntries(collection, files) {
     const items = files.map(async (file) => {
-      const source = await readFileWithCache(file.absolutePath).catch(() => "");
-      let data = source.length === 0 ? {} : parseMetaEntry(file.absolutePath, source);
+      const source = await readFileWithCache(file.fullPath).catch(() => "");
+      let data = source.length === 0 ? {} : parseMetaEntry(file.fullPath, source);
       if (collection?.schema) {
         data = await validate(
           collection.schema,
           data,
           {
             source,
-            path: file.absolutePath
+            path: file.fullPath
           },
-          `invalid data in ${file.absolutePath}`
+          `invalid data in ${file.fullPath}`
         );
       }
       return JSON.stringify({
@@ -599,33 +486,40 @@ async function generateJS(configPath, config, importPath, configHash = false) {
           specifier: "fumadocs-mdx/runtime/async",
           names: ["_runtimeAsync", "buildConfig"]
         }),
-        "const _sourceConfig = buildConfig(_source)"
+        "const _sourceConfig = buildConfig(_source)",
+        getImportCode({
+          type: "default",
+          name: "path",
+          specifier: "node:path"
+        })
       );
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
-      const parsed = fumaMatter(
-        await readFileWithCache(file.absolutePath).catch(() => "")
-      );
+      const content = await readFileWithCache(file.fullPath).catch(() => "");
+      const parsed = fumaMatter(content);
       let data = parsed.data;
       if (collection.schema) {
         data = await validate(
           collection.schema,
           parsed.data,
-          { path: file.absolutePath, source: parsed.content },
-          `invalid frontmatter in ${file.absolutePath}`
+          { path: file.fullPath, source: parsed.content },
+          `invalid frontmatter in ${file.fullPath}`
         );
       }
       let lastModified;
       if (config.global?.lastModifiedTime === "git") {
-        lastModified = await getGitTimestamp(file.absolutePath);
+        lastModified = await getGitTimestamp(file.fullPath);
       }
-      return JSON.stringify({
-        info: file,
-        lastModified,
-        data,
-        content: { body: parsed.content, matter: parsed.matter }
-      });
+      const hash = (0, import_node_crypto.createHash)("md5").update(content).digest("hex");
+      const infoStr = [];
+      for (const [k, v] of Object.entries({ ...file, hash })) {
+        infoStr.push(`${k}: ${JSON.stringify(v)}`);
+      }
+      infoStr.push(
+        `absolutePath: path.resolve(${JSON.stringify(file.fullPath)})`
+      );
+      return `{ info: { ${infoStr.join(", ")} }, lastModified: ${JSON.stringify(lastModified)}, data: ${JSON.stringify(data)} }`;
     });
     return Promise.all(entries2);
   }
@@ -665,14 +559,14 @@ async function getCollectionFiles(collection) {
   await Promise.all(
     dirs.map(async (dir) => {
       const result = await (0, import_tinyglobby.glob)(patterns, {
-        cwd: path4.resolve(dir),
-        absolute: true
+        cwd: path5.resolve(dir)
       });
       for (const item of result) {
         if (!isFileSupported(item, collection)) continue;
-        files.set(item, {
-          path: path4.relative(dir, item),
-          absolutePath: item
+        const fullPath = path5.join(dir, item);
+        files.set(fullPath, {
+          path: item,
+          fullPath
         });
       }
     })
@@ -680,7 +574,7 @@ async function getCollectionFiles(collection) {
   return Array.from(files.values());
 }
 function parseMetaEntry(file, content) {
-  const extname2 = path4.extname(file);
+  const extname2 = path5.extname(file);
   try {
     if (extname2 === ".json") return JSON.parse(content);
     if (extname2 === ".yaml") return (0, import_js_yaml2.load)(content);
@@ -691,12 +585,12 @@ function parseMetaEntry(file, content) {
   }
   throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
 }
-var path4, fs2, import_tinyglobby, import_js_yaml2;
+var path5, import_node_crypto, import_tinyglobby, import_js_yaml2;
 var init_generate = __esm({
-  "src/map/generate.ts"() {
+  "src/next/map/generate.ts"() {
     "use strict";
-    path4 = __toESM(require("path"), 1);
-    fs2 = __toESM(require("fs/promises"), 1);
+    path5 = __toESM(require("path"), 1);
+    import_node_crypto = require("crypto");
     import_tinyglobby = require("tinyglobby");
     init_validation();
     init_file_cache();
@@ -708,7 +602,19 @@ var init_generate = __esm({
   }
 });
 
-// src/map/watcher.ts
+// src/loaders/config/index.ts
+function findConfigFile() {
+  return import_node_path4.default.resolve("source.config.ts");
+}
+var import_node_path4;
+var init_config = __esm({
+  "src/loaders/config/index.ts"() {
+    "use strict";
+    import_node_path4 = __toESM(require("path"), 1);
+  }
+});
+
+// src/next/map/watcher.ts
 var watcher_exports = {};
 __export(watcher_exports, {
   watcher: () => watcher
@@ -732,17 +638,17 @@ function watcher(configPath, config, ignored) {
 }
 var import_chokidar;
 var init_watcher = __esm({
-  "src/map/watcher.ts"() {
+  "src/next/map/watcher.ts"() {
     "use strict";
     import_chokidar = require("chokidar");
   }
 });
 
-// src/map/index.ts
+// src/next/map/index.ts
 async function start(dev, configPath, outDir) {
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, outDir, configHash, true);
-  const outPath = path5.resolve(outDir, `index.ts`);
+  const outPath = path7.resolve(outDir, `index.ts`);
   async function updateMapFile() {
     const start3 = performance.now();
     try {
@@ -773,14 +679,14 @@ async function start(dev, configPath, outDir) {
     });
     instance.on("all", (event, file) => {
       if (typeof file !== "string") return;
-      const absolutePath = path5.resolve(file);
+      const absolutePath = path7.resolve(file);
       const onUpdate = async () => {
         const isConfigFile = absolutePath === configPath;
         if (isConfigFile) {
           configHash = await getConfigHash(configPath);
           config = await loadConfig(configPath, outDir, configHash, true);
         }
-        if (event === "change") fileCache.removeCache(absolutePath);
+        if (event === "change") removeFileCache(absolutePath);
         await updateMapFile();
       };
       void onUpdate();
@@ -791,13 +697,13 @@ async function start(dev, configPath, outDir) {
     });
   }
 }
-var path5, fs3;
+var path7, fs3;
 var init_map = __esm({
-  "src/map/index.ts"() {
+  "src/next/map/index.ts"() {
     "use strict";
-    path5 = __toESM(require("path"), 1);
+    path7 = __toESM(require("path"), 1);
     fs3 = __toESM(require("fs/promises"), 1);
-    init_config();
+    init_load();
     init_generate();
     init_file_cache();
     init_validation();
@@ -891,24 +797,25 @@ __export(next_exports, {
 });
 async function postInstall(configPath = findConfigFile(), outDir = ".source") {
   const config = await loadConfig(configPath, outDir, void 0, true);
-  const outPath = import_node_path3.default.join(outDir, "index.ts");
-  await import_promises.default.rm(outDir, { recursive: true });
-  await import_promises.default.mkdir(outDir, { recursive: true });
+  const outPath = import_node_path5.default.join(outDir, "index.ts");
+  await import_promises2.default.rm(outDir, { recursive: true });
+  await import_promises2.default.mkdir(outDir, { recursive: true });
   const hash = await getConfigHash(configPath);
-  await import_promises.default.writeFile(
+  await import_promises2.default.writeFile(
     outPath,
     await generateJS(configPath, config, { relativeTo: outDir }, hash)
   );
   console.log("[MDX] types generated");
 }
-var import_node_path3, import_promises;
+var import_node_path5, import_promises2;
 var init_next = __esm({
   "src/next/index.ts"() {
     "use strict";
-    init_config();
-    import_node_path3 = __toESM(require("path"), 1);
-    import_promises = __toESM(require("fs/promises"), 1);
+    init_load();
+    import_node_path5 = __toESM(require("path"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
     init_generate();
+    init_config();
     init_create();
   }
 });
@@ -1028,22 +935,23 @@ async function postInstall2(configPath = findConfigFile(), outDir, addJsExtensio
   const config = await loadConfig(configPath, "node_modules", void 0, true);
   const outFile = "source.generated.ts";
   if (outDir) {
-    await import_promises2.default.mkdir(outDir, { recursive: true });
+    await import_promises3.default.mkdir(outDir, { recursive: true });
   }
-  await import_promises2.default.writeFile(
-    outDir ? import_node_path4.default.join(outDir, outFile) : outFile,
+  await import_promises3.default.writeFile(
+    outDir ? import_node_path6.default.join(outDir, outFile) : outFile,
     entry(configPath, config, outDir ?? process.cwd(), addJsExtension)
   );
   console.log("[MDX] types generated");
 }
-var import_promises2, import_node_path4;
+var import_promises3, import_node_path6;
 var init_postinstall = __esm({
   "src/vite/postinstall.ts"() {
     "use strict";
-    init_config();
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    import_node_path4 = __toESM(require("path"), 1);
+    init_load();
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
     init_generate2();
+    init_config();
   }
 });
 

package/dist/bin.js

@@ -9,7 +9,7 @@ async function start() {
     const { postInstall } = await import("./next/index.js");
     await postInstall(...args);
   } else {
-    const { postInstall } = await import("./postinstall-XV4WSHZP.js");
+    const { postInstall } = await import("./postinstall-SCSXM4IM.js");
     await postInstall(...args);
   }
 }

package/dist/{browser-B2G8uAF2.d.cts → browser-D5lvL8vv.d.ts}

@@ -1,8 +1,55 @@
-import { C as CompiledMDXProperties } from './build-mdx-DnC1jKvn.cjs';
-import { ReactNode, FC } from 'react';
-import { a as DocCollection, b as DocsCollection, M as MetaCollection } from './define-BH4bnHQl.cjs';
+import { createProcessor } from '@mdx-js/mdx';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TableOfContents } from 'fumadocs-core/server';
+import { FC, ReactNode } from 'react';
+import { MDXProps } from 'mdx/types';
+import { E as ExtractedReference, a as DocCollection, b as DocsCollection, M as MetaCollection } from './define--6HQ1ehX.js';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
+type Processor = ReturnType<typeof createProcessor>;
+interface CompilerOptions {
+    addDependency: (file: string) => void;
+}
+interface CompiledMDXProperties<Frontmatter = Record<string, unknown>> {
+    frontmatter: Frontmatter;
+    structuredData: StructuredData;
+    toc: TableOfContents;
+    default: FC<MDXProps>;
+    /**
+     * Only available when `lastModifiedTime` is enabled on MDX loader
+     */
+    lastModified?: Date;
+    extractedReferences?: ExtractedReference[];
+    _markdown?: string;
+}
+interface FumadocsDataMap {
+    /**
+     * [Fumadocs MDX] raw frontmatter, you can modify it
+     */
+    frontmatter?: Record<string, unknown>;
+    /**
+     * [Fumadocs MDX] additional ESM exports to write
+     */
+    'mdx-export'?: {
+        name: string;
+        value: unknown;
+    }[];
+    extractedReferences: ExtractedReference[];
+    /**
+     * [Fumadocs MDX] The compiler object from loader
+     */
+    _compiler?: CompilerOptions;
+    _getProcessor?: (format: 'md' | 'mdx') => Processor;
+    /**
+     * [Fumadocs MDX] Processed Markdown content before `remark-rehype`.
+     */
+    _markdown?: string;
+}
+declare module 'vfile' {
+    interface DataMap extends FumadocsDataMap {
+    }
+}
+
 type CompiledMDXFile<Frontmatter> = CompiledMDXProperties<Frontmatter> & Record<string, unknown>;
 type DocMap<Frontmatter> = Record<string, (() => Promise<CompiledMDXFile<Frontmatter>>) & {
     base: string;
@@ -48,4 +95,4 @@ interface ClientLoader<Frontmatter, Props> {
 declare function createClientLoader<Frontmatter, Props = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, options: ClientLoaderOptions<Frontmatter, Props>): ClientLoader<Frontmatter, Props>;
 declare function toClientRenderer<Frontmatter, Props = object>(files: Record<string, () => Promise<CompiledMDXFile<Frontmatter>>>, component: (loaded: CompiledMDXFile<Frontmatter>, props: Props) => ReactNode): ClientRenderer<Props>;
 
-export { type BaseCreate as B, type CompiledMDXFile as C, type DocMap as D, type LazyDocMap as L, type MetaMap as M, type ClientLoader as a, type ClientLoaderOptions as b, createClientLoader as c, fromConfigBase as f, toClientRenderer as t };
+export { type BaseCreate as B, type ClientLoader as C, type DocMap as D, type LazyDocMap as L, type MetaMap as M, type ClientLoaderOptions as a, type CompiledMDXFile as b, createClientLoader as c, fromConfigBase as f, toClientRenderer as t };