fumadocs-mdx 12.0.3 → 13.0.0

package/dist/bin.cjs

@@ -30,6 +30,73 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/loaders/config/index.ts
+function findConfigFile() {
+  return import_node_path.default.resolve("source.config.ts");
+}
+function resolvedConfig(loaded) {
+  return {
+    getConfig() {
+      return loaded;
+    }
+  };
+}
+var import_node_path, import_promises;
+var init_config = __esm({
+  "src/loaders/config/index.ts"() {
+    "use strict";
+    import_node_path = __toESM(require("path"), 1);
+    import_promises = __toESM(require("fs/promises"), 1);
+  }
+});
+
+// src/plugins/index.ts
+function createPluginHandler(context, defaultPlugins = []) {
+  const plugins2 = [];
+  async function write(entry) {
+    const file = import_node_path2.default.join(context.outDir, entry.path);
+    await import_promises2.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
+    await import_promises2.default.writeFile(file, entry.content);
+  }
+  return {
+    async init(config) {
+      if (config.global.plugins) {
+        defaultPlugins.push(...config.global.plugins);
+      }
+      for await (const option of defaultPlugins) {
+        if (!option) continue;
+        if (Array.isArray(option)) plugins2.push(...option);
+        else plugins2.push(option);
+      }
+      for (const plugin of plugins2) {
+        const out = await plugin.config?.call(context, config);
+        if (out) config = out;
+      }
+      return config;
+    },
+    async emit() {
+      const out = await Promise.all(
+        plugins2.map((plugin) => {
+          return plugin.emit?.call(context) ?? [];
+        })
+      );
+      return out.flat();
+    },
+    async emitAndWrite() {
+      const entries = await this.emit();
+      await Promise.all(entries.map(write));
+    }
+  };
+}
+var import_node_path2, import_promises2;
+var init_plugins = __esm({
+  "src/plugins/index.ts"() {
+    "use strict";
+    import_node_path2 = __toESM(require("path"), 1);
+    import_promises2 = __toESM(require("fs/promises"), 1);
+  }
+});
+
 // src/loaders/mdx/preset.ts
 var preset_exports = {};
 __export(preset_exports, {
@@ -173,6 +240,10 @@ var init_build = __esm({
 });
 
 // src/loaders/config/load.ts
+var load_exports = {};
+__export(load_exports, {
+  loadConfig: () => loadConfig
+});
 async function compileConfig(configPath, outDir) {
   const { build } = await import("esbuild");
   const transformed = await build({
@@ -193,37 +264,53 @@ async function compileConfig(configPath, outDir) {
     throw new Error("failed to compile configuration file");
   }
 }
-async function loadConfig(configPath, outDir, hash, build = false) {
-  if (cache && cache.hash === hash) {
-    return await cache.config;
-  }
+async function loadConfig(configPath, outDir, build = false) {
   if (build) await compileConfig(configPath, outDir);
-  const url = (0, import_node_url.pathToFileURL)(path.resolve(outDir, "source.config.mjs"));
-  const config = import(`${url.href}?hash=${hash}`).then((loaded) => {
-    return buildConfig(
-      // every call to `loadConfig` will cause the previous cache to be ignored
-      loaded
-    );
-  });
-  if (hash) cache = { config, hash };
+  const url = (0, import_node_url.pathToFileURL)(path3.resolve(outDir, "source.config.mjs"));
+  url.searchParams.set("hash", Date.now().toString());
+  const config = import(url.href).then(
+    (loaded) => buildConfig(loaded)
+  );
   return await config;
 }
-async function getConfigHash(configPath) {
-  const stats = await fs.stat(configPath).catch(() => void 0);
-  if (stats) {
-    return stats.mtime.getTime().toString();
-  }
-  throw new Error("Cannot find config file");
-}
-var fs, path, import_node_url, cache;
+var path3, import_node_url;
 var init_load = __esm({
   "src/loaders/config/load.ts"() {
     "use strict";
-    fs = __toESM(require("fs/promises"), 1);
-    path = __toESM(require("path"), 1);
+    path3 = __toESM(require("path"), 1);
     import_node_url = require("url");
     init_build();
-    cache = null;
+  }
+});
+
+// src/next/file-cache.ts
+function toFullPath(file) {
+  if (import_node_path3.default.isAbsolute(file)) {
+    return import_node_path3.default.relative(process.cwd(), file);
+  }
+  return file;
+}
+async function readFileWithCache(file) {
+  const fullPath = toFullPath(file);
+  const cached = map.get(fullPath);
+  if (cached) return cached;
+  const read = import_promises3.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_promises3, import_node_path3, map;
+var init_file_cache = __esm({
+  "src/next/file-cache.ts"() {
+    "use strict";
+    import_lru_cache = require("lru-cache");
+    import_promises3 = __toESM(require("fs/promises"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
+    map = new import_lru_cache.LRUCache({
+      max: 100
+    });
   }
 });
 
@@ -271,63 +358,32 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
   }
 });
 
-// src/next/map/file-cache.ts
-function toFullPath(file) {
-  if (import_node_path.default.isAbsolute(file)) {
-    return import_node_path.default.relative(process.cwd(), file);
-  }
-  return file;
-}
-async function readFileWithCache(file) {
-  const fullPath = toFullPath(file);
-  const cached = map.get(fullPath);
-  if (cached) return cached;
-  const read = import_promises.default.readFile(fullPath).then((s) => s.toString());
-  map.set(fullPath, read);
-  return read;
-}
-function removeFileCache(file) {
-  map.delete(toFullPath(file));
-}
-var import_lru_cache, import_promises, import_node_path, map;
-var init_file_cache = __esm({
-  "src/next/map/file-cache.ts"() {
-    "use strict";
-    import_lru_cache = require("lru-cache");
-    import_promises = __toESM(require("fs/promises"), 1);
-    import_node_path = __toESM(require("path"), 1);
-    map = new import_lru_cache.LRUCache({
-      max: 100
-    });
-  }
-});
-
 // src/utils/git-timestamp.ts
 async function getGitTimestamp(file) {
-  const cached = cache2.get(file);
+  const cached = cache.get(file);
   if (cached) return cached;
   try {
     const out = await (0, import_tinyexec.x)(
       "git",
-      ["log", "-1", '--pretty="%ai"', import_node_path2.default.relative(process.cwd(), file)],
+      ["log", "-1", '--pretty="%ai"', import_node_path4.default.relative(process.cwd(), file)],
       {
         throwOnError: true
       }
     );
     const time = new Date(out.stdout);
-    cache2.set(file, time);
+    cache.set(file, time);
     return time;
   } catch {
     return;
   }
 }
-var import_node_path2, import_tinyexec, cache2;
+var import_node_path4, import_tinyexec, cache;
 var init_git_timestamp = __esm({
   "src/utils/git-timestamp.ts"() {
     "use strict";
-    import_node_path2 = __toESM(require("path"), 1);
+    import_node_path4 = __toESM(require("path"), 1);
     import_tinyexec = require("tinyexec");
-    cache2 = /* @__PURE__ */ new Map();
+    cache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -368,7 +424,7 @@ function getImportCode(info) {
   return `import ${specifier}`;
 }
 function toImportPath(file, config) {
-  const ext = import_node_path3.default.extname(file);
+  const ext = import_node_path5.default.extname(file);
   let filename;
   if (ext === ".ts" && config.jsExtension) {
     filename = file.substring(0, file.length - ext.length) + ".js";
@@ -379,23 +435,23 @@ function toImportPath(file, config) {
   }
   let importPath;
   if ("relativeTo" in config) {
-    importPath = import_node_path3.default.relative(config.relativeTo, filename);
-    if (!import_node_path3.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
+    importPath = import_node_path5.default.relative(config.relativeTo, filename);
+    if (!import_node_path5.default.isAbsolute(importPath) && !importPath.startsWith(".")) {
       importPath = `./${importPath}`;
     }
   } else {
-    importPath = import_node_path3.default.resolve(filename);
+    importPath = import_node_path5.default.resolve(filename);
   }
-  return importPath.replaceAll(import_node_path3.default.sep, "/");
+  return importPath.replaceAll(import_node_path5.default.sep, "/");
 }
 function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
 }
-var import_node_path3;
+var import_node_path5;
 var init_import_formatter = __esm({
   "src/utils/import-formatter.ts"() {
     "use strict";
-    import_node_path3 = __toESM(require("path"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
   }
 });
 
@@ -422,8 +478,26 @@ var init_collections = __esm({
   }
 });
 
-// src/next/map/generate.ts
-async function generateJS(configPath, config, importPath, configHash = false) {
+// src/plugins/next.ts
+function next() {
+  let config;
+  return {
+    config(v) {
+      config = v;
+    },
+    async emit() {
+      return [
+        {
+          path: "index.ts",
+          content: await indexFile(this.configPath, config, {
+            relativeTo: this.outDir
+          })
+        }
+      ];
+    }
+  };
+}
+async function indexFile(configPath, config, importPath, configHash = false) {
   let asyncInit = false;
   const lines = [
     getImportCode({
@@ -525,18 +599,18 @@ async function generateJS(configPath, config, importPath, configHash = false) {
   }
   const declares = entries.map(async ([k, collection]) => {
     if (collection.type === "docs") {
-      const docs2 = await getCollectionFiles(collection.docs);
+      const docs = await getCollectionFiles(collection.docs);
       const metas = await getCollectionFiles(collection.meta);
       const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
         ", "
       );
       if (collection.docs.async) {
-        const docsEntries2 = (await getAsyncEntries(collection.docs, docs2)).join(
+        const docsEntries2 = (await getAsyncEntries(collection.docs, docs)).join(
           ", "
         );
         return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
-      const docsEntries = (await getDocEntries(k, docs2)).join(", ");
+      const docsEntries = (await getDocEntries(k, docs)).join(", ");
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
     const files = await getCollectionFiles(collection);
@@ -559,11 +633,11 @@ async function getCollectionFiles(collection) {
   await Promise.all(
     dirs.map(async (dir) => {
       const result = await (0, import_tinyglobby.glob)(patterns, {
-        cwd: path5.resolve(dir)
+        cwd: path7.resolve(dir)
       });
       for (const item of result) {
         if (!isFileSupported(item, collection)) continue;
-        const fullPath = path5.join(dir, item);
+        const fullPath = path7.join(dir, item);
         files.set(fullPath, {
           path: item,
           fullPath
@@ -574,22 +648,22 @@ async function getCollectionFiles(collection) {
   return Array.from(files.values());
 }
 function parseMetaEntry(file, content) {
-  const extname2 = path5.extname(file);
+  const extname4 = path7.extname(file);
   try {
-    if (extname2 === ".json") return JSON.parse(content);
-    if (extname2 === ".yaml") return (0, import_js_yaml2.load)(content);
+    if (extname4 === ".json") return JSON.parse(content);
+    if (extname4 === ".yaml") return (0, import_js_yaml2.load)(content);
   } catch (e) {
     throw new Error(`Failed to parse meta file: ${file}.`, {
       cause: e
     });
   }
-  throw new Error(`Unknown meta file format: ${extname2}, in ${file}.`);
+  throw new Error(`Unknown meta file format: ${extname4}, in ${file}.`);
 }
-var path5, import_node_crypto, import_tinyglobby, import_js_yaml2;
-var init_generate = __esm({
-  "src/next/map/generate.ts"() {
+var path7, import_node_crypto, import_tinyglobby, import_js_yaml2;
+var init_next = __esm({
+  "src/plugins/next.ts"() {
     "use strict";
-    path5 = __toESM(require("path"), 1);
+    path7 = __toESM(require("path"), 1);
     import_node_crypto = require("crypto");
     import_tinyglobby = require("tinyglobby");
     init_validation();
@@ -602,19 +676,7 @@ var init_generate = __esm({
   }
 });
 
-// src/loaders/config/index.ts
-function findConfigFile() {
-  return import_node_path4.default.resolve("source.config.ts");
-}
-var import_node_path4;
-var init_config = __esm({
-  "src/loaders/config/index.ts"() {
-    "use strict";
-    import_node_path4 = __toESM(require("path"), 1);
-  }
-});
-
-// src/next/map/watcher.ts
+// src/next/watcher.ts
 var watcher_exports = {};
 __export(watcher_exports, {
   watcher: () => watcher
@@ -638,97 +700,33 @@ function watcher(configPath, config, ignored) {
 }
 var import_chokidar;
 var init_watcher = __esm({
-  "src/next/map/watcher.ts"() {
+  "src/next/watcher.ts"() {
     "use strict";
     import_chokidar = require("chokidar");
   }
 });
 
-// src/next/map/index.ts
-async function start(dev, configPath, outDir) {
-  let configHash = await getConfigHash(configPath);
-  let config = await loadConfig(configPath, outDir, configHash, true);
-  const outPath = path7.resolve(outDir, `index.ts`);
-  async function updateMapFile() {
-    const start3 = performance.now();
-    try {
-      await fs3.writeFile(
-        outPath,
-        await generateJS(
-          configPath,
-          config,
-          { relativeTo: outDir },
-          configHash
-        )
-      );
-    } catch (err) {
-      if (err instanceof ValidationError) {
-        console.error(err.toStringFormatted());
-      } else {
-        console.error(err);
-      }
-    }
-    console.log(`[MDX] updated map file in ${performance.now() - start3}ms`);
-  }
-  await updateMapFile();
-  if (dev) {
-    const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
-    const instance = watcher2(configPath, config, [outPath]);
-    instance.on("ready", () => {
-      console.log("[MDX] started dev server");
-    });
-    instance.on("all", (event, file) => {
-      if (typeof file !== "string") return;
-      const absolutePath = path7.resolve(file);
-      const onUpdate = async () => {
-        const isConfigFile = absolutePath === configPath;
-        if (isConfigFile) {
-          configHash = await getConfigHash(configPath);
-          config = await loadConfig(configPath, outDir, configHash, true);
-        }
-        if (event === "change") removeFileCache(absolutePath);
-        await updateMapFile();
-      };
-      void onUpdate();
-    });
-    process.on("exit", () => {
-      console.log("[MDX] closing dev server");
-      void instance.close();
-    });
-  }
-}
-var path7, fs3;
-var init_map = __esm({
-  "src/next/map/index.ts"() {
-    "use strict";
-    path7 = __toESM(require("path"), 1);
-    fs3 = __toESM(require("fs/promises"), 1);
-    init_load();
-    init_generate();
-    init_file_cache();
-    init_validation();
-  }
+// src/next/index.ts
+var next_exports = {};
+__export(next_exports, {
+  createMDX: () => createMDX,
+  postInstall: () => postInstall
 });
-
-// src/next/create.ts
-function createMDX({
-  configPath = findConfigFile(),
-  outDir = ".source"
-} = {}) {
+function createMDX(createOptions = {}) {
+  const options = applyDefaults(createOptions);
+  const isDev = process.env.NODE_ENV === "development";
   if (process.env._FUMADOCS_MDX !== "1") {
     process.env._FUMADOCS_MDX = "1";
-    void start(process.env.NODE_ENV === "development", configPath, outDir);
+    void init(isDev, options);
   }
   return (nextConfig = {}) => {
     const mdxLoaderOptions = {
-      configPath,
-      outDir
+      ...options,
+      isDev
     };
-    const turbo = {
-      ...nextConfig.experimental?.turbo,
+    const turbopack = {
       ...nextConfig.turbopack,
       rules: {
-        ...nextConfig.experimental?.turbo?.rules,
         ...nextConfig.turbopack?.rules,
         "*.{md,mdx}": {
           loaders: [
@@ -741,17 +739,18 @@ function createMDX({
         }
       }
     };
-    const updated = {
+    return {
       ...nextConfig,
+      turbopack,
       pageExtensions: nextConfig.pageExtensions ?? defaultPageExtensions,
-      webpack: (config, options) => {
+      webpack: (config, options2) => {
         config.resolve ||= {};
         config.module ||= {};
         config.module.rules ||= [];
         config.module.rules.push({
           test: /\.mdx?$/,
           use: [
-            options.defaultLoaders.babel,
+            options2.defaultLoaders.babel,
             {
               loader: "fumadocs-mdx/loader-mdx",
               options: mdxLoaderOptions
@@ -759,150 +758,753 @@ function createMDX({
           ]
         });
         config.plugins ||= [];
-        return nextConfig.webpack?.(config, options) ?? config;
+        return nextConfig.webpack?.(config, options2) ?? config;
       }
     };
-    if (isTurboExperimental) {
-      updated.experimental = { ...updated.experimental, turbo };
-    } else {
-      updated.turbopack = turbo;
-    }
-    return updated;
   };
 }
-var import_node_fs, defaultPageExtensions, isTurboExperimental;
-var init_create = __esm({
-  "src/next/create.ts"() {
-    "use strict";
-    init_config();
-    init_map();
-    import_node_fs = require("fs");
-    defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
+async function init(dev, options) {
+  const pluginHandler = createNextPluginHandler(options);
+  let config;
+  async function updateConfig() {
+    config = await pluginHandler.init(
+      await loadConfig(options.configPath, options.outDir, true)
+    );
+  }
+  async function emitFiles() {
+    const start2 = performance.now();
     try {
-      const content = (0, import_node_fs.readFileSync)("./node_modules/next/package.json").toString();
-      const version = JSON.parse(content).version;
-      isTurboExperimental = version.startsWith("15.0.") || version.startsWith("15.1.") || version.startsWith("15.2.");
-    } catch {
-      isTurboExperimental = false;
+      await pluginHandler.emitAndWrite();
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        console.error(err.toStringFormatted());
+      } else {
+        console.error(err);
+      }
     }
+    console.log(`[MDX] updated map file in ${performance.now() - start2}ms`);
   }
-});
-
-// src/next/index.ts
-var next_exports = {};
-__export(next_exports, {
-  createMDX: () => createMDX,
-  postInstall: () => postInstall,
-  start: () => start
-});
+  async function devServer() {
+    const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
+    const instance = watcher2(options.configPath, config, [options.outDir]);
+    async function onUpdate(event, file) {
+      const absolutePath = path8.resolve(file);
+      if (event === "change") removeFileCache(absolutePath);
+      if (absolutePath === path8.resolve(options.configPath)) {
+        await updateConfig();
+        console.log("[MDX] restarting dev server");
+        await instance.close();
+        void devServer();
+      }
+      await emitFiles();
+    }
+    instance.on("ready", () => {
+      console.log("[MDX] started dev server");
+    });
+    instance.on("all", (event, file) => {
+      void onUpdate(event, file);
+    });
+    process.on("exit", () => {
+      console.log("[MDX] closing dev server");
+      void instance.close();
+    });
+  }
+  await updateConfig();
+  await emitFiles();
+  if (dev) void devServer();
+}
 async function postInstall(configPath = findConfigFile(), outDir = ".source") {
-  const config = await loadConfig(configPath, outDir, void 0, true);
-  const outPath = import_node_path5.default.join(outDir, "index.ts");
-  await import_promises2.default.rm(outDir, { recursive: true });
-  await import_promises2.default.mkdir(outDir, { recursive: true });
-  const hash = await getConfigHash(configPath);
-  await import_promises2.default.writeFile(
-    outPath,
-    await generateJS(configPath, config, { relativeTo: outDir }, hash)
-  );
+  const pluginHandler = createNextPluginHandler({
+    outDir,
+    configPath
+  });
+  await pluginHandler.init(await loadConfig(configPath, outDir, true));
+  await pluginHandler.emitAndWrite();
   console.log("[MDX] types generated");
 }
-var import_node_path5, import_promises2;
-var init_next = __esm({
+function applyDefaults(options) {
+  return {
+    outDir: options.outDir ?? ".source",
+    configPath: options.configPath ?? findConfigFile()
+  };
+}
+function createNextPluginHandler({
+  outDir,
+  configPath
+}) {
+  return createPluginHandler(
+    {
+      environment: "next",
+      outDir,
+      configPath
+    },
+    [next()]
+  );
+}
+var path8, defaultPageExtensions;
+var init_next2 = __esm({
   "src/next/index.ts"() {
     "use strict";
-    init_load();
-    import_node_path5 = __toESM(require("path"), 1);
-    import_promises2 = __toESM(require("fs/promises"), 1);
-    init_generate();
     init_config();
-    init_create();
+    init_plugins();
+    path8 = __toESM(require("path"), 1);
+    init_load();
+    init_file_cache();
+    init_validation();
+    init_next();
+    defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
   }
 });
 
-// src/vite/generate-glob.ts
-function generateGlob(name, patterns, globOptions) {
-  const options = {
-    ...globOptions,
-    query: {
-      ...globOptions?.query,
-      collection: name
-    }
+// 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;
+        }
+      }
+    });
   };
-  return `import.meta.glob(${JSON.stringify(mapGlobPatterns(patterns))}, ${JSON.stringify(options, null, 2)})`;
 }
-function mapGlobPatterns(patterns) {
-  return patterns.map(enforceRelative);
+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/remark-include.ts
+function isElementLike(node) {
+  return ElementLikeTypes.includes(node.type);
 }
-function enforceRelative(file) {
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
+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 getGlobBase(collection) {
-  let dir = collection.dir;
-  if (Array.isArray(dir)) {
-    if (dir.length !== 1)
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+function parseSpecifier(specifier) {
+  const idx = specifier.lastIndexOf("#");
+  if (idx === -1) return { file: specifier };
+  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 fs4.readFile(file)).toString();
+    } catch (e) {
       throw new Error(
-        `[Fumadocs MDX] Vite Plugin doesn't support multiple \`dir\` for a collection at the moment.`
+        `failed to read file ${file}
+${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
       );
-    dir = dir[0];
+    }
+    const ext = path9.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, path9.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 = path9.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 enforceRelative(dir);
+  return async (tree, file) => {
+    await update(tree, path9.dirname(file.path), file.data);
+  };
 }
-var init_generate_glob = __esm({
-  "src/vite/generate-glob.ts"() {
+var import_unified, import_unist_util_visit2, path9, fs4, 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");
+    path9 = __toESM(require("path"), 1);
+    fs4 = __toESM(require("fs/promises"), 1);
+    init_fuma_matter();
+    import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+    init_remark_unravel();
+    ElementLikeTypes = [
+      "mdxJsxFlowElement",
+      "mdxJsxTextElement",
+      "containerDirective",
+      "textDirective",
+      "leafDirective"
+    ];
   }
 });
 
-// src/vite/generate.ts
-function docs(name, collection) {
-  const obj = [
-    ident(`doc: ${doc(name, collection.docs)}`),
-    ident(`meta: ${meta(name, collection.meta)}`)
-  ].join(",\n");
-  return `{
-${obj}
-}`;
+// src/loaders/mdx/remark-postprocess.ts
+function remarkPostprocess({
+  _format,
+  includeProcessedMarkdown = false,
+  includeMDAST = false,
+  valueToExport = []
+}) {
+  let _stringifyProcessor;
+  const getStringifyProcessor = () => {
+    if (_format === "mdx") return this;
+    return _stringifyProcessor ??= this().use(import_remark_mdx.default).freeze();
+  };
+  return (tree, file) => {
+    let title;
+    const urls = [];
+    (0, import_unist_util_visit3.visit)(tree, ["heading", "link"], (node) => {
+      if (node.type === "heading" && node.depth === 1) {
+        title = flattenNode2(node);
+      }
+      if (node.type !== "link") return;
+      urls.push({
+        href: node.url
+      });
+      return "skip";
+    });
+    if (title) {
+      file.data.frontmatter ??= {};
+      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
+    }
+    file.data.extractedReferences = urls;
+    if (includeProcessedMarkdown) {
+      const processor = getStringifyProcessor();
+      file.data._markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
+        ...processor.data("settings"),
+        // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
+        extensions: processor.data("toMarkdownExtensions") || []
+      });
+    }
+    if (includeMDAST) {
+      const options = includeMDAST === true ? {} : includeMDAST;
+      file.data._mdast = JSON.stringify(
+        options.removePosition ? (0, import_unist_util_remove_position.removePosition)(structuredClone(tree)) : tree
+      );
+    }
+    for (const { name, value } of file.data["mdx-export"] ?? []) {
+      tree.children.unshift(getMdastExport(name, value));
+    }
+    for (const name of valueToExport) {
+      if (!(name in file.data)) continue;
+      tree.children.unshift(getMdastExport(name, file.data[name]));
+    }
+  };
 }
-function doc(name, collection) {
-  const patterns = getGlobPatterns(collection);
-  const base = getGlobBase(collection);
-  const docGlob = generateGlob(name, patterns, {
-    base
+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)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+function flattenNode2(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode2(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+var import_unist_util_visit3, import_mdast_util_to_markdown, import_estree_util_value_to_estree, import_unist_util_remove_position, import_remark_mdx;
+var init_remark_postprocess = __esm({
+  "src/loaders/mdx/remark-postprocess.ts"() {
+    "use strict";
+    import_unist_util_visit3 = require("unist-util-visit");
+    import_mdast_util_to_markdown = require("mdast-util-to-markdown");
+    import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+    import_unist_util_remove_position = require("unist-util-remove-position");
+    import_remark_mdx = __toESM(require("remark-mdx"), 1);
+  }
+});
+
+// src/loaders/mdx/build-mdx.ts
+async function buildMDX(cacheKey, source, options) {
+  const { filePath, frontmatter, data, _compiler, ...rest } = options;
+  function getProcessor(format) {
+    const key = `${cacheKey}:${format}`;
+    let processor = cache2.get(key);
+    if (!processor) {
+      processor = (0, import_mdx.createProcessor)({
+        outputFormat: "program",
+        ...rest,
+        remarkPlugins: [
+          remarkInclude,
+          ...rest.remarkPlugins ?? [],
+          [
+            remarkPostprocess,
+            {
+              _format: format,
+              ...options.postprocess,
+              valueToExport: [
+                ...options.postprocess?.valueToExport ?? [],
+                "structuredData",
+                "extractedReferences",
+                "frontmatter",
+                "lastModified",
+                "_markdown",
+                "_mdast"
+              ]
+            }
+          ]
+        ],
+        format
+      });
+      cache2.set(key, processor);
+    }
+    return processor;
+  }
+  return getProcessor(
+    options.format ?? (filePath.endsWith(".mdx") ? "mdx" : "md")
+  ).process({
+    value: source,
+    path: filePath,
+    data: {
+      ...data,
+      frontmatter,
+      _compiler,
+      _getProcessor: getProcessor
+    }
   });
-  if (collection.async) {
-    const headBlob = generateGlob(name, patterns, {
-      query: {
-        only: "frontmatter"
-      },
-      import: "frontmatter",
-      base
+}
+var import_mdx, cache2;
+var init_build_mdx = __esm({
+  "src/loaders/mdx/build-mdx.ts"() {
+    "use strict";
+    import_mdx = require("@mdx-js/mdx");
+    init_remark_include();
+    init_remark_postprocess();
+    cache2 = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/loaders/mdx/index.ts
+function getConfigHash(config) {
+  let hash = hashes.get(config);
+  if (hash) return hash;
+  hash = Date.now().toString();
+  hashes.set(config, hash);
+  return hash;
+}
+function createMdxLoader(configLoader) {
+  return async ({
+    source: value,
+    development: isDevelopment,
+    query,
+    compiler,
+    filePath
+  }) => {
+    const matter = fumaMatter(value);
+    const parsed = querySchema.parse(query);
+    const loaded = await configLoader.getConfig();
+    const cacheDir = isDevelopment ? void 0 : loaded.global.experimentalBuildCache;
+    const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
+    if (cacheDir) {
+      const cached = await import_promises4.default.readFile(import_node_path6.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      if (cached && cached.hash === generateCacheHash(value)) return cached;
+    }
+    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+    let docCollection;
+    switch (collection?.type) {
+      case "doc":
+        docCollection = collection;
+        break;
+      case "docs":
+        docCollection = collection.docs;
+        break;
+    }
+    if (docCollection?.schema) {
+      matter.data = await validate(
+        docCollection.schema,
+        matter.data,
+        {
+          source: value,
+          path: filePath
+        },
+        `invalid frontmatter in ${filePath}`
+      );
+    }
+    if (parsed.only === "frontmatter") {
+      return {
+        code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
+        map: null
+      };
+    }
+    const data = {};
+    if (loaded.global.lastModifiedTime === "git") {
+      data.lastModified = (await getGitTimestamp(filePath))?.getTime();
+    }
+    const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
+    const compiled = await buildMDX(
+      `${getConfigHash(loaded)}:${parsed.collection ?? "global"}`,
+      "\n".repeat(lineOffset) + matter.content,
+      {
+        development: isDevelopment,
+        ...docCollection?.mdxOptions ?? await loaded.getDefaultMDXOptions(),
+        postprocess: docCollection?.postprocess,
+        data,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler
+      }
+    );
+    const out = {
+      code: String(compiled.value),
+      map: compiled.map
+    };
+    if (cacheDir) {
+      await import_promises4.default.mkdir(cacheDir, { recursive: true });
+      await import_promises4.default.writeFile(
+        import_node_path6.default.join(cacheDir, cacheKey),
+        JSON.stringify({
+          ...out,
+          hash: generateCacheHash(value)
+        })
+      );
+    }
+    return out;
+  };
+}
+function generateCacheHash(input) {
+  return (0, import_node_crypto2.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_promises4, import_node_path6, import_node_crypto2, querySchema, cacheEntry, hashes;
+var init_mdx = __esm({
+  "src/loaders/mdx/index.ts"() {
+    "use strict";
+    init_fuma_matter();
+    init_validation();
+    init_git_timestamp();
+    init_build_mdx();
+    import_zod = require("zod");
+    import_promises4 = __toESM(require("fs/promises"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
+    import_node_crypto2 = require("crypto");
+    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()
     });
-    return `create.docLazy("${name}", "${base}", ${headBlob}, ${docGlob})`;
+    hashes = /* @__PURE__ */ new WeakMap();
   }
-  return `create.doc("${name}", "${base}", ${docGlob})`;
+});
+
+// src/loaders/adapter.ts
+function toVite(loader) {
+  return async function(file, query, value) {
+    const result = await loader({
+      filePath: file,
+      query: (0, import_node_querystring.parse)(query),
+      source: value,
+      development: this.environment.mode === "dev",
+      compiler: {
+        addDependency: (file2) => {
+          this.addWatchFile(file2);
+        }
+      }
+    });
+    return {
+      code: result.code,
+      map: result.map
+    };
+  };
 }
-function meta(name, collection) {
-  const patterns = getGlobPatterns(collection);
-  const base = getGlobBase(collection);
-  return `create.meta("${name}", "${base}", ${generateGlob(name, patterns, {
-    import: "default",
-    base
-  })})`;
+var import_node_url2, import_promises5, import_node_querystring, import_node_path7;
+var init_adapter = __esm({
+  "src/loaders/adapter.ts"() {
+    "use strict";
+    import_node_url2 = require("url");
+    import_promises5 = __toESM(require("fs/promises"), 1);
+    import_node_querystring = require("querystring");
+    init_validation();
+    import_node_path7 = __toESM(require("path"), 1);
+  }
+});
+
+// src/utils/glob-import.ts
+function generateGlobImport(patterns, options) {
+  let code = "{";
+  const result = (0, import_tinyglobby2.globSync)(patterns, {
+    cwd: options.base
+  });
+  for (const item of result) {
+    const fullPath = import_node_path8.default.join(options.base, item);
+    const url = (0, import_node_url3.pathToFileURL)(fullPath);
+    for (const [k, v] of Object.entries(options.query ?? {})) {
+      url.searchParams.set(k, v);
+    }
+    let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(url.href)})`;
+    if (options.import) {
+      line += `.then(mod => mod[${JSON.stringify(options.import)}])`;
+    }
+    code += `${line}, `;
+  }
+  code += "}";
+  return code;
+}
+var import_tinyglobby2, import_node_path8, import_node_url3;
+var init_glob_import = __esm({
+  "src/utils/glob-import.ts"() {
+    "use strict";
+    import_tinyglobby2 = require("tinyglobby");
+    import_node_path8 = __toESM(require("path"), 1);
+    import_node_url3 = require("url");
+  }
+});
+
+// src/plugins/vite.ts
+function vite(options) {
+  let config;
+  return {
+    config(v) {
+      config = v;
+    },
+    emit() {
+      console.log("[Fumadocs MDX] Generating index files");
+      return [
+        {
+          path: "index.ts",
+          content: indexFile2(this.configPath, this.outDir, config, options)
+        }
+      ];
+    }
+  };
 }
-function entry(configPath, config, outDir, jsExtension) {
+function indexFile2(configPath, outDir, config, options) {
+  const { addJsExtension = false, runtime } = options;
   const lines = [
     '/// <reference types="vite/client" />',
     `import { fromConfig } from 'fumadocs-mdx/runtime/vite';`,
     `import type * as Config from '${toImportPath(configPath, {
       relativeTo: outDir,
-      jsExtension
+      jsExtension: addJsExtension
     })}';`,
     "",
     `export const create = fromConfig<typeof Config>();`
   ];
+  function docs(name, collection) {
+    const obj = [
+      ident(`doc: ${doc(name, collection.docs)}`),
+      ident(`meta: ${meta(name, collection.meta)}`)
+    ].join(",\n");
+    return `{
+${obj}
+}`;
+  }
+  function doc(name, collection) {
+    const patterns = getGlobPatterns(collection);
+    const base = getGlobBase(collection);
+    const docGlob = generateGlob(patterns, {
+      query: {
+        collection: name
+      },
+      base
+    });
+    if (collection.async) {
+      const headBlob = generateGlob(patterns, {
+        query: {
+          only: "frontmatter",
+          collection: name
+        },
+        import: "frontmatter",
+        base
+      });
+      return `create.docLazy("${name}", "${base}", ${headBlob}, ${docGlob})`;
+    }
+    return `create.doc("${name}", "${base}", ${docGlob})`;
+  }
+  function meta(name, collection) {
+    const patterns = getGlobPatterns(collection);
+    const base = getGlobBase(collection);
+    return `create.meta("${name}", "${base}", ${generateGlob(patterns, {
+      import: "default",
+      base,
+      query: {
+        collection: name
+      }
+    })})`;
+  }
+  function generateGlob(patterns, options2) {
+    patterns = mapGlobPatterns(patterns);
+    if (runtime === "node" || runtime === "bun") {
+      return generateGlobImport(patterns, options2);
+    } else {
+      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
+        {
+          ...options2,
+          base: import_node_path9.default.relative(outDir, options2.base)
+        },
+        null,
+        2
+      )})`;
+    }
+  }
   for (const [name, collection] of config.collections.entries()) {
     let body;
     if (collection.type === "docs") {
@@ -917,55 +1519,178 @@ function entry(configPath, config, outDir, jsExtension) {
   }
   return lines.join("\n");
 }
-var init_generate2 = __esm({
-  "src/vite/generate.ts"() {
+function mapGlobPatterns(patterns) {
+  return patterns.map(enforceRelative);
+}
+function enforceRelative(file) {
+  if (file.startsWith("./")) return file;
+  if (file.startsWith("/")) return `.${file}`;
+  return `./${file}`;
+}
+function getGlobBase(collection) {
+  let dir = collection.dir;
+  if (Array.isArray(dir)) {
+    if (dir.length !== 1)
+      throw new Error(
+        `[Fumadocs MDX] Vite Plugin doesn't support multiple \`dir\` for a collection at the moment.`
+      );
+    dir = dir[0];
+  }
+  return enforceRelative(dir);
+}
+var import_node_path9;
+var init_vite = __esm({
+  "src/plugins/vite.ts"() {
     "use strict";
     init_import_formatter();
-    init_generate_glob();
     init_collections();
+    init_glob_import();
+    import_node_path9 = __toESM(require("path"), 1);
   }
 });
 
-// src/vite/postinstall.ts
-var postinstall_exports = {};
-__export(postinstall_exports, {
+// src/vite/index.ts
+var vite_exports = {};
+__export(vite_exports, {
+  default: () => mdx,
   postInstall: () => postInstall2
 });
-async function postInstall2(configPath = findConfigFile(), outDir, addJsExtension = false) {
-  const config = await loadConfig(configPath, "node_modules", void 0, true);
-  const outFile = "source.generated.ts";
-  if (outDir) {
-    await import_promises3.default.mkdir(outDir, { recursive: true });
-  }
-  await import_promises3.default.writeFile(
-    outDir ? import_node_path6.default.join(outDir, outFile) : outFile,
-    entry(configPath, config, outDir ?? process.cwd(), addJsExtension)
-  );
+async function mdx(config, pluginOptions = {}) {
+  const options = applyDefaults2(pluginOptions);
+  const { updateViteConfig } = options;
+  const pluginHandler = createVitePluginHandler(options);
+  const loaded = await pluginHandler.init(buildConfig(config));
+  const mdxLoader = toVite(createMdxLoader(resolvedConfig(loaded)));
+  async function transformMeta(path15, query, value) {
+    const isJson = path15.endsWith(".json");
+    const parsed = (0, import_node_querystring2.parse)(query);
+    const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
+    if (!collection) return null;
+    let schema;
+    switch (collection.type) {
+      case "meta":
+        schema = collection.schema;
+        break;
+      case "docs":
+        schema = collection.meta.schema;
+        break;
+    }
+    if (!schema) return null;
+    let data;
+    try {
+      data = isJson ? JSON.parse(value) : (0, import_js_yaml3.load)(value);
+    } catch {
+      return null;
+    }
+    const out = await validate(
+      schema,
+      data,
+      { path: path15, source: value },
+      `invalid data in ${path15}`
+    );
+    return {
+      code: isJson ? JSON.stringify(out) : `export default ${JSON.stringify(out)}`,
+      map: null
+    };
+  }
+  return {
+    name: "fumadocs-mdx",
+    // needed, otherwise other plugins will be executed before our `transform`.
+    enforce: "pre",
+    config(config2) {
+      if (!updateViteConfig) return config2;
+      return (0, import_vite.mergeConfig)(config2, {
+        optimizeDeps: {
+          exclude: FumadocsDeps
+        },
+        resolve: {
+          noExternal: FumadocsDeps,
+          dedupe: FumadocsDeps
+        }
+      });
+    },
+    async buildStart() {
+      await pluginHandler.emitAndWrite();
+    },
+    async transform(value, id) {
+      const [file, query = ""] = id.split("?");
+      const ext = path14.extname(file);
+      try {
+        if ([".yaml", ".json"].includes(ext))
+          return await transformMeta(file, query, value);
+        if ([".md", ".mdx"].includes(ext))
+          return await mdxLoader.call(this, file, query, value);
+      } catch (e) {
+        if (e instanceof ValidationError) {
+          throw new Error(e.toStringFormatted());
+        }
+        throw e;
+      }
+    }
+  };
+}
+async function postInstall2(configPath = findConfigFile(), pluginOptions = {}) {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load(), load_exports));
+  const options = applyDefaults2(pluginOptions);
+  const pluginHandler = createVitePluginHandler(options);
+  await pluginHandler.init(await loadConfig2(configPath, options.outDir, true));
+  await pluginHandler.emitAndWrite();
   console.log("[MDX] types generated");
 }
-var import_promises3, import_node_path6;
-var init_postinstall = __esm({
-  "src/vite/postinstall.ts"() {
+function createVitePluginHandler({
+  configPath,
+  outDir,
+  generateIndexFile
+}) {
+  return createPluginHandler(
+    {
+      environment: "vite",
+      configPath,
+      outDir
+    },
+    [
+      generateIndexFile !== false && vite(typeof generateIndexFile === "object" ? generateIndexFile : {})
+    ]
+  );
+}
+function applyDefaults2(options) {
+  return {
+    updateViteConfig: options.updateViteConfig ?? true,
+    generateIndexFile: options.generateIndexFile ?? true,
+    configPath: options.configPath ?? "source.config.ts",
+    outDir: options.outDir ?? ".source"
+  };
+}
+var import_vite, import_node_querystring2, path14, import_js_yaml3, FumadocsDeps;
+var init_vite2 = __esm({
+  "src/vite/index.ts"() {
     "use strict";
-    init_load();
-    import_promises3 = __toESM(require("fs/promises"), 1);
-    import_node_path6 = __toESM(require("path"), 1);
-    init_generate2();
+    import_vite = require("vite");
+    init_build();
+    import_node_querystring2 = require("querystring");
+    init_validation();
+    path14 = __toESM(require("path"), 1);
+    import_js_yaml3 = require("js-yaml");
+    init_mdx();
     init_config();
+    init_adapter();
+    init_vite();
+    init_plugins();
+    FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
   }
 });
 
 // src/bin.ts
-var import_node_fs2 = require("fs");
-async function start2() {
-  const args = 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.ts");
+var import_node_fs = require("fs");
+async function start() {
+  const [configPath] = process.argv.slice(2);
+  const isNext = (0, import_node_fs.existsSync)("next.config.js") || (0, import_node_fs.existsSync)("next.config.mjs") || (0, import_node_fs.existsSync)("next.config.ts");
   if (isNext) {
-    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_next(), next_exports));
-    await postInstall3(...args);
+    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_next2(), next_exports));
+    await postInstall3(configPath);
   } else {
-    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_postinstall(), postinstall_exports));
-    await postInstall3(...args);
+    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
+    await postInstall3(configPath);
   }
 }
-void start2();
+void start();