@vxrn/mdx 1.1.538 → 1.1.540

package/dist/index.mjs

@@ -0,0 +1,424 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// ../../node_modules/mdx-bundler/dist/dirname-messed-up.cjs
+var require_dirname_messed_up = __commonJS({
+  "../../node_modules/mdx-bundler/dist/dirname-messed-up.cjs"(exports2, module2) {
+    "use strict";
+    module2.exports = !__dirname.includes("mdx-bundler");
+  }
+});
+
+// ../../node_modules/mdx-bundler/dist/index.js
+var require_dist = __commonJS({
+  "../../node_modules/mdx-bundler/dist/index.js"(exports2) {
+    "use strict";
+    var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+    Object.defineProperty(exports2, "__esModule", {
+      value: !0
+    });
+    exports2.bundleMDX = bundleMDX2;
+    var _fs = _interopRequireDefault(require("fs")), _path = _interopRequireDefault(require("path")), _string_decoder = require("string_decoder"), _grayMatter = _interopRequireDefault(require("gray-matter")), esbuild = _interopRequireWildcard(require("esbuild-wasm")), _nodeResolve = require("@esbuild-plugins/node-resolve"), _esbuildPluginGlobalExternals = require("@fal-works/esbuild-plugin-global-externals"), _uuid = require("uuid"), _dirnameMessedUp = _interopRequireDefault(require_dirname_messed_up());
+    function _getRequireWildcardCache(e) {
+      if (typeof WeakMap != "function") return null;
+      var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
+      return (_getRequireWildcardCache = function(e2) {
+        return e2 ? t : r;
+      })(e);
+    }
+    function _interopRequireWildcard(e, r) {
+      if (!r && e && e.__esModule) return e;
+      if (e === null || typeof e != "object" && typeof e != "function") return { default: e };
+      var t = _getRequireWildcardCache(r);
+      if (t && t.has(e)) return t.get(e);
+      var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
+      for (var u in e) if (u !== "default" && {}.hasOwnProperty.call(e, u)) {
+        var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
+        i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
+      }
+      return n.default = e, t && t.set(e, n), n;
+    }
+    var {
+      readFile,
+      unlink
+    } = _fs.default.promises;
+    async function bundleMDX2({
+      file,
+      source,
+      files = {},
+      mdxOptions = (options) => options,
+      esbuildOptions = (options) => options,
+      globals = {},
+      cwd = _path.default.join(process.cwd(), "__mdx_bundler_fake_dir__"),
+      grayMatterOptions = (options) => options,
+      bundleDirectory,
+      bundlePath
+    }) {
+      _dirnameMessedUp.default;
+      let [{
+        default: mdxESBuild
+      }, {
+        default: remarkFrontmatter
+      }, {
+        default: remarkMdxFrontmatter
+      }] = await Promise.all([import("@mdx-js/esbuild"), import("remark-frontmatter"), import("remark-mdx-frontmatter")]), code, entryPath, matter2, absoluteFiles = {}, isWriting = typeof bundleDirectory == "string";
+      if (typeof bundleDirectory != typeof bundlePath)
+        throw new Error("When using `bundleDirectory` or `bundlePath` the other must be set.");
+      function isVFile(vfile) {
+        return typeof vfile == "object" && vfile !== null && "value" in vfile;
+      }
+      if (typeof source == "string")
+        matter2 = (0, _grayMatter.default)(source, grayMatterOptions({})), entryPath = _path.default.join(cwd, `./_mdx_bundler_entry_point-${(0, _uuid.v4)()}.mdx`), absoluteFiles[entryPath] = source;
+      else if (isVFile(source)) {
+        let value = String(source.value);
+        matter2 = (0, _grayMatter.default)(value, grayMatterOptions({})), entryPath = source.path ? _path.default.isAbsolute(source.path) ? source.path : _path.default.join(source.cwd, source.path) : _path.default.join(cwd, `./_mdx_bundler_entry_point-${(0, _uuid.v4)()}.mdx`), absoluteFiles[entryPath] = value;
+      } else if (typeof file == "string")
+        matter2 = _grayMatter.default.read(file, grayMatterOptions({})), entryPath = file;
+      else
+        throw new Error("`source` or `file` must be defined");
+      for (let [filepath, fileCode] of Object.entries(files))
+        absoluteFiles[_path.default.join(cwd, filepath)] = fileCode;
+      let inMemoryPlugin = {
+        name: "inMemory",
+        setup(build) {
+          build.onResolve({
+            filter: /.*/
+          }, ({
+            path: filePath,
+            importer
+          }) => {
+            if (filePath === entryPath)
+              return {
+                path: filePath,
+                pluginData: {
+                  inMemory: !0,
+                  contents: absoluteFiles[filePath]
+                }
+              };
+            let modulePath = _path.default.resolve(_path.default.dirname(importer), filePath);
+            if (modulePath in absoluteFiles)
+              return {
+                path: modulePath,
+                pluginData: {
+                  inMemory: !0,
+                  contents: absoluteFiles[modulePath]
+                }
+              };
+            for (let ext of [".js", ".ts", ".jsx", ".tsx", ".json", ".mdx"]) {
+              let fullModulePath = `${modulePath}${ext}`;
+              if (fullModulePath in absoluteFiles)
+                return {
+                  path: fullModulePath,
+                  pluginData: {
+                    inMemory: !0,
+                    contents: absoluteFiles[fullModulePath]
+                  }
+                };
+            }
+            return {};
+          }), build.onLoad({
+            filter: /.*/
+          }, async ({
+            path: filePath,
+            pluginData
+          }) => {
+            if (pluginData === void 0 || !pluginData.inMemory)
+              return null;
+            let fileType = (_path.default.extname(filePath) || ".jsx").slice(1), contents = absoluteFiles[filePath];
+            if (fileType === "mdx") return null;
+            let loader;
+            return build.initialOptions.loader && build.initialOptions.loader[`.${fileType}`] ? loader = build.initialOptions.loader[`.${fileType}`] : loader = /** @type import('esbuild').Loader */
+            fileType, {
+              contents,
+              loader
+            };
+          });
+        }
+      }, buildOptions = esbuildOptions({
+        entryPoints: [entryPath],
+        write: isWriting,
+        outdir: isWriting ? bundleDirectory : void 0,
+        publicPath: isWriting ? bundlePath : void 0,
+        absWorkingDir: cwd,
+        define: {
+          "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV ?? "production")
+        },
+        plugins: [
+          (0, _esbuildPluginGlobalExternals.globalExternals)({
+            ...globals,
+            react: {
+              varName: "React",
+              type: "cjs"
+            },
+            "react-dom": {
+              varName: "ReactDOM",
+              type: "cjs"
+            },
+            "react/jsx-runtime": {
+              varName: "_jsx_runtime",
+              type: "cjs"
+            }
+          }),
+          // eslint-disable-next-line new-cap
+          (0, _nodeResolve.NodeResolvePlugin)({
+            extensions: [".js", ".ts", ".jsx", ".tsx"],
+            resolveOptions: {
+              basedir: cwd
+            }
+          }),
+          inMemoryPlugin,
+          mdxESBuild(mdxOptions({
+            remarkPlugins: [remarkFrontmatter, [remarkMdxFrontmatter, {
+              name: "frontmatter"
+            }]]
+          }, matter2.data))
+        ],
+        bundle: !0,
+        format: "iife",
+        globalName: "Component",
+        minify: !0
+      }, matter2.data), bundled = await esbuild.build(buildOptions);
+      if (bundled.outputFiles)
+        code = new _string_decoder.StringDecoder("utf8").write(Buffer.from(bundled.outputFiles[0].contents));
+      else if (buildOptions.outdir && buildOptions.write) {
+        let entryFile = (
+          /** @type {{entryPoints: string[]}} */
+          buildOptions.entryPoints[0]
+        ), fileName = _path.default.basename(entryFile).replace(/\.[^/.]+$/, ".js");
+        code = (await readFile(_path.default.join(buildOptions.outdir, fileName))).toString(), await unlink(_path.default.join(buildOptions.outdir, fileName));
+      } else
+        throw new Error("You must either specify `write: false` or `write: true` and `outdir: '/path'` in your esbuild options");
+      return {
+        code: `${code};return Component;`,
+        frontmatter: matter2.data,
+        errors: bundled.errors,
+        matter: matter2
+      };
+    }
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createCodeHighlighter: () => createCodeHighlighter,
+  getAllFrontmatter: () => getAllFrontmatter,
+  getAllVersionsFromPath: () => getAllVersionsFromPath,
+  getMDX: () => getMDX,
+  getMDXBySlug: () => getMDXBySlug
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/getAllFrontmatter.tsx
+var import_fast_glob = __toESM(require("fast-glob")), import_gray_matter = __toESM(require("gray-matter")), import_node_fs = __toESM(require("node:fs")), import_node_path = __toESM(require("node:path")), import_reading_time = __toESM(require("reading-time"));
+
+// src/getHeadings.ts
+var getTitle = (source) => source.replace(/^\#+\s+/, "").replace(/\<.*\>/, " "), getHeadings = (source) => source.split(`
+`).filter((x) => x.startsWith("#")).map((x) => ({
+  title: getTitle(x),
+  priority: x.trim().split(" ")[0].length,
+  id: `#${getTitle(x).replace(/\s+/g, "-").toLowerCase()}`
+}));
+
+// src/getAllFrontmatter.tsx
+var getAllFrontmatter = (fromPath) => import_fast_glob.default.sync(`${fromPath}/**/*.mdx`).map((filePath) => {
+  let source = import_node_fs.default.readFileSync(import_node_path.default.join(filePath), "utf8"), { data, content } = (0, import_gray_matter.default)(source), slug = filePath.replace(`${fromPath.replaceAll("\\", "/")}/`, "").replace(".mdx", "");
+  return {
+    ...data,
+    slug,
+    headings: getHeadings(source),
+    readingTime: (0, import_reading_time.default)(content)
+  };
+}).sort((a, b) => Number(new Date(b.publishedAt || "")) - Number(new Date(a.publishedAt || "")));
+
+// src/getMDX.ts
+var import_mdx_bundler = __toESM(require_dist()), import_reading_time2 = __toESM(require("reading-time")), import_rehype_autolink_headings = __toESM(require("rehype-autolink-headings")), import_rehype_slug = __toESM(require("rehype-slug"));
+
+// src/rehypeHighlightCode.tsx
+var import_hast_util_to_string = require("hast-util-to-string"), import_parse_numeric_range = __toESM(require("parse-numeric-range")), import_refractor = require("refractor"), import_tsx = __toESM(require("refractor/lang/tsx.js")), import_unist_util_visit = __toESM(require("unist-util-visit"));
+
+// src/rehypeLine.tsx
+var import_hast_util_to_html = require("hast-util-to-html"), import_rehype_parse = __toESM(require("rehype-parse")), import_unified = require("unified"), lineNumberify = function lineNumberify2(ast, lineNum = 1) {
+  let lineNumber = lineNum;
+  return ast.reduce(
+    (result, node) => {
+      if (node.type === "text") {
+        if (node.value.indexOf(`
+`) === -1)
+          return node.lineNumber = lineNumber, result.nodes.push(node), result;
+        let lines = node.value.split(`
+`);
+        for (let i = 0; i < lines.length; i++)
+          i !== 0 && ++lineNumber, !(i === lines.length - 1 && lines[i].length === 0) && result.nodes.push({
+            type: "text",
+            value: i === lines.length - 1 ? lines[i] : `${lines[i]}
+`,
+            lineNumber
+          });
+        return result.lineNumber = lineNumber, result;
+      }
+      if (node.children) {
+        node.lineNumber = lineNumber;
+        let processed = lineNumberify2(node.children, lineNumber);
+        return node.children = processed.nodes, result.lineNumber = processed.lineNumber, result.nodes.push(node), result;
+      }
+      return result.nodes.push(node), result;
+    },
+    { nodes: [], lineNumber }
+  );
+}, wrapLines = function(ast, linesToHighlight) {
+  let highlightAll = linesToHighlight.length === 1 && linesToHighlight[0] === 0, allLines = Array.from(new Set(ast.map((x) => x.lineNumber))), i = 0;
+  return allLines.reduce((nodes, marker) => {
+    let line = marker, children = [];
+    for (; i < ast.length; i++) {
+      if (ast[i].lineNumber < line) {
+        nodes.push(ast[i]);
+        continue;
+      }
+      if (ast[i].lineNumber === line) {
+        children.push(ast[i]);
+        continue;
+      }
+      if (ast[i].lineNumber > line)
+        break;
+    }
+    return nodes.push({
+      type: "element",
+      tagName: "div",
+      properties: {
+        dataLine: line,
+        className: "highlight-line",
+        dataHighlighted: linesToHighlight.includes(line) || highlightAll ? "true" : "false"
+      },
+      children,
+      lineNumber: line
+    }), nodes;
+  }, []);
+}, MULTILINE_TOKEN_SPAN = /<span class="token ([^"]+)">[^<]*\n[^<]*<\/span>/g, applyMultilineFix = (ast) => {
+  let html = (0, import_hast_util_to_html.toHtml)(ast);
+  return html = html.replace(
+    MULTILINE_TOKEN_SPAN,
+    (match, token) => match.replace(/\n/g, `</span>
+<span class="token ${token}">`)
+  ), (0, import_unified.unified)().use(import_rehype_parse.default, { emitParseErrors: !0, fragment: !0 }).parse(html).children;
+};
+function rehypeHighlightLine(ast, lines) {
+  let formattedAst = applyMultilineFix(ast), numbered = lineNumberify(formattedAst).nodes;
+  return wrapLines(numbered, lines);
+}
+
+// src/rehypeWord.tsx
+var import_hast_util_to_html2 = require("hast-util-to-html"), import_rehype_parse2 = __toESM(require("rehype-parse")), import_unified2 = require("unified"), CALLOUT = /__(.*?)__/g, rehypeHighlightWord = (code) => {
+  let result = (0, import_hast_util_to_html2.toHtml)(code).replace(CALLOUT, (_, text) => `<span class="highlight-word">${text}</span>`);
+  return (0, import_unified2.unified)().use(import_rehype_parse2.default, { emitParseErrors: !0, fragment: !0 }).parse(result).children;
+};
+
+// src/rehypeHighlightCode.tsx
+import_refractor.refractor.register(import_tsx.default);
+var rehypeHighlightCode = (options = {}) => {
+  return (tree) => {
+    (0, import_unist_util_visit.default)(tree, "element", visitor);
+  };
+  function visitor(node, index, parent) {
+    if (!parent || parent.tagName !== "pre" || node.tagName !== "code" || !node.properties.className)
+      return;
+    let [_, lang] = node.properties.className[0].split("-"), codeString = (0, import_hast_util_to_string.toString)(node), result = import_refractor.refractor.highlight(codeString, lang), linesToHighlight = (0, import_parse_numeric_range.default)(node.properties.line || "0");
+    result = rehypeHighlightLine(result, linesToHighlight), node.children = rehypeHighlightWord(result);
+  }
+};
+
+// src/rehypeMetaAttribute.tsx
+var import_unist_util_visit2 = __toESM(require("unist-util-visit")), re = /\b([-\w]+)(?:=(?:"([^"]*)"|'([^']*)'|([^"'\s]+)))?/g, rehypeMetaAttribute_default = (options = {}) => {
+  return (tree) => {
+    (0, import_unist_util_visit2.default)(tree, "element", onelement);
+  };
+  function onelement(node) {
+    let match;
+    if (node.tagName === "code" && node.data && node.data.meta)
+      for (re.lastIndex = 0; match = re.exec(node.data.meta); )
+        node.properties[match[1]] = match[2] || match[3] || match[4] || "";
+  }
+};
+
+// src/getMDX.ts
+async function getMDX(source, extraPlugins) {
+  let { frontmatter, code } = await (0, import_mdx_bundler.bundleMDX)({
+    source,
+    mdxOptions(options) {
+      let plugins = [
+        ...extraPlugins || [],
+        ...options.rehypePlugins ?? [],
+        rehypeMetaAttribute_default,
+        rehypeHighlightCode,
+        import_rehype_autolink_headings.default,
+        import_rehype_slug.default
+      ];
+      return options.rehypePlugins = plugins, options;
+    }
+  });
+  return {
+    frontmatter: {
+      ...frontmatter,
+      headings: getHeadings(source),
+      readingTime: (0, import_reading_time2.default)(code)
+    },
+    code
+  };
+}
+
+// src/getMDXBySlug.tsx
+var import_node_fs2 = __toESM(require("node:fs")), import_node_path2 = __toESM(require("node:path")), import_compare_versions = __toESM(require("compare-versions"));
+var getMDXBySlug = async (basePath, slug, extraPlugins) => {
+  let mdxPath = slug;
+  if (!slug.includes(".") && basePath.includes("components")) {
+    let versions = getAllVersionsFromPath(import_node_path2.default.join(basePath, slug));
+    mdxPath += `/${versions[0]}`;
+  }
+  let filePath = import_node_path2.default.join(basePath, `${mdxPath}.mdx`), source = import_node_fs2.default.readFileSync(filePath, "utf8");
+  return await getMDX(source, extraPlugins);
+};
+function getAllVersionsFromPath(fromPath) {
+  return import_node_fs2.default.existsSync(fromPath) ? import_node_fs2.default.readdirSync(fromPath).map((fileName) => fileName.replace(".mdx", "")).sort(import_compare_versions.default).reverse() : [];
+}
+
+// src/highlightCode.tsx
+var import_hast_util_to_html3 = require("hast-util-to-html"), import_parse_numeric_range2 = __toESM(require("parse-numeric-range")), import_refractor2 = require("refractor"), import_css = __toESM(require("refractor/lang/css.js")), import_tsx2 = __toESM(require("refractor/lang/tsx.js"));
+var highlighter;
+function createCodeHighlighter() {
+  return highlighter || (import_refractor2.refractor.register(import_tsx2.default), import_refractor2.refractor.register(import_css.default), highlighter = function(source, language, line = "0") {
+    let result = import_refractor2.refractor.highlight(source, language);
+    return result = rehypeHighlightLine(result, (0, import_parse_numeric_range2.default)(line)), result = rehypeHighlightWord(result), result = (0, import_hast_util_to_html3.toHtml)(result), result;
+  }, highlighter);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCodeHighlighter,
+  getAllFrontmatter,
+  getAllVersionsFromPath,
+  getMDX,
+  getMDXBySlug
+});
+//# sourceMappingURL=index.js.map