hermium 0.2.0 → 0.3.1

package/dist/server/_libs/hookable.mjs

@@ -0,0 +1 @@
+

package/dist/server/_libs/html-url-attributes.mjs

@@ -0,0 +1,26 @@
+const urlAttributes = {
+  action: ["form"],
+  cite: ["blockquote", "del", "ins", "q"],
+  data: ["object"],
+  formAction: ["button", "input"],
+  href: ["a", "area", "base", "link"],
+  icon: ["menuitem"],
+  itemId: null,
+  manifest: ["html"],
+  ping: ["a", "area"],
+  poster: ["video"],
+  src: [
+    "audio",
+    "embed",
+    "iframe",
+    "img",
+    "input",
+    "script",
+    "source",
+    "track",
+    "video"
+  ]
+};
+export {
+  urlAttributes as u
+};

package/dist/server/_libs/inline-style-parser.mjs

@@ -0,0 +1,142 @@
+var cjs;
+var hasRequiredCjs;
+function requireCjs() {
+  if (hasRequiredCjs) return cjs;
+  hasRequiredCjs = 1;
+  var COMMENT_REGEX = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+  var NEWLINE_REGEX = /\n/g;
+  var WHITESPACE_REGEX = /^\s*/;
+  var PROPERTY_REGEX = /^(\*?[-#/*\\\w]+(\[[0-9a-z_-]+\])?)\s*/;
+  var COLON_REGEX = /^:\s*/;
+  var VALUE_REGEX = /^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^)]*?\)|[^};])+)/;
+  var SEMICOLON_REGEX = /^[;\s]*/;
+  var TRIM_REGEX = /^\s+|\s+$/g;
+  var NEWLINE = "\n";
+  var FORWARD_SLASH = "/";
+  var ASTERISK = "*";
+  var EMPTY_STRING = "";
+  var TYPE_COMMENT = "comment";
+  var TYPE_DECLARATION = "declaration";
+  function index(style, options) {
+    if (typeof style !== "string") {
+      throw new TypeError("First argument must be a string");
+    }
+    if (!style) return [];
+    options = options || {};
+    var lineno = 1;
+    var column = 1;
+    function updatePosition(str) {
+      var lines = str.match(NEWLINE_REGEX);
+      if (lines) lineno += lines.length;
+      var i = str.lastIndexOf(NEWLINE);
+      column = ~i ? str.length - i : column + str.length;
+    }
+    function position() {
+      var start = { line: lineno, column };
+      return function(node) {
+        node.position = new Position(start);
+        whitespace();
+        return node;
+      };
+    }
+    function Position(start) {
+      this.start = start;
+      this.end = { line: lineno, column };
+      this.source = options.source;
+    }
+    Position.prototype.content = style;
+    function error(msg) {
+      var err = new Error(
+        options.source + ":" + lineno + ":" + column + ": " + msg
+      );
+      err.reason = msg;
+      err.filename = options.source;
+      err.line = lineno;
+      err.column = column;
+      err.source = style;
+      if (options.silent) ;
+      else {
+        throw err;
+      }
+    }
+    function match(re) {
+      var m = re.exec(style);
+      if (!m) return;
+      var str = m[0];
+      updatePosition(str);
+      style = style.slice(str.length);
+      return m;
+    }
+    function whitespace() {
+      match(WHITESPACE_REGEX);
+    }
+    function comments(rules) {
+      var c;
+      rules = rules || [];
+      while (c = comment()) {
+        if (c !== false) {
+          rules.push(c);
+        }
+      }
+      return rules;
+    }
+    function comment() {
+      var pos = position();
+      if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;
+      var i = 2;
+      while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {
+        ++i;
+      }
+      i += 2;
+      if (EMPTY_STRING === style.charAt(i - 1)) {
+        return error("End of comment missing");
+      }
+      var str = style.slice(2, i - 2);
+      column += 2;
+      updatePosition(str);
+      style = style.slice(i);
+      column += 2;
+      return pos({
+        type: TYPE_COMMENT,
+        comment: str
+      });
+    }
+    function declaration() {
+      var pos = position();
+      var prop = match(PROPERTY_REGEX);
+      if (!prop) return;
+      comment();
+      if (!match(COLON_REGEX)) return error("property missing ':'");
+      var val = match(VALUE_REGEX);
+      var ret = pos({
+        type: TYPE_DECLARATION,
+        property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),
+        value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING
+      });
+      match(SEMICOLON_REGEX);
+      return ret;
+    }
+    function declarations() {
+      var decls = [];
+      comments(decls);
+      var decl;
+      while (decl = declaration()) {
+        if (decl !== false) {
+          decls.push(decl);
+          comments(decls);
+        }
+      }
+      return decls;
+    }
+    whitespace();
+    return declarations();
+  }
+  function trim(str) {
+    return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;
+  }
+  cjs = index;
+  return cjs;
+}
+export {
+  requireCjs as r
+};

package/dist/server/_libs/is-plain-obj.mjs

@@ -0,0 +1,10 @@
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+export {
+  isPlainObject as i
+};

package/dist/server/_libs/isbot.mjs

@@ -0,0 +1,21 @@
+var fullPattern = " daum[ /]| deusu/|(?:^|[^g])news(?!sapphire)|(?<! (?:channel/|google/))google(?!(app|/google| pixel))|(?<! cu)bots?(?:\\b|_)|(?<!(?:lib))http|(?<!cam)scan|24x7|@[a-z][\\w-]+\\.|\\(\\)|\\.com\\b|\\b\\w+\\.ai|\\bcursor/|\\bmanus-user/|\\bort/|\\bperl\\b|\\bplaywright\\b|\\bsecurityheaders\\b|\\bselenium\\b|\\btime/|\\||^[\\w \\.\\-\\(?:\\):%]+(?:/v?\\d+(?:\\.\\d+)?(?:\\.\\d{1,10})*?)?(?:,|$)|^[\\w\\-]+/[\\w]+$|^[^ ]{50,}$|^\\d+\\b|^\\W|^\\w*search\\b|^\\w+/[\\w\\(\\)]*$|^\\w+/\\d\\.\\d\\s\\([\\w@]+\\)$|^active|^ad muncher|^amaya|^apache/|^avsdevicesdk/|^azure|^biglotron|^bot|^bw/|^clamav[ /]|^claude-code/|^client/|^cobweb/|^custom|^ddg[_-]android|^discourse|^dispatch/\\d|^downcast/|^duckduckgo|^email|^facebook|^getright/|^gozilla/|^hobbit|^hotzonu|^hwcdn/|^igetter/|^jeode/|^jetty/|^jigsaw|^microsoft bits|^movabletype|^mozilla/\\d\\.\\d\\s[\\w\\.-]+$|^mozilla/\\d\\.\\d\\s\\((?:compatible;)?(?:\\s?[\\w\\d-.]+\\/\\d+\\.\\d+)?\\)$|^navermailapp|^netsurf|^offline|^openai/|^owler|^php|^postman|^python|^rank|^read|^reed|^rest|^rss|^snapchat|^space bison|^svn|^swcd |^taringa|^thumbor/|^track|^w3c|^webbandit/|^webcopier|^wget|^whatsapp|^wordpress|^xenu link sleuth|^yahoo|^yandex|^zdm/\\d|^zoom marketplace/|advisor|agent\\b|analyzer|archive|ask jeeves/teoma|audit|bit\\.ly/|bluecoat drtr|browsex|burpcollaborator|capture|catch|check\\b|checker|chrome-lighthouse|chromeframe|classifier|cloudflare|convertify|crawl|cypress/|dareboost|datanyze|dejaclick|detect|dmbrowser|download|exaleadcloudview|feed|fetcher|firephp|functionize|grab|headless|httrack|hubspot marketing grader|ibisbrowser|infrawatch|insight|inspect|iplabel|java(?!;)|library|linkcheck|mail\\.ru/|manager|measure|monitor\\b|neustar wpm|node\\b|nutch|offbyone|onetrust|optimize|pageburst|pagespeed|parser|phantomjs|pingdom|powermarks|preview|proxy|ptst[ /]\\d|retriever|rexx;|rigor|rss\\b|scrape|server|sogou|sparkler/|speedcurve|spider|splash|statuscake|supercleaner|synapse|synthetic|tools|torrent|transcoder|url|validator|virtuoso|wappalyzer|webglance|webkit2png|whatcms/|xtate/";
+var naivePattern = /bot|crawl|http|lighthouse|scan|search|spider/i;
+var pattern;
+function getPattern() {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  try {
+    pattern = new RegExp(fullPattern, "i");
+  } catch (error) {
+    pattern = naivePattern;
+  }
+  return pattern;
+}
+var isNonEmptyString = (value) => typeof value === "string" && value !== "";
+function isbot(userAgent) {
+  return isNonEmptyString(userAgent) && getPattern().test(userAgent);
+}
+export {
+  isbot as i
+};

package/dist/server/_libs/longest-streak.mjs

@@ -0,0 +1,25 @@
+function longestStreak(value, substring) {
+  const source = String(value);
+  let index = source.indexOf(substring);
+  let expected = index;
+  let count = 0;
+  let max = 0;
+  if (typeof substring !== "string") {
+    throw new TypeError("Expected substring");
+  }
+  while (index !== -1) {
+    if (index === expected) {
+      if (++count > max) {
+        max = count;
+      }
+    } else {
+      count = 1;
+    }
+    expected = index + substring.length;
+    index = source.indexOf(substring, expected);
+  }
+  return max;
+}
+export {
+  longestStreak as l
+};

package/dist/server/_libs/lowlight.mjs

@@ -0,0 +1,262 @@
+import { L as yaml, K as xml, J as wasm, I as vbnet, G as typescript, F as swift, E as sql, D as shell, C as scss, B as rust, A as ruby, z as r, y as pythonRepl, x as python, w as plaintext, v as phpTemplate, u as php, t as perl, s as objectivec, r as markdown, q as makefile, p as lua, o as less, n as kotlin, m as json, l as javascript, k as java, j as ini, i as graphql, h as go, g as diff, f as css, e as csharp, d as cpp, c, b as bash, a as arduino, H as HighlightJS } from "./highlight.js.mjs";
+const grammars = {
+  arduino,
+  bash,
+  c,
+  cpp,
+  csharp,
+  css,
+  diff,
+  go,
+  graphql,
+  ini,
+  java,
+  javascript,
+  json,
+  kotlin,
+  less,
+  lua,
+  makefile,
+  markdown,
+  objectivec,
+  perl,
+  php,
+  "php-template": phpTemplate,
+  plaintext,
+  python,
+  "python-repl": pythonRepl,
+  r,
+  ruby,
+  rust,
+  scss,
+  shell,
+  sql,
+  swift,
+  typescript,
+  vbnet,
+  wasm,
+  xml,
+  yaml
+};
+const emptyOptions = {};
+const defaultPrefix = "hljs-";
+function createLowlight(grammars2) {
+  const high = HighlightJS.newInstance();
+  if (grammars2) {
+    register(grammars2);
+  }
+  return {
+    highlight,
+    highlightAuto,
+    listLanguages,
+    register,
+    registerAlias,
+    registered
+  };
+  function highlight(language, value, options) {
+    const settings = options || emptyOptions;
+    const prefix = typeof settings.prefix === "string" ? settings.prefix : defaultPrefix;
+    if (!high.getLanguage(language)) {
+      throw new Error("Unknown language: `" + language + "` is not registered");
+    }
+    high.configure({ __emitter: HastEmitter, classPrefix: prefix });
+    const result = (
+      /** @type {HighlightResult & {_emitter: HastEmitter}} */
+      high.highlight(value, { ignoreIllegals: true, language })
+    );
+    if (result.errorRaised) {
+      throw new Error("Could not highlight with `Highlight.js`", {
+        cause: result.errorRaised
+      });
+    }
+    const root = result._emitter.root;
+    const data = (
+      /** @type {RootData} */
+      root.data
+    );
+    data.language = result.language;
+    data.relevance = result.relevance;
+    return root;
+  }
+  function highlightAuto(value, options) {
+    const settings = options || emptyOptions;
+    const subset = settings.subset || listLanguages();
+    let index = -1;
+    let relevance = 0;
+    let result;
+    while (++index < subset.length) {
+      const name = subset[index];
+      if (!high.getLanguage(name)) continue;
+      const current = highlight(name, value, options);
+      if (current.data && current.data.relevance !== void 0 && current.data.relevance > relevance) {
+        relevance = current.data.relevance;
+        result = current;
+      }
+    }
+    return result || {
+      type: "root",
+      children: [],
+      data: { language: void 0, relevance }
+    };
+  }
+  function listLanguages() {
+    return high.listLanguages();
+  }
+  function register(grammarsOrName, grammar) {
+    if (typeof grammarsOrName === "string") {
+      high.registerLanguage(grammarsOrName, grammar);
+    } else {
+      let name;
+      for (name in grammarsOrName) {
+        if (Object.hasOwn(grammarsOrName, name)) {
+          high.registerLanguage(name, grammarsOrName[name]);
+        }
+      }
+    }
+  }
+  function registerAlias(aliasesOrName, alias) {
+    if (typeof aliasesOrName === "string") {
+      high.registerAliases(
+        // Note: copy needed because hljs doesn’t accept readonly arrays yet.
+        typeof alias === "string" ? alias : [...alias],
+        { languageName: aliasesOrName }
+      );
+    } else {
+      let key;
+      for (key in aliasesOrName) {
+        if (Object.hasOwn(aliasesOrName, key)) {
+          const aliases = aliasesOrName[key];
+          high.registerAliases(
+            // Note: copy needed because hljs doesn’t accept readonly arrays yet.
+            typeof aliases === "string" ? aliases : [...aliases],
+            { languageName: key }
+          );
+        }
+      }
+    }
+  }
+  function registered(aliasOrName) {
+    return Boolean(high.getLanguage(aliasOrName));
+  }
+}
+class HastEmitter {
+  /**
+   * @param {Readonly<HljsOptions>} options
+   *   Configuration.
+   * @returns
+   *   Instance.
+   */
+  constructor(options) {
+    this.options = options;
+    this.root = {
+      type: "root",
+      children: [],
+      data: { language: void 0, relevance: 0 }
+    };
+    this.stack = [this.root];
+  }
+  /**
+   * @param {string} value
+   *   Text to add.
+   * @returns {undefined}
+   *   Nothing.
+   *
+   */
+  addText(value) {
+    if (value === "") return;
+    const current = this.stack[this.stack.length - 1];
+    const tail = current.children[current.children.length - 1];
+    if (tail && tail.type === "text") {
+      tail.value += value;
+    } else {
+      current.children.push({ type: "text", value });
+    }
+  }
+  /**
+   *
+   * @param {unknown} rawName
+   *   Name to add.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  startScope(rawName) {
+    this.openNode(String(rawName));
+  }
+  /**
+   * @returns {undefined}
+   *   Nothing.
+   */
+  endScope() {
+    this.closeNode();
+  }
+  /**
+   * @param {HastEmitter} other
+   *   Other emitter.
+   * @param {string} name
+   *   Name of the sublanguage.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  __addSublanguage(other, name) {
+    const current = this.stack[this.stack.length - 1];
+    const results = (
+      /** @type {Array<ElementContent>} */
+      other.root.children
+    );
+    if (name) {
+      current.children.push({
+        type: "element",
+        tagName: "span",
+        properties: { className: [name] },
+        children: results
+      });
+    } else {
+      current.children.push(...results);
+    }
+  }
+  /**
+   * @param {string} name
+   *   Name to add.
+   * @returns {undefined}
+   *   Nothing.
+   */
+  openNode(name) {
+    const self = this;
+    const className = name.split(".").map(function(d, i) {
+      return i ? d + "_".repeat(i) : self.options.classPrefix + d;
+    });
+    const current = this.stack[this.stack.length - 1];
+    const child = {
+      type: "element",
+      tagName: "span",
+      properties: { className },
+      children: []
+    };
+    current.children.push(child);
+    this.stack.push(child);
+  }
+  /**
+   * @returns {undefined}
+   *   Nothing.
+   */
+  closeNode() {
+    this.stack.pop();
+  }
+  /**
+   * @returns {undefined}
+   *   Nothing.
+   */
+  finalize() {
+  }
+  /**
+   * @returns {string}
+   *   Nothing.
+   */
+  toHTML() {
+    return "";
+  }
+}
+export {
+  createLowlight as c,
+  grammars as g
+};

package/dist/server/_libs/markdown-table.mjs

@@ -0,0 +1,142 @@
+function defaultStringLength(value) {
+  return value.length;
+}
+function markdownTable(table, options) {
+  const settings = options || {};
+  const align = (settings.align || []).concat();
+  const stringLength = settings.stringLength || defaultStringLength;
+  const alignments = [];
+  const cellMatrix = [];
+  const sizeMatrix = [];
+  const longestCellByColumn = [];
+  let mostCellsPerRow = 0;
+  let rowIndex = -1;
+  while (++rowIndex < table.length) {
+    const row2 = [];
+    const sizes2 = [];
+    let columnIndex2 = -1;
+    if (table[rowIndex].length > mostCellsPerRow) {
+      mostCellsPerRow = table[rowIndex].length;
+    }
+    while (++columnIndex2 < table[rowIndex].length) {
+      const cell = serialize(table[rowIndex][columnIndex2]);
+      if (settings.alignDelimiters !== false) {
+        const size = stringLength(cell);
+        sizes2[columnIndex2] = size;
+        if (longestCellByColumn[columnIndex2] === void 0 || size > longestCellByColumn[columnIndex2]) {
+          longestCellByColumn[columnIndex2] = size;
+        }
+      }
+      row2.push(cell);
+    }
+    cellMatrix[rowIndex] = row2;
+    sizeMatrix[rowIndex] = sizes2;
+  }
+  let columnIndex = -1;
+  if (typeof align === "object" && "length" in align) {
+    while (++columnIndex < mostCellsPerRow) {
+      alignments[columnIndex] = toAlignment(align[columnIndex]);
+    }
+  } else {
+    const code = toAlignment(align);
+    while (++columnIndex < mostCellsPerRow) {
+      alignments[columnIndex] = code;
+    }
+  }
+  columnIndex = -1;
+  const row = [];
+  const sizes = [];
+  while (++columnIndex < mostCellsPerRow) {
+    const code = alignments[columnIndex];
+    let before = "";
+    let after = "";
+    if (code === 99) {
+      before = ":";
+      after = ":";
+    } else if (code === 108) {
+      before = ":";
+    } else if (code === 114) {
+      after = ":";
+    }
+    let size = settings.alignDelimiters === false ? 1 : Math.max(
+      1,
+      longestCellByColumn[columnIndex] - before.length - after.length
+    );
+    const cell = before + "-".repeat(size) + after;
+    if (settings.alignDelimiters !== false) {
+      size = before.length + size + after.length;
+      if (size > longestCellByColumn[columnIndex]) {
+        longestCellByColumn[columnIndex] = size;
+      }
+      sizes[columnIndex] = size;
+    }
+    row[columnIndex] = cell;
+  }
+  cellMatrix.splice(1, 0, row);
+  sizeMatrix.splice(1, 0, sizes);
+  rowIndex = -1;
+  const lines = [];
+  while (++rowIndex < cellMatrix.length) {
+    const row2 = cellMatrix[rowIndex];
+    const sizes2 = sizeMatrix[rowIndex];
+    columnIndex = -1;
+    const line = [];
+    while (++columnIndex < mostCellsPerRow) {
+      const cell = row2[columnIndex] || "";
+      let before = "";
+      let after = "";
+      if (settings.alignDelimiters !== false) {
+        const size = longestCellByColumn[columnIndex] - (sizes2[columnIndex] || 0);
+        const code = alignments[columnIndex];
+        if (code === 114) {
+          before = " ".repeat(size);
+        } else if (code === 99) {
+          if (size % 2) {
+            before = " ".repeat(size / 2 + 0.5);
+            after = " ".repeat(size / 2 - 0.5);
+          } else {
+            before = " ".repeat(size / 2);
+            after = before;
+          }
+        } else {
+          after = " ".repeat(size);
+        }
+      }
+      if (settings.delimiterStart !== false && !columnIndex) {
+        line.push("|");
+      }
+      if (settings.padding !== false && // Don’t add the opening space if we’re not aligning and the cell is
+      // empty: there will be a closing space.
+      !(settings.alignDelimiters === false && cell === "") && (settings.delimiterStart !== false || columnIndex)) {
+        line.push(" ");
+      }
+      if (settings.alignDelimiters !== false) {
+        line.push(before);
+      }
+      line.push(cell);
+      if (settings.alignDelimiters !== false) {
+        line.push(after);
+      }
+      if (settings.padding !== false) {
+        line.push(" ");
+      }
+      if (settings.delimiterEnd !== false || columnIndex !== mostCellsPerRow - 1) {
+        line.push("|");
+      }
+    }
+    lines.push(
+      settings.delimiterEnd === false ? line.join("").replace(/ +$/, "") : line.join("")
+    );
+  }
+  return lines.join("\n");
+}
+function serialize(value) {
+  return value === null || value === void 0 ? "" : String(value);
+}
+function toAlignment(value) {
+  const code = typeof value === "string" ? value.codePointAt(0) : 0;
+  return code === 67 || code === 99 ? 99 : code === 76 || code === 108 ? 108 : code === 82 || code === 114 ? 114 : 0;
+}
+export {
+  markdownTable as m
+};