hermium 0.2.0 → 0.3.1

package/dist/server/_libs/rehype-highlight.mjs

@@ -0,0 +1,94 @@
+import { g as grammars, c as createLowlight } from "./lowlight.mjs";
+import { v as visit } from "./unist-util-visit.mjs";
+import { t as toText } from "./hast-util-to-text.mjs";
+const emptyOptions = {};
+function rehypeHighlight(options) {
+  const settings = options || emptyOptions;
+  const aliases = settings.aliases;
+  const detect = settings.detect || false;
+  const languages = settings.languages || grammars;
+  const plainText = settings.plainText;
+  const prefix = settings.prefix;
+  const subset = settings.subset;
+  let name = "hljs";
+  const lowlight = createLowlight(languages);
+  if (aliases) {
+    lowlight.registerAlias(aliases);
+  }
+  if (prefix) {
+    const pos = prefix.indexOf("-");
+    name = pos === -1 ? prefix : prefix.slice(0, pos);
+  }
+  return function(tree, file) {
+    visit(tree, "element", function(node, _, parent) {
+      if (node.tagName !== "code" || !parent || parent.type !== "element" || parent.tagName !== "pre") {
+        return;
+      }
+      const lang = language(node);
+      if (lang === false || !lang && !detect || lang && plainText && plainText.includes(lang)) {
+        return;
+      }
+      if (!Array.isArray(node.properties.className)) {
+        node.properties.className = [];
+      }
+      if (!node.properties.className.includes(name)) {
+        node.properties.className.unshift(name);
+      }
+      const text = toText(node, { whitespace: "pre" });
+      let result;
+      try {
+        result = lang ? lowlight.highlight(lang, text, { prefix }) : lowlight.highlightAuto(text, { prefix, subset });
+      } catch (error) {
+        const cause = (
+          /** @type {Error} */
+          error
+        );
+        if (lang && /Unknown language/.test(cause.message)) {
+          file.message(
+            "Cannot highlight as `" + lang + "`, it’s not registered",
+            {
+              ancestors: [parent, node],
+              cause,
+              place: node.position,
+              ruleId: "missing-language",
+              source: "rehype-highlight"
+            }
+          );
+          return;
+        }
+        throw cause;
+      }
+      if (!lang && result.data && result.data.language) {
+        node.properties.className.push("language-" + result.data.language);
+      }
+      if (result.children.length > 0) {
+        node.children = /** @type {Array<ElementContent>} */
+        result.children;
+      }
+    });
+  };
+}
+function language(node) {
+  const list = node.properties.className;
+  let index = -1;
+  if (!Array.isArray(list)) {
+    return;
+  }
+  let name;
+  while (++index < list.length) {
+    const value = String(list[index]);
+    if (value === "no-highlight" || value === "nohighlight") {
+      return false;
+    }
+    if (!name && value.slice(0, 5) === "lang-") {
+      name = value.slice(5);
+    }
+    if (!name && value.slice(0, 9) === "language-") {
+      name = value.slice(9);
+    }
+  }
+  return name;
+}
+export {
+  rehypeHighlight as r
+};

package/dist/server/_libs/remark-gfm.mjs

@@ -0,0 +1,20 @@
+import { g as gfm } from "./micromark-extension-gfm.mjs";
+import { g as gfmFromMarkdown, a as gfmToMarkdown } from "./mdast-util-gfm.mjs";
+const emptyOptions = {};
+function remarkGfm(options) {
+  const self = (
+    /** @type {Processor<Root>} */
+    this
+  );
+  const settings = options || emptyOptions;
+  const data = self.data();
+  const micromarkExtensions = data.micromarkExtensions || (data.micromarkExtensions = []);
+  const fromMarkdownExtensions = data.fromMarkdownExtensions || (data.fromMarkdownExtensions = []);
+  const toMarkdownExtensions = data.toMarkdownExtensions || (data.toMarkdownExtensions = []);
+  micromarkExtensions.push(gfm(settings));
+  fromMarkdownExtensions.push(gfmFromMarkdown());
+  toMarkdownExtensions.push(gfmToMarkdown(settings));
+}
+export {
+  remarkGfm as r
+};

package/dist/server/_libs/remark-parse.mjs

@@ -0,0 +1,19 @@
+import { f as fromMarkdown } from "./mdast-util-from-markdown.mjs";
+function remarkParse(options) {
+  const self = this;
+  self.parser = parser;
+  function parser(doc) {
+    return fromMarkdown(doc, {
+      ...self.data("settings"),
+      ...options,
+      // Note: these options are not in the readme.
+      // The goal is for them to be set by plugins on `data` instead of being
+      // passed by users.
+      extensions: self.data("micromarkExtensions") || [],
+      mdastExtensions: self.data("fromMarkdownExtensions") || []
+    });
+  }
+}
+export {
+  remarkParse as r
+};

package/dist/server/_libs/remark-rehype.mjs

@@ -0,0 +1,21 @@
+import { t as toHast } from "./mdast-util-to-hast.mjs";
+function remarkRehype(destination, options) {
+  if (destination && "run" in destination) {
+    return async function(tree, file) {
+      const hastTree = (
+        /** @type {HastRoot} */
+        toHast(tree, { file, ...options })
+      );
+      await destination.run(hastTree, file);
+    };
+  }
+  return function(tree, file) {
+    return (
+      /** @type {HastRoot} */
+      toHast(tree, { file, ...destination || options })
+    );
+  };
+}
+export {
+  remarkRehype as r
+};

package/dist/server/_libs/reselect.mjs

@@ -0,0 +1 @@
+

package/dist/server/_libs/rou3.mjs

@@ -0,0 +1,8 @@
+const NullProtoObj = /* @__PURE__ */ (() => {
+  const e = function() {
+  };
+  return e.prototype = /* @__PURE__ */ Object.create(null), Object.freeze(e.prototype), e;
+})();
+export {
+  NullProtoObj as N
+};

package/dist/server/_libs/seroval-plugins.mjs

@@ -0,0 +1 @@
+

package/dist/server/_libs/seroval.mjs

@@ -0,0 +1 @@
+

package/dist/server/_libs/space-separated-tokens.mjs

@@ -0,0 +1,6 @@
+function stringify(values) {
+  return values.join(" ").trim();
+}
+export {
+  stringify as s
+};