jekyll-ham 1.0.2 → 1.1.1

data/assets/mermaid/classDiagram-fb54d2a0.js

@@ -0,0 +1,363 @@
+import { p as parser, d as db, s as styles } from "./styles-b83b31c9.js";
+import { line, curveBasis, select } from "d3";
+import { layout } from "dagre-d3-es/src/dagre/index.js";
+import * as graphlib from "dagre-d3-es/src/graphlib/index.js";
+import { u as utils, l as log, x as parseGenericTypes, c as getConfig, i as configureSvgSize } from "./mermaid-6dc72991.js";
+import "ts-dedent";
+import "dayjs";
+import "@braintree/sanitize-url";
+import "dompurify";
+import "khroma";
+import "lodash-es/memoize.js";
+import "lodash-es/merge.js";
+import "stylis";
+import "lodash-es/isEmpty.js";
+let edgeCount = 0;
+const drawEdge = function(elem, path, relation, conf, diagObj) {
+  const getRelationType = function(type) {
+    switch (type) {
+      case diagObj.db.relationType.AGGREGATION:
+        return "aggregation";
+      case diagObj.db.relationType.EXTENSION:
+        return "extension";
+      case diagObj.db.relationType.COMPOSITION:
+        return "composition";
+      case diagObj.db.relationType.DEPENDENCY:
+        return "dependency";
+      case diagObj.db.relationType.LOLLIPOP:
+        return "lollipop";
+    }
+  };
+  path.points = path.points.filter((p) => !Number.isNaN(p.y));
+  const lineData = path.points;
+  const lineFunction = line().x(function(d) {
+    return d.x;
+  }).y(function(d) {
+    return d.y;
+  }).curve(curveBasis);
+  const svgPath = elem.append("path").attr("d", lineFunction(lineData)).attr("id", "edge" + edgeCount).attr("class", "relation");
+  let url = "";
+  if (conf.arrowMarkerAbsolute) {
+    url = window.location.protocol + "//" + window.location.host + window.location.pathname + window.location.search;
+    url = url.replace(/\(/g, "\\(");
+    url = url.replace(/\)/g, "\\)");
+  }
+  if (relation.relation.lineType == 1) {
+    svgPath.attr("class", "relation dashed-line");
+  }
+  if (relation.relation.lineType == 10) {
+    svgPath.attr("class", "relation dotted-line");
+  }
+  if (relation.relation.type1 !== "none") {
+    svgPath.attr(
+      "marker-start",
+      "url(" + url + "#" + getRelationType(relation.relation.type1) + "Start)"
+    );
+  }
+  if (relation.relation.type2 !== "none") {
+    svgPath.attr(
+      "marker-end",
+      "url(" + url + "#" + getRelationType(relation.relation.type2) + "End)"
+    );
+  }
+  let x, y;
+  const l = path.points.length;
+  let labelPosition = utils.calcLabelPosition(path.points);
+  x = labelPosition.x;
+  y = labelPosition.y;
+  let p1_card_x, p1_card_y;
+  let p2_card_x, p2_card_y;
+  if (l % 2 !== 0 && l > 1) {
+    let cardinality_1_point = utils.calcCardinalityPosition(
+      relation.relation.type1 !== "none",
+      path.points,
+      path.points[0]
+    );
+    let cardinality_2_point = utils.calcCardinalityPosition(
+      relation.relation.type2 !== "none",
+      path.points,
+      path.points[l - 1]
+    );
+    log.debug("cardinality_1_point " + JSON.stringify(cardinality_1_point));
+    log.debug("cardinality_2_point " + JSON.stringify(cardinality_2_point));
+    p1_card_x = cardinality_1_point.x;
+    p1_card_y = cardinality_1_point.y;
+    p2_card_x = cardinality_2_point.x;
+    p2_card_y = cardinality_2_point.y;
+  }
+  if (relation.title !== void 0) {
+    const g = elem.append("g").attr("class", "classLabel");
+    const label = g.append("text").attr("class", "label").attr("x", x).attr("y", y).attr("fill", "red").attr("text-anchor", "middle").text(relation.title);
+    window.label = label;
+    const bounds = label.node().getBBox();
+    g.insert("rect", ":first-child").attr("class", "box").attr("x", bounds.x - conf.padding / 2).attr("y", bounds.y - conf.padding / 2).attr("width", bounds.width + conf.padding).attr("height", bounds.height + conf.padding);
+  }
+  log.info("Rendering relation " + JSON.stringify(relation));
+  if (relation.relationTitle1 !== void 0 && relation.relationTitle1 !== "none") {
+    const g = elem.append("g").attr("class", "cardinality");
+    g.append("text").attr("class", "type1").attr("x", p1_card_x).attr("y", p1_card_y).attr("fill", "black").attr("font-size", "6").text(relation.relationTitle1);
+  }
+  if (relation.relationTitle2 !== void 0 && relation.relationTitle2 !== "none") {
+    const g = elem.append("g").attr("class", "cardinality");
+    g.append("text").attr("class", "type2").attr("x", p2_card_x).attr("y", p2_card_y).attr("fill", "black").attr("font-size", "6").text(relation.relationTitle2);
+  }
+  edgeCount++;
+};
+const drawClass = function(elem, classDef, conf, diagObj) {
+  log.debug("Rendering class ", classDef, conf);
+  const id = classDef.id;
+  const classInfo = {
+    id,
+    label: classDef.id,
+    width: 0,
+    height: 0
+  };
+  const g = elem.append("g").attr("id", diagObj.db.lookUpDomId(id)).attr("class", "classGroup");
+  let title;
+  if (classDef.link) {
+    title = g.append("svg:a").attr("xlink:href", classDef.link).attr("target", classDef.linkTarget).append("text").attr("y", conf.textHeight + conf.padding).attr("x", 0);
+  } else {
+    title = g.append("text").attr("y", conf.textHeight + conf.padding).attr("x", 0);
+  }
+  let isFirst = true;
+  classDef.annotations.forEach(function(member) {
+    const titleText2 = title.append("tspan").text("«" + member + "»");
+    if (!isFirst) {
+      titleText2.attr("dy", conf.textHeight);
+    }
+    isFirst = false;
+  });
+  let classTitleString = getClassTitleString(classDef);
+  const classTitle = title.append("tspan").text(classTitleString).attr("class", "title");
+  if (!isFirst) {
+    classTitle.attr("dy", conf.textHeight);
+  }
+  const titleHeight = title.node().getBBox().height;
+  let membersLine;
+  let membersBox;
+  let methodsLine;
+  if (classDef.members.length > 0) {
+    membersLine = g.append("line").attr("x1", 0).attr("y1", conf.padding + titleHeight + conf.dividerMargin / 2).attr("y2", conf.padding + titleHeight + conf.dividerMargin / 2);
+    const members = g.append("text").attr("x", conf.padding).attr("y", titleHeight + conf.dividerMargin + conf.textHeight).attr("fill", "white").attr("class", "classText");
+    isFirst = true;
+    classDef.members.forEach(function(member) {
+      addTspan(members, member, isFirst, conf);
+      isFirst = false;
+    });
+    membersBox = members.node().getBBox();
+  }
+  if (classDef.methods.length > 0) {
+    methodsLine = g.append("line").attr("x1", 0).attr("y1", conf.padding + titleHeight + conf.dividerMargin + membersBox.height).attr("y2", conf.padding + titleHeight + conf.dividerMargin + membersBox.height);
+    const methods = g.append("text").attr("x", conf.padding).attr("y", titleHeight + 2 * conf.dividerMargin + membersBox.height + conf.textHeight).attr("fill", "white").attr("class", "classText");
+    isFirst = true;
+    classDef.methods.forEach(function(method) {
+      addTspan(methods, method, isFirst, conf);
+      isFirst = false;
+    });
+  }
+  const classBox = g.node().getBBox();
+  var cssClassStr = " ";
+  if (classDef.cssClasses.length > 0) {
+    cssClassStr = cssClassStr + classDef.cssClasses.join(" ");
+  }
+  const rect = g.insert("rect", ":first-child").attr("x", 0).attr("y", 0).attr("width", classBox.width + 2 * conf.padding).attr("height", classBox.height + conf.padding + 0.5 * conf.dividerMargin).attr("class", cssClassStr);
+  const rectWidth = rect.node().getBBox().width;
+  title.node().childNodes.forEach(function(x) {
+    x.setAttribute("x", (rectWidth - x.getBBox().width) / 2);
+  });
+  if (classDef.tooltip) {
+    title.insert("title").text(classDef.tooltip);
+  }
+  if (membersLine) {
+    membersLine.attr("x2", rectWidth);
+  }
+  if (methodsLine) {
+    methodsLine.attr("x2", rectWidth);
+  }
+  classInfo.width = rectWidth;
+  classInfo.height = classBox.height + conf.padding + 0.5 * conf.dividerMargin;
+  return classInfo;
+};
+const getClassTitleString = function(classDef) {
+  let classTitleString = classDef.id;
+  if (classDef.type) {
+    classTitleString += "<" + parseGenericTypes(classDef.type) + ">";
+  }
+  return classTitleString;
+};
+const drawNote = function(elem, note, conf, diagObj) {
+  log.debug("Rendering note ", note, conf);
+  const id = note.id;
+  const noteInfo = {
+    id,
+    text: note.text,
+    width: 0,
+    height: 0
+  };
+  const g = elem.append("g").attr("id", id).attr("class", "classGroup");
+  let text = g.append("text").attr("y", conf.textHeight + conf.padding).attr("x", 0);
+  const lines = JSON.parse(`"${note.text}"`).split("\n");
+  lines.forEach(function(line2) {
+    log.debug(`Adding line: ${line2}`);
+    text.append("tspan").text(line2).attr("class", "title").attr("dy", conf.textHeight);
+  });
+  const noteBox = g.node().getBBox();
+  const rect = g.insert("rect", ":first-child").attr("x", 0).attr("y", 0).attr("width", noteBox.width + 2 * conf.padding).attr(
+    "height",
+    noteBox.height + lines.length * conf.textHeight + conf.padding + 0.5 * conf.dividerMargin
+  );
+  const rectWidth = rect.node().getBBox().width;
+  text.node().childNodes.forEach(function(x) {
+    x.setAttribute("x", (rectWidth - x.getBBox().width) / 2);
+  });
+  noteInfo.width = rectWidth;
+  noteInfo.height = noteBox.height + lines.length * conf.textHeight + conf.padding + 0.5 * conf.dividerMargin;
+  return noteInfo;
+};
+const addTspan = function(textEl, member, isFirst, conf) {
+  const { displayText, cssStyle } = member.getDisplayDetails();
+  const tSpan = textEl.append("tspan").attr("x", conf.padding).text(displayText);
+  if (cssStyle !== "") {
+    tSpan.attr("style", member.cssStyle);
+  }
+  if (!isFirst) {
+    tSpan.attr("dy", conf.textHeight);
+  }
+};
+const svgDraw = {
+  getClassTitleString,
+  drawClass,
+  drawEdge,
+  drawNote
+};
+let idCache = {};
+const padding = 20;
+const getGraphId = function(label) {
+  const foundEntry = Object.entries(idCache).find((entry) => entry[1].label === label);
+  if (foundEntry) {
+    return foundEntry[0];
+  }
+};
+const insertMarkers = function(elem) {
+  elem.append("defs").append("marker").attr("id", "extensionStart").attr("class", "extension").attr("refX", 0).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 1,7 L18,13 V 1 Z");
+  elem.append("defs").append("marker").attr("id", "extensionEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 1,1 V 13 L18,7 Z");
+  elem.append("defs").append("marker").attr("id", "compositionStart").attr("class", "extension").attr("refX", 0).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z");
+  elem.append("defs").append("marker").attr("id", "compositionEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z");
+  elem.append("defs").append("marker").attr("id", "aggregationStart").attr("class", "extension").attr("refX", 0).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z");
+  elem.append("defs").append("marker").attr("id", "aggregationEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z");
+  elem.append("defs").append("marker").attr("id", "dependencyStart").attr("class", "extension").attr("refX", 0).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 5,7 L9,13 L1,7 L9,1 Z");
+  elem.append("defs").append("marker").attr("id", "dependencyEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L14,7 L9,1 Z");
+};
+const draw = function(text, id, _version, diagObj) {
+  const conf = getConfig().class;
+  idCache = {};
+  log.info("Rendering diagram " + text);
+  const securityLevel = getConfig().securityLevel;
+  let sandboxElement;
+  if (securityLevel === "sandbox") {
+    sandboxElement = select("#i" + id);
+  }
+  const root = securityLevel === "sandbox" ? select(sandboxElement.nodes()[0].contentDocument.body) : select("body");
+  const diagram2 = root.select(`[id='${id}']`);
+  insertMarkers(diagram2);
+  const g = new graphlib.Graph({
+    multigraph: true
+  });
+  g.setGraph({
+    isMultiGraph: true
+  });
+  g.setDefaultEdgeLabel(function() {
+    return {};
+  });
+  const classes = diagObj.db.getClasses();
+  const keys = Object.keys(classes);
+  for (const key of keys) {
+    const classDef = classes[key];
+    const node = svgDraw.drawClass(diagram2, classDef, conf, diagObj);
+    idCache[node.id] = node;
+    g.setNode(node.id, node);
+    log.info("Org height: " + node.height);
+  }
+  const relations = diagObj.db.getRelations();
+  relations.forEach(function(relation) {
+    log.info(
+      // cspell:ignore tjoho
+      "tjoho" + getGraphId(relation.id1) + getGraphId(relation.id2) + JSON.stringify(relation)
+    );
+    g.setEdge(
+      getGraphId(relation.id1),
+      getGraphId(relation.id2),
+      {
+        relation
+      },
+      relation.title || "DEFAULT"
+    );
+  });
+  const notes = diagObj.db.getNotes();
+  notes.forEach(function(note) {
+    log.debug(`Adding note: ${JSON.stringify(note)}`);
+    const node = svgDraw.drawNote(diagram2, note, conf, diagObj);
+    idCache[node.id] = node;
+    g.setNode(node.id, node);
+    if (note.class && note.class in classes) {
+      g.setEdge(
+        note.id,
+        getGraphId(note.class),
+        {
+          relation: {
+            id1: note.id,
+            id2: note.class,
+            relation: {
+              type1: "none",
+              type2: "none",
+              lineType: 10
+            }
+          }
+        },
+        "DEFAULT"
+      );
+    }
+  });
+  layout(g);
+  g.nodes().forEach(function(v) {
+    if (v !== void 0 && g.node(v) !== void 0) {
+      log.debug("Node " + v + ": " + JSON.stringify(g.node(v)));
+      root.select("#" + (diagObj.db.lookUpDomId(v) || v)).attr(
+        "transform",
+        "translate(" + (g.node(v).x - g.node(v).width / 2) + "," + (g.node(v).y - g.node(v).height / 2) + " )"
+      );
+    }
+  });
+  g.edges().forEach(function(e) {
+    if (e !== void 0 && g.edge(e) !== void 0) {
+      log.debug("Edge " + e.v + " -> " + e.w + ": " + JSON.stringify(g.edge(e)));
+      svgDraw.drawEdge(diagram2, g.edge(e), g.edge(e).relation, conf, diagObj);
+    }
+  });
+  const svgBounds = diagram2.node().getBBox();
+  const width = svgBounds.width + padding * 2;
+  const height = svgBounds.height + padding * 2;
+  configureSvgSize(diagram2, height, width, conf.useMaxWidth);
+  const vBox = `${svgBounds.x - padding} ${svgBounds.y - padding} ${width} ${height}`;
+  log.debug(`viewBox ${vBox}`);
+  diagram2.attr("viewBox", vBox);
+};
+const renderer = {
+  draw
+};
+const diagram = {
+  parser,
+  db,
+  renderer,
+  styles,
+  init: (cnf) => {
+    if (!cnf.class) {
+      cnf.class = {};
+    }
+    cnf.class.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute;
+    db.clear();
+  }
+};
+export {
+  diagram
+};

data/assets/mermaid/classDiagram-v2-640c694e.js

@@ -0,0 +1,206 @@
+import { p as R, d as N, s as $ } from "./styles-11e81fdd.js";
+import { l as c, c as r, j as k, A as B, t as G, o as E, q as A, n as C, f as _ } from "./mermaid-9f2aa176.js";
+import { G as q } from "./graph-0ee63739.js";
+import { r as z } from "./index-bb6d8841.js";
+import "./layout-fd473db2.js";
+import "./clone-afc2f047.js";
+import "./edges-16357fde.js";
+import "./createText-03b82060.js";
+import "./line-24d93f1b.js";
+import "./array-2ff2c7a6.js";
+import "./path-428ebac9.js";
+const S = (o) => _.sanitizeText(o, r());
+let v = {
+  dividerMargin: 10,
+  padding: 5,
+  textHeight: 10,
+  curve: void 0
+};
+const P = function(o, e, p, n) {
+  const t = Object.keys(o);
+  c.info("keys:", t), c.info(o), t.forEach(function(s) {
+    var y, d;
+    const l = o[s], i = {
+      shape: "rect",
+      id: l.id,
+      domId: l.domId,
+      labelText: S(l.id),
+      labelStyle: "",
+      style: "fill: none; stroke: black",
+      // TODO V10: Flowchart ? Keeping flowchart for backwards compatibility. Remove in next major release
+      padding: ((y = r().flowchart) == null ? void 0 : y.padding) ?? ((d = r().class) == null ? void 0 : d.padding)
+    };
+    e.setNode(l.id, i), I(l.classes, e, p, n, l.id), c.info("setNode", i);
+  });
+}, I = function(o, e, p, n, t) {
+  const s = Object.keys(o);
+  c.info("keys:", s), c.info(o), s.filter((l) => o[l].parent == t).forEach(function(l) {
+    var u, m;
+    const a = o[l], i = a.cssClasses.join(" "), y = E(a.styles), d = a.label ?? a.id, f = 0, h = "class_box", b = {
+      labelStyle: y.labelStyle,
+      shape: h,
+      labelText: S(d),
+      classData: a,
+      rx: f,
+      ry: f,
+      class: i,
+      style: y.style,
+      id: a.id,
+      domId: a.domId,
+      tooltip: n.db.getTooltip(a.id, t) || "",
+      haveCallback: a.haveCallback,
+      link: a.link,
+      width: a.type === "group" ? 500 : void 0,
+      type: a.type,
+      // TODO V10: Flowchart ? Keeping flowchart for backwards compatibility. Remove in next major release
+      padding: ((u = r().flowchart) == null ? void 0 : u.padding) ?? ((m = r().class) == null ? void 0 : m.padding)
+    };
+    e.setNode(a.id, b), t && e.setParent(a.id, t), c.info("setNode", b);
+  });
+}, F = function(o, e, p, n) {
+  c.info(o), o.forEach(function(t, s) {
+    var m, g;
+    const l = t, a = "", i = { labelStyle: "", style: "" }, y = l.text, d = 0, f = "note", h = {
+      labelStyle: i.labelStyle,
+      shape: f,
+      labelText: S(y),
+      noteData: l,
+      rx: d,
+      ry: d,
+      class: a,
+      style: i.style,
+      id: l.id,
+      domId: l.id,
+      tooltip: "",
+      type: "note",
+      // TODO V10: Flowchart ? Keeping flowchart for backwards compatibility. Remove in next major release
+      padding: ((m = r().flowchart) == null ? void 0 : m.padding) ?? ((g = r().class) == null ? void 0 : g.padding)
+    };
+    if (e.setNode(l.id, h), c.info("setNode", h), !l.class || !(l.class in n))
+      return;
+    const b = p + s, u = {
+      id: `edgeNote${b}`,
+      //Set relationship style and line type
+      classes: "relation",
+      pattern: "dotted",
+      // Set link type for rendering
+      arrowhead: "none",
+      //Set edge extra labels
+      startLabelRight: "",
+      endLabelLeft: "",
+      //Set relation arrow types
+      arrowTypeStart: "none",
+      arrowTypeEnd: "none",
+      style: "fill:none",
+      labelStyle: "",
+      curve: A(v.curve, C)
+    };
+    e.setEdge(l.id, l.class, u, b);
+  });
+}, H = function(o, e) {
+  const p = r().flowchart;
+  let n = 0;
+  o.forEach(function(t) {
+    var l;
+    n++;
+    const s = {
+      //Set relationship style and line type
+      classes: "relation",
+      pattern: t.relation.lineType == 1 ? "dashed" : "solid",
+      id: `id_${t.id1}_${t.id2}_${n}`,
+      // Set link type for rendering
+      arrowhead: t.type === "arrow_open" ? "none" : "normal",
+      //Set edge extra labels
+      startLabelRight: t.relationTitle1 === "none" ? "" : t.relationTitle1,
+      endLabelLeft: t.relationTitle2 === "none" ? "" : t.relationTitle2,
+      //Set relation arrow types
+      arrowTypeStart: D(t.relation.type1),
+      arrowTypeEnd: D(t.relation.type2),
+      style: "fill:none",
+      labelStyle: "",
+      curve: A(p == null ? void 0 : p.curve, C)
+    };
+    if (c.info(s, t), t.style !== void 0) {
+      const a = E(t.style);
+      s.style = a.style, s.labelStyle = a.labelStyle;
+    }
+    t.text = t.title, t.text === void 0 ? t.style !== void 0 && (s.arrowheadStyle = "fill: #333") : (s.arrowheadStyle = "fill: #333", s.labelpos = "c", ((l = r().flowchart) == null ? void 0 : l.htmlLabels) ?? r().htmlLabels ? (s.labelType = "html", s.label = '<span class="edgeLabel">' + t.text + "</span>") : (s.labelType = "text", s.label = t.text.replace(_.lineBreakRegex, `
+`), t.style === void 0 && (s.style = s.style || "stroke: #333; stroke-width: 1.5px;fill:none"), s.labelStyle = s.labelStyle.replace("color:", "fill:"))), e.setEdge(t.id1, t.id2, s, n);
+  });
+}, V = function(o) {
+  v = {
+    ...v,
+    ...o
+  };
+}, W = async function(o, e, p, n) {
+  c.info("Drawing class - ", e);
+  const t = r().flowchart ?? r().class, s = r().securityLevel;
+  c.info("config:", t);
+  const l = (t == null ? void 0 : t.nodeSpacing) ?? 50, a = (t == null ? void 0 : t.rankSpacing) ?? 50, i = new q({
+    multigraph: !0,
+    compound: !0
+  }).setGraph({
+    rankdir: n.db.getDirection(),
+    nodesep: l,
+    ranksep: a,
+    marginx: 8,
+    marginy: 8
+  }).setDefaultEdgeLabel(function() {
+    return {};
+  }), y = n.db.getNamespaces(), d = n.db.getClasses(), f = n.db.getRelations(), h = n.db.getNotes();
+  c.info(f), P(y, i, e, n), I(d, i, e, n), H(f, i), F(h, i, f.length + 1, d);
+  let b;
+  s === "sandbox" && (b = k("#i" + e));
+  const u = s === "sandbox" ? k(b.nodes()[0].contentDocument.body) : k("body"), m = u.select(`[id="${e}"]`), g = u.select("#" + e + " g");
+  if (await z(
+    g,
+    i,
+    ["aggregation", "extension", "composition", "dependency", "lollipop"],
+    "classDiagram",
+    e
+  ), B.insertTitle(m, "classTitleText", (t == null ? void 0 : t.titleTopMargin) ?? 5, n.db.getDiagramTitle()), G(i, m, t == null ? void 0 : t.diagramPadding, t == null ? void 0 : t.useMaxWidth), !(t != null && t.htmlLabels)) {
+    const T = s === "sandbox" ? b.nodes()[0].contentDocument : document, M = T.querySelectorAll('[id="' + e + '"] .edgeLabel .label');
+    for (const w of M) {
+      const L = w.getBBox(), x = T.createElementNS("http://www.w3.org/2000/svg", "rect");
+      x.setAttribute("rx", 0), x.setAttribute("ry", 0), x.setAttribute("width", L.width), x.setAttribute("height", L.height), w.insertBefore(x, w.firstChild);
+    }
+  }
+};
+function D(o) {
+  let e;
+  switch (o) {
+    case 0:
+      e = "aggregation";
+      break;
+    case 1:
+      e = "extension";
+      break;
+    case 2:
+      e = "composition";
+      break;
+    case 3:
+      e = "dependency";
+      break;
+    case 4:
+      e = "lollipop";
+      break;
+    default:
+      e = "none";
+  }
+  return e;
+}
+const J = {
+  setConf: V,
+  draw: W
+}, ot = {
+  parser: R,
+  db: N,
+  renderer: J,
+  styles: $,
+  init: (o) => {
+    o.class || (o.class = {}), o.class.arrowMarkerAbsolute = o.arrowMarkerAbsolute, N.clear();
+  }
+};
+export {
+  ot as diagram
+};