ranui 0.2.1-alpha.1 → 0.2.1-alpha.3

package/dist/blockDiagram-677ZJIJ3-3F79MOSt.js

@@ -0,0 +1,3321 @@
+import { n as u } from "./chunk-Y2CYZVJY-0JxdZxki.js";
+import { m as L, p as T } from "./src-DtRLxcYO.js";
+import { O as fe, T as M, a as pe, b as et, c as xe, it as ye, s as be, x as C, z as Ct } from "./chunk-WYO6CB5R-DDHkKowO.js";
+import { t as me } from "./channel-k5-UxdcV.js";
+import { A as we, B as Se, C as Le, D as ke, E as ve, F as Ee, G as Ut, H as _e, I as Te, L as De, M as Ne, N as Ie, O as Be, P as Oe, R as Ce, T as Re, U as Ae, V as ze, W as Me, a as Rt, b as Pe, et as Fe, g as J, j as We, k as Ye, l as He, v as Ke, w as Ue, z as Xe } from "./chunk-ICXQ74PX-DR8rL-xF.js";
+import { t as Ve } from "./line-BIPmUVxO.js";
+import "./chunk-HOUHSVGY-DRQcQeMT.js";
+import { n as _t } from "./chunk-Q4XR5HBZ-3BHjjc9u.js";
+import { t as je } from "./chunk-5VM5RSS4-Cni2Ogq2.js";
+import { n as Ge, t as Q } from "./chunk-7BUUIJ7U-9hiBbc7O.js";
+import { n as Ze, t as qe } from "./chunk-OGEWGWER-BV51ll2w.js";
+import { t as Je } from "./graphlib-CCKThIKP.js";
+function Qe(e) {
+  return Array.isArray(e);
+}
+function $e(e) {
+  if (Pe(e)) return e;
+  const t = Ut(e);
+  if (!tr(e)) return {};
+  if (Qe(e)) {
+    const n = Array.from(e);
+    return e.length > 0 && typeof e[0] == "string" && Object.hasOwn(e, "index") && (n.index = e.index, n.input = e.input), n;
+  }
+  if (Ke(e)) {
+    const n = e, s = n.constructor;
+    return new s(n.buffer, n.byteOffset, n.length);
+  }
+  if (t === "[object ArrayBuffer]") return new ArrayBuffer(e.byteLength);
+  if (t === "[object DataView]") {
+    const n = e, s = n.buffer, i = n.byteOffset, a = n.byteLength, c = new ArrayBuffer(a), l = new Uint8Array(s, i, a);
+    return new Uint8Array(c).set(l), new DataView(c);
+  }
+  if (t === "[object Boolean]" || t === "[object Number]" || t === "[object String]") {
+    const n = e.constructor, s = new n(e.valueOf());
+    return t === "[object String]" ? rr(s, e) : yt(s, e), s;
+  }
+  if (t === "[object Date]") return new Date(Number(e));
+  if (t === "[object RegExp]") {
+    const n = e, s = new RegExp(n.source, n.flags);
+    return s.lastIndex = n.lastIndex, s;
+  }
+  if (t === "[object Symbol]") return Object(Symbol.prototype.valueOf.call(e));
+  if (t === "[object Map]") {
+    const n = e, s = /* @__PURE__ */ new Map();
+    return n.forEach((i, a) => {
+      s.set(a, i);
+    }), s;
+  }
+  if (t === "[object Set]") {
+    const n = e, s = /* @__PURE__ */ new Set();
+    return n.forEach((i) => {
+      s.add(i);
+    }), s;
+  }
+  if (t === "[object Arguments]") {
+    const n = e, s = {};
+    return yt(s, n), s.length = n.length, s[Symbol.iterator] = n[Symbol.iterator], s;
+  }
+  const r = {};
+  return ar(r, e), yt(r, e), er(r, e), r;
+}
+function tr(e) {
+  switch (Ut(e)) {
+    case Le:
+    case Re:
+    case Ue:
+    case ke:
+    case ve:
+    case Be:
+    case Ye:
+    case we:
+    case Ie:
+    case We:
+    case Ne:
+    case Oe:
+    case Ee:
+    case Te:
+    case De:
+    case Ce:
+    case Xe:
+    case Se:
+    case Ae:
+    case Me:
+    case ze:
+    case _e:
+      return !0;
+    default:
+      return !1;
+  }
+}
+function yt(e, t) {
+  for (const r in t) Object.hasOwn(t, r) && (e[r] = t[r]);
+}
+function er(e, t) {
+  const r = Object.getOwnPropertySymbols(t);
+  for (let n = 0; n < r.length; n++) {
+    const s = r[n];
+    Object.prototype.propertyIsEnumerable.call(t, s) && (e[s] = t[s]);
+  }
+}
+function rr(e, t) {
+  const r = t.valueOf().length;
+  for (const n in t) Object.hasOwn(t, n) && (Number.isNaN(Number(n)) || Number(n) >= r) && (e[n] = t[n]);
+}
+function ar(e, t) {
+  const r = Object.getPrototypeOf(t);
+  r !== null && typeof t.constructor == "function" && Object.setPrototypeOf(e, r);
+}
+var mt = (function() {
+  var e = /* @__PURE__ */ u(function(w, f, b, E) {
+    for (b = b || {}, E = w.length; E--; b[w[E]] = f) ;
+    return b;
+  }, "o"), t = [1, 15], r = [1, 7], n = [1, 13], s = [1, 14], i = [1, 19], a = [1, 16], c = [1, 17], l = [1, 18], g = [8, 30], o = [
+    8,
+    10,
+    21,
+    28,
+    29,
+    30,
+    31,
+    39,
+    43,
+    46
+  ], d = [1, 23], x = [1, 24], m = [
+    8,
+    10,
+    15,
+    16,
+    21,
+    28,
+    29,
+    30,
+    31,
+    39,
+    43,
+    46
+  ], y = [
+    8,
+    10,
+    15,
+    16,
+    21,
+    27,
+    28,
+    29,
+    30,
+    31,
+    39,
+    43,
+    46
+  ], v = [1, 49], S = {
+    trace: /* @__PURE__ */ u(function() {
+    }, "trace"),
+    yy: {},
+    symbols_: {
+      error: 2,
+      spaceLines: 3,
+      SPACELINE: 4,
+      NL: 5,
+      separator: 6,
+      SPACE: 7,
+      EOF: 8,
+      start: 9,
+      BLOCK_DIAGRAM_KEY: 10,
+      document: 11,
+      stop: 12,
+      statement: 13,
+      link: 14,
+      LINK: 15,
+      START_LINK: 16,
+      LINK_LABEL: 17,
+      STR: 18,
+      nodeStatement: 19,
+      columnsStatement: 20,
+      SPACE_BLOCK: 21,
+      blockStatement: 22,
+      classDefStatement: 23,
+      cssClassStatement: 24,
+      styleStatement: 25,
+      node: 26,
+      SIZE: 27,
+      COLUMNS: 28,
+      "id-block": 29,
+      end: 30,
+      NODE_ID: 31,
+      nodeShapeNLabel: 32,
+      dirList: 33,
+      DIR: 34,
+      NODE_DSTART: 35,
+      NODE_DEND: 36,
+      BLOCK_ARROW_START: 37,
+      BLOCK_ARROW_END: 38,
+      classDef: 39,
+      CLASSDEF_ID: 40,
+      CLASSDEF_STYLEOPTS: 41,
+      DEFAULT: 42,
+      class: 43,
+      CLASSENTITY_IDS: 44,
+      STYLECLASS: 45,
+      style: 46,
+      STYLE_ENTITY_IDS: 47,
+      STYLE_DEFINITION_DATA: 48,
+      $accept: 0,
+      $end: 1
+    },
+    terminals_: {
+      2: "error",
+      4: "SPACELINE",
+      5: "NL",
+      7: "SPACE",
+      8: "EOF",
+      10: "BLOCK_DIAGRAM_KEY",
+      15: "LINK",
+      16: "START_LINK",
+      17: "LINK_LABEL",
+      18: "STR",
+      21: "SPACE_BLOCK",
+      27: "SIZE",
+      28: "COLUMNS",
+      29: "id-block",
+      30: "end",
+      31: "NODE_ID",
+      34: "DIR",
+      35: "NODE_DSTART",
+      36: "NODE_DEND",
+      37: "BLOCK_ARROW_START",
+      38: "BLOCK_ARROW_END",
+      39: "classDef",
+      40: "CLASSDEF_ID",
+      41: "CLASSDEF_STYLEOPTS",
+      42: "DEFAULT",
+      43: "class",
+      44: "CLASSENTITY_IDS",
+      45: "STYLECLASS",
+      46: "style",
+      47: "STYLE_ENTITY_IDS",
+      48: "STYLE_DEFINITION_DATA"
+    },
+    productions_: [
+      0,
+      [3, 1],
+      [3, 2],
+      [3, 2],
+      [6, 1],
+      [6, 1],
+      [6, 1],
+      [9, 3],
+      [12, 1],
+      [12, 1],
+      [12, 2],
+      [12, 2],
+      [11, 1],
+      [11, 2],
+      [14, 1],
+      [14, 4],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [13, 1],
+      [19, 3],
+      [19, 2],
+      [19, 1],
+      [20, 1],
+      [22, 4],
+      [22, 3],
+      [26, 1],
+      [26, 2],
+      [33, 1],
+      [33, 2],
+      [32, 3],
+      [32, 4],
+      [23, 3],
+      [23, 3],
+      [24, 3],
+      [25, 3]
+    ],
+    performAction: /* @__PURE__ */ u(function(f, b, E, k, _, h, P) {
+      var p = h.length - 1;
+      switch (_) {
+        case 4:
+          k.getLogger().debug("Rule: separator (NL) ");
+          break;
+        case 5:
+          k.getLogger().debug("Rule: separator (Space) ");
+          break;
+        case 6:
+          k.getLogger().debug("Rule: separator (EOF) ");
+          break;
+        case 7:
+          k.getLogger().debug("Rule: hierarchy: ", h[p - 1]), k.setHierarchy(h[p - 1]);
+          break;
+        case 8:
+          k.getLogger().debug("Stop NL ");
+          break;
+        case 9:
+          k.getLogger().debug("Stop EOF ");
+          break;
+        case 10:
+          k.getLogger().debug("Stop NL2 ");
+          break;
+        case 11:
+          k.getLogger().debug("Stop EOF2 ");
+          break;
+        case 12:
+          k.getLogger().debug("Rule: statement: ", h[p]), typeof h[p].length == "number" ? this.$ = h[p] : this.$ = [h[p]];
+          break;
+        case 13:
+          k.getLogger().debug("Rule: statement #2: ", h[p - 1]), this.$ = [h[p - 1]].concat(h[p]);
+          break;
+        case 14:
+          k.getLogger().debug("Rule: link: ", h[p], f), this.$ = {
+            edgeTypeStr: h[p],
+            label: ""
+          };
+          break;
+        case 15:
+          k.getLogger().debug("Rule: LABEL link: ", h[p - 3], h[p - 1], h[p]), this.$ = {
+            edgeTypeStr: h[p],
+            label: h[p - 1]
+          };
+          break;
+        case 18:
+          const B = parseInt(h[p]), j = k.generateId();
+          this.$ = {
+            id: j,
+            type: "space",
+            label: "",
+            width: B,
+            children: []
+          };
+          break;
+        case 23:
+          k.getLogger().debug("Rule: (nodeStatement link node) ", h[p - 2], h[p - 1], h[p], " typestr: ", h[p - 1].edgeTypeStr);
+          const X = k.edgeStrToEdgeData(h[p - 1].edgeTypeStr), ht = k.edgeStrToEdgeStartData(h[p - 1].edgeTypeStr), rt = k.edgeStrToThickness(h[p - 1].edgeTypeStr), gt = k.edgeStrToPattern(h[p - 1].edgeTypeStr);
+          this.$ = [
+            {
+              id: h[p - 2].id,
+              label: h[p - 2].label,
+              type: h[p - 2].type,
+              directions: h[p - 2].directions
+            },
+            {
+              id: h[p - 2].id + "-" + h[p].id,
+              start: h[p - 2].id,
+              end: h[p].id,
+              label: h[p - 1].label,
+              type: "edge",
+              thickness: rt,
+              pattern: gt,
+              directions: h[p].directions,
+              arrowTypeEnd: X,
+              arrowTypeStart: ht
+            },
+            {
+              id: h[p].id,
+              label: h[p].label,
+              type: k.typeStr2Type(h[p].typeStr),
+              directions: h[p].directions
+            }
+          ];
+          break;
+        case 24:
+          k.getLogger().debug("Rule: nodeStatement (abc88 node size) ", h[p - 1], h[p]), this.$ = {
+            id: h[p - 1].id,
+            label: h[p - 1].label,
+            type: k.typeStr2Type(h[p - 1].typeStr),
+            directions: h[p - 1].directions,
+            widthInColumns: parseInt(h[p], 10)
+          };
+          break;
+        case 25:
+          k.getLogger().debug("Rule: nodeStatement (node) ", h[p]), this.$ = {
+            id: h[p].id,
+            label: h[p].label,
+            type: k.typeStr2Type(h[p].typeStr),
+            directions: h[p].directions,
+            widthInColumns: 1
+          };
+          break;
+        case 26:
+          k.getLogger().debug("APA123", this ? this : "na"), k.getLogger().debug("COLUMNS: ", h[p]), this.$ = {
+            type: "column-setting",
+            columns: h[p] === "auto" ? -1 : parseInt(h[p])
+          };
+          break;
+        case 27:
+          k.getLogger().debug("Rule: id-block statement : ", h[p - 2], h[p - 1]), k.generateId(), this.$ = {
+            ...h[p - 2],
+            type: "composite",
+            children: h[p - 1]
+          };
+          break;
+        case 28:
+          k.getLogger().debug("Rule: blockStatement : ", h[p - 2], h[p - 1], h[p]);
+          const O = k.generateId();
+          this.$ = {
+            id: O,
+            type: "composite",
+            label: "",
+            children: h[p - 1]
+          };
+          break;
+        case 29:
+          k.getLogger().debug("Rule: node (NODE_ID separator): ", h[p]), this.$ = { id: h[p] };
+          break;
+        case 30:
+          k.getLogger().debug("Rule: node (NODE_ID nodeShapeNLabel separator): ", h[p - 1], h[p]), this.$ = {
+            id: h[p - 1],
+            label: h[p].label,
+            typeStr: h[p].typeStr,
+            directions: h[p].directions
+          };
+          break;
+        case 31:
+          k.getLogger().debug("Rule: dirList: ", h[p]), this.$ = [h[p]];
+          break;
+        case 32:
+          k.getLogger().debug("Rule: dirList: ", h[p - 1], h[p]), this.$ = [h[p - 1]].concat(h[p]);
+          break;
+        case 33:
+          k.getLogger().debug("Rule: nodeShapeNLabel: ", h[p - 2], h[p - 1], h[p]), this.$ = {
+            typeStr: h[p - 2] + h[p],
+            label: h[p - 1]
+          };
+          break;
+        case 34:
+          k.getLogger().debug("Rule: BLOCK_ARROW nodeShapeNLabel: ", h[p - 3], h[p - 2], " #3:", h[p - 1], h[p]), this.$ = {
+            typeStr: h[p - 3] + h[p],
+            label: h[p - 2],
+            directions: h[p - 1]
+          };
+          break;
+        case 35:
+        case 36:
+          this.$ = {
+            type: "classDef",
+            id: h[p - 1].trim(),
+            css: h[p].trim()
+          };
+          break;
+        case 37:
+          this.$ = {
+            type: "applyClass",
+            id: h[p - 1].trim(),
+            styleClass: h[p].trim()
+          };
+          break;
+        case 38:
+          this.$ = {
+            type: "applyStyles",
+            id: h[p - 1].trim(),
+            stylesStr: h[p].trim()
+          };
+          break;
+      }
+    }, "anonymous"),
+    table: [
+      {
+        9: 1,
+        10: [1, 2]
+      },
+      { 1: [3] },
+      {
+        10: t,
+        11: 3,
+        13: 4,
+        19: 5,
+        20: 6,
+        21: r,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        28: n,
+        29: s,
+        31: i,
+        39: a,
+        43: c,
+        46: l
+      },
+      { 8: [1, 20] },
+      e(g, [2, 12], {
+        13: 4,
+        19: 5,
+        20: 6,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        11: 21,
+        10: t,
+        21: r,
+        28: n,
+        29: s,
+        31: i,
+        39: a,
+        43: c,
+        46: l
+      }),
+      e(o, [2, 16], {
+        14: 22,
+        15: d,
+        16: x
+      }),
+      e(o, [2, 17]),
+      e(o, [2, 18]),
+      e(o, [2, 19]),
+      e(o, [2, 20]),
+      e(o, [2, 21]),
+      e(o, [2, 22]),
+      e(m, [2, 25], { 27: [1, 25] }),
+      e(o, [2, 26]),
+      {
+        19: 26,
+        26: 12,
+        31: i
+      },
+      {
+        10: t,
+        11: 27,
+        13: 4,
+        19: 5,
+        20: 6,
+        21: r,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        28: n,
+        29: s,
+        31: i,
+        39: a,
+        43: c,
+        46: l
+      },
+      {
+        40: [1, 28],
+        42: [1, 29]
+      },
+      { 44: [1, 30] },
+      { 47: [1, 31] },
+      e(y, [2, 29], {
+        32: 32,
+        35: [1, 33],
+        37: [1, 34]
+      }),
+      { 1: [2, 7] },
+      e(g, [2, 13]),
+      {
+        26: 35,
+        31: i
+      },
+      { 31: [2, 14] },
+      { 17: [1, 36] },
+      e(m, [2, 24]),
+      {
+        10: t,
+        11: 37,
+        13: 4,
+        14: 22,
+        15: d,
+        16: x,
+        19: 5,
+        20: 6,
+        21: r,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        28: n,
+        29: s,
+        31: i,
+        39: a,
+        43: c,
+        46: l
+      },
+      { 30: [1, 38] },
+      { 41: [1, 39] },
+      { 41: [1, 40] },
+      { 45: [1, 41] },
+      { 48: [1, 42] },
+      e(y, [2, 30]),
+      { 18: [1, 43] },
+      { 18: [1, 44] },
+      e(m, [2, 23]),
+      { 18: [1, 45] },
+      { 30: [1, 46] },
+      e(o, [2, 28]),
+      e(o, [2, 35]),
+      e(o, [2, 36]),
+      e(o, [2, 37]),
+      e(o, [2, 38]),
+      { 36: [1, 47] },
+      {
+        33: 48,
+        34: v
+      },
+      { 15: [1, 50] },
+      e(o, [2, 27]),
+      e(y, [2, 33]),
+      { 38: [1, 51] },
+      {
+        33: 52,
+        34: v,
+        38: [2, 31]
+      },
+      { 31: [2, 15] },
+      e(y, [2, 34]),
+      { 38: [2, 32] }
+    ],
+    defaultActions: {
+      20: [2, 7],
+      23: [2, 14],
+      50: [2, 15],
+      52: [2, 32]
+    },
+    parseError: /* @__PURE__ */ u(function(f, b) {
+      if (b.recoverable) this.trace(f);
+      else {
+        var E = new Error(f);
+        throw E.hash = b, E;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ u(function(f) {
+      var b = this, E = [0], k = [], _ = [null], h = [], P = this.table, p = "", B = 0, j = 0, X = 0, ht = 2, rt = 1, gt = h.slice.call(arguments, 1), O = Object.create(this.lexer), G = { yy: {} };
+      for (var ut in this.yy) Object.prototype.hasOwnProperty.call(this.yy, ut) && (G.yy[ut] = this.yy[ut]);
+      O.setInput(f, G.yy), G.yy.lexer = O, G.yy.parser = this, typeof O.yylloc > "u" && (O.yylloc = {});
+      var dt = O.yylloc;
+      h.push(dt);
+      var ue = O.options && O.options.ranges;
+      typeof G.yy.parseError == "function" ? this.parseError = G.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function de(Y) {
+        E.length = E.length - 2 * Y, _.length = _.length - Y, h.length = h.length - Y;
+      }
+      u(de, "popStack");
+      function Bt() {
+        var Y = k.pop() || O.lex() || rt;
+        return typeof Y != "number" && (Y instanceof Array && (k = Y, Y = k.pop()), Y = b.symbols_[Y] || Y), Y;
+      }
+      u(Bt, "lex");
+      for (var z, ft, Z, W, pt, q = {}, at, V, Ot, st; ; ) {
+        if (Z = E[E.length - 1], this.defaultActions[Z] ? W = this.defaultActions[Z] : ((z === null || typeof z > "u") && (z = Bt()), W = P[Z] && P[Z][z]), typeof W > "u" || !W.length || !W[0]) {
+          var xt = "";
+          st = [];
+          for (at in P[Z]) this.terminals_[at] && at > ht && st.push("'" + this.terminals_[at] + "'");
+          O.showPosition ? xt = "Parse error on line " + (B + 1) + `:
+` + O.showPosition() + `
+Expecting ` + st.join(", ") + ", got '" + (this.terminals_[z] || z) + "'" : xt = "Parse error on line " + (B + 1) + ": Unexpected " + (z == rt ? "end of input" : "'" + (this.terminals_[z] || z) + "'"), this.parseError(xt, {
+            text: O.match,
+            token: this.terminals_[z] || z,
+            line: O.yylineno,
+            loc: dt,
+            expected: st
+          });
+        }
+        if (W[0] instanceof Array && W.length > 1) throw new Error("Parse Error: multiple actions possible at state: " + Z + ", token: " + z);
+        switch (W[0]) {
+          case 1:
+            E.push(z), _.push(O.yytext), h.push(O.yylloc), E.push(W[1]), z = null, ft ? (z = ft, ft = null) : (j = O.yyleng, p = O.yytext, B = O.yylineno, dt = O.yylloc, X > 0 && X--);
+            break;
+          case 2:
+            if (V = this.productions_[W[1]][1], q.$ = _[_.length - V], q._$ = {
+              first_line: h[h.length - (V || 1)].first_line,
+              last_line: h[h.length - 1].last_line,
+              first_column: h[h.length - (V || 1)].first_column,
+              last_column: h[h.length - 1].last_column
+            }, ue && (q._$.range = [h[h.length - (V || 1)].range[0], h[h.length - 1].range[1]]), pt = this.performAction.apply(q, [
+              p,
+              j,
+              B,
+              G.yy,
+              W[1],
+              _,
+              h
+            ].concat(gt)), typeof pt < "u") return pt;
+            V && (E = E.slice(0, -1 * V * 2), _ = _.slice(0, -1 * V), h = h.slice(0, -1 * V)), E.push(this.productions_[W[1]][0]), _.push(q.$), h.push(q._$), Ot = P[E[E.length - 2]][E[E.length - 1]], E.push(Ot);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }, "parse")
+  };
+  S.lexer = /* @__PURE__ */ (function() {
+    return {
+      EOF: 1,
+      parseError: /* @__PURE__ */ u(function(f, b) {
+        if (this.yy.parser) this.yy.parser.parseError(f, b);
+        else throw new Error(f);
+      }, "parseError"),
+      setInput: /* @__PURE__ */ u(function(w, f) {
+        return this.yy = f || this.yy || {}, this._input = w, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = ["INITIAL"], this.yylloc = {
+          first_line: 1,
+          first_column: 0,
+          last_line: 1,
+          last_column: 0
+        }, this.options.ranges && (this.yylloc.range = [0, 0]), this.offset = 0, this;
+      }, "setInput"),
+      input: /* @__PURE__ */ u(function() {
+        var w = this._input[0];
+        return this.yytext += w, this.yyleng++, this.offset++, this.match += w, this.matched += w, w.match(/(?:\r\n?|\n).*/g) ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), w;
+      }, "input"),
+      unput: /* @__PURE__ */ u(function(w) {
+        var f = w.length, b = w.split(/(?:\r\n?|\n)/g);
+        this._input = w + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - f), this.offset -= f;
+        var E = this.match.split(/(?:\r\n?|\n)/g);
+        this.match = this.match.substr(0, this.match.length - 1), this.matched = this.matched.substr(0, this.matched.length - 1), b.length - 1 && (this.yylineno -= b.length - 1);
+        var k = this.yylloc.range;
+        return this.yylloc = {
+          first_line: this.yylloc.first_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.first_column,
+          last_column: b ? (b.length === E.length ? this.yylloc.first_column : 0) + E[E.length - b.length].length - b[0].length : this.yylloc.first_column - f
+        }, this.options.ranges && (this.yylloc.range = [k[0], k[0] + this.yyleng - f]), this.yyleng = this.yytext.length, this;
+      }, "unput"),
+      more: /* @__PURE__ */ u(function() {
+        return this._more = !0, this;
+      }, "more"),
+      reject: /* @__PURE__ */ u(function() {
+        if (this.options.backtrack_lexer) this._backtrack = !0;
+        else return this.parseError("Lexical error on line " + (this.yylineno + 1) + `. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+        return this;
+      }, "reject"),
+      less: /* @__PURE__ */ u(function(w) {
+        this.unput(this.match.slice(w));
+      }, "less"),
+      pastInput: /* @__PURE__ */ u(function() {
+        var w = this.matched.substr(0, this.matched.length - this.match.length);
+        return (w.length > 20 ? "..." : "") + w.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      upcomingInput: /* @__PURE__ */ u(function() {
+        var w = this.match;
+        return w.length < 20 && (w += this._input.substr(0, 20 - w.length)), (w.substr(0, 20) + (w.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      showPosition: /* @__PURE__ */ u(function() {
+        var w = this.pastInput(), f = new Array(w.length + 1).join("-");
+        return w + this.upcomingInput() + `
+` + f + "^";
+      }, "showPosition"),
+      test_match: /* @__PURE__ */ u(function(w, f) {
+        var b, E, k;
+        if (this.options.backtrack_lexer && (k = {
+          yylineno: this.yylineno,
+          yylloc: {
+            first_line: this.yylloc.first_line,
+            last_line: this.last_line,
+            first_column: this.yylloc.first_column,
+            last_column: this.yylloc.last_column
+          },
+          yytext: this.yytext,
+          match: this.match,
+          matches: this.matches,
+          matched: this.matched,
+          yyleng: this.yyleng,
+          offset: this.offset,
+          _more: this._more,
+          _input: this._input,
+          yy: this.yy,
+          conditionStack: this.conditionStack.slice(0),
+          done: this.done
+        }, this.options.ranges && (k.yylloc.range = this.yylloc.range.slice(0))), E = w[0].match(/(?:\r\n?|\n).*/g), E && (this.yylineno += E.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: E ? E[E.length - 1].length - E[E.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + w[0].length
+        }, this.yytext += w[0], this.match += w[0], this.matches = w, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [this.offset, this.offset += this.yyleng]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(w[0].length), this.matched += w[0], b = this.performAction.call(this, this.yy, this, f, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), b) return b;
+        if (this._backtrack) {
+          for (var _ in k) this[_] = k[_];
+          return !1;
+        }
+        return !1;
+      }, "test_match"),
+      next: /* @__PURE__ */ u(function() {
+        if (this.done) return this.EOF;
+        this._input || (this.done = !0);
+        var w, f, b, E;
+        this._more || (this.yytext = "", this.match = "");
+        for (var k = this._currentRules(), _ = 0; _ < k.length; _++)
+          if (b = this._input.match(this.rules[k[_]]), b && (!f || b[0].length > f[0].length)) {
+            if (f = b, E = _, this.options.backtrack_lexer) {
+              if (w = this.test_match(b, k[_]), w !== !1) return w;
+              if (this._backtrack) {
+                f = !1;
+                continue;
+              } else return !1;
+            } else if (!this.options.flex) break;
+          }
+        return f ? (w = this.test_match(f, k[E]), w !== !1 ? w : !1) : this._input === "" ? this.EOF : this.parseError("Lexical error on line " + (this.yylineno + 1) + `. Unrecognized text.
+` + this.showPosition(), {
+          text: "",
+          token: null,
+          line: this.yylineno
+        });
+      }, "next"),
+      lex: /* @__PURE__ */ u(function() {
+        var f = this.next();
+        return f || this.lex();
+      }, "lex"),
+      begin: /* @__PURE__ */ u(function(f) {
+        this.conditionStack.push(f);
+      }, "begin"),
+      popState: /* @__PURE__ */ u(function() {
+        return this.conditionStack.length - 1 > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      }, "popState"),
+      _currentRules: /* @__PURE__ */ u(function() {
+        return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : this.conditions.INITIAL.rules;
+      }, "_currentRules"),
+      topState: /* @__PURE__ */ u(function(f) {
+        return f = this.conditionStack.length - 1 - Math.abs(f || 0), f >= 0 ? this.conditionStack[f] : "INITIAL";
+      }, "topState"),
+      pushState: /* @__PURE__ */ u(function(f) {
+        this.begin(f);
+      }, "pushState"),
+      stateStackSize: /* @__PURE__ */ u(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: {},
+      performAction: /* @__PURE__ */ u(function(f, b, E, k) {
+        switch (E) {
+          case 0:
+            return f.getLogger().debug("Found block-beta"), 10;
+          case 1:
+            return f.getLogger().debug("Found id-block"), 29;
+          case 2:
+            return f.getLogger().debug("Found block"), 10;
+          case 3:
+            f.getLogger().debug(".", b.yytext);
+            break;
+          case 4:
+            f.getLogger().debug("_", b.yytext);
+            break;
+          case 5:
+            return 5;
+          case 6:
+            return b.yytext = -1, 28;
+          case 7:
+            return b.yytext = b.yytext.replace(/columns\s+/, ""), f.getLogger().debug("COLUMNS (LEX)", b.yytext), 28;
+          case 8:
+            this.pushState("md_string");
+            break;
+          case 9:
+            return "MD_STR";
+          case 10:
+            this.popState();
+            break;
+          case 11:
+            this.pushState("string");
+            break;
+          case 12:
+            f.getLogger().debug("LEX: POPPING STR:", b.yytext), this.popState();
+            break;
+          case 13:
+            return f.getLogger().debug("LEX: STR end:", b.yytext), "STR";
+          case 14:
+            return b.yytext = b.yytext.replace(/space\:/, ""), f.getLogger().debug("SPACE NUM (LEX)", b.yytext), 21;
+          case 15:
+            return b.yytext = "1", f.getLogger().debug("COLUMNS (LEX)", b.yytext), 21;
+          case 16:
+            return 42;
+          case 17:
+            return "LINKSTYLE";
+          case 18:
+            return "INTERPOLATE";
+          case 19:
+            return this.pushState("CLASSDEF"), 39;
+          case 20:
+            return this.popState(), this.pushState("CLASSDEFID"), "DEFAULT_CLASSDEF_ID";
+          case 21:
+            return this.popState(), this.pushState("CLASSDEFID"), 40;
+          case 22:
+            return this.popState(), 41;
+          case 23:
+            return this.pushState("CLASS"), 43;
+          case 24:
+            return this.popState(), this.pushState("CLASS_STYLE"), 44;
+          case 25:
+            return this.popState(), 45;
+          case 26:
+            return this.pushState("STYLE_STMNT"), 46;
+          case 27:
+            return this.popState(), this.pushState("STYLE_DEFINITION"), 47;
+          case 28:
+            return this.popState(), 48;
+          case 29:
+            return this.pushState("acc_title"), "acc_title";
+          case 30:
+            return this.popState(), "acc_title_value";
+          case 31:
+            return this.pushState("acc_descr"), "acc_descr";
+          case 32:
+            return this.popState(), "acc_descr_value";
+          case 33:
+            this.pushState("acc_descr_multiline");
+            break;
+          case 34:
+            this.popState();
+            break;
+          case 35:
+            return "acc_descr_multiline_value";
+          case 36:
+            return 30;
+          case 37:
+            return this.popState(), f.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 38:
+            return this.popState(), f.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 39:
+            return this.popState(), f.getLogger().debug("Lex: ))"), "NODE_DEND";
+          case 40:
+            return this.popState(), f.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 41:
+            return this.popState(), f.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 42:
+            return this.popState(), f.getLogger().debug("Lex: (-"), "NODE_DEND";
+          case 43:
+            return this.popState(), f.getLogger().debug("Lex: -)"), "NODE_DEND";
+          case 44:
+            return this.popState(), f.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 45:
+            return this.popState(), f.getLogger().debug("Lex: ]]"), "NODE_DEND";
+          case 46:
+            return this.popState(), f.getLogger().debug("Lex: ("), "NODE_DEND";
+          case 47:
+            return this.popState(), f.getLogger().debug("Lex: ])"), "NODE_DEND";
+          case 48:
+            return this.popState(), f.getLogger().debug("Lex: /]"), "NODE_DEND";
+          case 49:
+            return this.popState(), f.getLogger().debug("Lex: /]"), "NODE_DEND";
+          case 50:
+            return this.popState(), f.getLogger().debug("Lex: )]"), "NODE_DEND";
+          case 51:
+            return this.popState(), f.getLogger().debug("Lex: )"), "NODE_DEND";
+          case 52:
+            return this.popState(), f.getLogger().debug("Lex: ]>"), "NODE_DEND";
+          case 53:
+            return this.popState(), f.getLogger().debug("Lex: ]"), "NODE_DEND";
+          case 54:
+            return f.getLogger().debug("Lexa: -)"), this.pushState("NODE"), 35;
+          case 55:
+            return f.getLogger().debug("Lexa: (-"), this.pushState("NODE"), 35;
+          case 56:
+            return f.getLogger().debug("Lexa: ))"), this.pushState("NODE"), 35;
+          case 57:
+            return f.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 58:
+            return f.getLogger().debug("Lex: ((("), this.pushState("NODE"), 35;
+          case 59:
+            return f.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 60:
+            return f.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 61:
+            return f.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 62:
+            return f.getLogger().debug("Lexc: >"), this.pushState("NODE"), 35;
+          case 63:
+            return f.getLogger().debug("Lexa: (["), this.pushState("NODE"), 35;
+          case 64:
+            return f.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 65:
+            return this.pushState("NODE"), 35;
+          case 66:
+            return this.pushState("NODE"), 35;
+          case 67:
+            return this.pushState("NODE"), 35;
+          case 68:
+            return this.pushState("NODE"), 35;
+          case 69:
+            return this.pushState("NODE"), 35;
+          case 70:
+            return this.pushState("NODE"), 35;
+          case 71:
+            return this.pushState("NODE"), 35;
+          case 72:
+            return f.getLogger().debug("Lexa: ["), this.pushState("NODE"), 35;
+          case 73:
+            return this.pushState("BLOCK_ARROW"), f.getLogger().debug("LEX ARR START"), 37;
+          case 74:
+            return f.getLogger().debug("Lex: NODE_ID", b.yytext), 31;
+          case 75:
+            return f.getLogger().debug("Lex: EOF", b.yytext), 8;
+          case 76:
+            this.pushState("md_string");
+            break;
+          case 77:
+            this.pushState("md_string");
+            break;
+          case 78:
+            return "NODE_DESCR";
+          case 79:
+            this.popState();
+            break;
+          case 80:
+            f.getLogger().debug("Lex: Starting string"), this.pushState("string");
+            break;
+          case 81:
+            f.getLogger().debug("LEX ARR: Starting string"), this.pushState("string");
+            break;
+          case 82:
+            return f.getLogger().debug("LEX: NODE_DESCR:", b.yytext), "NODE_DESCR";
+          case 83:
+            f.getLogger().debug("LEX POPPING"), this.popState();
+            break;
+          case 84:
+            f.getLogger().debug("Lex: =>BAE"), this.pushState("ARROW_DIR");
+            break;
+          case 85:
+            return b.yytext = b.yytext.replace(/^,\s*/, ""), f.getLogger().debug("Lex (right): dir:", b.yytext), "DIR";
+          case 86:
+            return b.yytext = b.yytext.replace(/^,\s*/, ""), f.getLogger().debug("Lex (left):", b.yytext), "DIR";
+          case 87:
+            return b.yytext = b.yytext.replace(/^,\s*/, ""), f.getLogger().debug("Lex (x):", b.yytext), "DIR";
+          case 88:
+            return b.yytext = b.yytext.replace(/^,\s*/, ""), f.getLogger().debug("Lex (y):", b.yytext), "DIR";
+          case 89:
+            return b.yytext = b.yytext.replace(/^,\s*/, ""), f.getLogger().debug("Lex (up):", b.yytext), "DIR";
+          case 90:
+            return b.yytext = b.yytext.replace(/^,\s*/, ""), f.getLogger().debug("Lex (down):", b.yytext), "DIR";
+          case 91:
+            return b.yytext = "]>", f.getLogger().debug("Lex (ARROW_DIR end):", b.yytext), this.popState(), this.popState(), "BLOCK_ARROW_END";
+          case 92:
+            return f.getLogger().debug("Lex: LINK", "#" + b.yytext + "#"), 15;
+          case 93:
+            return f.getLogger().debug("Lex: LINK", b.yytext), 15;
+          case 94:
+            return f.getLogger().debug("Lex: LINK", b.yytext), 15;
+          case 95:
+            return f.getLogger().debug("Lex: LINK", b.yytext), 15;
+          case 96:
+            return f.getLogger().debug("Lex: START_LINK", b.yytext), this.pushState("LLABEL"), 16;
+          case 97:
+            return f.getLogger().debug("Lex: START_LINK", b.yytext), this.pushState("LLABEL"), 16;
+          case 98:
+            return f.getLogger().debug("Lex: START_LINK", b.yytext), this.pushState("LLABEL"), 16;
+          case 99:
+            this.pushState("md_string");
+            break;
+          case 100:
+            return f.getLogger().debug("Lex: Starting string"), this.pushState("string"), "LINK_LABEL";
+          case 101:
+            return this.popState(), f.getLogger().debug("Lex: LINK", "#" + b.yytext + "#"), 15;
+          case 102:
+            return this.popState(), f.getLogger().debug("Lex: LINK", b.yytext), 15;
+          case 103:
+            return this.popState(), f.getLogger().debug("Lex: LINK", b.yytext), 15;
+          case 104:
+            return f.getLogger().debug("Lex: COLON", b.yytext), b.yytext = b.yytext.slice(1), 27;
+        }
+      }, "anonymous"),
+      rules: [
+        /^(?:block-beta\b)/,
+        /^(?:block:)/,
+        /^(?:block\b)/,
+        /^(?:[\s]+)/,
+        /^(?:[\n]+)/,
+        /^(?:((\u000D\u000A)|(\u000A)))/,
+        /^(?:columns\s+auto\b)/,
+        /^(?:columns\s+[\d]+)/,
+        /^(?:["][`])/,
+        /^(?:[^`"]+)/,
+        /^(?:[`]["])/,
+        /^(?:["])/,
+        /^(?:["])/,
+        /^(?:[^"]*)/,
+        /^(?:space[:]\d+)/,
+        /^(?:space\b)/,
+        /^(?:default\b)/,
+        /^(?:linkStyle\b)/,
+        /^(?:interpolate\b)/,
+        /^(?:classDef\s+)/,
+        /^(?:DEFAULT\s+)/,
+        /^(?:\w+\s+)/,
+        /^(?:[^\n]*)/,
+        /^(?:class\s+)/,
+        /^(?:(\w+)+((,\s*\w+)*))/,
+        /^(?:[^\n]*)/,
+        /^(?:style\s+)/,
+        /^(?:(\w+)+((,\s*\w+)*))/,
+        /^(?:[^\n]*)/,
+        /^(?:accTitle\s*:\s*)/,
+        /^(?:(?!\n||)*[^\n]*)/,
+        /^(?:accDescr\s*:\s*)/,
+        /^(?:(?!\n||)*[^\n]*)/,
+        /^(?:accDescr\s*\{\s*)/,
+        /^(?:[\}])/,
+        /^(?:[^\}]*)/,
+        /^(?:end\b\s*)/,
+        /^(?:\(\(\()/,
+        /^(?:\)\)\))/,
+        /^(?:[\)]\))/,
+        /^(?:\}\})/,
+        /^(?:\})/,
+        /^(?:\(-)/,
+        /^(?:-\))/,
+        /^(?:\(\()/,
+        /^(?:\]\])/,
+        /^(?:\()/,
+        /^(?:\]\))/,
+        /^(?:\\\])/,
+        /^(?:\/\])/,
+        /^(?:\)\])/,
+        /^(?:[\)])/,
+        /^(?:\]>)/,
+        /^(?:[\]])/,
+        /^(?:-\))/,
+        /^(?:\(-)/,
+        /^(?:\)\))/,
+        /^(?:\))/,
+        /^(?:\(\(\()/,
+        /^(?:\(\()/,
+        /^(?:\{\{)/,
+        /^(?:\{)/,
+        /^(?:>)/,
+        /^(?:\(\[)/,
+        /^(?:\()/,
+        /^(?:\[\[)/,
+        /^(?:\[\|)/,
+        /^(?:\[\()/,
+        /^(?:\)\)\))/,
+        /^(?:\[\\)/,
+        /^(?:\[\/)/,
+        /^(?:\[\\)/,
+        /^(?:\[)/,
+        /^(?:<\[)/,
+        /^(?:[^\(\[\n\-\)\{\}\s\<\>:=]+)/,
+        /^(?:$)/,
+        /^(?:["][`])/,
+        /^(?:["][`])/,
+        /^(?:[^`"]+)/,
+        /^(?:[`]["])/,
+        /^(?:["])/,
+        /^(?:["])/,
+        /^(?:[^"]+)/,
+        /^(?:["])/,
+        /^(?:\]>\s*\()/,
+        /^(?:,?\s*right\s*)/,
+        /^(?:,?\s*left\s*)/,
+        /^(?:,?\s*x\s*)/,
+        /^(?:,?\s*y\s*)/,
+        /^(?:,?\s*up\s*)/,
+        /^(?:,?\s*down\s*)/,
+        /^(?:\)\s*)/,
+        /^(?:\s*[xo<]?--+[-xo>]\s*)/,
+        /^(?:\s*[xo<]?==+[=xo>]\s*)/,
+        /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,
+        /^(?:\s*~~[\~]+\s*)/,
+        /^(?:\s*[xo<]?--\s*)/,
+        /^(?:\s*[xo<]?==\s*)/,
+        /^(?:\s*[xo<]?-\.\s*)/,
+        /^(?:["][`])/,
+        /^(?:["])/,
+        /^(?:\s*[xo<]?--+[-xo>]\s*)/,
+        /^(?:\s*[xo<]?==+[=xo>]\s*)/,
+        /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,
+        /^(?::\d+)/
+      ],
+      conditions: {
+        STYLE_DEFINITION: {
+          rules: [28],
+          inclusive: !1
+        },
+        STYLE_STMNT: {
+          rules: [27],
+          inclusive: !1
+        },
+        CLASSDEFID: {
+          rules: [22],
+          inclusive: !1
+        },
+        CLASSDEF: {
+          rules: [20, 21],
+          inclusive: !1
+        },
+        CLASS_STYLE: {
+          rules: [25],
+          inclusive: !1
+        },
+        CLASS: {
+          rules: [24],
+          inclusive: !1
+        },
+        LLABEL: {
+          rules: [
+            99,
+            100,
+            101,
+            102,
+            103
+          ],
+          inclusive: !1
+        },
+        ARROW_DIR: {
+          rules: [
+            85,
+            86,
+            87,
+            88,
+            89,
+            90,
+            91
+          ],
+          inclusive: !1
+        },
+        BLOCK_ARROW: {
+          rules: [
+            76,
+            81,
+            84
+          ],
+          inclusive: !1
+        },
+        NODE: {
+          rules: [
+            37,
+            38,
+            39,
+            40,
+            41,
+            42,
+            43,
+            44,
+            45,
+            46,
+            47,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            77,
+            80
+          ],
+          inclusive: !1
+        },
+        md_string: {
+          rules: [
+            9,
+            10,
+            78,
+            79
+          ],
+          inclusive: !1
+        },
+        space: {
+          rules: [],
+          inclusive: !1
+        },
+        string: {
+          rules: [
+            12,
+            13,
+            82,
+            83
+          ],
+          inclusive: !1
+        },
+        acc_descr_multiline: {
+          rules: [34, 35],
+          inclusive: !1
+        },
+        acc_descr: {
+          rules: [32],
+          inclusive: !1
+        },
+        acc_title: {
+          rules: [30],
+          inclusive: !1
+        },
+        INITIAL: {
+          rules: [
+            0,
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            11,
+            14,
+            15,
+            16,
+            17,
+            18,
+            19,
+            23,
+            26,
+            29,
+            31,
+            33,
+            36,
+            54,
+            55,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            92,
+            93,
+            94,
+            95,
+            96,
+            97,
+            98,
+            104
+          ],
+          inclusive: !0
+        }
+      }
+    };
+  })();
+  function N() {
+    this.yy = {};
+  }
+  return u(N, "Parser"), N.prototype = S, S.Parser = N, new N();
+})();
+mt.parser = mt;
+var sr = mt, H = /* @__PURE__ */ new Map(), Tt = [], wt = /* @__PURE__ */ new Map(), At = "color", zt = "fill", ir = "bgFill", Xt = ",", nt = /* @__PURE__ */ new Map(), St = "", nr = /* @__PURE__ */ u((e) => be.sanitizeText(e, C()), "sanitizeText"), cr = /* @__PURE__ */ u(function(e, t = "") {
+  let r = nt.get(e);
+  r || (r = {
+    id: e,
+    styles: [],
+    textStyles: []
+  }, nt.set(e, r)), t?.split(Xt).forEach((n) => {
+    const s = n.replace(/([^;]*);/, "$1").trim();
+    if (RegExp(At).exec(n)) {
+      const i = s.replace(zt, ir).replace(At, zt);
+      r.textStyles.push(i);
+    }
+    r.styles.push(s);
+  });
+}, "addStyleClass"), lr = /* @__PURE__ */ u(function(e, t = "") {
+  const r = H.get(e);
+  t != null && (r.styles = t.split(Xt));
+}, "addStyle2Node"), or = /* @__PURE__ */ u(function(e, t) {
+  e.split(",").forEach(function(r) {
+    let n = H.get(r);
+    if (n === void 0) {
+      const s = r.trim();
+      n = {
+        id: s,
+        type: "na",
+        children: []
+      }, H.set(s, n);
+    }
+    n.classes || (n.classes = []), n.classes.push(t);
+  });
+}, "setCssClass"), Vt = /* @__PURE__ */ u((e, t) => {
+  const r = e.flat(), n = [], s = r.find((i) => i?.type === "column-setting")?.columns ?? -1;
+  for (const i of r) {
+    if (typeof s == "number" && s > 0 && i.type !== "column-setting" && typeof i.widthInColumns == "number" && i.widthInColumns > s && L.warn(`Block ${i.id} width ${i.widthInColumns} exceeds configured column width ${s}`), i.label && (i.label = nr(i.label)), i.type === "classDef") {
+      cr(i.id, i.css);
+      continue;
+    }
+    if (i.type === "applyClass") {
+      or(i.id, i?.styleClass ?? "");
+      continue;
+    }
+    if (i.type === "applyStyles") {
+      i?.stylesStr && lr(i.id, i?.stylesStr);
+      continue;
+    }
+    if (i.type === "column-setting") t.columns = i.columns ?? -1;
+    else if (i.type === "edge") {
+      const a = (wt.get(i.id) ?? 0) + 1;
+      wt.set(i.id, a), i.id = a + "-" + i.id, Tt.push(i);
+    } else {
+      i.label || (i.type === "composite" ? i.label = "" : i.label = i.id);
+      const a = H.get(i.id);
+      if (a === void 0 ? H.set(i.id, i) : (i.type !== "na" && (a.type = i.type), i.label !== i.id && (a.label = i.label)), i.children && Vt(i.children, i), i.type === "space") {
+        const c = i.width ?? 1;
+        for (let l = 0; l < c; l++) {
+          const g = $e(i);
+          g.id = g.id + "-" + l, H.set(g.id, g), n.push(g);
+        }
+      } else a === void 0 && n.push(i);
+    }
+  }
+  t.children = n;
+}, "populateBlockDatabase"), Lt = [], tt = {
+  id: "root",
+  type: "composite",
+  children: [],
+  columns: -1
+}, hr = /* @__PURE__ */ u(() => {
+  L.debug("Clear called"), pe(), tt = {
+    id: "root",
+    type: "composite",
+    children: [],
+    columns: -1
+  }, H = /* @__PURE__ */ new Map([["root", tt]]), Lt = [], nt = /* @__PURE__ */ new Map(), Tt = [], wt = /* @__PURE__ */ new Map(), St = "";
+}, "clear");
+function jt(e) {
+  switch (L.debug("typeStr2Type", e), e) {
+    case "[]":
+      return "square";
+    case "()":
+      return L.debug("we have a round"), "round";
+    case "(())":
+      return "circle";
+    case ">]":
+      return "rect_left_inv_arrow";
+    case "{}":
+      return "diamond";
+    case "{{}}":
+      return "hexagon";
+    case "([])":
+      return "stadium";
+    case "[[]]":
+      return "subroutine";
+    case "[()]":
+      return "cylinder";
+    case "((()))":
+      return "doublecircle";
+    case "[//]":
+      return "lean_right";
+    case "[\\\\]":
+      return "lean_left";
+    case "[/\\]":
+      return "trapezoid";
+    case "[\\/]":
+      return "inv_trapezoid";
+    case "<[]>":
+      return "block_arrow";
+    default:
+      return "na";
+  }
+}
+u(jt, "typeStr2Type");
+function Gt(e) {
+  return L.debug("typeStr2Type", e), e === "==" ? "thick" : "normal";
+}
+u(Gt, "edgeTypeStr2Type");
+function Zt(e) {
+  switch (e.trim().slice(-1)) {
+    case "x":
+      return "arrow_cross";
+    case "o":
+      return "arrow_circle";
+    case ">":
+      return "arrow_point";
+    default:
+      return "";
+  }
+}
+u(Zt, "edgeStrToEdgeData");
+function qt(e) {
+  switch (e.trim().charAt(0)) {
+    case "x":
+      return "arrow_cross";
+    case "o":
+      return "arrow_circle";
+    case "<":
+      return "arrow_point";
+    default:
+      return "arrow_open";
+  }
+}
+u(qt, "edgeStrToEdgeStartData");
+function Jt(e) {
+  return e.includes("==") ? "thick" : "normal";
+}
+u(Jt, "edgeStrToThickness");
+function Qt(e) {
+  return e.includes(".-") ? "dotted" : "solid";
+}
+u(Qt, "edgeStrToPattern");
+var Mt = 0, gr = {
+  getConfig: /* @__PURE__ */ u(() => et().block, "getConfig"),
+  typeStr2Type: jt,
+  edgeTypeStr2Type: Gt,
+  edgeStrToEdgeData: Zt,
+  edgeStrToEdgeStartData: qt,
+  edgeStrToThickness: Jt,
+  edgeStrToPattern: Qt,
+  getLogger: /* @__PURE__ */ u(() => L, "getLogger"),
+  getBlocksFlat: /* @__PURE__ */ u(() => [...H.values()], "getBlocksFlat"),
+  getBlocks: /* @__PURE__ */ u(() => Lt || [], "getBlocks"),
+  getEdges: /* @__PURE__ */ u(() => Tt, "getEdges"),
+  setHierarchy: /* @__PURE__ */ u((e) => {
+    tt.children = e, Vt(e, tt), Lt = tt.children;
+  }, "setHierarchy"),
+  getBlock: /* @__PURE__ */ u((e) => H.get(e), "getBlock"),
+  setBlock: /* @__PURE__ */ u((e) => {
+    H.set(e.id, e);
+  }, "setBlock"),
+  getColumns: /* @__PURE__ */ u((e) => {
+    const t = H.get(e);
+    return t ? t.columns ? t.columns : t.children ? t.children.length : -1 : -1;
+  }, "getColumns"),
+  getClasses: /* @__PURE__ */ u(function() {
+    return nt;
+  }, "getClasses"),
+  clear: hr,
+  generateId: /* @__PURE__ */ u(() => (Mt++, "id-" + Math.random().toString(36).substr(2, 12) + "-" + Mt), "generateId"),
+  setDiagramId: /* @__PURE__ */ u((e) => {
+    St = e;
+  }, "setDiagramId"),
+  getDiagramId: /* @__PURE__ */ u(() => St, "getDiagramId")
+}, bt = /* @__PURE__ */ u((e, t) => {
+  const r = me, n = r(e, "r"), s = r(e, "g"), i = r(e, "b");
+  return ye(n, s, i, t);
+}, "fade"), ur = /* @__PURE__ */ u((e) => `.label {
+    font-family: ${e.fontFamily};
+    color: ${e.nodeTextColor || e.textColor};
+  }
+  .cluster-label text {
+    fill: ${e.titleColor};
+  }
+  .cluster-label span,p {
+    color: ${e.titleColor};
+  }
+
+
+
+  .label text,span,p {
+    fill: ${e.nodeTextColor || e.textColor};
+    color: ${e.nodeTextColor || e.textColor};
+  }
+
+  .node rect,
+  .node circle,
+  .node ellipse,
+  .node polygon,
+  .node path {
+    fill: ${e.mainBkg};
+    stroke: ${e.nodeBorder};
+    stroke-width: 1px;
+  }
+  .flowchart-label text {
+    text-anchor: middle;
+  }
+  // .flowchart-label .text-outer-tspan {
+  //   text-anchor: middle;
+  // }
+  // .flowchart-label .text-inner-tspan {
+  //   text-anchor: start;
+  // }
+
+  .node .label {
+    text-align: center;
+  }
+  .node.clickable {
+    cursor: pointer;
+  }
+
+  .arrowheadPath {
+    fill: ${e.arrowheadColor};
+  }
+
+  .edgePath .path {
+    stroke: ${e.lineColor};
+    stroke-width: 2.0px;
+  }
+
+  .flowchart-link {
+    stroke: ${e.lineColor};
+    fill: none;
+  }
+
+  .edgeLabel {
+    background-color: ${e.edgeLabelBackground};
+    /*
+     * This is for backward compatibility with existing code that didn't
+     * add a \`<p>\` around edge labels.
+     *
+     * TODO: We should probably remove this in a future release.
+     */
+    p {
+      margin: 0;
+      padding: 0;
+      display: inline;
+    }
+    rect {
+      opacity: 0.5;
+      background-color: ${e.edgeLabelBackground};
+      fill: ${e.edgeLabelBackground};
+    }
+    text-align: center;
+  }
+
+  /* For html labels only */
+  .labelBkg {
+    background-color: ${e.edgeLabelBackground};
+  }
+
+  .node .cluster {
+    // fill: ${bt(e.mainBkg, 0.5)};
+    fill: ${bt(e.clusterBkg, 0.5)};
+    stroke: ${bt(e.clusterBorder, 0.2)};
+    box-shadow: rgba(50, 50, 93, 0.25) 0px 13px 27px -5px, rgba(0, 0, 0, 0.3) 0px 8px 16px -8px;
+    stroke-width: 1px;
+  }
+
+  .cluster text {
+    fill: ${e.titleColor};
+  }
+
+  .cluster span,p {
+    color: ${e.titleColor};
+  }
+  /* .cluster div {
+    color: ${e.titleColor};
+  } */
+
+  div.mermaidTooltip {
+    position: absolute;
+    text-align: center;
+    max-width: 200px;
+    padding: 2px;
+    font-family: ${e.fontFamily};
+    font-size: 12px;
+    background: ${e.tertiaryColor};
+    border: 1px solid ${e.border2};
+    border-radius: 2px;
+    pointer-events: none;
+    z-index: 100;
+  }
+
+  .flowchartTitleText {
+    text-anchor: middle;
+    font-size: 18px;
+    fill: ${e.textColor};
+  }
+  ${je()}
+`, "getStyles"), dr = /* @__PURE__ */ u((e, t, r, n) => {
+  t.forEach((s) => {
+    fr[s](e, r, n);
+  });
+}, "insertMarkers"), fr = {
+  extension: /* @__PURE__ */ u((e, t, r) => {
+    L.trace("Making markers for ", r), e.append("defs").append("marker").attr("id", r + "_" + t + "-extensionStart").attr("class", "marker extension " + t).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 1,7 L18,13 V 1 Z"), e.append("defs").append("marker").attr("id", r + "_" + t + "-extensionEnd").attr("class", "marker extension " + t).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 1,1 V 13 L18,7 Z");
+  }, "extension"),
+  composition: /* @__PURE__ */ u((e, t, r) => {
+    e.append("defs").append("marker").attr("id", r + "_" + t + "-compositionStart").attr("class", "marker composition " + t).attr("refX", 18).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"), e.append("defs").append("marker").attr("id", r + "_" + t + "-compositionEnd").attr("class", "marker composition " + t).attr("refX", 1).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");
+  }, "composition"),
+  aggregation: /* @__PURE__ */ u((e, t, r) => {
+    e.append("defs").append("marker").attr("id", r + "_" + t + "-aggregationStart").attr("class", "marker aggregation " + t).attr("refX", 18).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"), e.append("defs").append("marker").attr("id", r + "_" + t + "-aggregationEnd").attr("class", "marker aggregation " + t).attr("refX", 1).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");
+  }, "aggregation"),
+  dependency: /* @__PURE__ */ u((e, t, r) => {
+    e.append("defs").append("marker").attr("id", r + "_" + t + "-dependencyStart").attr("class", "marker dependency " + t).attr("refX", 6).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"), e.append("defs").append("marker").attr("id", r + "_" + t + "-dependencyEnd").attr("class", "marker dependency " + t).attr("refX", 13).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");
+  }, "dependency"),
+  lollipop: /* @__PURE__ */ u((e, t, r) => {
+    e.append("defs").append("marker").attr("id", r + "_" + t + "-lollipopStart").attr("class", "marker lollipop " + t).attr("refX", 13).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6), e.append("defs").append("marker").attr("id", r + "_" + t + "-lollipopEnd").attr("class", "marker lollipop " + t).attr("refX", 1).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6);
+  }, "lollipop"),
+  point: /* @__PURE__ */ u((e, t, r) => {
+    e.append("marker").attr("id", r + "_" + t + "-pointEnd").attr("class", "marker " + t).attr("viewBox", "0 0 10 10").attr("refX", 6).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 12).attr("markerHeight", 12).attr("orient", "auto").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"), e.append("marker").attr("id", r + "_" + t + "-pointStart").attr("class", "marker " + t).attr("viewBox", "0 0 10 10").attr("refX", 4.5).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 12).attr("markerHeight", 12).attr("orient", "auto").append("path").attr("d", "M 0 5 L 10 10 L 10 0 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0");
+  }, "point"),
+  circle: /* @__PURE__ */ u((e, t, r) => {
+    e.append("marker").attr("id", r + "_" + t + "-circleEnd").attr("class", "marker " + t).attr("viewBox", "0 0 10 10").attr("refX", 11).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"), e.append("marker").attr("id", r + "_" + t + "-circleStart").attr("class", "marker " + t).attr("viewBox", "0 0 10 10").attr("refX", -1).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0");
+  }, "circle"),
+  cross: /* @__PURE__ */ u((e, t, r) => {
+    e.append("marker").attr("id", r + "_" + t + "-crossEnd").attr("class", "marker cross " + t).attr("viewBox", "0 0 11 11").attr("refX", 12).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0"), e.append("marker").attr("id", r + "_" + t + "-crossStart").attr("class", "marker cross " + t).attr("viewBox", "0 0 11 11").attr("refX", -1).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0");
+  }, "cross"),
+  barb: /* @__PURE__ */ u((e, t, r) => {
+    e.append("defs").append("marker").attr("id", r + "_" + t + "-barbEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 14).attr("markerUnits", "strokeWidth").attr("orient", "auto").append("path").attr("d", "M 19,7 L9,13 L14,7 L9,1 Z");
+  }, "barb")
+}, pr = dr;
+function kt(e, t) {
+  if (e === 0 || !Number.isInteger(e)) throw new Error("Columns must be an integer !== 0.");
+  if (t < 0 || !Number.isInteger(t)) throw new Error("Position must be a non-negative integer." + t);
+  return e < 0 ? {
+    px: t,
+    py: 0
+  } : e === 1 ? {
+    px: 0,
+    py: t
+  } : {
+    px: t % e,
+    py: Math.floor(t / e)
+  };
+}
+u(kt, "calculateBlockPosition");
+var xr = /* @__PURE__ */ u((e) => {
+  let t = 0, r = 0;
+  for (const n of e.children) {
+    const { width: s, height: i, x: a, y: c } = n.size ?? {
+      width: 0,
+      height: 0,
+      x: 0,
+      y: 0
+    };
+    if (L.debug("getMaxChildSize abc95 child:", n.id, "width:", s, "height:", i, "x:", a, "y:", c, n.type), n.type === "space") continue;
+    const l = s / (n.widthInColumns ?? 1);
+    l > t && (t = l), i > r && (r = i);
+  }
+  return {
+    width: t,
+    height: r
+  };
+}, "getMaxChildSize");
+function ct(e, t, r = 0, n = 0, s = 8) {
+  L.debug("setBlockSizes abc95 (start)", e.id, e?.size?.x, "block width =", e?.size, "siblingWidth", r), e?.size?.width || (e.size = {
+    width: r,
+    height: n,
+    x: 0,
+    y: 0
+  });
+  let i = 0, a = 0;
+  if (e.children?.length > 0) {
+    for (const y of e.children) ct(y, t, 0, 0, s);
+    const c = xr(e);
+    i = c.width, a = c.height, L.debug("setBlockSizes abc95 maxWidth of", e.id, ":s children is ", i, a);
+    for (const y of e.children) y.size && (L.debug(`abc95 Setting size of children of ${e.id} id=${y.id} ${i} ${a} ${JSON.stringify(y.size)}`), y.size.width = i * (y.widthInColumns ?? 1) + s * ((y.widthInColumns ?? 1) - 1), y.size.height = a, y.size.x = 0, y.size.y = 0, L.debug(`abc95 updating size of ${e.id} children child:${y.id} maxWidth:${i} maxHeight:${a}`));
+    for (const y of e.children) ct(y, t, i, a, s);
+    const l = e.columns ?? -1;
+    let g = 0;
+    for (const y of e.children) g += y.widthInColumns ?? 1;
+    let o = e.children.length;
+    l > 0 && l < g && (o = l);
+    const d = Math.ceil(g / o);
+    let x = o * (i + s) + s, m = d * (a + s) + s;
+    if (x < r) {
+      L.debug(`Detected to small sibling: abc95 ${e.id} siblingWidth ${r} siblingHeight ${n} width ${x}`), x = r, m = n;
+      const y = (r - o * s - s) / o, v = (n - d * s - s) / d;
+      L.debug("Size indata abc88", e.id, "childWidth", y, "maxWidth", i), L.debug("Size indata abc88", e.id, "childHeight", v, "maxHeight", a), L.debug("Size indata abc88 xSize", o, "padding", s);
+      for (const S of e.children) S.size && (S.size.width = y, S.size.height = v, S.size.x = 0, S.size.y = 0);
+    }
+    if (L.debug(`abc95 (finale calc) ${e.id} xSize ${o} ySize ${d} columns ${l}${e.children.length} width=${Math.max(x, e.size?.width || 0)}`), x < (e?.size?.width || 0)) {
+      x = e?.size?.width || 0;
+      const y = l > 0 ? Math.min(e.children.length, l) : e.children.length;
+      if (y > 0) {
+        const v = (x - y * s - s) / y;
+        L.debug("abc95 (growing to fit) width", e.id, x, e.size?.width, v);
+        for (const S of e.children) S.size && (S.size.width = v);
+      }
+    }
+    e.size = {
+      width: x,
+      height: m,
+      x: 0,
+      y: 0
+    };
+  }
+  L.debug("setBlockSizes abc94 (done)", e.id, e?.size?.x, e?.size?.width, e?.size?.y, e?.size?.height);
+}
+u(ct, "setBlockSizes");
+function Dt(e, t, r = 8) {
+  L.debug(`abc85 layout blocks (=>layoutBlocks) ${e.id} x: ${e?.size?.x} y: ${e?.size?.y} width: ${e?.size?.width}`);
+  const n = e.columns ?? -1;
+  if (L.debug("layoutBlocks columns abc95", e.id, "=>", n, e), e.children && e.children.length > 0) {
+    const s = e?.children[0]?.size?.width ?? 0, i = e.children.length * s + (e.children.length - 1) * r;
+    L.debug("widthOfChildren 88", i, "posX");
+    const a = /* @__PURE__ */ new Map();
+    {
+      let d = 0;
+      for (const x of e.children) {
+        if (!x.size) continue;
+        const { py: m } = kt(n, d), y = a.get(m) ?? 0;
+        x.size.height > y && a.set(m, x.size.height);
+        let v = x?.widthInColumns ?? 1;
+        n > 0 && (v = Math.min(v, n - d % n)), d += v;
+      }
+    }
+    const c = /* @__PURE__ */ new Map();
+    {
+      let d = 0;
+      const x = [...a.keys()].sort((m, y) => m - y);
+      for (const m of x)
+        c.set(m, d), d += (a.get(m) ?? 0) + r;
+    }
+    let l = 0;
+    L.debug("abc91 block?.size?.x", e.id, e?.size?.x);
+    let g = e?.size?.x ? e?.size?.x + (-e?.size?.width / 2 || 0) : -r, o = 0;
+    for (const d of e.children) {
+      const x = e;
+      if (!d.size) continue;
+      const { width: m, height: y } = d.size, { px: v, py: S } = kt(n, l);
+      if (S != o && (o = S, g = e?.size?.x ? e?.size?.x + (-e?.size?.width / 2 || 0) : -r, L.debug("New row in layout for block", e.id, " and child ", d.id, o)), L.debug(`abc89 layout blocks (child) id: ${d.id} Pos: ${l} (px, py) ${v},${S} (${x?.size?.x},${x?.size?.y}) parent: ${x.id} width: ${m}${r}`), x.size) {
+        const w = m / 2;
+        d.size.x = g + r + w, L.debug(`abc91 layout blocks (calc) px, pyid:${d.id} startingPos=X${g} new startingPosX${d.size.x} ${w} padding=${r} width=${m} halfWidth=${w} => x:${d.size.x} y:${d.size.y} ${d.widthInColumns} (width * (child?.w || 1)) / 2 ${m * (d?.widthInColumns ?? 1) / 2}`), g = d.size.x + w;
+        const f = c.get(S) ?? 0, b = a.get(S) ?? y;
+        d.size.y = x.size.y - x.size.height / 2 + f + b / 2 + r, L.debug(`abc88 layout blocks (calc) px, pyid:${d.id}startingPosX${g}${r}${w}=>x:${d.size.x}y:${d.size.y}${d.widthInColumns}(width * (child?.w || 1)) / 2${m * (d?.widthInColumns ?? 1) / 2}`);
+      }
+      d.children && Dt(d, t, r);
+      let N = d?.widthInColumns ?? 1;
+      n > 0 && (N = Math.min(N, n - l % n)), l += N, L.debug("abc88 columnsPos", d, l);
+    }
+  }
+  L.debug(`layout blocks (<==layoutBlocks) ${e.id} x: ${e?.size?.x} y: ${e?.size?.y} width: ${e?.size?.width}`);
+}
+u(Dt, "layoutBlocks");
+function Nt(e, { minX: t, minY: r, maxX: n, maxY: s } = {
+  minX: 0,
+  minY: 0,
+  maxX: 0,
+  maxY: 0
+}) {
+  if (e.size && e.id !== "root") {
+    const { x: i, y: a, width: c, height: l } = e.size;
+    i - c / 2 < t && (t = i - c / 2), a - l / 2 < r && (r = a - l / 2), i + c / 2 > n && (n = i + c / 2), a + l / 2 > s && (s = a + l / 2);
+  }
+  if (e.children) for (const i of e.children) ({ minX: t, minY: r, maxX: n, maxY: s } = Nt(i, {
+    minX: t,
+    minY: r,
+    maxX: n,
+    maxY: s
+  }));
+  return {
+    minX: t,
+    minY: r,
+    maxX: n,
+    maxY: s
+  };
+}
+u(Nt, "findBounds");
+function $t(e) {
+  const t = e.getBlock("root");
+  if (!t) return;
+  const r = C()?.block?.padding ?? 8;
+  ct(t, e, 0, 0, r), Dt(t, e, r), L.debug("getBlocks", JSON.stringify(t, null, 2));
+  const { minX: n, minY: s, maxX: i, maxY: a } = Nt(t), c = a - s;
+  return {
+    x: n,
+    y: s,
+    width: i - n,
+    height: c
+  };
+}
+u($t, "layout");
+var K = /* @__PURE__ */ u(async (e, t, r, n = !1, s = !1) => {
+  let i = t || "";
+  typeof i == "object" && (i = i[0]);
+  const a = C(), c = M(a);
+  return await _t(e, i, {
+    style: r,
+    isTitle: n,
+    useHtmlLabels: c,
+    markdown: !1,
+    isNode: s,
+    width: Number.POSITIVE_INFINITY
+  }, a);
+}, "createLabel"), yr = /* @__PURE__ */ u((e, t, r, n, s) => {
+  t.arrowTypeStart && Pt(e, "start", t.arrowTypeStart, r, n, s), t.arrowTypeEnd && Pt(e, "end", t.arrowTypeEnd, r, n, s);
+}, "addEdgeMarkers"), br = {
+  arrow_cross: "cross",
+  arrow_point: "point",
+  arrow_barb: "barb",
+  arrow_circle: "circle",
+  aggregation: "aggregation",
+  extension: "extension",
+  composition: "composition",
+  dependency: "dependency",
+  lollipop: "lollipop"
+}, Pt = /* @__PURE__ */ u((e, t, r, n, s, i) => {
+  const a = br[r];
+  if (!a) {
+    L.warn(`Unknown arrow type: ${r}`);
+    return;
+  }
+  const c = t === "start" ? "Start" : "End";
+  e.attr(`marker-${t}`, `url(${n}#${s}_${i}-${a}${c})`);
+}, "addEdgeMarker"), vt = {}, A = {}, mr = /* @__PURE__ */ u(async (e, t) => {
+  const r = C(), n = M(r), s = e.insert("g").attr("class", "edgeLabel"), i = s.insert("g").attr("class", "label"), a = t.labelType === "markdown", c = await _t(e, t.label, {
+    style: t.labelStyle,
+    useHtmlLabels: n,
+    addSvgBackground: a,
+    isNode: !1,
+    markdown: a,
+    width: a ? void 0 : Number.POSITIVE_INFINITY
+  }, r);
+  i.node().appendChild(c);
+  let l = c.getBBox(), g = l;
+  if (n) {
+    const d = c.children[0], x = T(c);
+    l = d.getBoundingClientRect(), g = l, x.attr("width", l.width), x.attr("height", l.height);
+  } else {
+    const d = T(c).select("text").node();
+    d && typeof d.getBBox == "function" && (g = d.getBBox());
+  }
+  i.attr("transform", Q(g, n)), vt[t.id] = s, t.width = l.width, t.height = l.height;
+  let o;
+  if (t.startLabelLeft) {
+    const d = e.insert("g").attr("class", "edgeTerminals"), x = d.insert("g").attr("class", "inner"), m = await K(x, t.startLabelLeft, t.labelStyle);
+    o = m;
+    let y = m.getBBox();
+    if (n) {
+      const v = m.children[0], S = T(m);
+      y = v.getBoundingClientRect(), S.attr("width", y.width), S.attr("height", y.height);
+    }
+    x.attr("transform", Q(y, n)), A[t.id] || (A[t.id] = {}), A[t.id].startLeft = d, $(o, t.startLabelLeft);
+  }
+  if (t.startLabelRight) {
+    const d = e.insert("g").attr("class", "edgeTerminals"), x = d.insert("g").attr("class", "inner"), m = await K(x, t.startLabelRight, t.labelStyle);
+    o = m;
+    let y = m.getBBox();
+    if (n) {
+      const v = m.children[0], S = T(m);
+      y = v.getBoundingClientRect(), S.attr("width", y.width), S.attr("height", y.height);
+    }
+    x.attr("transform", Q(y, n)), A[t.id] || (A[t.id] = {}), A[t.id].startRight = d, $(o, t.startLabelRight);
+  }
+  if (t.endLabelLeft) {
+    const d = e.insert("g").attr("class", "edgeTerminals"), x = d.insert("g").attr("class", "inner"), m = await K(d, t.endLabelLeft, t.labelStyle);
+    o = m;
+    let y = m.getBBox();
+    if (n) {
+      const v = m.children[0], S = T(m);
+      y = v.getBoundingClientRect(), S.attr("width", y.width), S.attr("height", y.height);
+    }
+    x.attr("transform", Q(y, n)), A[t.id] || (A[t.id] = {}), A[t.id].endLeft = d, $(o, t.endLabelLeft);
+  }
+  if (t.endLabelRight) {
+    const d = e.insert("g").attr("class", "edgeTerminals"), x = d.insert("g").attr("class", "inner"), m = await K(d, t.endLabelRight, t.labelStyle);
+    o = m;
+    let y = m.getBBox();
+    if (n) {
+      const v = m.children[0], S = T(m);
+      y = v.getBoundingClientRect(), S.attr("width", y.width), S.attr("height", y.height);
+    }
+    x.attr("transform", Q(y, n)), A[t.id] || (A[t.id] = {}), A[t.id].endRight = d, $(o, t.endLabelRight);
+  }
+  return c;
+}, "insertEdgeLabel");
+function $(e, t) {
+  M(C()) && e && (e.style.width = t.length * 9 + "px", e.style.height = "12px");
+}
+u($, "setTerminalWidth");
+var wr = /* @__PURE__ */ u((e, t) => {
+  L.debug("Moving label abc88 ", e.id, e.label, vt[e.id], t);
+  let r = t.updatedPath ? t.updatedPath : t.originalPath;
+  const { subGraphTitleTotalMargin: n } = Ze(C());
+  if (e.label) {
+    const s = vt[e.id];
+    let i = e.x, a = e.y;
+    if (r) {
+      const c = J.calcLabelPosition(r);
+      L.debug("Moving label " + e.label + " from (", i, ",", a, ") to (", c.x, ",", c.y, ") abc88"), t.updatedPath && (i = c.x, a = c.y);
+    }
+    s.attr("transform", `translate(${i}, ${a + n / 2})`);
+  }
+  if (e.startLabelLeft) {
+    const s = A[e.id].startLeft;
+    let i = e.x, a = e.y;
+    if (r) {
+      const c = J.calcTerminalLabelPosition(e.arrowTypeStart ? 10 : 0, "start_left", r);
+      i = c.x, a = c.y;
+    }
+    s.attr("transform", `translate(${i}, ${a})`);
+  }
+  if (e.startLabelRight) {
+    const s = A[e.id].startRight;
+    let i = e.x, a = e.y;
+    if (r) {
+      const c = J.calcTerminalLabelPosition(e.arrowTypeStart ? 10 : 0, "start_right", r);
+      i = c.x, a = c.y;
+    }
+    s.attr("transform", `translate(${i}, ${a})`);
+  }
+  if (e.endLabelLeft) {
+    const s = A[e.id].endLeft;
+    let i = e.x, a = e.y;
+    if (r) {
+      const c = J.calcTerminalLabelPosition(e.arrowTypeEnd ? 10 : 0, "end_left", r);
+      i = c.x, a = c.y;
+    }
+    s.attr("transform", `translate(${i}, ${a})`);
+  }
+  if (e.endLabelRight) {
+    const s = A[e.id].endRight;
+    let i = e.x, a = e.y;
+    if (r) {
+      const c = J.calcTerminalLabelPosition(e.arrowTypeEnd ? 10 : 0, "end_right", r);
+      i = c.x, a = c.y;
+    }
+    s.attr("transform", `translate(${i}, ${a})`);
+  }
+}, "positionEdgeLabel"), Sr = /* @__PURE__ */ u((e, t) => {
+  const r = e.x, n = e.y, s = Math.abs(t.x - r), i = Math.abs(t.y - n), a = e.width / 2, c = e.height / 2;
+  return s >= a || i >= c;
+}, "outsideNode"), Lr = /* @__PURE__ */ u((e, t, r) => {
+  L.debug(`intersection calc abc89:
+  outsidePoint: ${JSON.stringify(t)}
+  insidePoint : ${JSON.stringify(r)}
+  node        : x:${e.x} y:${e.y} w:${e.width} h:${e.height}`);
+  const n = e.x, s = e.y, i = Math.abs(n - r.x), a = e.width / 2;
+  let c = r.x < t.x ? a - i : a + i;
+  const l = e.height / 2, g = Math.abs(t.y - r.y), o = Math.abs(t.x - r.x);
+  if (Math.abs(s - t.y) * a > Math.abs(n - t.x) * l) {
+    let d = r.y < t.y ? t.y - l - s : s - l - t.y;
+    c = o * d / g;
+    const x = {
+      x: r.x < t.x ? r.x + c : r.x - o + c,
+      y: r.y < t.y ? r.y + g - d : r.y - g + d
+    };
+    return c === 0 && (x.x = t.x, x.y = t.y), o === 0 && (x.x = t.x), g === 0 && (x.y = t.y), L.debug(`abc89 topp/bott calc, Q ${g}, q ${d}, R ${o}, r ${c}`, x), x;
+  } else {
+    r.x < t.x ? c = t.x - a - n : c = n - a - t.x;
+    let d = g * c / o, x = r.x < t.x ? r.x + o - c : r.x - o + c, m = r.y < t.y ? r.y + d : r.y - d;
+    return L.debug(`sides calc abc89, Q ${g}, q ${d}, R ${o}, r ${c}`, {
+      _x: x,
+      _y: m
+    }), c === 0 && (x = t.x, m = t.y), o === 0 && (x = t.x), g === 0 && (m = t.y), {
+      x,
+      y: m
+    };
+  }
+}, "intersection"), Ft = /* @__PURE__ */ u((e, t) => {
+  L.debug("abc88 cutPathAtIntersect", e, t);
+  let r = [], n = e[0], s = !1;
+  return e.forEach((i) => {
+    if (!Sr(t, i) && !s) {
+      const a = Lr(t, n, i);
+      let c = !1;
+      r.forEach((l) => {
+        c = c || l.x === a.x && l.y === a.y;
+      }), r.some((l) => l.x === a.x && l.y === a.y) || r.push(a), s = !0;
+    } else
+      n = i, s || r.push(i);
+  }), r;
+}, "cutPathAtIntersect"), kr = /* @__PURE__ */ u(function(e, t, r, n, s, i, a) {
+  let c = r.points;
+  L.debug("abc88 InsertEdge: edge=", r, "e=", t);
+  let l = !1;
+  const g = i.node(t.v);
+  var o = i.node(t.w);
+  o?.intersect && g?.intersect && (c = c.slice(1, r.points.length - 1), c.unshift(g.intersect(c[0])), c.push(o.intersect(c[c.length - 1]))), r.toCluster && (L.debug("to cluster abc88", n[r.toCluster]), c = Ft(r.points, n[r.toCluster].node), l = !0), r.fromCluster && (L.debug("from cluster abc88", n[r.fromCluster]), c = Ft(c.reverse(), n[r.fromCluster].node).reverse(), l = !0);
+  const d = c.filter((b) => !Number.isNaN(b.y));
+  let x = Fe;
+  r.curve && (s === "graph" || s === "flowchart") && (x = r.curve);
+  const { x: m, y } = Ge(r), v = Ve().x(m).y(y).curve(x);
+  let S;
+  switch (r.thickness) {
+    case "normal":
+      S = "edge-thickness-normal";
+      break;
+    case "thick":
+      S = "edge-thickness-thick";
+      break;
+    case "invisible":
+      S = "edge-thickness-thick";
+      break;
+    default:
+      S = "";
+  }
+  switch (r.pattern) {
+    case "solid":
+      S += " edge-pattern-solid";
+      break;
+    case "dotted":
+      S += " edge-pattern-dotted";
+      break;
+    case "dashed":
+      S += " edge-pattern-dashed";
+      break;
+  }
+  const N = e.append("path").attr("d", v(d)).attr("id", r.id).attr("class", " " + S + (r.classes ? " " + r.classes : "")).attr("style", r.style);
+  let w = "";
+  (C().flowchart.arrowMarkerAbsolute || C().state.arrowMarkerAbsolute) && (w = fe(!0)), yr(N, r, w, a, s);
+  let f = {};
+  return l && (f.updatedPath = c), f.originalPath = r.points, f;
+}, "insertEdge"), vr = /* @__PURE__ */ u((e) => {
+  const t = /* @__PURE__ */ new Set();
+  for (const r of e) switch (r) {
+    case "x":
+      t.add("right"), t.add("left");
+      break;
+    case "y":
+      t.add("up"), t.add("down");
+      break;
+    default:
+      t.add(r);
+      break;
+  }
+  return t;
+}, "expandAndDeduplicateDirections"), Er = /* @__PURE__ */ u((e, t, r, n) => {
+  const s = vr(e), i = 2, a = t.height + 2 * r.padding, c = a / i, l = n ?? t.width + 2 * c + r.padding, g = r.padding / 2;
+  return s.has("right") && s.has("left") && s.has("up") && s.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: c,
+      y: 0
+    },
+    {
+      x: l / 2,
+      y: 2 * g
+    },
+    {
+      x: l - c,
+      y: 0
+    },
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: l,
+      y: -a / 3
+    },
+    {
+      x: l + 2 * g,
+      y: -a / 2
+    },
+    {
+      x: l,
+      y: -2 * a / 3
+    },
+    {
+      x: l,
+      y: -a
+    },
+    {
+      x: l - c,
+      y: -a
+    },
+    {
+      x: l / 2,
+      y: -a - 2 * g
+    },
+    {
+      x: c,
+      y: -a
+    },
+    {
+      x: 0,
+      y: -a
+    },
+    {
+      x: 0,
+      y: -2 * a / 3
+    },
+    {
+      x: -2 * g,
+      y: -a / 2
+    },
+    {
+      x: 0,
+      y: -a / 3
+    }
+  ] : s.has("right") && s.has("left") && s.has("up") ? [
+    {
+      x: c,
+      y: 0
+    },
+    {
+      x: l - c,
+      y: 0
+    },
+    {
+      x: l,
+      y: -a / 2
+    },
+    {
+      x: l - c,
+      y: -a
+    },
+    {
+      x: c,
+      y: -a
+    },
+    {
+      x: 0,
+      y: -a / 2
+    }
+  ] : s.has("right") && s.has("left") && s.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: c,
+      y: -a
+    },
+    {
+      x: l - c,
+      y: -a
+    },
+    {
+      x: l,
+      y: 0
+    }
+  ] : s.has("right") && s.has("up") && s.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: -c
+    },
+    {
+      x: l,
+      y: -a + c
+    },
+    {
+      x: 0,
+      y: -a
+    }
+  ] : s.has("left") && s.has("up") && s.has("down") ? [
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -c
+    },
+    {
+      x: 0,
+      y: -a + c
+    },
+    {
+      x: l,
+      y: -a
+    }
+  ] : s.has("right") && s.has("left") ? [
+    {
+      x: c,
+      y: 0
+    },
+    {
+      x: c,
+      y: -g
+    },
+    {
+      x: l - c,
+      y: -g
+    },
+    {
+      x: l - c,
+      y: 0
+    },
+    {
+      x: l,
+      y: -a / 2
+    },
+    {
+      x: l - c,
+      y: -a
+    },
+    {
+      x: l - c,
+      y: -a + g
+    },
+    {
+      x: c,
+      y: -a + g
+    },
+    {
+      x: c,
+      y: -a
+    },
+    {
+      x: 0,
+      y: -a / 2
+    }
+  ] : s.has("up") && s.has("down") ? [
+    {
+      x: l / 2,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -g
+    },
+    {
+      x: c,
+      y: -g
+    },
+    {
+      x: c,
+      y: -a + g
+    },
+    {
+      x: 0,
+      y: -a + g
+    },
+    {
+      x: l / 2,
+      y: -a
+    },
+    {
+      x: l,
+      y: -a + g
+    },
+    {
+      x: l - c,
+      y: -a + g
+    },
+    {
+      x: l - c,
+      y: -g
+    },
+    {
+      x: l,
+      y: -g
+    }
+  ] : s.has("right") && s.has("up") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: -c
+    },
+    {
+      x: 0,
+      y: -a
+    }
+  ] : s.has("right") && s.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -a
+    }
+  ] : s.has("left") && s.has("up") ? [
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -c
+    },
+    {
+      x: l,
+      y: -a
+    }
+  ] : s.has("left") && s.has("down") ? [
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: -a
+    }
+  ] : s.has("right") ? [
+    {
+      x: c,
+      y: -g
+    },
+    {
+      x: c,
+      y: -g
+    },
+    {
+      x: l - c,
+      y: -g
+    },
+    {
+      x: l - c,
+      y: 0
+    },
+    {
+      x: l,
+      y: -a / 2
+    },
+    {
+      x: l - c,
+      y: -a
+    },
+    {
+      x: l - c,
+      y: -a + g
+    },
+    {
+      x: c,
+      y: -a + g
+    },
+    {
+      x: c,
+      y: -a + g
+    }
+  ] : s.has("left") ? [
+    {
+      x: c,
+      y: 0
+    },
+    {
+      x: c,
+      y: -g
+    },
+    {
+      x: l - c,
+      y: -g
+    },
+    {
+      x: l - c,
+      y: -a + g
+    },
+    {
+      x: c,
+      y: -a + g
+    },
+    {
+      x: c,
+      y: -a
+    },
+    {
+      x: 0,
+      y: -a / 2
+    }
+  ] : s.has("up") ? [
+    {
+      x: c,
+      y: -g
+    },
+    {
+      x: c,
+      y: -a + g
+    },
+    {
+      x: 0,
+      y: -a + g
+    },
+    {
+      x: l / 2,
+      y: -a
+    },
+    {
+      x: l,
+      y: -a + g
+    },
+    {
+      x: l - c,
+      y: -a + g
+    },
+    {
+      x: l - c,
+      y: -g
+    }
+  ] : s.has("down") ? [
+    {
+      x: l / 2,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -g
+    },
+    {
+      x: c,
+      y: -g
+    },
+    {
+      x: c,
+      y: -a + g
+    },
+    {
+      x: l - c,
+      y: -a + g
+    },
+    {
+      x: l - c,
+      y: -g
+    },
+    {
+      x: l,
+      y: -g
+    }
+  ] : [{
+    x: 0,
+    y: 0
+  }];
+}, "getArrowPoints");
+function te(e, t) {
+  return e.intersect(t);
+}
+u(te, "intersectNode");
+var _r = te;
+function ee(e, t, r, n) {
+  var s = e.x, i = e.y, a = s - n.x, c = i - n.y, l = Math.sqrt(t * t * c * c + r * r * a * a), g = Math.abs(t * r * a / l);
+  n.x < s && (g = -g);
+  var o = Math.abs(t * r * c / l);
+  return n.y < i && (o = -o), {
+    x: s + g,
+    y: i + o
+  };
+}
+u(ee, "intersectEllipse");
+var re = ee;
+function ae(e, t, r) {
+  return re(e, t, t, r);
+}
+u(ae, "intersectCircle");
+var Tr = ae;
+function se(e, t, r, n) {
+  var s, i, a, c, l, g, o, d, x, m, y, v, S, N, w;
+  if (s = t.y - e.y, a = e.x - t.x, l = t.x * e.y - e.x * t.y, x = s * r.x + a * r.y + l, m = s * n.x + a * n.y + l, !(x !== 0 && m !== 0 && Et(x, m)) && (i = n.y - r.y, c = r.x - n.x, g = n.x * r.y - r.x * n.y, o = i * e.x + c * e.y + g, d = i * t.x + c * t.y + g, !(o !== 0 && d !== 0 && Et(o, d)) && (y = s * c - i * a, y !== 0)))
+    return v = Math.abs(y / 2), S = a * g - c * l, N = S < 0 ? (S - v) / y : (S + v) / y, S = i * l - s * g, w = S < 0 ? (S - v) / y : (S + v) / y, {
+      x: N,
+      y: w
+    };
+}
+u(se, "intersectLine");
+function Et(e, t) {
+  return e * t > 0;
+}
+u(Et, "sameSign");
+var Dr = se, Nr = ie;
+function ie(e, t, r) {
+  var n = e.x, s = e.y, i = [], a = Number.POSITIVE_INFINITY, c = Number.POSITIVE_INFINITY;
+  typeof t.forEach == "function" ? t.forEach(function(y) {
+    a = Math.min(a, y.x), c = Math.min(c, y.y);
+  }) : (a = Math.min(a, t.x), c = Math.min(c, t.y));
+  for (var l = n - e.width / 2 - a, g = s - e.height / 2 - c, o = 0; o < t.length; o++) {
+    var d = t[o], x = t[o < t.length - 1 ? o + 1 : 0], m = Dr(e, r, {
+      x: l + d.x,
+      y: g + d.y
+    }, {
+      x: l + x.x,
+      y: g + x.y
+    });
+    m && i.push(m);
+  }
+  return i.length ? (i.length > 1 && i.sort(function(y, v) {
+    var S = y.x - r.x, N = y.y - r.y, w = Math.sqrt(S * S + N * N), f = v.x - r.x, b = v.y - r.y, E = Math.sqrt(f * f + b * b);
+    return w < E ? -1 : w === E ? 0 : 1;
+  }), i[0]) : e;
+}
+u(ie, "intersectPolygon");
+var D = {
+  node: _r,
+  circle: Tr,
+  ellipse: re,
+  polygon: Nr,
+  rect: /* @__PURE__ */ u((e, t) => {
+    var r = e.x, n = e.y, s = t.x - r, i = t.y - n, a = e.width / 2, c = e.height / 2, l, g;
+    return Math.abs(i) * a > Math.abs(s) * c ? (i < 0 && (c = -c), l = i === 0 ? 0 : c * s / i, g = c) : (s < 0 && (a = -a), l = a, g = s === 0 ? 0 : a * i / s), {
+      x: r + l,
+      y: n + g
+    };
+  }, "intersectRect")
+}, R = /* @__PURE__ */ u(async (e, t, r, n) => {
+  const s = C();
+  let i;
+  const a = t.useHtmlLabels || M(s);
+  r ? i = r : i = "node default";
+  const c = e.insert("g").attr("class", i).attr("id", t.domId || t.id), l = c.insert("g").attr("class", "label").attr("style", t.labelStyle);
+  let g;
+  t.labelText === void 0 ? g = "" : g = typeof t.labelText == "string" ? t.labelText : t.labelText[0];
+  let o;
+  t.labelType === "markdown" ? o = _t(l, Ct(Rt(g), s), {
+    useHtmlLabels: a,
+    width: t.width || s.flowchart.wrappingWidth,
+    classes: "markdown-node-label"
+  }, s) : o = await K(l, Ct(Rt(g), s), t.labelStyle, !1, n);
+  let d = o.getBBox();
+  const x = t.padding / 2;
+  if (M(s)) {
+    const m = o.children[0], y = T(o);
+    await qe(m, g), d = m.getBoundingClientRect(), y.attr("width", d.width), y.attr("height", d.height);
+  }
+  return a ? l.attr("transform", "translate(" + -d.width / 2 + ", " + -d.height / 2 + ")") : l.attr("transform", "translate(0, " + -d.height / 2 + ")"), t.centerLabel && l.attr("transform", "translate(" + -d.width / 2 + ", " + -d.height / 2 + ")"), l.insert("rect", ":first-child"), {
+    shapeSvg: c,
+    bbox: d,
+    halfPadding: x,
+    label: l
+  };
+}, "labelHelper"), I = /* @__PURE__ */ u((e, t) => {
+  const r = t.node().getBBox();
+  e.width = r.width, e.height = r.height;
+}, "updateNodeBounds");
+function U(e, t, r, n) {
+  return e.insert("polygon", ":first-child").attr("points", n.map(function(s) {
+    return s.x + "," + s.y;
+  }).join(" ")).attr("class", "label-container").attr("transform", "translate(" + -t / 2 + "," + r / 2 + ")");
+}
+u(U, "insertPolygonShape");
+var Ir = /* @__PURE__ */ u(async (e, t) => {
+  t.useHtmlLabels || M(C()) || (t.centerLabel = !0);
+  const { shapeSvg: r, bbox: n, halfPadding: s } = await R(e, t, "node " + t.classes, !0);
+  L.info("Classes = ", t.classes);
+  const i = r.insert("rect", ":first-child");
+  return i.attr("rx", t.rx).attr("ry", t.ry).attr("x", -n.width / 2 - s).attr("y", -n.height / 2 - s).attr("width", n.width + t.padding).attr("height", n.height + t.padding), I(t, i), t.intersect = function(a) {
+    return D.rect(t, a);
+  }, r;
+}, "note"), Wt = /* @__PURE__ */ u((e) => e ? " " + e : "", "formatClass"), F = /* @__PURE__ */ u((e, t) => `${t || "node default"}${Wt(e.classes)} ${Wt(e.class)}`, "getClassesFromNode"), Yt = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding + (n.height + t.padding), i = [
+    {
+      x: s / 2,
+      y: 0
+    },
+    {
+      x: s,
+      y: -s / 2
+    },
+    {
+      x: s / 2,
+      y: -s
+    },
+    {
+      x: 0,
+      y: -s / 2
+    }
+  ];
+  L.info("Question main (Circle)");
+  const a = U(r, s, s, i);
+  return a.attr("style", t.style), I(t, a), t.intersect = function(c) {
+    return L.warn("Intersect called"), D.polygon(t, i, c);
+  }, r;
+}, "question"), Br = /* @__PURE__ */ u((e, t) => {
+  const r = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id), n = 28, s = [
+    {
+      x: 0,
+      y: n / 2
+    },
+    {
+      x: n / 2,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -28 / 2
+    },
+    {
+      x: -28 / 2,
+      y: 0
+    }
+  ];
+  return r.insert("polygon", ":first-child").attr("points", s.map(function(i) {
+    return i.x + "," + i.y;
+  }).join(" ")).attr("class", "state-start").attr("r", 7).attr("width", 28).attr("height", 28), t.width = 28, t.height = 28, t.intersect = function(i) {
+    return D.circle(t, 14, i);
+  }, r;
+}, "choice"), Or = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = 4, i = t.positioned ? t.height : n.height + t.padding, a = i / s, c = t.positioned ? t.width : n.width + 2 * a + t.padding, l = [
+    {
+      x: a,
+      y: 0
+    },
+    {
+      x: c - a,
+      y: 0
+    },
+    {
+      x: c,
+      y: -i / 2
+    },
+    {
+      x: c - a,
+      y: -i
+    },
+    {
+      x: a,
+      y: -i
+    },
+    {
+      x: 0,
+      y: -i / 2
+    }
+  ], g = U(r, c, i, l);
+  return g.attr("style", t.style), I(t, g), t.intersect = function(o) {
+    return D.polygon(t, l, o);
+  }, r;
+}, "hexagon"), Cr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, void 0, !0), s = 2, i = n.height + 2 * t.padding, a = i / s, c = n.width + 2 * a + t.padding, l = t.positioned && (t.widthInColumns ?? 1) > 1 && t.width > c ? t.width : c, g = Er(t.directions, n, t, l), o = U(r, l, i, g);
+  return o.attr("style", t.style), I(t, o), t.intersect = function(d) {
+    return D.polygon(t, g, d);
+  }, r;
+}, "block_arrow"), Rr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding, i = n.height + t.padding, a = [
+    {
+      x: -i / 2,
+      y: 0
+    },
+    {
+      x: s,
+      y: 0
+    },
+    {
+      x: s,
+      y: -i
+    },
+    {
+      x: -i / 2,
+      y: -i
+    },
+    {
+      x: 0,
+      y: -i / 2
+    }
+  ];
+  return U(r, s, i, a).attr("style", t.style), t.width = s + i, t.height = i, t.intersect = function(c) {
+    return D.polygon(t, a, c);
+  }, r;
+}, "rect_left_inv_arrow"), Ar = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t), !0), s = n.width + t.padding, i = n.height + t.padding, a = [
+    {
+      x: -2 * i / 6,
+      y: 0
+    },
+    {
+      x: s - i / 6,
+      y: 0
+    },
+    {
+      x: s + 2 * i / 6,
+      y: -i
+    },
+    {
+      x: i / 6,
+      y: -i
+    }
+  ], c = U(r, s, i, a);
+  return c.attr("style", t.style), I(t, c), t.intersect = function(l) {
+    return D.polygon(t, a, l);
+  }, r;
+}, "lean_right"), zr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding, i = n.height + t.padding, a = [
+    {
+      x: 2 * i / 6,
+      y: 0
+    },
+    {
+      x: s + i / 6,
+      y: 0
+    },
+    {
+      x: s - 2 * i / 6,
+      y: -i
+    },
+    {
+      x: -i / 6,
+      y: -i
+    }
+  ], c = U(r, s, i, a);
+  return c.attr("style", t.style), I(t, c), t.intersect = function(l) {
+    return D.polygon(t, a, l);
+  }, r;
+}, "lean_left"), Mr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding, i = n.height + t.padding, a = [
+    {
+      x: -2 * i / 6,
+      y: 0
+    },
+    {
+      x: s + 2 * i / 6,
+      y: 0
+    },
+    {
+      x: s - i / 6,
+      y: -i
+    },
+    {
+      x: i / 6,
+      y: -i
+    }
+  ], c = U(r, s, i, a);
+  return c.attr("style", t.style), I(t, c), t.intersect = function(l) {
+    return D.polygon(t, a, l);
+  }, r;
+}, "trapezoid"), Pr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding, i = n.height + t.padding, a = [
+    {
+      x: i / 6,
+      y: 0
+    },
+    {
+      x: s - i / 6,
+      y: 0
+    },
+    {
+      x: s + 2 * i / 6,
+      y: -i
+    },
+    {
+      x: -2 * i / 6,
+      y: -i
+    }
+  ], c = U(r, s, i, a);
+  return c.attr("style", t.style), I(t, c), t.intersect = function(l) {
+    return D.polygon(t, a, l);
+  }, r;
+}, "inv_trapezoid"), Fr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding, i = n.height + t.padding, a = [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: s + i / 2,
+      y: 0
+    },
+    {
+      x: s,
+      y: -i / 2
+    },
+    {
+      x: s + i / 2,
+      y: -i
+    },
+    {
+      x: 0,
+      y: -i
+    }
+  ], c = U(r, s, i, a);
+  return c.attr("style", t.style), I(t, c), t.intersect = function(l) {
+    return D.polygon(t, a, l);
+  }, r;
+}, "rect_right_inv_arrow"), Wr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding, i = s / 2, a = i / (2.5 + s / 50), c = n.height + a + t.padding, l = "M 0," + a + " a " + i + "," + a + " 0,0,0 " + s + " 0 a " + i + "," + a + " 0,0,0 " + -s + " 0 l 0," + c + " a " + i + "," + a + " 0,0,0 " + s + " 0 l 0," + -c;
+  return I(t, r.attr("label-offset-y", a).insert("path", ":first-child").attr("style", t.style).attr("d", l).attr("transform", "translate(" + -s / 2 + "," + -(c / 2 + a) + ")")), t.intersect = function(g) {
+    const o = D.rect(t, g), d = o.x - t.x;
+    if (i != 0 && (Math.abs(d) < t.width / 2 || Math.abs(d) == t.width / 2 && Math.abs(o.y - t.y) > t.height / 2 - a)) {
+      let x = a * a * (1 - d * d / (i * i));
+      x != 0 && (x = Math.sqrt(x)), x = a - x, g.y - t.y > 0 && (x = -x), o.y += x;
+    }
+    return o;
+  }, r;
+}, "cylinder"), Yr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n, halfPadding: s } = await R(e, t, "node " + t.classes + " " + t.class, !0), i = r.insert("rect", ":first-child"), a = t.positioned ? t.width : n.width + t.padding, c = t.positioned ? t.height : n.height + t.padding, l = t.positioned ? -a / 2 : -n.width / 2 - s, g = t.positioned ? -c / 2 : -n.height / 2 - s;
+  if (i.attr("class", "basic label-container").attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("x", l).attr("y", g).attr("width", a).attr("height", c), t.props) {
+    const o = new Set(Object.keys(t.props));
+    t.props.borders && (lt(i, t.props.borders, a, c), o.delete("borders")), o.forEach((d) => {
+      L.warn(`Unknown node property ${d}`);
+    });
+  }
+  return I(t, i), t.intersect = function(o) {
+    return D.rect(t, o);
+  }, r;
+}, "rect"), Hr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n, halfPadding: s } = await R(e, t, "node " + t.classes, !0), i = r.insert("rect", ":first-child"), a = t.positioned ? t.width : n.width + t.padding, c = t.positioned ? t.height : n.height + t.padding, l = t.positioned ? -a / 2 : -n.width / 2 - s, g = t.positioned ? -c / 2 : -n.height / 2 - s;
+  if (i.attr("class", "basic cluster composite label-container").attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("x", l).attr("y", g).attr("width", a).attr("height", c), t.props) {
+    const o = new Set(Object.keys(t.props));
+    t.props.borders && (lt(i, t.props.borders, a, c), o.delete("borders")), o.forEach((d) => {
+      L.warn(`Unknown node property ${d}`);
+    });
+  }
+  return I(t, i), t.intersect = function(o) {
+    return D.rect(t, o);
+  }, r;
+}, "composite"), Kr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r } = await R(e, t, "label", !0);
+  L.trace("Classes = ", t.class);
+  const n = r.insert("rect", ":first-child"), s = 0, i = 0;
+  if (n.attr("width", s).attr("height", i), r.attr("class", "label edgeLabel"), t.props) {
+    const a = new Set(Object.keys(t.props));
+    t.props.borders && (lt(n, t.props.borders, s, i), a.delete("borders")), a.forEach((c) => {
+      L.warn(`Unknown node property ${c}`);
+    });
+  }
+  return I(t, n), t.intersect = function(a) {
+    return D.rect(t, a);
+  }, r;
+}, "labelRect");
+function lt(e, t, r, n) {
+  const s = [], i = /* @__PURE__ */ u((c) => {
+    s.push(c, 0);
+  }, "addBorder"), a = /* @__PURE__ */ u((c) => {
+    s.push(0, c);
+  }, "skipBorder");
+  t.includes("t") ? (L.debug("add top border"), i(r)) : a(r), t.includes("r") ? (L.debug("add right border"), i(n)) : a(n), t.includes("b") ? (L.debug("add bottom border"), i(r)) : a(r), t.includes("l") ? (L.debug("add left border"), i(n)) : a(n), e.attr("stroke-dasharray", s.join(" "));
+}
+u(lt, "applyNodePropertyBorders");
+var Ur = /* @__PURE__ */ u(async (e, t) => {
+  let r;
+  t.classes ? r = "node " + t.classes : r = "node default";
+  const n = e.insert("g").attr("class", r).attr("id", t.domId || t.id), s = n.insert("rect", ":first-child"), i = n.insert("line"), a = n.insert("g").attr("class", "label"), c = t.labelText.flat ? t.labelText.flat() : t.labelText;
+  let l = "";
+  typeof c == "object" ? l = c[0] : l = c, L.info("Label text abc79", l, c, typeof c == "object");
+  const g = await K(a, l, t.labelStyle, !0, !0);
+  let o = {
+    width: 0,
+    height: 0
+  };
+  if (M(C())) {
+    const v = g.children[0], S = T(g);
+    o = v.getBoundingClientRect(), S.attr("width", o.width), S.attr("height", o.height);
+  }
+  L.info("Text 2", c);
+  const d = c.slice(1, c.length);
+  let x = g.getBBox();
+  const m = await K(a, d.join ? d.join("<br/>") : d, t.labelStyle, !0, !0);
+  if (M(C())) {
+    const v = m.children[0], S = T(m);
+    o = v.getBoundingClientRect(), S.attr("width", o.width), S.attr("height", o.height);
+  }
+  const y = t.padding / 2;
+  return T(m).attr("transform", "translate( " + (o.width > x.width ? 0 : (x.width - o.width) / 2) + ", " + (x.height + y + 5) + ")"), T(g).attr("transform", "translate( " + (o.width < x.width ? 0 : -(x.width - o.width) / 2) + ", 0)"), o = a.node().getBBox(), a.attr("transform", "translate(" + -o.width / 2 + ", " + (-o.height / 2 - y + 3) + ")"), s.attr("class", "outer title-state").attr("x", -o.width / 2 - y).attr("y", -o.height / 2 - y).attr("width", o.width + t.padding).attr("height", o.height + t.padding), i.attr("class", "divider").attr("x1", -o.width / 2 - y).attr("x2", o.width / 2 + y).attr("y1", -o.height / 2 - y + x.height + y).attr("y2", -o.height / 2 - y + x.height + y), I(t, s), t.intersect = function(v) {
+    return D.rect(t, v);
+  }, n;
+}, "rectWithTitle"), Xr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.height + t.padding, i = n.width + s / 4 + t.padding;
+  return I(t, r.insert("rect", ":first-child").attr("style", t.style).attr("rx", s / 2).attr("ry", s / 2).attr("x", -i / 2).attr("y", -s / 2).attr("width", i).attr("height", s)), t.intersect = function(a) {
+    return D.rect(t, a);
+  }, r;
+}, "stadium"), Vr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n, halfPadding: s } = await R(e, t, F(t, void 0), !0), i = r.insert("circle", ":first-child");
+  return i.attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("r", n.width / 2 + s).attr("width", n.width + t.padding).attr("height", n.height + t.padding), L.info("Circle main"), I(t, i), t.intersect = function(a) {
+    return L.info("Circle intersect", t, n.width / 2 + s, a), D.circle(t, n.width / 2 + s, a);
+  }, r;
+}, "circle"), jr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n, halfPadding: s } = await R(e, t, F(t, void 0), !0), i = 5, a = r.insert("g", ":first-child"), c = a.insert("circle"), l = a.insert("circle");
+  return a.attr("class", t.class), c.attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("r", n.width / 2 + s + i).attr("width", n.width + t.padding + i * 2).attr("height", n.height + t.padding + i * 2), l.attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("r", n.width / 2 + s).attr("width", n.width + t.padding).attr("height", n.height + t.padding), L.info("DoubleCircle main"), I(t, c), t.intersect = function(g) {
+    return L.info("DoubleCircle intersect", t, n.width / 2 + s + i, g), D.circle(t, n.width / 2 + s + i, g);
+  }, r;
+}, "doublecircle"), Gr = /* @__PURE__ */ u(async (e, t) => {
+  const { shapeSvg: r, bbox: n } = await R(e, t, F(t, void 0), !0), s = n.width + t.padding, i = n.height + t.padding, a = [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: s,
+      y: 0
+    },
+    {
+      x: s,
+      y: -i
+    },
+    {
+      x: 0,
+      y: -i
+    },
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: -8,
+      y: 0
+    },
+    {
+      x: s + 8,
+      y: 0
+    },
+    {
+      x: s + 8,
+      y: -i
+    },
+    {
+      x: -8,
+      y: -i
+    },
+    {
+      x: -8,
+      y: 0
+    }
+  ], c = U(r, s, i, a);
+  return c.attr("style", t.style), I(t, c), t.intersect = function(l) {
+    return D.polygon(t, a, l);
+  }, r;
+}, "subroutine"), Zr = /* @__PURE__ */ u((e, t) => {
+  const r = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id), n = r.insert("circle", ":first-child");
+  return n.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14), I(t, n), t.intersect = function(s) {
+    return D.circle(t, 7, s);
+  }, r;
+}, "start"), Ht = /* @__PURE__ */ u((e, t, r) => {
+  const n = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id);
+  let s = 70, i = 10;
+  return r === "LR" && (s = 10, i = 70), I(t, n.append("rect").attr("x", -1 * s / 2).attr("y", -1 * i / 2).attr("width", s).attr("height", i).attr("class", "fork-join")), t.height = t.height + t.padding / 2, t.width = t.width + t.padding / 2, t.intersect = function(a) {
+    return D.rect(t, a);
+  }, n;
+}, "forkJoin"), Kt = {
+  rhombus: Yt,
+  composite: Hr,
+  question: Yt,
+  rect: Yr,
+  labelRect: Kr,
+  rectWithTitle: Ur,
+  choice: Br,
+  circle: Vr,
+  doublecircle: jr,
+  stadium: Xr,
+  hexagon: Or,
+  block_arrow: Cr,
+  rect_left_inv_arrow: Rr,
+  lean_right: Ar,
+  lean_left: zr,
+  trapezoid: Mr,
+  inv_trapezoid: Pr,
+  rect_right_inv_arrow: Fr,
+  cylinder: Wr,
+  start: Zr,
+  end: /* @__PURE__ */ u((e, t) => {
+    const r = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id), n = r.insert("circle", ":first-child"), s = r.insert("circle", ":first-child");
+    return s.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14), n.attr("class", "state-end").attr("r", 5).attr("width", 10).attr("height", 10), I(t, s), t.intersect = function(i) {
+      return D.circle(t, 7, i);
+    }, r;
+  }, "end"),
+  note: Ir,
+  subroutine: Gr,
+  fork: Ht,
+  join: Ht,
+  class_box: /* @__PURE__ */ u(async (e, t) => {
+    const r = t.padding / 2, n = 4, s = 8;
+    let i;
+    t.classes ? i = "node " + t.classes : i = "node default";
+    const a = e.insert("g").attr("class", i).attr("id", t.domId || t.id), c = a.insert("rect", ":first-child"), l = a.insert("line"), g = a.insert("line");
+    let o = 0, d = n;
+    const x = a.insert("g").attr("class", "label");
+    let m = 0;
+    const y = t.classData.annotations?.[0], v = await K(x, t.classData.annotations[0] ? "«" + t.classData.annotations[0] + "»" : "", t.labelStyle, !0, !0);
+    let S = v.getBBox();
+    if (M(C())) {
+      const _ = v.children[0], h = T(v);
+      S = _.getBoundingClientRect(), h.attr("width", S.width), h.attr("height", S.height);
+    }
+    t.classData.annotations[0] && (d += S.height + n, o += S.width);
+    let N = t.classData.label;
+    t.classData.type !== void 0 && t.classData.type !== "" && (M(C()) ? N += "&lt;" + t.classData.type + "&gt;" : N += "<" + t.classData.type + ">");
+    const w = await K(x, N, t.labelStyle, !0, !0);
+    T(w).attr("class", "classTitle");
+    let f = w.getBBox();
+    if (M(C())) {
+      const _ = w.children[0], h = T(w);
+      f = _.getBoundingClientRect(), h.attr("width", f.width), h.attr("height", f.height);
+    }
+    d += f.height + n, f.width > o && (o = f.width);
+    const b = [];
+    t.classData.members.forEach(async (_) => {
+      const h = _.getDisplayDetails();
+      let P = h.displayText;
+      M(C()) && (P = P.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+      const p = await K(x, P, h.cssStyle ? h.cssStyle : t.labelStyle, !0, !0);
+      let B = p.getBBox();
+      if (M(C())) {
+        const j = p.children[0], X = T(p);
+        B = j.getBoundingClientRect(), X.attr("width", B.width), X.attr("height", B.height);
+      }
+      B.width > o && (o = B.width), d += B.height + n, b.push(p);
+    }), d += s;
+    const E = [];
+    if (t.classData.methods.forEach(async (_) => {
+      const h = _.getDisplayDetails();
+      let P = h.displayText;
+      M(C()) && (P = P.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+      const p = await K(x, P, h.cssStyle ? h.cssStyle : t.labelStyle, !0, !0);
+      let B = p.getBBox();
+      if (M(C())) {
+        const j = p.children[0], X = T(p);
+        B = j.getBoundingClientRect(), X.attr("width", B.width), X.attr("height", B.height);
+      }
+      B.width > o && (o = B.width), d += B.height + n, E.push(p);
+    }), d += s, y) {
+      let _ = (o - S.width) / 2;
+      T(v).attr("transform", "translate( " + (-1 * o / 2 + _) + ", " + -1 * d / 2 + ")"), m = S.height + n;
+    }
+    let k = (o - f.width) / 2;
+    return T(w).attr("transform", "translate( " + (-1 * o / 2 + k) + ", " + (-1 * d / 2 + m) + ")"), m += f.height + n, l.attr("class", "divider").attr("x1", -o / 2 - r).attr("x2", o / 2 + r).attr("y1", -d / 2 - r + s + m).attr("y2", -d / 2 - r + s + m), m += s, b.forEach((_) => {
+      T(_).attr("transform", "translate( " + -o / 2 + ", " + (-1 * d / 2 + m + s / 2) + ")");
+      const h = _?.getBBox();
+      m += (h?.height ?? 0) + n;
+    }), m += s, g.attr("class", "divider").attr("x1", -o / 2 - r).attr("x2", o / 2 + r).attr("y1", -d / 2 - r + s + m).attr("y2", -d / 2 - r + s + m), m += s, E.forEach((_) => {
+      T(_).attr("transform", "translate( " + -o / 2 + ", " + (-1 * d / 2 + m) + ")");
+      const h = _?.getBBox();
+      m += (h?.height ?? 0) + n;
+    }), c.attr("style", t.style).attr("class", "outer title-state").attr("x", -o / 2 - r).attr("y", -(d / 2) - r).attr("width", o + t.padding).attr("height", d + t.padding), I(t, c), t.intersect = function(_) {
+      return D.rect(t, _);
+    }, a;
+  }, "class_box")
+}, it = {}, ne = /* @__PURE__ */ u(async (e, t, r) => {
+  let n, s;
+  if (t.link) {
+    let i;
+    C().securityLevel === "sandbox" ? i = "_top" : t.linkTarget && (i = t.linkTarget || "_blank"), n = e.insert("svg:a").attr("xlink:href", t.link).attr("target", i), s = await Kt[t.shape](n, t, r);
+  } else
+    s = await Kt[t.shape](e, t, r), n = s;
+  return t.tooltip && s.attr("title", t.tooltip), t.class && s.attr("class", "node default " + t.class), it[t.id] = n, t.haveCallback && it[t.id].attr("class", it[t.id].attr("class") + " clickable"), n;
+}, "insertNode"), qr = /* @__PURE__ */ u((e) => {
+  const t = it[e.id];
+  L.trace("Transforming node", e.diff, e, "translate(" + (e.x - e.width / 2 - 5) + ", " + e.width / 2 + ")");
+  const r = 8, n = e.diff || 0;
+  return e.clusterNode ? t.attr("transform", "translate(" + (e.x + n - e.width / 2) + ", " + (e.y - e.height / 2 - r) + ")") : t.attr("transform", "translate(" + e.x + ", " + e.y + ")"), n;
+}, "positionNode");
+function It(e, t, r = !1) {
+  const n = e;
+  let s = "default";
+  (n?.classes?.length || 0) > 0 && (s = (n?.classes ?? []).join(" ")), s = s + " flowchart-label";
+  let i = 0, a = "", c;
+  switch (n.type) {
+    case "round":
+      i = 5, a = "rect";
+      break;
+    case "composite":
+      i = 0, a = "composite", c = 0;
+      break;
+    case "square":
+      a = "rect";
+      break;
+    case "diamond":
+      a = "question";
+      break;
+    case "hexagon":
+      a = "hexagon";
+      break;
+    case "block_arrow":
+      a = "block_arrow";
+      break;
+    case "odd":
+      a = "rect_left_inv_arrow";
+      break;
+    case "lean_right":
+      a = "lean_right";
+      break;
+    case "lean_left":
+      a = "lean_left";
+      break;
+    case "trapezoid":
+      a = "trapezoid";
+      break;
+    case "inv_trapezoid":
+      a = "inv_trapezoid";
+      break;
+    case "rect_left_inv_arrow":
+      a = "rect_left_inv_arrow";
+      break;
+    case "circle":
+      a = "circle";
+      break;
+    case "ellipse":
+      a = "ellipse";
+      break;
+    case "stadium":
+      a = "stadium";
+      break;
+    case "subroutine":
+      a = "subroutine";
+      break;
+    case "cylinder":
+      a = "cylinder";
+      break;
+    case "group":
+      a = "rect";
+      break;
+    case "doublecircle":
+      a = "doublecircle";
+      break;
+    default:
+      a = "rect";
+  }
+  const l = He(n?.styles ?? []), g = n.label, o = n.size ?? {
+    width: 0,
+    height: 0,
+    x: 0,
+    y: 0
+  }, d = t.getDiagramId();
+  return {
+    labelStyle: l.labelStyle,
+    shape: a,
+    labelText: g,
+    rx: i,
+    ry: i,
+    class: s,
+    style: l.style,
+    id: n.id,
+    domId: d ? `${d}-${n.id}` : n.id,
+    directions: n.directions,
+    width: o.width,
+    height: o.height,
+    x: o.x,
+    y: o.y,
+    positioned: r,
+    intersect: void 0,
+    type: n.type,
+    padding: c ?? et()?.block?.padding ?? 0,
+    widthInColumns: n.widthInColumns ?? 1
+  };
+}
+u(It, "getNodeFromBlock");
+async function ce(e, t, r) {
+  const n = It(t, r, !1);
+  if (n.type === "group") return;
+  const s = await ne(e, n, { config: et() }), i = s.node().getBBox(), a = r.getBlock(n.id);
+  a.size = {
+    width: i.width,
+    height: i.height,
+    x: 0,
+    y: 0,
+    node: s
+  }, r.setBlock(a), s.remove();
+}
+u(ce, "calculateBlockSize");
+async function le(e, t, r) {
+  const n = It(t, r, !0);
+  r.getBlock(n.id).type !== "space" && (await ne(e, n, { config: et() }), t.intersect = n?.intersect, qr(n));
+}
+u(le, "insertBlockPositioned");
+async function ot(e, t, r, n) {
+  for (const s of t)
+    await n(e, s, r), s.children && await ot(e, s.children, r, n);
+}
+u(ot, "performOperations");
+async function oe(e, t, r) {
+  await ot(e, t, r, ce);
+}
+u(oe, "calculateBlockSizes");
+async function he(e, t, r) {
+  await ot(e, t, r, le);
+}
+u(he, "insertBlocks");
+async function ge(e, t, r, n, s) {
+  const i = new Je({
+    multigraph: !0,
+    compound: !0
+  });
+  i.setGraph({
+    rankdir: "TB",
+    nodesep: 10,
+    ranksep: 10,
+    marginx: 8,
+    marginy: 8
+  });
+  for (const a of r) a.size && i.setNode(a.id, {
+    width: a.size.width,
+    height: a.size.height,
+    intersect: a.intersect
+  });
+  for (const a of t) if (a.start && a.end) {
+    const c = n.getBlock(a.start), l = n.getBlock(a.end);
+    if (c?.size && l?.size) {
+      const g = c.size, o = l.size, d = [
+        {
+          x: g.x,
+          y: g.y
+        },
+        {
+          x: g.x + (o.x - g.x) / 2,
+          y: g.y + (o.y - g.y) / 2
+        },
+        {
+          x: o.x,
+          y: o.y
+        }
+      ], x = s ? `${s}-${a.id}` : a.id, m = `${a.thickness === "thick" ? "edge-thickness-thick" : "edge-thickness-normal"} ${a.pattern === "dotted" ? "edge-pattern-dotted" : "edge-pattern-solid"} flowchart-link LS-a1 LE-b1`;
+      kr(e, {
+        v: a.start,
+        w: a.end,
+        name: x
+      }, {
+        ...a,
+        id: x,
+        arrowTypeEnd: a.arrowTypeEnd,
+        arrowTypeStart: a.arrowTypeStart,
+        points: d,
+        classes: m
+      }, void 0, "block", i, s), a.label && (await mr(e, {
+        ...a,
+        label: a.label,
+        labelStyle: "stroke: #333; stroke-width: 1.5px;fill:none;",
+        arrowTypeEnd: a.arrowTypeEnd,
+        arrowTypeStart: a.arrowTypeStart,
+        points: d,
+        classes: m
+      }), wr({
+        ...a,
+        x: d[1].x,
+        y: d[1].y
+      }, { originalPath: d }));
+    }
+  }
+}
+u(ge, "insertEdges");
+var oa = {
+  parser: sr,
+  db: gr,
+  renderer: {
+    draw: /* @__PURE__ */ u(async function(e, t, r, n) {
+      const { securityLevel: s, block: i } = et(), a = n.db;
+      a.setDiagramId(t);
+      let c;
+      s === "sandbox" && (c = T("#i" + t));
+      const l = s === "sandbox" ? T(c.nodes()[0].contentDocument.body) : T("body"), g = s === "sandbox" ? l.select(`[id="${t}"]`) : T(`[id="${t}"]`);
+      pr(g, [
+        "point",
+        "circle",
+        "cross"
+      ], n.type, t);
+      const o = a.getBlocks(), d = a.getBlocksFlat(), x = a.getEdges(), m = g.insert("g").attr("class", "block");
+      await oe(m, o, a);
+      const y = $t(a);
+      if (await he(m, o, a), await ge(m, x, d, a, t), y) {
+        const v = y, S = Math.max(1, Math.round(0.125 * (v.width / v.height))), N = v.height + S + 10, w = v.width + 10, { useMaxWidth: f } = i;
+        xe(g, N, w, !!f), L.debug("Here Bounds", y, v), g.attr("viewBox", `${v.x - 5} ${v.y - 5} ${v.width + 10} ${v.height + 10}`);
+      }
+    }, "draw"),
+    getClasses: /* @__PURE__ */ u(function(e, t) {
+      return t.db.getClasses();
+    }, "getClasses")
+  },
+  styles: ur
+};
+export {
+  oa as diagram
+};