fumadocs-mdx 12.0.3 → 13.0.0

package/dist/node/loader.cjs

@@ -175,7 +175,6 @@ var init_build = __esm({
 // src/loaders/config/load.ts
 var load_exports = {};
 __export(load_exports, {
-  getConfigHash: () => getConfigHash,
   loadConfig: () => loadConfig
 });
 async function compileConfig(configPath, outDir) {
@@ -198,37 +197,22 @@ 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 };
+  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 path, 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);
     import_node_url = require("url");
     init_build();
-    cache = null;
   }
 });
 
@@ -241,18 +225,23 @@ module.exports = __toCommonJS(loader_exports);
 
 // src/loaders/config/index.ts
 var import_node_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
 function findConfigFile() {
   return import_node_path.default.resolve("source.config.ts");
 }
-function dynamicConfig(configPath, outDir) {
+function staticConfig({
+  outDir,
+  configPath,
+  buildConfig: buildConfig2
+}) {
+  let cached;
   return {
-    async getConfig(hash) {
-      const { loadConfig: loadConfig2, getConfigHash: getConfigHash2 } = await Promise.resolve().then(() => (init_load(), load_exports));
-      return loadConfig2(
-        configPath,
-        outDir,
-        hash ?? await getConfigHash2(configPath)
+    async getConfig() {
+      if (cached) return cached;
+      cached = Promise.resolve().then(() => (init_load(), load_exports)).then(
+        (mod) => mod.loadConfig(configPath, outDir, buildConfig2)
       );
+      return cached;
     }
   };
 }
@@ -314,9 +303,9 @@ async function validate(schema, data, context, errorMessage) {
 // src/utils/git-timestamp.ts
 var import_node_path2 = __toESM(require("path"), 1);
 var import_tinyexec = require("tinyexec");
-var cache2 = /* @__PURE__ */ new Map();
+var cache = /* @__PURE__ */ new Map();
 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)(
@@ -327,7 +316,7 @@ async function getGitTimestamp(file) {
       }
     );
     const time = new Date(out.stdout);
-    cache2.set(file, time);
+    cache.set(file, time);
     return time;
   } catch {
     return;
@@ -339,12 +328,56 @@ var import_mdx = require("@mdx-js/mdx");
 
 // src/loaders/mdx/remark-include.ts
 var import_unified = require("unified");
-var import_unist_util_visit = require("unist-util-visit");
+var import_unist_util_visit2 = require("unist-util-visit");
 var path4 = __toESM(require("path"), 1);
 var fs2 = __toESM(require("fs/promises"), 1);
-var import_remark_parse = __toESM(require("remark-parse"), 1);
-var import_remark_mdx = __toESM(require("remark-mdx"), 1);
 var import_mdx_plugins = require("fumadocs-core/mdx-plugins");
+
+// src/loaders/mdx/remark-unravel.ts
+var import_unist_util_visit = require("unist-util-visit");
+function remarkMarkAndUnravel() {
+  return (tree) => {
+    (0, import_unist_util_visit.visit)(tree, function(node, index, parent) {
+      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;
+        }
+      }
+    });
+  };
+}
+
+// src/loaders/mdx/remark-include.ts
 var ElementLikeTypes = [
   "mdxJsxFlowElement",
   "mdxJsxTextElement",
@@ -384,7 +417,7 @@ function parseSpecifier(specifier) {
 function extractSection(root, section) {
   let nodes;
   let capturingHeadingContent = false;
-  (0, import_unist_util_visit.visit)(root, (node) => {
+  (0, import_unist_util_visit2.visit)(root, (node) => {
     if (node.type === "heading") {
       if (capturingHeadingContent) {
         return false;
@@ -416,7 +449,7 @@ function extractSection(root, section) {
 }
 function remarkInclude() {
   const TagName = "include";
-  async function embedContent(file, heading, params, data) {
+  const embedContent = async (file, heading, params, data) => {
     let content;
     try {
       content = (await fs2.readFile(file)).toString();
@@ -439,18 +472,17 @@ ${e instanceof Error ? e.message : String(e)}`,
         data: {}
       };
     }
-    const parser = (data._getProcessor ?? getDefaultProcessor)(
-      ext === ".mdx" ? "mdx" : "md"
-    );
+    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 (0, import_unified.unified)().use(import_mdx_plugins.remarkHeading).run(mdast),
+        await baseProcessor.use(import_mdx_plugins.remarkHeading).run(mdast),
         heading
       );
       if (!extracted)
@@ -458,13 +490,15 @@ ${e instanceof Error ? e.message : String(e)}`,
           `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, path4.dirname(file), data);
     return mdast;
-  }
+  };
   async function update(tree, directory, data) {
     const queue = [];
-    (0, import_unist_util_visit.visit)(tree, ElementLikeTypes, (_node, _, parent) => {
+    (0, import_unist_util_visit2.visit)(tree, ElementLikeTypes, (_node, _, parent) => {
       const node = _node;
       if (node.name !== TagName) return;
       const specifier = flattenNode(node);
@@ -491,24 +525,28 @@ ${e instanceof Error ? e.message : String(e)}`,
     await update(tree, path4.dirname(file.path), file.data);
   };
 }
-function getDefaultProcessor(format) {
-  const mdProcessor = (0, import_unified.unified)().use(import_remark_parse.default);
-  if (format === "md") return mdProcessor;
-  return mdProcessor.use(import_remark_mdx.default);
-}
 
 // src/loaders/mdx/remark-postprocess.ts
-var import_unist_util_visit2 = require("unist-util-visit");
+var import_unist_util_visit3 = require("unist-util-visit");
 var import_mdast_util_to_markdown = require("mdast-util-to-markdown");
 var import_estree_util_value_to_estree = require("estree-util-value-to-estree");
+var import_unist_util_remove_position = require("unist-util-remove-position");
+var import_remark_mdx = __toESM(require("remark-mdx"), 1);
 function remarkPostprocess({
+  _format,
   includeProcessedMarkdown = false,
+  includeMDAST = false,
   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_visit2.visit)(tree, ["heading", "link"], (node) => {
+    (0, import_unist_util_visit3.visit)(tree, ["heading", "link"], (node) => {
       if (node.type === "heading" && node.depth === 1) {
         title = flattenNode2(node);
       }
@@ -524,12 +562,19 @@ function remarkPostprocess({
     }
     file.data.extractedReferences = urls;
     if (includeProcessedMarkdown) {
+      const processor = getStringifyProcessor();
       file.data._markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
-        ...this.data("settings"),
+        ...processor.data("settings"),
         // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
-        extensions: this.data("toMarkdownExtensions") || []
+        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));
     }
@@ -581,12 +626,12 @@ function flattenNode2(node) {
 }
 
 // src/loaders/mdx/build-mdx.ts
-var cache3 = /* @__PURE__ */ new Map();
+var cache2 = /* @__PURE__ */ new Map();
 async function buildMDX(cacheKey, source, options) {
   const { filePath, frontmatter, data, _compiler, ...rest } = options;
   function getProcessor(format) {
     const key = `${cacheKey}:${format}`;
-    let processor = cache3.get(key);
+    let processor = cache2.get(key);
     if (!processor) {
       processor = (0, import_mdx.createProcessor)({
         outputFormat: "program",
@@ -597,6 +642,7 @@ async function buildMDX(cacheKey, source, options) {
           [
             remarkPostprocess,
             {
+              _format: format,
               ...options.postprocess,
               valueToExport: [
                 ...options.postprocess?.valueToExport ?? [],
@@ -604,14 +650,15 @@ async function buildMDX(cacheKey, source, options) {
                 "extractedReferences",
                 "frontmatter",
                 "lastModified",
-                "_markdown"
+                "_markdown",
+                "_mdast"
               ]
             }
           ]
         ],
         format
       });
-      cache3.set(key, processor);
+      cache2.set(key, processor);
     }
     return processor;
   }
@@ -631,21 +678,26 @@ async function buildMDX(cacheKey, source, options) {
 
 // src/loaders/mdx/index.ts
 var import_zod = require("zod");
-var import_promises = __toESM(require("fs/promises"), 1);
+var import_promises2 = __toESM(require("fs/promises"), 1);
 var import_node_path3 = __toESM(require("path"), 1);
 var import_node_crypto = require("crypto");
 var querySchema = import_zod.z.object({
   only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
-  collection: import_zod.z.string().optional(),
-  hash: import_zod.z.string().describe(
-    "the hash of config, used for revalidation on Turbopack/Webpack."
-  ).optional()
+  collection: import_zod.z.string().optional()
 }).loose();
 var cacheEntry = import_zod.z.object({
   code: import_zod.z.string(),
   map: import_zod.z.any().optional(),
   hash: import_zod.z.string().optional()
 });
+var hashes = /* @__PURE__ */ new WeakMap();
+function getConfigHash(config) {
+  let hash = hashes.get(config);
+  if (hash) return hash;
+  hash = Date.now().toString();
+  hashes.set(config, hash);
+  return hash;
+}
 function createMdxLoader(configLoader) {
   return async ({
     source: value,
@@ -656,11 +708,11 @@ function createMdxLoader(configLoader) {
   }) => {
     const matter = fumaMatter(value);
     const parsed = querySchema.parse(query);
-    const loaded = await configLoader.getConfig(parsed.hash);
+    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_promises.default.readFile(import_node_path3.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+      const cached = await import_promises2.default.readFile(import_node_path3.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
       if (cached && cached.hash === generateCacheHash(value)) return cached;
     }
     const collection = parsed.collection ? loaded.collections.get(parsed.collection) : void 0;
@@ -696,7 +748,7 @@ function createMdxLoader(configLoader) {
     }
     const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
     const compiled = await buildMDX(
-      `${parsed.hash ?? ""}:${parsed.collection ?? "global"}`,
+      `${getConfigHash(loaded)}:${parsed.collection ?? "global"}`,
       "\n".repeat(lineOffset) + matter.content,
       {
         development: isDevelopment,
@@ -713,8 +765,8 @@ function createMdxLoader(configLoader) {
       map: compiled.map
     };
     if (cacheDir) {
-      await import_promises.default.mkdir(cacheDir, { recursive: true });
-      await import_promises.default.writeFile(
+      await import_promises2.default.mkdir(cacheDir, { recursive: true });
+      await import_promises2.default.writeFile(
         import_node_path3.default.join(cacheDir, cacheKey),
         JSON.stringify({
           ...out,
@@ -738,7 +790,7 @@ function countLines(s) {
 
 // src/loaders/adapter.ts
 var import_node_url2 = require("url");
-var import_promises2 = __toESM(require("fs/promises"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_querystring = require("querystring");
 var import_node_path4 = __toESM(require("path"), 1);
 function toNode(loader, filterByPath) {
@@ -747,7 +799,7 @@ function toNode(loader, filterByPath) {
     const parsedUrl = new URL(url);
     const filePath = (0, import_node_url2.fileURLToPath)(parsedUrl);
     if (filterByPath(filePath)) {
-      const source = (await import_promises2.default.readFile(filePath)).toString();
+      const source = (await import_promises3.default.readFile(filePath)).toString();
       const result = await loader({
         filePath,
         query: Object.fromEntries(parsedUrl.searchParams.entries()),
@@ -770,7 +822,13 @@ function toNode(loader, filterByPath) {
 
 // src/node/loader.ts
 var load2 = toNode(
-  createMdxLoader(dynamicConfig(findConfigFile(), ".source")),
+  createMdxLoader(
+    staticConfig({
+      configPath: findConfigFile(),
+      outDir: ".source",
+      buildConfig: true
+    })
+  ),
   (filePath) => filePath.endsWith(".md") || filePath.endsWith(".mdx")
 );
 // Annotate the CommonJS export names for ESM import in node:

package/dist/node/loader.js

@@ -1,21 +1,26 @@
 import {
   toNode
-} from "../chunk-VXEBLM4X.js";
+} from "../chunk-XV5Z4BFL.js";
 import {
   createMdxLoader
-} from "../chunk-RMDXSZYE.js";
-import "../chunk-QAUWMR5D.js";
-import "../chunk-LMG6UWCL.js";
-import "../chunk-IQAEAI4P.js";
+} from "../chunk-CEA6MYJU.js";
+import "../chunk-3J3WL7WN.js";
+import "../chunk-K5ZLPEIQ.js";
 import {
-  dynamicConfig,
-  findConfigFile
-} from "../chunk-XMFLD5J6.js";
+  findConfigFile,
+  staticConfig
+} from "../chunk-HI62EXSB.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/node/loader.ts
 var load = toNode(
-  createMdxLoader(dynamicConfig(findConfigFile(), ".source")),
+  createMdxLoader(
+    staticConfig({
+      configPath: findConfigFile(),
+      outDir: ".source",
+      buildConfig: true
+    })
+  ),
   (filePath) => filePath.endsWith(".md") || filePath.endsWith(".mdx")
 );
 export {

package/dist/plugins/index.cjs

@@ -0,0 +1,78 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/index.ts
+var plugins_exports = {};
+__export(plugins_exports, {
+  createPluginHandler: () => createPluginHandler
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_node_path = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+function createPluginHandler(context, defaultPlugins = []) {
+  const plugins = [];
+  async function write(entry) {
+    const file = import_node_path.default.join(context.outDir, entry.path);
+    await import_promises.default.mkdir(import_node_path.default.dirname(file), { recursive: true });
+    await import_promises.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)) plugins.push(...option);
+        else plugins.push(option);
+      }
+      for (const plugin of plugins) {
+        const out = await plugin.config?.call(context, config);
+        if (out) config = out;
+      }
+      return config;
+    },
+    async emit() {
+      const out = await Promise.all(
+        plugins.map((plugin) => {
+          return plugin.emit?.call(context) ?? [];
+        })
+      );
+      return out.flat();
+    },
+    async emitAndWrite() {
+      const entries = await this.emit();
+      await Promise.all(entries.map(write));
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPluginHandler
+});

package/dist/plugins/index.d.cts

@@ -0,0 +1,7 @@
+export { E as EmitEntry, P as Plugin, h as PluginContext, i as PluginOption, j as createPluginHandler } from '../define-BCNh3n4O.cjs';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import '../remark-postprocess-K233ZVBK.cjs';

package/dist/plugins/index.d.ts

@@ -0,0 +1,7 @@
+export { E as EmitEntry, P as Plugin, h as PluginContext, i as PluginOption, j as createPluginHandler } from '../define-bck_EB4t.js';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import '../remark-postprocess-K233ZVBK.js';

package/dist/plugins/index.js

@@ -0,0 +1,6 @@
+import {
+  createPluginHandler
+} from "../chunk-4MAYA5QX.js";
+export {
+  createPluginHandler
+};

package/dist/plugins/json-schema.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/json-schema.ts
+var json_schema_exports = {};
+__export(json_schema_exports, {
+  default: () => jsonSchema
+});
+module.exports = __toCommonJS(json_schema_exports);
+var import_zod = require("zod");
+function jsonSchema() {
+  let config;
+  return {
+    config(v) {
+      config = v;
+    },
+    emit() {
+      const files = [];
+      function onSchema(name, schema) {
+        files.push({
+          path: `json-schema/${name}.json`,
+          content: JSON.stringify(
+            import_zod.z.toJSONSchema(schema, {
+              io: "input",
+              unrepresentable: "any"
+            })
+          )
+        });
+      }
+      for (const [name, collection] of config.collections) {
+        if (collection.type === "docs") {
+          if (collection.meta.schema instanceof import_zod.z.ZodType) {
+            onSchema(`${name}.meta`, collection.meta.schema);
+          }
+          if (collection.docs.schema instanceof import_zod.z.ZodType) {
+            onSchema(`${name}.docs`, collection.docs.schema);
+          }
+        } else if (collection.schema instanceof import_zod.z.ZodType) {
+          onSchema(name, collection.schema);
+        }
+      }
+      return files;
+    }
+  };
+}

package/dist/plugins/json-schema.d.cts

@@ -0,0 +1,16 @@
+import { P as Plugin } from '../define-BCNh3n4O.cjs';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import '../remark-postprocess-K233ZVBK.cjs';
+
+/**
+ * Generate JSON schemas locally for collection schemas
+ *
+ * note: **it only works with Zod**
+ */
+declare function jsonSchema(): Plugin;
+
+export { jsonSchema as default };

package/dist/plugins/json-schema.d.ts

@@ -0,0 +1,16 @@
+import { P as Plugin } from '../define-bck_EB4t.js';
+import '@standard-schema/spec';
+import 'fumadocs-core/mdx-plugins';
+import '@mdx-js/mdx';
+import 'unified';
+import 'zod';
+import '../remark-postprocess-K233ZVBK.js';
+
+/**
+ * Generate JSON schemas locally for collection schemas
+ *
+ * note: **it only works with Zod**
+ */
+declare function jsonSchema(): Plugin;
+
+export { jsonSchema as default };