fumadocs-mdx 11.9.1 → 11.10.1

package/dist/vite/index.cjs

@@ -200,7 +200,8 @@ var init_mdx_options = __esm({
 // src/vite/index.ts
 var vite_exports = {};
 __export(vite_exports, {
-  default: () => mdx
+  default: () => mdx,
+  postInstall: () => postInstall
 });
 module.exports = __toCommonJS(vite_exports);
 var import_vite = require("vite");
@@ -255,14 +256,183 @@ function buildConfig(config) {
   };
 }
 
-// src/utils/build-mdx.ts
-var import_mdx = require("@mdx-js/mdx");
+// src/vite/index.ts
+var import_node_querystring2 = require("querystring");
 
-// src/mdx-plugins/remark-include.ts
-var import_unified = require("unified");
-var import_unist_util_visit2 = require("unist-util-visit");
-var path = __toESM(require("path"), 1);
-var fs = __toESM(require("fs/promises"), 1);
+// src/utils/validation.ts
+var import_picocolors = __toESM(require("picocolors"), 1);
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(
+      `${message}:
+${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
+    );
+    this.title = message;
+    this.issues = issues;
+  }
+  toStringFormatted() {
+    return [
+      import_picocolors.default.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => import_picocolors.default.redBright(
+          `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+        )
+      )
+    ].join("\n");
+  }
+};
+async function validate(schema, data, context, errorMessage) {
+  if (typeof schema === "function" && !("~standard" in schema)) {
+    schema = schema(context);
+  }
+  if ("~standard" in schema) {
+    const result = await schema["~standard"].validate(
+      data
+    );
+    if (result.issues) {
+      throw new ValidationError(errorMessage, result.issues);
+    }
+    return result.value;
+  }
+  return data;
+}
+
+// src/vite/index.ts
+var fs6 = __toESM(require("fs/promises"), 1);
+var path8 = __toESM(require("path"), 1);
+var import_js_yaml2 = require("js-yaml");
+
+// src/utils/import-formatter.ts
+var import_node_path = __toESM(require("path"), 1);
+function toImportPath(file, config) {
+  const ext = import_node_path.default.extname(file);
+  let filename;
+  if (ext === ".ts" && config.jsExtension) {
+    filename = file.substring(0, file.length - ext.length) + ".js";
+  } else if (ext === ".ts") {
+    filename = file.substring(0, file.length - ext.length);
+  } else {
+    filename = file;
+  }
+  let importPath;
+  if ("relativeTo" in config) {
+    importPath = import_node_path.default.relative(config.relativeTo, filename);
+    if (!import_node_path.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+      importPath = `./${importPath}`;
+    }
+  } else {
+    importPath = import_node_path.default.resolve(filename);
+  }
+  return importPath.replaceAll(import_node_path.default.sep, "/");
+}
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+
+// src/vite/generate-glob.ts
+function generateGlob(name, patterns, globOptions) {
+  const options = {
+    ...globOptions,
+    query: {
+      ...globOptions?.query,
+      collection: name
+    }
+  };
+  return `import.meta.glob(${JSON.stringify(mapGlobPatterns(patterns))}, ${JSON.stringify(options, null, 2)})`;
+}
+function mapGlobPatterns(patterns) {
+  return patterns.map(enforceRelative);
+}
+function enforceRelative(file) {
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
+}
+function getGlobBase(collection) {
+  let dir = collection.dir;
+  if (Array.isArray(dir)) {
+    if (dir.length !== 1)
+      throw new Error(
+        `[Fumadocs MDX] Vite Plugin doesn't support multiple \`dir\` for a collection at the moment.`
+      );
+    dir = dir[0];
+  }
+  return enforceRelative(dir);
+}
+
+// src/utils/collections.ts
+function getSupportedFormats(collection) {
+  return {
+    doc: ["mdx", "md"],
+    meta: ["json", "yaml"]
+  }[collection.type];
+}
+function getGlobPatterns(collection) {
+  if (collection.files) return collection.files;
+  return [`**/*.{${getSupportedFormats(collection).join(",")}}`];
+}
+
+// src/vite/generate.ts
+function docs(name, collection) {
+  const obj = [
+    ident(`doc: ${doc(name, collection.docs)}`),
+    ident(`meta: ${meta(name, collection.meta)}`)
+  ].join(",\n");
+  return `{
+${obj}
+}`;
+}
+function doc(name, collection) {
+  const patterns = getGlobPatterns(collection);
+  const base = getGlobBase(collection);
+  const docGlob = generateGlob(name, patterns, {
+    base
+  });
+  if (collection.async) {
+    const headBlob = generateGlob(name, patterns, {
+      query: {
+        only: "frontmatter"
+      },
+      import: "frontmatter",
+      base
+    });
+    return `create.docLazy("${name}", "${base}", ${headBlob}, ${docGlob})`;
+  }
+  return `create.doc("${name}", "${base}", ${docGlob})`;
+}
+function meta(name, collection) {
+  const patterns = getGlobPatterns(collection);
+  const base = getGlobBase(collection);
+  return `create.meta("${name}", "${base}", ${generateGlob(name, patterns, {
+    import: "default",
+    base
+  })})`;
+}
+function entry(configPath, config, outDir, jsExtension) {
+  const lines = [
+    '/// <reference types="vite/client" />',
+    `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
+    `import type * as Config from '${toImportPath(configPath, {
+      relativeTo: outDir,
+      jsExtension
+    })}';`,
+    "",
+    `export const create = fromConfig<typeof Config>();`
+  ];
+  for (const [name, collection] of config.collections.entries()) {
+    let body;
+    if (collection.type === "docs") {
+      body = docs(name, collection);
+    } else if (collection.type === "meta") {
+      body = meta(name, collection);
+    } else {
+      body = doc(name, collection);
+    }
+    lines.push("");
+    lines.push(`export const ${name} = ${body};`);
+  }
+  return lines.join("\n");
+}
 
 // src/utils/fuma-matter.ts
 var import_js_yaml = require("js-yaml");
@@ -280,7 +450,46 @@ function fumaMatter(input) {
   return output;
 }
 
+// src/utils/git-timestamp.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_tinyexec = require("tinyexec");
+var cache = /* @__PURE__ */ new Map();
+async function getGitTimestamp(file) {
+  const cached = cache.get(file);
+  if (cached) return cached;
+  try {
+    const out = await (0, import_tinyexec.x)(
+      "git",
+      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
+      {
+        throwOnError: true
+      }
+    );
+    const time = new Date(out.stdout);
+    cache.set(file, time);
+    return time;
+  } catch {
+    return;
+  }
+}
+
+// src/utils/count-lines.ts
+function countLines(s) {
+  let num = 0;
+  for (const c of s) {
+    if (c === "\n") num++;
+  }
+  return num;
+}
+
+// src/utils/build-mdx.ts
+var import_mdx = require("@mdx-js/mdx");
+
 // src/mdx-plugins/remark-include.ts
+var import_unified = require("unified");
+var import_unist_util_visit2 = require("unist-util-visit");
+var path3 = __toESM(require("path"), 1);
+var fs = __toESM(require("fs/promises"), 1);
 var import_remark_parse = __toESM(require("remark-parse"), 1);
 var import_remark_mdx = __toESM(require("remark-mdx"), 1);
 var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
@@ -335,7 +544,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path.extname(file);
+    const ext = path3.extname(file);
     data._compiler?.addDependency(file);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
@@ -361,7 +570,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         );
       parsed = extracted;
     }
-    await update(parsed, path.dirname(file), data);
+    await update(parsed, path3.dirname(file), data);
     return parsed;
   }
   async function update(tree, directory, data) {
@@ -381,7 +590,7 @@ ${e instanceof Error ? e.message : String(e)}`,
           }
         }
         const { file: relativePath, section } = parseSpecifier(specifier);
-        const file = path.resolve(
+        const file = path3.resolve(
           "cwd" in params ? process.cwd() : directory,
           relativePath
         );
@@ -399,7 +608,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path.dirname(file.path), file.data);
+    await update(tree, path3.dirname(file.path), file.data);
   };
 }
 function getDefaultProcessor(format) {
@@ -409,12 +618,12 @@ function getDefaultProcessor(format) {
 }
 
 // src/utils/build-mdx.ts
-var cache = /* @__PURE__ */ new Map();
+var cache2 = /* @__PURE__ */ new Map();
 async function buildMDX(cacheKey, source, options) {
   const { filePath, frontmatter, data, _compiler, ...rest } = options;
   function getProcessor(format) {
     const key = `${cacheKey}:${format}`;
-    let processor = cache.get(key);
+    let processor = cache2.get(key);
     if (!processor) {
       processor = (0, import_mdx.createProcessor)({
         outputFormat: "program",
@@ -422,7 +631,7 @@ async function buildMDX(cacheKey, source, options) {
         remarkPlugins: [remarkInclude, ...rest.remarkPlugins ?? []],
         format
       });
-      cache.set(key, processor);
+      cache2.set(key, processor);
     }
     return processor;
   }
@@ -440,229 +649,241 @@ async function buildMDX(cacheKey, source, options) {
   });
 }
 
-// src/vite/index.ts
-var import_node_querystring = require("querystring");
-
-// src/utils/count-lines.ts
-function countLines(s) {
-  let num = 0;
-  for (const c of s) {
-    if (c === "\n") num++;
-  }
-  return num;
-}
-
-// src/utils/validation.ts
-var import_picocolors = __toESM(require("picocolors"), 1);
-var ValidationError = class extends Error {
-  constructor(message, issues) {
-    super(
-      `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
-    );
-    this.title = message;
-    this.issues = issues;
-  }
-  toStringFormatted() {
-    return [
-      import_picocolors.default.bold(`[MDX] ${this.title}:`),
-      ...this.issues.map(
-        (issue) => import_picocolors.default.redBright(
-          `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
-        )
-      )
-    ].join("\n");
-  }
-};
-async function validate(schema, data, context, errorMessage) {
-  if (typeof schema === "function" && !("~standard" in schema)) {
-    schema = schema(context);
-  }
-  if ("~standard" in schema) {
-    const result = await schema["~standard"].validate(
-      data
+// src/loaders/mdx.ts
+var import_zod = require("zod");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_crypto = require("crypto");
+var querySchema = import_zod.z.object({
+  only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
+  collection: import_zod.z.string().optional(),
+  hash: import_zod.z.string().describe(
+    "the hash of config, used for revalidation on Turbopack/Webpack."
+  ).optional()
+}).loose();
+var cacheEntry = import_zod.z.object({
+  code: import_zod.z.string(),
+  map: import_zod.z.any().optional(),
+  hash: import_zod.z.string().optional()
+});
+function createMdxLoader(configLoader) {
+  return async ({
+    source: value,
+    development: isDevelopment,
+    query,
+    compiler,
+    filePath
+  }) => {
+    const matter = fumaMatter(value);
+    const parsed = querySchema.parse(query);
+    const loaded = await configLoader.getConfig(parsed.hash);
+    const cacheDir = isDevelopment ? void 0 : loaded.global.experimentalBuildCache;
+    const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
+    if (cacheDir) {
+      const cached = await import_promises.default.readFile(import_node_path3.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      if (cached && cached.hash === generateCacheHash(value)) return cached;
+    }
+    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+    let schema;
+    let mdxOptions;
+    switch (collection?.type) {
+      case "doc":
+        mdxOptions = collection.mdxOptions;
+        schema = collection.schema;
+        break;
+      case "docs":
+        mdxOptions = collection.docs.mdxOptions;
+        schema = collection.docs.schema;
+        break;
+    }
+    if (schema) {
+      matter.data = await validate(
+        schema,
+        matter.data,
+        {
+          source: value,
+          path: filePath
+        },
+        `invalid frontmatter in ${filePath}`
+      );
+    }
+    if (parsed.only === "frontmatter") {
+      return {
+        code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+        map: null
+      };
+    }
+    const data = {};
+    if (loaded.global.lastModifiedTime === "git") {
+      data.lastModified = (await getGitTimestamp(filePath))?.getTime();
+    }
+    const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+    const compiled = await buildMDX(
+      `${parsed.hash ?? ""}:${parsed.collection ?? "global"}`,
+      "\n".repeat(lineOffset) + matter.content,
+      {
+        development: isDevelopment,
+        ...mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        data,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler
+      }
     );
-    if (result.issues) {
-      throw new ValidationError(errorMessage, result.issues);
+    const out = {
+      code: String(compiled.value),
+      map: compiled.map
+    };
+    if (cacheDir) {
+      await import_promises.default.mkdir(cacheDir, { recursive: true });
+      await import_promises.default.writeFile(
+        import_node_path3.default.join(cacheDir, cacheKey),
+        JSON.stringify({
+          ...out,
+          hash: generateCacheHash(value)
+        })
+      );
     }
-    return result.value;
-  }
-  return data;
+    return out;
+  };
+}
+function generateCacheHash(input) {
+  return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
 }
 
-// src/vite/index.ts
-var import_zod = require("zod");
-var fs2 = __toESM(require("fs/promises"), 1);
-var path4 = __toESM(require("path"), 1);
-var import_js_yaml2 = require("js-yaml");
-
-// src/utils/git-timestamp.ts
-var import_node_path = __toESM(require("path"), 1);
-var import_tinyexec = require("tinyexec");
-var cache2 = /* @__PURE__ */ new Map();
-async function getGitTimestamp(file) {
-  const cached = cache2.get(file);
-  if (cached) return cached;
+// src/utils/config.ts
+var fs3 = __toESM(require("fs/promises"), 1);
+var path5 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+function findConfigFile() {
+  return path5.resolve("source.config.ts");
+}
+var cache3 = null;
+async function isZod3() {
   try {
-    const out = await (0, import_tinyexec.x)(
-      "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path.default.relative(process.cwd(), file)],
-      {
-        throwOnError: true
-      }
+    const content = JSON.parse(
+      (await fs3.readFile("node_modules/zod/package.json")).toString()
     );
-    const time = new Date(out.stdout);
-    cache2.set(file, time);
-    return time;
+    const version = content.version;
+    return typeof version === "string" && version.startsWith("3.");
   } catch {
-    return;
-  }
-}
-
-// src/utils/import-formatter.ts
-var import_node_path2 = __toESM(require("path"), 1);
-function toImportPath(file, config) {
-  const ext = import_node_path2.default.extname(file);
-  let filename;
-  if (ext === ".ts" && config.jsExtension) {
-    filename = file.substring(0, file.length - ext.length) + ".js";
-  } else if (ext === ".ts") {
-    filename = file.substring(0, file.length - ext.length);
-  } else {
-    filename = file;
-  }
-  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 = `./${importPath}`;
-    }
-  } else {
-    importPath = import_node_path2.default.resolve(filename);
+    return false;
   }
-  return importPath.replaceAll(import_node_path2.default.sep, "/");
-}
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-
-// src/vite/generate-glob.ts
-function generateGlob(name, patterns, globOptions) {
-  const options = {
-    ...globOptions,
-    query: {
-      ...globOptions?.query,
-      collection: name
+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
+        };
+      });
     }
   };
-  return `import.meta.glob(${JSON.stringify(mapGlobPatterns(patterns))}, ${JSON.stringify(options, null, 2)})`;
-}
-function mapGlobPatterns(patterns) {
-  return patterns.map(enforceRelative);
 }
-function enforceRelative(file) {
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
+async function compileConfig(configPath, outDir) {
+  const { build } = await import("esbuild");
+  const transformed = await build({
+    entryPoints: [{ in: configPath, out: "source.config" }],
+    bundle: true,
+    outdir: outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    plugins: [createCompatZodPlugin()],
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
 }
-function getGlobBase(collection) {
-  let dir = collection.dir;
-  if (Array.isArray(dir)) {
-    if (dir.length !== 1)
-      throw new Error(
-        `[Fumadocs MDX] Vite Plugin doesn't support multiple \`dir\` for a collection at the moment.`
-      );
-    dir = dir[0];
+async function loadConfig(configPath, outDir, hash, build = false) {
+  if (cache3 && cache3.hash === hash) {
+    return await cache3.config;
   }
-  return enforceRelative(dir);
+  if (build) await compileConfig(configPath, outDir);
+  const url = (0, import_node_url.pathToFileURL)(path5.resolve(outDir, "source.config.mjs"));
+  const config = import(`${url.href}?hash=${hash}`).then((loaded) => {
+    return buildConfig(
+      // every call to `loadConfig` will cause the previous cache to be ignored
+      loaded
+    );
+  });
+  if (hash) cache3 = { config, hash };
+  return await config;
 }
 
-// src/utils/collections.ts
-function getSupportedFormats(collection) {
+// src/loaders/config-loader.ts
+function resolvedConfig(loaded) {
   return {
-    doc: ["mdx", "md"],
-    meta: ["json", "yaml"]
-  }[collection.type];
-}
-function getGlobPatterns(collection) {
-  if (collection.files) return collection.files;
-  return [`**/*.{${getSupportedFormats(collection).join(",")}}`];
+    getConfig() {
+      return loaded;
+    }
+  };
 }
 
-// src/vite/generate.ts
-function docs(name, collection) {
-  const obj = [
-    ident(`doc: ${doc(name, collection.docs)}`),
-    ident(`meta: ${meta(name, collection.meta)}`)
-  ].join(",\n");
-  return `{
-${obj}
-}`;
-}
-function doc(name, collection) {
-  const patterns = getGlobPatterns(collection);
-  const base = getGlobBase(collection);
-  const docGlob = generateGlob(name, patterns, {
-    base
-  });
-  if (collection.async) {
-    const headBlob = generateGlob(name, patterns, {
-      query: {
-        only: "frontmatter"
-      },
-      import: "frontmatter",
-      base
+// src/loaders/adapter.ts
+var import_node_url2 = require("url");
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_node_querystring = require("querystring");
+var import_node_path4 = __toESM(require("path"), 1);
+function toVite(loader) {
+  return async function(file, query, value) {
+    const result = await loader({
+      filePath: file,
+      query: (0, import_node_querystring.parse)(query),
+      source: value,
+      development: this.environment.mode === "dev",
+      compiler: {
+        addDependency: (file2) => {
+          this.addWatchFile(file2);
+        }
+      }
     });
-    return `create.docLazy("${name}", "${base}", ${headBlob}, ${docGlob})`;
-  }
-  return `create.doc("${name}", "${base}", ${docGlob})`;
-}
-function meta(name, collection) {
-  const patterns = getGlobPatterns(collection);
-  const base = getGlobBase(collection);
-  return `create.meta("${name}", "${base}", ${generateGlob(name, patterns, {
-    import: "default",
-    base
-  })})`;
+    return {
+      code: result.code,
+      map: result.map
+    };
+  };
 }
-function entry(configPath, config, outDir, jsExtension) {
-  const lines = [
-    '/// <reference types="vite/client" />',
-    `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
-    `import type * as Config from '${toImportPath(configPath, {
-      relativeTo: outDir,
-      jsExtension
-    })}';`,
-    "",
-    `export const create = fromConfig<typeof Config>();`
-  ];
-  for (const [name, collection] of config.collections.entries()) {
-    let body;
-    if (collection.type === "docs") {
-      body = docs(name, collection);
-    } else if (collection.type === "meta") {
-      body = meta(name, collection);
-    } else {
-      body = doc(name, collection);
-    }
-    lines.push("");
-    lines.push(`export const ${name} = ${body};`);
+
+// src/vite/postinstall.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+async function postInstall(configPath = findConfigFile(), outDir, addJsExtension = false) {
+  const config = await loadConfig(configPath, "node_modules", void 0, true);
+  const outFile = "source.generated.ts";
+  if (outDir) {
+    await import_promises3.default.mkdir(outDir, { recursive: true });
   }
-  return lines.join("\n");
+  await import_promises3.default.writeFile(
+    outDir ? import_node_path5.default.join(outDir, outFile) : outFile,
+    entry(configPath, config, outDir ?? process.cwd(), addJsExtension)
+  );
+  console.log("[MDX] types generated");
 }
 
 // src/vite/index.ts
 var FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
-var querySchema = import_zod.z.object({
-  only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
-  collection: import_zod.z.string().optional()
-}).loose();
 function mdx(config, options = {}) {
   const { generateIndexFile = true, configPath = "source.config.ts" } = options;
   const loaded = buildConfig(config);
-  async function transformMeta(path5, query, value) {
-    const isJson = path5.endsWith(".json");
-    const parsed = (0, import_node_querystring.parse)(query);
+  const mdxLoader = toVite(createMdxLoader(resolvedConfig(loaded)));
+  async function transformMeta(path9, query, value) {
+    const isJson = path9.endsWith(".json");
+    const parsed = (0, import_node_querystring2.parse)(query);
     const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
     if (!collection) return null;
     let schema;
@@ -684,75 +905,14 @@ function mdx(config, options = {}) {
     const out = await validate(
       schema,
       data,
-      { path: path5, source: value },
-      `invalid data in ${path5}`
+      { path: path9, source: value },
+      `invalid data in ${path9}`
     );
     return {
       code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
       map: null
     };
   }
-  async function transformContent(file, query, value) {
-    const matter = fumaMatter(value);
-    const isDevelopment = this.environment.mode === "dev";
-    const parsed = querySchema.parse((0, import_node_querystring.parse)(query));
-    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
-    let schema;
-    let mdxOptions;
-    switch (collection?.type) {
-      case "doc":
-        mdxOptions = collection.mdxOptions;
-        schema = collection.schema;
-        break;
-      case "docs":
-        mdxOptions = collection.docs.mdxOptions;
-        schema = collection.docs.schema;
-        break;
-    }
-    if (schema) {
-      matter.data = await validate(
-        schema,
-        matter.data,
-        {
-          source: value,
-          path: file
-        },
-        `invalid frontmatter in ${file}`
-      );
-    }
-    if (parsed.only === "frontmatter") {
-      return {
-        code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
-        map: null
-      };
-    }
-    const data = {};
-    if (loaded.global.lastModifiedTime === "git") {
-      data.lastModified = (await getGitTimestamp(file))?.getTime();
-    }
-    mdxOptions ??= await loaded.getDefaultMDXOptions();
-    const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-    const compiled = await buildMDX(
-      parsed.collection ?? "global",
-      "\n".repeat(lineOffset) + matter.content,
-      {
-        development: isDevelopment,
-        ...mdxOptions,
-        data,
-        filePath: file,
-        frontmatter: matter.data,
-        _compiler: {
-          addDependency: (file2) => {
-            this.addWatchFile(file2);
-          }
-        }
-      }
-    );
-    return {
-      code: String(compiled.value),
-      map: compiled.map
-    };
-  }
   return {
     name: "fumadocs-mdx",
     // needed, otherwise other plugins will be executed before our `transform`.
@@ -773,8 +933,8 @@ function mdx(config, options = {}) {
       console.log("[Fumadocs MDX] Generating index files");
       const outDir = process.cwd();
       const outFile = "source.generated.ts";
-      await fs2.writeFile(
-        path4.join(outDir, outFile),
+      await fs6.writeFile(
+        path8.join(outDir, outFile),
         entry(
           configPath,
           loaded,
@@ -785,12 +945,12 @@ function mdx(config, options = {}) {
     },
     async transform(value, id) {
       const [file, query = ""] = id.split("?");
-      const ext = path4.extname(file);
+      const ext = path8.extname(file);
       try {
         if ([".yaml", ".json"].includes(ext))
           return await transformMeta(file, query, value);
         if ([".md", ".mdx"].includes(ext))
-          return await transformContent.call(this, file, query, value);
+          return await mdxLoader.call(this, file, query, value);
       } catch (e) {
         if (e instanceof ValidationError) {
           throw new Error(e.toStringFormatted());
@@ -800,3 +960,7 @@ function mdx(config, options = {}) {
     }
   };
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  postInstall
+});