fumadocs-mdx 14.0.1 → 14.0.3

package/dist/bin.cjs

@@ -1,1958 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// 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(core) {
-  const { build } = await import("esbuild");
-  const { configPath, outDir } = core.getOptions();
-  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(core, build = false) {
-  if (build) await compileConfig(core);
-  const url = (0, import_node_url.pathToFileURL)(core.getCompiledConfigPath());
-  url.searchParams.set("hash", Date.now().toString());
-  const config = import(url.href).then(
-    (loaded) => buildConfig(loaded)
-  );
-  return await config;
-}
-var import_node_url;
-var init_load_from_file = __esm({
-  "src/config/load-from-file.ts"() {
-    "use strict";
-    import_node_url = require("url");
-    init_build();
-  }
-});
-
-// src/utils/validation.ts
-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;
-}
-var ValidationError;
-var init_validation = __esm({
-  "src/utils/validation.ts"() {
-    "use strict";
-    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");
-      }
-    };
-  }
-});
-
-// src/utils/codegen.ts
-function createCodegen({
-  target = "default",
-  outDir = "",
-  jsExtension = false,
-  globCache = /* @__PURE__ */ new Map()
-}) {
-  let eagerImportId = 0;
-  const banner = ["// @ts-nocheck"];
-  if (target === "vite") {
-    banner.push('/// <reference types="vite/client" />');
-  }
-  return {
-    options: {
-      target,
-      outDir
-    },
-    lines: [],
-    addImport(statement) {
-      this.lines.unshift(statement);
-    },
-    async pushAsync(insert) {
-      for (const line of await Promise.all(insert)) {
-        if (line === void 0) continue;
-        this.lines.push(line);
-      }
-    },
-    async generateGlobImport(patterns, options) {
-      if (target === "vite") {
-        return this.generateViteGlobImport(patterns, options);
-      }
-      return this.generateNodeGlobImport(patterns, options);
-    },
-    generateViteGlobImport(patterns, { base, ...rest }) {
-      patterns = (typeof patterns === "string" ? [patterns] : patterns).map(
-        normalizeViteGlobPath
-      );
-      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
-        {
-          base: normalizeViteGlobPath(import_node_path.default.relative(outDir, base)),
-          ...rest
-        },
-        null,
-        2
-      )})`;
-    },
-    async generateNodeGlobImport(patterns, {
-      base,
-      eager = false,
-      query = {},
-      import: importName
-    }) {
-      const cacheKey = JSON.stringify({ patterns, base });
-      let files = globCache.get(cacheKey);
-      if (!files) {
-        files = (0, import_tinyglobby.glob)(patterns, {
-          cwd: base
-        });
-        globCache.set(cacheKey, files);
-      }
-      let code = "{";
-      for (const item of await files) {
-        const fullPath = import_node_path.default.join(base, item);
-        const searchParams = new URLSearchParams();
-        for (const [k, v] of Object.entries(query)) {
-          searchParams.set(k, v);
-        }
-        const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
-        if (eager) {
-          const name = `__fd_glob_${eagerImportId++}`;
-          this.lines.unshift(
-            importName ? `import { ${importName} as ${name} } from ${JSON.stringify(importPath)}` : `import * as ${name} from ${JSON.stringify(importPath)}`
-          );
-          code += `${JSON.stringify(item)}: ${name}, `;
-        } else {
-          let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(importPath)})`;
-          if (importName) {
-            line += `.then(mod => mod.${importName})`;
-          }
-          code += `${line}, `;
-        }
-      }
-      code += "}";
-      return code;
-    },
-    formatImportPath(file) {
-      const ext = import_node_path.default.extname(file);
-      let filename;
-      if (ext === ".ts" && 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;
-      }
-      const importPath = slash(import_node_path.default.relative(outDir, filename));
-      return importPath.startsWith(".") ? importPath : `./${importPath}`;
-    },
-    toString() {
-      return [...banner, ...this.lines].join("\n");
-    }
-  };
-}
-function normalizeViteGlobPath(file) {
-  file = slash(file);
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
-}
-function slash(path9) {
-  const isExtendedLengthPath = path9.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path9;
-  }
-  return path9.replaceAll("\\", "/");
-}
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
-}
-var import_node_path, import_tinyglobby;
-var init_codegen = __esm({
-  "src/utils/codegen.ts"() {
-    "use strict";
-    import_node_path = __toESM(require("path"), 1);
-    import_tinyglobby = require("tinyglobby");
-  }
-});
-
-// 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 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 core = {
-    /**
-     * Convenient cache store, reset when config changes
-     */
-    cache: /* @__PURE__ */ new Map(),
-    async init({ config: newConfig }) {
-      config = await newConfig;
-      this.cache.clear();
-      plugins = await getPlugins([
-        postprocessPlugin(),
-        ...defaultPlugins,
-        ...config.global.plugins ?? []
-      ]);
-      for (const plugin of plugins) {
-        const out = await plugin.config?.call(pluginContext, config);
-        if (out) config = out;
-      }
-    },
-    getOptions() {
-      return options;
-    },
-    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_path2.default.join(options.outDir, "source.config.mjs");
-    },
-    getPlugins() {
-      return plugins;
-    },
-    getPluginContext() {
-      return pluginContext;
-    },
-    async initServer(server) {
-      for (const plugin of plugins) {
-        await plugin.configureServer?.call(pluginContext, server);
-      }
-    },
-    async emit({ filterPlugin = () => true } = {}) {
-      return (await Promise.all(
-        plugins.map((plugin) => {
-          if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(pluginContext);
-        })
-      )).flat();
-    },
-    async emitAndWrite(emitOptions) {
-      const start2 = performance.now();
-      const out = await this.emit(emitOptions);
-      await Promise.all(
-        out.map(async (entry) => {
-          const file = import_node_path2.default.join(options.outDir, entry.path);
-          await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
-          await import_promises.default.writeFile(file, entry.content);
-        })
-      );
-      console.log(`[MDX] generated files in ${performance.now() - start2}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,
-    ...options
-  };
-  return core;
-}
-function postprocessPlugin() {
-  const LinkReferenceTypes = `{
-  /**
-   * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
-   */
-  extractedReferences?: import('fumadocs-mdx').ExtractedReference[];
-}`;
-  return {
-    "index-file": {
-      generateTypeConfig() {
-        const lines = [];
-        lines.push("{");
-        lines.push("  DocData: {");
-        for (const collection of this.core.getConfig().collectionList) {
-          let postprocessOptions;
-          switch (collection.type) {
-            case "doc":
-              postprocessOptions = collection.postprocess;
-              break;
-            case "docs":
-              postprocessOptions = collection.docs.postprocess;
-              break;
-          }
-          if (postprocessOptions?.extractLinkReferences) {
-            lines.push(ident(`${collection.name}: ${LinkReferenceTypes},`, 2));
-          }
-        }
-        lines.push("  }");
-        lines.push("}");
-        return lines.join("\n");
-      },
-      serverOptions(options) {
-        options.doc ??= {};
-        options.doc.passthroughs ??= [];
-        options.doc.passthroughs.push("extractedReferences");
-      }
-    }
-  };
-}
-var import_node_path2, import_promises, _Defaults;
-var init_core = __esm({
-  "src/core.ts"() {
-    "use strict";
-    import_node_path2 = __toESM(require("path"), 1);
-    import_promises = __toESM(require("fs/promises"), 1);
-    init_validation();
-    init_codegen();
-    _Defaults = {
-      configPath: "source.config.ts",
-      outDir: ".source"
-    };
-  }
-});
-
-// src/loaders/index.ts
-var metaLoaderGlob, mdxLoaderGlob;
-var init_loaders = __esm({
-  "src/loaders/index.ts"() {
-    "use strict";
-    metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
-    mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
-  }
-});
-
-// src/utils/fs-cache.ts
-function toFullPath(file) {
-  if (import_node_path3.default.isAbsolute(file)) {
-    return import_node_path3.default.relative(process.cwd(), file);
-  }
-  return file;
-}
-function readFileWithCache(file) {
-  const fullPath = toFullPath(file);
-  const cached = map.get(fullPath);
-  if (cached) return cached;
-  const read = import_promises2.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_promises2, import_node_path3, map;
-var init_fs_cache = __esm({
-  "src/utils/fs-cache.ts"() {
-    "use strict";
-    import_lru_cache = require("lru-cache");
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    import_node_path3 = __toESM(require("path"), 1);
-    map = new import_lru_cache.LRUCache({
-      max: 100
-    });
-  }
-});
-
-// src/utils/fuma-matter.ts
-function fumaMatter(input) {
-  const output = { matter: "", data: {}, content: input };
-  const match = regex.exec(input);
-  if (!match) {
-    return output;
-  }
-  output.matter = match[0];
-  output.content = input.slice(match[0].length);
-  const loaded = (0, import_js_yaml.load)(match[1]);
-  output.data = loaded ?? {};
-  return output;
-}
-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/plugins/index-file.ts
-function indexFile(options = {}) {
-  const {
-    target = "default",
-    addJsExtension,
-    browser = true,
-    dynamic = true
-  } = options;
-  let config;
-  let dynamicCollections;
-  function isDynamic(collection) {
-    return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
-  }
-  function generateConfigs(core) {
-    const serverOptions = {};
-    const typeConfigs = [];
-    const ctx = core.getPluginContext();
-    for (const plugin of core.getPlugins()) {
-      const indexFilePlugin = plugin["index-file"];
-      if (!indexFilePlugin) continue;
-      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
-      const config2 = indexFilePlugin.generateTypeConfig?.call(ctx);
-      if (config2) typeConfigs.push(config2);
-    }
-    if (typeConfigs.length === 0) {
-      typeConfigs.push("{ DocData: {} }");
-    }
-    return {
-      serverOptions,
-      tc: typeConfigs.join(" & ")
-    };
-  }
-  return {
-    name: "index-file",
-    config(v) {
-      config = v;
-      dynamicCollections = config.collectionList.filter(isDynamic);
-    },
-    configureServer(server) {
-      if (!server.watcher) return;
-      server.watcher.on("all", async (event, file) => {
-        removeFileCache(file);
-        if (dynamicCollections.length === 0) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        const updatedCollection = config.collectionList.find(
-          (collection) => collection.hasFile(file)
-        );
-        if (!updatedCollection) return;
-        if (!isDynamic(updatedCollection)) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        await this.core.emitAndWrite({
-          filterPlugin: (plugin) => plugin.name === "index-file"
-        });
-      });
-    },
-    async emit() {
-      const globCache = /* @__PURE__ */ new Map();
-      const { serverOptions, tc } = generateConfigs(this.core);
-      const toEmitEntry = async (path9, content) => {
-        const codegen = createCodegen({
-          target,
-          outDir: this.outDir,
-          jsExtension: addJsExtension,
-          globCache
-        });
-        await content({
-          core: this.core,
-          codegen,
-          serverOptions,
-          tc
-        });
-        return {
-          path: path9,
-          content: codegen.toString()
-        };
-      };
-      const out = [
-        toEmitEntry("server.ts", generateServerIndexFile)
-      ];
-      if (dynamic)
-        out.push(toEmitEntry("dynamic.ts", generateDynamicIndexFile));
-      if (browser)
-        out.push(toEmitEntry("browser.ts", generateBrowserIndexFile));
-      return await Promise.all(out);
-    }
-  };
-}
-async function generateServerIndexFile({
-  core,
-  codegen,
-  serverOptions,
-  tc
-}) {
-  codegen.lines.push(
-    `import { server } from 'fumadocs-mdx/runtime/server';`,
-    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
-    "",
-    `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
-  );
-  async function generateCollectionObject(collection) {
-    switch (collection.type) {
-      case "docs": {
-        if (collection.docs.dynamic) return;
-        if (collection.docs.async) {
-          const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
-            generateMetaCollectionGlob(codegen, collection.meta, true),
-            generateDocCollectionFrontmatterGlob(
-              codegen,
-              collection.docs,
-              true
-            ),
-            generateDocCollectionGlob(codegen, collection.docs)
-          ]);
-          return `await create.docsLazy("${collection.name}", "${collection.dir}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
-        }
-        const [metaGlob, docGlob] = await Promise.all([
-          generateMetaCollectionGlob(codegen, collection.meta, true),
-          generateDocCollectionGlob(codegen, collection.docs, true)
-        ]);
-        return `await create.docs("${collection.name}", "${collection.dir}", ${metaGlob}, ${docGlob})`;
-      }
-      case "doc":
-        if (collection.dynamic) return;
-        if (collection.async) {
-          const [headGlob, bodyGlob] = await Promise.all([
-            generateDocCollectionFrontmatterGlob(codegen, collection, true),
-            generateDocCollectionGlob(codegen, collection)
-          ]);
-          return `await create.docLazy("${collection.name}", "${collection.dir}", ${headGlob}, ${bodyGlob})`;
-        }
-        return `await create.doc("${collection.name}", "${collection.dir}", ${await generateDocCollectionGlob(
-          codegen,
-          collection,
-          true
-        )})`;
-      case "meta":
-        return `await create.meta("${collection.name}", "${collection.dir}", ${await generateMetaCollectionGlob(
-          codegen,
-          collection,
-          true
-        )})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
-}
-async function generateDynamicIndexFile({
-  core,
-  codegen,
-  serverOptions,
-  tc
-}) {
-  const { configPath } = core.getOptions();
-  codegen.lines.push(
-    `import { dynamic } from 'fumadocs-mdx/runtime/dynamic';`,
-    `import * as Config from '${codegen.formatImportPath(configPath)}';`,
-    "",
-    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(core.getOptions())}, ${JSON.stringify(serverOptions)});`
-  );
-  async function generateCollectionObjectEntry(collection, file) {
-    const fullPath = import_path.default.join(collection.dir, file);
-    const content = await readFileWithCache(fullPath).catch(() => "");
-    const parsed = fumaMatter(content);
-    const data = await core.transformFrontmatter(
-      {
-        collection,
-        filePath: fullPath,
-        source: content
-      },
-      parsed.data
-    );
-    const hash = (0, import_crypto.createHash)("md5").update(content).digest("hex");
-    const infoStr = [
-      // make sure it's included in vercel/nft
-      `absolutePath: path.resolve(${JSON.stringify(fullPath)})`
-    ];
-    for (const [k, v] of Object.entries({
-      info: {
-        fullPath,
-        path: file
-      },
-      data,
-      hash
-    })) {
-      infoStr.push(`${k}: ${JSON.stringify(v)}`);
-    }
-    return `{ ${infoStr.join(", ")} }`;
-  }
-  async function generateCollectionObject(parent) {
-    let collection;
-    if (parent.type === "doc") collection = parent;
-    else if (parent.type === "docs") collection = parent.docs;
-    if (!collection || !collection.dynamic) return;
-    const files = await (0, import_tinyglobby2.glob)(collection.patterns, {
-      cwd: collection.dir
-    });
-    const entries = await Promise.all(
-      files.map((file) => generateCollectionObjectEntry(collection, file))
-    );
-    switch (parent.type) {
-      case "docs": {
-        const metaGlob = await generateMetaCollectionGlob(
-          codegen,
-          parent.meta,
-          true
-        );
-        return `await create.docs("${parent.name}", "${parent.dir}", ${metaGlob}, ${entries.join(", ")})`;
-      }
-      case "doc":
-        return `await create.doc("${collection.name}", "${collection.dir}", ${entries.join(", ")})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
-}
-async function generateBrowserIndexFile({ core, codegen, tc }) {
-  codegen.lines.push(
-    `import { browser } from 'fumadocs-mdx/runtime/browser';`,
-    `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
-    "",
-    `const create = browser<typeof Config, ${tc}>();`
-  );
-  async function generateCollectionObject(collection) {
-    switch (collection.type) {
-      case "docs": {
-        if (collection.docs.dynamic) return;
-        return generateCollectionObject(collection.docs);
-      }
-      case "doc":
-        if (collection.dynamic) return;
-        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(codegen, collection)})`;
-    }
-  }
-  codegen.lines.push("const browserCollections = {");
-  await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return ident(`${collection.name}: ${obj},`);
-    })
-  );
-  codegen.lines.push("};", "export default browserCollections;");
-}
-function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      only: "frontmatter"
-    },
-    import: "frontmatter",
-    base: collection.dir,
-    eager
-  });
-}
-function generateDocCollectionGlob(codegen, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name
-    },
-    base: collection.dir,
-    eager
-  });
-}
-function generateMetaCollectionGlob(codegen, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name
-    },
-    import: "default",
-    base: collection.dir,
-    eager
-  });
-}
-var import_path, import_tinyglobby2, import_crypto;
-var init_index_file = __esm({
-  "src/plugins/index-file.ts"() {
-    "use strict";
-    import_path = __toESM(require("path"), 1);
-    init_codegen();
-    import_tinyglobby2 = require("tinyglobby");
-    init_fs_cache();
-    import_crypto = require("crypto");
-    init_fuma_matter();
-  }
-});
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createMDX: () => createMDX,
-  postInstall: () => postInstall
-});
-function createMDX(createOptions = {}) {
-  const core = createNextCore(applyDefaults(createOptions));
-  const isDev = process.env.NODE_ENV === "development";
-  if (process.env._FUMADOCS_MDX !== "1") {
-    process.env._FUMADOCS_MDX = "1";
-    void init(isDev, core);
-  }
-  return (nextConfig = {}) => {
-    const loaderOptions = {
-      ...core.getOptions(),
-      compiledConfigPath: core.getCompiledConfigPath(),
-      isDev
-    };
-    const turbopack = {
-      ...nextConfig.turbopack,
-      rules: {
-        ...nextConfig.turbopack?.rules,
-        "*.{md,mdx}": {
-          loaders: [
-            {
-              loader: "fumadocs-mdx/loader-mdx",
-              options: loaderOptions
-            }
-          ],
-          as: "*.js"
-        },
-        "*.json": {
-          loaders: [
-            {
-              loader: "fumadocs-mdx/loader-meta",
-              options: loaderOptions
-            }
-          ],
-          as: "*.json"
-        },
-        "*.yaml": {
-          loaders: [
-            {
-              loader: "fumadocs-mdx/loader-meta",
-              options: loaderOptions
-            }
-          ],
-          as: "*.js"
-        }
-      }
-    };
-    return {
-      ...nextConfig,
-      turbopack,
-      pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
-      webpack: (config, options) => {
-        config.resolve ||= {};
-        config.module ||= {};
-        config.module.rules ||= [];
-        config.module.rules.push(
-          {
-            test: mdxLoaderGlob,
-            use: [
-              options.defaultLoaders.babel,
-              {
-                loader: "fumadocs-mdx/loader-mdx",
-                options: loaderOptions
-              }
-            ]
-          },
-          {
-            test: metaLoaderGlob,
-            use: [
-              options.defaultLoaders.babel,
-              {
-                loader: "fumadocs-mdx/loader-meta",
-                options: loaderOptions
-              }
-            ]
-          }
-        );
-        config.plugins ||= [];
-        return nextConfig.webpack?.(config, options) ?? config;
-      }
-    };
-  };
-}
-async function init(dev, core) {
-  async function initOrReload() {
-    await core.init({
-      config: loadConfig(core, true)
-    });
-    await core.emitAndWrite();
-  }
-  async function devServer() {
-    const { FSWatcher } = await import("chokidar");
-    const { configPath, outDir } = core.getOptions();
-    const watcher = new FSWatcher({
-      ignoreInitial: true,
-      persistent: true,
-      ignored: [outDir]
-    });
-    watcher.add(configPath);
-    for (const collection of core.getConfig().collectionList) {
-      if (collection.type === "docs") {
-        watcher.add(collection.docs.dir);
-        watcher.add(collection.meta.dir);
-      } else {
-        watcher.add(collection.dir);
-      }
-    }
-    watcher.on("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    const absoluteConfigPath = path5.resolve(configPath);
-    watcher.on("all", async (_event, file) => {
-      if (path5.resolve(file) === absoluteConfigPath) {
-        watcher.removeAllListeners();
-        await watcher.close();
-        await initOrReload();
-        console.log("[MDX] restarting dev server");
-        await devServer();
-      }
-    });
-    process.on("exit", () => {
-      if (watcher.closed) return;
-      console.log("[MDX] closing dev server");
-      void watcher.close();
-    });
-    await core.initServer({ watcher });
-  }
-  await initOrReload();
-  if (dev) {
-    await devServer();
-  }
-}
-async function postInstall(options) {
-  const core = createNextCore(applyDefaults(options));
-  await core.init({
-    config: loadConfig(core, true)
-  });
-  await core.emitAndWrite();
-}
-function applyDefaults(options) {
-  return {
-    index: {},
-    outDir: options.outDir ?? _Defaults.outDir,
-    configPath: options.configPath ?? _Defaults.configPath
-  };
-}
-function createNextCore(options) {
-  const core = createCore(
-    {
-      environment: "next",
-      outDir: options.outDir,
-      configPath: options.configPath
-    },
-    [options.index && indexFile(options.index)]
-  );
-  return {
-    ...core,
-    async emitAndWrite(...args) {
-      try {
-        await core.emitAndWrite(...args);
-      } catch (err) {
-        if (err instanceof ValidationError) {
-          console.error(await err.toStringFormatted());
-        } else {
-          console.error(err);
-        }
-      }
-    }
-  };
-}
-var path5, defaultPageExtensions;
-var init_next = __esm({
-  "src/next/index.ts"() {
-    "use strict";
-    path5 = __toESM(require("path"), 1);
-    init_load_from_file();
-    init_validation();
-    init_core();
-    init_loaders();
-    init_index_file();
-    defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
-  }
-});
-
-// src/loaders/mdx/remark-unravel.ts
-function remarkMarkAndUnravel() {
-  return (tree) => {
-    (0, import_unist_util_visit.visit)(tree, function(node, index, parent) {
-      let offset = -1;
-      let all = true;
-      let oneOrMore = false;
-      if (parent && typeof index === "number" && node.type === "paragraph") {
-        const children = node.children;
-        while (++offset < children.length) {
-          const child = children[offset];
-          if (child.type === "mdxJsxTextElement" || child.type === "mdxTextExpression") {
-            oneOrMore = true;
-          } else if (child.type === "text" && child.value.trim().length === 0) {
-          } else {
-            all = false;
-            break;
-          }
-        }
-        if (all && oneOrMore) {
-          offset = -1;
-          const newChildren = [];
-          while (++offset < children.length) {
-            const child = children[offset];
-            if (child.type === "mdxJsxTextElement") {
-              child.type = "mdxJsxFlowElement";
-            }
-            if (child.type === "mdxTextExpression") {
-              child.type = "mdxFlowExpression";
-            }
-            if (child.type === "text" && /^[\t\r\n ]+$/.test(String(child.value))) {
-            } else {
-              newChildren.push(child);
-            }
-          }
-          parent.children.splice(index, 1, ...newChildren);
-          return index;
-        }
-      }
-    });
-  };
-}
-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
-function isElementLike(node) {
-  return ElementLikeTypes.includes(node.type);
-}
-function parseElementAttributes(element) {
-  if (Array.isArray(element.attributes)) {
-    const attributes = {};
-    for (const attr of element.attributes) {
-      if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
-        attributes[attr.name] = attr.value;
-      }
-    }
-    return attributes;
-  }
-  return element.attributes ?? {};
-}
-function parseSpecifier(specifier) {
-  const idx = specifier.lastIndexOf("#");
-  if (idx === -1) return { file: specifier };
-  return {
-    file: specifier.slice(0, idx),
-    section: specifier.slice(idx + 1)
-  };
-}
-function extractSection(root, section) {
-  let nodes;
-  let capturingHeadingContent = false;
-  (0, import_unist_util_visit2.visit)(root, (node) => {
-    if (node.type === "heading") {
-      if (capturingHeadingContent) {
-        return false;
-      }
-      if (node.data?.hProperties?.id === section) {
-        capturingHeadingContent = true;
-        nodes = [node];
-        return "skip";
-      }
-      return;
-    }
-    if (capturingHeadingContent) {
-      nodes?.push(node);
-      return "skip";
-    }
-    if (isElementLike(node) && node.name === "section") {
-      const attributes = parseElementAttributes(node);
-      if (attributes.id === section) {
-        nodes = node.children;
-        return false;
-      }
-    }
-  });
-  if (nodes)
-    return {
-      type: "root",
-      children: nodes
-    };
-}
-function remarkInclude() {
-  const TagName = "include";
-  const embedContent = async (file, heading, params, data) => {
-    let content;
-    try {
-      content = (await fs3.readFile(file)).toString();
-    } catch (e) {
-      throw new Error(
-        `failed to read file ${file}
-${e instanceof Error ? e.message : String(e)}`,
-        { cause: e }
-      );
-    }
-    const ext = path6.extname(file);
-    data._compiler?.addDependency(file);
-    if (params.lang || ext !== ".md" && ext !== ".mdx") {
-      const lang = params.lang ?? ext.slice(1);
-      return {
-        type: "code",
-        lang,
-        meta: params.meta,
-        value: content,
-        data: {}
-      };
-    }
-    const parser = data._getProcessor ? data._getProcessor(ext === ".mdx" ? "mdx" : "md") : this;
-    const parsed = fumaMatter(content);
-    let mdast = parser.parse({
-      path: file,
-      value: parsed.content,
-      data: { frontmatter: parsed.data }
-    });
-    const baseProcessor = (0, import_unified.unified)().use(remarkMarkAndUnravel);
-    if (heading) {
-      const extracted = extractSection(
-        await baseProcessor.use(import_mdx_plugins.remarkHeading).run(mdast),
-        heading
-      );
-      if (!extracted)
-        throw new Error(
-          `Cannot find section ${heading} in ${file}, make sure you have encapsulated the section in a <section id="${heading}"> tag, or a :::section directive with remark-directive configured.`
-        );
-      mdast = extracted;
-    } else {
-      mdast = await baseProcessor.run(mdast);
-    }
-    await update(mdast, path6.dirname(file), data);
-    return mdast;
-  };
-  async function update(tree, directory, data) {
-    const queue = [];
-    (0, import_unist_util_visit2.visit)(tree, ElementLikeTypes, (_node, _, parent) => {
-      const node = _node;
-      if (node.name !== TagName) return;
-      const specifier = flattenNode(node);
-      if (specifier.length === 0) return "skip";
-      const attributes = parseElementAttributes(node);
-      const { file: relativePath, section } = parseSpecifier(specifier);
-      const file = path6.resolve(
-        "cwd" in attributes ? process.cwd() : directory,
-        relativePath
-      );
-      queue.push(
-        embedContent(file, section, attributes, data).then((replace) => {
-          Object.assign(
-            parent && parent.type === "paragraph" ? parent : node,
-            replace
-          );
-        })
-      );
-      return "skip";
-    });
-    await Promise.all(queue);
-  }
-  return async (tree, file) => {
-    await update(tree, path6.dirname(file.path), file.data);
-  };
-}
-var import_unified, import_unist_util_visit2, path6, fs3, 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");
-    path6 = __toESM(require("path"), 1);
-    fs3 = __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
-function remarkPostprocess({
-  _format,
-  includeProcessedMarkdown = false,
-  includeMDAST = false,
-  extractLinkReferences = false,
-  valueToExport = []
-}) {
-  let _stringifyProcessor;
-  const getStringifyProcessor = () => {
-    return _stringifyProcessor ??= _format === "mdx" ? this : (
-      // force Markdown processor to stringify MDX nodes
-      this().use(import_remark_mdx.default).freeze()
-    );
-  };
-  return (tree, file) => {
-    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
-      });
-    }
-    if (includeProcessedMarkdown) {
-      const processor = getStringifyProcessor();
-      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;
-      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"]) {
-      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]));
-    }
-  };
-}
-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_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 build_mdx_exports = {};
-__export(build_mdx_exports, {
-  buildMDX: () => buildMDX
-});
-async function buildMDX(core, collection, {
-  filePath,
-  frontmatter,
-  source,
-  _compiler,
-  environment,
-  isDevelopment
-}) {
-  const mdxOptions = await core.getConfig().getMDXOptions(collection, environment);
-  function getProcessor(format) {
-    const cache = core.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",
-        development: isDevelopment,
-        ...mdxOptions,
-        remarkPlugins: [
-          remarkInclude,
-          ...mdxOptions.remarkPlugins ?? [],
-          [remarkPostprocess, postprocessOptions]
-        ],
-        format
-      });
-      cache.set(key, processor);
-    }
-    return processor;
-  }
-  let vfile = new import_vfile.VFile({
-    value: source,
-    path: filePath,
-    data: { frontmatter, _compiler, _getProcessor: getProcessor }
-  });
-  if (collection) {
-    vfile = await core.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/loaders/mdx/index.ts
-function createMdxLoader(configLoader) {
-  return {
-    test: mdxLoaderGlob,
-    async load({
-      getSource,
-      development: isDevelopment,
-      query,
-      compiler,
-      filePath
-    }) {
-      const config = await configLoader.getConfig();
-      const value = await getSource();
-      const matter = fumaMatter(value);
-      const parsed = querySchema.parse(query);
-      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_promises3.default.readFile(import_node_path4.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_promises3.default.mkdir(cacheDir, { recursive: true });
-          await import_promises3.default.writeFile(
-            import_node_path4.default.join(cacheDir, cacheKey),
-            JSON.stringify({
-              ...out,
-              hash: generateCacheHash(value)
-            })
-          );
-        };
-      }
-      const collection = parsed.collection ? config.getCollection(parsed.collection) : void 0;
-      let docCollection;
-      switch (collection?.type) {
-        case "doc":
-          docCollection = collection;
-          break;
-        case "docs":
-          docCollection = collection.docs;
-          break;
-      }
-      if (docCollection) {
-        matter.data = await configLoader.core.transformFrontmatter(
-          { collection: docCollection, filePath, source: value },
-          matter.data
-        );
-      }
-      if (parsed.only === "frontmatter") {
-        return {
-          code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
-          map: null
-        };
-      }
-      const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-      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
-      };
-      await after?.();
-      return out;
-    }
-  };
-}
-function generateCacheHash(input) {
-  return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
-}
-function countLines(s) {
-  let num = 0;
-  for (const c of s) {
-    if (c === "\n") num++;
-  }
-  return num;
-}
-var import_zod, import_promises3, import_node_path4, import_node_crypto, querySchema, cacheEntry;
-var init_mdx = __esm({
-  "src/loaders/mdx/index.ts"() {
-    "use strict";
-    init_fuma_matter();
-    import_zod = require("zod");
-    import_promises3 = __toESM(require("fs/promises"), 1);
-    import_node_path4 = __toESM(require("path"), 1);
-    import_node_crypto = require("crypto");
-    init_loaders();
-    querySchema = import_zod.z.object({
-      only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
-      collection: import_zod.z.string().optional()
-    }).loose();
-    cacheEntry = import_zod.z.object({
-      code: import_zod.z.string(),
-      map: import_zod.z.any().optional(),
-      hash: import_zod.z.string().optional()
-    });
-  }
-});
-
-// src/loaders/adapter.ts
-function toVite(loader) {
-  return {
-    filter(id) {
-      return !loader.test || loader.test.test(id);
-    },
-    async transform(value, id) {
-      const [file, query = ""] = id.split("?", 2);
-      const result = await loader.load({
-        filePath: file,
-        query: (0, import_node_querystring.parse)(query),
-        getSource() {
-          return value;
-        },
-        development: this.environment.mode === "dev",
-        compiler: {
-          addDependency: (file2) => {
-            this.addWatchFile(file2);
-          }
-        }
-      });
-      if (result === null) return null;
-      return {
-        code: result.code,
-        map: result.map
-      };
-    }
-  };
-}
-var import_node_url2, import_promises4, import_node_querystring, import_node_path5, import_node_fs;
-var init_adapter = __esm({
-  "src/loaders/adapter.ts"() {
-    "use strict";
-    import_node_url2 = require("url");
-    import_promises4 = __toESM(require("fs/promises"), 1);
-    import_node_querystring = require("querystring");
-    init_validation();
-    import_node_path5 = __toESM(require("path"), 1);
-    import_node_fs = require("fs");
-  }
-});
-
-// src/loaders/config.ts
-function createIntegratedConfigLoader(core) {
-  return {
-    core,
-    getConfig() {
-      return core.getConfig();
-    }
-  };
-}
-var import_promises5;
-var init_config = __esm({
-  "src/loaders/config.ts"() {
-    "use strict";
-    import_promises5 = __toESM(require("fs/promises"), 1);
-  }
-});
-
-// src/loaders/meta.ts
-function createMetaLoader(configLoader, resolve3 = {}) {
-  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve3;
-  function parse2(filePath, source) {
-    try {
-      if (filePath.endsWith(".json")) return JSON.parse(source);
-      if (filePath.endsWith(".yaml")) return (0, import_js_yaml2.load)(source);
-    } catch (e) {
-      throw new Error(`invalid data in ${filePath}`, { cause: e });
-    }
-    throw new Error("Unknown file type " + filePath);
-  }
-  function onMeta(source, { filePath, query }) {
-    const parsed = querySchema2.safeParse(query);
-    if (!parsed.success || !parsed.data.collection) return null;
-    const collectionName = parsed.data.collection;
-    return async () => {
-      const config = await configLoader.getConfig();
-      const collection = config.getCollection(collectionName);
-      let metaCollection;
-      switch (collection?.type) {
-        case "meta":
-          metaCollection = collection;
-          break;
-        case "docs":
-          metaCollection = collection.meta;
-          break;
-      }
-      const data = parse2(filePath, source);
-      if (!metaCollection) return data;
-      return configLoader.core.transformMeta(
-        {
-          collection: metaCollection,
-          filePath,
-          source
-        },
-        data
-      );
-    };
-  }
-  return {
-    test: metaLoaderGlob,
-    async load(input) {
-      const result = onMeta(await input.getSource(), input);
-      if (result === null) return null;
-      const data = await result();
-      if (input.filePath.endsWith(".json")) {
-        return {
-          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
-        };
-      } else {
-        return {
-          code: resolveYaml === "yaml" ? (0, import_js_yaml2.dump)(data) : `export default ${JSON.stringify(data)}`
-        };
-      }
-    },
-    bun: {
-      load(source, input) {
-        const result = onMeta(source, input);
-        if (result === null)
-          return {
-            loader: "object",
-            exports: parse2(input.filePath, source)
-          };
-        return result().then((data) => ({
-          loader: "object",
-          exports: { default: data }
-        }));
-      }
-    }
-  };
-}
-var import_js_yaml2, import_zod2, querySchema2;
-var init_meta = __esm({
-  "src/loaders/meta.ts"() {
-    "use strict";
-    import_js_yaml2 = require("js-yaml");
-    import_zod2 = require("zod");
-    init_loaders();
-    querySchema2 = import_zod2.z.object({
-      collection: import_zod2.z.string().optional()
-    }).loose();
-  }
-});
-
-// src/vite/index.ts
-var vite_exports = {};
-__export(vite_exports, {
-  default: () => mdx,
-  postInstall: () => postInstall2
-});
-async function mdx(config, pluginOptions = {}) {
-  const options = applyDefaults2(pluginOptions);
-  const core = createViteCore(options);
-  await core.init({
-    config: buildConfig(config)
-  });
-  const configLoader = createIntegratedConfigLoader(core);
-  const mdxLoader = toVite(createMdxLoader(configLoader));
-  const metaLoader = toVite(
-    createMetaLoader(configLoader, {
-      // vite has built-in plugin for JSON files
-      json: "json"
-    })
-  );
-  return {
-    name: "fumadocs-mdx",
-    // needed, otherwise other plugins will be executed before our `transform`.
-    enforce: "pre",
-    config(config2) {
-      if (!options.updateViteConfig) return config2;
-      return (0, import_vite.mergeConfig)(config2, {
-        optimizeDeps: {
-          exclude: FumadocsDeps
-        },
-        resolve: {
-          noExternal: FumadocsDeps,
-          dedupe: FumadocsDeps
-        }
-      });
-    },
-    async buildStart() {
-      await core.emitAndWrite();
-    },
-    async configureServer(server) {
-      await core.initServer({
-        watcher: server.watcher
-      });
-    },
-    async transform(value, id) {
-      try {
-        if (metaLoader.filter(id)) {
-          return await metaLoader.transform.call(this, value, id);
-        }
-        if (mdxLoader.filter(id)) {
-          return await mdxLoader.transform.call(this, value, id);
-        }
-      } catch (e) {
-        if (e instanceof ValidationError) {
-          throw new Error(await e.toStringFormatted());
-        }
-        throw e;
-      }
-    }
-  };
-}
-async function postInstall2(pluginOptions = {}) {
-  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
-  const core = createViteCore(applyDefaults2(pluginOptions));
-  await core.init({
-    config: loadConfig2(core, true)
-  });
-  await core.emitAndWrite();
-}
-function createViteCore({
-  index,
-  configPath,
-  outDir
-}) {
-  if (index === true) index = {};
-  return createCore(
-    {
-      environment: "vite",
-      configPath,
-      outDir
-    },
-    [
-      index && indexFile({
-        ...index,
-        target: index.target ?? "vite"
-      })
-    ]
-  );
-}
-function applyDefaults2(options) {
-  return {
-    updateViteConfig: options.updateViteConfig ?? true,
-    index: options.index ?? true,
-    configPath: options.configPath ?? _Defaults.configPath,
-    outDir: options.outDir ?? _Defaults.outDir
-  };
-}
-var import_vite, FumadocsDeps;
-var init_vite = __esm({
-  "src/vite/index.ts"() {
-    "use strict";
-    import_vite = require("vite");
-    init_build();
-    init_validation();
-    init_mdx();
-    init_adapter();
-    init_core();
-    init_config();
-    init_meta();
-    init_index_file();
-    FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
-  }
-});
-
-// src/bin.ts
-var import_node_fs2 = require("fs");
-async function start() {
-  const [configPath, outDir] = process.argv.slice(2);
-  const isNext = (0, import_node_fs2.existsSync)("next.config.js") || (0, import_node_fs2.existsSync)("next.config.mjs") || (0, import_node_fs2.existsSync)("next.config.mts") || (0, import_node_fs2.existsSync)("next.config.ts");
-  if (isNext) {
-    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_next(), next_exports));
-    await postInstall3({ configPath, outDir });
-  } else {
-    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
-    await postInstall3({ configPath, outDir });
-  }
-}
-void start();