@kong-ui-public/documentation 1.5.78 → 1.6.0

package/dist/blockDiagram-GPEHLZMM-9Cp9Hbl7-CKP-SiVG.js

@@ -0,0 +1,3268 @@
+import { p as g, o as tt, q as v, A as ye, g as S, H as pe, k as xe, aB as be, aj as fe, ap as me, Z as O, am as we, aC as z, aD as Et, aE as G, aF as Se, N as J, a as ke, aG as Le, aH as jt, aI as _e, aJ as Ee, aK as $e, aL as De, aM as ve, aN as Ne, aO as Te, aP as Ie, aQ as Oe, aR as Be, aS as Ce, aT as Re, aU as ze, aV as Ae, aW as Me, aX as Pe, aY as Ye, aZ as We, a_ as Xe, a$ as Fe, b0 as je, b1 as He, b2 as Ke, b3 as Ue, c as Bt, b4 as Ct, b5 as qe } from "./index-DfVKdDwj.js";
+import { n as Ze } from "./channel-DM9j7IFL-DxqBUxfY.js";
+import { t as Ge } from "./chunk-FMBD7UC4-D_tZ4Dxg-DwjoPGUH.js";
+import { y as Je } from "./graphlib-D2YdGpuK-CnQPmzkS.js";
+function Ve(e) {
+  return Array.isArray(e);
+}
+function Qe(e) {
+  if (Le(e)) return e;
+  let t = jt(e);
+  if (!tr(e)) return {};
+  if (Ve(e)) {
+    let 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 (_e(e)) {
+    let n = e, i = n.constructor;
+    return new i(n.buffer, n.byteOffset, n.length);
+  }
+  if (t === "[object ArrayBuffer]") return new ArrayBuffer(e.byteLength);
+  if (t === "[object DataView]") {
+    let n = e, i = n.buffer, r = n.byteOffset, s = n.byteLength, l = new ArrayBuffer(s), o = new Uint8Array(i, r, s);
+    return new Uint8Array(l).set(o), new DataView(l);
+  }
+  if (t === "[object Boolean]" || t === "[object Number]" || t === "[object String]") {
+    let n = e.constructor, i = new n(e.valueOf());
+    return t === "[object String]" ? rr(i, e) : xt(i, e), i;
+  }
+  if (t === "[object Date]") return new Date(Number(e));
+  if (t === "[object RegExp]") {
+    let n = e, i = new RegExp(n.source, n.flags);
+    return i.lastIndex = n.lastIndex, i;
+  }
+  if (t === "[object Symbol]") return Object(Symbol.prototype.valueOf.call(e));
+  if (t === "[object Map]") {
+    let n = e, i = /* @__PURE__ */ new Map();
+    return n.forEach((r, s) => {
+      i.set(s, r);
+    }), i;
+  }
+  if (t === "[object Set]") {
+    let n = e, i = /* @__PURE__ */ new Set();
+    return n.forEach((r) => {
+      i.add(r);
+    }), i;
+  }
+  if (t === "[object Arguments]") {
+    let n = e, i = {};
+    return xt(i, n), i.length = n.length, i[Symbol.iterator] = n[Symbol.iterator], i;
+  }
+  let a = {};
+  return ar(a, e), xt(a, e), er(a, e), a;
+}
+function tr(e) {
+  switch (jt(e)) {
+    case Ke:
+    case He:
+    case je:
+    case Fe:
+    case Xe:
+    case We:
+    case Ye:
+    case Pe:
+    case Me:
+    case Ae:
+    case ze:
+    case Re:
+    case Ce:
+    case Be:
+    case Oe:
+    case Ie:
+    case Te:
+    case Ne:
+    case ve:
+    case De:
+    case $e:
+    case Ee:
+      return !0;
+    default:
+      return !1;
+  }
+}
+function xt(e, t) {
+  for (let a in t) Object.hasOwn(t, a) && (e[a] = t[a]);
+}
+function er(e, t) {
+  let a = Object.getOwnPropertySymbols(t);
+  for (let n = 0; n < a.length; n++) {
+    let i = a[n];
+    Object.prototype.propertyIsEnumerable.call(t, i) && (e[i] = t[i]);
+  }
+}
+function rr(e, t) {
+  let a = t.valueOf().length;
+  for (let n in t) Object.hasOwn(t, n) && (Number.isNaN(Number(n)) || Number(n) >= a) && (e[n] = t[n]);
+}
+function ar(e, t) {
+  let a = Object.getPrototypeOf(t);
+  a !== null && typeof t.constructor == "function" && Object.setPrototypeOf(e, a);
+}
+var ft = (function() {
+  var e = /* @__PURE__ */ g(function(d, x, _, f) {
+    for (_ ||= {}, f = d.length; f--; _[d[f]] = x) ;
+    return _;
+  }, "o"), t = [1, 15], a = [1, 7], n = [1, 13], i = [1, 14], r = [1, 19], s = [1, 16], l = [1, 17], o = [1, 18], p = [8, 30], c = [
+    8,
+    10,
+    21,
+    28,
+    29,
+    30,
+    31,
+    39,
+    43,
+    46
+  ], u = [1, 23], m = [1, 24], b = [
+    8,
+    10,
+    15,
+    16,
+    21,
+    28,
+    29,
+    30,
+    31,
+    39,
+    43,
+    46
+  ], w = [
+    8,
+    10,
+    15,
+    16,
+    21,
+    27,
+    28,
+    29,
+    30,
+    31,
+    39,
+    43,
+    46
+  ], k = [1, 49], L = {
+    trace: /* @__PURE__ */ g(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__ */ g(function(d, x, _, f, E, h, R) {
+      var y = h.length - 1;
+      switch (E) {
+        case 4:
+          f.getLogger().debug("Rule: separator (NL) ");
+          break;
+        case 5:
+          f.getLogger().debug("Rule: separator (Space) ");
+          break;
+        case 6:
+          f.getLogger().debug("Rule: separator (EOF) ");
+          break;
+        case 7:
+          f.getLogger().debug("Rule: hierarchy: ", h[y - 1]), f.setHierarchy(h[y - 1]);
+          break;
+        case 8:
+          f.getLogger().debug("Stop NL ");
+          break;
+        case 9:
+          f.getLogger().debug("Stop EOF ");
+          break;
+        case 10:
+          f.getLogger().debug("Stop NL2 ");
+          break;
+        case 11:
+          f.getLogger().debug("Stop EOF2 ");
+          break;
+        case 12:
+          f.getLogger().debug("Rule: statement: ", h[y]), typeof h[y].length == "number" ? this.$ = h[y] : this.$ = [h[y]];
+          break;
+        case 13:
+          f.getLogger().debug("Rule: statement #2: ", h[y - 1]), this.$ = [h[y - 1]].concat(h[y]);
+          break;
+        case 14:
+          f.getLogger().debug("Rule: link: ", h[y], d), this.$ = {
+            edgeTypeStr: h[y],
+            label: ""
+          };
+          break;
+        case 15:
+          f.getLogger().debug("Rule: LABEL link: ", h[y - 3], h[y - 1], h[y]), this.$ = {
+            edgeTypeStr: h[y],
+            label: h[y - 1]
+          };
+          break;
+        case 18:
+          let j = parseInt(h[y]), H = f.generateId();
+          this.$ = {
+            id: H,
+            type: "space",
+            label: "",
+            width: j,
+            children: []
+          };
+          break;
+        case 23:
+          f.getLogger().debug("Rule: (nodeStatement link node) ", h[y - 2], h[y - 1], h[y], " typestr: ", h[y - 1].edgeTypeStr);
+          let ct = f.edgeStrToEdgeData(h[y - 1].edgeTypeStr), dt = f.edgeStrToEdgeStartData(h[y - 1].edgeTypeStr), et = f.edgeStrToThickness(h[y - 1].edgeTypeStr), ht = f.edgeStrToPattern(h[y - 1].edgeTypeStr);
+          this.$ = [
+            {
+              id: h[y - 2].id,
+              label: h[y - 2].label,
+              type: h[y - 2].type,
+              directions: h[y - 2].directions
+            },
+            {
+              id: h[y - 2].id + "-" + h[y].id,
+              start: h[y - 2].id,
+              end: h[y].id,
+              label: h[y - 1].label,
+              type: "edge",
+              thickness: et,
+              pattern: ht,
+              directions: h[y].directions,
+              arrowTypeEnd: ct,
+              arrowTypeStart: dt
+            },
+            {
+              id: h[y].id,
+              label: h[y].label,
+              type: f.typeStr2Type(h[y].typeStr),
+              directions: h[y].directions
+            }
+          ];
+          break;
+        case 24:
+          f.getLogger().debug("Rule: nodeStatement (abc88 node size) ", h[y - 1], h[y]), this.$ = {
+            id: h[y - 1].id,
+            label: h[y - 1].label,
+            type: f.typeStr2Type(h[y - 1].typeStr),
+            directions: h[y - 1].directions,
+            widthInColumns: parseInt(h[y], 10)
+          };
+          break;
+        case 25:
+          f.getLogger().debug("Rule: nodeStatement (node) ", h[y]), this.$ = {
+            id: h[y].id,
+            label: h[y].label,
+            type: f.typeStr2Type(h[y].typeStr),
+            directions: h[y].directions,
+            widthInColumns: 1
+          };
+          break;
+        case 26:
+          f.getLogger().debug("APA123", this ? this : "na"), f.getLogger().debug("COLUMNS: ", h[y]), this.$ = {
+            type: "column-setting",
+            columns: h[y] === "auto" ? -1 : parseInt(h[y])
+          };
+          break;
+        case 27:
+          f.getLogger().debug("Rule: id-block statement : ", h[y - 2], h[y - 1]), f.generateId(), this.$ = {
+            ...h[y - 2],
+            type: "composite",
+            children: h[y - 1]
+          };
+          break;
+        case 28:
+          f.getLogger().debug("Rule: blockStatement : ", h[y - 2], h[y - 1], h[y]);
+          let I = f.generateId();
+          this.$ = {
+            id: I,
+            type: "composite",
+            label: "",
+            children: h[y - 1]
+          };
+          break;
+        case 29:
+          f.getLogger().debug("Rule: node (NODE_ID separator): ", h[y]), this.$ = { id: h[y] };
+          break;
+        case 30:
+          f.getLogger().debug("Rule: node (NODE_ID nodeShapeNLabel separator): ", h[y - 1], h[y]), this.$ = {
+            id: h[y - 1],
+            label: h[y].label,
+            typeStr: h[y].typeStr,
+            directions: h[y].directions
+          };
+          break;
+        case 31:
+          f.getLogger().debug("Rule: dirList: ", h[y]), this.$ = [h[y]];
+          break;
+        case 32:
+          f.getLogger().debug("Rule: dirList: ", h[y - 1], h[y]), this.$ = [h[y - 1]].concat(h[y]);
+          break;
+        case 33:
+          f.getLogger().debug("Rule: nodeShapeNLabel: ", h[y - 2], h[y - 1], h[y]), this.$ = {
+            typeStr: h[y - 2] + h[y],
+            label: h[y - 1]
+          };
+          break;
+        case 34:
+          f.getLogger().debug("Rule: BLOCK_ARROW nodeShapeNLabel: ", h[y - 3], h[y - 2], " #3:", h[y - 1], h[y]), this.$ = {
+            typeStr: h[y - 3] + h[y],
+            label: h[y - 2],
+            directions: h[y - 1]
+          };
+          break;
+        case 35:
+        case 36:
+          this.$ = {
+            type: "classDef",
+            id: h[y - 1].trim(),
+            css: h[y].trim()
+          };
+          break;
+        case 37:
+          this.$ = {
+            type: "applyClass",
+            id: h[y - 1].trim(),
+            styleClass: h[y].trim()
+          };
+          break;
+        case 38:
+          this.$ = {
+            type: "applyStyles",
+            id: h[y - 1].trim(),
+            stylesStr: h[y].trim()
+          };
+          break;
+      }
+    }, "anonymous"),
+    table: [
+      {
+        9: 1,
+        10: [1, 2]
+      },
+      { 1: [3] },
+      {
+        10: t,
+        11: 3,
+        13: 4,
+        19: 5,
+        20: 6,
+        21: a,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        28: n,
+        29: i,
+        31: r,
+        39: s,
+        43: l,
+        46: o
+      },
+      { 8: [1, 20] },
+      e(p, [2, 12], {
+        13: 4,
+        19: 5,
+        20: 6,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        11: 21,
+        10: t,
+        21: a,
+        28: n,
+        29: i,
+        31: r,
+        39: s,
+        43: l,
+        46: o
+      }),
+      e(c, [2, 16], {
+        14: 22,
+        15: u,
+        16: m
+      }),
+      e(c, [2, 17]),
+      e(c, [2, 18]),
+      e(c, [2, 19]),
+      e(c, [2, 20]),
+      e(c, [2, 21]),
+      e(c, [2, 22]),
+      e(b, [2, 25], { 27: [1, 25] }),
+      e(c, [2, 26]),
+      {
+        19: 26,
+        26: 12,
+        31: r
+      },
+      {
+        10: t,
+        11: 27,
+        13: 4,
+        19: 5,
+        20: 6,
+        21: a,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        28: n,
+        29: i,
+        31: r,
+        39: s,
+        43: l,
+        46: o
+      },
+      {
+        40: [1, 28],
+        42: [1, 29]
+      },
+      { 44: [1, 30] },
+      { 47: [1, 31] },
+      e(w, [2, 29], {
+        32: 32,
+        35: [1, 33],
+        37: [1, 34]
+      }),
+      { 1: [2, 7] },
+      e(p, [2, 13]),
+      {
+        26: 35,
+        31: r
+      },
+      { 31: [2, 14] },
+      { 17: [1, 36] },
+      e(b, [2, 24]),
+      {
+        10: t,
+        11: 37,
+        13: 4,
+        14: 22,
+        15: u,
+        16: m,
+        19: 5,
+        20: 6,
+        21: a,
+        22: 8,
+        23: 9,
+        24: 10,
+        25: 11,
+        26: 12,
+        28: n,
+        29: i,
+        31: r,
+        39: s,
+        43: l,
+        46: o
+      },
+      { 30: [1, 38] },
+      { 41: [1, 39] },
+      { 41: [1, 40] },
+      { 45: [1, 41] },
+      { 48: [1, 42] },
+      e(w, [2, 30]),
+      { 18: [1, 43] },
+      { 18: [1, 44] },
+      e(b, [2, 23]),
+      { 18: [1, 45] },
+      { 30: [1, 46] },
+      e(c, [2, 28]),
+      e(c, [2, 35]),
+      e(c, [2, 36]),
+      e(c, [2, 37]),
+      e(c, [2, 38]),
+      { 36: [1, 47] },
+      {
+        33: 48,
+        34: k
+      },
+      { 15: [1, 50] },
+      e(c, [2, 27]),
+      e(w, [2, 33]),
+      { 38: [1, 51] },
+      {
+        33: 52,
+        34: k,
+        38: [2, 31]
+      },
+      { 31: [2, 15] },
+      e(w, [2, 34]),
+      { 38: [2, 32] }
+    ],
+    defaultActions: {
+      20: [2, 7],
+      23: [2, 14],
+      50: [2, 15],
+      52: [2, 32]
+    },
+    parseError: /* @__PURE__ */ g(function(d, x) {
+      if (x.recoverable) this.trace(d);
+      else {
+        var _ = Error(d);
+        throw _.hash = x, _;
+      }
+    }, "parseError"),
+    parse: /* @__PURE__ */ g(function(d) {
+      var x = this, _ = [0], f = [], E = [null], h = [], R = this.table, y = "", j = 0, H = 0, ct = 0, dt = 2, et = 1, ht = h.slice.call(arguments, 1), I = Object.create(this.lexer), U = { yy: {} };
+      for (var gt in this.yy) Object.prototype.hasOwnProperty.call(this.yy, gt) && (U.yy[gt] = this.yy[gt]);
+      I.setInput(d, U.yy), U.yy.lexer = I, U.yy.parser = this, I.yylloc === void 0 && (I.yylloc = {});
+      var ut = I.yylloc;
+      h.push(ut);
+      var ge = I.options && I.options.ranges;
+      typeof U.yy.parseError == "function" ? this.parseError = U.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+      function ue(Y) {
+        _.length -= 2 * Y, E.length -= Y, h.length -= Y;
+      }
+      g(ue, "popStack");
+      function Tt() {
+        var Y = f.pop() || I.lex() || et;
+        return typeof Y != "number" && (Y instanceof Array && (f = Y, Y = f.pop()), Y = x.symbols_[Y] || Y), Y;
+      }
+      g(Tt, "lex");
+      for (var A, yt, q, P, pt, Z = {}, rt, K, It, at; ; ) {
+        if (q = _[_.length - 1], this.defaultActions[q] ? P = this.defaultActions[q] : (A ??= Tt(), P = R[q] && R[q][A]), P === void 0 || !P.length || !P[0]) {
+          var Ot = "";
+          for (rt in at = [], R[q]) this.terminals_[rt] && rt > dt && at.push("'" + this.terminals_[rt] + "'");
+          Ot = I.showPosition ? "Parse error on line " + (j + 1) + `:
+` + I.showPosition() + `
+Expecting ` + at.join(", ") + ", got '" + (this.terminals_[A] || A) + "'" : "Parse error on line " + (j + 1) + ": Unexpected " + (A == et ? "end of input" : "'" + (this.terminals_[A] || A) + "'"), this.parseError(Ot, {
+            text: I.match,
+            token: this.terminals_[A] || A,
+            line: I.yylineno,
+            loc: ut,
+            expected: at
+          });
+        }
+        if (P[0] instanceof Array && P.length > 1) throw Error("Parse Error: multiple actions possible at state: " + q + ", token: " + A);
+        switch (P[0]) {
+          case 1:
+            _.push(A), E.push(I.yytext), h.push(I.yylloc), _.push(P[1]), A = null, yt ? (A = yt, yt = null) : (H = I.yyleng, y = I.yytext, j = I.yylineno, ut = I.yylloc, ct > 0);
+            break;
+          case 2:
+            if (K = this.productions_[P[1]][1], Z.$ = E[E.length - K], Z._$ = {
+              first_line: h[h.length - (K || 1)].first_line,
+              last_line: h[h.length - 1].last_line,
+              first_column: h[h.length - (K || 1)].first_column,
+              last_column: h[h.length - 1].last_column
+            }, ge && (Z._$.range = [h[h.length - (K || 1)].range[0], h[h.length - 1].range[1]]), pt = this.performAction.apply(Z, [
+              y,
+              H,
+              j,
+              U.yy,
+              P[1],
+              E,
+              h
+            ].concat(ht)), pt !== void 0) return pt;
+            K && (_ = _.slice(0, -1 * K * 2), E = E.slice(0, -1 * K), h = h.slice(0, -1 * K)), _.push(this.productions_[P[1]][0]), E.push(Z.$), h.push(Z._$), It = R[_[_.length - 2]][_[_.length - 1]], _.push(It);
+            break;
+          case 3:
+            return !0;
+        }
+      }
+      return !0;
+    }, "parse")
+  };
+  L.lexer = /* @__PURE__ */ (function() {
+    return {
+      EOF: 1,
+      parseError: /* @__PURE__ */ g(function(d, x) {
+        if (this.yy.parser) this.yy.parser.parseError(d, x);
+        else throw Error(d);
+      }, "parseError"),
+      setInput: /* @__PURE__ */ g(function(d, x) {
+        return this.yy = x || this.yy || {}, this._input = d, 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__ */ g(function() {
+        var d = this._input[0];
+        return this.yytext += d, this.yyleng++, this.offset++, this.match += d, this.matched += d, d.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), d;
+      }, "input"),
+      unput: /* @__PURE__ */ g(function(d) {
+        var x = d.length, _ = d.split(/(?:\r\n?|\n)/g);
+        this._input = d + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - x), this.offset -= x;
+        var f = 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), _.length - 1 && (this.yylineno -= _.length - 1);
+        var E = 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: _ ? (_.length === f.length ? this.yylloc.first_column : 0) + f[f.length - _.length].length - _[0].length : this.yylloc.first_column - x
+        }, this.options.ranges && (this.yylloc.range = [E[0], E[0] + this.yyleng - x]), this.yyleng = this.yytext.length, this;
+      }, "unput"),
+      more: /* @__PURE__ */ g(function() {
+        return this._more = !0, this;
+      }, "more"),
+      reject: /* @__PURE__ */ g(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__ */ g(function(d) {
+        this.unput(this.match.slice(d));
+      }, "less"),
+      pastInput: /* @__PURE__ */ g(function() {
+        var d = this.matched.substr(0, this.matched.length - this.match.length);
+        return (d.length > 20 ? "..." : "") + d.substr(-20).replace(/\n/g, "");
+      }, "pastInput"),
+      upcomingInput: /* @__PURE__ */ g(function() {
+        var d = this.match;
+        return d.length < 20 && (d += this._input.substr(0, 20 - d.length)), (d.substr(0, 20) + (d.length > 20 ? "..." : "")).replace(/\n/g, "");
+      }, "upcomingInput"),
+      showPosition: /* @__PURE__ */ g(function() {
+        var d = this.pastInput(), x = Array(d.length + 1).join("-");
+        return d + this.upcomingInput() + `
+` + x + "^";
+      }, "showPosition"),
+      test_match: /* @__PURE__ */ g(function(d, x) {
+        var _, f, E;
+        if (this.options.backtrack_lexer && (E = {
+          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 && (E.yylloc.range = this.yylloc.range.slice(0))), f = d[0].match(/(?:\r\n?|\n).*/g), f && (this.yylineno += f.length), this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: f ? f[f.length - 1].length - f[f.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + d[0].length
+        }, this.yytext += d[0], this.match += d[0], this.matches = d, 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(d[0].length), this.matched += d[0], _ = this.performAction.call(this, this.yy, this, x, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), _) return _;
+        if (this._backtrack) {
+          for (var h in E) this[h] = E[h];
+          return !1;
+        }
+        return !1;
+      }, "test_match"),
+      next: /* @__PURE__ */ g(function() {
+        if (this.done) return this.EOF;
+        this._input || (this.done = !0);
+        var d, x, _, f;
+        this._more || (this.yytext = "", this.match = "");
+        for (var E = this._currentRules(), h = 0; h < E.length; h++) if (_ = this._input.match(this.rules[E[h]]), _ && (!x || _[0].length > x[0].length)) {
+          if (x = _, f = h, this.options.backtrack_lexer) {
+            if (d = this.test_match(_, E[h]), d !== !1) return d;
+            if (this._backtrack) {
+              x = !1;
+              continue;
+            } else return !1;
+          } else if (!this.options.flex) break;
+        }
+        return x ? (d = this.test_match(x, E[f]), d === !1 ? !1 : d) : 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__ */ g(function() {
+        return this.next() || this.lex();
+      }, "lex"),
+      begin: /* @__PURE__ */ g(function(d) {
+        this.conditionStack.push(d);
+      }, "begin"),
+      popState: /* @__PURE__ */ g(function() {
+        return this.conditionStack.length - 1 > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+      }, "popState"),
+      _currentRules: /* @__PURE__ */ g(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__ */ g(function(d) {
+        return d = this.conditionStack.length - 1 - Math.abs(d || 0), d >= 0 ? this.conditionStack[d] : "INITIAL";
+      }, "topState"),
+      pushState: /* @__PURE__ */ g(function(d) {
+        this.begin(d);
+      }, "pushState"),
+      stateStackSize: /* @__PURE__ */ g(function() {
+        return this.conditionStack.length;
+      }, "stateStackSize"),
+      options: {},
+      performAction: /* @__PURE__ */ g(function(d, x, _, f) {
+        switch (_) {
+          case 0:
+            return d.getLogger().debug("Found block-beta"), 10;
+          case 1:
+            return d.getLogger().debug("Found id-block"), 29;
+          case 2:
+            return d.getLogger().debug("Found block"), 10;
+          case 3:
+            d.getLogger().debug(".", x.yytext);
+            break;
+          case 4:
+            d.getLogger().debug("_", x.yytext);
+            break;
+          case 5:
+            return 5;
+          case 6:
+            return x.yytext = -1, 28;
+          case 7:
+            return x.yytext = x.yytext.replace(/columns\s+/, ""), d.getLogger().debug("COLUMNS (LEX)", x.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:
+            d.getLogger().debug("LEX: POPPING STR:", x.yytext), this.popState();
+            break;
+          case 13:
+            return d.getLogger().debug("LEX: STR end:", x.yytext), "STR";
+          case 14:
+            return x.yytext = x.yytext.replace(/space\:/, ""), d.getLogger().debug("SPACE NUM (LEX)", x.yytext), 21;
+          case 15:
+            return x.yytext = "1", d.getLogger().debug("COLUMNS (LEX)", x.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(), d.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 38:
+            return this.popState(), d.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 39:
+            return this.popState(), d.getLogger().debug("Lex: ))"), "NODE_DEND";
+          case 40:
+            return this.popState(), d.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 41:
+            return this.popState(), d.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 42:
+            return this.popState(), d.getLogger().debug("Lex: (-"), "NODE_DEND";
+          case 43:
+            return this.popState(), d.getLogger().debug("Lex: -)"), "NODE_DEND";
+          case 44:
+            return this.popState(), d.getLogger().debug("Lex: (("), "NODE_DEND";
+          case 45:
+            return this.popState(), d.getLogger().debug("Lex: ]]"), "NODE_DEND";
+          case 46:
+            return this.popState(), d.getLogger().debug("Lex: ("), "NODE_DEND";
+          case 47:
+            return this.popState(), d.getLogger().debug("Lex: ])"), "NODE_DEND";
+          case 48:
+            return this.popState(), d.getLogger().debug("Lex: /]"), "NODE_DEND";
+          case 49:
+            return this.popState(), d.getLogger().debug("Lex: /]"), "NODE_DEND";
+          case 50:
+            return this.popState(), d.getLogger().debug("Lex: )]"), "NODE_DEND";
+          case 51:
+            return this.popState(), d.getLogger().debug("Lex: )"), "NODE_DEND";
+          case 52:
+            return this.popState(), d.getLogger().debug("Lex: ]>"), "NODE_DEND";
+          case 53:
+            return this.popState(), d.getLogger().debug("Lex: ]"), "NODE_DEND";
+          case 54:
+            return d.getLogger().debug("Lexa: -)"), this.pushState("NODE"), 35;
+          case 55:
+            return d.getLogger().debug("Lexa: (-"), this.pushState("NODE"), 35;
+          case 56:
+            return d.getLogger().debug("Lexa: ))"), this.pushState("NODE"), 35;
+          case 57:
+            return d.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 58:
+            return d.getLogger().debug("Lex: ((("), this.pushState("NODE"), 35;
+          case 59:
+            return d.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 60:
+            return d.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 61:
+            return d.getLogger().debug("Lexa: )"), this.pushState("NODE"), 35;
+          case 62:
+            return d.getLogger().debug("Lexc: >"), this.pushState("NODE"), 35;
+          case 63:
+            return d.getLogger().debug("Lexa: (["), this.pushState("NODE"), 35;
+          case 64:
+            return d.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 d.getLogger().debug("Lexa: ["), this.pushState("NODE"), 35;
+          case 73:
+            return this.pushState("BLOCK_ARROW"), d.getLogger().debug("LEX ARR START"), 37;
+          case 74:
+            return d.getLogger().debug("Lex: NODE_ID", x.yytext), 31;
+          case 75:
+            return d.getLogger().debug("Lex: EOF", x.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:
+            d.getLogger().debug("Lex: Starting string"), this.pushState("string");
+            break;
+          case 81:
+            d.getLogger().debug("LEX ARR: Starting string"), this.pushState("string");
+            break;
+          case 82:
+            return d.getLogger().debug("LEX: NODE_DESCR:", x.yytext), "NODE_DESCR";
+          case 83:
+            d.getLogger().debug("LEX POPPING"), this.popState();
+            break;
+          case 84:
+            d.getLogger().debug("Lex: =>BAE"), this.pushState("ARROW_DIR");
+            break;
+          case 85:
+            return x.yytext = x.yytext.replace(/^,\s*/, ""), d.getLogger().debug("Lex (right): dir:", x.yytext), "DIR";
+          case 86:
+            return x.yytext = x.yytext.replace(/^,\s*/, ""), d.getLogger().debug("Lex (left):", x.yytext), "DIR";
+          case 87:
+            return x.yytext = x.yytext.replace(/^,\s*/, ""), d.getLogger().debug("Lex (x):", x.yytext), "DIR";
+          case 88:
+            return x.yytext = x.yytext.replace(/^,\s*/, ""), d.getLogger().debug("Lex (y):", x.yytext), "DIR";
+          case 89:
+            return x.yytext = x.yytext.replace(/^,\s*/, ""), d.getLogger().debug("Lex (up):", x.yytext), "DIR";
+          case 90:
+            return x.yytext = x.yytext.replace(/^,\s*/, ""), d.getLogger().debug("Lex (down):", x.yytext), "DIR";
+          case 91:
+            return x.yytext = "]>", d.getLogger().debug("Lex (ARROW_DIR end):", x.yytext), this.popState(), this.popState(), "BLOCK_ARROW_END";
+          case 92:
+            return d.getLogger().debug("Lex: LINK", "#" + x.yytext + "#"), 15;
+          case 93:
+            return d.getLogger().debug("Lex: LINK", x.yytext), 15;
+          case 94:
+            return d.getLogger().debug("Lex: LINK", x.yytext), 15;
+          case 95:
+            return d.getLogger().debug("Lex: LINK", x.yytext), 15;
+          case 96:
+            return d.getLogger().debug("Lex: START_LINK", x.yytext), this.pushState("LLABEL"), 16;
+          case 97:
+            return d.getLogger().debug("Lex: START_LINK", x.yytext), this.pushState("LLABEL"), 16;
+          case 98:
+            return d.getLogger().debug("Lex: START_LINK", x.yytext), this.pushState("LLABEL"), 16;
+          case 99:
+            this.pushState("md_string");
+            break;
+          case 100:
+            return d.getLogger().debug("Lex: Starting string"), this.pushState("string"), "LINK_LABEL";
+          case 101:
+            return this.popState(), d.getLogger().debug("Lex: LINK", "#" + x.yytext + "#"), 15;
+          case 102:
+            return this.popState(), d.getLogger().debug("Lex: LINK", x.yytext), 15;
+          case 103:
+            return this.popState(), d.getLogger().debug("Lex: LINK", x.yytext), 15;
+          case 104:
+            return d.getLogger().debug("Lex: COLON", x.yytext), x.yytext = x.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 $() {
+    this.yy = {};
+  }
+  return g($, "Parser"), $.prototype = L, L.Parser = $, new $();
+})();
+ft.parser = ft;
+var ir = ft, W = /* @__PURE__ */ new Map(), $t = [], mt = /* @__PURE__ */ new Map(), Rt = "color", zt = "fill", sr = "bgFill", Ht = ",", nr = O(), st = /* @__PURE__ */ new Map(), wt = "", lr = /* @__PURE__ */ g((e) => ke.sanitizeText(e, nr), "sanitizeText"), or = /* @__PURE__ */ g(function(e, t = "") {
+  let a = st.get(e);
+  a || (a = {
+    id: e,
+    styles: [],
+    textStyles: []
+  }, st.set(e, a)), t?.split(Ht).forEach((n) => {
+    let i = n.replace(/([^;]*);/, "$1").trim();
+    if (RegExp(Rt).exec(n)) {
+      let r = i.replace(zt, sr).replace(Rt, zt);
+      a.textStyles.push(r);
+    }
+    a.styles.push(i);
+  });
+}, "addStyleClass"), cr = /* @__PURE__ */ g(function(e, t = "") {
+  let a = W.get(e);
+  t != null && (a.styles = t.split(Ht));
+}, "addStyle2Node"), dr = /* @__PURE__ */ g(function(e, t) {
+  e.split(",").forEach(function(a) {
+    let n = W.get(a);
+    if (n === void 0) {
+      let i = a.trim();
+      n = {
+        id: i,
+        type: "na",
+        children: []
+      }, W.set(i, n);
+    }
+    n.classes ||= [], n.classes.push(t);
+  });
+}, "setCssClass"), Kt = /* @__PURE__ */ g((e, t) => {
+  let a = e.flat(), n = [], i = a.find((r) => r?.type === "column-setting")?.columns ?? -1;
+  for (let r of a) {
+    if (typeof i == "number" && i > 0 && r.type !== "column-setting" && typeof r.widthInColumns == "number" && r.widthInColumns > i && S.warn(`Block ${r.id} width ${r.widthInColumns} exceeds configured column width ${i}`), r.label &&= lr(r.label), r.type === "classDef") {
+      or(r.id, r.css);
+      continue;
+    }
+    if (r.type === "applyClass") {
+      dr(r.id, r?.styleClass ?? "");
+      continue;
+    }
+    if (r.type === "applyStyles") {
+      r?.stylesStr && cr(r.id, r?.stylesStr);
+      continue;
+    }
+    if (r.type === "column-setting") t.columns = r.columns ?? -1;
+    else if (r.type === "edge") {
+      let s = (mt.get(r.id) ?? 0) + 1;
+      mt.set(r.id, s), r.id = s + "-" + r.id, $t.push(r);
+    } else {
+      r.label || (r.type === "composite" ? r.label = "" : r.label = r.id);
+      let s = W.get(r.id);
+      if (s === void 0 ? W.set(r.id, r) : (r.type !== "na" && (s.type = r.type), r.label !== r.id && (s.label = r.label)), r.children && Kt(r.children, r), r.type === "space") {
+        let l = r.width ?? 1;
+        for (let o = 0; o < l; o++) {
+          let p = Qe(r);
+          p.id = p.id + "-" + o, W.set(p.id, p), n.push(p);
+        }
+      } else s === void 0 && n.push(r);
+    }
+  }
+  t.children = n;
+}, "populateBlockDatabase"), St = [], Q = {
+  id: "root",
+  type: "composite",
+  children: [],
+  columns: -1
+}, hr = /* @__PURE__ */ g(() => {
+  S.debug("Clear called"), pe(), Q = {
+    id: "root",
+    type: "composite",
+    children: [],
+    columns: -1
+  }, W = /* @__PURE__ */ new Map([["root", Q]]), St = [], st = /* @__PURE__ */ new Map(), $t = [], mt = /* @__PURE__ */ new Map(), wt = "";
+}, "clear");
+function Ut(e) {
+  switch (S.debug("typeStr2Type", e), e) {
+    case "[]":
+      return "square";
+    case "()":
+      return S.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";
+  }
+}
+g(Ut, "typeStr2Type");
+function qt(e) {
+  return (S.debug("typeStr2Type", e), e) === "==" ? "thick" : "normal";
+}
+g(qt, "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 "";
+  }
+}
+g(Zt, "edgeStrToEdgeData");
+function Gt(e) {
+  switch (e.trim().charAt(0)) {
+    case "x":
+      return "arrow_cross";
+    case "o":
+      return "arrow_circle";
+    case "<":
+      return "arrow_point";
+    default:
+      return "arrow_open";
+  }
+}
+g(Gt, "edgeStrToEdgeStartData");
+function Jt(e) {
+  return e.includes("==") ? "thick" : "normal";
+}
+g(Jt, "edgeStrToThickness");
+function Vt(e) {
+  return e.includes(".-") ? "dotted" : "solid";
+}
+g(Vt, "edgeStrToPattern");
+var At = 0, gr = {
+  getConfig: /* @__PURE__ */ g(() => tt().block, "getConfig"),
+  typeStr2Type: Ut,
+  edgeTypeStr2Type: qt,
+  edgeStrToEdgeData: Zt,
+  edgeStrToEdgeStartData: Gt,
+  edgeStrToThickness: Jt,
+  edgeStrToPattern: Vt,
+  getLogger: /* @__PURE__ */ g(() => S, "getLogger"),
+  getBlocksFlat: /* @__PURE__ */ g(() => [...W.values()], "getBlocksFlat"),
+  getBlocks: /* @__PURE__ */ g(() => St || [], "getBlocks"),
+  getEdges: /* @__PURE__ */ g(() => $t, "getEdges"),
+  setHierarchy: /* @__PURE__ */ g((e) => {
+    Q.children = e, Kt(e, Q), St = Q.children;
+  }, "setHierarchy"),
+  getBlock: /* @__PURE__ */ g((e) => W.get(e), "getBlock"),
+  setBlock: /* @__PURE__ */ g((e) => {
+    W.set(e.id, e);
+  }, "setBlock"),
+  getColumns: /* @__PURE__ */ g((e) => {
+    let t = W.get(e);
+    return t ? t.columns ? t.columns : t.children ? t.children.length : -1 : -1;
+  }, "getColumns"),
+  getClasses: /* @__PURE__ */ g(function() {
+    return st;
+  }, "getClasses"),
+  clear: hr,
+  generateId: /* @__PURE__ */ g(() => (At++, "id-" + Math.random().toString(36).substr(2, 12) + "-" + At), "generateId"),
+  setDiagramId: /* @__PURE__ */ g((e) => {
+    wt = e;
+  }, "setDiagramId"),
+  getDiagramId: /* @__PURE__ */ g(() => wt, "getDiagramId")
+}, bt = /* @__PURE__ */ g((e, t) => {
+  let a = Ze;
+  return xe(a(e, "r"), a(e, "g"), a(e, "b"), t);
+}, "fade"), ur = /* @__PURE__ */ g((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};
+  }
+  ${Ge()}
+`, "getStyles"), yr = /* @__PURE__ */ g((e, t, a, n) => {
+  t.forEach((i) => {
+    pr[i](e, a, n);
+  });
+}, "insertMarkers"), pr = {
+  extension: /* @__PURE__ */ g((e, t, a) => {
+    S.trace("Making markers for ", a), e.append("defs").append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("defs").append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("defs").append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("defs").append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("defs").append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("marker").attr("id", a + "_" + 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", a + "_" + 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__ */ g((e, t, a) => {
+    e.append("defs").append("marker").attr("id", a + "_" + 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")
+}, xr = yr, T = O()?.block?.padding ?? 8;
+function kt(e, t) {
+  if (e === 0 || !Number.isInteger(e)) throw Error("Columns must be an integer !== 0.");
+  if (t < 0 || !Number.isInteger(t)) throw 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)
+  };
+}
+g(kt, "calculateBlockPosition");
+var br = /* @__PURE__ */ g((e) => {
+  let t = 0, a = 0;
+  for (let n of e.children) {
+    let { width: i, height: r, x: s, y: l } = n.size ?? {
+      width: 0,
+      height: 0,
+      x: 0,
+      y: 0
+    };
+    if (S.debug("getMaxChildSize abc95 child:", n.id, "width:", i, "height:", r, "x:", s, "y:", l, n.type), n.type === "space") continue;
+    let o = i / (n.widthInColumns ?? 1);
+    o > t && (t = o), r > a && (a = r);
+  }
+  return {
+    width: t,
+    height: a
+  };
+}, "getMaxChildSize");
+function nt(e, t, a = 0, n = 0) {
+  S.debug("setBlockSizes abc95 (start)", e.id, e?.size?.x, "block width =", e?.size, "siblingWidth", a), e?.size?.width || (e.size = {
+    width: a,
+    height: n,
+    x: 0,
+    y: 0
+  });
+  let i = 0, r = 0;
+  if (e.children?.length > 0) {
+    for (let b of e.children) nt(b, t);
+    let s = br(e);
+    i = s.width, r = s.height, S.debug("setBlockSizes abc95 maxWidth of", e.id, ":s children is ", i, r);
+    for (let b of e.children) b.size && (S.debug(`abc95 Setting size of children of ${e.id} id=${b.id} ${i} ${r} ${JSON.stringify(b.size)}`), b.size.width = i * (b.widthInColumns ?? 1) + T * ((b.widthInColumns ?? 1) - 1), b.size.height = r, b.size.x = 0, b.size.y = 0, S.debug(`abc95 updating size of ${e.id} children child:${b.id} maxWidth:${i} maxHeight:${r}`));
+    for (let b of e.children) nt(b, t, i, r);
+    let l = e.columns ?? -1, o = 0;
+    for (let b of e.children) o += b.widthInColumns ?? 1;
+    let p = e.children.length;
+    l > 0 && l < o && (p = l);
+    let c = Math.ceil(o / p), u = p * (i + T) + T, m = c * (r + T) + T;
+    if (u < a) {
+      S.debug(`Detected to small sibling: abc95 ${e.id} siblingWidth ${a} siblingHeight ${n} width ${u}`), u = a, m = n;
+      let b = (a - p * T - T) / p, w = (n - c * T - T) / c;
+      S.debug("Size indata abc88", e.id, "childWidth", b, "maxWidth", i), S.debug("Size indata abc88", e.id, "childHeight", w, "maxHeight", r), S.debug("Size indata abc88 xSize", p, "padding", T);
+      for (let k of e.children) k.size && (k.size.width = b, k.size.height = w, k.size.x = 0, k.size.y = 0);
+    }
+    if (S.debug(`abc95 (finale calc) ${e.id} xSize ${p} ySize ${c} columns ${l}${e.children.length} width=${Math.max(u, e.size?.width || 0)}`), u < (e?.size?.width || 0)) {
+      u = e?.size?.width || 0;
+      let b = l > 0 ? Math.min(e.children.length, l) : e.children.length;
+      if (b > 0) {
+        let w = (u - b * T - T) / b;
+        S.debug("abc95 (growing to fit) width", e.id, u, e.size?.width, w);
+        for (let k of e.children) k.size && (k.size.width = w);
+      }
+    }
+    e.size = {
+      width: u,
+      height: m,
+      x: 0,
+      y: 0
+    };
+  }
+  S.debug("setBlockSizes abc94 (done)", e.id, e?.size?.x, e?.size?.width, e?.size?.y, e?.size?.height);
+}
+g(nt, "setBlockSizes");
+function Dt(e, t) {
+  S.debug(`abc85 layout blocks (=>layoutBlocks) ${e.id} x: ${e?.size?.x} y: ${e?.size?.y} width: ${e?.size?.width}`);
+  let a = e.columns ?? -1;
+  if (S.debug("layoutBlocks columns abc95", e.id, "=>", a, e), e.children && e.children.length > 0) {
+    let n = e?.children[0]?.size?.width ?? 0, i = e.children.length * n + (e.children.length - 1) * T;
+    S.debug("widthOfChildren 88", i, "posX");
+    let r = /* @__PURE__ */ new Map();
+    {
+      let c = 0;
+      for (let u of e.children) {
+        if (!u.size) continue;
+        let { py: m } = kt(a, c), b = r.get(m) ?? 0;
+        u.size.height > b && r.set(m, u.size.height);
+        let w = u?.widthInColumns ?? 1;
+        a > 0 && (w = Math.min(w, a - c % a)), c += w;
+      }
+    }
+    let s = /* @__PURE__ */ new Map();
+    {
+      let c = 0, u = [...r.keys()].sort((m, b) => m - b);
+      for (let m of u) s.set(m, c), c += (r.get(m) ?? 0) + T;
+    }
+    let l = 0;
+    S.debug("abc91 block?.size?.x", e.id, e?.size?.x);
+    let o = e?.size?.x ? e?.size?.x + (-e?.size?.width / 2 || 0) : -T, p = 0;
+    for (let c of e.children) {
+      let u = e;
+      if (!c.size) continue;
+      let { width: m, height: b } = c.size, { px: w, py: k } = kt(a, l);
+      if (k != p && (p = k, o = e?.size?.x ? e?.size?.x + (-e?.size?.width / 2 || 0) : -T, S.debug("New row in layout for block", e.id, " and child ", c.id, p)), S.debug(`abc89 layout blocks (child) id: ${c.id} Pos: ${l} (px, py) ${w},${k} (${u?.size?.x},${u?.size?.y}) parent: ${u.id} width: ${m}${T}`), u.size) {
+        let $ = m / 2;
+        c.size.x = o + T + $, S.debug(`abc91 layout blocks (calc) px, pyid:${c.id} startingPos=X${o} new startingPosX${c.size.x} ${$} padding=${T} width=${m} halfWidth=${$} => x:${c.size.x} y:${c.size.y} ${c.widthInColumns} (width * (child?.w || 1)) / 2 ${m * (c?.widthInColumns ?? 1) / 2}`), o = c.size.x + $;
+        let d = s.get(k) ?? 0, x = r.get(k) ?? b;
+        c.size.y = u.size.y - u.size.height / 2 + d + x / 2 + T, S.debug(`abc88 layout blocks (calc) px, pyid:${c.id}startingPosX${o}${T}${$}=>x:${c.size.x}y:${c.size.y}${c.widthInColumns}(width * (child?.w || 1)) / 2${m * (c?.widthInColumns ?? 1) / 2}`);
+      }
+      c.children && Dt(c);
+      let L = c?.widthInColumns ?? 1;
+      a > 0 && (L = Math.min(L, a - l % a)), l += L, S.debug("abc88 columnsPos", c, l);
+    }
+  }
+  S.debug(`layout blocks (<==layoutBlocks) ${e.id} x: ${e?.size?.x} y: ${e?.size?.y} width: ${e?.size?.width}`);
+}
+g(Dt, "layoutBlocks");
+function vt(e, { minX: t, minY: a, maxX: n, maxY: i } = {
+  minX: 0,
+  minY: 0,
+  maxX: 0,
+  maxY: 0
+}) {
+  if (e.size && e.id !== "root") {
+    let { x: r, y: s, width: l, height: o } = e.size;
+    r - l / 2 < t && (t = r - l / 2), s - o / 2 < a && (a = s - o / 2), r + l / 2 > n && (n = r + l / 2), s + o / 2 > i && (i = s + o / 2);
+  }
+  if (e.children) for (let r of e.children) ({ minX: t, minY: a, maxX: n, maxY: i } = vt(r, {
+    minX: t,
+    minY: a,
+    maxX: n,
+    maxY: i
+  }));
+  return {
+    minX: t,
+    minY: a,
+    maxX: n,
+    maxY: i
+  };
+}
+g(vt, "findBounds");
+function Qt(e) {
+  let t = e.getBlock("root");
+  if (!t) return;
+  nt(t, e, 0, 0), Dt(t), S.debug("getBlocks", JSON.stringify(t, null, 2));
+  let { minX: a, minY: n, maxX: i, maxY: r } = vt(t), s = r - n;
+  return {
+    x: a,
+    y: n,
+    width: i - a,
+    height: s
+  };
+}
+g(Qt, "layout");
+var X = /* @__PURE__ */ g(async (e, t, a, n = !1, i = !1) => {
+  let r = t || "";
+  typeof r == "object" && (r = r[0]);
+  let s = O(), l = z(s);
+  return await Et(e, r, {
+    style: a,
+    isTitle: n,
+    useHtmlLabels: l,
+    markdown: !1,
+    isNode: i,
+    width: 1 / 0
+  }, s);
+}, "createLabel"), fr = /* @__PURE__ */ g((e, t, a, n, i) => {
+  t.arrowTypeStart && Mt(e, "start", t.arrowTypeStart, a, n, i), t.arrowTypeEnd && Mt(e, "end", t.arrowTypeEnd, a, n, i);
+}, "addEdgeMarkers"), mr = {
+  arrow_cross: "cross",
+  arrow_point: "point",
+  arrow_barb: "barb",
+  arrow_circle: "circle",
+  aggregation: "aggregation",
+  extension: "extension",
+  composition: "composition",
+  dependency: "dependency",
+  lollipop: "lollipop"
+}, Mt = /* @__PURE__ */ g((e, t, a, n, i, r) => {
+  let s = mr[a];
+  if (!s) {
+    S.warn(`Unknown arrow type: ${a}`);
+    return;
+  }
+  let l = t === "start" ? "Start" : "End";
+  e.attr(`marker-${t}`, `url(${n}#${i}_${r}-${s}${l})`);
+}, "addEdgeMarker"), Lt = {}, C = {}, wr = /* @__PURE__ */ g(async (e, t) => {
+  let a = O(), n = z(a), i = e.insert("g").attr("class", "edgeLabel"), r = i.insert("g").attr("class", "label"), s = t.labelType === "markdown", l = await Et(e, t.label, {
+    style: t.labelStyle,
+    useHtmlLabels: n,
+    addSvgBackground: s,
+    isNode: !1,
+    markdown: s,
+    width: s ? void 0 : 1 / 0
+  }, a);
+  r.node().appendChild(l);
+  let o = l.getBBox(), p = o;
+  if (n) {
+    let u = l.children[0], m = v(l);
+    o = u.getBoundingClientRect(), p = o, m.attr("width", o.width), m.attr("height", o.height);
+  } else {
+    let u = v(l).select("text").node();
+    u && typeof u.getBBox == "function" && (p = u.getBBox());
+  }
+  r.attr("transform", G(p, n)), Lt[t.id] = i, t.width = o.width, t.height = o.height;
+  let c;
+  if (t.startLabelLeft) {
+    let u = e.insert("g").attr("class", "edgeTerminals"), m = u.insert("g").attr("class", "inner"), b = await X(m, t.startLabelLeft, t.labelStyle);
+    c = b;
+    let w = b.getBBox();
+    if (n) {
+      let k = b.children[0], L = v(b);
+      w = k.getBoundingClientRect(), L.attr("width", w.width), L.attr("height", w.height);
+    }
+    m.attr("transform", G(w, n)), C[t.id] || (C[t.id] = {}), C[t.id].startLeft = u, V(c, t.startLabelLeft);
+  }
+  if (t.startLabelRight) {
+    let u = e.insert("g").attr("class", "edgeTerminals"), m = u.insert("g").attr("class", "inner"), b = await X(m, t.startLabelRight, t.labelStyle);
+    c = b;
+    let w = b.getBBox();
+    if (n) {
+      let k = b.children[0], L = v(b);
+      w = k.getBoundingClientRect(), L.attr("width", w.width), L.attr("height", w.height);
+    }
+    m.attr("transform", G(w, n)), C[t.id] || (C[t.id] = {}), C[t.id].startRight = u, V(c, t.startLabelRight);
+  }
+  if (t.endLabelLeft) {
+    let u = e.insert("g").attr("class", "edgeTerminals"), m = u.insert("g").attr("class", "inner"), b = await X(u, t.endLabelLeft, t.labelStyle);
+    c = b;
+    let w = b.getBBox();
+    if (n) {
+      let k = b.children[0], L = v(b);
+      w = k.getBoundingClientRect(), L.attr("width", w.width), L.attr("height", w.height);
+    }
+    m.attr("transform", G(w, n)), C[t.id] || (C[t.id] = {}), C[t.id].endLeft = u, V(c, t.endLabelLeft);
+  }
+  if (t.endLabelRight) {
+    let u = e.insert("g").attr("class", "edgeTerminals"), m = u.insert("g").attr("class", "inner"), b = await X(u, t.endLabelRight, t.labelStyle);
+    c = b;
+    let w = b.getBBox();
+    if (n) {
+      let k = b.children[0], L = v(b);
+      w = k.getBoundingClientRect(), L.attr("width", w.width), L.attr("height", w.height);
+    }
+    m.attr("transform", G(w, n)), C[t.id] || (C[t.id] = {}), C[t.id].endRight = u, V(c, t.endLabelRight);
+  }
+  return l;
+}, "insertEdgeLabel");
+function V(e, t) {
+  z(O()) && e && (e.style.width = t.length * 9 + "px", e.style.height = "12px");
+}
+g(V, "setTerminalWidth");
+var Sr = /* @__PURE__ */ g((e, t) => {
+  S.debug("Moving label abc88 ", e.id, e.label, Lt[e.id], t);
+  let a = t.updatedPath ? t.updatedPath : t.originalPath, { subGraphTitleTotalMargin: n } = Se(O());
+  if (e.label) {
+    let i = Lt[e.id], r = e.x, s = e.y;
+    if (a) {
+      let l = J.calcLabelPosition(a);
+      S.debug("Moving label " + e.label + " from (", r, ",", s, ") to (", l.x, ",", l.y, ") abc88"), t.updatedPath && (r = l.x, s = l.y);
+    }
+    i.attr("transform", `translate(${r}, ${s + n / 2})`);
+  }
+  if (e.startLabelLeft) {
+    let i = C[e.id].startLeft, r = e.x, s = e.y;
+    if (a) {
+      let l = J.calcTerminalLabelPosition(e.arrowTypeStart ? 10 : 0, "start_left", a);
+      r = l.x, s = l.y;
+    }
+    i.attr("transform", `translate(${r}, ${s})`);
+  }
+  if (e.startLabelRight) {
+    let i = C[e.id].startRight, r = e.x, s = e.y;
+    if (a) {
+      let l = J.calcTerminalLabelPosition(e.arrowTypeStart ? 10 : 0, "start_right", a);
+      r = l.x, s = l.y;
+    }
+    i.attr("transform", `translate(${r}, ${s})`);
+  }
+  if (e.endLabelLeft) {
+    let i = C[e.id].endLeft, r = e.x, s = e.y;
+    if (a) {
+      let l = J.calcTerminalLabelPosition(e.arrowTypeEnd ? 10 : 0, "end_left", a);
+      r = l.x, s = l.y;
+    }
+    i.attr("transform", `translate(${r}, ${s})`);
+  }
+  if (e.endLabelRight) {
+    let i = C[e.id].endRight, r = e.x, s = e.y;
+    if (a) {
+      let l = J.calcTerminalLabelPosition(e.arrowTypeEnd ? 10 : 0, "end_right", a);
+      r = l.x, s = l.y;
+    }
+    i.attr("transform", `translate(${r}, ${s})`);
+  }
+}, "positionEdgeLabel"), kr = /* @__PURE__ */ g((e, t) => {
+  let a = e.x, n = e.y, i = Math.abs(t.x - a), r = Math.abs(t.y - n), s = e.width / 2, l = e.height / 2;
+  return i >= s || r >= l;
+}, "outsideNode"), Lr = /* @__PURE__ */ g((e, t, a) => {
+  S.debug(`intersection calc abc89:
+  outsidePoint: ${JSON.stringify(t)}
+  insidePoint : ${JSON.stringify(a)}
+  node        : x:${e.x} y:${e.y} w:${e.width} h:${e.height}`);
+  let n = e.x, i = e.y, r = Math.abs(n - a.x), s = e.width / 2, l = a.x < t.x ? s - r : s + r, o = e.height / 2, p = Math.abs(t.y - a.y), c = Math.abs(t.x - a.x);
+  if (Math.abs(i - t.y) * s > Math.abs(n - t.x) * o) {
+    let u = a.y < t.y ? t.y - o - i : i - o - t.y;
+    l = c * u / p;
+    let m = {
+      x: a.x < t.x ? a.x + l : a.x - c + l,
+      y: a.y < t.y ? a.y + p - u : a.y - p + u
+    };
+    return l === 0 && (m.x = t.x, m.y = t.y), c === 0 && (m.x = t.x), p === 0 && (m.y = t.y), S.debug(`abc89 topp/bott calc, Q ${p}, q ${u}, R ${c}, r ${l}`, m), m;
+  } else {
+    l = a.x < t.x ? t.x - s - n : n - s - t.x;
+    let u = p * l / c, m = a.x < t.x ? a.x + c - l : a.x - c + l, b = a.y < t.y ? a.y + u : a.y - u;
+    return S.debug(`sides calc abc89, Q ${p}, q ${u}, R ${c}, r ${l}`, {
+      _x: m,
+      _y: b
+    }), l === 0 && (m = t.x, b = t.y), c === 0 && (m = t.x), p === 0 && (b = t.y), {
+      x: m,
+      y: b
+    };
+  }
+}, "intersection"), Pt = /* @__PURE__ */ g((e, t) => {
+  S.debug("abc88 cutPathAtIntersect", e, t);
+  let a = [], n = e[0], i = !1;
+  return e.forEach((r) => {
+    if (!kr(t, r) && !i) {
+      let s = Lr(t, n, r), l = !1;
+      a.forEach((o) => {
+        l ||= o.x === s.x && o.y === s.y;
+      }), a.some((o) => o.x === s.x && o.y === s.y) || a.push(s), i = !0;
+    } else n = r, i || a.push(r);
+  }), a;
+}, "cutPathAtIntersect"), _r = /* @__PURE__ */ g(function(e, t, a, n, i, r, s) {
+  let l = a.points;
+  S.debug("abc88 InsertEdge: edge=", a, "e=", t);
+  let o = !1, p = r.node(t.v);
+  var c = r.node(t.w);
+  c?.intersect && p?.intersect && (l = l.slice(1, a.points.length - 1), l.unshift(p.intersect(l[0])), l.push(c.intersect(l[l.length - 1]))), a.toCluster && (S.debug("to cluster abc88", n[a.toCluster]), l = Pt(a.points, n[a.toCluster].node), o = !0), a.fromCluster && (S.debug("from cluster abc88", n[a.fromCluster]), l = Pt(l.reverse(), n[a.fromCluster].node).reverse(), o = !0);
+  let u = l.filter((_) => !Number.isNaN(_.y)), m = me;
+  a.curve && (i === "graph" || i === "flowchart") && (m = a.curve);
+  let { x: b, y: w } = be(a), k = fe().x(b).y(w).curve(m), L;
+  switch (a.thickness) {
+    case "normal":
+      L = "edge-thickness-normal";
+      break;
+    case "thick":
+      L = "edge-thickness-thick";
+      break;
+    case "invisible":
+      L = "edge-thickness-thick";
+      break;
+    default:
+      L = "";
+  }
+  switch (a.pattern) {
+    case "solid":
+      L += " edge-pattern-solid";
+      break;
+    case "dotted":
+      L += " edge-pattern-dotted";
+      break;
+    case "dashed":
+      L += " edge-pattern-dashed";
+      break;
+  }
+  let $ = e.append("path").attr("d", k(u)).attr("id", a.id).attr("class", " " + L + (a.classes ? " " + a.classes : "")).attr("style", a.style), d = "";
+  (O().flowchart.arrowMarkerAbsolute || O().state.arrowMarkerAbsolute) && (d = we(!0)), fr($, a, d, s, i);
+  let x = {};
+  return o && (x.updatedPath = l), x.originalPath = a.points, x;
+}, "insertEdge"), Er = /* @__PURE__ */ g((e) => {
+  let t = /* @__PURE__ */ new Set();
+  for (let a of e) switch (a) {
+    case "x":
+      t.add("right"), t.add("left");
+      break;
+    case "y":
+      t.add("up"), t.add("down");
+      break;
+    default:
+      t.add(a);
+      break;
+  }
+  return t;
+}, "expandAndDeduplicateDirections"), $r = /* @__PURE__ */ g((e, t, a, n) => {
+  let i = Er(e), r = t.height + 2 * a.padding, s = r / 2, l = n ?? t.width + 2 * s + a.padding, o = a.padding / 2;
+  return i.has("right") && i.has("left") && i.has("up") && i.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: s,
+      y: 0
+    },
+    {
+      x: l / 2,
+      y: 2 * o
+    },
+    {
+      x: l - s,
+      y: 0
+    },
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: l,
+      y: -r / 3
+    },
+    {
+      x: l + 2 * o,
+      y: -r / 2
+    },
+    {
+      x: l,
+      y: -2 * r / 3
+    },
+    {
+      x: l,
+      y: -r
+    },
+    {
+      x: l - s,
+      y: -r
+    },
+    {
+      x: l / 2,
+      y: -r - 2 * o
+    },
+    {
+      x: s,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -2 * r / 3
+    },
+    {
+      x: -2 * o,
+      y: -r / 2
+    },
+    {
+      x: 0,
+      y: -r / 3
+    }
+  ] : i.has("right") && i.has("left") && i.has("up") ? [
+    {
+      x: s,
+      y: 0
+    },
+    {
+      x: l - s,
+      y: 0
+    },
+    {
+      x: l,
+      y: -r / 2
+    },
+    {
+      x: l - s,
+      y: -r
+    },
+    {
+      x: s,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -r / 2
+    }
+  ] : i.has("right") && i.has("left") && i.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: s,
+      y: -r
+    },
+    {
+      x: l - s,
+      y: -r
+    },
+    {
+      x: l,
+      y: 0
+    }
+  ] : i.has("right") && i.has("up") && i.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: -s
+    },
+    {
+      x: l,
+      y: -r + s
+    },
+    {
+      x: 0,
+      y: -r
+    }
+  ] : i.has("left") && i.has("up") && i.has("down") ? [
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -s
+    },
+    {
+      x: 0,
+      y: -r + s
+    },
+    {
+      x: l,
+      y: -r
+    }
+  ] : i.has("right") && i.has("left") ? [
+    {
+      x: s,
+      y: 0
+    },
+    {
+      x: s,
+      y: -o
+    },
+    {
+      x: l - s,
+      y: -o
+    },
+    {
+      x: l - s,
+      y: 0
+    },
+    {
+      x: l,
+      y: -r / 2
+    },
+    {
+      x: l - s,
+      y: -r
+    },
+    {
+      x: l - s,
+      y: -r + o
+    },
+    {
+      x: s,
+      y: -r + o
+    },
+    {
+      x: s,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -r / 2
+    }
+  ] : i.has("up") && i.has("down") ? [
+    {
+      x: l / 2,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -o
+    },
+    {
+      x: s,
+      y: -o
+    },
+    {
+      x: s,
+      y: -r + o
+    },
+    {
+      x: 0,
+      y: -r + o
+    },
+    {
+      x: l / 2,
+      y: -r
+    },
+    {
+      x: l,
+      y: -r + o
+    },
+    {
+      x: l - s,
+      y: -r + o
+    },
+    {
+      x: l - s,
+      y: -o
+    },
+    {
+      x: l,
+      y: -o
+    }
+  ] : i.has("right") && i.has("up") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: -s
+    },
+    {
+      x: 0,
+      y: -r
+    }
+  ] : i.has("right") && i.has("down") ? [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -r
+    }
+  ] : i.has("left") && i.has("up") ? [
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -s
+    },
+    {
+      x: l,
+      y: -r
+    }
+  ] : i.has("left") && i.has("down") ? [
+    {
+      x: l,
+      y: 0
+    },
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: l,
+      y: -r
+    }
+  ] : i.has("right") ? [
+    {
+      x: s,
+      y: -o
+    },
+    {
+      x: s,
+      y: -o
+    },
+    {
+      x: l - s,
+      y: -o
+    },
+    {
+      x: l - s,
+      y: 0
+    },
+    {
+      x: l,
+      y: -r / 2
+    },
+    {
+      x: l - s,
+      y: -r
+    },
+    {
+      x: l - s,
+      y: -r + o
+    },
+    {
+      x: s,
+      y: -r + o
+    },
+    {
+      x: s,
+      y: -r + o
+    }
+  ] : i.has("left") ? [
+    {
+      x: s,
+      y: 0
+    },
+    {
+      x: s,
+      y: -o
+    },
+    {
+      x: l - s,
+      y: -o
+    },
+    {
+      x: l - s,
+      y: -r + o
+    },
+    {
+      x: s,
+      y: -r + o
+    },
+    {
+      x: s,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -r / 2
+    }
+  ] : i.has("up") ? [
+    {
+      x: s,
+      y: -o
+    },
+    {
+      x: s,
+      y: -r + o
+    },
+    {
+      x: 0,
+      y: -r + o
+    },
+    {
+      x: l / 2,
+      y: -r
+    },
+    {
+      x: l,
+      y: -r + o
+    },
+    {
+      x: l - s,
+      y: -r + o
+    },
+    {
+      x: l - s,
+      y: -o
+    }
+  ] : i.has("down") ? [
+    {
+      x: l / 2,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -o
+    },
+    {
+      x: s,
+      y: -o
+    },
+    {
+      x: s,
+      y: -r + o
+    },
+    {
+      x: l - s,
+      y: -r + o
+    },
+    {
+      x: l - s,
+      y: -o
+    },
+    {
+      x: l,
+      y: -o
+    }
+  ] : [{
+    x: 0,
+    y: 0
+  }];
+}, "getArrowPoints");
+function te(e, t) {
+  return e.intersect(t);
+}
+g(te, "intersectNode");
+var Dr = te;
+function ee(e, t, a, n) {
+  var i = e.x, r = e.y, s = i - n.x, l = r - n.y, o = Math.sqrt(t * t * l * l + a * a * s * s), p = Math.abs(t * a * s / o);
+  n.x < i && (p = -p);
+  var c = Math.abs(t * a * l / o);
+  return n.y < r && (c = -c), {
+    x: i + p,
+    y: r + c
+  };
+}
+g(ee, "intersectEllipse");
+var re = ee;
+function ae(e, t, a) {
+  return re(e, t, t, a);
+}
+g(ae, "intersectCircle");
+var vr = ae;
+function ie(e, t, a, n) {
+  var i = t.y - e.y, r, s = e.x - t.x, l, o = t.x * e.y - e.x * t.y, p, c, u, m = i * a.x + s * a.y + o, b = i * n.x + s * n.y + o, w, k, L, $, d;
+  if (!(m !== 0 && b !== 0 && _t(m, b)) && (r = n.y - a.y, l = a.x - n.x, p = n.x * a.y - a.x * n.y, c = r * e.x + l * e.y + p, u = r * t.x + l * t.y + p, !(c !== 0 && u !== 0 && _t(c, u)) && (w = i * l - r * s, w !== 0))) return k = Math.abs(w / 2), L = s * p - l * o, $ = L < 0 ? (L - k) / w : (L + k) / w, L = r * o - i * p, d = L < 0 ? (L - k) / w : (L + k) / w, {
+    x: $,
+    y: d
+  };
+}
+g(ie, "intersectLine");
+function _t(e, t) {
+  return e * t > 0;
+}
+g(_t, "sameSign");
+var Nr = ie, Tr = se;
+function se(e, t, a) {
+  var n = e.x, i = e.y, r = [], s = 1 / 0, l = 1 / 0;
+  typeof t.forEach == "function" ? t.forEach(function(w) {
+    s = Math.min(s, w.x), l = Math.min(l, w.y);
+  }) : (s = Math.min(s, t.x), l = Math.min(l, t.y));
+  for (var o = n - e.width / 2 - s, p = i - e.height / 2 - l, c = 0; c < t.length; c++) {
+    var u = t[c], m = t[c < t.length - 1 ? c + 1 : 0], b = Nr(e, a, {
+      x: o + u.x,
+      y: p + u.y
+    }, {
+      x: o + m.x,
+      y: p + m.y
+    });
+    b && r.push(b);
+  }
+  return r.length ? (r.length > 1 && r.sort(function(w, k) {
+    var L = w.x - a.x, $ = w.y - a.y, d = Math.sqrt(L * L + $ * $), x = k.x - a.x, _ = k.y - a.y, f = Math.sqrt(x * x + _ * _);
+    return d < f ? -1 : d === f ? 0 : 1;
+  }), r[0]) : e;
+}
+g(se, "intersectPolygon");
+var D = {
+  node: Dr,
+  circle: vr,
+  ellipse: re,
+  polygon: Tr,
+  rect: /* @__PURE__ */ g((e, t) => {
+    var a = e.x, n = e.y, i = t.x - a, r = t.y - n, s = e.width / 2, l = e.height / 2, o, p;
+    return Math.abs(r) * s > Math.abs(i) * l ? (r < 0 && (l = -l), o = r === 0 ? 0 : l * i / r, p = l) : (i < 0 && (s = -s), o = s, p = i === 0 ? 0 : s * r / i), {
+      x: a + o,
+      y: n + p
+    };
+  }, "intersectRect")
+}, B = /* @__PURE__ */ g(async (e, t, a, n) => {
+  let i = O(), r, s = t.useHtmlLabels || z(i);
+  r = a || "node default";
+  let l = e.insert("g").attr("class", r).attr("id", t.domId || t.id), o = l.insert("g").attr("class", "label").attr("style", t.labelStyle), p;
+  p = t.labelText === void 0 ? "" : typeof t.labelText == "string" ? t.labelText : t.labelText[0];
+  let c;
+  c = t.labelType === "markdown" ? Et(o, Bt(Ct(p), i), {
+    useHtmlLabels: s,
+    width: t.width || i.flowchart.wrappingWidth,
+    classes: "markdown-node-label"
+  }, i) : await X(o, Bt(Ct(p), i), t.labelStyle, !1, n);
+  let u = c.getBBox(), m = t.padding / 2;
+  if (z(i)) {
+    let b = c.children[0], w = v(c);
+    await qe(b, p), u = b.getBoundingClientRect(), w.attr("width", u.width), w.attr("height", u.height);
+  }
+  return s ? o.attr("transform", "translate(" + -u.width / 2 + ", " + -u.height / 2 + ")") : o.attr("transform", "translate(0, " + -u.height / 2 + ")"), t.centerLabel && o.attr("transform", "translate(" + -u.width / 2 + ", " + -u.height / 2 + ")"), o.insert("rect", ":first-child"), {
+    shapeSvg: l,
+    bbox: u,
+    halfPadding: m,
+    label: o
+  };
+}, "labelHelper"), N = /* @__PURE__ */ g((e, t) => {
+  let a = t.node().getBBox();
+  e.width = a.width, e.height = a.height;
+}, "updateNodeBounds");
+function F(e, t, a, n) {
+  return e.insert("polygon", ":first-child").attr("points", n.map(function(i) {
+    return i.x + "," + i.y;
+  }).join(" ")).attr("class", "label-container").attr("transform", "translate(" + -t / 2 + "," + a / 2 + ")");
+}
+g(F, "insertPolygonShape");
+var Ir = /* @__PURE__ */ g(async (e, t) => {
+  t.useHtmlLabels || z(O()) || (t.centerLabel = !0);
+  let { shapeSvg: a, bbox: n, halfPadding: i } = await B(e, t, "node " + t.classes, !0);
+  S.info("Classes = ", t.classes);
+  let r = a.insert("rect", ":first-child");
+  return r.attr("rx", t.rx).attr("ry", t.ry).attr("x", -n.width / 2 - i).attr("y", -n.height / 2 - i).attr("width", n.width + t.padding).attr("height", n.height + t.padding), N(t, r), t.intersect = function(s) {
+    return D.rect(t, s);
+  }, a;
+}, "note"), Yt = /* @__PURE__ */ g((e) => e ? " " + e : "", "formatClass"), M = /* @__PURE__ */ g((e, t) => `${t || "node default"}${Yt(e.classes)} ${Yt(e.class)}`, "getClassesFromNode"), Wt = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding + (n.height + t.padding), r = [
+    {
+      x: i / 2,
+      y: 0
+    },
+    {
+      x: i,
+      y: -i / 2
+    },
+    {
+      x: i / 2,
+      y: -i
+    },
+    {
+      x: 0,
+      y: -i / 2
+    }
+  ];
+  S.info("Question main (Circle)");
+  let s = F(a, i, i, r);
+  return s.attr("style", t.style), N(t, s), t.intersect = function(l) {
+    return S.warn("Intersect called"), D.polygon(t, r, l);
+  }, a;
+}, "question"), Or = /* @__PURE__ */ g((e, t) => {
+  let a = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id);
+  return a.insert("polygon", ":first-child").attr("points", [
+    {
+      x: 0,
+      y: 28 / 2
+    },
+    {
+      x: 28 / 2,
+      y: 0
+    },
+    {
+      x: 0,
+      y: -28 / 2
+    },
+    {
+      x: -28 / 2,
+      y: 0
+    }
+  ].map(function(n) {
+    return n.x + "," + n.y;
+  }).join(" ")).attr("class", "state-start").attr("r", 7).attr("width", 28).attr("height", 28), t.width = 28, t.height = 28, t.intersect = function(n) {
+    return D.circle(t, 14, n);
+  }, a;
+}, "choice"), Br = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = t.positioned ? t.height : n.height + t.padding, r = i / 4, s = t.positioned ? t.width : n.width + 2 * r + t.padding, l = [
+    {
+      x: r,
+      y: 0
+    },
+    {
+      x: s - r,
+      y: 0
+    },
+    {
+      x: s,
+      y: -i / 2
+    },
+    {
+      x: s - r,
+      y: -i
+    },
+    {
+      x: r,
+      y: -i
+    },
+    {
+      x: 0,
+      y: -i / 2
+    }
+  ], o = F(a, s, i, l);
+  return o.attr("style", t.style), N(t, o), t.intersect = function(p) {
+    return D.polygon(t, l, p);
+  }, a;
+}, "hexagon"), Cr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, void 0, !0), i = n.height + 2 * t.padding, r = i / 2, s = n.width + 2 * r + t.padding, l = t.positioned && (t.widthInColumns ?? 1) > 1 && t.width > s ? t.width : s, o = $r(t.directions, n, t, l), p = F(a, l, i, o);
+  return p.attr("style", t.style), N(t, p), t.intersect = function(c) {
+    return D.polygon(t, o, c);
+  }, a;
+}, "block_arrow"), Rr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding, r = n.height + t.padding, s = [
+    {
+      x: -r / 2,
+      y: 0
+    },
+    {
+      x: i,
+      y: 0
+    },
+    {
+      x: i,
+      y: -r
+    },
+    {
+      x: -r / 2,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -r / 2
+    }
+  ];
+  return F(a, i, r, s).attr("style", t.style), t.width = i + r, t.height = r, t.intersect = function(l) {
+    return D.polygon(t, s, l);
+  }, a;
+}, "rect_left_inv_arrow"), zr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t), !0), i = n.width + t.padding, r = n.height + t.padding, s = [
+    {
+      x: -2 * r / 6,
+      y: 0
+    },
+    {
+      x: i - r / 6,
+      y: 0
+    },
+    {
+      x: i + 2 * r / 6,
+      y: -r
+    },
+    {
+      x: r / 6,
+      y: -r
+    }
+  ], l = F(a, i, r, s);
+  return l.attr("style", t.style), N(t, l), t.intersect = function(o) {
+    return D.polygon(t, s, o);
+  }, a;
+}, "lean_right"), Ar = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding, r = n.height + t.padding, s = [
+    {
+      x: 2 * r / 6,
+      y: 0
+    },
+    {
+      x: i + r / 6,
+      y: 0
+    },
+    {
+      x: i - 2 * r / 6,
+      y: -r
+    },
+    {
+      x: -r / 6,
+      y: -r
+    }
+  ], l = F(a, i, r, s);
+  return l.attr("style", t.style), N(t, l), t.intersect = function(o) {
+    return D.polygon(t, s, o);
+  }, a;
+}, "lean_left"), Mr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding, r = n.height + t.padding, s = [
+    {
+      x: -2 * r / 6,
+      y: 0
+    },
+    {
+      x: i + 2 * r / 6,
+      y: 0
+    },
+    {
+      x: i - r / 6,
+      y: -r
+    },
+    {
+      x: r / 6,
+      y: -r
+    }
+  ], l = F(a, i, r, s);
+  return l.attr("style", t.style), N(t, l), t.intersect = function(o) {
+    return D.polygon(t, s, o);
+  }, a;
+}, "trapezoid"), Pr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding, r = n.height + t.padding, s = [
+    {
+      x: r / 6,
+      y: 0
+    },
+    {
+      x: i - r / 6,
+      y: 0
+    },
+    {
+      x: i + 2 * r / 6,
+      y: -r
+    },
+    {
+      x: -2 * r / 6,
+      y: -r
+    }
+  ], l = F(a, i, r, s);
+  return l.attr("style", t.style), N(t, l), t.intersect = function(o) {
+    return D.polygon(t, s, o);
+  }, a;
+}, "inv_trapezoid"), Yr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding, r = n.height + t.padding, s = [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: i + r / 2,
+      y: 0
+    },
+    {
+      x: i,
+      y: -r / 2
+    },
+    {
+      x: i + r / 2,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -r
+    }
+  ], l = F(a, i, r, s);
+  return l.attr("style", t.style), N(t, l), t.intersect = function(o) {
+    return D.polygon(t, s, o);
+  }, a;
+}, "rect_right_inv_arrow"), Wr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding, r = i / 2, s = r / (2.5 + i / 50), l = n.height + s + t.padding, o = "M 0," + s + " a " + r + "," + s + " 0,0,0 " + i + " 0 a " + r + "," + s + " 0,0,0 " + -i + " 0 l 0," + l + " a " + r + "," + s + " 0,0,0 " + i + " 0 l 0," + -l;
+  return N(t, a.attr("label-offset-y", s).insert("path", ":first-child").attr("style", t.style).attr("d", o).attr("transform", "translate(" + -i / 2 + "," + -(l / 2 + s) + ")")), t.intersect = function(p) {
+    let c = D.rect(t, p), u = c.x - t.x;
+    if (r != 0 && (Math.abs(u) < t.width / 2 || Math.abs(u) == t.width / 2 && Math.abs(c.y - t.y) > t.height / 2 - s)) {
+      let m = s * s * (1 - u * u / (r * r));
+      m != 0 && (m = Math.sqrt(m)), m = s - m, p.y - t.y > 0 && (m = -m), c.y += m;
+    }
+    return c;
+  }, a;
+}, "cylinder"), Xr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n, halfPadding: i } = await B(e, t, "node " + t.classes + " " + t.class, !0), r = a.insert("rect", ":first-child"), s = t.positioned ? t.width : n.width + t.padding, l = t.positioned ? t.height : n.height + t.padding, o = t.positioned ? -s / 2 : -n.width / 2 - i, p = t.positioned ? -l / 2 : -n.height / 2 - i;
+  if (r.attr("class", "basic label-container").attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("x", o).attr("y", p).attr("width", s).attr("height", l), t.props) {
+    let c = new Set(Object.keys(t.props));
+    t.props.borders && (lt(r, t.props.borders, s, l), c.delete("borders")), c.forEach((u) => {
+      S.warn(`Unknown node property ${u}`);
+    });
+  }
+  return N(t, r), t.intersect = function(c) {
+    return D.rect(t, c);
+  }, a;
+}, "rect"), Fr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n, halfPadding: i } = await B(e, t, "node " + t.classes, !0), r = a.insert("rect", ":first-child"), s = t.positioned ? t.width : n.width + t.padding, l = t.positioned ? t.height : n.height + t.padding, o = t.positioned ? -s / 2 : -n.width / 2 - i, p = t.positioned ? -l / 2 : -n.height / 2 - i;
+  if (r.attr("class", "basic cluster composite label-container").attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("x", o).attr("y", p).attr("width", s).attr("height", l), t.props) {
+    let c = new Set(Object.keys(t.props));
+    t.props.borders && (lt(r, t.props.borders, s, l), c.delete("borders")), c.forEach((u) => {
+      S.warn(`Unknown node property ${u}`);
+    });
+  }
+  return N(t, r), t.intersect = function(c) {
+    return D.rect(t, c);
+  }, a;
+}, "composite"), jr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a } = await B(e, t, "label", !0);
+  S.trace("Classes = ", t.class);
+  let n = a.insert("rect", ":first-child");
+  if (n.attr("width", 0).attr("height", 0), a.attr("class", "label edgeLabel"), t.props) {
+    let i = new Set(Object.keys(t.props));
+    t.props.borders && (lt(n, t.props.borders, 0, 0), i.delete("borders")), i.forEach((r) => {
+      S.warn(`Unknown node property ${r}`);
+    });
+  }
+  return N(t, n), t.intersect = function(i) {
+    return D.rect(t, i);
+  }, a;
+}, "labelRect");
+function lt(e, t, a, n) {
+  let i = [], r = /* @__PURE__ */ g((l) => {
+    i.push(l, 0);
+  }, "addBorder"), s = /* @__PURE__ */ g((l) => {
+    i.push(0, l);
+  }, "skipBorder");
+  t.includes("t") ? (S.debug("add top border"), r(a)) : s(a), t.includes("r") ? (S.debug("add right border"), r(n)) : s(n), t.includes("b") ? (S.debug("add bottom border"), r(a)) : s(a), t.includes("l") ? (S.debug("add left border"), r(n)) : s(n), e.attr("stroke-dasharray", i.join(" "));
+}
+g(lt, "applyNodePropertyBorders");
+var Hr = /* @__PURE__ */ g(async (e, t) => {
+  let a;
+  a = t.classes ? "node " + t.classes : "node default";
+  let n = e.insert("g").attr("class", a).attr("id", t.domId || t.id), i = n.insert("rect", ":first-child"), r = n.insert("line"), s = n.insert("g").attr("class", "label"), l = t.labelText.flat ? t.labelText.flat() : t.labelText, o = "";
+  o = typeof l == "object" ? l[0] : l, S.info("Label text abc79", o, l, typeof l == "object");
+  let p = await X(s, o, t.labelStyle, !0, !0), c = {
+    width: 0,
+    height: 0
+  };
+  if (z(O())) {
+    let k = p.children[0], L = v(p);
+    c = k.getBoundingClientRect(), L.attr("width", c.width), L.attr("height", c.height);
+  }
+  S.info("Text 2", l);
+  let u = l.slice(1, l.length), m = p.getBBox(), b = await X(s, u.join ? u.join("<br/>") : u, t.labelStyle, !0, !0);
+  if (z(O())) {
+    let k = b.children[0], L = v(b);
+    c = k.getBoundingClientRect(), L.attr("width", c.width), L.attr("height", c.height);
+  }
+  let w = t.padding / 2;
+  return v(b).attr("transform", "translate( " + (c.width > m.width ? 0 : (m.width - c.width) / 2) + ", " + (m.height + w + 5) + ")"), v(p).attr("transform", "translate( " + (c.width < m.width ? 0 : -(m.width - c.width) / 2) + ", 0)"), c = s.node().getBBox(), s.attr("transform", "translate(" + -c.width / 2 + ", " + (-c.height / 2 - w + 3) + ")"), i.attr("class", "outer title-state").attr("x", -c.width / 2 - w).attr("y", -c.height / 2 - w).attr("width", c.width + t.padding).attr("height", c.height + t.padding), r.attr("class", "divider").attr("x1", -c.width / 2 - w).attr("x2", c.width / 2 + w).attr("y1", -c.height / 2 - w + m.height + w).attr("y2", -c.height / 2 - w + m.height + w), N(t, i), t.intersect = function(k) {
+    return D.rect(t, k);
+  }, n;
+}, "rectWithTitle"), Kr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.height + t.padding, r = n.width + i / 4 + t.padding;
+  return N(t, a.insert("rect", ":first-child").attr("style", t.style).attr("rx", i / 2).attr("ry", i / 2).attr("x", -r / 2).attr("y", -i / 2).attr("width", r).attr("height", i)), t.intersect = function(s) {
+    return D.rect(t, s);
+  }, a;
+}, "stadium"), Ur = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n, halfPadding: i } = await B(e, t, M(t, void 0), !0), r = a.insert("circle", ":first-child");
+  return r.attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("r", n.width / 2 + i).attr("width", n.width + t.padding).attr("height", n.height + t.padding), S.info("Circle main"), N(t, r), t.intersect = function(s) {
+    return S.info("Circle intersect", t, n.width / 2 + i, s), D.circle(t, n.width / 2 + i, s);
+  }, a;
+}, "circle"), qr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n, halfPadding: i } = await B(e, t, M(t, void 0), !0), r = a.insert("g", ":first-child"), s = r.insert("circle"), l = r.insert("circle");
+  return r.attr("class", t.class), s.attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("r", n.width / 2 + i + 5).attr("width", n.width + t.padding + 10).attr("height", n.height + t.padding + 10), l.attr("style", t.style).attr("rx", t.rx).attr("ry", t.ry).attr("r", n.width / 2 + i).attr("width", n.width + t.padding).attr("height", n.height + t.padding), S.info("DoubleCircle main"), N(t, s), t.intersect = function(o) {
+    return S.info("DoubleCircle intersect", t, n.width / 2 + i + 5, o), D.circle(t, n.width / 2 + i + 5, o);
+  }, a;
+}, "doublecircle"), Zr = /* @__PURE__ */ g(async (e, t) => {
+  let { shapeSvg: a, bbox: n } = await B(e, t, M(t, void 0), !0), i = n.width + t.padding, r = n.height + t.padding, s = [
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: i,
+      y: 0
+    },
+    {
+      x: i,
+      y: -r
+    },
+    {
+      x: 0,
+      y: -r
+    },
+    {
+      x: 0,
+      y: 0
+    },
+    {
+      x: -8,
+      y: 0
+    },
+    {
+      x: i + 8,
+      y: 0
+    },
+    {
+      x: i + 8,
+      y: -r
+    },
+    {
+      x: -8,
+      y: -r
+    },
+    {
+      x: -8,
+      y: 0
+    }
+  ], l = F(a, i, r, s);
+  return l.attr("style", t.style), N(t, l), t.intersect = function(o) {
+    return D.polygon(t, s, o);
+  }, a;
+}, "subroutine"), Gr = /* @__PURE__ */ g((e, t) => {
+  let a = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id), n = a.insert("circle", ":first-child");
+  return n.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14), N(t, n), t.intersect = function(i) {
+    return D.circle(t, 7, i);
+  }, a;
+}, "start"), Xt = /* @__PURE__ */ g((e, t, a) => {
+  let n = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id), i = 70, r = 10;
+  return a === "LR" && (i = 10, r = 70), N(t, n.append("rect").attr("x", -1 * i / 2).attr("y", -1 * r / 2).attr("width", i).attr("height", r).attr("class", "fork-join")), t.height += t.padding / 2, t.width += t.padding / 2, t.intersect = function(s) {
+    return D.rect(t, s);
+  }, n;
+}, "forkJoin"), Ft = {
+  rhombus: Wt,
+  composite: Fr,
+  question: Wt,
+  rect: Xr,
+  labelRect: jr,
+  rectWithTitle: Hr,
+  choice: Or,
+  circle: Ur,
+  doublecircle: qr,
+  stadium: Kr,
+  hexagon: Br,
+  block_arrow: Cr,
+  rect_left_inv_arrow: Rr,
+  lean_right: zr,
+  lean_left: Ar,
+  trapezoid: Mr,
+  inv_trapezoid: Pr,
+  rect_right_inv_arrow: Yr,
+  cylinder: Wr,
+  start: Gr,
+  end: /* @__PURE__ */ g((e, t) => {
+    let a = e.insert("g").attr("class", "node default").attr("id", t.domId || t.id), n = a.insert("circle", ":first-child"), i = a.insert("circle", ":first-child");
+    return i.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), N(t, i), t.intersect = function(r) {
+      return D.circle(t, 7, r);
+    }, a;
+  }, "end"),
+  note: Ir,
+  subroutine: Zr,
+  fork: Xt,
+  join: Xt,
+  class_box: /* @__PURE__ */ g(async (e, t) => {
+    let a = t.padding / 2, n;
+    n = t.classes ? "node " + t.classes : "node default";
+    let i = e.insert("g").attr("class", n).attr("id", t.domId || t.id), r = i.insert("rect", ":first-child"), s = i.insert("line"), l = i.insert("line"), o = 0, p = 4, c = i.insert("g").attr("class", "label"), u = 0, m = t.classData.annotations?.[0], b = await X(c, t.classData.annotations[0] ? "«" + t.classData.annotations[0] + "»" : "", t.labelStyle, !0, !0), w = b.getBBox();
+    if (z(O())) {
+      let f = b.children[0], E = v(b);
+      w = f.getBoundingClientRect(), E.attr("width", w.width), E.attr("height", w.height);
+    }
+    t.classData.annotations[0] && (p += w.height + 4, o += w.width);
+    let k = t.classData.label;
+    t.classData.type !== void 0 && t.classData.type !== "" && (z(O()) ? k += "&lt;" + t.classData.type + "&gt;" : k += "<" + t.classData.type + ">");
+    let L = await X(c, k, t.labelStyle, !0, !0);
+    v(L).attr("class", "classTitle");
+    let $ = L.getBBox();
+    if (z(O())) {
+      let f = L.children[0], E = v(L);
+      $ = f.getBoundingClientRect(), E.attr("width", $.width), E.attr("height", $.height);
+    }
+    p += $.height + 4, $.width > o && (o = $.width);
+    let d = [];
+    t.classData.members.forEach(async (f) => {
+      let E = f.getDisplayDetails(), h = E.displayText;
+      z(O()) && (h = h.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+      let R = await X(c, h, E.cssStyle ? E.cssStyle : t.labelStyle, !0, !0), y = R.getBBox();
+      if (z(O())) {
+        let j = R.children[0], H = v(R);
+        y = j.getBoundingClientRect(), H.attr("width", y.width), H.attr("height", y.height);
+      }
+      y.width > o && (o = y.width), p += y.height + 4, d.push(R);
+    }), p += 8;
+    let x = [];
+    if (t.classData.methods.forEach(async (f) => {
+      let E = f.getDisplayDetails(), h = E.displayText;
+      z(O()) && (h = h.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+      let R = await X(c, h, E.cssStyle ? E.cssStyle : t.labelStyle, !0, !0), y = R.getBBox();
+      if (z(O())) {
+        let j = R.children[0], H = v(R);
+        y = j.getBoundingClientRect(), H.attr("width", y.width), H.attr("height", y.height);
+      }
+      y.width > o && (o = y.width), p += y.height + 4, x.push(R);
+    }), p += 8, m) {
+      let f = (o - w.width) / 2;
+      v(b).attr("transform", "translate( " + (-1 * o / 2 + f) + ", " + -1 * p / 2 + ")"), u = w.height + 4;
+    }
+    let _ = (o - $.width) / 2;
+    return v(L).attr("transform", "translate( " + (-1 * o / 2 + _) + ", " + (-1 * p / 2 + u) + ")"), u += $.height + 4, s.attr("class", "divider").attr("x1", -o / 2 - a).attr("x2", o / 2 + a).attr("y1", -p / 2 - a + 8 + u).attr("y2", -p / 2 - a + 8 + u), u += 8, d.forEach((f) => {
+      v(f).attr("transform", "translate( " + -o / 2 + ", " + (-1 * p / 2 + u + 8 / 2) + ")");
+      let E = f?.getBBox();
+      u += (E?.height ?? 0) + 4;
+    }), u += 8, l.attr("class", "divider").attr("x1", -o / 2 - a).attr("x2", o / 2 + a).attr("y1", -p / 2 - a + 8 + u).attr("y2", -p / 2 - a + 8 + u), u += 8, x.forEach((f) => {
+      v(f).attr("transform", "translate( " + -o / 2 + ", " + (-1 * p / 2 + u) + ")");
+      let E = f?.getBBox();
+      u += (E?.height ?? 0) + 4;
+    }), r.attr("style", t.style).attr("class", "outer title-state").attr("x", -o / 2 - a).attr("y", -(p / 2) - a).attr("width", o + t.padding).attr("height", p + t.padding), N(t, r), t.intersect = function(f) {
+      return D.rect(t, f);
+    }, i;
+  }, "class_box")
+}, it = {}, ne = /* @__PURE__ */ g(async (e, t, a) => {
+  let n, i;
+  if (t.link) {
+    let r;
+    O().securityLevel === "sandbox" ? r = "_top" : t.linkTarget && (r = t.linkTarget || "_blank"), n = e.insert("svg:a").attr("xlink:href", t.link).attr("target", r), i = await Ft[t.shape](n, t, a);
+  } else i = await Ft[t.shape](e, t, a), n = i;
+  return t.tooltip && i.attr("title", t.tooltip), t.class && i.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"), Jr = /* @__PURE__ */ g((e) => {
+  let t = it[e.id];
+  S.trace("Transforming node", e.diff, e, "translate(" + (e.x - e.width / 2 - 5) + ", " + e.width / 2 + ")");
+  let a = e.diff || 0;
+  return e.clusterNode ? t.attr("transform", "translate(" + (e.x + a - e.width / 2) + ", " + (e.y - e.height / 2 - 8) + ")") : t.attr("transform", "translate(" + e.x + ", " + e.y + ")"), a;
+}, "positionNode");
+function Nt(e, t, a = !1) {
+  let n = e, i = "default";
+  (n?.classes?.length || 0) > 0 && (i = (n?.classes ?? []).join(" ")), i += " flowchart-label";
+  let r = 0, s = "", l;
+  switch (n.type) {
+    case "round":
+      r = 5, s = "rect";
+      break;
+    case "composite":
+      r = 0, s = "composite", l = 0;
+      break;
+    case "square":
+      s = "rect";
+      break;
+    case "diamond":
+      s = "question";
+      break;
+    case "hexagon":
+      s = "hexagon";
+      break;
+    case "block_arrow":
+      s = "block_arrow";
+      break;
+    case "odd":
+      s = "rect_left_inv_arrow";
+      break;
+    case "lean_right":
+      s = "lean_right";
+      break;
+    case "lean_left":
+      s = "lean_left";
+      break;
+    case "trapezoid":
+      s = "trapezoid";
+      break;
+    case "inv_trapezoid":
+      s = "inv_trapezoid";
+      break;
+    case "rect_left_inv_arrow":
+      s = "rect_left_inv_arrow";
+      break;
+    case "circle":
+      s = "circle";
+      break;
+    case "ellipse":
+      s = "ellipse";
+      break;
+    case "stadium":
+      s = "stadium";
+      break;
+    case "subroutine":
+      s = "subroutine";
+      break;
+    case "cylinder":
+      s = "cylinder";
+      break;
+    case "group":
+      s = "rect";
+      break;
+    case "doublecircle":
+      s = "doublecircle";
+      break;
+    default:
+      s = "rect";
+  }
+  let o = Ue(n?.styles ?? []), p = n.label, c = n.size ?? {
+    width: 0,
+    height: 0,
+    x: 0,
+    y: 0
+  }, u = t.getDiagramId();
+  return {
+    labelStyle: o.labelStyle,
+    shape: s,
+    labelText: p,
+    rx: r,
+    ry: r,
+    class: i,
+    style: o.style,
+    id: n.id,
+    domId: u ? `${u}-${n.id}` : n.id,
+    directions: n.directions,
+    width: c.width,
+    height: c.height,
+    x: c.x,
+    y: c.y,
+    positioned: a,
+    intersect: void 0,
+    type: n.type,
+    padding: l ?? tt()?.block?.padding ?? 0,
+    widthInColumns: n.widthInColumns ?? 1
+  };
+}
+g(Nt, "getNodeFromBlock");
+async function le(e, t, a) {
+  let n = Nt(t, a, !1);
+  if (n.type === "group") return;
+  let i = await ne(e, n, { config: tt() }), r = i.node().getBBox(), s = a.getBlock(n.id);
+  s.size = {
+    width: r.width,
+    height: r.height,
+    x: 0,
+    y: 0,
+    node: i
+  }, a.setBlock(s), i.remove();
+}
+g(le, "calculateBlockSize");
+async function oe(e, t, a) {
+  let n = Nt(t, a, !0);
+  a.getBlock(n.id).type !== "space" && (await ne(e, n, { config: tt() }), t.intersect = n?.intersect, Jr(n));
+}
+g(oe, "insertBlockPositioned");
+async function ot(e, t, a, n) {
+  for (let i of t) await n(e, i, a), i.children && await ot(e, i.children, a, n);
+}
+g(ot, "performOperations");
+async function ce(e, t, a) {
+  await ot(e, t, a, le);
+}
+g(ce, "calculateBlockSizes");
+async function de(e, t, a) {
+  await ot(e, t, a, oe);
+}
+g(de, "insertBlocks");
+async function he(e, t, a, n, i) {
+  let r = new Je({
+    multigraph: !0,
+    compound: !0
+  });
+  r.setGraph({
+    rankdir: "TB",
+    nodesep: 10,
+    ranksep: 10,
+    marginx: 8,
+    marginy: 8
+  });
+  for (let s of a) s.size && r.setNode(s.id, {
+    width: s.size.width,
+    height: s.size.height,
+    intersect: s.intersect
+  });
+  for (let s of t) if (s.start && s.end) {
+    let l = n.getBlock(s.start), o = n.getBlock(s.end);
+    if (l?.size && o?.size) {
+      let p = l.size, c = o.size, u = [
+        {
+          x: p.x,
+          y: p.y
+        },
+        {
+          x: p.x + (c.x - p.x) / 2,
+          y: p.y + (c.y - p.y) / 2
+        },
+        {
+          x: c.x,
+          y: c.y
+        }
+      ], m = i ? `${i}-${s.id}` : s.id, b = `${s.thickness === "thick" ? "edge-thickness-thick" : "edge-thickness-normal"} ${s.pattern === "dotted" ? "edge-pattern-dotted" : "edge-pattern-solid"} flowchart-link LS-a1 LE-b1`;
+      _r(e, {
+        v: s.start,
+        w: s.end,
+        name: m
+      }, {
+        ...s,
+        id: m,
+        arrowTypeEnd: s.arrowTypeEnd,
+        arrowTypeStart: s.arrowTypeStart,
+        points: u,
+        classes: b
+      }, void 0, "block", r, i), s.label && (await wr(e, {
+        ...s,
+        label: s.label,
+        labelStyle: "stroke: #333; stroke-width: 1.5px;fill:none;",
+        arrowTypeEnd: s.arrowTypeEnd,
+        arrowTypeStart: s.arrowTypeStart,
+        points: u,
+        classes: b
+      }), Sr({
+        ...s,
+        x: u[1].x,
+        y: u[1].y
+      }, { originalPath: u }));
+    }
+  }
+}
+g(he, "insertEdges");
+var ra = {
+  parser: ir,
+  db: gr,
+  renderer: {
+    draw: /* @__PURE__ */ g(async function(e, t, a, n) {
+      let { securityLevel: i, block: r } = tt(), s = n.db;
+      s.setDiagramId(t);
+      let l;
+      i === "sandbox" && (l = v("#i" + t));
+      let o = v(i === "sandbox" ? l.nodes()[0].contentDocument.body : "body"), p = i === "sandbox" ? o.select(`[id="${t}"]`) : v(`[id="${t}"]`);
+      xr(p, [
+        "point",
+        "circle",
+        "cross"
+      ], n.type, t);
+      let c = s.getBlocks(), u = s.getBlocksFlat(), m = s.getEdges(), b = p.insert("g").attr("class", "block");
+      await ce(b, c, s);
+      let w = Qt(s);
+      if (await de(b, c, s), await he(b, m, u, s, t), w) {
+        let k = w, L = Math.max(1, Math.round(0.125 * (k.width / k.height))), $ = k.height + L + 10, d = k.width + 10, { useMaxWidth: x } = r;
+        ye(p, $, d, !!x), S.debug("Here Bounds", w, k), p.attr("viewBox", `${k.x - 5} ${k.y - 5} ${k.width + 10} ${k.height + 10}`);
+      }
+    }, "draw"),
+    getClasses: /* @__PURE__ */ g(function(e, t) {
+      return t.db.getClasses();
+    }, "getClasses")
+  },
+  styles: ur
+};
+export {
+  ra as diagram
+};