fumadocs-mdx 13.0.7 → 14.0.0

package/dist/webpack/mdx.cjs

@@ -30,251 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/loaders/mdx/preset.ts
-var preset_exports = {};
-__export(preset_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,
-  _withoutBundler = false,
-  ...mdxOptions
-}) {
-  const remarkPlugins = pluginOption(
-    (v) => [
-      plugins.remarkGfm,
-      [
-        plugins.remarkHeading,
-        {
-          generateToc: false,
-          ...remarkHeadingOptions
-        }
-      ],
-      remarkImageOptions !== false && [
-        plugins.remarkImage,
-        {
-          ...remarkImageOptions,
-          useImport: _withoutBundler ? false : remarkImageOptions?.useImport
-        }
-      ],
-      "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
-        plugins.remarkCodeTab,
-        remarkCodeTabOptions
-      ],
-      "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
-      ...v,
-      remarkStructureOptions !== false && [
-        plugins.remarkStructure,
-        remarkStructureOptions
-      ],
-      () => {
-        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
-  );
-  const rehypePlugins = pluginOption(
-    (v) => [
-      rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
-      ...v,
-      plugins.rehypeToc
-    ],
-    mdxOptions.rehypePlugins
-  );
-  return {
-    ...mdxOptions,
-    outputFormat: _withoutBundler ? "function-body" : mdxOptions.outputFormat,
-    remarkPlugins,
-    rehypePlugins
-  };
-}
-var plugins;
-var init_preset = __esm({
-  "src/loaders/mdx/preset.ts"() {
-    "use strict";
-    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
-  }
-});
-
-// src/config/build.ts
-function buildCollection(name, config) {
-  if (config.type === "docs") {
-    return {
-      ...config,
-      name,
-      meta: buildPrimitiveCollection(name, config.meta),
-      docs: buildPrimitiveCollection(name, config.docs)
-    };
-  }
-  return buildPrimitiveCollection(name, config);
-}
-function buildPrimitiveCollection(name, { files, ...config }) {
-  const supportedFormats = SupportedFormats[config.type];
-  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
-  let matchers;
-  return {
-    ...config,
-    name,
-    patterns,
-    isFileSupported(filePath) {
-      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
-    },
-    hasFile(filePath) {
-      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
-        (dir) => (0, import_picomatch.default)(patterns, {
-          cwd: dir
-        })
-      );
-      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
-    }
-  };
-}
-function buildConfig(config) {
-  const collections = /* @__PURE__ */ new Map();
-  const loaded = {};
-  for (const [k, v] of Object.entries(config)) {
-    if (!v) {
-      continue;
-    }
-    if (typeof v === "object" && "type" in v) {
-      if (v.type === "docs") {
-        collections.set(k, buildCollection(k, v));
-        continue;
-      }
-      if (v.type === "doc" || v.type === "meta") {
-        collections.set(
-          k,
-          buildCollection(k, v)
-        );
-        continue;
-      }
-    }
-    if (k === "default" && v) {
-      Object.assign(loaded, v);
-      continue;
-    }
-    throw new Error(
-      `Unknown export "${k}", you can only export collections from source configuration file.`
-    );
-  }
-  if (loaded.collections) {
-    for (const [k, v] of Object.entries(loaded.collections)) {
-      collections.set(k, buildCollection(k, v));
-    }
-  }
-  const mdxOptionsCache = /* @__PURE__ */ new Map();
-  return {
-    global: loaded,
-    collectionList: Array.from(collections.values()),
-    getCollection(name) {
-      return collections.get(name);
-    },
-    async getDefaultMDXOptions(mode = "default") {
-      const cached = mdxOptionsCache.get(mode);
-      if (cached) return cached;
-      const input = this.global.mdxOptions;
-      async function uncached() {
-        const options = typeof input === "function" ? await input() : input;
-        const { getDefaultMDXOptions: getDefaultMDXOptions2 } = await Promise.resolve().then(() => (init_preset(), preset_exports));
-        if (options?.preset === "minimal") return options;
-        return getDefaultMDXOptions2({
-          ...options,
-          _withoutBundler: mode === "remote"
-        });
-      }
-      const result = uncached();
-      mdxOptionsCache.set(mode, result);
-      return result;
-    }
-  };
-}
-var import_picomatch, SupportedFormats;
-var init_build = __esm({
-  "src/config/build.ts"() {
-    "use strict";
-    import_picomatch = __toESM(require("picomatch"), 1);
-    SupportedFormats = {
-      doc: ["mdx", "md"],
-      meta: ["json", "yaml"]
-    };
-  }
-});
-
-// src/config/load-from-file.ts
-var load_from_file_exports = {};
-__export(load_from_file_exports, {
-  loadConfig: () => loadConfig
-});
-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",
-    outExtension: {
-      ".js": ".mjs"
-    },
-    allowOverwrite: true
-  });
-  if (transformed.errors.length > 0) {
-    throw new Error("failed to compile configuration file");
-  }
-}
-async function loadConfig(configPath, outDir, build = false) {
-  if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url2.pathToFileURL)(path6.resolve(outDir, "source.config.mjs"));
-  url.searchParams.set("hash", Date.now().toString());
-  const config = import(url.href).then(
-    (loaded) => buildConfig(loaded)
-  );
-  return await config;
-}
-var path6, import_node_url2;
-var init_load_from_file = __esm({
-  "src/config/load-from-file.ts"() {
-    "use strict";
-    path6 = __toESM(require("path"), 1);
-    import_node_url2 = require("url");
-    init_build();
-  }
-});
-
-// src/webpack/mdx.ts
-var mdx_exports = {};
-__export(mdx_exports, {
-  default: () => loader
-});
-module.exports = __toCommonJS(mdx_exports);
-
 // src/utils/fuma-matter.ts
-var import_js_yaml = require("js-yaml");
-var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
 function fumaMatter(input) {
   const output = { matter: "", data: {}, content: input };
   const match = regex.exec(input);
@@ -287,80 +43,16 @@ function fumaMatter(input) {
   output.data = loaded ?? {};
   return output;
 }
-
-// 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/utils/git-timestamp.ts
-var import_node_path = __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_path.default.relative(process.cwd(), file)],
-      {
-        throwOnError: true
-      }
-    );
-    const time = new Date(out.stdout);
-    cache.set(file, time);
-    return time;
-  } catch {
-    return;
+var import_js_yaml, regex;
+var init_fuma_matter = __esm({
+  "src/utils/fuma-matter.ts"() {
+    "use strict";
+    import_js_yaml = require("js-yaml");
+    regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
   }
-}
-
-// src/loaders/mdx/build-mdx.ts
-var import_mdx = require("@mdx-js/mdx");
-
-// src/loaders/mdx/remark-include.ts
-var import_unified = require("unified");
-var import_unist_util_visit2 = require("unist-util-visit");
-var path2 = __toESM(require("path"), 1);
-var fs = __toESM(require("fs/promises"), 1);
-var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+});
 
 // src/loaders/mdx/remark-unravel.ts
-var import_unist_util_visit = require("unist-util-visit");
 function remarkMarkAndUnravel() {
   return (tree) => {
     (0, import_unist_util_visit.visit)(tree, function(node, index, parent) {
@@ -402,15 +94,28 @@ function remarkMarkAndUnravel() {
     });
   };
 }
+var import_unist_util_visit;
+var init_remark_unravel = __esm({
+  "src/loaders/mdx/remark-unravel.ts"() {
+    "use strict";
+    import_unist_util_visit = require("unist-util-visit");
+  }
+});
+
+// src/loaders/mdx/mdast-utils.ts
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+var init_mdast_utils = __esm({
+  "src/loaders/mdx/mdast-utils.ts"() {
+    "use strict";
+  }
+});
 
 // src/loaders/mdx/remark-include.ts
-var ElementLikeTypes = [
-  "mdxJsxFlowElement",
-  "mdxJsxTextElement",
-  "containerDirective",
-  "textDirective",
-  "leafDirective"
-];
 function isElementLike(node) {
   return ElementLikeTypes.includes(node.type);
 }
@@ -426,12 +131,6 @@ function parseElementAttributes(element) {
   }
   return element.attributes ?? {};
 }
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
 function parseSpecifier(specifier) {
   const idx = specifier.lastIndexOf("#");
   if (idx === -1) return { file: specifier };
@@ -486,7 +185,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path2.extname(file);
+    const ext = path.extname(file);
     data._compiler?.addDependency(file);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
@@ -519,7 +218,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     } else {
       mdast = await baseProcessor.run(mdast);
     }
-    await update(mdast, path2.dirname(file), data);
+    await update(mdast, path.dirname(file), data);
     return mdast;
   };
   async function update(tree, directory, data) {
@@ -531,7 +230,7 @@ ${e instanceof Error ? e.message : String(e)}`,
       if (specifier.length === 0) return "skip";
       const attributes = parseElementAttributes(node);
       const { file: relativePath, section } = parseSpecifier(specifier);
-      const file = path2.resolve(
+      const file = path.resolve(
         "cwd" in attributes ? process.cwd() : directory,
         relativePath
       );
@@ -548,62 +247,96 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path2.dirname(file.path), file.data);
+    await update(tree, path.dirname(file.path), file.data);
   };
 }
+var import_unified, import_unist_util_visit2, path, fs, import_mdx_plugins, ElementLikeTypes;
+var init_remark_include = __esm({
+  "src/loaders/mdx/remark-include.ts"() {
+    "use strict";
+    import_unified = require("unified");
+    import_unist_util_visit2 = require("unist-util-visit");
+    path = __toESM(require("path"), 1);
+    fs = __toESM(require("fs/promises"), 1);
+    init_fuma_matter();
+    import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+    init_remark_unravel();
+    init_mdast_utils();
+    ElementLikeTypes = [
+      "mdxJsxFlowElement",
+      "mdxJsxTextElement",
+      "containerDirective",
+      "textDirective",
+      "leafDirective"
+    ];
+  }
+});
 
 // src/loaders/mdx/remark-postprocess.ts
-var import_unist_util_visit3 = require("unist-util-visit");
-var import_mdast_util_to_markdown = require("mdast-util-to-markdown");
-var import_estree_util_value_to_estree = require("estree-util-value-to-estree");
-var import_unist_util_remove_position = require("unist-util-remove-position");
-var import_remark_mdx = __toESM(require("remark-mdx"), 1);
 function remarkPostprocess({
   _format,
   includeProcessedMarkdown = false,
   includeMDAST = false,
+  extractLinkReferences = false,
   valueToExport = []
 }) {
   let _stringifyProcessor;
   const getStringifyProcessor = () => {
-    if (_format === "mdx") return this;
-    return _stringifyProcessor ??= this().use(import_remark_mdx.default).freeze();
+    return _stringifyProcessor ??= _format === "mdx" ? this : (
+      // force Markdown processor to stringify MDX nodes
+      this().use(import_remark_mdx.default).freeze()
+    );
   };
   return (tree, file) => {
-    let title;
-    const urls = [];
-    (0, import_unist_util_visit3.visit)(tree, ["heading", "link"], (node) => {
-      if (node.type === "heading" && node.depth === 1) {
-        title = flattenNode2(node);
-      }
-      if (node.type !== "link") return;
-      urls.push({
-        href: node.url
+    const frontmatter = file.data.frontmatter ??= {};
+    if (!frontmatter.title) {
+      (0, import_unist_util_visit3.visit)(tree, "heading", (node) => {
+        if (node.depth === 1) {
+          frontmatter.title = flattenNode(node);
+          return false;
+        }
+      });
+    }
+    file.data["mdx-export"] ??= [];
+    if (extractLinkReferences) {
+      const urls = [];
+      (0, import_unist_util_visit3.visit)(tree, "link", (node) => {
+        urls.push({
+          href: node.url
+        });
+        return "skip";
+      });
+      file.data["mdx-export"].push({
+        name: "extractedReferences",
+        value: urls
       });
-      return "skip";
-    });
-    if (title) {
-      file.data.frontmatter ??= {};
-      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
     }
-    file.data.extractedReferences = urls;
     if (includeProcessedMarkdown) {
       const processor = getStringifyProcessor();
-      file.data._markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
+      const markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
         ...processor.data("settings"),
         // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
         extensions: processor.data("toMarkdownExtensions") || []
       });
+      file.data["mdx-export"].push({
+        name: "_markdown",
+        value: markdown
+      });
     }
     if (includeMDAST) {
       const options = includeMDAST === true ? {} : includeMDAST;
-      file.data._mdast = JSON.stringify(
+      const mdast = JSON.stringify(
         options.removePosition ? (0, import_unist_util_remove_position.removePosition)(structuredClone(tree)) : tree
       );
+      file.data["mdx-export"].push({
+        name: "_mdast",
+        value: mdast
+      });
     }
-    for (const { name, value } of file.data["mdx-export"] ?? []) {
+    for (const { name, value } of file.data["mdx-export"]) {
       tree.children.unshift(getMdastExport(name, value));
     }
+    file.data["mdx-export"] = [];
     for (const name of valueToExport) {
       if (!(name in file.data)) continue;
       tree.children.unshift(getMdastExport(name, file.data[name]));
@@ -644,68 +377,330 @@ function getMdastExport(name, value) {
     }
   };
 }
-function flattenNode2(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode2(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
+var import_unist_util_visit3, import_mdast_util_to_markdown, import_estree_util_value_to_estree, import_unist_util_remove_position, import_remark_mdx;
+var init_remark_postprocess = __esm({
+  "src/loaders/mdx/remark-postprocess.ts"() {
+    "use strict";
+    import_unist_util_visit3 = require("unist-util-visit");
+    import_mdast_util_to_markdown = require("mdast-util-to-markdown");
+    import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+    import_unist_util_remove_position = require("unist-util-remove-position");
+    import_remark_mdx = __toESM(require("remark-mdx"), 1);
+    init_mdast_utils();
+  }
+});
 
 // src/loaders/mdx/build-mdx.ts
-var cache2 = /* @__PURE__ */ new Map();
-async function buildMDX(cacheKey, source, options) {
-  const { filePath, frontmatter, data, _compiler, ...rest } = options;
+var build_mdx_exports = {};
+__export(build_mdx_exports, {
+  buildMDX: () => buildMDX
+});
+async function buildMDX(core2, collection, {
+  filePath,
+  frontmatter,
+  source,
+  _compiler,
+  environment,
+  isDevelopment
+}) {
+  const mdxOptions = await core2.getConfig().getMDXOptions(collection, environment);
   function getProcessor(format) {
-    const key = `${cacheKey}:${format}`;
-    let processor = cache2.get(key);
+    const cache = core2.cache;
+    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
+    let processor = cache.get(key);
     if (!processor) {
+      const postprocessOptions = {
+        _format: format,
+        ...collection?.postprocess,
+        valueToExport: [
+          ...collection?.postprocess?.valueToExport ?? [],
+          "structuredData",
+          "frontmatter"
+        ]
+      };
       processor = (0, import_mdx.createProcessor)({
         outputFormat: "program",
-        ...rest,
+        development: isDevelopment,
+        ...mdxOptions,
         remarkPlugins: [
           remarkInclude,
-          ...rest.remarkPlugins ?? [],
-          [
-            remarkPostprocess,
-            {
-              _format: format,
-              ...options.postprocess,
-              valueToExport: [
-                ...options.postprocess?.valueToExport ?? [],
-                "structuredData",
-                "extractedReferences",
-                "frontmatter",
-                "lastModified",
-                "_markdown",
-                "_mdast"
-              ]
-            }
-          ]
+          ...mdxOptions.remarkPlugins ?? [],
+          [remarkPostprocess, postprocessOptions]
         ],
         format
       });
-      cache2.set(key, processor);
+      cache.set(key, processor);
     }
     return processor;
   }
-  return getProcessor(
-    options.format ?? (filePath.endsWith(".mdx") ? "mdx" : "md")
-  ).process({
+  let vfile = new import_vfile.VFile({
     value: source,
     path: filePath,
-    data: {
-      ...data,
-      frontmatter,
-      _compiler,
-      _getProcessor: getProcessor
-    }
+    data: { frontmatter, _compiler, _getProcessor: getProcessor }
   });
+  if (collection) {
+    vfile = await core2.transformVFile({ collection, filePath, source }, vfile);
+  }
+  return getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md").process(vfile);
 }
-
+var import_mdx, import_vfile;
+var init_build_mdx = __esm({
+  "src/loaders/mdx/build-mdx.ts"() {
+    "use strict";
+    import_mdx = require("@mdx-js/mdx");
+    import_vfile = require("vfile");
+    init_remark_include();
+    init_remark_postprocess();
+  }
+});
+
+// src/config/preset.ts
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []).filter(
+    Boolean
+  );
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+function applyMdxPreset(options = {}) {
+  return async (environment = "bundler") => {
+    if (options.preset === "minimal") return options;
+    const plugins = await import("fumadocs-core/mdx-plugins");
+    const {
+      valueToExport = [],
+      rehypeCodeOptions,
+      remarkImageOptions,
+      remarkHeadingOptions,
+      remarkStructureOptions,
+      remarkCodeTabOptions,
+      remarkNpmOptions,
+      ...mdxOptions
+    } = options;
+    const remarkPlugins = pluginOption(
+      (v) => [
+        plugins.remarkGfm,
+        [
+          plugins.remarkHeading,
+          {
+            generateToc: false,
+            ...remarkHeadingOptions
+          }
+        ],
+        remarkImageOptions !== false && [
+          plugins.remarkImage,
+          {
+            ...remarkImageOptions,
+            useImport: remarkImageOptions?.useImport ?? environment === "bundler"
+          }
+        ],
+        "remarkCodeTab" in plugins && remarkCodeTabOptions !== false && [
+          plugins.remarkCodeTab,
+          remarkCodeTabOptions
+        ],
+        "remarkNpm" in plugins && remarkNpmOptions !== false && [plugins.remarkNpm, remarkNpmOptions],
+        ...v,
+        remarkStructureOptions !== false && [
+          plugins.remarkStructure,
+          remarkStructureOptions
+        ],
+        valueToExport.length > 0 && (() => {
+          return (_, file) => {
+            file.data["mdx-export"] ??= [];
+            for (const name of valueToExport) {
+              if (!(name in file.data)) continue;
+              file.data["mdx-export"].push({
+                name,
+                value: file.data[name]
+              });
+            }
+          };
+        })
+      ],
+      mdxOptions.remarkPlugins
+    );
+    const rehypePlugins = pluginOption(
+      (v) => [
+        rehypeCodeOptions !== false && [plugins.rehypeCode, rehypeCodeOptions],
+        ...v,
+        plugins.rehypeToc
+      ],
+      mdxOptions.rehypePlugins
+    );
+    return {
+      ...mdxOptions,
+      outputFormat: environment === "runtime" ? "function-body" : mdxOptions.outputFormat,
+      remarkPlugins,
+      rehypePlugins
+    };
+  };
+}
+var init_preset = __esm({
+  "src/config/preset.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/build.ts
+function buildCollection(name, config) {
+  if (config.type === "docs") {
+    return {
+      ...config,
+      name,
+      meta: buildPrimitiveCollection(name, config.meta),
+      docs: buildPrimitiveCollection(name, config.docs),
+      hasFile(filePath) {
+        return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
+      }
+    };
+  }
+  return buildPrimitiveCollection(name, config);
+}
+function buildPrimitiveCollection(name, { files, ...config }) {
+  const supportedFormats = SupportedFormats[config.type];
+  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
+  let matchers;
+  return {
+    ...config,
+    name,
+    patterns,
+    isFileSupported(filePath) {
+      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
+    },
+    hasFile(filePath) {
+      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
+        (dir) => (0, import_picomatch.default)(patterns, {
+          cwd: dir
+        })
+      );
+      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
+    }
+  };
+}
+function buildConfig(config) {
+  const collections = /* @__PURE__ */ new Map();
+  const loaded = {};
+  for (const [k, v] of Object.entries(config)) {
+    if (!v) {
+      continue;
+    }
+    if (typeof v === "object" && "type" in v) {
+      if (v.type === "docs") {
+        collections.set(k, buildCollection(k, v));
+        continue;
+      }
+      if (v.type === "doc" || v.type === "meta") {
+        collections.set(
+          k,
+          buildCollection(k, v)
+        );
+        continue;
+      }
+    }
+    if (k === "default" && v) {
+      Object.assign(loaded, v);
+      continue;
+    }
+    throw new Error(
+      `Unknown export "${k}", you can only export collections from source configuration file.`
+    );
+  }
+  const mdxOptionsCache = /* @__PURE__ */ new Map();
+  return {
+    global: loaded,
+    collectionList: Array.from(collections.values()),
+    getCollection(name) {
+      return collections.get(name);
+    },
+    getMDXOptions(collection, environment = "bundler") {
+      const key = collection ? `${environment}:${collection.name}` : environment;
+      const cached = mdxOptionsCache.get(key);
+      if (cached) return cached;
+      let result;
+      if (collection?.mdxOptions) {
+        const optionsFn = collection.mdxOptions;
+        result = typeof optionsFn === "function" ? optionsFn(environment) : optionsFn;
+      } else {
+        result = (async () => {
+          const optionsFn = this.global.mdxOptions;
+          const options = typeof optionsFn === "function" ? await optionsFn() : optionsFn;
+          return applyMdxPreset(options)(environment);
+        })();
+      }
+      mdxOptionsCache.set(key, result);
+      return result;
+    }
+  };
+}
+var import_picomatch, SupportedFormats;
+var init_build = __esm({
+  "src/config/build.ts"() {
+    "use strict";
+    import_picomatch = __toESM(require("picomatch"), 1);
+    init_preset();
+    SupportedFormats = {
+      doc: ["mdx", "md"],
+      meta: ["json", "yaml"]
+    };
+  }
+});
+
+// src/config/load-from-file.ts
+var load_from_file_exports = {};
+__export(load_from_file_exports, {
+  loadConfig: () => loadConfig
+});
+async function compileConfig(core2) {
+  const { build } = await import("esbuild");
+  const transformed = await build({
+    entryPoints: [{ in: core2._options.configPath, out: "source.config" }],
+    bundle: true,
+    outdir: core2._options.outDir,
+    target: "node20",
+    write: true,
+    platform: "node",
+    format: "esm",
+    packages: "external",
+    outExtension: {
+      ".js": ".mjs"
+    },
+    allowOverwrite: true
+  });
+  if (transformed.errors.length > 0) {
+    throw new Error("failed to compile configuration file");
+  }
+}
+async function loadConfig(core2, build = false) {
+  if (build) await compileConfig(core2);
+  const url = (0, import_node_url2.pathToFileURL)(core2.getCompiledConfigPath());
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
+  return await config;
+}
+var import_node_url2;
+var init_load_from_file = __esm({
+  "src/config/load-from-file.ts"() {
+    "use strict";
+    import_node_url2 = require("url");
+    init_build();
+  }
+});
+
+// src/webpack/mdx.ts
+var mdx_exports = {};
+__export(mdx_exports, {
+  default: () => loader
+});
+module.exports = __toCommonJS(mdx_exports);
+
 // src/loaders/mdx/index.ts
+init_fuma_matter();
 var import_zod = require("zod");
 var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
 
 // src/loaders/index.ts
@@ -731,20 +726,20 @@ function createMdxLoader(configLoader) {
       compiler,
       filePath
     }) {
+      const config = await configLoader.getConfig();
       const value = await getSource();
       const matter = fumaMatter(value);
       const parsed = querySchema.parse(query);
-      const config = await configLoader.getConfig();
       let after;
       if (!isDevelopment && config.global.experimentalBuildCache) {
         const cacheDir = config.global.experimentalBuildCache;
         const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
-        const cached = await import_promises.default.readFile(import_node_path2.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+        const cached = await import_promises.default.readFile(import_node_path.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
         if (cached && cached.hash === generateCacheHash(value)) return cached;
         after = async () => {
           await import_promises.default.mkdir(cacheDir, { recursive: true });
           await import_promises.default.writeFile(
-            import_node_path2.default.join(cacheDir, cacheKey),
+            import_node_path.default.join(cacheDir, cacheKey),
             JSON.stringify({
               ...out,
               hash: generateCacheHash(value)
@@ -762,15 +757,10 @@ function createMdxLoader(configLoader) {
           docCollection = collection.docs;
           break;
       }
-      if (docCollection?.schema) {
-        matter.data = await validate(
-          docCollection.schema,
-          matter.data,
-          {
-            source: value,
-            path: filePath
-          },
-          `invalid frontmatter in ${filePath}`
+      if (docCollection) {
+        matter.data = await configLoader.core.transformFrontmatter(
+          { collection: docCollection, filePath, source: value },
+          matter.data
         );
       }
       if (parsed.only === "frontmatter") {
@@ -779,24 +769,16 @@ function createMdxLoader(configLoader) {
           map: null
         };
       }
-      const data = {};
-      if (config.global.lastModifiedTime === "git") {
-        data.lastModified = (await getGitTimestamp(filePath))?.getTime();
-      }
       const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-      const compiled = await buildMDX(
-        `${getConfigHash(config)}:${parsed.collection ?? "global"}`,
-        "\n".repeat(lineOffset) + matter.content,
-        {
-          development: isDevelopment,
-          ...docCollection?.mdxOptions ?? await config.getDefaultMDXOptions(),
-          postprocess: docCollection?.postprocess,
-          data,
-          filePath,
-          frontmatter: matter.data,
-          _compiler: compiler
-        }
-      );
+      const { buildMDX: buildMDX2 } = await Promise.resolve().then(() => (init_build_mdx(), build_mdx_exports));
+      const compiled = await buildMDX2(configLoader.core, docCollection, {
+        isDevelopment,
+        source: "\n".repeat(lineOffset) + matter.content,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler,
+        environment: "bundler"
+      });
       const out = {
         code: String(compiled.value),
         map: compiled.map
@@ -806,14 +788,6 @@ function createMdxLoader(configLoader) {
     }
   };
 }
-var hashes = /* @__PURE__ */ new WeakMap();
-function getConfigHash(config) {
-  let hash = hashes.get(config);
-  if (hash) return hash;
-  hash = Date.now().toString();
-  hashes.set(config, hash);
-  return hash;
-}
 function generateCacheHash(input) {
   return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
 }
@@ -829,7 +803,48 @@ function countLines(s) {
 var import_node_url = require("url");
 var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_querystring = require("querystring");
-var import_node_path3 = __toESM(require("path"), 1);
+
+// src/utils/validation.ts
+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;
+  }
+  async toStringFormatted() {
+    const picocolors = await import("picocolors");
+    return [
+      picocolors.bold(`[MDX] ${this.title}:`),
+      ...this.issues.map(
+        (issue) => picocolors.redBright(
+          `- ${picocolors.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/loaders/adapter.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_fs = require("fs");
 function toWebpack(loader2) {
   return async function(source, callback) {
     try {
@@ -849,30 +864,103 @@ function toWebpack(loader2) {
       }
     } catch (error) {
       if (error instanceof ValidationError) {
-        return callback(new Error(error.toStringFormatted()));
+        return callback(new Error(await error.toStringFormatted()));
       }
       if (!(error instanceof Error)) throw error;
-      const fpath = import_node_path3.default.relative(this.context, this.resourcePath);
+      const fpath = import_node_path2.default.relative(this.context, this.resourcePath);
       error.message = `${fpath}:${error.name}: ${error.message}`;
       callback(error);
     }
   };
 }
 
+// src/loaders/config.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+function createStandaloneConfigLoader({
+  core: core2,
+  buildConfig: buildConfig2,
+  mode
+}) {
+  let loaded;
+  async function getConfigHash() {
+    if (mode === "production") return "static";
+    const stats = await import_promises3.default.stat(core2._options.configPath).catch(() => {
+      throw new Error("Cannot find config file");
+    });
+    return stats.mtime.getTime().toString();
+  }
+  async function newConfig() {
+    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
+    await core2.init({
+      config: loadConfig2(core2, buildConfig2)
+    });
+    return core2.getConfig();
+  }
+  return {
+    core: core2,
+    async getConfig() {
+      const hash = await getConfigHash();
+      if (loaded && loaded.hash === hash) return loaded.config;
+      loaded = {
+        hash,
+        config: newConfig()
+      };
+      return loaded.config;
+    }
+  };
+}
+
 // src/core.ts
 var import_node_path4 = __toESM(require("path"), 1);
-var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_promises5 = __toESM(require("fs/promises"), 1);
+
+// src/utils/codegen/cache.ts
+var import_lru_cache = require("lru-cache");
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var map = new import_lru_cache.LRUCache({
+  max: 100
+});
+function toFullPath(file) {
+  if (import_node_path3.default.isAbsolute(file)) {
+    return import_node_path3.default.relative(process.cwd(), file);
+  }
+  return file;
+}
+function removeFileCache(file) {
+  map.delete(toFullPath(file));
+}
+
+// src/core.ts
+async function getPlugins(pluginOptions) {
+  const plugins = [];
+  for await (const option of pluginOptions) {
+    if (!option) continue;
+    if (Array.isArray(option)) plugins.push(...await getPlugins(option));
+    else plugins.push(option);
+  }
+  return plugins;
+}
 function createCore(options, defaultPlugins = []) {
   let config;
-  let plugins2;
-  return {
+  let plugins;
+  async function transformMetadata({
+    collection,
+    filePath,
+    source
+  }, data) {
+    if (collection.schema) {
+      data = await validate(
+        collection.schema,
+        data,
+        { path: filePath, source },
+        collection.type === "doc" ? `invalid frontmatter in ${filePath}` : `invalid data in ${filePath}`
+      );
+    }
+    return data;
+  }
+  const core2 = {
     _options: options,
-    getPluginContext() {
-      return {
-        core: this,
-        ...options
-      };
-    },
     /**
      * Convenient cache store, reset when config changes
      */
@@ -880,17 +968,12 @@ function createCore(options, defaultPlugins = []) {
     async init({ config: newConfig }) {
       config = await newConfig;
       this.cache.clear();
-      plugins2 = [];
-      for await (const option of [
+      plugins = await getPlugins([
         ...defaultPlugins,
         ...config.global.plugins ?? []
-      ]) {
-        if (!option) continue;
-        if (Array.isArray(option)) plugins2.push(...option);
-        else plugins2.push(option);
-      }
-      for (const plugin of plugins2) {
-        const out = await plugin.config?.call(this.getPluginContext(), config);
+      ]);
+      for (const plugin of plugins) {
+        const out = await plugin.config?.call(pluginContext, config);
         if (out) config = out;
       }
       return this;
@@ -898,90 +981,106 @@ function createCore(options, defaultPlugins = []) {
     getConfig() {
       return config;
     },
+    /**
+     * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
+     */
+    getCompiledConfigPath() {
+      return import_node_path4.default.join(options.outDir, "source.config.mjs");
+    },
     async initServer(server) {
-      for (const plugin of plugins2) {
-        await plugin.configureServer?.call(this.getPluginContext(), server);
+      server.watcher?.on("all", async (event, file) => {
+        if (event === "change") removeFileCache(file);
+      });
+      for (const plugin of plugins) {
+        await plugin.configureServer?.call(pluginContext, server);
       }
     },
-    async emitAndWrite({
-      filterPlugin = () => true
-    } = {}) {
-      const start = performance.now();
-      const out = await Promise.all(
-        plugins2.map((plugin) => {
+    async emit({ filterPlugin = () => true } = {}) {
+      return (await Promise.all(
+        plugins.map((plugin) => {
           if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(this.getPluginContext());
+          return plugin.emit.call(pluginContext);
         })
-      );
+      )).flat();
+    },
+    async emitAndWrite(emitOptions) {
+      const start = performance.now();
+      const out = await this.emit(emitOptions);
       await Promise.all(
-        out.flat().map(async (entry) => {
+        out.map(async (entry) => {
           const file = import_node_path4.default.join(options.outDir, entry.path);
-          await import_promises3.default.mkdir(import_node_path4.default.dirname(file), { recursive: true });
-          await import_promises3.default.writeFile(file, entry.content);
+          await import_promises5.default.mkdir(import_node_path4.default.dirname(file), { recursive: true });
+          await import_promises5.default.writeFile(file, entry.content);
         })
       );
       console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+    },
+    async transformMeta(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.meta?.transform)
+          data = await plugin.meta.transform.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformFrontmatter(options2, data) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      data = await transformMetadata(options2, data);
+      for (const plugin of plugins) {
+        if (plugin.doc?.frontmatter)
+          data = await plugin.doc.frontmatter.call(ctx, data) ?? data;
+      }
+      return data;
+    },
+    async transformVFile(options2, file) {
+      const ctx = {
+        ...pluginContext,
+        ...options2
+      };
+      for (const plugin of plugins) {
+        if (plugin.doc?.vfile)
+          file = await plugin.doc.vfile.call(ctx, file) ?? file;
+      }
+      return file;
     }
   };
+  const pluginContext = {
+    core: core2,
+    ...options
+  };
+  return core2;
 }
 
-// src/loaders/config.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
-function createStandaloneConfigLoader({
-  core,
-  buildConfig: buildConfig2,
-  mode
-}) {
-  let loaded;
-  async function getConfigHash2() {
-    if (mode === "production") return "static";
-    const stats = await import_promises4.default.stat(core._options.configPath).catch(() => {
-      throw new Error("Cannot find config file");
-    });
-    return stats.mtime.getTime().toString();
-  }
-  async function newConfig() {
-    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
-    await core.init({
-      config: loadConfig2(
-        core._options.configPath,
-        core._options.outDir,
-        buildConfig2
-      )
-    });
-    return core.getConfig();
-  }
-  return {
-    async getConfig() {
-      const hash = await getConfigHash2();
-      if (loaded && loaded.hash === hash) return loaded.config;
-      loaded = {
-        hash,
-        config: newConfig()
-      };
-      return loaded.config;
-    }
-  };
+// src/webpack/index.ts
+var core;
+function getCore(options) {
+  return core ??= createCore({
+    environment: "webpack",
+    outDir: options.outDir,
+    configPath: options.configPath
+  });
 }
 
 // src/webpack/mdx.ts
 var instance;
 async function loader(source, callback) {
-  const { isDev, outDir, configPath } = this.getOptions();
+  const options = this.getOptions();
   this.cacheable(true);
-  this.addDependency(configPath);
+  this.addDependency(options.compiledConfigPath);
   if (!instance) {
-    const core = createCore({
-      environment: "webpack",
-      outDir,
-      configPath
-    });
     instance = toWebpack(
       createMdxLoader(
         createStandaloneConfigLoader({
-          core,
+          core: getCore(options),
           buildConfig: false,
-          mode: isDev ? "dev" : "production"
+          mode: options.isDev ? "dev" : "production"
         })
       )
     );