hermium 0.1.10 → 0.3.0

package/dist/{web-server → server}/_libs/floating-ui__utils.mjs

@@ -280,43 +280,43 @@ function rectToClientRect(rect) {
   };
 }
 export {
-  rectToClientRect as A,
-  sides as B,
-  getOppositeAxis as C,
-  getOverflowAncestors as D,
-  getDocumentElement as E,
-  createCoords as F,
-  getFrameElement as G,
-  round as H,
-  isTopLayer as I,
-  isTableElement as J,
-  isContainingBlock as K,
-  getContainingBlock as L,
-  getNodeScroll as M,
-  isShadowRoot as a,
-  isHTMLElement as b,
-  isElement as c,
-  getComputedStyle as d,
-  getNodeName as e,
+  isHTMLElement as A,
+  isLastTraversableNode as B,
+  isNode as C,
+  isOverflowElement as D,
+  isShadowRoot as E,
+  isTableElement as F,
+  isTopLayer as G,
+  isWebKit as H,
+  max as I,
+  min as J,
+  rectToClientRect as K,
+  round as L,
+  sides as M,
+  createCoords as a,
+  getAlignmentAxis as b,
+  clamp as c,
+  getAlignmentSides as d,
+  evaluate as e,
   floor as f,
-  getWindow as g,
-  isNode as h,
-  isOverflowElement as i,
-  isWebKit as j,
-  isLastTraversableNode as k,
-  getParentNode as l,
-  evaluate as m,
-  getPaddingObject as n,
-  getAlignmentAxis as o,
-  getAlignment as p,
-  getAxisLength as q,
-  clamp as r,
-  getSide as s,
-  getSideAxis as t,
-  getOppositePlacement as u,
-  getExpandedPlacements as v,
-  getOppositeAxisPlacements as w,
-  getAlignmentSides as x,
-  min as y,
-  max as z
+  getAlignment as g,
+  getAxisLength as h,
+  getComputedStyle as i,
+  getContainingBlock as j,
+  getDocumentElement as k,
+  getExpandedPlacements as l,
+  getFrameElement as m,
+  getNodeName as n,
+  getNodeScroll as o,
+  getOppositeAxis as p,
+  getOppositeAxisPlacements as q,
+  getOppositePlacement as r,
+  getOverflowAncestors as s,
+  getPaddingObject as t,
+  getParentNode as u,
+  getSide as v,
+  getSideAxis as w,
+  getWindow as x,
+  isContainingBlock as y,
+  isElement as z
 };

package/dist/{web-server → server}/_libs/h3.mjs

@@ -399,9 +399,9 @@ var H3Core = class {
   }
 };
 export {
-  HTTPError as H,
-  defineLazyEventHandler as a,
-  H3Core as b,
+  H3Core as H,
+  HTTPError as a,
+  defineLazyEventHandler as b,
   toRequest as c,
   defineHandler as d,
   toEventHandler as t

package/dist/server/_libs/hast-util-is-element.mjs

@@ -0,0 +1,75 @@
+const convertElement = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends TestFunction>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & Predicate<Condition, Element>) &
+   *   (<Condition extends string>(test: Condition) => (element: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element & {tagName: Condition}) &
+   *   ((test?: null | undefined) => (element?: unknown, index?: number | null | undefined, parent?: Parents | null | undefined, context?: unknown) => element is Element) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test | null | undefined} [test]
+   * @returns {Check}
+   */
+  (function(test) {
+    if (test === null || test === void 0) {
+      return element;
+    }
+    if (typeof test === "string") {
+      return tagNameFactory(test);
+    }
+    if (typeof test === "object") {
+      return anyFactory(test);
+    }
+    if (typeof test === "function") {
+      return castFactory(test);
+    }
+    throw new Error("Expected function, string, or array as `test`");
+  })
+);
+function anyFactory(tests) {
+  const checks = [];
+  let index = -1;
+  while (++index < tests.length) {
+    checks[index] = convertElement(tests[index]);
+  }
+  return castFactory(any);
+  function any(...parameters) {
+    let index2 = -1;
+    while (++index2 < checks.length) {
+      if (checks[index2].apply(this, parameters)) return true;
+    }
+    return false;
+  }
+}
+function tagNameFactory(check) {
+  return castFactory(tagName);
+  function tagName(element2) {
+    return element2.tagName === check;
+  }
+}
+function castFactory(testFunction) {
+  return check;
+  function check(value, index, parent) {
+    return Boolean(
+      looksLikeAnElement(value) && testFunction.call(
+        this,
+        value,
+        typeof index === "number" ? index : void 0,
+        parent || void 0
+      )
+    );
+  }
+}
+function element(element2) {
+  return Boolean(
+    element2 && typeof element2 === "object" && "type" in element2 && element2.type === "element" && "tagName" in element2 && typeof element2.tagName === "string"
+  );
+}
+function looksLikeAnElement(value) {
+  return value !== null && typeof value === "object" && "type" in value && "tagName" in value;
+}
+export {
+  convertElement as c
+};

package/dist/{web-server → server}/_libs/hast-util-to-jsx-runtime.mjs

@@ -1,12 +1,12 @@
 import { s as stringify } from "./comma-separated-tokens.mjs";
 import { o as ok } from "./devlop.mjs";
-import { s as svg, h as html, f as find, a as hastToReact } from "./property-information.mjs";
+import { s as svg, a as html, f as find, h as hastToReact } from "./property-information.mjs";
 import { s as stringify$1 } from "./space-separated-tokens.mjs";
 import { s as styleToJs } from "./style-to-js.mjs";
 import { w as whitespace } from "./hast-util-whitespace.mjs";
 import { n as name } from "./estree-util-is-identifier-name.mjs";
 import { V as VFileMessage } from "./vfile-message.mjs";
-import { p as pointStart } from "./unist-util-position.mjs";
+import { a as pointStart } from "./unist-util-position.mjs";
 const own = {}.hasOwnProperty;
 const emptyMap = /* @__PURE__ */ new Map();
 const cap = /[A-Z]/g;

package/dist/server/_libs/hast-util-to-text.mjs

@@ -0,0 +1,305 @@
+import { c as convertElement } from "./hast-util-is-element.mjs";
+import { f as findAfter } from "./unist-util-find-after.mjs";
+const searchLineFeeds = /\n/g;
+const searchTabOrSpaces = /[\t ]+/g;
+const br = convertElement("br");
+const cell = convertElement(isCell);
+const p = convertElement("p");
+const row = convertElement("tr");
+const notRendered = convertElement([
+  // List from: <https://html.spec.whatwg.org/multipage/rendering.html#hidden-elements>
+  "datalist",
+  "head",
+  "noembed",
+  "noframes",
+  "noscript",
+  // Act as if we support scripting.
+  "rp",
+  "script",
+  "style",
+  "template",
+  "title",
+  // Hidden attribute.
+  hidden,
+  // From: <https://html.spec.whatwg.org/multipage/rendering.html#flow-content-3>
+  closedDialog
+]);
+const blockOrCaption = convertElement([
+  "address",
+  // Flow content
+  "article",
+  // Sections and headings
+  "aside",
+  // Sections and headings
+  "blockquote",
+  // Flow content
+  "body",
+  // Page
+  "caption",
+  // `table-caption`
+  "center",
+  // Flow content (legacy)
+  "dd",
+  // Lists
+  "dialog",
+  // Flow content
+  "dir",
+  // Lists (legacy)
+  "dl",
+  // Lists
+  "dt",
+  // Lists
+  "div",
+  // Flow content
+  "figure",
+  // Flow content
+  "figcaption",
+  // Flow content
+  "footer",
+  // Flow content
+  "form,",
+  // Flow content
+  "h1",
+  // Sections and headings
+  "h2",
+  // Sections and headings
+  "h3",
+  // Sections and headings
+  "h4",
+  // Sections and headings
+  "h5",
+  // Sections and headings
+  "h6",
+  // Sections and headings
+  "header",
+  // Flow content
+  "hgroup",
+  // Sections and headings
+  "hr",
+  // Flow content
+  "html",
+  // Page
+  "legend",
+  // Flow content
+  "li",
+  // Lists (as `display: list-item`)
+  "listing",
+  // Flow content (legacy)
+  "main",
+  // Flow content
+  "menu",
+  // Lists
+  "nav",
+  // Sections and headings
+  "ol",
+  // Lists
+  "p",
+  // Flow content
+  "plaintext",
+  // Flow content (legacy)
+  "pre",
+  // Flow content
+  "section",
+  // Sections and headings
+  "ul",
+  // Lists
+  "xmp"
+  // Flow content (legacy)
+]);
+function toText(tree, options) {
+  const options_ = options || {};
+  const children = "children" in tree ? tree.children : [];
+  const block = blockOrCaption(tree);
+  const whitespace = inferWhitespace(tree, {
+    whitespace: options_.whitespace || "normal"
+  });
+  const results = [];
+  if (tree.type === "text" || tree.type === "comment") {
+    results.push(
+      ...collectText(tree, {
+        breakBefore: true,
+        breakAfter: true
+      })
+    );
+  }
+  let index = -1;
+  while (++index < children.length) {
+    results.push(
+      ...renderedTextCollection(
+        children[index],
+        // @ts-expect-error: `tree` is a parent if we’re here.
+        tree,
+        {
+          whitespace,
+          breakBefore: index ? void 0 : block,
+          breakAfter: index < children.length - 1 ? br(children[index + 1]) : block
+        }
+      )
+    );
+  }
+  const result = [];
+  let count;
+  index = -1;
+  while (++index < results.length) {
+    const value = results[index];
+    if (typeof value === "number") {
+      if (count !== void 0 && value > count) count = value;
+    } else if (value) {
+      if (count !== void 0 && count > -1) {
+        result.push("\n".repeat(count) || " ");
+      }
+      count = -1;
+      result.push(value);
+    }
+  }
+  return result.join("");
+}
+function renderedTextCollection(node, parent, info) {
+  if (node.type === "element") {
+    return collectElement(node, parent, info);
+  }
+  if (node.type === "text") {
+    return info.whitespace === "normal" ? collectText(node, info) : collectPreText(node);
+  }
+  return [];
+}
+function collectElement(node, parent, info) {
+  const whitespace = inferWhitespace(node, info);
+  const children = node.children || [];
+  let index = -1;
+  let items = [];
+  if (notRendered(node)) {
+    return items;
+  }
+  let prefix;
+  let suffix;
+  if (br(node)) {
+    suffix = "\n";
+  } else if (row(node) && // @ts-expect-error: something up with types of parents.
+  findAfter(parent, node, row)) {
+    suffix = "\n";
+  } else if (p(node)) {
+    prefix = 2;
+    suffix = 2;
+  } else if (blockOrCaption(node)) {
+    prefix = 1;
+    suffix = 1;
+  }
+  while (++index < children.length) {
+    items = items.concat(
+      renderedTextCollection(children[index], node, {
+        whitespace,
+        breakBefore: index ? void 0 : prefix,
+        breakAfter: index < children.length - 1 ? br(children[index + 1]) : suffix
+      })
+    );
+  }
+  if (cell(node) && // @ts-expect-error: something up with types of parents.
+  findAfter(parent, node, cell)) {
+    items.push("	");
+  }
+  if (prefix) items.unshift(prefix);
+  if (suffix) items.push(suffix);
+  return items;
+}
+function collectText(node, info) {
+  const value = String(node.value);
+  const lines = [];
+  const result = [];
+  let start = 0;
+  while (start <= value.length) {
+    searchLineFeeds.lastIndex = start;
+    const match = searchLineFeeds.exec(value);
+    const end = match && "index" in match ? match.index : value.length;
+    lines.push(
+      // Any sequence of collapsible spaces and tabs immediately preceding or
+      // following a segment break is removed.
+      trimAndCollapseSpacesAndTabs(
+        // […] ignoring bidi formatting characters (characters with the
+        // Bidi_Control property [UAX9]: ALM, LTR, RTL, LRE-RLO, LRI-PDI) as if
+        // they were not there.
+        value.slice(start, end).replace(/[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/g, ""),
+        start === 0 ? info.breakBefore : true,
+        end === value.length ? info.breakAfter : true
+      )
+    );
+    start = end + 1;
+  }
+  let index = -1;
+  let join;
+  while (++index < lines.length) {
+    if (lines[index].charCodeAt(lines[index].length - 1) === 8203 || index < lines.length - 1 && lines[index + 1].charCodeAt(0) === 8203) {
+      result.push(lines[index]);
+      join = void 0;
+    } else if (lines[index]) {
+      if (typeof join === "number") result.push(join);
+      result.push(lines[index]);
+      join = 0;
+    } else if (index === 0 || index === lines.length - 1) {
+      result.push(0);
+    }
+  }
+  return result;
+}
+function collectPreText(node) {
+  return [String(node.value)];
+}
+function trimAndCollapseSpacesAndTabs(value, breakBefore, breakAfter) {
+  const result = [];
+  let start = 0;
+  let end;
+  while (start < value.length) {
+    searchTabOrSpaces.lastIndex = start;
+    const match = searchTabOrSpaces.exec(value);
+    end = match ? match.index : value.length;
+    if (!start && !end && match && !breakBefore) {
+      result.push("");
+    }
+    if (start !== end) {
+      result.push(value.slice(start, end));
+    }
+    start = match ? end + match[0].length : end;
+  }
+  if (start !== end && !breakAfter) {
+    result.push("");
+  }
+  return result.join(" ");
+}
+function inferWhitespace(node, info) {
+  if (node.type === "element") {
+    const properties = node.properties || {};
+    switch (node.tagName) {
+      case "listing":
+      case "plaintext":
+      case "xmp": {
+        return "pre";
+      }
+      case "nobr": {
+        return "nowrap";
+      }
+      case "pre": {
+        return properties.wrap ? "pre-wrap" : "pre";
+      }
+      case "td":
+      case "th": {
+        return properties.noWrap ? "nowrap" : info.whitespace;
+      }
+      case "textarea": {
+        return "pre-wrap";
+      }
+    }
+  }
+  return info.whitespace;
+}
+function hidden(node) {
+  return Boolean((node.properties || {}).hidden);
+}
+function isCell(node) {
+  return node.tagName === "td" || node.tagName === "th";
+}
+function closedDialog(node) {
+  return node.tagName === "dialog" && !(node.properties || {}).open;
+}
+export {
+  toText as t
+};