fumadocs-mdx 14.2.2 → 14.2.4

package/dist/next/index.cjs

@@ -1,1165 +1,952 @@
-"use strict";
+//#region rolldown:runtime
 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 __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;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, 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
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createMDX: () => createMDX,
-  postInstall: () => postInstall
-});
-module.exports = __toCommonJS(next_exports);
-var path6 = __toESM(require("path"), 1);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/config/load-from-file.ts
-var import_node_url = require("url");
+//#endregion
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_url = require("node:url");
+let picomatch = require("picomatch");
+picomatch = __toESM(picomatch);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let tinyglobby = require("tinyglobby");
+let path = require("path");
+path = __toESM(path);
+let crypto = require("crypto");
+let js_yaml = require("js-yaml");
 
-// src/config/build.ts
-var import_picomatch = __toESM(require("picomatch"), 1);
-
-// src/config/preset.ts
+//#region 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;
+	const list = def(Array.isArray(options) ? options : []).filter(Boolean);
+	if (typeof options === "function") return options(list);
+	return list;
 }
+/**
+* apply MDX processor presets
+*/
 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,
-          {
-            exportAs: "structuredData",
-            ...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
-    };
-  };
+	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, {
+				exportAs: "structuredData",
+				...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
+		};
+	};
 }
 
-// src/config/build.ts
-var import_node_path = __toESM(require("path"), 1);
-var SupportedFormats = {
-  doc: ["mdx", "md"],
-  meta: ["json", "yaml"]
+//#endregion
+//#region src/config/build.ts
+const SupportedFormats = {
+	doc: ["mdx", "md"],
+	meta: ["json", "yaml"]
 };
 function buildCollection(name, collection, cwd) {
-  if (collection.type === "docs") {
-    return {
-      ...collection,
-      type: "docs",
-      get dir() {
-        return this.docs.dir;
-      },
-      name,
-      meta: buildCollection(name, collection.meta, cwd),
-      docs: buildCollection(name, collection.docs, cwd),
-      hasFile(filePath) {
-        return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
-      },
-      isFileSupported(filePath) {
-        return this.docs.isFileSupported(filePath) || this.meta.isFileSupported(filePath);
-      },
-      cwd
-    };
-  }
-  return {
-    ...collection,
-    ...buildPrimitiveCollection(name, collection, cwd)
-  };
+	if (collection.type === "docs") return {
+		...collection,
+		type: "docs",
+		get dir() {
+			return this.docs.dir;
+		},
+		name,
+		meta: buildCollection(name, collection.meta, cwd),
+		docs: buildCollection(name, collection.docs, cwd),
+		hasFile(filePath) {
+			return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
+		},
+		isFileSupported(filePath) {
+			return this.docs.isFileSupported(filePath) || this.meta.isFileSupported(filePath);
+		},
+		cwd
+	};
+	return {
+		...collection,
+		...buildPrimitiveCollection(name, collection, cwd)
+	};
 }
 function buildPrimitiveCollection(name, config, cwd) {
-  const supportedFormats = SupportedFormats[config.type];
-  const patterns = config.files ?? [`**/*.{${supportedFormats.join(",")}}`];
-  let matcher;
-  return {
-    dir: import_node_path.default.resolve(cwd, config.dir),
-    cwd,
-    name,
-    patterns,
-    isFileSupported(filePath) {
-      return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
-    },
-    hasFile(filePath) {
-      if (!this.isFileSupported(filePath)) return false;
-      const relativePath = import_node_path.default.relative(this.dir, filePath);
-      if (relativePath.startsWith(`..${import_node_path.default.sep}`)) return false;
-      return (matcher ??= (0, import_picomatch.default)(patterns))(relativePath);
-    }
-  };
+	const supportedFormats = SupportedFormats[config.type];
+	const patterns = config.files ?? [`**/*.{${supportedFormats.join(",")}}`];
+	let matcher;
+	return {
+		dir: node_path.default.resolve(cwd, config.dir),
+		cwd,
+		name,
+		patterns,
+		isFileSupported(filePath) {
+			return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
+		},
+		hasFile(filePath) {
+			if (!this.isFileSupported(filePath)) return false;
+			const relativePath = node_path.default.relative(this.dir, filePath);
+			if (relativePath.startsWith(`..${node_path.default.sep}`)) return false;
+			return (matcher ??= (0, picomatch.default)(patterns))(relativePath);
+		}
+	};
 }
 function buildConfig(config, cwd = process.cwd()) {
-  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" || v.type === "doc" || v.type === "meta") {
-        collections.set(k, buildCollection(k, v, cwd));
-        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,
-    collections,
-    workspaces: Object.fromEntries(
-      Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
-        return [
-          key,
-          {
-            dir: value.dir,
-            config: buildConfig(value.config, import_node_path.default.resolve(cwd, value.dir))
-          }
-        ];
-      })
-    ),
-    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;
-    }
-  };
+	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" || v.type === "doc" || v.type === "meta") {
+				collections.set(k, buildCollection(k, v, cwd));
+				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,
+		collections,
+		workspaces: Object.fromEntries(Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
+			return [key, {
+				dir: value.dir,
+				config: buildConfig(value.config, node_path.default.resolve(cwd, value.dir))
+			}];
+		})),
+		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;
+				return applyMdxPreset(typeof optionsFn === "function" ? await optionsFn() : optionsFn)(environment);
+			})();
+			mdxOptionsCache.set(key, result);
+			return result;
+		}
+	};
 }
 
-// src/config/load-from-file.ts
+//#endregion
+//#region src/config/load-from-file.ts
 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");
-  }
+	const { build } = await import("esbuild");
+	const { configPath, outDir } = core.getOptions();
+	if ((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
+	})).errors.length > 0) throw new Error("failed to compile configuration file");
 }
+/**
+* Load config
+*
+* @param build - By default, it assumes the config file has been compiled. Set this `true` to compile the config first.
+*/
 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;
+	if (build) await compileConfig(core);
+	const url = (0, node_url.pathToFileURL)(core.getCompiledConfigPath());
+	url.searchParams.set("hash", Date.now().toString());
+	return await import(url.href).then((loaded) => buildConfig(loaded));
 }
 
-// src/core.ts
-var import_node_path3 = __toESM(require("path"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
-
-// src/utils/validation.ts
+//#endregion
+//#region 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 picocolorsModule = await import("picocolors");
-    const picocolors = picocolorsModule.default ?? picocolorsModule;
-    return [
-      picocolors.bold(`[MDX] ${this.title}:`),
-      ...this.issues.map(
-        (issue) => picocolors.redBright(
-          `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
-        )
-      )
-    ].join("\n");
-  }
+	constructor(message, issues) {
+		super(`${message}:\n${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`);
+		this.title = message;
+		this.issues = issues;
+	}
+	async toStringFormatted() {
+		const picocolorsModule = await import("picocolors");
+		const picocolors = picocolorsModule.default ?? picocolorsModule;
+		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;
+	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/codegen.ts
-var import_node_path2 = __toESM(require("path"), 1);
-var import_tinyglobby = require("tinyglobby");
-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_path2.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_path2.default.join(base, item);
-        const searchParams = new URLSearchParams();
-        for (const [k, v] of Object.entries(query)) {
-          if (v !== void 0) 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_path2.default.extname(file);
-      let filename;
-      if (ext === ".ts") {
-        filename = file.substring(0, file.length - ext.length);
-        if (jsExtension) filename += ".js";
-      } else {
-        filename = file;
-      }
-      const importPath = slash(import_node_path2.default.relative(outDir, filename));
-      return importPath.startsWith(".") ? importPath : `./${importPath}`;
-    },
-    toString() {
-      return [...banner, ...this.lines].join("\n");
-    }
-  };
+//#endregion
+//#region src/utils/codegen.ts
+/**
+* Code generator (one instance per file)
+*/
+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(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, tinyglobby.glob)(patterns, { cwd: base });
+				globCache.set(cacheKey, files);
+			}
+			let code = "{";
+			for (const item of await files) {
+				const fullPath = node_path.default.join(base, item);
+				const searchParams = new URLSearchParams();
+				for (const [k, v] of Object.entries(query)) if (v !== void 0) 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 = node_path.default.extname(file);
+			let filename;
+			if (ext === ".ts") {
+				filename = file.substring(0, file.length - ext.length);
+				if (jsExtension) filename += ".js";
+			} else filename = file;
+			const importPath = slash(node_path.default.relative(outDir, filename));
+			return importPath.startsWith(".") ? importPath : `./${importPath}`;
+		},
+		toString() {
+			return [...banner, ...this.lines].join("\n");
+		}
+	};
 }
+/**
+* convert into POSIX & relative file paths, such that Vite can accept it.
+*/
 function normalizeViteGlobPath(file) {
-  file = slash(file);
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
+	file = slash(file);
+	if (file.startsWith("./")) return file;
+	if (file.startsWith("/")) return `.${file}`;
+	return `./${file}`;
 }
-function slash(path7) {
-  const isExtendedLengthPath = path7.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path7;
-  }
-  return path7.replaceAll("\\", "/");
+function slash(path$6) {
+	if (path$6.startsWith("\\\\?\\")) return path$6;
+	return path$6.replaceAll("\\", "/");
 }
 function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+	return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
 
-// src/core.ts
-var _Defaults = {
-  configPath: "source.config.ts",
-  outDir: ".source"
+//#endregion
+//#region src/core.ts
+const _Defaults = {
+	configPath: "source.config.ts",
+	outDir: ".source"
 };
 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;
+	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) {
-  let config;
-  let plugins;
-  const workspaces = /* @__PURE__ */ new Map();
-  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;
-  }
-  return {
-    /**
-     * Convenient cache store, reset when config changes
-     */
-    cache: /* @__PURE__ */ new Map(),
-    async init({ config: newConfig }) {
-      config = await newConfig;
-      this.cache.clear();
-      workspaces.clear();
-      plugins = await getPlugins([
-        postprocessPlugin(),
-        options.plugins,
-        config.global.plugins
-      ]);
-      for (const plugin of plugins) {
-        const out = await plugin.config?.call(this.getPluginContext(), config);
-        if (out) config = out;
-      }
-      if (!options.workspace) {
-        await Promise.all(
-          Object.entries(config.workspaces).map(async ([name, workspace]) => {
-            const core = createCore({
-              ...options,
-              outDir: import_node_path3.default.join(options.outDir, name),
-              workspace: {
-                name,
-                parent: this,
-                dir: workspace.dir
-              }
-            });
-            await core.init({ config: workspace.config });
-            workspaces.set(name, core);
-          })
-        );
-      }
-    },
-    getWorkspaces() {
-      return workspaces;
-    },
-    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_path3.default.join(options.outDir, "source.config.mjs");
-    },
-    getPlugins() {
-      return plugins;
-    },
-    getCollections() {
-      return Array.from(config.collections.values());
-    },
-    getCollection(name) {
-      return config.collections.get(name);
-    },
-    getPluginContext() {
-      return {
-        core: this
-      };
-    },
-    async initServer(server) {
-      const ctx = this.getPluginContext();
-      for (const plugin of plugins) {
-        await plugin.configureServer?.call(ctx, server);
-      }
-      for (const workspace of workspaces.values()) {
-        await workspace.initServer(server);
-      }
-    },
-    async emit(emitOptions = {}) {
-      const { filterPlugin, filterWorkspace, write = false } = emitOptions;
-      const start = performance.now();
-      const ctx = this.getPluginContext();
-      const added = /* @__PURE__ */ new Set();
-      const out = {
-        entries: [],
-        workspaces: {}
-      };
-      for (const li of await Promise.all(
-        plugins.map((plugin) => {
-          if (filterPlugin && !filterPlugin(plugin) || !plugin.emit) return;
-          return plugin.emit.call(ctx);
-        })
-      )) {
-        if (!li) continue;
-        for (const item of li) {
-          if (added.has(item.path)) continue;
-          out.entries.push(item);
-          added.add(item.path);
-        }
-      }
-      if (write) {
-        await Promise.all(
-          out.entries.map(async (entry) => {
-            const file = import_node_path3.default.join(options.outDir, entry.path);
-            await import_promises.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
-            await import_promises.default.writeFile(file, entry.content);
-          })
-        );
-        console.log(
-          options.workspace ? `[MDX: ${options.workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
-        );
-      }
-      for (const [name, workspace] of workspaces) {
-        if (filterWorkspace && !filterWorkspace(name)) continue;
-        out.workspaces[name] = (await workspace.emit(emitOptions)).entries;
-      }
-      return out;
-    },
-    async transformMeta(options2, data) {
-      const ctx = {
-        ...this.getPluginContext(),
-        ...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 = {
-        ...this.getPluginContext(),
-        ...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 = {
-        ...this.getPluginContext(),
-        ...options2
-      };
-      for (const plugin of plugins) {
-        if (plugin.doc?.vfile)
-          file = await plugin.doc.vfile.call(ctx, file) ?? file;
-      }
-      return file;
-    }
-  };
+	let config;
+	let plugins;
+	const workspaces = /* @__PURE__ */ new Map();
+	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;
+	}
+	return {
+		cache: /* @__PURE__ */ new Map(),
+		async init({ config: newConfig }) {
+			config = await newConfig;
+			this.cache.clear();
+			workspaces.clear();
+			plugins = await getPlugins([
+				postprocessPlugin(),
+				options.plugins,
+				config.global.plugins
+			]);
+			for (const plugin of plugins) {
+				const out = await plugin.config?.call(this.getPluginContext(), config);
+				if (out) config = out;
+			}
+			if (!options.workspace) await Promise.all(Object.entries(config.workspaces).map(async ([name, workspace]) => {
+				const core = createCore({
+					...options,
+					outDir: node_path.default.join(options.outDir, name),
+					workspace: {
+						name,
+						parent: this,
+						dir: workspace.dir
+					}
+				});
+				await core.init({ config: workspace.config });
+				workspaces.set(name, core);
+			}));
+		},
+		getWorkspaces() {
+			return workspaces;
+		},
+		getOptions() {
+			return options;
+		},
+		getConfig() {
+			return config;
+		},
+		getCompiledConfigPath() {
+			return node_path.default.join(options.outDir, "source.config.mjs");
+		},
+		getPlugins() {
+			return plugins;
+		},
+		getCollections() {
+			return Array.from(config.collections.values());
+		},
+		getCollection(name) {
+			return config.collections.get(name);
+		},
+		getPluginContext() {
+			return { core: this };
+		},
+		async initServer(server) {
+			const ctx = this.getPluginContext();
+			for (const plugin of plugins) await plugin.configureServer?.call(ctx, server);
+			for (const workspace of workspaces.values()) await workspace.initServer(server);
+		},
+		async emit(emitOptions = {}) {
+			const { filterPlugin, filterWorkspace, write = false } = emitOptions;
+			const start = performance.now();
+			const ctx = this.getPluginContext();
+			const added = /* @__PURE__ */ new Set();
+			const out = {
+				entries: [],
+				workspaces: {}
+			};
+			for (const li of await Promise.all(plugins.map((plugin) => {
+				if (filterPlugin && !filterPlugin(plugin) || !plugin.emit) return;
+				return plugin.emit.call(ctx);
+			}))) {
+				if (!li) continue;
+				for (const item of li) {
+					if (added.has(item.path)) continue;
+					out.entries.push(item);
+					added.add(item.path);
+				}
+			}
+			if (write) {
+				await Promise.all(out.entries.map(async (entry) => {
+					const file = node_path.default.join(options.outDir, entry.path);
+					await node_fs_promises.default.mkdir(node_path.default.dirname(file), { recursive: true });
+					await node_fs_promises.default.writeFile(file, entry.content);
+				}));
+				console.log(options.workspace ? `[MDX: ${options.workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`);
+			}
+			for (const [name, workspace] of workspaces) {
+				if (filterWorkspace && !filterWorkspace(name)) continue;
+				out.workspaces[name] = (await workspace.emit(emitOptions)).entries;
+			}
+			return out;
+		},
+		async transformMeta(options$1, data) {
+			const ctx = {
+				...this.getPluginContext(),
+				...options$1
+			};
+			data = await transformMetadata(options$1, data);
+			for (const plugin of plugins) if (plugin.meta?.transform) data = await plugin.meta.transform.call(ctx, data) ?? data;
+			return data;
+		},
+		async transformFrontmatter(options$1, data) {
+			const ctx = {
+				...this.getPluginContext(),
+				...options$1
+			};
+			data = await transformMetadata(options$1, data);
+			for (const plugin of plugins) if (plugin.doc?.frontmatter) data = await plugin.doc.frontmatter.call(ctx, data) ?? data;
+			return data;
+		},
+		async transformVFile(options$1, file) {
+			const ctx = {
+				...this.getPluginContext(),
+				...options$1
+			};
+			for (const plugin of plugins) if (plugin.doc?.vfile) file = await plugin.doc.vfile.call(ctx, file) ?? file;
+			return file;
+		}
+	};
 }
 function postprocessPlugin() {
-  const LinkReferenceTypes = `{
+	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.getCollections()) {
-          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");
-      }
-    }
-  };
+	return { "index-file": {
+		generateTypeConfig() {
+			const lines = [];
+			lines.push("{");
+			lines.push("  DocData: {");
+			for (const collection of this.core.getCollections()) {
+				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");
+		}
+	} };
 }
 
-// src/loaders/index.ts
-var metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
-var mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+//#endregion
+//#region src/loaders/index.ts
+const metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+const mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
 
-// src/plugins/index-file.ts
-var import_path = __toESM(require("path"), 1);
-var import_tinyglobby2 = require("tinyglobby");
-
-// src/utils/fs-cache.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-var map = /* @__PURE__ */ new Map();
+//#endregion
+//#region src/utils/fs-cache.ts
+const map = /* @__PURE__ */ new Map();
 function createFSCache() {
-  return {
-    read(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;
-    },
-    delete(file) {
-      map.delete(toFullPath(file));
-    }
-  };
+	return {
+		read(file) {
+			const fullPath = toFullPath(file);
+			const cached = map.get(fullPath);
+			if (cached) return cached;
+			const read = node_fs_promises.default.readFile(fullPath).then((s) => s.toString());
+			map.set(fullPath, read);
+			return read;
+		},
+		delete(file) {
+			map.delete(toFullPath(file));
+		}
+	};
 }
+/**
+* make file paths relative to cwd
+*/
 function toFullPath(file) {
-  if (import_node_path4.default.isAbsolute(file)) {
-    return import_node_path4.default.relative(process.cwd(), file);
-  }
-  return file;
+	if (node_path.default.isAbsolute(file)) return node_path.default.relative(process.cwd(), file);
+	return file;
 }
 
-// src/plugins/index-file.ts
-var import_crypto = require("crypto");
-
-// src/utils/fuma-matter.ts
-var import_js_yaml = require("js-yaml");
-var regex = /^---\r?\n(.+?)\r?\n---\r?\n/s;
+//#endregion
+//#region src/utils/fuma-matter.ts
+/**
+* Inspired by https://github.com/jonschlinkert/gray-matter
+*/
+const regex = /^---\r?\n(.+?)\r?\n---\r?\n?/s;
+/**
+* parse frontmatter, it supports only yaml format
+*/
 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;
+	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);
+	output.data = (0, js_yaml.load)(match[1]) ?? {};
+	return output;
 }
 
-// src/plugins/index-file.ts
-var indexFileCache = createFSCache();
+//#endregion
+//#region src/plugins/index-file.ts
+const indexFileCache = createFSCache();
 function indexFile(options = {}) {
-  const {
-    target = "default",
-    addJsExtension,
-    browser = true,
-    dynamic = true
-  } = options;
-  let dynamicCollections;
-  function isDynamic(collection) {
-    return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
-  }
-  function generateConfigs(core) {
-    const serverOptions = {};
-    const typeConfigs = [
-      'import("fumadocs-mdx/runtime/types").InternalTypeConfig'
-    ];
-    const ctx = core.getPluginContext();
-    for (const plugin of core.getPlugins()) {
-      const indexFilePlugin = plugin["index-file"];
-      if (!indexFilePlugin) continue;
-      indexFilePlugin.serverOptions?.call(ctx, serverOptions);
-      const config = indexFilePlugin.generateTypeConfig?.call(ctx);
-      if (config) typeConfigs.push(config);
-    }
-    return {
-      serverOptions,
-      tc: typeConfigs.join(" & ")
-    };
-  }
-  return {
-    name: "index-file",
-    config() {
-      dynamicCollections = this.core.getCollections().filter(isDynamic);
-    },
-    configureServer(server) {
-      if (!server.watcher) return;
-      server.watcher.on("all", async (event, file) => {
-        indexFileCache.delete(file);
-        if (dynamicCollections.length === 0) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        const updatedCollection = this.core.getCollections().find((collection) => collection.hasFile(file));
-        if (!updatedCollection) return;
-        if (!isDynamic(updatedCollection)) {
-          if (target === "vite") return;
-          if (target === "default" && event === "change") return;
-        }
-        await this.core.emit({
-          filterPlugin: (plugin) => plugin.name === "index-file",
-          filterWorkspace: () => false,
-          write: true
-        });
-      });
-    },
-    async emit() {
-      const globCache = /* @__PURE__ */ new Map();
-      const { workspace, outDir } = this.core.getOptions();
-      const { serverOptions, tc } = generateConfigs(this.core);
-      const toEmitEntry = async (path7, content) => {
-        const codegen = createCodegen({
-          target,
-          outDir,
-          jsExtension: addJsExtension,
-          globCache
-        });
-        await content({
-          core: this.core,
-          codegen,
-          serverOptions,
-          tc,
-          workspace: workspace?.name
-        });
-        return {
-          path: path7,
-          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);
-    }
-  };
+	const { target = "default", addJsExtension, browser = true, dynamic = true } = options;
+	let dynamicCollections;
+	function isDynamic(collection) {
+		return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
+	}
+	function generateConfigs(core) {
+		const serverOptions = {};
+		const typeConfigs = ["import(\"fumadocs-mdx/runtime/types\").InternalTypeConfig"];
+		const ctx = core.getPluginContext();
+		for (const plugin of core.getPlugins()) {
+			const indexFilePlugin = plugin["index-file"];
+			if (!indexFilePlugin) continue;
+			indexFilePlugin.serverOptions?.call(ctx, serverOptions);
+			const config = indexFilePlugin.generateTypeConfig?.call(ctx);
+			if (config) typeConfigs.push(config);
+		}
+		return {
+			serverOptions,
+			tc: typeConfigs.join(" & ")
+		};
+	}
+	return {
+		name: "index-file",
+		config() {
+			dynamicCollections = this.core.getCollections().filter(isDynamic);
+		},
+		configureServer(server) {
+			if (!server.watcher) return;
+			server.watcher.on("all", async (event, file) => {
+				indexFileCache.delete(file);
+				if (dynamicCollections.length === 0) {
+					if (target === "vite") return;
+					if (target === "default" && event === "change") return;
+				}
+				const updatedCollection = this.core.getCollections().find((collection) => collection.hasFile(file));
+				if (!updatedCollection) return;
+				if (!isDynamic(updatedCollection)) {
+					if (target === "vite") return;
+					if (target === "default" && event === "change") return;
+				}
+				await this.core.emit({
+					filterPlugin: (plugin) => plugin.name === "index-file",
+					filterWorkspace: () => false,
+					write: true
+				});
+			});
+		},
+		async emit() {
+			const globCache = /* @__PURE__ */ new Map();
+			const { workspace, outDir } = this.core.getOptions();
+			const { serverOptions, tc } = generateConfigs(this.core);
+			const toEmitEntry = async (path$6, content) => {
+				const codegen = createCodegen({
+					target,
+					outDir,
+					jsExtension: addJsExtension,
+					globCache
+				});
+				await content({
+					core: this.core,
+					codegen,
+					serverOptions,
+					tc,
+					workspace: workspace?.name
+				});
+				return {
+					path: path$6,
+					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(ctx) {
-  const { core, codegen, serverOptions, tc } = ctx;
-  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) {
-    const base = getBase(collection);
-    switch (collection.type) {
-      case "docs": {
-        if (collection.docs.dynamic) return;
-        if (collection.docs.async) {
-          const [metaGlob2, headGlob, bodyGlob] = await Promise.all([
-            generateMetaCollectionGlob(ctx, collection.meta, true),
-            generateDocCollectionFrontmatterGlob(ctx, collection.docs, true),
-            generateDocCollectionGlob(ctx, collection.docs)
-          ]);
-          return `await create.docsLazy("${collection.name}", "${base}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
-        }
-        const [metaGlob, docGlob] = await Promise.all([
-          generateMetaCollectionGlob(ctx, collection.meta, true),
-          generateDocCollectionGlob(ctx, collection.docs, true)
-        ]);
-        return `await create.docs("${collection.name}", "${base}", ${metaGlob}, ${docGlob})`;
-      }
-      case "doc":
-        if (collection.dynamic) return;
-        if (collection.async) {
-          const [headGlob, bodyGlob] = await Promise.all([
-            generateDocCollectionFrontmatterGlob(ctx, collection, true),
-            generateDocCollectionGlob(ctx, collection)
-          ]);
-          return `await create.docLazy("${collection.name}", "${base}", ${headGlob}, ${bodyGlob})`;
-        }
-        return `await create.doc("${collection.name}", "${base}", ${await generateDocCollectionGlob(
-          ctx,
-          collection,
-          true
-        )})`;
-      case "meta":
-        return `await create.meta("${collection.name}", "${base}", ${await generateMetaCollectionGlob(
-          ctx,
-          collection,
-          true
-        )})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
+	const { core, codegen, serverOptions, tc } = ctx;
+	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) {
+		const base = getBase(collection);
+		switch (collection.type) {
+			case "docs": {
+				if (collection.docs.dynamic) return;
+				if (collection.docs.async) {
+					const [metaGlob$1, headGlob, bodyGlob] = await Promise.all([
+						generateMetaCollectionGlob(ctx, collection.meta, true),
+						generateDocCollectionFrontmatterGlob(ctx, collection.docs, true),
+						generateDocCollectionGlob(ctx, collection.docs)
+					]);
+					return `await create.docsLazy("${collection.name}", "${base}", ${metaGlob$1}, ${headGlob}, ${bodyGlob})`;
+				}
+				const [metaGlob, docGlob] = await Promise.all([generateMetaCollectionGlob(ctx, collection.meta, true), generateDocCollectionGlob(ctx, collection.docs, true)]);
+				return `await create.docs("${collection.name}", "${base}", ${metaGlob}, ${docGlob})`;
+			}
+			case "doc":
+				if (collection.dynamic) return;
+				if (collection.async) {
+					const [headGlob, bodyGlob] = await Promise.all([generateDocCollectionFrontmatterGlob(ctx, collection, true), generateDocCollectionGlob(ctx, collection)]);
+					return `await create.docLazy("${collection.name}", "${base}", ${headGlob}, ${bodyGlob})`;
+				}
+				return `await create.doc("${collection.name}", "${base}", ${await generateDocCollectionGlob(ctx, collection, true)})`;
+			case "meta": return `await create.meta("${collection.name}", "${base}", ${await generateMetaCollectionGlob(ctx, collection, true)})`;
+		}
+	}
+	await codegen.pushAsync(core.getCollections().map(async (collection) => {
+		const obj = await generateCollectionObject(collection);
+		if (!obj) return;
+		return `\nexport const ${collection.name} = ${obj};`;
+	}));
 }
 async function generateDynamicIndexFile(ctx) {
-  const { core, codegen, serverOptions, tc } = ctx;
-  const { configPath, environment, outDir } = core.getOptions();
-  const partialOptions = {
-    configPath,
-    environment,
-    outDir
-  };
-  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(partialOptions)}, ${JSON.stringify(serverOptions)});`
-  );
-  async function generateCollectionObjectEntry(collection, absolutePath) {
-    const fullPath = import_path.default.relative(process.cwd(), absolutePath);
-    const content = await indexFileCache.read(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: import_path.default.relative(collection.dir, absolutePath)
-      },
-      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,
-      absolute: true
-    });
-    const entries = await Promise.all(
-      files.map((file) => generateCollectionObjectEntry(collection, file))
-    );
-    switch (parent.type) {
-      case "docs": {
-        const metaGlob = await generateMetaCollectionGlob(
-          ctx,
-          parent.meta,
-          true
-        );
-        return `await create.docs("${parent.name}", "${getBase(parent)}", ${metaGlob}, ${entries.join(", ")})`;
-      }
-      case "doc":
-        return `await create.doc("${collection.name}", "${getBase(collection)}", ${entries.join(", ")})`;
-    }
-  }
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return `
-export const ${collection.name} = ${obj};`;
-    })
-  );
+	const { core, codegen, serverOptions, tc } = ctx;
+	const { configPath, environment, outDir } = core.getOptions();
+	const partialOptions = {
+		configPath,
+		environment,
+		outDir
+	};
+	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(partialOptions)}, ${JSON.stringify(serverOptions)});`);
+	async function generateCollectionObjectEntry(collection, absolutePath) {
+		const fullPath = path.default.relative(process.cwd(), absolutePath);
+		const content = await indexFileCache.read(fullPath).catch(() => "");
+		const parsed = fumaMatter(content);
+		const data = await core.transformFrontmatter({
+			collection,
+			filePath: fullPath,
+			source: content
+		}, parsed.data);
+		const hash = (0, crypto.createHash)("md5").update(content).digest("hex");
+		const infoStr = [`absolutePath: path.resolve(${JSON.stringify(fullPath)})`];
+		for (const [k, v] of Object.entries({
+			info: {
+				fullPath,
+				path: path.default.relative(collection.dir, absolutePath)
+			},
+			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, tinyglobby.glob)(collection.patterns, {
+			cwd: collection.dir,
+			absolute: true
+		});
+		const entries = await Promise.all(files.map((file) => generateCollectionObjectEntry(collection, file)));
+		switch (parent.type) {
+			case "docs": {
+				const metaGlob = await generateMetaCollectionGlob(ctx, parent.meta, true);
+				return `await create.docs("${parent.name}", "${getBase(parent)}", ${metaGlob}, ${entries.join(", ")})`;
+			}
+			case "doc": return `await create.doc("${collection.name}", "${getBase(collection)}", ${entries.join(", ")})`;
+		}
+	}
+	await codegen.pushAsync(core.getCollections().map(async (collection) => {
+		const obj = await generateCollectionObject(collection);
+		if (!obj) return;
+		return `\nexport const ${collection.name} = ${obj};`;
+	}));
 }
 async function generateBrowserIndexFile(ctx) {
-  const { core, codegen, tc } = ctx;
-  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(ctx, collection)})`;
-    }
-  }
-  codegen.lines.push("const browserCollections = {");
-  await codegen.pushAsync(
-    core.getCollections().map(async (collection) => {
-      const obj = await generateCollectionObject(collection);
-      if (!obj) return;
-      return ident(`${collection.name}: ${obj},`);
-    })
-  );
-  codegen.lines.push("};", "export default browserCollections;");
+	const { core, codegen, tc } = ctx;
+	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(ctx, collection)})`;
+		}
+	}
+	codegen.lines.push("const browserCollections = {");
+	await codegen.pushAsync(core.getCollections().map(async (collection) => {
+		const obj = await generateCollectionObject(collection);
+		if (!obj) return;
+		return ident(`${collection.name}: ${obj},`);
+	}));
+	codegen.lines.push("};", "export default browserCollections;");
 }
 function getBase(collection) {
-  return slash(import_path.default.relative(process.cwd(), collection.dir));
+	return slash(path.default.relative(process.cwd(), collection.dir));
 }
 function generateDocCollectionFrontmatterGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      only: "frontmatter",
-      workspace
-    },
-    import: "frontmatter",
-    base: collection.dir,
-    eager
-  });
+	return codegen.generateGlobImport(collection.patterns, {
+		query: {
+			collection: collection.name,
+			only: "frontmatter",
+			workspace
+		},
+		import: "frontmatter",
+		base: collection.dir,
+		eager
+	});
 }
 function generateDocCollectionGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      workspace
-    },
-    base: collection.dir,
-    eager
-  });
+	return codegen.generateGlobImport(collection.patterns, {
+		query: {
+			collection: collection.name,
+			workspace
+		},
+		base: collection.dir,
+		eager
+	});
 }
 function generateMetaCollectionGlob({ codegen, workspace }, collection, eager = false) {
-  return codegen.generateGlobImport(collection.patterns, {
-    query: {
-      collection: collection.name,
-      workspace
-    },
-    import: "default",
-    base: collection.dir,
-    eager
-  });
+	return codegen.generateGlobImport(collection.patterns, {
+		query: {
+			collection: collection.name,
+			workspace
+		},
+		import: "default",
+		base: collection.dir,
+		eager
+	});
 }
 
-// src/next/index.ts
-var defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
+//#endregion
+//#region src/next/index.ts
+const defaultPageExtensions = [
+	"mdx",
+	"md",
+	"jsx",
+	"js",
+	"tsx",
+	"ts"
+];
 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 { configPath, outDir } = core.getOptions();
-    const loaderOptions = {
-      configPath,
-      outDir,
-      absoluteCompiledConfigPath: path6.resolve(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,
-            enforce: "pre",
-            use: [
-              {
-                loader: "fumadocs-mdx/loader-meta",
-                options: loaderOptions
-              }
-            ]
-          }
-        );
-        config.plugins ||= [];
-        return nextConfig.webpack?.(config, options) ?? config;
-      }
-    };
-  };
+	const core = createNextCore(applyDefaults(createOptions));
+	const isDev = process.env.NODE_ENV === "development";
+	if (process.env._FUMADOCS_MDX !== "1") {
+		process.env._FUMADOCS_MDX = "1";
+		init(isDev, core);
+	}
+	return (nextConfig = {}) => {
+		const { configPath, outDir } = core.getOptions();
+		const loaderOptions = {
+			configPath,
+			outDir,
+			absoluteCompiledConfigPath: node_path.resolve(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,
+					enforce: "pre",
+					use: [{
+						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.emit({ write: true });
-  }
-  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.getCollections()) {
-      watcher.add(collection.dir);
-    }
-    for (const workspace of core.getWorkspaces().values()) {
-      for (const collection of workspace.getCollections()) {
-        watcher.add(collection.dir);
-      }
-    }
-    watcher.on("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    const absoluteConfigPath = path6.resolve(configPath);
-    watcher.on("all", async (_event, file) => {
-      if (path6.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 initOrReload() {
+		await core.init({ config: loadConfig(core, true) });
+		await core.emit({ write: true });
+	}
+	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.getCollections()) watcher.add(collection.dir);
+		for (const workspace of core.getWorkspaces().values()) for (const collection of workspace.getCollections()) watcher.add(collection.dir);
+		watcher.on("ready", () => {
+			console.log("[MDX] started dev server");
+		});
+		const absoluteConfigPath = node_path.resolve(configPath);
+		watcher.on("all", async (_event, file) => {
+			if (node_path.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");
+			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.emit({ write: true });
+	const core = createNextCore(applyDefaults(options));
+	await core.init({ config: loadConfig(core, true) });
+	await core.emit({ write: true });
 }
 function applyDefaults(options) {
-  return {
-    index: {},
-    outDir: options.outDir ?? _Defaults.outDir,
-    configPath: options.configPath ?? _Defaults.configPath
-  };
+	return {
+		index: {},
+		outDir: options.outDir ?? _Defaults.outDir,
+		configPath: options.configPath ?? _Defaults.configPath
+	};
 }
 function createNextCore(options) {
-  return createCore({
-    environment: "next",
-    outDir: options.outDir,
-    configPath: options.configPath,
-    plugins: [options.index && indexFile(options.index)]
-  });
+	return createCore({
+		environment: "next",
+		outDir: options.outDir,
+		configPath: options.configPath,
+		plugins: [options.index && indexFile(options.index)]
+	});
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createMDX,
-  postInstall
-});
+
+//#endregion
+exports.createMDX = createMDX;
+exports.postInstall = postInstall;