fumadocs-mdx 14.2.2 → 14.2.4

package/dist/chunk-WFDF56IJ.js

@@ -1,290 +0,0 @@
-import {
-  fumaMatter
-} from "./chunk-VWJKRQZR.js";
-
-// src/loaders/mdx/remark-include.ts
-import { unified } from "unified";
-import { visit as visit2 } from "unist-util-visit";
-import * as path from "path";
-import * as fs from "fs/promises";
-import { remarkHeading } from "fumadocs-core/mdx-plugins";
-import { VFile } from "vfile";
-
-// src/loaders/mdx/remark-unravel.ts
-import { visit } from "unist-util-visit";
-function remarkMarkAndUnravel() {
-  return (tree) => {
-    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/mdast-utils.ts
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
-
-// src/loaders/mdx/remark-include.ts
-var REGION_MARKERS = [
-  {
-    start: /^\s*\/\/\s*#?region\b\s*(.*?)\s*$/,
-    end: /^\s*\/\/\s*#?endregion\b\s*(.*?)\s*$/
-  },
-  {
-    start: /^\s*<!--\s*#?region\b\s*(.*?)\s*-->/,
-    end: /^\s*<!--\s*#?endregion\b\s*(.*?)\s*-->/
-  },
-  {
-    start: /^\s*\/\*\s*#region\b\s*(.*?)\s*\*\//,
-    end: /^\s*\/\*\s*#endregion\b\s*(.*?)\s*\*\//
-  },
-  {
-    start: /^\s*#[rR]egion\b\s*(.*?)\s*$/,
-    end: /^\s*#[eE]nd ?[rR]egion\b\s*(.*?)\s*$/
-  },
-  {
-    start: /^\s*#\s*#?region\b\s*(.*?)\s*$/,
-    end: /^\s*#\s*#?endregion\b\s*(.*?)\s*$/
-  },
-  {
-    start: /^\s*(?:--|::|@?REM)\s*#region\b\s*(.*?)\s*$/,
-    end: /^\s*(?:--|::|@?REM)\s*#endregion\b\s*(.*?)\s*$/
-  },
-  {
-    start: /^\s*#pragma\s+region\b\s*(.*?)\s*$/,
-    end: /^\s*#pragma\s+endregion\b\s*(.*?)\s*$/
-  },
-  {
-    start: /^\s*\(\*\s*#region\b\s*(.*?)\s*\*\)/,
-    end: /^\s*\(\*\s*#endregion\b\s*(.*?)\s*\*\)/
-  }
-];
-function dedent(lines) {
-  const minIndent = lines.reduce((min, line) => {
-    const match = line.match(/^(\s*)\S/);
-    return match ? Math.min(min, match[1].length) : min;
-  }, Infinity);
-  return minIndent === Infinity ? lines.join("\n") : lines.map((l) => l.slice(minIndent)).join("\n");
-}
-function extractCodeRegion(content, regionName) {
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    for (const re of REGION_MARKERS) {
-      let match = re.start.exec(lines[i]);
-      if (match?.[1] !== regionName) continue;
-      let depth = 1;
-      const extractedLines = [];
-      for (let j = i + 1; j < lines.length; j++) {
-        match = re.start.exec(lines[j]);
-        if (match) {
-          depth++;
-          continue;
-        }
-        match = re.end.exec(lines[j]);
-        if (match) {
-          if (match[1] === regionName) depth = 0;
-          else if (match[1] === "") depth--;
-          else continue;
-          if (depth > 0) continue;
-          return dedent(extractedLines);
-        } else {
-          extractedLines.push(lines[j]);
-        }
-      }
-    }
-  }
-  throw new Error(`Region "${regionName}" not found`);
-}
-var ElementLikeTypes = [
-  "mdxJsxFlowElement",
-  "mdxJsxTextElement",
-  "containerDirective",
-  "textDirective",
-  "leafDirective"
-];
-function isElementLike(node) {
-  return ElementLikeTypes.includes(node.type);
-}
-function parseElementAttributes(element) {
-  if (Array.isArray(element.attributes)) {
-    const attributes = {};
-    for (const attr of element.attributes) {
-      if (attr.type === "mdxJsxAttribute" && (typeof attr.value === "string" || attr.value === null)) {
-        attributes[attr.name] = attr.value;
-      }
-    }
-    return attributes;
-  }
-  return element.attributes ?? {};
-}
-function parseSpecifier(specifier) {
-  const idx = specifier.lastIndexOf("#");
-  if (idx === -1) return { file: specifier };
-  return {
-    file: specifier.slice(0, idx),
-    section: specifier.slice(idx + 1)
-  };
-}
-function extractSection(root, section) {
-  let nodes;
-  let capturingHeadingContent = false;
-  visit2(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 (targetPath, heading, params, parent) => {
-    const { _getProcessor = () => this, _compiler } = parent.data;
-    let content;
-    try {
-      content = (await fs.readFile(targetPath)).toString();
-    } catch (e) {
-      throw new Error(
-        `failed to read file ${targetPath}
-${e instanceof Error ? e.message : String(e)}`,
-        { cause: e }
-      );
-    }
-    const ext = path.extname(targetPath);
-    _compiler?.addDependency(targetPath);
-    if (params.lang || ext !== ".md" && ext !== ".mdx") {
-      const lang = params.lang ?? ext.slice(1);
-      let value = content;
-      if (heading) {
-        value = extractCodeRegion(content, heading.trim());
-      }
-      return {
-        type: "code",
-        lang,
-        meta: params.meta,
-        value,
-        data: {}
-      };
-    }
-    const parser = _getProcessor(ext === ".mdx" ? "mdx" : "md");
-    const parsed = fumaMatter(content);
-    const targetFile = new VFile({
-      path: targetPath,
-      value: parsed.content,
-      data: {
-        ...parent.data,
-        frontmatter: parsed.data
-      }
-    });
-    let mdast = parser.parse(targetFile);
-    const baseProcessor = unified().use(remarkMarkAndUnravel);
-    if (heading) {
-      const extracted = extractSection(
-        await baseProcessor.use(remarkHeading).run(mdast),
-        heading
-      );
-      if (!extracted)
-        throw new Error(
-          `Cannot find section ${heading} in ${targetPath}, 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, targetFile);
-    return mdast;
-  };
-  async function update(tree, file) {
-    const queue = [];
-    visit2(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 targetPath = path.resolve(
-        "cwd" in attributes ? file.cwd : file.dirname,
-        relativePath
-      );
-      queue.push(
-        embedContent(targetPath, section, attributes, file).then((replace) => {
-          Object.assign(
-            parent && parent.type === "paragraph" ? parent : node,
-            replace
-          );
-        })
-      );
-      return "skip";
-    });
-    await Promise.all(queue);
-  }
-  return async (tree, file) => {
-    await update(tree, file);
-  };
-}
-
-export {
-  flattenNode,
-  remarkInclude
-};

package/dist/chunk-WSQ23PNV.js

@@ -1,179 +0,0 @@
-import {
-  ValidationError
-} from "./chunk-KWSETXYC.js";
-
-// src/loaders/adapter.ts
-import { fileURLToPath } from "url";
-import fs from "fs/promises";
-import { parse } from "querystring";
-import path from "path";
-import { readFileSync } from "fs";
-function toNode(loader) {
-  return async (url, _context, nextLoad) => {
-    if (url.startsWith("file:///") && (!loader.test || loader.test.test(url))) {
-      const parsedUrl = new URL(url);
-      const filePath = fileURLToPath(parsedUrl);
-      const result = await loader.load({
-        filePath,
-        query: Object.fromEntries(parsedUrl.searchParams.entries()),
-        async getSource() {
-          return (await fs.readFile(filePath)).toString();
-        },
-        development: false,
-        compiler: {
-          addDependency() {
-          }
-        }
-      });
-      if (result) {
-        return {
-          source: result.code,
-          format: "module",
-          shortCircuit: true
-        };
-      }
-    }
-    return nextLoad(url);
-  };
-}
-function toVite(loader) {
-  return {
-    filter(id) {
-      return !loader.test || loader.test.test(id);
-    },
-    async transform(value, id) {
-      const [file, query = ""] = id.split("?", 2);
-      const result = await loader.load({
-        filePath: file,
-        query: parse(query),
-        getSource() {
-          return value;
-        },
-        development: this.environment.mode === "dev",
-        compiler: {
-          addDependency: (file2) => {
-            this.addWatchFile(file2);
-          }
-        }
-      });
-      if (result === null) return null;
-      return {
-        code: result.code,
-        map: result.map
-      };
-    }
-  };
-}
-function toWebpack(loader) {
-  return async function(source, callback) {
-    try {
-      const result = await loader.load({
-        filePath: this.resourcePath,
-        query: parse(this.resourceQuery.slice(1)),
-        getSource() {
-          return source;
-        },
-        development: this.mode === "development",
-        compiler: this
-      });
-      if (result === null) {
-        callback(void 0, source);
-      } else {
-        callback(void 0, result.code, result.map);
-      }
-    } catch (error) {
-      if (error instanceof ValidationError) {
-        return callback(new Error(await error.toStringFormatted()));
-      }
-      if (!(error instanceof Error)) throw error;
-      const fpath = path.relative(this.context, this.resourcePath);
-      error.message = `${fpath}:${error.name}: ${error.message}`;
-      callback(error);
-    }
-  };
-}
-function toBun(loader) {
-  function toResult(output) {
-    if (!output) return;
-    return {
-      contents: output.code,
-      loader: "js"
-    };
-  }
-  return (build) => {
-    build.onLoad({ filter: loader.test ?? /.+/ }, (args) => {
-      const [filePath, query = ""] = args.path.split("?", 2);
-      const input = {
-        async getSource() {
-          return Bun.file(filePath).text();
-        },
-        query: parse(query),
-        filePath,
-        development: false,
-        compiler: {
-          addDependency() {
-          }
-        }
-      };
-      if (loader.bun?.load) {
-        return loader.bun.load(readFileSync(filePath).toString(), input);
-      }
-      const result = loader.load(input);
-      if (result instanceof Promise) {
-        return result.then(toResult);
-      }
-      return toResult(result);
-    });
-  };
-}
-
-// src/loaders/config.ts
-import fs2 from "fs/promises";
-function createStandaloneConfigLoader({
-  core,
-  buildConfig,
-  mode
-}) {
-  let prev;
-  async function getConfigHash() {
-    if (mode === "production") return "static";
-    const stats = await fs2.stat(core.getOptions().configPath).catch(() => {
-      throw new Error("Cannot find config file");
-    });
-    return stats.mtime.getTime().toString();
-  }
-  return {
-    async getCore() {
-      const hash = await getConfigHash();
-      if (!prev || hash !== prev.hash) {
-        prev = {
-          hash,
-          init: (async () => {
-            const { loadConfig } = await import("./load-from-file-FHW724YY.js");
-            await core.init({
-              config: loadConfig(core, buildConfig)
-            });
-          })()
-        };
-      }
-      await prev.init;
-      return core;
-    }
-  };
-}
-function createIntegratedConfigLoader(core) {
-  return {
-    async getCore() {
-      return core;
-    }
-  };
-}
-
-export {
-  toNode,
-  toVite,
-  toWebpack,
-  toBun,
-  createStandaloneConfigLoader,
-  createIntegratedConfigLoader
-};

package/dist/chunk-ZAYZWFWP.js

@@ -1,89 +0,0 @@
-import {
-  metaLoaderGlob
-} from "./chunk-4JSFLXXT.js";
-
-// src/loaders/meta.ts
-import { dump, load } from "js-yaml";
-import { z } from "zod";
-var querySchema = z.object({
-  collection: z.string().optional(),
-  workspace: z.string().optional()
-}).loose();
-function createMetaLoader({ getCore }, resolve = {}) {
-  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
-  function parse(filePath, source) {
-    try {
-      if (filePath.endsWith(".json")) return JSON.parse(source);
-      if (filePath.endsWith(".yaml")) return load(source);
-    } catch (e) {
-      throw new Error(`invalid data in ${filePath}`, { cause: e });
-    }
-    throw new Error("Unknown file type " + filePath);
-  }
-  function onMeta(source, { filePath, query }) {
-    const parsed = querySchema.safeParse(query);
-    if (!parsed.success || !parsed.data.collection) return null;
-    const { collection: collectionName, workspace } = parsed.data;
-    return async () => {
-      let core = await getCore();
-      if (workspace) {
-        core = core.getWorkspaces().get(workspace) ?? core;
-      }
-      const collection = core.getCollection(collectionName);
-      let metaCollection;
-      switch (collection?.type) {
-        case "meta":
-          metaCollection = collection;
-          break;
-        case "docs":
-          metaCollection = collection.meta;
-          break;
-      }
-      const data = parse(filePath, source);
-      if (!metaCollection) return data;
-      return core.transformMeta(
-        {
-          collection: metaCollection,
-          filePath,
-          source
-        },
-        data
-      );
-    };
-  }
-  return {
-    test: metaLoaderGlob,
-    async load(input) {
-      const result = onMeta(await input.getSource(), input);
-      if (result === null) return null;
-      const data = await result();
-      if (input.filePath.endsWith(".json")) {
-        return {
-          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
-        };
-      } else {
-        return {
-          code: resolveYaml === "yaml" ? dump(data) : `export default ${JSON.stringify(data)}`
-        };
-      }
-    },
-    bun: {
-      load(source, input) {
-        const result = onMeta(source, input);
-        if (result === null)
-          return {
-            loader: "object",
-            exports: parse(input.filePath, source)
-          };
-        return result().then((data) => ({
-          loader: "object",
-          exports: { default: data }
-        }));
-      }
-    }
-  };
-}
-
-export {
-  createMetaLoader
-};