@oxide/design-system 1.7.6 → 1.7.7--canary.87d60df.0

package/components/dist/index.js

@@ -1,126 +1,3740 @@
+import {
+  version
+} from "./chunk-YGFBWU2Q.js";
+import {
+  selectSvgElement
+} from "./chunk-TG4YEU4Q.js";
+import {
+  JSON_SCHEMA,
+  load
+} from "./chunk-WDK4G4UR.js";
+import {
+  registerLayoutLoaders
+} from "./chunk-WLVQWTC6.js";
+import "./chunk-ND3FLKHU.js";
+import "./chunk-LQ2ABR7F.js";
+import "./chunk-BW7DFBOS.js";
+import "./chunk-M6L3MM6K.js";
+import {
+  registerIconPacks
+} from "./chunk-H72D3HRR.js";
+import {
+  dedent
+} from "./chunk-NIVHLOPB.js";
+import {
+  cleanAndMerge,
+  decodeEntities,
+  encodeEntities,
+  isDetailedError,
+  removeDirectives,
+  utils_default
+} from "./chunk-T7HPDS4Z.js";
+import "./chunk-7I5DT373.js";
+import {
+  UnknownDiagramError,
+  __name,
+  addDirective,
+  assignWithDepth_default,
+  configureSvgSize,
+  defaultConfig,
+  detectType,
+  detectors,
+  evaluate,
+  frontMatterRegex,
+  getConfig,
+  getDiagram,
+  getDiagramLoader,
+  getSiteConfig,
+  log,
+  purify,
+  registerDiagram,
+  registerLazyLoadedDiagrams,
+  reset,
+  saveConfigFromInitialize,
+  select_default,
+  setConfig,
+  setLogLevel,
+  setSiteConfig,
+  styles_default,
+  themes_default,
+  updateSiteConfig
+} from "./chunk-RWDBBMDN.js";
+import {
+  isEmpty_default
+} from "./chunk-BVYAEHG3.js";
+import "./chunk-562WOS3Z.js";
+import "./chunk-K532NZMW.js";
+
+// components/src/asciidoc/index.tsx
+import asciidoctor2 from "@asciidoctor/core";
+import { Content as Content4 } from "@oxide/react-asciidoc";
+
 // components/src/asciidoc/Admonition.tsx
 import { Content, Title, parse } from "@oxide/react-asciidoc";
 
-// components/src/utils.ts
-import cn from "classnames";
-import { createElement } from "react";
-var titleCase = (text) => {
-  return text.replace(
-    /\w\S*/g,
-    (text2) => text2.charAt(0).toUpperCase() + text2.substring(1).toLowerCase()
-  );
+// components/src/utils.ts
+import cn from "classnames";
+import { createElement } from "react";
+var titleCase = (text) => {
+  return text.replace(
+    /\w\S*/g,
+    (text2) => text2.charAt(0).toUpperCase() + text2.substring(1).toLowerCase()
+  );
+};
+var make = (tag) => (
+  // only one argument here means string interpolations are not allowed
+  (strings) => {
+    const Comp = ({ className, children, ...rest }) => createElement(tag, { className: cn(strings[0], className), ...rest }, children);
+    Comp.displayName = `classed.${tag}`;
+    return Comp;
+  }
+);
+var classed = {
+  button: make("button"),
+  div: make("div"),
+  h1: make("h1"),
+  h2: make("h2"),
+  h3: make("h3"),
+  h4: make("h4"),
+  hr: make("hr"),
+  header: make("header"),
+  input: make("input"),
+  label: make("label"),
+  li: make("li"),
+  main: make("main"),
+  ol: make("ol"),
+  p: make("p"),
+  span: make("span"),
+  table: make("table"),
+  tbody: make("tbody"),
+  td: make("td"),
+  th: make("th"),
+  tr: make("tr")
+};
+
+// components/src/asciidoc/Admonition.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var Admonition = ({ node: node2 }) => {
+  const attrs2 = node2.attributes;
+  let icon;
+  if (attrs2.name === "caution") {
+    icon = /* @__PURE__ */ jsx(Error12, {});
+  } else if (attrs2.name === "warning") {
+    icon = /* @__PURE__ */ jsx(Warning12, {});
+  } else {
+    icon = /* @__PURE__ */ jsx(Error12, { className: "rotate-180" });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: `admonitionblock ${attrs2.name}`, children: [
+    /* @__PURE__ */ jsx("div", { className: "admonition-icon", children: icon }),
+    /* @__PURE__ */ jsxs("div", { className: "admonition-content content", children: [
+      /* @__PURE__ */ jsx(Title, { text: node2.title }),
+      /* @__PURE__ */ jsx("div", { children: titleCase(attrs2.name.toString()) }),
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx(Title, { text: node2.title }),
+        node2.content && parse(node2.content),
+        /* @__PURE__ */ jsx(Content, { blocks: node2.blocks })
+      ] })
+    ] })
+  ] });
+};
+var Error12 = ({ className }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: "12",
+    height: "12",
+    viewBox: "0 0 12 12",
+    xmlns: "http://www.w3.org/2000/svg",
+    className,
+    children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        fillRule: "evenodd",
+        clipRule: "evenodd",
+        d: "M6 12A6 6 0 1 0 6 0a6 6 0 0 0 0 12Zm.083-9c.368 0 .667.299.667.667v2.666A.667.667 0 0 1 6.083 7h-.166a.667.667 0 0 1-.667-.667V3.667c0-.368.299-.667.667-.667h.166Zm0 5c.368 0 .667.299.667.667v.166a.667.667 0 0 1-.667.667h-.166a.667.667 0 0 1-.667-.667v-.166c0-.368.299-.667.667-.667h.166Z",
+        fill: "currentColor"
+      }
+    )
+  }
+);
+var Warning12 = ({ className }) => /* @__PURE__ */ jsx(
+  "svg",
+  {
+    width: "12",
+    height: "12",
+    viewBox: "0 0 12 12",
+    xmlns: "http://www.w3.org/2000/svg",
+    className,
+    children: /* @__PURE__ */ jsx(
+      "path",
+      {
+        fillRule: "evenodd",
+        clipRule: "evenodd",
+        d: "M6 12A6 6 0 1 0 6 0a6 6 0 0 0 0 12Zm.083-9c.368 0 .667.299.667.667v2.666A.667.667 0 0 1 6.083 7h-.166a.667.667 0 0 1-.667-.667V3.667c0-.368.299-.667.667-.667h.166Zm0 5c.368 0 .667.299.667.667v.166a.667.667 0 0 1-.667.667h-.166a.667.667 0 0 1-.667-.667v-.166c0-.368.299-.667.667-.667h.166Z",
+        fill: "currentColor"
+      }
+    )
+  }
+);
+var Admonition_default = Admonition;
+
+// node_modules/stylis/src/Enum.js
+var COMMENT = "comm";
+var RULESET = "rule";
+var DECLARATION = "decl";
+var IMPORT = "@import";
+var KEYFRAMES = "@keyframes";
+var LAYER = "@layer";
+
+// node_modules/stylis/src/Utility.js
+var abs = Math.abs;
+var from = String.fromCharCode;
+function trim(value) {
+  return value.trim();
+}
+function replace(value, pattern, replacement) {
+  return value.replace(pattern, replacement);
+}
+function indexof(value, search, position2) {
+  return value.indexOf(search, position2);
+}
+function charat(value, index) {
+  return value.charCodeAt(index) | 0;
+}
+function substr(value, begin, end) {
+  return value.slice(begin, end);
+}
+function strlen(value) {
+  return value.length;
+}
+function sizeof(value) {
+  return value.length;
+}
+function append(value, array) {
+  return array.push(value), value;
+}
+
+// node_modules/stylis/src/Tokenizer.js
+var line = 1;
+var column = 1;
+var length = 0;
+var position = 0;
+var character = 0;
+var characters = "";
+function node(value, root, parent, type, props, children, length2, siblings) {
+  return { value, root, parent, type, props, children, line, column, length: length2, return: "", siblings };
+}
+function char() {
+  return character;
+}
+function prev() {
+  character = position > 0 ? charat(characters, --position) : 0;
+  if (column--, character === 10)
+    column = 1, line--;
+  return character;
+}
+function next() {
+  character = position < length ? charat(characters, position++) : 0;
+  if (column++, character === 10)
+    column = 1, line++;
+  return character;
+}
+function peek() {
+  return charat(characters, position);
+}
+function caret() {
+  return position;
+}
+function slice(begin, end) {
+  return substr(characters, begin, end);
+}
+function token(type) {
+  switch (type) {
+    case 0:
+    case 9:
+    case 10:
+    case 13:
+    case 32:
+      return 5;
+    case 33:
+    case 43:
+    case 44:
+    case 47:
+    case 62:
+    case 64:
+    case 126:
+    case 59:
+    case 123:
+    case 125:
+      return 4;
+    case 58:
+      return 3;
+    case 34:
+    case 39:
+    case 40:
+    case 91:
+      return 2;
+    case 41:
+    case 93:
+      return 1;
+  }
+  return 0;
+}
+function alloc(value) {
+  return line = column = 1, length = strlen(characters = value), position = 0, [];
+}
+function dealloc(value) {
+  return characters = "", value;
+}
+function delimit(type) {
+  return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)));
+}
+function whitespace(type) {
+  while (character = peek())
+    if (character < 33)
+      next();
+    else
+      break;
+  return token(type) > 2 || token(character) > 3 ? "" : " ";
+}
+function escaping(index, count) {
+  while (--count && next())
+    if (character < 48 || character > 102 || character > 57 && character < 65 || character > 70 && character < 97)
+      break;
+  return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32));
+}
+function delimiter(type) {
+  while (next())
+    switch (character) {
+      case type:
+        return position;
+      case 34:
+      case 39:
+        if (type !== 34 && type !== 39)
+          delimiter(character);
+        break;
+      case 40:
+        if (type === 41)
+          delimiter(type);
+        break;
+      case 92:
+        next();
+        break;
+    }
+  return position;
+}
+function commenter(type, index) {
+  while (next())
+    if (type + character === 47 + 10)
+      break;
+    else if (type + character === 42 + 42 && peek() === 47)
+      break;
+  return "/*" + slice(index, position - 1) + "*" + from(type === 47 ? type : next());
+}
+function identifier(index) {
+  while (!token(peek()))
+    next();
+  return slice(index, position);
+}
+
+// node_modules/stylis/src/Parser.js
+function compile(value) {
+  return dealloc(parse2("", null, null, null, [""], value = alloc(value), 0, [0], value));
+}
+function parse2(value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
+  var index = 0;
+  var offset2 = 0;
+  var length2 = pseudo;
+  var atrule = 0;
+  var property = 0;
+  var previous = 0;
+  var variable = 1;
+  var scanning = 1;
+  var ampersand = 1;
+  var character2 = 0;
+  var type = "";
+  var props = rules;
+  var children = rulesets;
+  var reference = rule;
+  var characters2 = type;
+  while (scanning)
+    switch (previous = character2, character2 = next()) {
+      case 40:
+        if (previous != 108 && charat(characters2, length2 - 1) == 58) {
+          if (indexof(characters2 += replace(delimit(character2), "&", "&\f"), "&\f", abs(index ? points[index - 1] : 0)) != -1)
+            ampersand = -1;
+          break;
+        }
+      case 34:
+      case 39:
+      case 91:
+        characters2 += delimit(character2);
+        break;
+      case 9:
+      case 10:
+      case 13:
+      case 32:
+        characters2 += whitespace(previous);
+        break;
+      case 92:
+        characters2 += escaping(caret() - 1, 7);
+        continue;
+      case 47:
+        switch (peek()) {
+          case 42:
+          case 47:
+            append(comment(commenter(next(), caret()), root, parent, declarations), declarations);
+            if ((token(previous || 1) == 5 || token(peek() || 1) == 5) && strlen(characters2) && substr(characters2, -1, void 0) !== " ")
+              characters2 += " ";
+            break;
+          default:
+            characters2 += "/";
+        }
+        break;
+      case 123 * variable:
+        points[index++] = strlen(characters2) * ampersand;
+      case 125 * variable:
+      case 59:
+      case 0:
+        switch (character2) {
+          case 0:
+          case 125:
+            scanning = 0;
+          case 59 + offset2:
+            if (ampersand == -1)
+              characters2 = replace(characters2, /\f/g, "");
+            if (property > 0 && (strlen(characters2) - length2 || variable === 0 && previous === 47))
+              append(property > 32 ? declaration(characters2 + ";", rule, parent, length2 - 1, declarations) : declaration(replace(characters2, " ", "") + ";", rule, parent, length2 - 2, declarations), declarations);
+            break;
+          case 59:
+            characters2 += ";";
+          default:
+            append(reference = ruleset(characters2, root, parent, index, offset2, rules, points, type, props = [], children = [], length2, rulesets), rulesets);
+            if (character2 === 123)
+              if (offset2 === 0)
+                parse2(characters2, root, reference, reference, props, rulesets, length2, points, children);
+              else
+                switch (atrule === 99 && charat(characters2, 3) === 110 ? 100 : atrule) {
+                  case 100:
+                  case 108:
+                  case 109:
+                  case 115:
+                    parse2(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length2, children), children), rules, children, length2, points, rule ? props : children);
+                    break;
+                  default:
+                    parse2(characters2, reference, reference, reference, [""], children, 0, points, children);
+                }
+        }
+        index = offset2 = property = 0, variable = ampersand = 1, type = characters2 = "", length2 = pseudo;
+        break;
+      case 58:
+        length2 = 1 + strlen(characters2), property = previous;
+      default:
+        if (variable < 1) {
+          if (character2 == 123)
+            --variable;
+          else if (character2 == 125 && variable++ == 0 && prev() == 125)
+            continue;
+        }
+        switch (characters2 += from(character2), character2 * variable) {
+          case 38:
+            ampersand = offset2 > 0 ? 1 : (characters2 += "\f", -1);
+            break;
+          case 44:
+            points[index++] = (strlen(characters2) - 1) * ampersand, ampersand = 1;
+            break;
+          case 64:
+            if (peek() === 45)
+              characters2 += delimit(next());
+            atrule = peek(), offset2 = length2 = strlen(type = characters2 += identifier(caret())), character2++;
+            break;
+          case 45:
+            if (previous === 45 && strlen(characters2) == 2)
+              variable = 0;
+        }
+    }
+  return rulesets;
+}
+function ruleset(value, root, parent, index, offset2, rules, points, type, props, children, length2, siblings) {
+  var post = offset2 - 1;
+  var rule = offset2 === 0 ? rules : [""];
+  var size2 = sizeof(rule);
+  for (var i = 0, j = 0, k = 0; i < index; ++i)
+    for (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size2; ++x)
+      if (z = trim(j > 0 ? rule[x] + " " + y : replace(y, /&\f/g, rule[x])))
+        props[k++] = z;
+  return node(value, root, parent, offset2 === 0 ? RULESET : type, props, children, length2, siblings);
+}
+function comment(value, root, parent, siblings) {
+  return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0, siblings);
+}
+function declaration(value, root, parent, length2, siblings) {
+  return node(value, root, parent, DECLARATION, substr(value, 0, length2), substr(value, length2 + 1, -1), length2, siblings);
+}
+
+// node_modules/stylis/src/Serializer.js
+function serialize(children, callback) {
+  var output = "";
+  for (var i = 0; i < children.length; i++)
+    output += callback(children[i], i, children, callback) || "";
+  return output;
+}
+function stringify(element, index, children, callback) {
+  switch (element.type) {
+    case LAYER:
+      if (element.children.length)
+        break;
+    case IMPORT:
+    case DECLARATION:
+      return element.return = element.return || element.value;
+    case COMMENT:
+      return "";
+    case KEYFRAMES:
+      return element.return = element.value + "{" + serialize(element.children, callback) + "}";
+    case RULESET:
+      if (!strlen(element.value = element.props.join(",")))
+        return "";
+  }
+  return strlen(children = serialize(element.children, callback)) ? element.return = element.value + "{" + children + "}" : "";
+}
+
+// node_modules/mermaid/dist/mermaid.core.mjs
+var id = "c4";
+var detector = /* @__PURE__ */ __name((txt) => {
+  return /^\s*C4Context|C4Container|C4Component|C4Dynamic|C4Deployment/.test(txt);
+}, "detector");
+var loader = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./c4Diagram-6F5ED5ID-TBHFK2XY.js");
+  return { id, diagram: diagram2 };
+}, "loader");
+var plugin = {
+  id,
+  detector,
+  loader
+};
+var c4Detector_default = plugin;
+var id2 = "flowchart";
+var detector2 = /* @__PURE__ */ __name((txt, config) => {
+  if (config?.flowchart?.defaultRenderer === "dagre-wrapper" || config?.flowchart?.defaultRenderer === "elk") {
+    return false;
+  }
+  return /^\s*graph/.test(txt);
+}, "detector");
+var loader2 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./flowDiagram-7ASYPVHJ-2542732I.js");
+  return { id: id2, diagram: diagram2 };
+}, "loader");
+var plugin2 = {
+  id: id2,
+  detector: detector2,
+  loader: loader2
+};
+var flowDetector_default = plugin2;
+var id3 = "flowchart-v2";
+var detector3 = /* @__PURE__ */ __name((txt, config) => {
+  if (config?.flowchart?.defaultRenderer === "dagre-d3") {
+    return false;
+  }
+  if (config?.flowchart?.defaultRenderer === "elk") {
+    config.layout = "elk";
+  }
+  if (/^\s*graph/.test(txt) && config?.flowchart?.defaultRenderer === "dagre-wrapper") {
+    return true;
+  }
+  return /^\s*flowchart/.test(txt);
+}, "detector");
+var loader3 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./flowDiagram-7ASYPVHJ-2542732I.js");
+  return { id: id3, diagram: diagram2 };
+}, "loader");
+var plugin3 = {
+  id: id3,
+  detector: detector3,
+  loader: loader3
+};
+var flowDetector_v2_default = plugin3;
+var id4 = "er";
+var detector4 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*erDiagram/.test(txt);
+}, "detector");
+var loader4 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./erDiagram-6RL3IURR-HQULDVJI.js");
+  return { id: id4, diagram: diagram2 };
+}, "loader");
+var plugin4 = {
+  id: id4,
+  detector: detector4,
+  loader: loader4
+};
+var erDetector_default = plugin4;
+var id5 = "gitGraph";
+var detector5 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*gitGraph/.test(txt);
+}, "detector");
+var loader5 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./gitGraphDiagram-NRZ2UAAF-5DU6QMYZ.js");
+  return { id: id5, diagram: diagram2 };
+}, "loader");
+var plugin5 = {
+  id: id5,
+  detector: detector5,
+  loader: loader5
+};
+var gitGraphDetector_default = plugin5;
+var id6 = "gantt";
+var detector6 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*gantt/.test(txt);
+}, "detector");
+var loader6 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./ganttDiagram-NTVNEXSI-V66YQQB3.js");
+  return { id: id6, diagram: diagram2 };
+}, "loader");
+var plugin6 = {
+  id: id6,
+  detector: detector6,
+  loader: loader6
+};
+var ganttDetector_default = plugin6;
+var id7 = "info";
+var detector7 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*info/.test(txt);
+}, "detector");
+var loader7 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./infoDiagram-A4XQUW5V-UZERSQDI.js");
+  return { id: id7, diagram: diagram2 };
+}, "loader");
+var info = {
+  id: id7,
+  detector: detector7,
+  loader: loader7
+};
+var id8 = "pie";
+var detector8 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*pie/.test(txt);
+}, "detector");
+var loader8 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./pieDiagram-YF2LJOPJ-IXEVHPCM.js");
+  return { id: id8, diagram: diagram2 };
+}, "loader");
+var pie = {
+  id: id8,
+  detector: detector8,
+  loader: loader8
+};
+var id9 = "quadrantChart";
+var detector9 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*quadrantChart/.test(txt);
+}, "detector");
+var loader9 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./quadrantDiagram-OS5C2QUG-MW26UCZV.js");
+  return { id: id9, diagram: diagram2 };
+}, "loader");
+var plugin7 = {
+  id: id9,
+  detector: detector9,
+  loader: loader9
+};
+var quadrantDetector_default = plugin7;
+var id10 = "xychart";
+var detector10 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*xychart-beta/.test(txt);
+}, "detector");
+var loader10 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./xychartDiagram-6QU3TZC5-BFFLEHUP.js");
+  return { id: id10, diagram: diagram2 };
+}, "loader");
+var plugin8 = {
+  id: id10,
+  detector: detector10,
+  loader: loader10
+};
+var xychartDetector_default = plugin8;
+var id11 = "requirement";
+var detector11 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*requirement(Diagram)?/.test(txt);
+}, "detector");
+var loader11 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./requirementDiagram-MIRIMTAZ-BX24AAHL.js");
+  return { id: id11, diagram: diagram2 };
+}, "loader");
+var plugin9 = {
+  id: id11,
+  detector: detector11,
+  loader: loader11
+};
+var requirementDetector_default = plugin9;
+var id12 = "sequence";
+var detector12 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*sequenceDiagram/.test(txt);
+}, "detector");
+var loader12 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./sequenceDiagram-G6AWOVSC-2T3JBUZ2.js");
+  return { id: id12, diagram: diagram2 };
+}, "loader");
+var plugin10 = {
+  id: id12,
+  detector: detector12,
+  loader: loader12
+};
+var sequenceDetector_default = plugin10;
+var id13 = "class";
+var detector13 = /* @__PURE__ */ __name((txt, config) => {
+  if (config?.class?.defaultRenderer === "dagre-wrapper") {
+    return false;
+  }
+  return /^\s*classDiagram/.test(txt);
+}, "detector");
+var loader13 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./classDiagram-LNE6IOMH-VRQHEQWM.js");
+  return { id: id13, diagram: diagram2 };
+}, "loader");
+var plugin11 = {
+  id: id13,
+  detector: detector13,
+  loader: loader13
+};
+var classDetector_default = plugin11;
+var id14 = "classDiagram";
+var detector14 = /* @__PURE__ */ __name((txt, config) => {
+  if (/^\s*classDiagram/.test(txt) && config?.class?.defaultRenderer === "dagre-wrapper") {
+    return true;
+  }
+  return /^\s*classDiagram-v2/.test(txt);
+}, "detector");
+var loader14 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./classDiagram-v2-MQ7JQ4JX-5GB4NXXM.js");
+  return { id: id14, diagram: diagram2 };
+}, "loader");
+var plugin12 = {
+  id: id14,
+  detector: detector14,
+  loader: loader14
+};
+var classDetector_V2_default = plugin12;
+var id15 = "state";
+var detector15 = /* @__PURE__ */ __name((txt, config) => {
+  if (config?.state?.defaultRenderer === "dagre-wrapper") {
+    return false;
+  }
+  return /^\s*stateDiagram/.test(txt);
+}, "detector");
+var loader15 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./stateDiagram-MAYHULR4-HZ5EGLPA.js");
+  return { id: id15, diagram: diagram2 };
+}, "loader");
+var plugin13 = {
+  id: id15,
+  detector: detector15,
+  loader: loader15
+};
+var stateDetector_default = plugin13;
+var id16 = "stateDiagram";
+var detector16 = /* @__PURE__ */ __name((txt, config) => {
+  if (/^\s*stateDiagram-v2/.test(txt)) {
+    return true;
+  }
+  if (/^\s*stateDiagram/.test(txt) && config?.state?.defaultRenderer === "dagre-wrapper") {
+    return true;
+  }
+  return false;
+}, "detector");
+var loader16 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./stateDiagram-v2-4JROLMXI-DN2FEZV3.js");
+  return { id: id16, diagram: diagram2 };
+}, "loader");
+var plugin14 = {
+  id: id16,
+  detector: detector16,
+  loader: loader16
+};
+var stateDetector_V2_default = plugin14;
+var id17 = "journey";
+var detector17 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*journey/.test(txt);
+}, "detector");
+var loader17 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./journeyDiagram-G5WM74LC-RVKMRGRW.js");
+  return { id: id17, diagram: diagram2 };
+}, "loader");
+var plugin15 = {
+  id: id17,
+  detector: detector17,
+  loader: loader17
+};
+var journeyDetector_default = plugin15;
+var draw = /* @__PURE__ */ __name((_text, id26, version2) => {
+  log.debug("rendering svg for syntax error\n");
+  const svg = selectSvgElement(id26);
+  const g = svg.append("g");
+  svg.attr("viewBox", "0 0 2412 512");
+  configureSvgSize(svg, 100, 512, true);
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m411.313,123.313c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32-9.375,9.375-20.688-20.688c-12.484-12.5-32.766-12.5-45.25,0l-16,16c-1.261,1.261-2.304,2.648-3.31,4.051-21.739-8.561-45.324-13.426-70.065-13.426-105.867,0-192,86.133-192,192s86.133,192 192,192 192-86.133 192-192c0-24.741-4.864-48.327-13.426-70.065 1.402-1.007 2.79-2.049 4.051-3.31l16-16c12.5-12.492 12.5-32.758 0-45.25l-20.688-20.688 9.375-9.375 32.001-31.999zm-219.313,100.687c-52.938,0-96,43.063-96,96 0,8.836-7.164,16-16,16s-16-7.164-16-16c0-70.578 57.422-128 128-128 8.836,0 16,7.164 16,16s-7.164,16-16,16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m459.02,148.98c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l16,16c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16.001-16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m340.395,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16-16c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l15.999,16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m400,64c8.844,0 16-7.164 16-16v-32c0-8.836-7.156-16-16-16-8.844,0-16,7.164-16,16v32c0,8.836 7.156,16 16,16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m496,96.586h-32c-8.844,0-16,7.164-16,16 0,8.836 7.156,16 16,16h32c8.844,0 16-7.164 16-16 0-8.836-7.156-16-16-16z"
+  );
+  g.append("path").attr("class", "error-icon").attr(
+    "d",
+    "m436.98,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688l32-32c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32c-6.251,6.25-6.251,16.375-0.001,22.625z"
+  );
+  g.append("text").attr("class", "error-text").attr("x", 1440).attr("y", 250).attr("font-size", "150px").style("text-anchor", "middle").text("Syntax error in text");
+  g.append("text").attr("class", "error-text").attr("x", 1250).attr("y", 400).attr("font-size", "100px").style("text-anchor", "middle").text(`mermaid version ${version2}`);
+}, "draw");
+var renderer = { draw };
+var errorRenderer_default = renderer;
+var diagram = {
+  db: {},
+  renderer,
+  parser: {
+    parse: /* @__PURE__ */ __name(() => {
+      return;
+    }, "parse")
+  }
+};
+var errorDiagram_default = diagram;
+var id18 = "flowchart-elk";
+var detector18 = /* @__PURE__ */ __name((txt, config = {}) => {
+  if (
+    // If diagram explicitly states flowchart-elk
+    /^\s*flowchart-elk/.test(txt) || // If a flowchart/graph diagram has their default renderer set to elk
+    /^\s*flowchart|graph/.test(txt) && config?.flowchart?.defaultRenderer === "elk"
+  ) {
+    config.layout = "elk";
+    return true;
+  }
+  return false;
+}, "detector");
+var loader18 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./flowDiagram-7ASYPVHJ-2542732I.js");
+  return { id: id18, diagram: diagram2 };
+}, "loader");
+var plugin16 = {
+  id: id18,
+  detector: detector18,
+  loader: loader18
+};
+var detector_default = plugin16;
+var id19 = "timeline";
+var detector19 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*timeline/.test(txt);
+}, "detector");
+var loader19 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./timeline-definition-U7ZMHBDA-GB6AKKW4.js");
+  return { id: id19, diagram: diagram2 };
+}, "loader");
+var plugin17 = {
+  id: id19,
+  detector: detector19,
+  loader: loader19
+};
+var detector_default2 = plugin17;
+var id20 = "mindmap";
+var detector20 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*mindmap/.test(txt);
+}, "detector");
+var loader20 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./mindmap-definition-GWI6TPTV-MISEH6LG.js");
+  return { id: id20, diagram: diagram2 };
+}, "loader");
+var plugin18 = {
+  id: id20,
+  detector: detector20,
+  loader: loader20
+};
+var detector_default3 = plugin18;
+var id21 = "kanban";
+var detector21 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*kanban/.test(txt);
+}, "detector");
+var loader21 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./kanban-definition-QRCXZQQD-NWU5I3TK.js");
+  return { id: id21, diagram: diagram2 };
+}, "loader");
+var plugin19 = {
+  id: id21,
+  detector: detector21,
+  loader: loader21
+};
+var detector_default4 = plugin19;
+var id22 = "sankey";
+var detector22 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*sankey-beta/.test(txt);
+}, "detector");
+var loader22 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./sankeyDiagram-Y46BX6SQ-5RKUGG63.js");
+  return { id: id22, diagram: diagram2 };
+}, "loader");
+var plugin20 = {
+  id: id22,
+  detector: detector22,
+  loader: loader22
+};
+var sankeyDetector_default = plugin20;
+var id23 = "packet";
+var detector23 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*packet-beta/.test(txt);
+}, "detector");
+var loader23 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./diagram-QW4FP2JN-J2YMUPB5.js");
+  return { id: id23, diagram: diagram2 };
+}, "loader");
+var packet = {
+  id: id23,
+  detector: detector23,
+  loader: loader23
+};
+var id24 = "block";
+var detector24 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*block-beta/.test(txt);
+}, "detector");
+var loader24 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./blockDiagram-ZHA2E4KO-OAYYKCLF.js");
+  return { id: id24, diagram: diagram2 };
+}, "loader");
+var plugin21 = {
+  id: id24,
+  detector: detector24,
+  loader: loader24
+};
+var blockDetector_default = plugin21;
+var id25 = "architecture";
+var detector25 = /* @__PURE__ */ __name((txt) => {
+  return /^\s*architecture/.test(txt);
+}, "detector");
+var loader25 = /* @__PURE__ */ __name(async () => {
+  const { diagram: diagram2 } = await import("./architectureDiagram-UYN6MBPD-HXPGIDN7.js");
+  return { id: id25, diagram: diagram2 };
+}, "loader");
+var architecture = {
+  id: id25,
+  detector: detector25,
+  loader: loader25
+};
+var architectureDetector_default = architecture;
+var hasLoadedDiagrams = false;
+var addDiagrams = /* @__PURE__ */ __name(() => {
+  if (hasLoadedDiagrams) {
+    return;
+  }
+  hasLoadedDiagrams = true;
+  registerDiagram("error", errorDiagram_default, (text) => {
+    return text.toLowerCase().trim() === "error";
+  });
+  registerDiagram(
+    "---",
+    // --- diagram type may appear if YAML front-matter is not parsed correctly
+    {
+      db: {
+        clear: /* @__PURE__ */ __name(() => {
+        }, "clear")
+      },
+      styles: {},
+      // should never be used
+      renderer: {
+        draw: /* @__PURE__ */ __name(() => {
+        }, "draw")
+      },
+      parser: {
+        parse: /* @__PURE__ */ __name(() => {
+          throw new Error(
+            "Diagrams beginning with --- are not valid. If you were trying to use a YAML front-matter, please ensure that you've correctly opened and closed the YAML front-matter with un-indented `---` blocks"
+          );
+        }, "parse")
+      },
+      init: /* @__PURE__ */ __name(() => null, "init")
+      // no op
+    },
+    (text) => {
+      return text.toLowerCase().trimStart().startsWith("---");
+    }
+  );
+  registerLazyLoadedDiagrams(
+    c4Detector_default,
+    detector_default4,
+    classDetector_V2_default,
+    classDetector_default,
+    erDetector_default,
+    ganttDetector_default,
+    info,
+    pie,
+    requirementDetector_default,
+    sequenceDetector_default,
+    detector_default,
+    flowDetector_v2_default,
+    flowDetector_default,
+    detector_default3,
+    detector_default2,
+    gitGraphDetector_default,
+    stateDetector_V2_default,
+    stateDetector_default,
+    journeyDetector_default,
+    quadrantDetector_default,
+    sankeyDetector_default,
+    packet,
+    xychartDetector_default,
+    blockDetector_default,
+    architectureDetector_default
+  );
+}, "addDiagrams");
+var loadRegisteredDiagrams = /* @__PURE__ */ __name(async () => {
+  log.debug(`Loading registered diagrams`);
+  const results = await Promise.allSettled(
+    Object.entries(detectors).map(async ([key, { detector: detector26, loader: loader26 }]) => {
+      if (loader26) {
+        try {
+          getDiagram(key);
+        } catch {
+          try {
+            const { diagram: diagram2, id: id26 } = await loader26();
+            registerDiagram(id26, diagram2, detector26);
+          } catch (err) {
+            log.error(`Failed to load external diagram with key ${key}. Removing from detectors.`);
+            delete detectors[key];
+            throw err;
+          }
+        }
+      }
+    })
+  );
+  const failed = results.filter((result) => result.status === "rejected");
+  if (failed.length > 0) {
+    log.error(`Failed to load ${failed.length} external diagrams`);
+    for (const res of failed) {
+      log.error(res);
+    }
+    throw new Error(`Failed to load ${failed.length} external diagrams`);
+  }
+}, "loadRegisteredDiagrams");
+var SVG_ROLE = "graphics-document document";
+function setA11yDiagramInfo(svg, diagramType) {
+  svg.attr("role", SVG_ROLE);
+  if (diagramType !== "") {
+    svg.attr("aria-roledescription", diagramType);
+  }
+}
+__name(setA11yDiagramInfo, "setA11yDiagramInfo");
+function addSVGa11yTitleDescription(svg, a11yTitle, a11yDesc, baseId) {
+  if (svg.insert === void 0) {
+    return;
+  }
+  if (a11yDesc) {
+    const descId = `chart-desc-${baseId}`;
+    svg.attr("aria-describedby", descId);
+    svg.insert("desc", ":first-child").attr("id", descId).text(a11yDesc);
+  }
+  if (a11yTitle) {
+    const titleId = `chart-title-${baseId}`;
+    svg.attr("aria-labelledby", titleId);
+    svg.insert("title", ":first-child").attr("id", titleId).text(a11yTitle);
+  }
+}
+__name(addSVGa11yTitleDescription, "addSVGa11yTitleDescription");
+var Diagram = class _Diagram {
+  constructor(type, text, db, parser, renderer2) {
+    this.type = type;
+    this.text = text;
+    this.db = db;
+    this.parser = parser;
+    this.renderer = renderer2;
+  }
+  static {
+    __name(this, "Diagram");
+  }
+  static async fromText(text, metadata = {}) {
+    const config = getConfig();
+    const type = detectType(text, config);
+    text = encodeEntities(text) + "\n";
+    try {
+      getDiagram(type);
+    } catch {
+      const loader26 = getDiagramLoader(type);
+      if (!loader26) {
+        throw new UnknownDiagramError(`Diagram ${type} not found.`);
+      }
+      const { id: id26, diagram: diagram2 } = await loader26();
+      registerDiagram(id26, diagram2);
+    }
+    const { db, parser, renderer: renderer2, init: init2 } = getDiagram(type);
+    if (parser.parser) {
+      parser.parser.yy = db;
+    }
+    db.clear?.();
+    init2?.(config);
+    if (metadata.title) {
+      db.setDiagramTitle?.(metadata.title);
+    }
+    await parser.parse(text);
+    return new _Diagram(type, text, db, parser, renderer2);
+  }
+  async render(id26, version2) {
+    await this.renderer.draw(this.text, id26, version2, this);
+  }
+  getParser() {
+    return this.parser;
+  }
+  getType() {
+    return this.type;
+  }
+};
+var interactionFunctions = [];
+var attachFunctions = /* @__PURE__ */ __name(() => {
+  interactionFunctions.forEach((f) => {
+    f();
+  });
+  interactionFunctions = [];
+}, "attachFunctions");
+var cleanupComments = /* @__PURE__ */ __name((text) => {
+  return text.replace(/^\s*%%(?!{)[^\n]+\n?/gm, "").trimStart();
+}, "cleanupComments");
+function extractFrontMatter(text) {
+  const matches = text.match(frontMatterRegex);
+  if (!matches) {
+    return {
+      text,
+      metadata: {}
+    };
+  }
+  let parsed = load(matches[1], {
+    // To support config, we need JSON schema.
+    // https://www.yaml.org/spec/1.2/spec.html#id2803231
+    schema: JSON_SCHEMA
+  }) ?? {};
+  parsed = typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  const metadata = {};
+  if (parsed.displayMode) {
+    metadata.displayMode = parsed.displayMode.toString();
+  }
+  if (parsed.title) {
+    metadata.title = parsed.title.toString();
+  }
+  if (parsed.config) {
+    metadata.config = parsed.config;
+  }
+  return {
+    text: text.slice(matches[0].length),
+    metadata
+  };
+}
+__name(extractFrontMatter, "extractFrontMatter");
+var cleanupText = /* @__PURE__ */ __name((code) => {
+  return code.replace(/\r\n?/g, "\n").replace(
+    /<(\w+)([^>]*)>/g,
+    (match, tag, attributes) => "<" + tag + attributes.replace(/="([^"]*)"/g, "='$1'") + ">"
+  );
+}, "cleanupText");
+var processFrontmatter = /* @__PURE__ */ __name((code) => {
+  const { text, metadata } = extractFrontMatter(code);
+  const { displayMode, title, config = {} } = metadata;
+  if (displayMode) {
+    if (!config.gantt) {
+      config.gantt = {};
+    }
+    config.gantt.displayMode = displayMode;
+  }
+  return { title, config, text };
+}, "processFrontmatter");
+var processDirectives = /* @__PURE__ */ __name((code) => {
+  const initDirective = utils_default.detectInit(code) ?? {};
+  const wrapDirectives = utils_default.detectDirective(code, "wrap");
+  if (Array.isArray(wrapDirectives)) {
+    initDirective.wrap = wrapDirectives.some(({ type }) => type === "wrap");
+  } else if (wrapDirectives?.type === "wrap") {
+    initDirective.wrap = true;
+  }
+  return {
+    text: removeDirectives(code),
+    directive: initDirective
+  };
+}, "processDirectives");
+function preprocessDiagram(code) {
+  const cleanedCode = cleanupText(code);
+  const frontMatterResult = processFrontmatter(cleanedCode);
+  const directiveResult = processDirectives(frontMatterResult.text);
+  const config = cleanAndMerge(frontMatterResult.config, directiveResult.directive);
+  code = cleanupComments(directiveResult.text);
+  return {
+    code,
+    title: frontMatterResult.title,
+    config
+  };
+}
+__name(preprocessDiagram, "preprocessDiagram");
+function toBase64(str) {
+  const utf8Bytes = new TextEncoder().encode(str);
+  const utf8Str = Array.from(utf8Bytes, (byte) => String.fromCodePoint(byte)).join("");
+  return btoa(utf8Str);
+}
+__name(toBase64, "toBase64");
+var MAX_TEXTLENGTH = 5e4;
+var MAX_TEXTLENGTH_EXCEEDED_MSG = "graph TB;a[Maximum text size in diagram exceeded];style a fill:#faa";
+var SECURITY_LVL_SANDBOX = "sandbox";
+var SECURITY_LVL_LOOSE = "loose";
+var XMLNS_SVG_STD = "http://www.w3.org/2000/svg";
+var XMLNS_XLINK_STD = "http://www.w3.org/1999/xlink";
+var XMLNS_XHTML_STD = "http://www.w3.org/1999/xhtml";
+var IFRAME_WIDTH = "100%";
+var IFRAME_HEIGHT = "100%";
+var IFRAME_STYLES = "border:0;margin:0;";
+var IFRAME_BODY_STYLE = "margin:0";
+var IFRAME_SANDBOX_OPTS = "allow-top-navigation-by-user-activation allow-popups";
+var IFRAME_NOT_SUPPORTED_MSG = 'The "iframe" tag is not supported by your browser.';
+var DOMPURIFY_TAGS = ["foreignobject"];
+var DOMPURIFY_ATTR = ["dominant-baseline"];
+function processAndSetConfigs(text) {
+  const processed = preprocessDiagram(text);
+  reset();
+  addDirective(processed.config ?? {});
+  return processed;
+}
+__name(processAndSetConfigs, "processAndSetConfigs");
+async function parse3(text, parseOptions) {
+  addDiagrams();
+  try {
+    const { code, config } = processAndSetConfigs(text);
+    const diagram2 = await getDiagramFromText(code);
+    return { diagramType: diagram2.type, config };
+  } catch (error) {
+    if (parseOptions?.suppressErrors) {
+      return false;
+    }
+    throw error;
+  }
+}
+__name(parse3, "parse");
+var cssImportantStyles = /* @__PURE__ */ __name((cssClass, element, cssClasses = []) => {
+  return `
+.${cssClass} ${element} { ${cssClasses.join(" !important; ")} !important; }`;
+}, "cssImportantStyles");
+var createCssStyles = /* @__PURE__ */ __name((config, classDefs = /* @__PURE__ */ new Map()) => {
+  let cssStyles = "";
+  if (config.themeCSS !== void 0) {
+    cssStyles += `
+${config.themeCSS}`;
+  }
+  if (config.fontFamily !== void 0) {
+    cssStyles += `
+:root { --mermaid-font-family: ${config.fontFamily}}`;
+  }
+  if (config.altFontFamily !== void 0) {
+    cssStyles += `
+:root { --mermaid-alt-font-family: ${config.altFontFamily}}`;
+  }
+  if (classDefs instanceof Map) {
+    const htmlLabels = config.htmlLabels ?? config.flowchart?.htmlLabels;
+    const cssHtmlElements = ["> *", "span"];
+    const cssShapeElements = ["rect", "polygon", "ellipse", "circle", "path"];
+    const cssElements = htmlLabels ? cssHtmlElements : cssShapeElements;
+    classDefs.forEach((styleClassDef) => {
+      if (!isEmpty_default(styleClassDef.styles)) {
+        cssElements.forEach((cssElement) => {
+          cssStyles += cssImportantStyles(styleClassDef.id, cssElement, styleClassDef.styles);
+        });
+      }
+      if (!isEmpty_default(styleClassDef.textStyles)) {
+        cssStyles += cssImportantStyles(
+          styleClassDef.id,
+          "tspan",
+          (styleClassDef?.textStyles || []).map((s) => s.replace("color", "fill"))
+        );
+      }
+    });
+  }
+  return cssStyles;
+}, "createCssStyles");
+var createUserStyles = /* @__PURE__ */ __name((config, graphType, classDefs, svgId) => {
+  const userCSSstyles = createCssStyles(config, classDefs);
+  const allStyles = styles_default(graphType, userCSSstyles, config.themeVariables);
+  return serialize(compile(`${svgId}{${allStyles}}`), stringify);
+}, "createUserStyles");
+var cleanUpSvgCode = /* @__PURE__ */ __name((svgCode = "", inSandboxMode, useArrowMarkerUrls) => {
+  let cleanedUpSvg = svgCode;
+  if (!useArrowMarkerUrls && !inSandboxMode) {
+    cleanedUpSvg = cleanedUpSvg.replace(
+      /marker-end="url\([\d+./:=?A-Za-z-]*?#/g,
+      'marker-end="url(#'
+    );
+  }
+  cleanedUpSvg = decodeEntities(cleanedUpSvg);
+  cleanedUpSvg = cleanedUpSvg.replace(/<br>/g, "<br/>");
+  return cleanedUpSvg;
+}, "cleanUpSvgCode");
+var putIntoIFrame = /* @__PURE__ */ __name((svgCode = "", svgElement) => {
+  const height = svgElement?.viewBox?.baseVal?.height ? svgElement.viewBox.baseVal.height + "px" : IFRAME_HEIGHT;
+  const base64encodedSrc = toBase64(`<body style="${IFRAME_BODY_STYLE}">${svgCode}</body>`);
+  return `<iframe style="width:${IFRAME_WIDTH};height:${height};${IFRAME_STYLES}" src="data:text/html;charset=UTF-8;base64,${base64encodedSrc}" sandbox="${IFRAME_SANDBOX_OPTS}">
+  ${IFRAME_NOT_SUPPORTED_MSG}
+</iframe>`;
+}, "putIntoIFrame");
+var appendDivSvgG = /* @__PURE__ */ __name((parentRoot, id26, enclosingDivId, divStyle, svgXlink) => {
+  const enclosingDiv = parentRoot.append("div");
+  enclosingDiv.attr("id", enclosingDivId);
+  if (divStyle) {
+    enclosingDiv.attr("style", divStyle);
+  }
+  const svgNode = enclosingDiv.append("svg").attr("id", id26).attr("width", "100%").attr("xmlns", XMLNS_SVG_STD);
+  if (svgXlink) {
+    svgNode.attr("xmlns:xlink", svgXlink);
+  }
+  svgNode.append("g");
+  return parentRoot;
+}, "appendDivSvgG");
+function sandboxedIframe(parentNode, iFrameId) {
+  return parentNode.append("iframe").attr("id", iFrameId).attr("style", "width: 100%; height: 100%;").attr("sandbox", "");
+}
+__name(sandboxedIframe, "sandboxedIframe");
+var removeExistingElements = /* @__PURE__ */ __name((doc, id26, divId, iFrameId) => {
+  doc.getElementById(id26)?.remove();
+  doc.getElementById(divId)?.remove();
+  doc.getElementById(iFrameId)?.remove();
+}, "removeExistingElements");
+var render = /* @__PURE__ */ __name(async function(id26, text, svgContainingElement) {
+  addDiagrams();
+  const processed = processAndSetConfigs(text);
+  text = processed.code;
+  const config = getConfig();
+  log.debug(config);
+  if (text.length > (config?.maxTextSize ?? MAX_TEXTLENGTH)) {
+    text = MAX_TEXTLENGTH_EXCEEDED_MSG;
+  }
+  const idSelector = "#" + id26;
+  const iFrameID = "i" + id26;
+  const iFrameID_selector = "#" + iFrameID;
+  const enclosingDivID = "d" + id26;
+  const enclosingDivID_selector = "#" + enclosingDivID;
+  const removeTempElements = /* @__PURE__ */ __name(() => {
+    const tmpElementSelector = isSandboxed ? iFrameID_selector : enclosingDivID_selector;
+    const node2 = select_default(tmpElementSelector).node();
+    if (node2 && "remove" in node2) {
+      node2.remove();
+    }
+  }, "removeTempElements");
+  let root = select_default("body");
+  const isSandboxed = config.securityLevel === SECURITY_LVL_SANDBOX;
+  const isLooseSecurityLevel = config.securityLevel === SECURITY_LVL_LOOSE;
+  const fontFamily = config.fontFamily;
+  if (svgContainingElement !== void 0) {
+    if (svgContainingElement) {
+      svgContainingElement.innerHTML = "";
+    }
+    if (isSandboxed) {
+      const iframe = sandboxedIframe(select_default(svgContainingElement), iFrameID);
+      root = select_default(iframe.nodes()[0].contentDocument.body);
+      root.node().style.margin = 0;
+    } else {
+      root = select_default(svgContainingElement);
+    }
+    appendDivSvgG(root, id26, enclosingDivID, `font-family: ${fontFamily}`, XMLNS_XLINK_STD);
+  } else {
+    removeExistingElements(document, id26, enclosingDivID, iFrameID);
+    if (isSandboxed) {
+      const iframe = sandboxedIframe(select_default("body"), iFrameID);
+      root = select_default(iframe.nodes()[0].contentDocument.body);
+      root.node().style.margin = 0;
+    } else {
+      root = select_default("body");
+    }
+    appendDivSvgG(root, id26, enclosingDivID);
+  }
+  let diag;
+  let parseEncounteredException;
+  try {
+    diag = await Diagram.fromText(text, { title: processed.title });
+  } catch (error) {
+    if (config.suppressErrorRendering) {
+      removeTempElements();
+      throw error;
+    }
+    diag = await Diagram.fromText("error");
+    parseEncounteredException = error;
+  }
+  const element = root.select(enclosingDivID_selector).node();
+  const diagramType = diag.type;
+  const svg = element.firstChild;
+  const firstChild = svg.firstChild;
+  const diagramClassDefs = diag.renderer.getClasses?.(text, diag);
+  const rules = createUserStyles(config, diagramType, diagramClassDefs, idSelector);
+  const style1 = document.createElement("style");
+  style1.innerHTML = rules;
+  svg.insertBefore(style1, firstChild);
+  try {
+    await diag.renderer.draw(text, id26, version, diag);
+  } catch (e) {
+    if (config.suppressErrorRendering) {
+      removeTempElements();
+    } else {
+      errorRenderer_default.draw(text, id26, version);
+    }
+    throw e;
+  }
+  const svgNode = root.select(`${enclosingDivID_selector} svg`);
+  const a11yTitle = diag.db.getAccTitle?.();
+  const a11yDescr = diag.db.getAccDescription?.();
+  addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr);
+  root.select(`[id="${id26}"]`).selectAll("foreignobject > *").attr("xmlns", XMLNS_XHTML_STD);
+  let svgCode = root.select(enclosingDivID_selector).node().innerHTML;
+  log.debug("config.arrowMarkerAbsolute", config.arrowMarkerAbsolute);
+  svgCode = cleanUpSvgCode(svgCode, isSandboxed, evaluate(config.arrowMarkerAbsolute));
+  if (isSandboxed) {
+    const svgEl = root.select(enclosingDivID_selector + " svg").node();
+    svgCode = putIntoIFrame(svgCode, svgEl);
+  } else if (!isLooseSecurityLevel) {
+    svgCode = purify.sanitize(svgCode, {
+      ADD_TAGS: DOMPURIFY_TAGS,
+      ADD_ATTR: DOMPURIFY_ATTR,
+      HTML_INTEGRATION_POINTS: { foreignobject: true }
+    });
+  }
+  attachFunctions();
+  if (parseEncounteredException) {
+    throw parseEncounteredException;
+  }
+  removeTempElements();
+  return {
+    diagramType,
+    svg: svgCode,
+    bindFunctions: diag.db.bindFunctions
+  };
+}, "render");
+function initialize(userOptions = {}) {
+  const options = assignWithDepth_default({}, userOptions);
+  if (options?.fontFamily && !options.themeVariables?.fontFamily) {
+    if (!options.themeVariables) {
+      options.themeVariables = {};
+    }
+    options.themeVariables.fontFamily = options.fontFamily;
+  }
+  saveConfigFromInitialize(options);
+  if (options?.theme && options.theme in themes_default) {
+    options.themeVariables = themes_default[options.theme].getThemeVariables(
+      options.themeVariables
+    );
+  } else if (options) {
+    options.themeVariables = themes_default.default.getThemeVariables(options.themeVariables);
+  }
+  const config = typeof options === "object" ? setSiteConfig(options) : getSiteConfig();
+  setLogLevel(config.logLevel);
+  addDiagrams();
+}
+__name(initialize, "initialize");
+var getDiagramFromText = /* @__PURE__ */ __name((text, metadata = {}) => {
+  const { code } = preprocessDiagram(text);
+  return Diagram.fromText(code, metadata);
+}, "getDiagramFromText");
+function addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr) {
+  setA11yDiagramInfo(svgNode, diagramType);
+  addSVGa11yTitleDescription(svgNode, a11yTitle, a11yDescr, svgNode.attr("id"));
+}
+__name(addA11yInfo, "addA11yInfo");
+var mermaidAPI = Object.freeze({
+  render,
+  parse: parse3,
+  getDiagramFromText,
+  initialize,
+  getConfig,
+  setConfig,
+  getSiteConfig,
+  updateSiteConfig,
+  reset: /* @__PURE__ */ __name(() => {
+    reset();
+  }, "reset"),
+  globalReset: /* @__PURE__ */ __name(() => {
+    reset(defaultConfig);
+  }, "globalReset"),
+  defaultConfig
+});
+setLogLevel(getConfig().logLevel);
+reset(getConfig());
+var handleError = /* @__PURE__ */ __name((error, errors, parseError) => {
+  log.warn(error);
+  if (isDetailedError(error)) {
+    if (parseError) {
+      parseError(error.str, error.hash);
+    }
+    errors.push({ ...error, message: error.str, error });
+  } else {
+    if (parseError) {
+      parseError(error);
+    }
+    if (error instanceof Error) {
+      errors.push({
+        str: error.message,
+        message: error.message,
+        hash: error.name,
+        error
+      });
+    }
+  }
+}, "handleError");
+var run = /* @__PURE__ */ __name(async function(options = {
+  querySelector: ".mermaid"
+}) {
+  try {
+    await runThrowsErrors(options);
+  } catch (e) {
+    if (isDetailedError(e)) {
+      log.error(e.str);
+    }
+    if (mermaid.parseError) {
+      mermaid.parseError(e);
+    }
+    if (!options.suppressErrors) {
+      log.error("Use the suppressErrors option to suppress these errors");
+      throw e;
+    }
+  }
+}, "run");
+var runThrowsErrors = /* @__PURE__ */ __name(async function({ postRenderCallback, querySelector, nodes } = {
+  querySelector: ".mermaid"
+}) {
+  const conf = mermaidAPI.getConfig();
+  log.debug(`${!postRenderCallback ? "No " : ""}Callback function found`);
+  let nodesToProcess;
+  if (nodes) {
+    nodesToProcess = nodes;
+  } else if (querySelector) {
+    nodesToProcess = document.querySelectorAll(querySelector);
+  } else {
+    throw new Error("Nodes and querySelector are both undefined");
+  }
+  log.debug(`Found ${nodesToProcess.length} diagrams`);
+  if (conf?.startOnLoad !== void 0) {
+    log.debug("Start On Load: " + conf?.startOnLoad);
+    mermaidAPI.updateSiteConfig({ startOnLoad: conf?.startOnLoad });
+  }
+  const idGenerator = new utils_default.InitIDGenerator(conf.deterministicIds, conf.deterministicIDSeed);
+  let txt;
+  const errors = [];
+  for (const element of Array.from(nodesToProcess)) {
+    log.info("Rendering diagram: " + element.id);
+    if (element.getAttribute("data-processed")) {
+      continue;
+    }
+    element.setAttribute("data-processed", "true");
+    const id26 = `mermaid-${idGenerator.next()}`;
+    txt = element.innerHTML;
+    txt = dedent(utils_default.entityDecode(txt)).trim().replace(/<br\s*\/?>/gi, "<br/>");
+    const init2 = utils_default.detectInit(txt);
+    if (init2) {
+      log.debug("Detected early reinit: ", init2);
+    }
+    try {
+      const { svg, bindFunctions } = await render2(id26, txt, element);
+      element.innerHTML = svg;
+      if (postRenderCallback) {
+        await postRenderCallback(id26);
+      }
+      if (bindFunctions) {
+        bindFunctions(element);
+      }
+    } catch (error) {
+      handleError(error, errors, mermaid.parseError);
+    }
+  }
+  if (errors.length > 0) {
+    throw errors[0];
+  }
+}, "runThrowsErrors");
+var initialize2 = /* @__PURE__ */ __name(function(config) {
+  mermaidAPI.initialize(config);
+}, "initialize");
+var init = /* @__PURE__ */ __name(async function(config, nodes, callback) {
+  log.warn("mermaid.init is deprecated. Please use run instead.");
+  if (config) {
+    initialize2(config);
+  }
+  const runOptions = { postRenderCallback: callback, querySelector: ".mermaid" };
+  if (typeof nodes === "string") {
+    runOptions.querySelector = nodes;
+  } else if (nodes) {
+    if (nodes instanceof HTMLElement) {
+      runOptions.nodes = [nodes];
+    } else {
+      runOptions.nodes = nodes;
+    }
+  }
+  await run(runOptions);
+}, "init");
+var registerExternalDiagrams = /* @__PURE__ */ __name(async (diagrams, {
+  lazyLoad = true
+} = {}) => {
+  addDiagrams();
+  registerLazyLoadedDiagrams(...diagrams);
+  if (lazyLoad === false) {
+    await loadRegisteredDiagrams();
+  }
+}, "registerExternalDiagrams");
+var contentLoaded = /* @__PURE__ */ __name(function() {
+  if (mermaid.startOnLoad) {
+    const { startOnLoad } = mermaidAPI.getConfig();
+    if (startOnLoad) {
+      mermaid.run().catch((err) => log.error("Mermaid failed to initialize", err));
+    }
+  }
+}, "contentLoaded");
+if (typeof document !== "undefined") {
+  window.addEventListener("load", contentLoaded, false);
+}
+var setParseErrorHandler = /* @__PURE__ */ __name(function(parseErrorHandler) {
+  mermaid.parseError = parseErrorHandler;
+}, "setParseErrorHandler");
+var executionQueue = [];
+var executionQueueRunning = false;
+var executeQueue = /* @__PURE__ */ __name(async () => {
+  if (executionQueueRunning) {
+    return;
+  }
+  executionQueueRunning = true;
+  while (executionQueue.length > 0) {
+    const f = executionQueue.shift();
+    if (f) {
+      try {
+        await f();
+      } catch (e) {
+        log.error("Error executing queue", e);
+      }
+    }
+  }
+  executionQueueRunning = false;
+}, "executeQueue");
+var parse22 = /* @__PURE__ */ __name(async (text, parseOptions) => {
+  return new Promise((resolve, reject) => {
+    const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => {
+      mermaidAPI.parse(text, parseOptions).then(
+        (r) => {
+          res(r);
+          resolve(r);
+        },
+        (e) => {
+          log.error("Error parsing", e);
+          mermaid.parseError?.(e);
+          rej(e);
+          reject(e);
+        }
+      );
+    }), "performCall");
+    executionQueue.push(performCall);
+    executeQueue().catch(reject);
+  });
+}, "parse");
+var render2 = /* @__PURE__ */ __name((id26, text, container) => {
+  return new Promise((resolve, reject) => {
+    const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => {
+      mermaidAPI.render(id26, text, container).then(
+        (r) => {
+          res(r);
+          resolve(r);
+        },
+        (e) => {
+          log.error("Error parsing", e);
+          mermaid.parseError?.(e);
+          rej(e);
+          reject(e);
+        }
+      );
+    }), "performCall");
+    executionQueue.push(performCall);
+    executeQueue().catch(reject);
+  });
+}, "render");
+var mermaid = {
+  startOnLoad: true,
+  mermaidAPI,
+  parse: parse22,
+  render: render2,
+  init,
+  run,
+  registerExternalDiagrams,
+  registerLayoutLoaders,
+  initialize: initialize2,
+  parseError: void 0,
+  contentLoaded,
+  setParseErrorHandler,
+  detectType,
+  registerIconPacks
+};
+var mermaid_default = mermaid;
+
+// components/src/asciidoc/Mermaid.tsx
+import { memo, useId, useState } from "react";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+mermaid_default.initialize({
+  startOnLoad: false,
+  theme: "dark"
+});
+var Mermaid = memo(function Mermaid2({ content }) {
+  const [showSource, setShowSource] = useState(false);
+  const id26 = `mermaid-diagram-${useId().replace(/:/g, "_")}`;
+  const mermaidRef = async (node2) => {
+    if (node2) {
+      const { svg } = await mermaid_default.render(id26, content);
+      node2.innerHTML = svg;
+    }
+  };
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsxs2(
+      "button",
+      {
+        className: "absolute right-2 top-2 text-mono-xs text-tertiary",
+        onClick: () => setShowSource(!showSource),
+        children: [
+          showSource ? "Hide" : "Show",
+          " Source ",
+          /* @__PURE__ */ jsx2("span", { className: "text-quinary", children: "|" }),
+          " ",
+          "Mermaid"
+        ]
+      }
+    ),
+    !showSource ? /* @__PURE__ */ jsx2("code", { ref: mermaidRef, className: "w-full" }) : /* @__PURE__ */ jsx2("code", { children: content })
+  ] });
+});
+var Mermaid_default = Mermaid;
+
+// icons/react/Link16Icon.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var Link16Icon = ({ title, titleId, ...props }) => /* @__PURE__ */ jsxs3(
+  "svg",
+  {
+    width: 16,
+    height: 16,
+    viewBox: "0 0 16 16",
+    xmlns: "http://www.w3.org/2000/svg",
+    role: "img",
+    "aria-labelledby": titleId,
+    ...props,
+    children: [
+      title ? /* @__PURE__ */ jsx3("title", { id: titleId, children: title }) : null,
+      /* @__PURE__ */ jsxs3("g", { fill: "currentColor", children: [
+        /* @__PURE__ */ jsx3("path", { d: "m6.586 12.243 1.59-1.591a.75.75 0 0 1 1.061 0l.354.353a.75.75 0 0 1 0 1.06L8 13.658A4 4 0 0 1 2.343 8l1.591-1.591a.75.75 0 0 1 1.06 0l.354.354a.75.75 0 0 1 0 1.06l-1.59 1.591a2 2 0 1 0 2.828 2.829ZM12.066 9.591a.75.75 0 0 1-1.06 0l-.354-.354a.75.75 0 0 1 0-1.06l1.59-1.591a2 2 0 1 0-2.828-2.829l-1.59 1.591a.75.75 0 0 1-1.061 0l-.354-.353a.75.75 0 0 1 0-1.06L8 2.342A4 4 0 0 1 13.657 8l-1.591 1.591Z" }),
+        /* @__PURE__ */ jsx3("path", { d: "M9.945 5.702a.75.75 0 0 0-1.061 0L5.702 8.884a.75.75 0 0 0 0 1.06l.353.354a.75.75 0 0 0 1.061 0l3.182-3.182a.75.75 0 0 0 0-1.06l-.353-.354Z" })
+      ] })
+    ]
+  }
+);
+var Link16Icon_default = Link16Icon;
+
+// icons/react/Checkmark12Icon.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var Checkmark12Icon = ({
+  title,
+  titleId,
+  ...props
+}) => /* @__PURE__ */ jsxs4(
+  "svg",
+  {
+    width: 12,
+    height: 12,
+    viewBox: "0 0 12 12",
+    xmlns: "http://www.w3.org/2000/svg",
+    role: "img",
+    "aria-labelledby": titleId,
+    ...props,
+    children: [
+      title ? /* @__PURE__ */ jsx4("title", { id: titleId, children: title }) : null,
+      /* @__PURE__ */ jsx4(
+        "path",
+        {
+          fillRule: "evenodd",
+          clipRule: "evenodd",
+          d: "M10.492 2.651c.28.242.31.665.067.944L5.447 9.463a.667.667 0 0 1-.974.035L1.475 6.516a.667.667 0 0 1 0-.946l.237-.235a.667.667 0 0 1 .94 0l2.24 2.226L9.3 2.501a.667.667 0 0 1 .938-.068l.253.218Z",
+          fill: "currentColor"
+        }
+      )
+    ]
+  }
+);
+var Checkmark12Icon_default = Checkmark12Icon;
+
+// icons/react/DirectionRightIcon.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var DirectionRightIcon = ({
+  title,
+  titleId,
+  ...props
+}) => /* @__PURE__ */ jsxs5(
+  "svg",
+  {
+    width: 12,
+    height: 12,
+    viewBox: "0 0 12 12",
+    xmlns: "http://www.w3.org/2000/svg",
+    role: "img",
+    "aria-labelledby": titleId,
+    ...props,
+    children: [
+      title ? /* @__PURE__ */ jsx5("title", { id: titleId, children: title }) : null,
+      /* @__PURE__ */ jsx5(
+        "path",
+        {
+          d: "M8.807 6.597a.667.667 0 0 0 0-1.194l-5.842-2.92A.667.667 0 0 0 2 3.079v5.842c0 .496.522.818.965.596l5.842-2.92Z",
+          fill: "currentColor"
+        }
+      )
+    ]
+  }
+);
+var DirectionRightIcon_default = DirectionRightIcon;
+
+// icons/react/SelectArrows6Icon.tsx
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var SelectArrows6Icon = ({
+  title,
+  titleId,
+  ...props
+}) => /* @__PURE__ */ jsxs6(
+  "svg",
+  {
+    width: 6,
+    height: 14,
+    viewBox: "0 0 6 14",
+    xmlns: "http://www.w3.org/2000/svg",
+    role: "img",
+    "aria-labelledby": titleId,
+    ...props,
+    children: [
+      title ? /* @__PURE__ */ jsx6("title", { id: titleId, children: title }) : null,
+      /* @__PURE__ */ jsx6(
+        "path",
+        {
+          fillRule: "evenodd",
+          clipRule: "evenodd",
+          d: "M3.322.536a.375.375 0 0 0-.644 0L.341 4.432C.19 4.682.37 5 .662 5h4.676a.375.375 0 0 0 .321-.568L3.322.536Zm-.644 12.928a.375.375 0 0 0 .644 0l2.337-3.896A.375.375 0 0 0 5.338 9H.662a.375.375 0 0 0-.321.568l2.337 3.896Z",
+          fill: "currentColor"
+        }
+      )
+    ]
+  }
+);
+var SelectArrows6Icon_default = SelectArrows6Icon;
+
+// components/src/asciidoc/Section.tsx
+import { Content as Content2, parse as parse4 } from "@oxide/react-asciidoc";
+import cn2 from "classnames";
+import { createElement as createElement2 } from "react";
+import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var stripAnchors = (str) => str.replace(/<a[^>]*>(.*?)<\/a>/gi, "$1");
+var Section = ({ node: node2 }) => {
+  const level = node2.level;
+  let title = "";
+  let sectNum = node2.num;
+  sectNum = sectNum === "." ? "" : sectNum;
+  title = /* @__PURE__ */ jsxs7(Fragment2, { children: [
+    /* @__PURE__ */ jsx7("span", { className: "anchor", id: node2.id || "", "aria-hidden": "true" }),
+    /* @__PURE__ */ jsxs7("a", { className: "link group", href: `#${node2.id}`, children: [
+      parse4(stripAnchors(node2.title)),
+      /* @__PURE__ */ jsx7(Link16Icon_default, { className: "ml-2 hidden text-accent-secondary group-hover:inline-block" })
+    ] })
+  ] });
+  if (level === 0) {
+    return /* @__PURE__ */ jsxs7(Fragment2, { children: [
+      /* @__PURE__ */ jsx7("h1", { className: cn2("sect0", node2.role), "data-sectnum": sectNum, children: title }),
+      /* @__PURE__ */ jsx7(Content2, { blocks: node2.blocks })
+    ] });
+  } else {
+    return /* @__PURE__ */ jsxs7("div", { className: cn2(`sect${level}`, node2.role), children: [
+      createElement2(`h${level + 1}`, { "data-sectnum": sectNum }, title),
+      /* @__PURE__ */ jsx7("div", { className: "sectionbody", children: /* @__PURE__ */ jsx7(Content2, { blocks: node2.blocks }) })
+    ] });
+  }
+};
+var Section_default = Section;
+
+// components/src/asciidoc/Table.tsx
+import { Table as InnerTable } from "@oxide/react-asciidoc";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var Table = ({ node: node2 }) => /* @__PURE__ */ jsx8("div", { className: "table-wrapper", children: /* @__PURE__ */ jsx8(InnerTable, { node: node2 }) });
+var Table_default = Table;
+
+// components/src/asciidoc/TableOfContents.tsx
+import * as Accordion from "@radix-ui/react-accordion";
+import { Link } from "@remix-run/react";
+import cn3 from "classnames";
+import { Fragment as Fragment3, useCallback, useEffect, useMemo, useRef, useState as useState2 } from "react";
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function useIntersectionObserver(elements, callback, options) {
+  const [observer, setObserver] = useState2(null);
+  useEffect(() => {
+    const observer2 = new IntersectionObserver(callback, options);
+    setObserver(observer2);
+    return () => {
+      observer2.disconnect();
+    };
+  }, [callback, options]);
+  useEffect(() => {
+    if (observer) {
+      for (const element of elements) {
+        observer.observe(element);
+      }
+    }
+    return () => {
+      if (observer) {
+        for (const element of elements) {
+          observer.unobserve(element);
+        }
+      }
+    };
+  }, [elements, observer]);
+  return observer;
+}
+var THRESHOLD = [...Array(2e3).keys()].map((n) => n / 2e3);
+function isTopLevelSection(element) {
+  return element.classList.contains("sect1");
+}
+function findParentSection(element) {
+  const sect2Wrapper = element.closest(".sect2");
+  return sect2Wrapper ? sect2Wrapper : element.closest(".sect1");
+}
+function newSection(node2, element, wrapper, parent) {
+  return {
+    node: node2,
+    element,
+    wrapper,
+    parent,
+    children: []
+  };
+}
+function buildSectionTree(elements) {
+  const sections = [];
+  let parent = null;
+  for (let i = 0; i < elements.length; i++) {
+    const element = elements[i];
+    const parentWrapper = findParentSection(element);
+    if (parentWrapper) {
+      if (parentWrapper && isTopLevelSection(parentWrapper)) {
+        const section = newSection(i, element, parentWrapper, null);
+        sections.push(section);
+        parent = section;
+      } else {
+        if (parent === null) {
+          return [];
+        } else {
+          const section = newSection(i, element, parentWrapper, parent.node);
+          parent.children.push(i);
+          sections.push(section);
+        }
+      }
+    } else {
+      return [];
+    }
+  }
+  return sections;
+}
+function maxIndex(nums) {
+  return nums.reduce((maxIndex2, current, currentIndex) => {
+    const currentMax = maxIndex2 !== void 0 ? nums[maxIndex2] : 0;
+    return current > currentMax ? currentIndex : maxIndex2;
+  }, void 0);
+}
+function useActiveSectionTracking(initialSections, onSectionChange, debug = false) {
+  const [sectionWrappers, setSectionWrappers] = useState2(
+    buildSectionTree(initialSections)
+  );
+  const sectionMeasurements = useRef([]);
+  const setSections = useCallback(
+    (sections) => {
+      setSectionWrappers(buildSectionTree(sections));
+      sectionMeasurements.current = [];
+    },
+    [setSectionWrappers]
+  );
+  const wrapperActivator = useCallback(
+    (entries) => {
+      for (const entry of entries) {
+        const index = sectionWrappers.findIndex((node2) => node2.wrapper === entry.target);
+        const covered = entry.intersectionRect.height / (entry.rootBounds?.height || 1);
+        sectionMeasurements.current[index] = covered;
+      }
+      const ownedSectionSizes = sectionWrappers.map((section) => {
+        const childSizes = section.children.map((c) => sectionMeasurements.current[c]).reduce((c, a) => c + a, 0);
+        return sectionMeasurements.current[section.node] - childSizes;
+      });
+      const activeSectionIndex = maxIndex(ownedSectionSizes);
+      if (activeSectionIndex !== void 0) {
+        onSectionChange(sectionWrappers[activeSectionIndex].element);
+      }
+    },
+    [sectionWrappers, onSectionChange]
+  );
+  const wrapperSettings = useMemo(
+    () => ({ threshold: THRESHOLD, rootMargin: `-15% 0px -70% 0px` }),
+    []
+  );
+  const bindableWrappers = useMemo(
+    () => sectionWrappers.map((s) => s.wrapper),
+    [sectionWrappers]
+  );
+  const sectionObserver = useIntersectionObserver(
+    bindableWrappers,
+    wrapperActivator,
+    wrapperSettings
+  );
+  let debugNode = null;
+  if (debug && sectionObserver?.root === null) {
+    const edges = sectionObserver.rootMargin.split(" ").map((margin) => {
+      if (margin.endsWith("%")) {
+        return parseInt(margin) * -1 + "%";
+      } else if (margin.endsWith("px")) {
+        return parseInt(margin) * -1 + "px";
+      } else {
+        return "0px";
+      }
+    });
+    debugNode = /* @__PURE__ */ jsx9(
+      "div",
+      {
+        style: {
+          position: "fixed",
+          top: edges[0],
+          right: edges[1],
+          bottom: edges[2],
+          left: edges[3],
+          background: "rgba(255, 92, 170, 0.2)",
+          border: "1px solid rgba(255, 92, 170)",
+          pointerEvents: "none",
+          zIndex: 500
+        }
+      }
+    );
+  }
+  return {
+    setSections,
+    debugNode
+  };
+}
+var DesktopOutline = ({
+  toc,
+  activeItem
+}) => {
+  const renderToc = (sections) => {
+    return sections.map((item) => /* @__PURE__ */ jsxs8(Fragment3, { children: [
+      /* @__PURE__ */ jsx9(
+        "li",
+        {
+          "data-level": item.level,
+          className: cn3("mb-0 list-none text-sans-sm", item.level > 2 && "hidden"),
+          children: /* @__PURE__ */ jsx9(
+            Link,
+            {
+              to: `#${item.id}`,
+              className: cn3(
+                "block border-l py-[4px] pr-4",
+                activeItem === item.id ? "active text-accent-secondary border-accent-secondary hover:text-accent" : "text-tertiary border-secondary hover:text-secondary"
+              ),
+              style: {
+                paddingLeft: `${0.5 + item.level * 0.5}rem`
+              },
+              children: /* @__PURE__ */ jsx9("span", { dangerouslySetInnerHTML: { __html: item.title } })
+            }
+          )
+        }
+      ),
+      item.sections && renderToc(item.sections)
+    ] }, item.id));
+  };
+  if (toc && toc.length > 0) {
+    return /* @__PURE__ */ jsx9("ul", { className: "toc", children: renderToc(toc) });
+  }
+  return null;
+};
+var SmallScreenOutline = ({
+  toc,
+  activeItem,
+  title
+}) => {
+  const renderToc = (sections) => {
+    return sections.map((item) => /* @__PURE__ */ jsxs8(Fragment3, { children: [
+      /* @__PURE__ */ jsx9(
+        "li",
+        {
+          "data-level": item.level,
+          className: cn3(
+            "AccordionContent hydrated list-none text-sans-sm",
+            item.level > 2 && "hidden"
+          ),
+          children: /* @__PURE__ */ jsx9(
+            Link,
+            {
+              to: `#${item.id}`,
+              className: cn3(
+                "block border-l py-[4px]",
+                activeItem === item.id ? "active text-accent-secondary border-accent-secondary hover:text-accent" : "text-tertiary border-secondary hover:text-secondary"
+              ),
+              style: {
+                paddingLeft: `${0.5 + item.level * 0.5}rem`
+              },
+              children: /* @__PURE__ */ jsx9("span", { dangerouslySetInnerHTML: { __html: item.title } })
+            }
+          )
+        }
+      ),
+      item.sections && renderToc(item.sections)
+    ] }, item.id));
+  };
+  if (toc && toc.length > 0) {
+    return /* @__PURE__ */ jsx9(
+      Accordion.Root,
+      {
+        type: "single",
+        className: "sticky top-[calc(var(--header-height)-1px)] z-10 -mt-px mb-10 block max-h-[calc(100vh-var(--header-height)+1px)] w-full overflow-y-scroll border-b border-t bg-default border-secondary 1200:hidden print:hidden",
+        collapsible: true,
+        children: /* @__PURE__ */ jsxs8(Accordion.Item, { value: `small-toc-${title}`, children: [
+          /* @__PURE__ */ jsx9(Accordion.Header, { children: /* @__PURE__ */ jsxs8(Accordion.Trigger, { className: "flex h-[--toc-header-height] w-full items-center justify-between px-4 text-sans-md text-default hover:bg-hover 400:px-6 600:px-8 [&>svg]:data-[state=open]:rotate-90", children: [
+            "Table of Contents",
+            " ",
+            /* @__PURE__ */ jsx9(DirectionRightIcon_default, { className: "transition-all text-tertiary" })
+          ] }) }),
+          /* @__PURE__ */ jsx9(Accordion.Content, { className: "AccordionContent hydrated w-full border-t px-4 border-secondary 400:px-6 600:px-8", children: /* @__PURE__ */ jsx9("div", { className: "py-4", children: renderToc(toc) }) })
+        ] })
+      }
+    );
+  }
+  return null;
+};
+
+// components/src/asciidoc/util.ts
+import asciidoctor from "@asciidoctor/core";
+import {
+  prepareDocument,
+  processDocument
+} from "@oxide/react-asciidoc";
+import {
+  bundledLanguages,
+  getHighlighter
+} from "shiki";
+
+// components/src/asciidoc/langs/oxql.tmLanguage.json
+var oxql_tmLanguage_default = {
+  $schema: "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  name: "oxql",
+  repository: {
+    keywords: {
+      patterns: [
+        {
+          name: "keyword.control.oxql",
+          match: "\\b(if|while|for|return)\\b"
+        }
+      ]
+    },
+    strings: {
+      name: "string.quoted.double.oxql",
+      begin: '"',
+      end: '"',
+      patterns: [
+        {
+          name: "constant.character.escape.oxql",
+          match: "\\\\."
+        }
+      ]
+    }
+  },
+  scopeName: "source.oxql",
+  patterns: [
+    {
+      name: "keyword.control.oxql",
+      match: "\\b(get|join|align|filter|group_by)\\b"
+    },
+    {
+      name: "string.quoted.double.oxql",
+      begin: '"',
+      end: '"',
+      patterns: [
+        {
+          name: "constant.character.escape.oxql",
+          match: "\\\\."
+        }
+      ]
+    },
+    {
+      name: "constant.numeric.oxql",
+      match: "\\b\\d+[smhdw]\\b"
+    },
+    {
+      name: "constant.numeric.datetime.oxql",
+      match: "@\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}"
+    },
+    {
+      name: "constant.numeric.function.oxql",
+      match: "@now\\(\\)"
+    },
+    {
+      name: "constant.numeric.oxql",
+      match: "\\b\\d+\\b"
+    },
+    {
+      name: "comment.block.oxql",
+      begin: "/\\*",
+      end: "\\*/"
+    },
+    {
+      name: "comment.line.double-slash.oxql",
+      match: "//.*$"
+    },
+    {
+      name: "keyword.operator.oxql",
+      match: "\\|"
+    }
+  ]
+};
+
+// components/src/asciidoc/oxide-dark.json
+var oxide_dark_default = {
+  name: "Oxide Dark",
+  colors: {
+    "editor.background": "#080F11",
+    "editor.foreground": "#E7E7E8"
+  },
+  tokenColors: [
+    {
+      scope: [
+        "text",
+        "source",
+        "variable.other.readwrite",
+        "punctuation.definition.variable"
+      ],
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "punctuation",
+      settings: {
+        foreground: "#A1A4A5",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["comment", "punctuation.definition.comment"],
+      settings: {
+        foreground: "#A1A4A5"
+      }
+    },
+    {
+      scope: ["string", "punctuation.definition.string"],
+      settings: {
+        foreground: "#68D9A7"
+      }
+    },
+    {
+      scope: "constant.character.escape",
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: [
+        "constant.numeric",
+        "variable.other.constant",
+        "entity.name.constant",
+        "constant.language.boolean",
+        "constant.language.false",
+        "constant.language.true",
+        "keyword.other.unit.user-defined",
+        "keyword.other.unit.suffix.floating-point"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "keyword",
+        "keyword.operator.word",
+        "keyword.operator.new",
+        "variable.language.super",
+        "support.type.primitive",
+        "storage.type",
+        "storage.modifier",
+        "punctuation.definition.keyword"
+      ],
+      settings: {
+        foreground: "#C6A5EA",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "entity.name.tag.documentation",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: [
+        "keyword.operator",
+        "punctuation.accessor",
+        "punctuation.definition.generic",
+        "meta.function.closure punctuation.section.parameters",
+        "punctuation.definition.tag",
+        "punctuation.separator.key-value"
+      ],
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: [
+        "entity.name.function",
+        "meta.function-call.method",
+        "support.function",
+        "support.function.misc",
+        "variable.function"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "entity.name.class",
+        "entity.other.inherited-class",
+        "support.class",
+        "meta.function-call.constructor",
+        "entity.name.struct"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "entity.name.enum",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: ["meta.enum variable.other.readwrite", "variable.other.enummember"],
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "meta.property.object",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: ["meta.type", "meta.type-alias", "support.type", "entity.name.type"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "meta.annotation variable.function",
+        "meta.annotation variable.annotation.function",
+        "meta.annotation punctuation.definition.annotation",
+        "meta.decorator",
+        "punctuation.decorator"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: ["variable.parameter", "meta.function.parameters"],
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: ["constant.language", "support.function.builtin"],
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: "entity.other.attribute-name.documentation",
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: ["keyword.control.directive", "punctuation.definition.directive"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "punctuation.definition.typeparameters",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "entity.name.namespace",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "support.type.property-name.css",
+      settings: {
+        foreground: "#9DAFFA",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: [
+        "variable.language.this",
+        "variable.language.this punctuation.definition.variable"
+      ],
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: "variable.object.property",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: ["string.template variable", "string variable"],
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "keyword.operator.new",
+      settings: {
+        fontStyle: "bold"
+      }
+    },
+    {
+      scope: "storage.modifier.specifier.extern.cpp",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: [
+        "entity.name.scope-resolution.template.call.cpp",
+        "entity.name.scope-resolution.parameter.cpp",
+        "entity.name.scope-resolution.cpp",
+        "entity.name.scope-resolution.function.definition.cpp"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "storage.type.class.doxygen",
+      settings: {
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["storage.modifier.reference.cpp"],
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "meta.interpolation.cs",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "comment.block.documentation.cs",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: [
+        "source.css entity.other.attribute-name.class.css",
+        "entity.other.attribute-name.parent-selector.css punctuation.definition.entity.css"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "punctuation.separator.operator.css",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "source.css entity.other.attribute-name.pseudo-class",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "source.css constant.other.unicode-range",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "source.css variable.parameter.url",
+      settings: {
+        foreground: "#88DCB7",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["support.type.vendored.property-name"],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "source.css meta.property-value variable",
+        "source.css meta.property-value variable.other.less",
+        "source.css meta.property-value variable.other.less punctuation.definition.variable.less",
+        "meta.definition.variable.scss"
+      ],
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: [
+        "source.css meta.property-list variable",
+        "meta.property-list variable.other.less",
+        "meta.property-list variable.other.less punctuation.definition.variable.less"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "keyword.other.unit.percentage.css",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "source.css meta.attribute-selector",
+      settings: {
+        foreground: "#88DCB7"
+      }
+    },
+    {
+      scope: [
+        "keyword.other.definition.ini",
+        "punctuation.support.type.property-name.json",
+        "support.type.property-name.json",
+        "punctuation.support.type.property-name.toml",
+        "support.type.property-name.toml",
+        "entity.name.tag.yaml",
+        "punctuation.support.type.property-name.yaml",
+        "support.type.property-name.yaml"
+      ],
+      settings: {
+        foreground: "#9DAFFA",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["constant.language.json", "constant.language.yaml"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: ["entity.name.type.anchor.yaml", "variable.other.alias.yaml"],
+      settings: {
+        foreground: "#EDD5A6",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["support.type.property-name.table", "entity.name.section.group-title.ini"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "constant.other.time.datetime.offset.toml",
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: ["punctuation.definition.anchor.yaml", "punctuation.definition.alias.yaml"],
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: "entity.other.document.begin.yaml",
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: "markup.changed.diff",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "meta.diff.header.from-file",
+        "meta.diff.header.to-file",
+        "punctuation.definition.from-file.diff",
+        "punctuation.definition.to-file.diff"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "markup.inserted.diff",
+      settings: {
+        foreground: "#88DCB7"
+      }
+    },
+    {
+      scope: "markup.deleted.diff",
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: ["variable.other.env"],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: ["string.quoted variable.other.env"],
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "support.function.builtin.gdscript",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "constant.language.gdscript",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "comment meta.annotation.go",
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: "comment meta.annotation.parameters.go",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "constant.language.go",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "variable.graphql",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "string.unquoted.alias.graphql",
+      settings: {
+        foreground: "#F2CDCD"
+      }
+    },
+    {
+      scope: "constant.character.enum.graphql",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "meta.objectvalues.graphql constant.object.key.graphql string.unquoted.graphql",
+      settings: {
+        foreground: "#F2CDCD"
+      }
+    },
+    {
+      scope: [
+        "keyword.other.doctype",
+        "meta.tag.sgml.doctype punctuation.definition.tag",
+        "meta.tag.metadata.doctype entity.name.tag",
+        "meta.tag.metadata.doctype punctuation.definition.tag"
+      ],
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: ["entity.name.tag"],
+      settings: {
+        foreground: "#9DAFFA",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: [
+        "text.html constant.character.entity",
+        "text.html constant.character.entity punctuation",
+        "constant.character.entity.xml",
+        "constant.character.entity.xml punctuation",
+        "constant.character.entity.js.jsx",
+        "constant.charactger.entity.js.jsx punctuation",
+        "constant.character.entity.tsx",
+        "constant.character.entity.tsx punctuation"
+      ],
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: ["entity.other.attribute-name"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "support.class.component",
+        "support.class.component.jsx",
+        "support.class.component.tsx",
+        "support.class.component.vue"
+      ],
+      settings: {
+        foreground: "#EFB7C2",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["punctuation.definition.annotation", "storage.type.annotation"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "constant.other.enum.java",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "storage.modifier.import.java",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "comment.block.javadoc.java keyword.other.documentation.javadoc.java",
+      settings: {
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "meta.export variable.other.readwrite.js",
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: [
+        "variable.other.constant.js",
+        "variable.other.constant.ts",
+        "variable.other.property.js",
+        "variable.other.property.ts"
+      ],
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: ["variable.other.jsdoc", "comment.block.documentation variable.other"],
+      settings: {
+        foreground: "#F39EAE",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "storage.type.class.jsdoc",
+      settings: {
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "support.type.object.console.js",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: ["support.constant.node", "support.type.object.module.js"],
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "storage.modifier.implements",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: [
+        "constant.language.null.js",
+        "constant.language.null.ts",
+        "constant.language.undefined.js",
+        "constant.language.undefined.ts",
+        "support.type.builtin.ts"
+      ],
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "variable.parameter.generic",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: ["keyword.declaration.function.arrow.js", "storage.type.function.arrow.ts"],
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "punctuation.decorator.ts",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "keyword.operator.expression.in.js",
+        "keyword.operator.expression.in.ts",
+        "keyword.operator.expression.infer.ts",
+        "keyword.operator.expression.instanceof.js",
+        "keyword.operator.expression.instanceof.ts",
+        "keyword.operator.expression.is",
+        "keyword.operator.expression.keyof.ts",
+        "keyword.operator.expression.of.js",
+        "keyword.operator.expression.of.ts",
+        "keyword.operator.expression.typeof.ts"
+      ],
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "support.function.macro.julia",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "constant.language.julia",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "constant.other.symbol.julia",
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: "text.tex keyword.control.preamble",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "text.tex support.function.be",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "constant.other.general.math.tex",
+      settings: {
+        foreground: "#F2CDCD"
+      }
+    },
+    {
+      scope: "comment.line.double-dash.documentation.lua storage.type.annotation.lua",
+      settings: {
+        foreground: "#C6A5EA",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: [
+        "comment.line.double-dash.documentation.lua entity.name.variable.lua",
+        "comment.line.double-dash.documentation.lua variable.lua"
+      ],
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: [
+        "heading.1.markdown punctuation.definition.heading.markdown",
+        "heading.1.markdown",
+        "heading.1.quarto punctuation.definition.heading.quarto",
+        "heading.1.quarto",
+        "markup.heading.atx.1.mdx",
+        "markup.heading.atx.1.mdx punctuation.definition.heading.mdx",
+        "markup.heading.setext.1.markdown",
+        "markup.heading.heading-0.asciidoc"
+      ],
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: [
+        "heading.2.markdown punctuation.definition.heading.markdown",
+        "heading.2.markdown",
+        "heading.2.quarto punctuation.definition.heading.quarto",
+        "heading.2.quarto",
+        "markup.heading.atx.2.mdx",
+        "markup.heading.atx.2.mdx punctuation.definition.heading.mdx",
+        "markup.heading.setext.2.markdown",
+        "markup.heading.heading-1.asciidoc"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "heading.3.markdown punctuation.definition.heading.markdown",
+        "heading.3.markdown",
+        "heading.3.quarto punctuation.definition.heading.quarto",
+        "heading.3.quarto",
+        "markup.heading.atx.3.mdx",
+        "markup.heading.atx.3.mdx punctuation.definition.heading.mdx",
+        "markup.heading.heading-2.asciidoc"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "heading.4.markdown punctuation.definition.heading.markdown",
+        "heading.4.markdown",
+        "heading.4.quarto punctuation.definition.heading.quarto",
+        "heading.4.quarto",
+        "markup.heading.atx.4.mdx",
+        "markup.heading.atx.4.mdx punctuation.definition.heading.mdx",
+        "markup.heading.heading-3.asciidoc"
+      ],
+      settings: {
+        foreground: "#88DCB7"
+      }
+    },
+    {
+      scope: [
+        "heading.5.markdown punctuation.definition.heading.markdown",
+        "heading.5.markdown",
+        "heading.5.quarto punctuation.definition.heading.quarto",
+        "heading.5.quarto",
+        "markup.heading.atx.5.mdx",
+        "markup.heading.atx.5.mdx punctuation.definition.heading.mdx",
+        "markup.heading.heading-4.asciidoc"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "heading.6.markdown punctuation.definition.heading.markdown",
+        "heading.6.markdown",
+        "heading.6.quarto punctuation.definition.heading.quarto",
+        "heading.6.quarto",
+        "markup.heading.atx.6.mdx",
+        "markup.heading.atx.6.mdx punctuation.definition.heading.mdx",
+        "markup.heading.heading-5.asciidoc"
+      ],
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "markup.bold",
+      settings: {
+        foreground: "#F7869B",
+        fontStyle: "bold"
+      }
+    },
+    {
+      scope: "markup.italic",
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: "markup.strikethrough",
+      settings: {
+        foreground: "#A6ADC8",
+        fontStyle: "strikethrough"
+      }
+    },
+    {
+      scope: ["punctuation.definition.link", "markup.underline.link"],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "text.html.markdown punctuation.definition.link.title",
+        "text.html.quarto punctuation.definition.link.title",
+        "string.other.link.title.markdown",
+        "string.other.link.title.quarto",
+        "markup.link",
+        "punctuation.definition.constant.markdown",
+        "punctuation.definition.constant.quarto",
+        "constant.other.reference.link.markdown",
+        "constant.other.reference.link.quarto",
+        "markup.substitution.attribute-reference"
+      ],
+      settings: {
+        foreground: "#B4BEFE"
+      }
+    },
+    {
+      scope: [
+        "punctuation.definition.raw.markdown",
+        "punctuation.definition.raw.quarto",
+        "markup.inline.raw.string.markdown",
+        "markup.inline.raw.string.quarto",
+        "markup.raw.block.markdown",
+        "markup.raw.block.quarto"
+      ],
+      settings: {
+        foreground: "#88DCB7"
+      }
+    },
+    {
+      scope: "fenced_code.block.language",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "markup.fenced_code.block punctuation.definition",
+        "markup.raw support.asciidoc"
+      ],
+      settings: {
+        foreground: "#A1A4A5"
+      }
+    },
+    {
+      scope: ["markup.quote", "punctuation.definition.quote.begin"],
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: "meta.separator.markdown",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: [
+        "punctuation.definition.list.begin.markdown",
+        "punctuation.definition.list.begin.quarto",
+        "markup.list.bullet"
+      ],
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "markup.heading.quarto",
+      settings: {
+        fontStyle: "bold"
+      }
+    },
+    {
+      scope: [
+        "entity.other.attribute-name.multipart.nix",
+        "entity.other.attribute-name.single.nix"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "variable.parameter.name.nix",
+      settings: {
+        foreground: "#E7E7E8",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "meta.embedded variable.parameter.name.nix",
+      settings: {
+        foreground: "#B4BEFE",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "string.unquoted.path.nix",
+      settings: {
+        foreground: "#EFB7C2",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["support.attribute.builtin", "meta.attribute.php"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "meta.function.parameters.php punctuation.definition.variable.php",
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: "constant.language.php",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "text.html.php support.function",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "keyword.other.phpdoc.php",
+      settings: {
+        fontStyle: ""
+      }
+    },
+    {
+      scope: ["support.variable.magic.python", "meta.function-call.arguments.python"],
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: ["support.function.magic.python"],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "variable.parameter.function.language.special.self.python",
+        "variable.language.special.self.python"
+      ],
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: ["keyword.control.flow.python", "keyword.operator.logical.python"],
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "storage.type.function.python",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: [
+        "support.token.decorator.python",
+        "meta.function.decorator.identifier.python"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: ["meta.function-call.python"],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "entity.name.function.decorator.python",
+        "punctuation.definition.decorator.python"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "constant.character.format.placeholder.other.python",
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: ["support.type.exception.python", "support.function.builtin.python"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: ["support.type.python"],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "constant.language.python",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: ["meta.indexed-name.python", "meta.item-access.python"],
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: "storage.type.string.python",
+      settings: {
+        foreground: "#88DCB7"
+      }
+    },
+    {
+      scope: "meta.function.parameters.python",
+      settings: {
+        fontStyle: ""
+      }
+    },
+    {
+      scope: [
+        "string.regexp punctuation.definition.string.begin",
+        "string.regexp punctuation.definition.string.end"
+      ],
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: "keyword.control.anchor.regexp",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "string.regexp.ts",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: [
+        "punctuation.definition.group.regexp",
+        "keyword.other.back-reference.regexp"
+      ],
+      settings: {
+        foreground: "#88DCB7"
+      }
+    },
+    {
+      scope: "punctuation.definition.character-class.regexp",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "constant.other.character-class.regexp",
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: "constant.other.character-class.range.regexp",
+      settings: {
+        foreground: "#F5E0DC"
+      }
+    },
+    {
+      scope: "keyword.operator.quantifier.regexp",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "constant.character.numeric.regexp",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "punctuation.definition.group.no-capture.regexp",
+        "meta.assertion.look-ahead.regexp",
+        "meta.assertion.negative-look-ahead.regexp"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: [
+        "meta.annotation.rust",
+        "meta.annotation.rust punctuation",
+        "meta.attribute.rust",
+        "punctuation.definition.attribute.rust"
+      ],
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "meta.attribute.rust string.quoted.double.rust",
+        "meta.attribute.rust string.quoted.single.char.rust"
+      ],
+      settings: {
+        fontStyle: ""
+      }
+    },
+    {
+      scope: [
+        "entity.name.function.macro.rules.rust",
+        "storage.type.module.rust",
+        "storage.modifier.rust",
+        "storage.type.struct.rust",
+        "storage.type.enum.rust",
+        "storage.type.trait.rust",
+        "storage.type.union.rust",
+        "storage.type.impl.rust",
+        "storage.type.rust",
+        "storage.type.function.rust",
+        "storage.type.type.rust"
+      ],
+      settings: {
+        foreground: "#C6A5EA",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "entity.name.type.numeric.rust",
+      settings: {
+        foreground: "#C6A5EA",
+        fontStyle: ""
+      }
+    },
+    {
+      scope: "meta.generic.rust",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "entity.name.impl.rust",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "entity.name.module.rust",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "entity.name.trait.rust",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "storage.type.source.rust",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "entity.name.union.rust",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: "meta.enum.rust storage.type.source.rust",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: [
+        "support.macro.rust",
+        "meta.macro.rust support.function.rust",
+        "entity.name.function.macro.rust"
+      ],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: ["storage.modifier.lifetime.rust", "entity.name.type.lifetime"],
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "string.quoted.double.rust constant.other.placeholder.rust",
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: "meta.function.return-type.rust meta.generic.rust storage.type.rust",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "meta.function.call.rust",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "punctuation.brackets.angle.rust",
+      settings: {
+        foreground: "#9DAFFA"
+      }
+    },
+    {
+      scope: "constant.other.caps.rust",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: ["meta.function.definition.rust variable.other.rust"],
+      settings: {
+        foreground: "#F39EAE"
+      }
+    },
+    {
+      scope: "meta.function.call.rust variable.other.rust",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "variable.language.self.rust",
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: [
+        "variable.other.metavariable.name.rust",
+        "meta.macro.metavariable.rust keyword.operator.macro.dollar.rust"
+      ],
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: [
+        "comment.line.shebang",
+        "comment.line.shebang punctuation.definition.comment",
+        "comment.line.shebang",
+        "punctuation.definition.comment.shebang.shell",
+        "meta.shebang.shell"
+      ],
+      settings: {
+        foreground: "#EFB7C2"
+      }
+    },
+    {
+      scope: "comment.line.shebang constant.language",
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: [
+        "meta.function-call.arguments.shell punctuation.definition.variable.shell",
+        "meta.function-call.arguments.shell punctuation.section.interpolation",
+        "meta.function-call.arguments.shell punctuation.definition.variable.shell",
+        "meta.function-call.arguments.shell punctuation.section.interpolation"
+      ],
+      settings: {
+        foreground: "#F7869B"
+      }
+    },
+    {
+      scope: "meta.string meta.interpolation.parameter.shell variable.other.readwrite",
+      settings: {
+        foreground: "#EDD5A6"
+      }
+    },
+    {
+      scope: [
+        "source.shell punctuation.section.interpolation",
+        "punctuation.definition.evaluation.backticks.shell"
+      ],
+      settings: {
+        foreground: "#A7E0C8"
+      }
+    },
+    {
+      scope: "entity.name.tag.heredoc.shell",
+      settings: {
+        foreground: "#C6A5EA"
+      }
+    },
+    {
+      scope: "string.quoted.double.shell variable.other.normal.shell",
+      settings: {
+        foreground: "#E7E7E8"
+      }
+    },
+    {
+      scope: "token.info-token",
+      settings: {
+        foreground: "#8BA1FF"
+      }
+    },
+    {
+      scope: "token.warn-token",
+      settings: {
+        foreground: "#F5B944"
+      }
+    },
+    {
+      scope: "token.error-token",
+      settings: {
+        foreground: "#FB6E88"
+      }
+    },
+    {
+      scope: "token.debug-token",
+      settings: {
+        foreground: "#BE95EB"
+      }
+    }
+  ]
+};
+
+// components/src/asciidoc/util.ts
+var highlighter = null;
+var customLanguages = ["oxql"];
+var supportedLanguages = [...Object.keys(bundledLanguages), ...customLanguages];
+async function getOrCreateHighlighter() {
+  if (!highlighter) {
+    const langs = [];
+    langs.push({
+      ...oxql_tmLanguage_default
+    });
+    highlighter = await getHighlighter({
+      themes: [oxide_dark_default],
+      langs
+    });
+  }
+  return highlighter;
+}
+var highlight = async (block) => {
+  if (block.type === "listing") {
+    const literalBlock = block;
+    if (!literalBlock.content) {
+      return block;
+    }
+    const calloutRegex = /<i class="conum" data-value="\d+"><\/i>/g;
+    const callouts = [];
+    const placeholderContent = literalBlock.content.replace(calloutRegex, (match) => {
+      callouts.push(match);
+      return `__CALLOUT_PLACEHOLDER_${callouts.length - 1}__`;
+    });
+    if (!literalBlock.language) {
+      return {
+        ...block,
+        content: placeholderContent.replace(
+          /__CALLOUT_PLACEHOLDER_(\d+)__/g,
+          (_, index) => callouts[parseInt(index)]
+        )
+      };
+    }
+    let lang = literalBlock.language;
+    const h = await getOrCreateHighlighter();
+    const loadedLanguages = h.getLoadedLanguages();
+    if (!supportedLanguages.includes(lang)) {
+      lang = "text";
+    }
+    if (!loadedLanguages.includes(lang)) {
+      await h.loadLanguage(lang);
+    }
+    const highlightedContent = h.codeToHtml(placeholderContent, {
+      lang,
+      theme: oxide_dark_default,
+      structure: "inline"
+    });
+    const restoredContent = highlightedContent.replace(
+      /__CALLOUT_PLACEHOLDER_(\d+)__/g,
+      (_, index) => callouts[parseInt(index)]
+    );
+    return {
+      ...block,
+      content: restoredContent
+    };
+  }
+  return block;
 };
-var make = (tag) => (
-  // only one argument here means string interpolations are not allowed
-  (strings) => {
-    const Comp = ({ className, children, ...rest }) => createElement(tag, { className: cn(strings[0], className), ...rest }, children);
-    Comp.displayName = `classed.${tag}`;
-    return Comp;
+var attrs = {
+  sectlinks: "true",
+  stem: "latexmath",
+  stylesheet: false
+};
+var loadAsciidoctor = ({
+  extensions = []
+}) => {
+  const ad2 = asciidoctor();
+  class InlineConverter2 {
+    baseConverter;
+    constructor() {
+      this.baseConverter = new ad2.Html5Converter();
+    }
+    convert(node2, transform) {
+      switch (node2.getNodeName()) {
+        case "inline_callout":
+          return convertInlineCallout(node2);
+        default:
+          break;
+      }
+      return this.baseConverter.convert(node2, transform);
+    }
   }
-);
-var classed = {
-  button: make("button"),
-  div: make("div"),
-  h1: make("h1"),
-  h2: make("h2"),
-  h3: make("h3"),
-  h4: make("h4"),
-  hr: make("hr"),
-  header: make("header"),
-  input: make("input"),
-  label: make("label"),
-  li: make("li"),
-  main: make("main"),
-  ol: make("ol"),
-  p: make("p"),
-  span: make("span"),
-  table: make("table"),
-  tbody: make("tbody"),
-  td: make("td"),
-  th: make("th"),
-  tr: make("tr")
+  extensions.forEach((extension) => ad2.Extensions.register(extension));
+  ad2.ConverterFactory.register(new InlineConverter2(), ["html5"]);
+  return ad2;
+};
+function convertInlineCallout(node2) {
+  return `<i class="conum" data-value="${node2.getText()}"></i>`;
+}
+var handleDocument = async (document2) => {
+  const doc = prepareDocument(document2);
+  return await processDocument(doc, highlight);
 };
 
-// components/src/asciidoc/Admonition.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
-var Admonition = ({ node }) => {
-  const attrs = node.attributes;
-  let icon;
-  if (attrs.name === "caution") {
-    icon = /* @__PURE__ */ jsx(Error12, {});
-  } else if (attrs.name === "warning") {
-    icon = /* @__PURE__ */ jsx(Warning12, {});
+// components/src/asciidoc/index.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var MinimalDocument = ({ document: document2 }) => /* @__PURE__ */ jsx10("div", { id: "content", className: "asciidoc-body w-full", children: /* @__PURE__ */ jsx10(Content4, { blocks: document2.blocks }) });
+var AsciiDocBlocks = {
+  Admonition: Admonition_default,
+  Table: Table_default,
+  Section: Section_default,
+  Mermaid: Mermaid_default,
+  MinimalDocument
+};
+var renderWithBreaks = (text) => {
+  return text.split(/(<[^>]*>)/g).map((segment) => {
+    if (segment.startsWith("<") && segment.endsWith(">")) {
+      return segment;
+    }
+    return segment.replace(/(?:^|(?<=\S))\/(?=\S)/g, "/<wbr/>");
+  }).join("");
+};
+var QUOTE_TAGS = {
+  "monospaced": ["<code>", "</code>", true],
+  "emphasis": ["<em>", "</em>", true],
+  "strong": ["<strong>", "</strong>", true],
+  "double": ["&#8220;", "&#8221;"],
+  "single": ["&#8216;", "&#8217;"],
+  "mark": ["<mark>", "</mark>", true],
+  "superscript": ["<sup>", "</sup>", true],
+  "subscript": ["<sub>", "</sub>", true],
+  "unquoted": ["<span>", "</span>", true],
+  "asciimath": ["\\$", "\\$"],
+  "latexmath": ["\\(", "\\)"]
+};
+var chop = (str) => str.substring(0, str.length - 1);
+var convertInlineQuoted = (node2) => {
+  const type = node2.getType();
+  const quoteTag = QUOTE_TAGS[type];
+  const [open, close, tag] = quoteTag || ["", ""];
+  let text = node2.getText();
+  if (type === "monospaced") {
+    text = renderWithBreaks(text);
+  }
+  const id26 = node2.getId();
+  const role = node2.getRole();
+  const idAttr = id26 ? `id="${id26}"` : "";
+  const classAttr = role ? `class="${role}"` : "";
+  const attrs2 = `${idAttr} ${classAttr}`;
+  if (id26 || role) {
+    if (tag) {
+      return `${chop(open)} ${attrs2}>${text}${close}`;
+    } else {
+      return `<span ${attrs2}>${open}${text}${close}</span>`;
+    }
   } else {
-    icon = /* @__PURE__ */ jsx(Error12, { className: "rotate-180" });
+    return `${open}${text}${close}`;
   }
-  return /* @__PURE__ */ jsxs("div", { className: `admonitionblock ${attrs.name}`, children: [
-    /* @__PURE__ */ jsx("div", { className: "admonition-icon", children: icon }),
-    /* @__PURE__ */ jsxs("div", { className: "admonition-content content", children: [
-      /* @__PURE__ */ jsx(Title, { text: node.title }),
-      /* @__PURE__ */ jsx("div", { children: titleCase(attrs.name.toString()) }),
-      /* @__PURE__ */ jsxs("div", { children: [
-        /* @__PURE__ */ jsx(Title, { text: node.title }),
-        node.content && parse(node.content),
-        /* @__PURE__ */ jsx(Content, { blocks: node.blocks })
-      ] })
-    ] })
-  ] });
 };
-var Error12 = ({ className }) => /* @__PURE__ */ jsx(
-  "svg",
-  {
-    width: "12",
-    height: "12",
-    viewBox: "0 0 12 12",
-    xmlns: "http://www.w3.org/2000/svg",
-    className,
-    children: /* @__PURE__ */ jsx(
-      "path",
-      {
-        fillRule: "evenodd",
-        clipRule: "evenodd",
-        d: "M6 12A6 6 0 1 0 6 0a6 6 0 0 0 0 12Zm.083-9c.368 0 .667.299.667.667v2.666A.667.667 0 0 1 6.083 7h-.166a.667.667 0 0 1-.667-.667V3.667c0-.368.299-.667.667-.667h.166Zm0 5c.368 0 .667.299.667.667v.166a.667.667 0 0 1-.667.667h-.166a.667.667 0 0 1-.667-.667v-.166c0-.368.299-.667.667-.667h.166Z",
-        fill: "currentColor"
-      }
-    )
+function convertInlineCallout2(node2) {
+  return `<i class="conum" data-value="${node2.getText()}"></i>`;
+}
+var ad = asciidoctor2();
+var InlineConverter = class {
+  baseConverter;
+  constructor() {
+    this.baseConverter = new ad.Html5Converter();
   }
-);
-var Warning12 = ({ className }) => /* @__PURE__ */ jsx(
-  "svg",
-  {
-    width: "12",
-    height: "12",
-    viewBox: "0 0 12 12",
-    xmlns: "http://www.w3.org/2000/svg",
-    className,
-    children: /* @__PURE__ */ jsx(
-      "path",
-      {
-        fillRule: "evenodd",
-        clipRule: "evenodd",
-        d: "M6 12A6 6 0 1 0 6 0a6 6 0 0 0 0 12Zm.083-9c.368 0 .667.299.667.667v2.666A.667.667 0 0 1 6.083 7h-.166a.667.667 0 0 1-.667-.667V3.667c0-.368.299-.667.667-.667h.166Zm0 5c.368 0 .667.299.667.667v.166a.667.667 0 0 1-.667.667h-.166a.667.667 0 0 1-.667-.667v-.166c0-.368.299-.667.667-.667h.166Z",
-        fill: "currentColor"
-      }
-    )
+  convert(node2, transform) {
+    switch (node2.getNodeName()) {
+      case "inline_quoted":
+        return convertInlineQuoted(node2);
+      case "inline_callout":
+        return convertInlineCallout2(node2);
+      default:
+        break;
+    }
+    return this.baseConverter.convert(node2, transform);
   }
-);
-var Admonition_default = Admonition;
-
-// components/src/asciidoc/Table.tsx
-import { Table as InnerTable } from "@oxide/react-asciidoc";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var Table = ({ node }) => /* @__PURE__ */ jsx2("div", { className: "table-wrapper", children: /* @__PURE__ */ jsx2(InnerTable, { node }) });
-var Table_default = Table;
-
-// components/src/asciidoc/index.ts
-var AsciiDocBlocks = {
-  Admonition: Admonition_default,
-  Table: Table_default
 };
 
 // components/src/ui/badge/Badge.tsx
-import cn2 from "classnames";
-import { jsx as jsx3 } from "react/jsx-runtime";
+import cn4 from "classnames";
+import { jsx as jsx11 } from "react/jsx-runtime";
 var badgeColors = {
   default: {
     default: `ring-1 ring-inset bg-accent-secondary text-accent ring-[rgba(var(--base-green-800-rgb),0.15)]`,
@@ -145,25 +3759,25 @@ var Badge = ({
   color = "default",
   variant = "default"
 }) => {
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx11(
     "span",
     {
-      className: cn2(
+      className: cn4(
         "ox-badge",
         `variant-${variant}`,
         "inline-flex h-4 items-center whitespace-nowrap rounded-sm px-[3px] py-[1px] uppercase text-mono-sm",
         badgeColors[variant][color],
         className
       ),
-      children: /* @__PURE__ */ jsx3("span", { children })
+      children: /* @__PURE__ */ jsx11("span", { children })
     }
   );
 };
 
 // components/src/ui/button/Button.tsx
-import cn3 from "classnames";
+import cn5 from "classnames";
 import { forwardRef } from "react";
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
 var buttonSizes = ["sm", "icon", "base"];
 var variants = ["primary", "secondary", "ghost", "danger"];
 var sizeStyle = {
@@ -176,7 +3790,7 @@ var buttonStyle = ({
   size: size2 = "base",
   variant = "primary"
 } = {}) => {
-  return cn3(
+  return cn5(
     "ox-button inline-flex items-center justify-center rounded align-top elevation-1 disabled:cursor-not-allowed",
     `btn-${variant}`,
     sizeStyle[size2],
@@ -203,10 +3817,10 @@ var Button = forwardRef(
     ...rest
   }, ref) => {
     const isDisabled = disabled || loading;
-    return /* @__PURE__ */ jsxs2(
+    return /* @__PURE__ */ jsxs9(
       "button",
       {
-        className: cn3(buttonStyle({ size: size2, variant }), className, {
+        className: cn5(buttonStyle({ size: size2, variant }), className, {
           "visually-disabled": isDisabled
         }),
         ref,
@@ -216,8 +3830,8 @@ var Button = forwardRef(
         "aria-disabled": isDisabled,
         ...rest,
         children: [
-          loading && /* @__PURE__ */ jsx4(Spinner, { className: "absolute", variant }),
-          /* @__PURE__ */ jsx4("span", { className: cn3("flex items-center", innerClassName, { invisible: loading }), children })
+          loading && /* @__PURE__ */ jsx12(Spinner, { className: "absolute", variant }),
+          /* @__PURE__ */ jsx12("span", { className: cn5("flex items-center", innerClassName, { invisible: loading }), children })
         ]
       }
     );
@@ -225,9 +3839,9 @@ var Button = forwardRef(
 );
 
 // components/src/ui/spinner/Spinner.tsx
-import cn4 from "classnames";
-import { useEffect, useRef, useState } from "react";
-import { Fragment, jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+import cn6 from "classnames";
+import { useEffect as useEffect2, useRef as useRef2, useState as useState3 } from "react";
+import { Fragment as Fragment4, jsx as jsx13, jsxs as jsxs10 } from "react/jsx-runtime";
 var spinnerSizes = ["base", "lg"];
 var spinnerVariants = ["primary", "secondary", "ghost", "danger"];
 var Spinner = ({
@@ -239,7 +3853,7 @@ var Spinner = ({
   const center = size2 === "lg" ? 18 : 6;
   const radius = size2 === "lg" ? 16 : 5;
   const strokeWidth = size2 === "lg" ? 3 : 2;
-  return /* @__PURE__ */ jsxs3(
+  return /* @__PURE__ */ jsxs10(
     "svg",
     {
       width: frameSize,
@@ -248,9 +3862,9 @@ var Spinner = ({
       fill: "none",
       xmlns: "http://www.w3.org/2000/svg",
       "aria-labelledby": "Spinner",
-      className: cn4("spinner", `spinner-${variant}`, `spinner-${size2}`, className),
+      className: cn6("spinner", `spinner-${variant}`, `spinner-${size2}`, className),
       children: [
-        /* @__PURE__ */ jsx5(
+        /* @__PURE__ */ jsx13(
           "circle",
           {
             fill: "none",
@@ -263,7 +3877,7 @@ var Spinner = ({
             strokeOpacity: 0.2
           }
         ),
-        /* @__PURE__ */ jsx5(
+        /* @__PURE__ */ jsx13(
           "circle",
           {
             className: "path",
@@ -281,10 +3895,10 @@ var Spinner = ({
   );
 };
 var SpinnerLoader = ({ isLoading, children = null, minTime = 500 }) => {
-  const [isVisible, setIsVisible] = useState(isLoading);
-  const hideTimeout = useRef(null);
-  const loadingStartTime = useRef(0);
-  useEffect(() => {
+  const [isVisible, setIsVisible] = useState3(isLoading);
+  const hideTimeout = useRef2(null);
+  const loadingStartTime = useRef2(0);
+  useEffect2(() => {
     if (isLoading) {
       setIsVisible(true);
       loadingStartTime.current = Date.now();
@@ -304,88 +3918,24 @@ var SpinnerLoader = ({ isLoading, children = null, minTime = 500 }) => {
         clearTimeout(hideTimeout.current);
     };
   }, [isLoading, minTime]);
-  return isVisible ? /* @__PURE__ */ jsx5(Spinner, {}) : /* @__PURE__ */ jsx5(Fragment, { children });
+  return isVisible ? /* @__PURE__ */ jsx13(Spinner, {}) : /* @__PURE__ */ jsx13(Fragment4, { children });
 };
 
 // components/src/ui/tabs/Tabs.tsx
-import { Content as Content2, List, Root, Trigger } from "@radix-ui/react-tabs";
-import cn5 from "classnames";
-import { jsx as jsx6 } from "react/jsx-runtime";
+import { Content as Content5, List, Root as Root2, Trigger as Trigger2 } from "@radix-ui/react-tabs";
+import cn7 from "classnames";
+import { jsx as jsx14 } from "react/jsx-runtime";
 var Tabs = {
-  Root: ({ className, ...props }) => /* @__PURE__ */ jsx6(Root, { ...props, className: cn5("ox-tabs", className) }),
-  Trigger: ({ children, className, ...props }) => /* @__PURE__ */ jsx6(Trigger, { ...props, className: cn5("ox-tab", className), children: /* @__PURE__ */ jsx6("div", { children }) }),
-  List: ({ className, ...props }) => /* @__PURE__ */ jsx6(List, { ...props, className: cn5("ox-tabs-list", className) }),
-  Content: ({ className, ...props }) => /* @__PURE__ */ jsx6(Content2, { ...props, className: cn5("ox-tabs-panel", className) })
+  Root: ({ className, ...props }) => /* @__PURE__ */ jsx14(Root2, { ...props, className: cn7("ox-tabs", className) }),
+  Trigger: ({ children, className, ...props }) => /* @__PURE__ */ jsx14(Trigger2, { ...props, className: cn7("ox-tab", className), children: /* @__PURE__ */ jsx14("div", { children }) }),
+  List: ({ className, ...props }) => /* @__PURE__ */ jsx14(List, { ...props, className: cn7("ox-tabs-list", className) }),
+  Content: ({ className, ...props }) => /* @__PURE__ */ jsx14(Content5, { ...props, className: cn7("ox-tabs-panel", className) })
 };
 
-// icons/react/Checkmark12Icon.tsx
-import { jsx as jsx7, jsxs as jsxs4 } from "react/jsx-runtime";
-var Checkmark12Icon = ({
-  title,
-  titleId,
-  ...props
-}) => /* @__PURE__ */ jsxs4(
-  "svg",
-  {
-    width: 12,
-    height: 12,
-    viewBox: "0 0 12 12",
-    xmlns: "http://www.w3.org/2000/svg",
-    role: "img",
-    "aria-labelledby": titleId,
-    ...props,
-    children: [
-      title ? /* @__PURE__ */ jsx7("title", { id: titleId, children: title }) : null,
-      /* @__PURE__ */ jsx7(
-        "path",
-        {
-          fillRule: "evenodd",
-          clipRule: "evenodd",
-          d: "M10.492 2.651c.28.242.31.665.067.944L5.447 9.463a.667.667 0 0 1-.974.035L1.475 6.516a.667.667 0 0 1 0-.946l.237-.235a.667.667 0 0 1 .94 0l2.24 2.226L9.3 2.501a.667.667 0 0 1 .938-.068l.253.218Z",
-          fill: "currentColor"
-        }
-      )
-    ]
-  }
-);
-var Checkmark12Icon_default = Checkmark12Icon;
-
-// icons/react/SelectArrows6Icon.tsx
-import { jsx as jsx8, jsxs as jsxs5 } from "react/jsx-runtime";
-var SelectArrows6Icon = ({
-  title,
-  titleId,
-  ...props
-}) => /* @__PURE__ */ jsxs5(
-  "svg",
-  {
-    width: 6,
-    height: 14,
-    viewBox: "0 0 6 14",
-    xmlns: "http://www.w3.org/2000/svg",
-    role: "img",
-    "aria-labelledby": titleId,
-    ...props,
-    children: [
-      title ? /* @__PURE__ */ jsx8("title", { id: titleId, children: title }) : null,
-      /* @__PURE__ */ jsx8(
-        "path",
-        {
-          fillRule: "evenodd",
-          clipRule: "evenodd",
-          d: "M3.322.536a.375.375 0 0 0-.644 0L.341 4.432C.19 4.682.37 5 .662 5h4.676a.375.375 0 0 0 .321-.568L3.322.536Zm-.644 12.928a.375.375 0 0 0 .644 0l2.337-3.896A.375.375 0 0 0 5.338 9H.662a.375.375 0 0 0-.321.568l2.337 3.896Z",
-          fill: "currentColor"
-        }
-      )
-    ]
-  }
-);
-var SelectArrows6Icon_default = SelectArrows6Icon;
-
 // components/src/ui/checkbox/Checkbox.tsx
-import cn6 from "classnames";
-import { jsx as jsx9, jsxs as jsxs6 } from "react/jsx-runtime";
-var Check = () => /* @__PURE__ */ jsx9(Checkmark12Icon_default, { className: "pointer-events-none absolute left-0.5 top-0.5 h-3 w-3 fill-current text-accent" });
+import cn8 from "classnames";
+import { jsx as jsx15, jsxs as jsxs11 } from "react/jsx-runtime";
+var Check = () => /* @__PURE__ */ jsx15(Checkmark12Icon_default, { className: "pointer-events-none absolute left-0.5 top-0.5 h-3 w-3 fill-current text-accent" });
 var Indeterminate = classed.div`absolute w-2 h-0.5 left-1 top-[7px] bg-accent pointer-events-none`;
 var inputStyle = `
   appearance-none border border-default bg-default h-4 w-4 rounded-sm absolute left-0 outline-none
@@ -399,28 +3949,28 @@ var Checkbox = ({
   children,
   className,
   ...inputProps
-}) => /* @__PURE__ */ jsxs6("label", { className: "inline-flex items-center", children: [
-  /* @__PURE__ */ jsxs6("span", { className: "relative h-4 w-4", children: [
-    /* @__PURE__ */ jsx9(
+}) => /* @__PURE__ */ jsxs11("label", { className: "inline-flex items-center", children: [
+  /* @__PURE__ */ jsxs11("span", { className: "relative h-4 w-4", children: [
+    /* @__PURE__ */ jsx15(
       "input",
       {
-        className: cn6(inputStyle, className),
+        className: cn8(inputStyle, className),
         type: "checkbox",
         ref: (el) => el && (el.indeterminate = !!indeterminate),
         ...inputProps
       }
     ),
-    inputProps.checked && !indeterminate && /* @__PURE__ */ jsx9(Check, {}),
-    indeterminate && /* @__PURE__ */ jsx9(Indeterminate, {})
+    inputProps.checked && !indeterminate && /* @__PURE__ */ jsx15(Check, {}),
+    indeterminate && /* @__PURE__ */ jsx15(Indeterminate, {})
   ] }),
-  children && /* @__PURE__ */ jsx9("span", { className: "ml-2.5 text-sans-md text-secondary", children })
+  children && /* @__PURE__ */ jsx15("span", { className: "ml-2.5 text-sans-md text-secondary", children })
 ] });
 
 // components/src/ui/listbox/Listbox.tsx
 import { FloatingPortal, flip, offset, size, useFloating } from "@floating-ui/react";
 import { Listbox as Select } from "@headlessui/react";
-import cn7 from "classnames";
-import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs7 } from "react/jsx-runtime";
+import cn9 from "classnames";
+import { Fragment as Fragment5, jsx as jsx16, jsxs as jsxs12 } from "react/jsx-runtime";
 var Listbox = ({
   name,
   selected,
@@ -449,19 +3999,19 @@ var Listbox = ({
   const selectedItem = selected && items.find((i) => i.value === selected);
   const noItems = !isLoading && items.length === 0;
   const isDisabled = disabled || noItems;
-  return /* @__PURE__ */ jsx10("div", { className: cn7("relative", className), children: /* @__PURE__ */ jsx10(
+  return /* @__PURE__ */ jsx16("div", { className: cn9("relative", className), children: /* @__PURE__ */ jsx16(
     Select,
     {
       value: selected,
       onChange: (val) => val !== null && onChange(val),
       disabled: isDisabled || isLoading,
-      children: ({ open }) => /* @__PURE__ */ jsxs7(Fragment2, { children: [
-        /* @__PURE__ */ jsxs7(
+      children: ({ open }) => /* @__PURE__ */ jsxs12(Fragment5, { children: [
+        /* @__PURE__ */ jsxs12(
           Select.Button,
           {
             name,
             ref: refs.setReference,
-            className: cn7(
+            className: cn9(
               `flex h-10 w-full items-center justify-between
                     rounded border text-sans-md`,
               hasError ? "focus-error border-error-secondary hover:border-error" : "border-default hover:border-hover",
@@ -472,37 +4022,37 @@ var Listbox = ({
             ),
             ...props,
             children: [
-              /* @__PURE__ */ jsx10("div", { className: "w-full px-3 text-left", children: selectedItem ? (
+              /* @__PURE__ */ jsx16("div", { className: "w-full px-3 text-left", children: selectedItem ? (
                 // labelString is one line, which is what we need when label is a ReactNode
                 selectedItem.labelString || selectedItem.label
-              ) : /* @__PURE__ */ jsx10("span", { className: "text-quaternary", children: noItems ? "No items" : placeholder }) }),
-              !isDisabled && /* @__PURE__ */ jsx10(SpinnerLoader, { isLoading }),
-              /* @__PURE__ */ jsx10(
+              ) : /* @__PURE__ */ jsx16("span", { className: "text-quaternary", children: noItems ? "No items" : placeholder }) }),
+              !isDisabled && /* @__PURE__ */ jsx16(SpinnerLoader, { isLoading }),
+              /* @__PURE__ */ jsx16(
                 "div",
                 {
                   className: "ml-3 flex h-[calc(100%-12px)] items-center border-l px-3 border-secondary",
                   "aria-hidden": true,
-                  children: /* @__PURE__ */ jsx10(SelectArrows6Icon_default, { className: "h-[14px] w-2 text-tertiary" })
+                  children: /* @__PURE__ */ jsx16(SelectArrows6Icon_default, { className: "h-[14px] w-2 text-tertiary" })
                 }
               )
             ]
           }
         ),
-        /* @__PURE__ */ jsx10(FloatingPortal, { children: /* @__PURE__ */ jsx10(
+        /* @__PURE__ */ jsx16(FloatingPortal, { children: /* @__PURE__ */ jsx16(
           Select.Options,
           {
             ref: refs.setFloating,
             style: floatingStyles,
             className: "ox-menu pointer-events-auto z-50 overflow-y-auto !outline-none",
-            children: items.map((item) => /* @__PURE__ */ jsx10(
+            children: items.map((item) => /* @__PURE__ */ jsx16(
               Select.Option,
               {
                 value: item.value,
                 className: "relative border-b border-secondary last:border-0",
-                children: ({ active, selected: selected2 }) => /* @__PURE__ */ jsx10(
+                children: ({ active, selected: selected2 }) => /* @__PURE__ */ jsx16(
                   "div",
                   {
-                    className: cn7(
+                    className: cn9(
                       "ox-menu-item text-secondary",
                       selected2 && "is-selected",
                       active && "is-highlighted"
@@ -524,15 +4074,33 @@ export {
   Badge,
   Button,
   Checkbox,
+  DesktopOutline,
+  InlineConverter,
   Listbox,
+  SmallScreenOutline,
   Spinner,
   SpinnerLoader,
   Tabs,
+  attrs,
   badgeColors,
   buttonSizes,
   buttonStyle,
+  handleDocument,
+  highlight,
+  loadAsciidoctor,
+  renderWithBreaks,
   spinnerSizes,
   spinnerVariants,
+  useActiveSectionTracking,
+  useIntersectionObserver,
   variants
 };
+/*! Bundled license information:
+
+mermaid/dist/mermaid.core.mjs:
+  (*! Check if previously processed *)
+  (*!
+   * Wait for document loaded before starting the execution
+   *)
+*/
 //# sourceMappingURL=index.js.map