flowink 0.1.0

package/dist/index.js

@@ -0,0 +1,3560 @@
+// src/parser/generated.js
+var parser = (function() {
+  var o = function(k, v, o2, l) {
+    for (o2 = o2 || {}, l = k.length; l--; o2[k[l]] = v) ;
+    return o2;
+  }, $V0 = [1, 4], $V1 = [1, 3], $V2 = [1, 5], $V3 = [1, 8, 9, 10, 11, 27, 34, 36, 38, 44, 60, 84, 85, 86, 87, 88, 89, 102, 105, 106, 109, 111, 114, 115, 116, 121, 122, 123, 124, 125], $V4 = [2, 2], $V5 = [1, 13], $V6 = [1, 14], $V7 = [1, 15], $V8 = [1, 16], $V9 = [1, 23], $Va = [1, 25], $Vb = [1, 26], $Vc = [1, 27], $Vd = [1, 50], $Ve = [1, 49], $Vf = [1, 29], $Vg = [1, 30], $Vh = [1, 31], $Vi = [1, 32], $Vj = [1, 33], $Vk = [1, 45], $Vl = [1, 47], $Vm = [1, 43], $Vn = [1, 48], $Vo = [1, 44], $Vp = [1, 51], $Vq = [1, 46], $Vr = [1, 52], $Vs = [1, 53], $Vt = [1, 34], $Vu = [1, 35], $Vv = [1, 36], $Vw = [1, 37], $Vx = [1, 38], $Vy = [1, 58], $Vz = [1, 8, 9, 10, 11, 27, 32, 34, 36, 38, 44, 60, 84, 85, 86, 87, 88, 89, 102, 105, 106, 109, 111, 114, 115, 116, 121, 122, 123, 124, 125], $VA = [1, 62], $VB = [1, 61], $VC = [1, 63], $VD = [8, 9, 11, 75, 77, 78], $VE = [1, 79], $VF = [1, 92], $VG = [1, 97], $VH = [1, 96], $VI = [1, 93], $VJ = [1, 89], $VK = [1, 95], $VL = [1, 91], $VM = [1, 98], $VN = [1, 94], $VO = [1, 99], $VP = [1, 90], $VQ = [8, 9, 10, 11, 40, 75, 77, 78], $VR = [8, 9, 10, 11, 40, 46, 75, 77, 78], $VS = [8, 9, 10, 11, 29, 40, 44, 46, 48, 50, 52, 54, 56, 58, 60, 63, 65, 67, 68, 70, 75, 77, 78, 89, 102, 105, 106, 109, 111, 114, 115, 116], $VT = [8, 9, 11, 44, 60, 75, 77, 78, 89, 102, 105, 106, 109, 111, 114, 115, 116], $VU = [44, 60, 89, 102, 105, 106, 109, 111, 114, 115, 116], $VV = [1, 122], $VW = [1, 123], $VX = [1, 125], $VY = [1, 124], $VZ = [44, 60, 62, 74, 89, 102, 105, 106, 109, 111, 114, 115, 116], $V_ = [1, 134], $V$ = [1, 148], $V01 = [1, 149], $V11 = [1, 150], $V21 = [1, 151], $V31 = [1, 136], $V41 = [1, 138], $V51 = [1, 142], $V61 = [1, 143], $V71 = [1, 144], $V81 = [1, 145], $V91 = [1, 146], $Va1 = [1, 147], $Vb1 = [1, 152], $Vc1 = [1, 153], $Vd1 = [1, 132], $Ve1 = [1, 133], $Vf1 = [1, 140], $Vg1 = [1, 135], $Vh1 = [1, 139], $Vi1 = [1, 137], $Vj1 = [8, 9, 10, 11, 27, 32, 34, 36, 38, 44, 60, 84, 85, 86, 87, 88, 89, 102, 105, 106, 109, 111, 114, 115, 116, 121, 122, 123, 124, 125], $Vk1 = [1, 155], $Vl1 = [1, 157], $Vm1 = [8, 9, 11], $Vn1 = [8, 9, 10, 11, 14, 44, 60, 89, 105, 106, 109, 111, 114, 115, 116], $Vo1 = [1, 177], $Vp1 = [1, 173], $Vq1 = [1, 174], $Vr1 = [1, 178], $Vs1 = [1, 175], $Vt1 = [1, 176], $Vu1 = [77, 116, 119], $Vv1 = [8, 9, 10, 11, 12, 14, 27, 29, 32, 44, 60, 75, 84, 85, 86, 87, 88, 89, 90, 105, 109, 111, 114, 115, 116], $Vw1 = [10, 106], $Vx1 = [31, 49, 51, 53, 55, 57, 62, 64, 66, 67, 69, 71, 116, 117, 118], $Vy1 = [1, 248], $Vz1 = [1, 246], $VA1 = [1, 250], $VB1 = [1, 244], $VC1 = [1, 245], $VD1 = [1, 247], $VE1 = [1, 249], $VF1 = [1, 251], $VG1 = [1, 269], $VH1 = [8, 9, 11, 106], $VI1 = [8, 9, 10, 11, 60, 84, 105, 106, 109, 110, 111, 112];
+  var parser2 = {
+    trace: function trace() {
+    },
+    yy: {},
+    symbols_: { "error": 2, "start": 3, "graphConfig": 4, "document": 5, "line": 6, "statement": 7, "SEMI": 8, "NEWLINE": 9, "SPACE": 10, "EOF": 11, "GRAPH": 12, "NODIR": 13, "DIR": 14, "FirstStmtSeparator": 15, "ending": 16, "endToken": 17, "spaceList": 18, "spaceListNewline": 19, "vertexStatement": 20, "separator": 21, "styleStatement": 22, "linkStyleStatement": 23, "classDefStatement": 24, "classStatement": 25, "clickStatement": 26, "subgraph": 27, "textNoTags": 28, "SQS": 29, "text": 30, "SQE": 31, "end": 32, "direction": 33, "acc_title": 34, "acc_title_value": 35, "acc_descr": 36, "acc_descr_value": 37, "acc_descr_multiline_value": 38, "shapeData": 39, "SHAPE_DATA": 40, "link": 41, "node": 42, "styledVertex": 43, "AMP": 44, "vertex": 45, "STYLE_SEPARATOR": 46, "idString": 47, "DOUBLECIRCLESTART": 48, "DOUBLECIRCLEEND": 49, "PS": 50, "PE": 51, "(-": 52, "-)": 53, "STADIUMSTART": 54, "STADIUMEND": 55, "SUBROUTINESTART": 56, "SUBROUTINEEND": 57, "VERTEX_WITH_PROPS_START": 58, "NODE_STRING[field]": 59, "COLON": 60, "NODE_STRING[value]": 61, "PIPE": 62, "CYLINDERSTART": 63, "CYLINDEREND": 64, "DIAMOND_START": 65, "DIAMOND_STOP": 66, "TAGEND": 67, "TRAPSTART": 68, "TRAPEND": 69, "INVTRAPSTART": 70, "INVTRAPEND": 71, "linkStatement": 72, "arrowText": 73, "TESTSTR": 74, "START_LINK": 75, "edgeText": 76, "LINK": 77, "LINK_ID": 78, "edgeTextToken": 79, "STR": 80, "MD_STR": 81, "textToken": 82, "keywords": 83, "STYLE": 84, "LINKSTYLE": 85, "CLASSDEF": 86, "CLASS": 87, "CLICK": 88, "DOWN": 89, "UP": 90, "textNoTagsToken": 91, "stylesOpt": 92, "idString[vertex]": 93, "idString[class]": 94, "CALLBACKNAME": 95, "CALLBACKARGS": 96, "HREF": 97, "LINK_TARGET": 98, "STR[link]": 99, "STR[tooltip]": 100, "alphaNum": 101, "DEFAULT": 102, "numList": 103, "INTERPOLATE": 104, "NUM": 105, "COMMA": 106, "style": 107, "styleComponent": 108, "NODE_STRING": 109, "UNIT": 110, "BRKT": 111, "PCT": 112, "idStringToken": 113, "MINUS": 114, "MULT": 115, "UNICODE_TEXT": 116, "TEXT": 117, "TAGSTART": 118, "EDGE_TEXT": 119, "alphaNumToken": 120, "direction_tb": 121, "direction_bt": 122, "direction_rl": 123, "direction_lr": 124, "direction_td": 125, "$accept": 0, "$end": 1 },
+    terminals_: { 2: "error", 8: "SEMI", 9: "NEWLINE", 10: "SPACE", 11: "EOF", 12: "GRAPH", 13: "NODIR", 14: "DIR", 27: "subgraph", 29: "SQS", 31: "SQE", 32: "end", 34: "acc_title", 35: "acc_title_value", 36: "acc_descr", 37: "acc_descr_value", 38: "acc_descr_multiline_value", 40: "SHAPE_DATA", 44: "AMP", 46: "STYLE_SEPARATOR", 48: "DOUBLECIRCLESTART", 49: "DOUBLECIRCLEEND", 50: "PS", 51: "PE", 52: "(-", 53: "-)", 54: "STADIUMSTART", 55: "STADIUMEND", 56: "SUBROUTINESTART", 57: "SUBROUTINEEND", 58: "VERTEX_WITH_PROPS_START", 59: "NODE_STRING[field]", 60: "COLON", 61: "NODE_STRING[value]", 62: "PIPE", 63: "CYLINDERSTART", 64: "CYLINDEREND", 65: "DIAMOND_START", 66: "DIAMOND_STOP", 67: "TAGEND", 68: "TRAPSTART", 69: "TRAPEND", 70: "INVTRAPSTART", 71: "INVTRAPEND", 74: "TESTSTR", 75: "START_LINK", 77: "LINK", 78: "LINK_ID", 80: "STR", 81: "MD_STR", 84: "STYLE", 85: "LINKSTYLE", 86: "CLASSDEF", 87: "CLASS", 88: "CLICK", 89: "DOWN", 90: "UP", 93: "idString[vertex]", 94: "idString[class]", 95: "CALLBACKNAME", 96: "CALLBACKARGS", 97: "HREF", 98: "LINK_TARGET", 99: "STR[link]", 100: "STR[tooltip]", 102: "DEFAULT", 104: "INTERPOLATE", 105: "NUM", 106: "COMMA", 109: "NODE_STRING", 110: "UNIT", 111: "BRKT", 112: "PCT", 114: "MINUS", 115: "MULT", 116: "UNICODE_TEXT", 117: "TEXT", 118: "TAGSTART", 119: "EDGE_TEXT", 121: "direction_tb", 122: "direction_bt", 123: "direction_rl", 124: "direction_lr", 125: "direction_td" },
+    productions_: [0, [3, 2], [5, 0], [5, 2], [6, 1], [6, 1], [6, 1], [6, 1], [6, 1], [4, 2], [4, 2], [4, 2], [4, 3], [16, 2], [16, 1], [17, 1], [17, 1], [17, 1], [15, 1], [15, 1], [15, 2], [19, 2], [19, 2], [19, 1], [19, 1], [18, 2], [18, 1], [7, 2], [7, 2], [7, 2], [7, 2], [7, 2], [7, 2], [7, 9], [7, 6], [7, 4], [7, 1], [7, 2], [7, 2], [7, 1], [21, 1], [21, 1], [21, 1], [39, 2], [39, 1], [20, 4], [20, 3], [20, 4], [20, 2], [20, 2], [20, 1], [42, 1], [42, 6], [42, 5], [43, 1], [43, 3], [45, 4], [45, 4], [45, 6], [45, 4], [45, 4], [45, 4], [45, 8], [45, 4], [45, 4], [45, 4], [45, 6], [45, 4], [45, 4], [45, 4], [45, 4], [45, 4], [45, 1], [41, 2], [41, 3], [41, 3], [41, 1], [41, 3], [41, 4], [76, 1], [76, 2], [76, 1], [76, 1], [72, 1], [72, 2], [73, 3], [30, 1], [30, 2], [30, 1], [30, 1], [83, 1], [83, 1], [83, 1], [83, 1], [83, 1], [83, 1], [83, 1], [83, 1], [83, 1], [83, 1], [83, 1], [28, 1], [28, 2], [28, 1], [28, 1], [24, 5], [25, 5], [26, 2], [26, 4], [26, 3], [26, 5], [26, 3], [26, 5], [26, 5], [26, 7], [26, 2], [26, 4], [26, 2], [26, 4], [26, 4], [26, 6], [22, 5], [23, 5], [23, 5], [23, 9], [23, 9], [23, 7], [23, 7], [103, 1], [103, 3], [92, 1], [92, 3], [107, 1], [107, 2], [108, 1], [108, 1], [108, 1], [108, 1], [108, 1], [108, 1], [108, 1], [108, 1], [113, 1], [113, 1], [113, 1], [113, 1], [113, 1], [113, 1], [113, 1], [113, 1], [113, 1], [113, 1], [113, 1], [82, 1], [82, 1], [82, 1], [82, 1], [91, 1], [91, 1], [91, 1], [91, 1], [91, 1], [91, 1], [91, 1], [91, 1], [91, 1], [91, 1], [91, 1], [79, 1], [79, 1], [120, 1], [120, 1], [120, 1], [120, 1], [120, 1], [120, 1], [120, 1], [120, 1], [120, 1], [120, 1], [120, 1], [47, 1], [47, 2], [101, 1], [101, 2], [33, 1], [33, 1], [33, 1], [33, 1], [33, 1]],
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+      var $0 = $$.length - 1;
+      switch (yystate) {
+        case 2:
+          this.$ = [];
+          break;
+        case 3:
+          if (!Array.isArray($$[$0]) || $$[$0].length > 0) {
+            $$[$0 - 1].push($$[$0]);
+          }
+          this.$ = $$[$0 - 1];
+          break;
+        case 4:
+        case 183:
+          this.$ = $$[$0];
+          break;
+        case 11:
+          yy.setDirection("TB");
+          this.$ = "TB";
+          break;
+        case 12:
+          yy.setDirection($$[$0 - 1]);
+          this.$ = $$[$0 - 1];
+          break;
+        case 27:
+          this.$ = $$[$0 - 1].nodes;
+          break;
+        case 28:
+        case 29:
+        case 30:
+        case 31:
+        case 32:
+          this.$ = [];
+          break;
+        case 33:
+          this.$ = yy.addSubGraph($$[$0 - 6], $$[$0 - 1], $$[$0 - 4]);
+          break;
+        case 34:
+          this.$ = yy.addSubGraph($$[$0 - 3], $$[$0 - 1], $$[$0 - 3]);
+          break;
+        case 35:
+          this.$ = yy.addSubGraph(void 0, $$[$0 - 1], void 0);
+          break;
+        case 37:
+          this.$ = $$[$0].trim();
+          yy.setAccTitle(this.$);
+          break;
+        case 38:
+        case 39:
+          this.$ = $$[$0].trim();
+          yy.setAccDescription(this.$);
+          break;
+        case 43:
+          this.$ = $$[$0 - 1] + $$[$0];
+          break;
+        case 44:
+          this.$ = $$[$0];
+          break;
+        case 45:
+          yy.addVertex($$[$0 - 1][$$[$0 - 1].length - 1], void 0, void 0, void 0, void 0, void 0, void 0, $$[$0]);
+          yy.addLink($$[$0 - 3].stmt, $$[$0 - 1], $$[$0 - 2]);
+          this.$ = { stmt: $$[$0 - 1], nodes: $$[$0 - 1].concat($$[$0 - 3].nodes) };
+          break;
+        case 46:
+          yy.addLink($$[$0 - 2].stmt, $$[$0], $$[$0 - 1]);
+          this.$ = { stmt: $$[$0], nodes: $$[$0].concat($$[$0 - 2].nodes) };
+          break;
+        case 47:
+          yy.addLink($$[$0 - 3].stmt, $$[$0 - 1], $$[$0 - 2]);
+          this.$ = { stmt: $$[$0 - 1], nodes: $$[$0 - 1].concat($$[$0 - 3].nodes) };
+          break;
+        case 48:
+          this.$ = { stmt: $$[$0 - 1], nodes: $$[$0 - 1] };
+          break;
+        case 49:
+          yy.addVertex($$[$0 - 1][$$[$0 - 1].length - 1], void 0, void 0, void 0, void 0, void 0, void 0, $$[$0]);
+          this.$ = { stmt: $$[$0 - 1], nodes: $$[$0 - 1], shapeData: $$[$0] };
+          break;
+        case 50:
+          this.$ = { stmt: $$[$0], nodes: $$[$0] };
+          break;
+        case 51:
+          this.$ = [$$[$0]];
+          break;
+        case 52:
+          yy.addVertex($$[$0 - 5][$$[$0 - 5].length - 1], void 0, void 0, void 0, void 0, void 0, void 0, $$[$0 - 4]);
+          this.$ = $$[$0 - 5].concat($$[$0]);
+          break;
+        case 53:
+          this.$ = $$[$0 - 4].concat($$[$0]);
+          break;
+        case 54:
+          this.$ = $$[$0];
+          break;
+        case 55:
+          this.$ = $$[$0 - 2];
+          yy.setClass($$[$0 - 2], $$[$0]);
+          break;
+        case 56:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "square");
+          break;
+        case 57:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "doublecircle");
+          break;
+        case 58:
+          this.$ = $$[$0 - 5];
+          yy.addVertex($$[$0 - 5], $$[$0 - 2], "circle");
+          break;
+        case 59:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "ellipse");
+          break;
+        case 60:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "stadium");
+          break;
+        case 61:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "subroutine");
+          break;
+        case 62:
+          this.$ = $$[$0 - 7];
+          yy.addVertex($$[$0 - 7], $$[$0 - 1], "rect", void 0, void 0, void 0, Object.fromEntries([[$$[$0 - 5], $$[$0 - 3]]]));
+          break;
+        case 63:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "cylinder");
+          break;
+        case 64:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "round");
+          break;
+        case 65:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "diamond");
+          break;
+        case 66:
+          this.$ = $$[$0 - 5];
+          yy.addVertex($$[$0 - 5], $$[$0 - 2], "hexagon");
+          break;
+        case 67:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "odd");
+          break;
+        case 68:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "trapezoid");
+          break;
+        case 69:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "inv_trapezoid");
+          break;
+        case 70:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "lean_right");
+          break;
+        case 71:
+          this.$ = $$[$0 - 3];
+          yy.addVertex($$[$0 - 3], $$[$0 - 1], "lean_left");
+          break;
+        case 72:
+          this.$ = $$[$0];
+          yy.addVertex($$[$0]);
+          break;
+        case 73:
+          $$[$0 - 1].text = $$[$0];
+          this.$ = $$[$0 - 1];
+          break;
+        case 74:
+        case 75:
+          $$[$0 - 2].text = $$[$0 - 1];
+          this.$ = $$[$0 - 2];
+          break;
+        case 76:
+          this.$ = $$[$0];
+          break;
+        case 77:
+          var inf = yy.destructLink($$[$0], $$[$0 - 2]);
+          this.$ = { "type": inf.type, "stroke": inf.stroke, "length": inf.length, "text": $$[$0 - 1] };
+          break;
+        case 78:
+          var inf = yy.destructLink($$[$0], $$[$0 - 2]);
+          this.$ = { "type": inf.type, "stroke": inf.stroke, "length": inf.length, "text": $$[$0 - 1], "id": $$[$0 - 3] };
+          break;
+        case 79:
+          this.$ = { text: $$[$0], type: "text" };
+          break;
+        case 80:
+          this.$ = { text: $$[$0 - 1].text + "" + $$[$0], type: $$[$0 - 1].type };
+          break;
+        case 81:
+          this.$ = { text: $$[$0], type: "string" };
+          break;
+        case 82:
+          this.$ = { text: $$[$0], type: "markdown" };
+          break;
+        case 83:
+          var inf = yy.destructLink($$[$0]);
+          this.$ = { "type": inf.type, "stroke": inf.stroke, "length": inf.length };
+          break;
+        case 84:
+          var inf = yy.destructLink($$[$0]);
+          this.$ = { "type": inf.type, "stroke": inf.stroke, "length": inf.length, "id": $$[$0 - 1] };
+          break;
+        case 85:
+          this.$ = $$[$0 - 1];
+          break;
+        case 86:
+          this.$ = { text: $$[$0], type: "text" };
+          break;
+        case 87:
+          this.$ = { text: $$[$0 - 1].text + "" + $$[$0], type: $$[$0 - 1].type };
+          break;
+        case 88:
+          this.$ = { text: $$[$0], type: "string" };
+          break;
+        case 89:
+        case 104:
+          this.$ = { text: $$[$0], type: "markdown" };
+          break;
+        case 101:
+          this.$ = { text: $$[$0], type: "text" };
+          break;
+        case 102:
+          this.$ = { text: $$[$0 - 1].text + "" + $$[$0], type: $$[$0 - 1].type };
+          break;
+        case 103:
+          this.$ = { text: $$[$0], type: "text" };
+          break;
+        case 105:
+          this.$ = $$[$0 - 4];
+          yy.addClass($$[$0 - 2], $$[$0]);
+          break;
+        case 106:
+          this.$ = $$[$0 - 4];
+          yy.setClass($$[$0 - 2], $$[$0]);
+          break;
+        case 107:
+        case 115:
+          this.$ = $$[$0 - 1];
+          yy.setClickEvent($$[$0 - 1], $$[$0]);
+          break;
+        case 108:
+        case 116:
+          this.$ = $$[$0 - 3];
+          yy.setClickEvent($$[$0 - 3], $$[$0 - 2]);
+          yy.setTooltip($$[$0 - 3], $$[$0]);
+          break;
+        case 109:
+          this.$ = $$[$0 - 2];
+          yy.setClickEvent($$[$0 - 2], $$[$0 - 1], $$[$0]);
+          break;
+        case 110:
+          this.$ = $$[$0 - 4];
+          yy.setClickEvent($$[$0 - 4], $$[$0 - 3], $$[$0 - 2]);
+          yy.setTooltip($$[$0 - 4], $$[$0]);
+          break;
+        case 111:
+          this.$ = $$[$0 - 2];
+          yy.setLink($$[$0 - 2], $$[$0]);
+          break;
+        case 112:
+          this.$ = $$[$0 - 4];
+          yy.setLink($$[$0 - 4], $$[$0 - 2]);
+          yy.setTooltip($$[$0 - 4], $$[$0]);
+          break;
+        case 113:
+          this.$ = $$[$0 - 4];
+          yy.setLink($$[$0 - 4], $$[$0 - 2], $$[$0]);
+          break;
+        case 114:
+          this.$ = $$[$0 - 6];
+          yy.setLink($$[$0 - 6], $$[$0 - 4], $$[$0]);
+          yy.setTooltip($$[$0 - 6], $$[$0 - 2]);
+          break;
+        case 117:
+          this.$ = $$[$0 - 1];
+          yy.setLink($$[$0 - 1], $$[$0]);
+          break;
+        case 118:
+          this.$ = $$[$0 - 3];
+          yy.setLink($$[$0 - 3], $$[$0 - 2]);
+          yy.setTooltip($$[$0 - 3], $$[$0]);
+          break;
+        case 119:
+          this.$ = $$[$0 - 3];
+          yy.setLink($$[$0 - 3], $$[$0 - 2], $$[$0]);
+          break;
+        case 120:
+          this.$ = $$[$0 - 5];
+          yy.setLink($$[$0 - 5], $$[$0 - 4], $$[$0]);
+          yy.setTooltip($$[$0 - 5], $$[$0 - 2]);
+          break;
+        case 121:
+          this.$ = $$[$0 - 4];
+          yy.addVertex($$[$0 - 2], void 0, void 0, $$[$0]);
+          break;
+        case 122:
+          this.$ = $$[$0 - 4];
+          yy.updateLink([$$[$0 - 2]], $$[$0]);
+          break;
+        case 123:
+          this.$ = $$[$0 - 4];
+          yy.updateLink($$[$0 - 2], $$[$0]);
+          break;
+        case 124:
+          this.$ = $$[$0 - 8];
+          yy.updateLinkInterpolate([$$[$0 - 6]], $$[$0 - 2]);
+          yy.updateLink([$$[$0 - 6]], $$[$0]);
+          break;
+        case 125:
+          this.$ = $$[$0 - 8];
+          yy.updateLinkInterpolate($$[$0 - 6], $$[$0 - 2]);
+          yy.updateLink($$[$0 - 6], $$[$0]);
+          break;
+        case 126:
+          this.$ = $$[$0 - 6];
+          yy.updateLinkInterpolate([$$[$0 - 4]], $$[$0]);
+          break;
+        case 127:
+          this.$ = $$[$0 - 6];
+          yy.updateLinkInterpolate($$[$0 - 4], $$[$0]);
+          break;
+        case 128:
+        case 130:
+          this.$ = [$$[$0]];
+          break;
+        case 129:
+        case 131:
+          $$[$0 - 2].push($$[$0]);
+          this.$ = $$[$0 - 2];
+          break;
+        case 133:
+          this.$ = $$[$0 - 1] + $$[$0];
+          break;
+        case 181:
+          this.$ = $$[$0];
+          break;
+        case 182:
+          this.$ = $$[$0 - 1] + "" + $$[$0];
+          break;
+        case 184:
+          this.$ = $$[$0 - 1] + "" + $$[$0];
+          break;
+        case 185:
+          this.$ = { stmt: "dir", value: "TB" };
+          break;
+        case 186:
+          this.$ = { stmt: "dir", value: "BT" };
+          break;
+        case 187:
+          this.$ = { stmt: "dir", value: "RL" };
+          break;
+        case 188:
+          this.$ = { stmt: "dir", value: "LR" };
+          break;
+        case 189:
+          this.$ = { stmt: "dir", value: "TD" };
+          break;
+      }
+    },
+    table: [{ 3: 1, 4: 2, 9: $V0, 10: $V1, 12: $V2 }, { 1: [3] }, o($V3, $V4, { 5: 6 }), { 4: 7, 9: $V0, 10: $V1, 12: $V2 }, { 4: 8, 9: $V0, 10: $V1, 12: $V2 }, { 13: [1, 9], 14: [1, 10] }, { 1: [2, 1], 6: 11, 7: 12, 8: $V5, 9: $V6, 10: $V7, 11: $V8, 20: 17, 22: 18, 23: 19, 24: 20, 25: 21, 26: 22, 27: $V9, 33: 24, 34: $Va, 36: $Vb, 38: $Vc, 42: 28, 43: 39, 44: $Vd, 45: 40, 47: 41, 60: $Ve, 84: $Vf, 85: $Vg, 86: $Vh, 87: $Vi, 88: $Vj, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs, 121: $Vt, 122: $Vu, 123: $Vv, 124: $Vw, 125: $Vx }, o($V3, [2, 9]), o($V3, [2, 10]), o($V3, [2, 11]), { 8: [1, 55], 9: [1, 56], 10: $Vy, 15: 54, 18: 57 }, o($Vz, [2, 3]), o($Vz, [2, 4]), o($Vz, [2, 5]), o($Vz, [2, 6]), o($Vz, [2, 7]), o($Vz, [2, 8]), { 8: $VA, 9: $VB, 11: $VC, 21: 59, 41: 60, 72: 64, 75: [1, 65], 77: [1, 67], 78: [1, 66] }, { 8: $VA, 9: $VB, 11: $VC, 21: 68 }, { 8: $VA, 9: $VB, 11: $VC, 21: 69 }, { 8: $VA, 9: $VB, 11: $VC, 21: 70 }, { 8: $VA, 9: $VB, 11: $VC, 21: 71 }, { 8: $VA, 9: $VB, 11: $VC, 21: 72 }, { 8: $VA, 9: $VB, 10: [1, 73], 11: $VC, 21: 74 }, o($Vz, [2, 36]), { 35: [1, 75] }, { 37: [1, 76] }, o($Vz, [2, 39]), o($VD, [2, 50], { 18: 77, 39: 78, 10: $Vy, 40: $VE }), { 10: [1, 80] }, { 10: [1, 81] }, { 10: [1, 82] }, { 10: [1, 83] }, { 14: $VF, 44: $VG, 60: $VH, 80: [1, 87], 89: $VI, 95: [1, 84], 97: [1, 85], 101: 86, 105: $VJ, 106: $VK, 109: $VL, 111: $VM, 114: $VN, 115: $VO, 116: $VP, 120: 88 }, o($Vz, [2, 185]), o($Vz, [2, 186]), o($Vz, [2, 187]), o($Vz, [2, 188]), o($Vz, [2, 189]), o($VQ, [2, 51]), o($VQ, [2, 54], { 46: [1, 100] }), o($VR, [2, 72], { 113: 113, 29: [1, 101], 44: $Vd, 48: [1, 102], 50: [1, 103], 52: [1, 104], 54: [1, 105], 56: [1, 106], 58: [1, 107], 60: $Ve, 63: [1, 108], 65: [1, 109], 67: [1, 110], 68: [1, 111], 70: [1, 112], 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 114: $Vq, 115: $Vr, 116: $Vs }), o($VS, [2, 181]), o($VS, [2, 142]), o($VS, [2, 143]), o($VS, [2, 144]), o($VS, [2, 145]), o($VS, [2, 146]), o($VS, [2, 147]), o($VS, [2, 148]), o($VS, [2, 149]), o($VS, [2, 150]), o($VS, [2, 151]), o($VS, [2, 152]), o($V3, [2, 12]), o($V3, [2, 18]), o($V3, [2, 19]), { 9: [1, 114] }, o($VT, [2, 26], { 18: 115, 10: $Vy }), o($Vz, [2, 27]), { 42: 116, 43: 39, 44: $Vd, 45: 40, 47: 41, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, o($Vz, [2, 40]), o($Vz, [2, 41]), o($Vz, [2, 42]), o($VU, [2, 76], { 73: 117, 62: [1, 119], 74: [1, 118] }), { 76: 120, 79: 121, 80: $VV, 81: $VW, 116: $VX, 119: $VY }, { 75: [1, 126], 77: [1, 127] }, o($VZ, [2, 83]), o($Vz, [2, 28]), o($Vz, [2, 29]), o($Vz, [2, 30]), o($Vz, [2, 31]), o($Vz, [2, 32]), { 10: $V_, 12: $V$, 14: $V01, 27: $V11, 28: 128, 32: $V21, 44: $V31, 60: $V41, 75: $V51, 80: [1, 130], 81: [1, 131], 83: 141, 84: $V61, 85: $V71, 86: $V81, 87: $V91, 88: $Va1, 89: $Vb1, 90: $Vc1, 91: 129, 105: $Vd1, 109: $Ve1, 111: $Vf1, 114: $Vg1, 115: $Vh1, 116: $Vi1 }, o($Vj1, $V4, { 5: 154 }), o($Vz, [2, 37]), o($Vz, [2, 38]), o($VD, [2, 48], { 44: $Vk1 }), o($VD, [2, 49], { 18: 156, 10: $Vy, 40: $Vl1 }), o($VQ, [2, 44]), { 44: $Vd, 47: 158, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, { 102: [1, 159], 103: 160, 105: [1, 161] }, { 44: $Vd, 47: 162, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, { 44: $Vd, 47: 163, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, o($Vm1, [2, 107], { 10: [1, 164], 96: [1, 165] }), { 80: [1, 166] }, o($Vm1, [2, 115], { 120: 168, 10: [1, 167], 14: $VF, 44: $VG, 60: $VH, 89: $VI, 105: $VJ, 106: $VK, 109: $VL, 111: $VM, 114: $VN, 115: $VO, 116: $VP }), o($Vm1, [2, 117], { 10: [1, 169] }), o($Vn1, [2, 183]), o($Vn1, [2, 170]), o($Vn1, [2, 171]), o($Vn1, [2, 172]), o($Vn1, [2, 173]), o($Vn1, [2, 174]), o($Vn1, [2, 175]), o($Vn1, [2, 176]), o($Vn1, [2, 177]), o($Vn1, [2, 178]), o($Vn1, [2, 179]), o($Vn1, [2, 180]), { 44: $Vd, 47: 170, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, { 30: 171, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 179, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 181, 50: [1, 180], 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 182, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 183, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 184, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 109: [1, 185] }, { 30: 186, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 187, 65: [1, 188], 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 189, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 190, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 191, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($VS, [2, 182]), o($V3, [2, 20]), o($VT, [2, 25]), o($VD, [2, 46], { 39: 192, 18: 193, 10: $Vy, 40: $VE }), o($VU, [2, 73], { 10: [1, 194] }), { 10: [1, 195] }, { 30: 196, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 77: [1, 197], 79: 198, 116: $VX, 119: $VY }, o($Vu1, [2, 79]), o($Vu1, [2, 81]), o($Vu1, [2, 82]), o($Vu1, [2, 168]), o($Vu1, [2, 169]), { 76: 199, 79: 121, 80: $VV, 81: $VW, 116: $VX, 119: $VY }, o($VZ, [2, 84]), { 8: $VA, 9: $VB, 10: $V_, 11: $VC, 12: $V$, 14: $V01, 21: 201, 27: $V11, 29: [1, 200], 32: $V21, 44: $V31, 60: $V41, 75: $V51, 83: 141, 84: $V61, 85: $V71, 86: $V81, 87: $V91, 88: $Va1, 89: $Vb1, 90: $Vc1, 91: 202, 105: $Vd1, 109: $Ve1, 111: $Vf1, 114: $Vg1, 115: $Vh1, 116: $Vi1 }, o($Vv1, [2, 101]), o($Vv1, [2, 103]), o($Vv1, [2, 104]), o($Vv1, [2, 157]), o($Vv1, [2, 158]), o($Vv1, [2, 159]), o($Vv1, [2, 160]), o($Vv1, [2, 161]), o($Vv1, [2, 162]), o($Vv1, [2, 163]), o($Vv1, [2, 164]), o($Vv1, [2, 165]), o($Vv1, [2, 166]), o($Vv1, [2, 167]), o($Vv1, [2, 90]), o($Vv1, [2, 91]), o($Vv1, [2, 92]), o($Vv1, [2, 93]), o($Vv1, [2, 94]), o($Vv1, [2, 95]), o($Vv1, [2, 96]), o($Vv1, [2, 97]), o($Vv1, [2, 98]), o($Vv1, [2, 99]), o($Vv1, [2, 100]), { 6: 11, 7: 12, 8: $V5, 9: $V6, 10: $V7, 11: $V8, 20: 17, 22: 18, 23: 19, 24: 20, 25: 21, 26: 22, 27: $V9, 32: [1, 203], 33: 24, 34: $Va, 36: $Vb, 38: $Vc, 42: 28, 43: 39, 44: $Vd, 45: 40, 47: 41, 60: $Ve, 84: $Vf, 85: $Vg, 86: $Vh, 87: $Vi, 88: $Vj, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs, 121: $Vt, 122: $Vu, 123: $Vv, 124: $Vw, 125: $Vx }, { 10: $Vy, 18: 204 }, { 44: [1, 205] }, o($VQ, [2, 43]), { 10: [1, 206], 44: $Vd, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 113, 114: $Vq, 115: $Vr, 116: $Vs }, { 10: [1, 207] }, { 10: [1, 208], 106: [1, 209] }, o($Vw1, [2, 128]), { 10: [1, 210], 44: $Vd, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 113, 114: $Vq, 115: $Vr, 116: $Vs }, { 10: [1, 211], 44: $Vd, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 113, 114: $Vq, 115: $Vr, 116: $Vs }, { 80: [1, 212] }, o($Vm1, [2, 109], { 10: [1, 213] }), o($Vm1, [2, 111], { 10: [1, 214] }), { 80: [1, 215] }, o($Vn1, [2, 184]), { 80: [1, 216], 98: [1, 217] }, o($VQ, [2, 55], { 113: 113, 44: $Vd, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 114: $Vq, 115: $Vr, 116: $Vs }), { 31: [1, 218], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($Vx1, [2, 86]), o($Vx1, [2, 88]), o($Vx1, [2, 89]), o($Vx1, [2, 153]), o($Vx1, [2, 154]), o($Vx1, [2, 155]), o($Vx1, [2, 156]), { 49: [1, 220], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 221, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 51: [1, 222], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 53: [1, 223], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 55: [1, 224], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 57: [1, 225], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 60: [1, 226] }, { 64: [1, 227], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 66: [1, 228], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 30: 229, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 31: [1, 230], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 67: $Vo1, 69: [1, 231], 71: [1, 232], 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 67: $Vo1, 69: [1, 234], 71: [1, 233], 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($VD, [2, 45], { 18: 156, 10: $Vy, 40: $Vl1 }), o($VD, [2, 47], { 44: $Vk1 }), o($VU, [2, 75]), o($VU, [2, 74]), { 62: [1, 235], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($VU, [2, 77]), o($Vu1, [2, 80]), { 77: [1, 236], 79: 198, 116: $VX, 119: $VY }, { 30: 237, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($Vj1, $V4, { 5: 238 }), o($Vv1, [2, 102]), o($Vz, [2, 35]), { 43: 239, 44: $Vd, 45: 40, 47: 41, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, { 10: $Vy, 18: 240 }, { 10: $Vy1, 60: $Vz1, 84: $VA1, 92: 241, 105: $VB1, 107: 242, 108: 243, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }, { 10: $Vy1, 60: $Vz1, 84: $VA1, 92: 252, 104: [1, 253], 105: $VB1, 107: 242, 108: 243, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }, { 10: $Vy1, 60: $Vz1, 84: $VA1, 92: 254, 104: [1, 255], 105: $VB1, 107: 242, 108: 243, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }, { 105: [1, 256] }, { 10: $Vy1, 60: $Vz1, 84: $VA1, 92: 257, 105: $VB1, 107: 242, 108: 243, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }, { 44: $Vd, 47: 258, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, o($Vm1, [2, 108]), { 80: [1, 259] }, { 80: [1, 260], 98: [1, 261] }, o($Vm1, [2, 116]), o($Vm1, [2, 118], { 10: [1, 262] }), o($Vm1, [2, 119]), o($VR, [2, 56]), o($Vx1, [2, 87]), o($VR, [2, 57]), { 51: [1, 263], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($VR, [2, 64]), o($VR, [2, 59]), o($VR, [2, 60]), o($VR, [2, 61]), { 109: [1, 264] }, o($VR, [2, 63]), o($VR, [2, 65]), { 66: [1, 265], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($VR, [2, 67]), o($VR, [2, 68]), o($VR, [2, 70]), o($VR, [2, 69]), o($VR, [2, 71]), o([10, 44, 60, 89, 102, 105, 106, 109, 111, 114, 115, 116], [2, 85]), o($VU, [2, 78]), { 31: [1, 266], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 6: 11, 7: 12, 8: $V5, 9: $V6, 10: $V7, 11: $V8, 20: 17, 22: 18, 23: 19, 24: 20, 25: 21, 26: 22, 27: $V9, 32: [1, 267], 33: 24, 34: $Va, 36: $Vb, 38: $Vc, 42: 28, 43: 39, 44: $Vd, 45: 40, 47: 41, 60: $Ve, 84: $Vf, 85: $Vg, 86: $Vh, 87: $Vi, 88: $Vj, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs, 121: $Vt, 122: $Vu, 123: $Vv, 124: $Vw, 125: $Vx }, o($VQ, [2, 53]), { 43: 268, 44: $Vd, 45: 40, 47: 41, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs }, o($Vm1, [2, 121], { 106: $VG1 }), o($VH1, [2, 130], { 108: 270, 10: $Vy1, 60: $Vz1, 84: $VA1, 105: $VB1, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }), o($VI1, [2, 132]), o($VI1, [2, 134]), o($VI1, [2, 135]), o($VI1, [2, 136]), o($VI1, [2, 137]), o($VI1, [2, 138]), o($VI1, [2, 139]), o($VI1, [2, 140]), o($VI1, [2, 141]), o($Vm1, [2, 122], { 106: $VG1 }), { 10: [1, 271] }, o($Vm1, [2, 123], { 106: $VG1 }), { 10: [1, 272] }, o($Vw1, [2, 129]), o($Vm1, [2, 105], { 106: $VG1 }), o($Vm1, [2, 106], { 113: 113, 44: $Vd, 60: $Ve, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 114: $Vq, 115: $Vr, 116: $Vs }), o($Vm1, [2, 110]), o($Vm1, [2, 112], { 10: [1, 273] }), o($Vm1, [2, 113]), { 98: [1, 274] }, { 51: [1, 275] }, { 62: [1, 276] }, { 66: [1, 277] }, { 8: $VA, 9: $VB, 11: $VC, 21: 278 }, o($Vz, [2, 34]), o($VQ, [2, 52]), { 10: $Vy1, 60: $Vz1, 84: $VA1, 105: $VB1, 107: 279, 108: 243, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }, o($VI1, [2, 133]), { 14: $VF, 44: $VG, 60: $VH, 89: $VI, 101: 280, 105: $VJ, 106: $VK, 109: $VL, 111: $VM, 114: $VN, 115: $VO, 116: $VP, 120: 88 }, { 14: $VF, 44: $VG, 60: $VH, 89: $VI, 101: 281, 105: $VJ, 106: $VK, 109: $VL, 111: $VM, 114: $VN, 115: $VO, 116: $VP, 120: 88 }, { 98: [1, 282] }, o($Vm1, [2, 120]), o($VR, [2, 58]), { 30: 283, 67: $Vo1, 80: $Vp1, 81: $Vq1, 82: 172, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, o($VR, [2, 66]), o($Vj1, $V4, { 5: 284 }), o($VH1, [2, 131], { 108: 270, 10: $Vy1, 60: $Vz1, 84: $VA1, 105: $VB1, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }), o($Vm1, [2, 126], { 120: 168, 10: [1, 285], 14: $VF, 44: $VG, 60: $VH, 89: $VI, 105: $VJ, 106: $VK, 109: $VL, 111: $VM, 114: $VN, 115: $VO, 116: $VP }), o($Vm1, [2, 127], { 120: 168, 10: [1, 286], 14: $VF, 44: $VG, 60: $VH, 89: $VI, 105: $VJ, 106: $VK, 109: $VL, 111: $VM, 114: $VN, 115: $VO, 116: $VP }), o($Vm1, [2, 114]), { 31: [1, 287], 67: $Vo1, 82: 219, 116: $Vr1, 117: $Vs1, 118: $Vt1 }, { 6: 11, 7: 12, 8: $V5, 9: $V6, 10: $V7, 11: $V8, 20: 17, 22: 18, 23: 19, 24: 20, 25: 21, 26: 22, 27: $V9, 32: [1, 288], 33: 24, 34: $Va, 36: $Vb, 38: $Vc, 42: 28, 43: 39, 44: $Vd, 45: 40, 47: 41, 60: $Ve, 84: $Vf, 85: $Vg, 86: $Vh, 87: $Vi, 88: $Vj, 89: $Vk, 102: $Vl, 105: $Vm, 106: $Vn, 109: $Vo, 111: $Vp, 113: 42, 114: $Vq, 115: $Vr, 116: $Vs, 121: $Vt, 122: $Vu, 123: $Vv, 124: $Vw, 125: $Vx }, { 10: $Vy1, 60: $Vz1, 84: $VA1, 92: 289, 105: $VB1, 107: 242, 108: 243, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }, { 10: $Vy1, 60: $Vz1, 84: $VA1, 92: 290, 105: $VB1, 107: 242, 108: 243, 109: $VC1, 110: $VD1, 111: $VE1, 112: $VF1 }, o($VR, [2, 62]), o($Vz, [2, 33]), o($Vm1, [2, 124], { 106: $VG1 }), o($Vm1, [2, 125], { 106: $VG1 })],
+    defaultActions: {},
+    parseError: function parseError(str, hash) {
+      if (hash.recoverable) {
+        this.trace(str);
+      } else {
+        var error = new Error(str);
+        error.hash = hash;
+        throw error;
+      }
+    },
+    parse: function parse2(input) {
+      var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+      var args = lstack.slice.call(arguments, 1);
+      var lexer2 = Object.create(this.lexer);
+      var sharedState = { yy: {} };
+      for (var k in this.yy) {
+        if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
+          sharedState.yy[k] = this.yy[k];
+        }
+      }
+      lexer2.setInput(input, sharedState.yy);
+      sharedState.yy.lexer = lexer2;
+      sharedState.yy.parser = this;
+      if (typeof lexer2.yylloc == "undefined") {
+        lexer2.yylloc = {};
+      }
+      var yyloc = lexer2.yylloc;
+      lstack.push(yyloc);
+      var ranges = lexer2.options && lexer2.options.ranges;
+      if (typeof sharedState.yy.parseError === "function") {
+        this.parseError = sharedState.yy.parseError;
+      } else {
+        this.parseError = Object.getPrototypeOf(this).parseError;
+      }
+      function popStack(n) {
+        stack.length = stack.length - 2 * n;
+        vstack.length = vstack.length - n;
+        lstack.length = lstack.length - n;
+      }
+      _token_stack:
+        var lex = function() {
+          var token;
+          token = lexer2.lex() || EOF;
+          if (typeof token !== "number") {
+            token = self.symbols_[token] || token;
+          }
+          return token;
+        };
+      var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
+      while (true) {
+        state = stack[stack.length - 1];
+        if (this.defaultActions[state]) {
+          action = this.defaultActions[state];
+        } else {
+          if (symbol === null || typeof symbol == "undefined") {
+            symbol = lex();
+          }
+          action = table[state] && table[state][symbol];
+        }
+        if (typeof action === "undefined" || !action.length || !action[0]) {
+          var errStr = "";
+          expected = [];
+          for (p in table[state]) {
+            if (this.terminals_[p] && p > TERROR) {
+              expected.push("'" + this.terminals_[p] + "'");
+            }
+          }
+          if (lexer2.showPosition) {
+            errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer2.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
+          } else {
+            errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'");
+          }
+          this.parseError(errStr, {
+            text: lexer2.match,
+            token: this.terminals_[symbol] || symbol,
+            line: lexer2.yylineno,
+            loc: yyloc,
+            expected
+          });
+        }
+        if (action[0] instanceof Array && action.length > 1) {
+          throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
+        }
+        switch (action[0]) {
+          case 1:
+            stack.push(symbol);
+            vstack.push(lexer2.yytext);
+            lstack.push(lexer2.yylloc);
+            stack.push(action[1]);
+            symbol = null;
+            if (!preErrorSymbol) {
+              yyleng = lexer2.yyleng;
+              yytext = lexer2.yytext;
+              yylineno = lexer2.yylineno;
+              yyloc = lexer2.yylloc;
+              if (recovering > 0) {
+                recovering--;
+              }
+            } else {
+              symbol = preErrorSymbol;
+              preErrorSymbol = null;
+            }
+            break;
+          case 2:
+            len = this.productions_[action[1]][1];
+            yyval.$ = vstack[vstack.length - len];
+            yyval._$ = {
+              first_line: lstack[lstack.length - (len || 1)].first_line,
+              last_line: lstack[lstack.length - 1].last_line,
+              first_column: lstack[lstack.length - (len || 1)].first_column,
+              last_column: lstack[lstack.length - 1].last_column
+            };
+            if (ranges) {
+              yyval._$.range = [
+                lstack[lstack.length - (len || 1)].range[0],
+                lstack[lstack.length - 1].range[1]
+              ];
+            }
+            r = this.performAction.apply(yyval, [
+              yytext,
+              yyleng,
+              yylineno,
+              sharedState.yy,
+              action[1],
+              vstack,
+              lstack
+            ].concat(args));
+            if (typeof r !== "undefined") {
+              return r;
+            }
+            if (len) {
+              stack = stack.slice(0, -1 * len * 2);
+              vstack = vstack.slice(0, -1 * len);
+              lstack = lstack.slice(0, -1 * len);
+            }
+            stack.push(this.productions_[action[1]][0]);
+            vstack.push(yyval.$);
+            lstack.push(yyval._$);
+            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+            stack.push(newState);
+            break;
+          case 3:
+            return true;
+        }
+      }
+      return true;
+    }
+  };
+  var lexer = /* @__PURE__ */ (function() {
+    var lexer2 = {
+      EOF: 1,
+      parseError: function parseError(str, hash) {
+        if (this.yy.parser) {
+          this.yy.parser.parseError(str, hash);
+        } else {
+          throw new Error(str);
+        }
+      },
+      // resets the lexer, sets new input
+      setInput: function(input, yy) {
+        this.yy = yy || this.yy || {};
+        this._input = input;
+        this._more = this._backtrack = this.done = false;
+        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
+        };
+        if (this.options.ranges) {
+          this.yylloc.range = [0, 0];
+        }
+        this.offset = 0;
+        return this;
+      },
+      // consumes and returns one char from the input
+      input: function() {
+        var ch = this._input[0];
+        this.yytext += ch;
+        this.yyleng++;
+        this.offset++;
+        this.match += ch;
+        this.matched += ch;
+        var lines = ch.match(/(?:\r\n?|\n).*/g);
+        if (lines) {
+          this.yylineno++;
+          this.yylloc.last_line++;
+        } else {
+          this.yylloc.last_column++;
+        }
+        if (this.options.ranges) {
+          this.yylloc.range[1]++;
+        }
+        this._input = this._input.slice(1);
+        return ch;
+      },
+      // unshifts one char (or a string) into the input
+      unput: function(ch) {
+        var len = ch.length;
+        var lines = ch.split(/(?:\r\n?|\n)/g);
+        this._input = ch + this._input;
+        this.yytext = this.yytext.substr(0, this.yytext.length - len);
+        this.offset -= len;
+        var oldLines = 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);
+        if (lines.length - 1) {
+          this.yylineno -= lines.length - 1;
+        }
+        var r = this.yylloc.range;
+        this.yylloc = {
+          first_line: this.yylloc.first_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.first_column,
+          last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len
+        };
+        if (this.options.ranges) {
+          this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+        }
+        this.yyleng = this.yytext.length;
+        return this;
+      },
+      // When called from action, caches matched text and appends it on next action
+      more: function() {
+        this._more = true;
+        return this;
+      },
+      // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
+      reject: function() {
+        if (this.options.backtrack_lexer) {
+          this._backtrack = true;
+        } 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).\n" + this.showPosition(), {
+            text: "",
+            token: null,
+            line: this.yylineno
+          });
+        }
+        return this;
+      },
+      // retain first n characters of the match
+      less: function(n) {
+        this.unput(this.match.slice(n));
+      },
+      // displays already matched input, i.e. for error messages
+      pastInput: function() {
+        var past = this.matched.substr(0, this.matched.length - this.match.length);
+        return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
+      },
+      // displays upcoming input, i.e. for error messages
+      upcomingInput: function() {
+        var next = this.match;
+        if (next.length < 20) {
+          next += this._input.substr(0, 20 - next.length);
+        }
+        return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
+      },
+      // displays the character position where the lexing error occurred, i.e. for error messages
+      showPosition: function() {
+        var pre = this.pastInput();
+        var c = new Array(pre.length + 1).join("-");
+        return pre + this.upcomingInput() + "\n" + c + "^";
+      },
+      // test the lexed token: return FALSE when not a match, otherwise return token
+      test_match: function(match, indexed_rule) {
+        var token, lines, backup;
+        if (this.options.backtrack_lexer) {
+          backup = {
+            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
+          };
+          if (this.options.ranges) {
+            backup.yylloc.range = this.yylloc.range.slice(0);
+          }
+        }
+        lines = match[0].match(/(?:\r\n?|\n).*/g);
+        if (lines) {
+          this.yylineno += lines.length;
+        }
+        this.yylloc = {
+          first_line: this.yylloc.last_line,
+          last_line: this.yylineno + 1,
+          first_column: this.yylloc.last_column,
+          last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length
+        };
+        this.yytext += match[0];
+        this.match += match[0];
+        this.matches = match;
+        this.yyleng = this.yytext.length;
+        if (this.options.ranges) {
+          this.yylloc.range = [this.offset, this.offset += this.yyleng];
+        }
+        this._more = false;
+        this._backtrack = false;
+        this._input = this._input.slice(match[0].length);
+        this.matched += match[0];
+        token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
+        if (this.done && this._input) {
+          this.done = false;
+        }
+        if (token) {
+          return token;
+        } else if (this._backtrack) {
+          for (var k in backup) {
+            this[k] = backup[k];
+          }
+          return false;
+        }
+        return false;
+      },
+      // return next match in input
+      next: function() {
+        if (this.done) {
+          return this.EOF;
+        }
+        if (!this._input) {
+          this.done = true;
+        }
+        var token, match, tempMatch, index;
+        if (!this._more) {
+          this.yytext = "";
+          this.match = "";
+        }
+        var rules = this._currentRules();
+        for (var i = 0; i < rules.length; i++) {
+          tempMatch = this._input.match(this.rules[rules[i]]);
+          if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+            match = tempMatch;
+            index = i;
+            if (this.options.backtrack_lexer) {
+              token = this.test_match(tempMatch, rules[i]);
+              if (token !== false) {
+                return token;
+              } else if (this._backtrack) {
+                match = false;
+                continue;
+              } else {
+                return false;
+              }
+            } else if (!this.options.flex) {
+              break;
+            }
+          }
+        }
+        if (match) {
+          token = this.test_match(match, rules[index]);
+          if (token !== false) {
+            return token;
+          }
+          return false;
+        }
+        if (this._input === "") {
+          return this.EOF;
+        } else {
+          return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), {
+            text: "",
+            token: null,
+            line: this.yylineno
+          });
+        }
+      },
+      // return next match that has a token
+      lex: function lex() {
+        var r = this.next();
+        if (r) {
+          return r;
+        } else {
+          return this.lex();
+        }
+      },
+      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+      begin: function begin(condition) {
+        this.conditionStack.push(condition);
+      },
+      // pop the previously active lexer condition state off the condition stack
+      popState: function popState() {
+        var n = this.conditionStack.length - 1;
+        if (n > 0) {
+          return this.conditionStack.pop();
+        } else {
+          return this.conditionStack[0];
+        }
+      },
+      // produce the lexer rule set which is active for the currently active lexer condition state
+      _currentRules: function _currentRules() {
+        if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
+          return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
+        } else {
+          return this.conditions["INITIAL"].rules;
+        }
+      },
+      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+      topState: function topState(n) {
+        n = this.conditionStack.length - 1 - Math.abs(n || 0);
+        if (n >= 0) {
+          return this.conditionStack[n];
+        } else {
+          return "INITIAL";
+        }
+      },
+      // alias for begin(condition)
+      pushState: function pushState(condition) {
+        this.begin(condition);
+      },
+      // return the number of states currently on the stack
+      stateStackSize: function stateStackSize() {
+        return this.conditionStack.length;
+      },
+      options: {},
+      performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
+        var YYSTATE = YY_START;
+        switch ($avoiding_name_collisions) {
+          case 0:
+            this.begin("acc_title");
+            return 34;
+            break;
+          case 1:
+            this.popState();
+            return "acc_title_value";
+            break;
+          case 2:
+            this.begin("acc_descr");
+            return 36;
+            break;
+          case 3:
+            this.popState();
+            return "acc_descr_value";
+            break;
+          case 4:
+            this.begin("acc_descr_multiline");
+            break;
+          case 5:
+            this.popState();
+            break;
+          case 6:
+            return "acc_descr_multiline_value";
+            break;
+          case 7:
+            this.pushState("shapeData");
+            yy_.yytext = "";
+            return 40;
+            break;
+          case 8:
+            this.pushState("shapeDataStr");
+            return 40;
+            break;
+          case 9:
+            this.popState();
+            return 40;
+            break;
+          case 10:
+            const re = /\n\s*/g;
+            yy_.yytext = yy_.yytext.replace(re, "<br/>");
+            return 40;
+            break;
+          case 11:
+            return 40;
+            break;
+          case 12:
+            this.popState();
+            break;
+          case 13:
+            this.begin("callbackname");
+            break;
+          case 14:
+            this.popState();
+            break;
+          case 15:
+            this.popState();
+            this.begin("callbackargs");
+            break;
+          case 16:
+            return 95;
+            break;
+          case 17:
+            this.popState();
+            break;
+          case 18:
+            return 96;
+            break;
+          case 19:
+            return "MD_STR";
+            break;
+          case 20:
+            this.popState();
+            break;
+          case 21:
+            this.begin("md_string");
+            break;
+          case 22:
+            return "STR";
+            break;
+          case 23:
+            this.popState();
+            break;
+          case 24:
+            this.pushState("string");
+            break;
+          case 25:
+            return 84;
+            break;
+          case 26:
+            return 102;
+            break;
+          case 27:
+            return 85;
+            break;
+          case 28:
+            return 104;
+            break;
+          case 29:
+            return 86;
+            break;
+          case 30:
+            return 87;
+            break;
+          case 31:
+            return 97;
+            break;
+          case 32:
+            this.begin("click");
+            break;
+          case 33:
+            this.popState();
+            break;
+          case 34:
+            return 88;
+            break;
+          case 35:
+            if (yy.lex.firstGraph()) {
+              this.begin("dir");
+            }
+            return 12;
+            break;
+          case 36:
+            if (yy.lex.firstGraph()) {
+              this.begin("dir");
+            }
+            return 12;
+            break;
+          case 37:
+            if (yy.lex.firstGraph()) {
+              this.begin("dir");
+            }
+            return 12;
+            break;
+          case 38:
+            if (yy.lex.firstGraph()) {
+              this.begin("dir");
+            }
+            return 12;
+            break;
+          case 39:
+            return 27;
+            break;
+          case 40:
+            return 32;
+            break;
+          case 41:
+            return 98;
+            break;
+          case 42:
+            return 98;
+            break;
+          case 43:
+            return 98;
+            break;
+          case 44:
+            return 98;
+            break;
+          case 45:
+            this.popState();
+            return 13;
+            break;
+          case 46:
+            this.popState();
+            return 14;
+            break;
+          case 47:
+            this.popState();
+            return 14;
+            break;
+          case 48:
+            this.popState();
+            return 14;
+            break;
+          case 49:
+            this.popState();
+            return 14;
+            break;
+          case 50:
+            this.popState();
+            return 14;
+            break;
+          case 51:
+            this.popState();
+            return 14;
+            break;
+          case 52:
+            this.popState();
+            return 14;
+            break;
+          case 53:
+            this.popState();
+            return 14;
+            break;
+          case 54:
+            this.popState();
+            return 14;
+            break;
+          case 55:
+            this.popState();
+            return 14;
+            break;
+          case 56:
+            return 121;
+            break;
+          case 57:
+            return 122;
+            break;
+          case 58:
+            return 123;
+            break;
+          case 59:
+            return 124;
+            break;
+          case 60:
+            return 125;
+            break;
+          case 61:
+            return 78;
+            break;
+          case 62:
+            return 105;
+            break;
+          case 63:
+            return 111;
+            break;
+          case 64:
+            return 46;
+            break;
+          case 65:
+            return 60;
+            break;
+          case 66:
+            return 44;
+            break;
+          case 67:
+            return 8;
+            break;
+          case 68:
+            return 106;
+            break;
+          case 69:
+            return 115;
+            break;
+          case 70:
+            this.popState();
+            return 77;
+            break;
+          case 71:
+            this.pushState("edgeText");
+            return 75;
+            break;
+          case 72:
+            return 119;
+            break;
+          case 73:
+            this.popState();
+            return 77;
+            break;
+          case 74:
+            this.pushState("thickEdgeText");
+            return 75;
+            break;
+          case 75:
+            return 119;
+            break;
+          case 76:
+            this.popState();
+            return 77;
+            break;
+          case 77:
+            this.pushState("dottedEdgeText");
+            return 75;
+            break;
+          case 78:
+            return 119;
+            break;
+          case 79:
+            return 77;
+            break;
+          case 80:
+            this.popState();
+            return 53;
+            break;
+          case 81:
+            return "TEXT";
+            break;
+          case 82:
+            this.pushState("ellipseText");
+            return 52;
+            break;
+          case 83:
+            this.popState();
+            return 55;
+            break;
+          case 84:
+            this.pushState("text");
+            return 54;
+            break;
+          case 85:
+            this.popState();
+            return 57;
+            break;
+          case 86:
+            this.pushState("text");
+            return 56;
+            break;
+          case 87:
+            return 58;
+            break;
+          case 88:
+            this.pushState("text");
+            return 67;
+            break;
+          case 89:
+            this.popState();
+            return 64;
+            break;
+          case 90:
+            this.pushState("text");
+            return 63;
+            break;
+          case 91:
+            this.popState();
+            return 49;
+            break;
+          case 92:
+            this.pushState("text");
+            return 48;
+            break;
+          case 93:
+            this.popState();
+            return 69;
+            break;
+          case 94:
+            this.popState();
+            return 71;
+            break;
+          case 95:
+            return 117;
+            break;
+          case 96:
+            this.pushState("trapText");
+            return 68;
+            break;
+          case 97:
+            this.pushState("trapText");
+            return 70;
+            break;
+          case 98:
+            return 118;
+            break;
+          case 99:
+            return 67;
+            break;
+          case 100:
+            return 90;
+            break;
+          case 101:
+            return "SEP";
+            break;
+          case 102:
+            return 89;
+            break;
+          case 103:
+            return 115;
+            break;
+          case 104:
+            return 111;
+            break;
+          case 105:
+            return 44;
+            break;
+          case 106:
+            return 109;
+            break;
+          case 107:
+            return 114;
+            break;
+          case 108:
+            return 116;
+            break;
+          case 109:
+            this.popState();
+            return 62;
+            break;
+          case 110:
+            this.pushState("text");
+            return 62;
+            break;
+          case 111:
+            this.popState();
+            return 51;
+            break;
+          case 112:
+            this.pushState("text");
+            return 50;
+            break;
+          case 113:
+            this.popState();
+            return 31;
+            break;
+          case 114:
+            this.pushState("text");
+            return 29;
+            break;
+          case 115:
+            this.popState();
+            return 66;
+            break;
+          case 116:
+            this.pushState("text");
+            return 65;
+            break;
+          case 117:
+            return "TEXT";
+            break;
+          case 118:
+            return "QUOTE";
+            break;
+          case 119:
+            return 9;
+            break;
+          case 120:
+            return 10;
+            break;
+          case 121:
+            return 11;
+            break;
+        }
+      },
+      rules: [/^(?:accTitle\s*:\s*)/, /^(?:(?!\n||)*[^\n]*)/, /^(?:accDescr\s*:\s*)/, /^(?:(?!\n||)*[^\n]*)/, /^(?:accDescr\s*\{\s*)/, /^(?:[\}])/, /^(?:[^\}]*)/, /^(?:@\{)/, /^(?:["])/, /^(?:["])/, /^(?:[^\"]+)/, /^(?:[^}^"]+)/, /^(?:\})/, /^(?:call[\s]+)/, /^(?:\([\s]*\))/, /^(?:\()/, /^(?:[^(]*)/, /^(?:\))/, /^(?:[^)]*)/, /^(?:[^`"]+)/, /^(?:[`]["])/, /^(?:["][`])/, /^(?:[^"]+)/, /^(?:["])/, /^(?:["])/, /^(?:style\b)/, /^(?:default\b)/, /^(?:linkStyle\b)/, /^(?:interpolate\b)/, /^(?:classDef\b)/, /^(?:class\b)/, /^(?:href[\s])/, /^(?:click[\s]+)/, /^(?:[\s\n])/, /^(?:[^\s\n]*)/, /^(?:flowchart-elk\b)/, /^(?:swimlane-beta\b)/, /^(?:graph\b)/, /^(?:flowchart\b)/, /^(?:subgraph\b)/, /^(?:end\b\s*)/, /^(?:_self\b)/, /^(?:_blank\b)/, /^(?:_parent\b)/, /^(?:_top\b)/, /^(?:(\r?\n)*\s*\n)/, /^(?:\s*LR\b)/, /^(?:\s*RL\b)/, /^(?:\s*TB\b)/, /^(?:\s*BT\b)/, /^(?:\s*TD\b)/, /^(?:\s*BR\b)/, /^(?:\s*<)/, /^(?:\s*>)/, /^(?:\s*\^)/, /^(?:\s*v\b)/, /^(?:.*direction\s+TB[^\n]*)/, /^(?:.*direction\s+BT[^\n]*)/, /^(?:.*direction\s+RL[^\n]*)/, /^(?:.*direction\s+LR[^\n]*)/, /^(?:.*direction\s+TD[^\n]*)/, /^(?:[^\s\"]+@(?=[^\{\"]))/, /^(?:[0-9]+)/, /^(?:#)/, /^(?::::)/, /^(?::)/, /^(?:&)/, /^(?:;)/, /^(?:,)/, /^(?:\*)/, /^(?:\s*[xo<]?--+[-xo>]\s*)/, /^(?:\s*[xo<]?--\s*)/, /^(?:[^-]|-(?!-)+)/, /^(?:\s*[xo<]?==+[=xo>]\s*)/, /^(?:\s*[xo<]?==\s*)/, /^(?:[^=]|=(?!))/, /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/, /^(?:\s*[xo<]?-\.\s*)/, /^(?:[^\.]|\.(?!))/, /^(?:\s*~~[\~]+\s*)/, /^(?:[-/\)][\)])/, /^(?:[^\(\)\[\]\{\}]|!\)+)/, /^(?:\(-)/, /^(?:\]\))/, /^(?:\(\[)/, /^(?:\]\])/, /^(?:\[\[)/, /^(?:\[\|)/, /^(?:>)/, /^(?:\)\])/, /^(?:\[\()/, /^(?:\)\)\))/, /^(?:\(\(\()/, /^(?:[\\(?=\])][\]])/, /^(?:\/(?=\])\])/, /^(?:\/(?!\])|\\(?!\])|[^\\\[\]\(\)\{\}\/]+)/, /^(?:\[\/)/, /^(?:\[\\)/, /^(?:<)/, /^(?:>)/, /^(?:\^)/, /^(?:\\\|)/, /^(?:v\b)/, /^(?:\*)/, /^(?:#)/, /^(?:&)/, /^(?:([A-Za-z0-9!"\#$%&'*+\.`?\\_\/]|-(?=[^\>\-\.])|(?!))+)/, /^(?:-)/, /^(?:[\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6]|[\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377]|[\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5]|[\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA]|[\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE]|[\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA]|[\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0]|[\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977]|[\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2]|[\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A]|[\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39]|[\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8]|[\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C]|[\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C]|[\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99]|[\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0]|[\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D]|[\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3]|[\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10]|[\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1]|[\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81]|[\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3]|[\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6]|[\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A]|[\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081]|[\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D]|[\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0]|[\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310]|[\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C]|[\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711]|[\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7]|[\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C]|[\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16]|[\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF]|[\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC]|[\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D]|[\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D]|[\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3]|[\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F]|[\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128]|[\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184]|[\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3]|[\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6]|[\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE]|[\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C]|[\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D]|[\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC]|[\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B]|[\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788]|[\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805]|[\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB]|[\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28]|[\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5]|[\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4]|[\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E]|[\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D]|[\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36]|[\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D]|[\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC]|[\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF]|[\uFFD2-\uFFD7\uFFDA-\uFFDC])/, /^(?:\|)/, /^(?:\|)/, /^(?:\))/, /^(?:\()/, /^(?:\])/, /^(?:\[)/, /^(?:(\}))/, /^(?:\{)/, /^(?:[^\[\]\(\)\{\}\|\"]+)/, /^(?:")/, /^(?:(\r?\n)+)/, /^(?:[^\S\n\r]+)/, /^(?:$)/],
+      conditions: { "shapeDataEndBracket": { "rules": [21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "shapeDataStr": { "rules": [9, 10, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "shapeData": { "rules": [8, 11, 12, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "callbackargs": { "rules": [17, 18, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "callbackname": { "rules": [14, 15, 16, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "href": { "rules": [21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "click": { "rules": [21, 24, 33, 34, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "dottedEdgeText": { "rules": [21, 24, 76, 78, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "thickEdgeText": { "rules": [21, 24, 73, 75, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "edgeText": { "rules": [21, 24, 70, 72, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "trapText": { "rules": [21, 24, 79, 82, 84, 86, 90, 92, 93, 94, 95, 96, 97, 110, 112, 114, 116], "inclusive": false }, "ellipseText": { "rules": [21, 24, 79, 80, 81, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "text": { "rules": [21, 24, 79, 82, 83, 84, 85, 86, 89, 90, 91, 92, 96, 97, 109, 110, 111, 112, 113, 114, 115, 116, 117], "inclusive": false }, "vertex": { "rules": [21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "dir": { "rules": [21, 24, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "acc_descr_multiline": { "rules": [5, 6, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "acc_descr": { "rules": [3, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "acc_title": { "rules": [1, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "md_string": { "rules": [19, 20, 21, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "string": { "rules": [21, 22, 23, 24, 79, 82, 84, 86, 90, 92, 96, 97, 110, 112, 114, 116], "inclusive": false }, "INITIAL": { "rules": [0, 2, 4, 7, 13, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 73, 74, 76, 77, 79, 82, 84, 86, 87, 88, 90, 92, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 110, 112, 114, 116, 118, 119, 120, 121], "inclusive": true } }
+    };
+    return lexer2;
+  })();
+  parser2.lexer = lexer;
+  function Parser() {
+    this.yy = {};
+  }
+  Parser.prototype = parser2;
+  parser2.Parser = Parser;
+  return new Parser();
+})();
+var generatedParser = parser;
+var generated_default = generatedParser;
+
+// src/errors.js
+var FlowInkError = class extends Error {
+  /** @param {string} message @param {{code?:string,line?:number,column?:number,cause?:unknown}} [options] */
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "FlowInkError";
+    this.code = options.code ?? "FLOWINK_ERROR";
+    this.line = options.line;
+    this.column = options.column;
+  }
+};
+
+// src/parser/semantic.js
+import yaml from "js-yaml";
+var VALID_SHAPES = new Set(`join rounded state anchor db summary database start document event stop console process text circle rect display prepare squareRect choice note composite rectWithTitle labelRect block_arrow collapsedGroup iconSquare iconCircle icon iconRounded imageSquare kanbanItem proc rectangle roundedRect stadium terminal pill fr-rect subprocess subproc framed-rectangle subroutine cyl cylinder datastore data-store folder directory bucket browser person circ bang cloud diam decision diamond question hex hexagon lean-r lean-right in-out lean_right lean-l lean-left out-in lean_left trap-b priority trapezoid-bottom trapezoid trap-t manual trapezoid-top inv-trapezoid inv_trapezoid dbl-circ double-circle doublecircle notch-rect card notched-rectangle lin-rect lined-rectangle lined-process lin-proc shaded-process sm-circ small-circle stateStart fr-circ framed-circle stateEnd fork forkJoin hourglass collate brace comment brace-l brace-r braces bolt com-link lightning-bolt doc delay half-rounded-rectangle h-cyl das horizontal-cylinder lin-cyl disk lined-cylinder curv-trap curved-trapezoid div-rect div-proc divided-rectangle divided-process tri extract triangle win-pane internal-storage window-pane f-circ junction filled-circle notch-pent loop-limit notched-pentagon flip-tri manual-file flipped-triangle sl-rect manual-input sloped-rectangle docs documents st-doc stacked-document st-rect procs processes stacked-rectangle bow-rect stored-data bow-tie-rectangle cross-circ crossed-circle tag-doc tagged-document tag-rect tagged-rectangle tag-proc tagged-process flag paper-tape odd rect_left_inv_arrow lin-doc lined-document`.split(/\s+/));
+function textValue(value) {
+  if (value === void 0 || value === null) return "";
+  return typeof value === "object" && "text" in value ? String(value.text) : String(value);
+}
+function labelType(value) {
+  return value?.type === "markdown" || value?.type === "string" ? value.type : "text";
+}
+function parseShapeData(raw) {
+  const metadata = {};
+  if (!raw) return metadata;
+  const body = String(raw).trim();
+  const lines = body.split("\n");
+  const indents = lines.slice(1).filter((line) => line.trim()).map((line) => line.match(/^\s*/)[0].length);
+  const indent = indents.length ? Math.min(...indents) : 0;
+  const normalized = lines.map((line, index) => index === 0 ? line : line.slice(Math.min(indent, line.length))).join("\n");
+  try {
+    const parsed = yaml.load(normalized.includes("\n") ? normalized : `{${normalized}}`, { schema: yaml.JSON_SCHEMA });
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) Object.assign(metadata, parsed);
+  } catch (error) {
+    throw new FlowInkError(error?.message ?? "Invalid shape data.", { code: "SHAPE_DATA_ERROR", cause: error });
+  }
+  metadata.raw = body;
+  return metadata;
+}
+var FlowSemanticDB = class {
+  constructor(source) {
+    this.source = source;
+    this.direction = "TB";
+    this.vertices = /* @__PURE__ */ new Map();
+    this.edges = [];
+    this.classes = /* @__PURE__ */ new Map();
+    this.classTextStyles = /* @__PURE__ */ new Map();
+    this.subGraphs = [];
+    this.subGraphLookup = /* @__PURE__ */ new Map();
+    this.tooltips = /* @__PURE__ */ new Map();
+    this.interactions = /* @__PURE__ */ new Map();
+    this.defaultStyles = [];
+    this.defaultInterpolate = void 0;
+    this.vertexCounter = 0;
+    this.firstGraphFlag = true;
+    this.lex = { firstGraph: () => this.firstGraph() };
+    this.title = void 0;
+    this.description = void 0;
+    for (const name of [
+      "firstGraph",
+      "setDirection",
+      "addVertex",
+      "addSingleLink",
+      "addLink",
+      "destructLink",
+      "addSubGraph",
+      "addClass",
+      "setClass",
+      "updateLink",
+      "updateLinkInterpolate",
+      "setTooltip",
+      "setLink",
+      "setClickEvent",
+      "setAccTitle",
+      "setAccDescription"
+    ]) this[name] = this[name].bind(this);
+  }
+  firstGraph() {
+    if (this.firstGraphFlag) {
+      this.firstGraphFlag = false;
+      return true;
+    }
+    return false;
+  }
+  clear() {
+  }
+  setDirection(direction) {
+    const value = String(direction).trim();
+    this.direction = value === "TD" || value.includes("v") ? "TB" : value.includes(">") ? "LR" : value.includes("<") ? "RL" : value.includes("^") ? "BT" : value;
+  }
+  addVertex(id, textObj, type, styles, classes, dir, props, rawShapeData) {
+    if (!id || !String(id).trim()) return;
+    id = String(id);
+    const shapeData = rawShapeData !== void 0 ? parseShapeData(rawShapeData) : void 0;
+    const subGraph = this.subGraphLookup.get(id);
+    if (subGraph && shapeData) {
+      Object.assign(subGraph.metadata, shapeData);
+      return;
+    }
+    const edge = this.edges.find((item) => item.id === id.replace(/^@|@$/g, ""));
+    if (edge && rawShapeData !== void 0) {
+      const placeholder = this.vertices.get(id);
+      if (placeholder && placeholder.label === id && placeholder.shape === "rect" && !placeholder.styles.length && !placeholder.classes.length) this.vertices.delete(id);
+      Object.assign(edge.metadata, shapeData);
+      const shape = edge.metadata;
+      if (shape.animate !== void 0) edge.animate = Boolean(shape.animate);
+      if (shape.animation !== void 0) edge.animation = String(shape.animation);
+      if (shape.curve !== void 0) {
+        edge.curve = String(shape.curve);
+        edge.interpolate = String(shape.curve);
+        edge.metadata.interpolate = String(shape.curve);
+      }
+      return;
+    }
+    let vertex = this.vertices.get(id);
+    if (!vertex) {
+      vertex = { id, label: id, labelType: "text", shape: "rect", styles: [], classes: [], metadata: {} };
+      this.vertices.set(id, vertex);
+    }
+    this.vertexCounter += 1;
+    if (textObj !== void 0) {
+      vertex.label = textValue(textObj).trim().replace(/^"|"$/g, "");
+      vertex.labelType = labelType(textObj);
+    }
+    if (type) vertex.shape = type;
+    if (Array.isArray(styles)) vertex.styles.push(...styles);
+    if (Array.isArray(classes)) vertex.classes.push(...classes);
+    if (dir) vertex.direction = dir;
+    if (props && typeof props === "object") Object.assign(vertex.metadata, props);
+    if (rawShapeData !== void 0) Object.assign(vertex.metadata, shapeData);
+    if (rawShapeData !== void 0) {
+      const shapeData2 = vertex.metadata;
+      if (shapeData2.shape !== void 0) {
+        const shape = String(shapeData2.shape);
+        if (shape !== shape.toLowerCase() || shape.includes("_") || !VALID_SHAPES.has(shape)) {
+          throw new FlowInkError(`No such shape: ${shape}.`, { code: "INVALID_SHAPE" });
+        }
+        vertex.shape = shape;
+      }
+      if (shapeData2.label !== void 0) {
+        vertex.label = String(shapeData2.label);
+        vertex.labelType = shapeData2.labelType === void 0 ? "markdown" : labelType({ type: shapeData2.labelType });
+      } else if (shapeData2.labelType !== void 0) vertex.labelType = labelType({ type: shapeData2.labelType });
+      else if ((shapeData2.icon || shapeData2.img) && vertex.label === id) vertex.label = "";
+    }
+  }
+  addSingleLink(start, end, type = {}, id) {
+    const cleanId = id ? String(id).replace(/^@|@$/g, "") : void 0;
+    const existingUserId = cleanId && this.edges.find((item) => item.id === cleanId);
+    if (existingUserId && !existingUserId.isUserDefinedId) {
+      let replacement = `L${this.edges.length}`;
+      while (this.edges.some((item) => item.id === replacement) || replacement === cleanId) replacement = `L${Number(replacement.slice(1)) + 1}`;
+      existingUserId.id = replacement;
+    }
+    let generatedId = `L${this.edges.length}`;
+    while (this.edges.some((item) => item.id === generatedId) || generatedId === cleanId) {
+      generatedId = `L${Number(generatedId.slice(1)) + 1}`;
+    }
+    const useUserId = Boolean(cleanId && !this.edges.some((item) => item.id === cleanId));
+    const edge = {
+      id: useUserId ? cleanId : generatedId,
+      source: String(start),
+      target: String(end),
+      label: textValue(type.text),
+      labelType: labelType(type.text),
+      arrowStart: "none",
+      arrowEnd: "none",
+      stroke: type.stroke ?? "normal",
+      length: Math.min(type.length ?? 1, 10),
+      styles: [],
+      classes: [],
+      metadata: this.defaultInterpolate === void 0 ? {} : { interpolate: this.defaultInterpolate }
+    };
+    if (this.defaultInterpolate !== void 0) edge.interpolate = this.defaultInterpolate;
+    if (useUserId) edge.isUserDefinedId = true;
+    if (useUserId) edge.metadata.isUserDefinedId = true;
+    const map = {
+      arrow_open: ["none", "none"],
+      arrow_point: ["none", "point"],
+      arrow_circle: ["none", "circle"],
+      arrow_cross: ["none", "cross"],
+      double_arrow_point: ["point", "point"],
+      double_arrow_circle: ["circle", "circle"],
+      double_arrow_cross: ["cross", "cross"]
+    };
+    [edge.arrowStart, edge.arrowEnd] = map[type.type] ?? ["none", "none"];
+    this.edges.push(edge);
+  }
+  addLink(starts, ends, linkData = {}) {
+    const id = linkData?.id ? String(linkData.id).replace(/^@|@$/g, "") : void 0;
+    for (const start of starts) for (const end of ends) this.addSingleLink(start, end, linkData, start === starts.at(-1) && end === ends[0] ? id : void 0);
+  }
+  destructLink(value, startValue) {
+    const end = String(value).trim();
+    let type = end.endsWith(">") ? "arrow_point" : end.endsWith("o") ? "arrow_circle" : end.endsWith("x") ? "arrow_cross" : "arrow_open";
+    let line = end.slice(0, -1);
+    let stroke = "normal";
+    const startMarker = line[0];
+    const endMarker = end.at(-1);
+    if (!startValue && (startMarker === "<" && endMarker === ">" || startMarker === "o" && endMarker === "o" || startMarker === "x" && endMarker === "x")) {
+      type = `double_${type}`;
+      line = line.slice(1);
+    }
+    stroke = line.startsWith("=") ? "thick" : line.startsWith("~") ? "invisible" : line.includes(".") ? "dotted" : "normal";
+    let length = line.length - 1;
+    if (stroke === "dotted") length = (line.match(/\./g) || []).length;
+    if (startValue) {
+      const start = String(startValue).trim();
+      const startType = start[0] === "<" ? "arrow_point" : start[0] === "o" ? "arrow_circle" : start[0] === "x" ? "arrow_cross" : "arrow_open";
+      if (startType !== "arrow_open" && startType !== type) return { type: "INVALID", stroke: "INVALID" };
+      if (startType !== "arrow_open") type = `double_${type.replace("arrow_", "arrow_")}`;
+      if (type === "double_arrow_arrow_point") type = "double_arrow_point";
+    }
+    return { type, stroke, length };
+  }
+  addSubGraph(idObj, list, titleObj) {
+    const title = textValue(titleObj ?? idObj).trim();
+    const sameText = idObj && titleObj && idObj === titleObj;
+    const id = idObj?.text && (!sameText || !/\s/.test(idObj.text)) ? idObj.text.trim() : `subGraph${this.subGraphs.length}`;
+    const flat = (list ?? []).flat(Infinity);
+    const directions = flat.filter((item) => item?.stmt === "dir");
+    const direction = directions.at(-1)?.value;
+    const nodeIds = [...new Set(flat.flatMap((item) => {
+      if (typeof item === "string" && item.trim()) return [item];
+      if (item && typeof item === "object" && typeof item.id === "string") return [item.id];
+      return [];
+    }))];
+    const occupied = new Set(this.subGraphs.flatMap((group) => group.nodeIds));
+    const uniqueNodeIds = nodeIds.filter((nodeId) => !occupied.has(nodeId));
+    const subgraph = { id, label: title, nodeIds: uniqueNodeIds, ...direction ? { direction: direction === "TD" ? "TB" : direction } : {}, styles: [], classes: [], metadata: { labelType: labelType(titleObj ?? idObj) } };
+    this.subGraphs.push(subgraph);
+    this.subGraphLookup.set(id, subgraph);
+    for (const nodeId of nodeIds) {
+      const node = this.vertices.get(nodeId);
+      if (node && !node.parentId) node.parentId = id;
+      const child = this.subGraphLookup.get(nodeId);
+      if (child && !child.parentId) child.parentId = id;
+    }
+    return subgraph;
+  }
+  addClass(ids, styles) {
+    const values = String(styles?.join?.() ?? styles ?? "").replace(/\\,/g, "\xA7\xA7\xA7").replace(/,/g, ";").replace(/§§§/g, ",").split(";").map((style) => style.trim()).filter(Boolean);
+    for (const id of String(ids).split(",")) {
+      this.classes.set(id, [...this.classes.get(id) ?? [], ...values]);
+      const textStyles = values.filter((style) => /color/.test(style)).map((style) => style.replace("fill", "bgFill"));
+      if (textStyles.length) this.classTextStyles.set(id, [...this.classTextStyles.get(id) ?? [], ...textStyles]);
+    }
+  }
+  setClass(ids, className) {
+    for (const id of String(ids).split(",")) {
+      const node = this.vertices.get(id);
+      if (node) node.classes.push(String(className));
+      const edge = this.edges.find((item) => item.id === id);
+      if (edge) edge.classes.push(String(className));
+      const group = this.subGraphLookup.get(id);
+      if (group) group.classes.push(String(className));
+    }
+  }
+  updateLink(positions, styles) {
+    for (const position of positions) {
+      if (position === "default") this.defaultStyles = styles.slice();
+      else if (this.edges[position]) {
+        this.edges[position].styles = styles.slice();
+        if (styles.length && !styles.some((style) => String(style).startsWith("fill"))) this.edges[position].styles.push("fill:none");
+      } else throw new FlowInkError(`The link index ${position} is out of bounds.`, { code: "INVALID_LINK_INDEX" });
+    }
+  }
+  updateLinkInterpolate(positions, value) {
+    const interpolate = String(value);
+    for (const position of positions) {
+      if (position === "default") {
+        this.defaultInterpolate = interpolate;
+      } else if (this.edges[position]) {
+        this.edges[position].metadata.interpolate = interpolate;
+        this.edges[position].interpolate = interpolate;
+      } else throw new FlowInkError(`The link index ${position} is out of bounds.`, { code: "INVALID_LINK_INDEX" });
+    }
+  }
+  setTooltip(ids, tooltip) {
+    for (const id of String(ids).split(",")) this.tooltips.set(id, String(tooltip));
+  }
+  setLink(ids, link, target) {
+    for (const id of String(ids).split(",")) {
+      if (!this.vertices.has(id) && !this.edges.some((edge) => edge.id === id) && !this.subGraphLookup.has(id)) continue;
+      this.interactions.set(id, { href: String(link), target });
+      this.setClass(id, "clickable");
+    }
+  }
+  setClickEvent(ids, callback, args) {
+    for (const id of String(ids).split(",")) {
+      if (!this.vertices.has(id) && !this.edges.some((edge) => edge.id === id) && !this.subGraphLookup.has(id)) continue;
+      this.interactions.set(id, { callback: String(callback), args: args ? String(args) : void 0 });
+      this.setClass(id, "clickable");
+    }
+  }
+  setAccTitle(value) {
+    this.title = String(value);
+  }
+  setAccDescription(value) {
+    this.description = String(value);
+  }
+  finalize() {
+    for (const group of this.subGraphs) {
+      const synthetic = this.vertices.get(group.id);
+      if (synthetic) {
+        group.styles.push(...synthetic.styles);
+        group.classes.push(...synthetic.classes);
+        Object.assign(group.metadata, synthetic.metadata);
+      }
+      if (this.tooltips.has(group.id)) group.metadata.tooltip = this.tooltips.get(group.id);
+      if (this.interactions.has(group.id)) group.metadata.interaction = this.interactions.get(group.id);
+    }
+    for (const node of this.vertices.values()) {
+      for (const className of node.classes) node.styles.push(...this.classes.get(className) ?? []);
+      if (this.tooltips.has(node.id)) node.metadata.tooltip = this.tooltips.get(node.id);
+      if (this.interactions.has(node.id)) node.metadata.interaction = this.interactions.get(node.id);
+    }
+    for (const edge of this.edges) {
+      if (edge.interpolate === void 0 && this.defaultInterpolate !== void 0) {
+        edge.interpolate = this.defaultInterpolate;
+        edge.metadata.interpolate = this.defaultInterpolate;
+      }
+      edge.styles = [...this.defaultStyles, ...edge.styles];
+      for (const className of edge.classes) edge.styles.push(...this.classes.get(className) ?? []);
+      if (this.interactions.has(edge.id)) edge.metadata.interaction = this.interactions.get(edge.id);
+    }
+    const metadata = {};
+    if (this.title !== void 0) metadata.title = this.title;
+    if (this.description !== void 0) metadata.description = this.description;
+    if (this.title !== void 0) metadata.accessibilityTitle = this.title;
+    if (this.description !== void 0) metadata.accessibilityDescription = this.description;
+    if (this.defaultStyles.length) metadata.defaultStyle = [...this.defaultStyles];
+    if (this.defaultInterpolate !== void 0) metadata.defaultInterpolate = this.defaultInterpolate;
+    if (this.classTextStyles.size) metadata.classTextStyles = Object.fromEntries(this.classTextStyles);
+    return { source: this.source, direction: this.direction, nodes: [...this.vertices.values()], edges: this.edges, subgraphs: this.subGraphs, classes: Object.fromEntries(this.classes), metadata };
+  }
+};
+function parserError(error, source) {
+  const line = error?.hash?.loc?.first_line ?? error?.lineNumber;
+  const firstColumn = error?.hash?.loc?.first_column;
+  const column = firstColumn === void 0 ? void 0 : firstColumn + 1;
+  return new FlowInkError(error?.message ?? "Invalid Mermaid flowchart", { code: "PARSE_ERROR", line, column, cause: error });
+}
+
+// src/parser/preprocess.js
+import yaml2 from "js-yaml";
+var FRONT_MATTER = /^([^\S\n\r]*)-{3}\s*[\n\r](.*?)[\n\r]\1-{3}\s*[\n\r]+/s;
+function cleanupText(value) {
+  return value.replace(/\r\n?/g, "\n").replace(
+    /<(\w+)([^>]*)>/g,
+    (match, tag, attributes) => `<${tag}${attributes.replace(/="([^"]*)"/g, "='$1'")}>`
+  );
+}
+function sourceLineAt(source, index) {
+  return source.slice(0, index).split(/\r\n?|\n/).length;
+}
+function preprocess(source) {
+  const original = String(source);
+  let text = cleanupText(original.replace(/^\uFEFF/, ""));
+  let frontmatter;
+  let lineOffset = 0;
+  const match = text.match(FRONT_MATTER);
+  if (match) {
+    const prefix = match[0];
+    lineOffset = prefix.split(/\r?\n/).length - (prefix.endsWith("\n") ? 1 : 0);
+    try {
+      frontmatter = yaml2.load(match[2], { schema: yaml2.JSON_SCHEMA }) ?? {};
+      if (!frontmatter || typeof frontmatter !== "object" || Array.isArray(frontmatter)) frontmatter = {};
+    } catch (error) {
+      const mark = error?.mark;
+      throw new FlowInkError(error?.message ?? "Invalid Mermaid frontmatter", {
+        code: "FRONTMATTER_ERROR",
+        line: sourceLineAt(text, match.index + match[0].indexOf(match[2])) + (mark?.line ?? 0),
+        column: mark ? mark.column + 1 : void 0,
+        cause: error
+      });
+    }
+    text = text.slice(prefix.length);
+  }
+  const directives = [];
+  text = text.replace(/^\s*%%\{([\s\S]*?)\}%%\s*(?:\r?\n|$)/gm, (match2, value) => {
+    directives.push(value.trim());
+    return match2.replace(/[^\n]/g, "");
+  });
+  text = text.replace(/^[^\S\n]*%%(?!\{)[^\n]*/gm, "");
+  const metadata = {};
+  if (frontmatter) {
+    metadata.frontmatter = frontmatter;
+    if (frontmatter.title !== void 0) metadata.title = String(frontmatter.title);
+    if (frontmatter.config !== void 0) metadata.config = frontmatter.config;
+    if (frontmatter.displayMode !== void 0) metadata.displayMode = String(frontmatter.displayMode);
+  }
+  if (directives.length) metadata.directives = directives;
+  return { text, metadata, lineOffset };
+}
+
+// src/parse.js
+function parse(source) {
+  if (typeof source !== "string") throw new FlowInkError("Flowchart source must be a string", { code: "INVALID_INPUT" });
+  const db = new FlowSemanticDB(source);
+  const processed = preprocess(source);
+  const localParser = new generated_default.Parser();
+  try {
+    localParser.yy = db;
+    localParser.parse(`${processed.text.replace(/}[^\S\n]*(?=\n|$)/g, "}")}
+`);
+    const graph = db.finalize();
+    const canonicaliseLabel = (value) => String(value).replace(/(<[^>]+?)='([^']*)'/g, '$1="$2"');
+    for (const node of graph.nodes) node.label = canonicaliseLabel(node.label);
+    for (const edge of graph.edges) edge.label = canonicaliseLabel(edge.label);
+    Object.assign(graph.metadata, processed.metadata);
+    return graph;
+  } catch (error) {
+    if (error instanceof FlowInkError) throw error;
+    const wrapped = parserError(error, source);
+    if (wrapped.line !== void 0) wrapped.line += processed.lineOffset;
+    throw wrapped;
+  }
+}
+
+// src/layout.js
+import ELK from "elkjs/lib/elk.bundled.js";
+
+// src/text.js
+import stringWidth from "string-width";
+import { decodeHTML } from "entities";
+import { marked } from "marked";
+function displayWidth(value) {
+  if (value === null || value === void 0) return 0;
+  const text = String(value).replace(/\r\n?/g, "\n");
+  return Math.max(0, ...text.split("\n").map((line) => stringWidth(line)));
+}
+var graphemeSegmenter = typeof Intl !== "undefined" && Intl.Segmenter ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+function expandTabs(value) {
+  return value.split("\n").map((line) => {
+    let column = 0;
+    let result = "";
+    const graphemes = graphemeSegmenter ? [...graphemeSegmenter.segment(line)].map(({ segment: segment2 }) => segment2) : [...line];
+    for (const grapheme of graphemes) {
+      if (grapheme === "	") {
+        const spaces = 4 - column % 4;
+        result += " ".repeat(spaces);
+        column += spaces;
+      } else {
+        result += grapheme;
+        column += stringWidth(grapheme);
+      }
+    }
+    return result;
+  }).join("\n");
+}
+var BLOCK_TAGS = /^(?:address|article|aside|blockquote|br|caption|dd|div|dl|dt|fieldset|figcaption|figure|footer|form|h[1-6]|header|hr|li|main|nav|ol|p|pre|section|table|tbody|td|tfoot|th|thead|tr|ul)$/i;
+function decodeLabelEntities(value) {
+  let result = decodeHTML(value);
+  return result.replace(/(?<!&)#(x[0-9a-f]+|[0-9]+|[a-z][a-z0-9]+);/gi, (match, name) => {
+    const entity = /^x/i.test(name) ? `&#${name};` : /^[0-9]/.test(name) ? `&#${name};` : `&${name};`;
+    const decoded = decodeHTML(entity);
+    return decoded === entity ? match : decoded;
+  });
+}
+function htmlTokenText(value) {
+  const source = String(value);
+  let result = "";
+  let index = 0;
+  while (index < source.length) {
+    if (source.startsWith("<!--", index)) {
+      const end2 = source.indexOf("-->", index + 4);
+      index = end2 < 0 ? source.length : end2 + 3;
+      continue;
+    }
+    if (source[index] !== "<") {
+      result += source[index];
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    let quote = "";
+    for (; end < source.length; end += 1) {
+      const character = source[end];
+      if (quote) {
+        if (character === quote) quote = "";
+      } else if (character === '"' || character === "'") {
+        quote = character;
+      } else if (character === ">") {
+        break;
+      }
+    }
+    if (end >= source.length) {
+      result += "<";
+      index += 1;
+      continue;
+    }
+    const rawTag = source.slice(index, end + 1);
+    const match = rawTag.match(/^<(\/?[a-z][a-z0-9-]*)(?=\s|\/?>)[\s\S]*>$/i);
+    if (!match) {
+      result += "<";
+      index += 1;
+      continue;
+    }
+    const closing = match[1].startsWith("/");
+    const tag = match[1].replace(/^\//, "").toLowerCase();
+    if (tag === "img") {
+      const alt = rawTag.match(/\balt\s*=\s*(['"])([\s\S]*?)\1/i);
+      if (alt) result += alt[2];
+    } else if (tag === "br") {
+      result += "\n";
+    } else if (BLOCK_TAGS.test(tag) && (closing || tag === "hr")) {
+      result += "\n";
+    }
+    index = end + 1;
+  }
+  return result;
+}
+function tokenText(token) {
+  if (!token) return "";
+  const type = token.type;
+  if (type === "html") return htmlTokenText(token.text ?? token.raw ?? "");
+  if (type === "image") {
+    return token.tokens ? tokensText(token.tokens) : token.text ?? "";
+  }
+  if (type === "br") return "\n";
+  if (type === "codespan" || type === "code" || type === "text" || type === "escape") {
+    if (type === "code" || type === "codespan") return token.text ?? "";
+    if (token.tokens) return tokensText(token.tokens);
+    return token.text ?? "";
+  }
+  if (type === "hr") return "\n";
+  if (type === "space") return "\n";
+  if (type === "table") {
+    const header = (token.header ?? []).map(tokenText).join(" | ");
+    const rows = (token.rows ?? []).map((row) => row.map(tokenText).join(" | "));
+    return [header, ...rows].filter((line) => line !== "").join("\n") + "\n";
+  }
+  if (type === "list_item") {
+    const body = token.tokens ? tokensText(token.tokens) : token.text ?? "";
+    const marker = token.task ? `[${token.checked ? "x" : " "}] ` : "";
+    return marker + body + "\n";
+  }
+  if (token.tokens) return tokensText(token.tokens) + (type === "paragraph" || type === "heading" ? "\n" : "");
+  if (token.items) return token.items.map(tokenText).join("") + "\n";
+  if (token.text !== void 0) return String(token.text);
+  return "";
+}
+function tokensText(tokens) {
+  return (tokens ?? []).map(tokenText).join("");
+}
+function labelLines(label, labelType2 = "text") {
+  const source = label === null || label === void 0 ? "" : String(label);
+  if (source === "") return [""];
+  let plain;
+  const markdown = /^(?:markdown|md)$/i.test(String(labelType2 ?? ""));
+  if (!markdown) {
+    plain = htmlTokenText(source);
+  } else {
+    try {
+      plain = tokensText(marked.lexer(source));
+    } catch {
+      plain = htmlTokenText(source);
+    }
+  }
+  plain = expandTabs(decodeLabelEntities(plain).replace(/\r\n?/g, "\n"));
+  plain = plain.replace(/^\n+|\n+$/g, "");
+  return plain === "" ? [""] : plain.split("\n");
+}
+var SHAPE_ALIASES = /* @__PURE__ */ new Map([
+  ["rect", "rect"],
+  ["rectangle", "rect"],
+  ["square", "rect"],
+  ["proc", "rect"],
+  ["process", "rect"],
+  ["f_rect", "rect"],
+  ["fr_rect", "rect"],
+  ["subroutine", "rect"],
+  ["subproc", "rect"],
+  ["lined_square", "rect"],
+  ["notch_rect", "rect"],
+  ["div_rect", "rect"],
+  ["tag", "rect"],
+  ["fork", "rect"],
+  ["join", "rect"],
+  ["round", "round"],
+  ["rounded", "round"],
+  ["stadium", "round"],
+  ["pill", "round"],
+  ["event", "round"],
+  ["f_round", "round"],
+  ["fr_round", "round"],
+  ["circle", "circle"],
+  ["circ", "circle"],
+  ["doublecircle", "circle"],
+  ["dbl_circ", "circle"],
+  ["sm_circ", "circle"],
+  ["fr_circ", "circle"],
+  ["f_circ", "circle"],
+  ["state", "circle"],
+  ["diamond", "diamond"],
+  ["diam", "diamond"],
+  ["rhombus", "diamond"],
+  ["decision", "diamond"],
+  ["question", "diamond"],
+  ["image", "image"],
+  ["img", "image"],
+  ["icon", "icon"]
+]);
+function shapeKey(value) {
+  return String(value ?? "").trim().toLowerCase().replace(/[\s-]+/g, "_");
+}
+function metadataField(metadata, name) {
+  return metadata[name];
+}
+function shapeForNode(node) {
+  const metadata = node && node.metadata && typeof node.metadata === "object" ? node.metadata : {};
+  const primary = node?.shape;
+  const metadataShape = metadataField(metadata, "shape");
+  const iconValue = metadataField(metadata, "icon");
+  const imgValue = metadataField(metadata, "img");
+  const mediaKind = iconValue !== void 0 && iconValue !== null ? "icon" : imgValue !== void 0 && imgValue !== null ? "image" : void 0;
+  const form = metadataField(metadata, "form");
+  const formShape = mediaKind && SHAPE_ALIASES.has(shapeKey(form)) ? form : void 0;
+  const typeShape = SHAPE_ALIASES.has(shapeKey(node?.type)) ? node?.type : void 0;
+  const mediaUsesDefaultShape = mediaKind && metadataShape === void 0 && (primary === void 0 || shapeKey(primary) === "rect");
+  const candidates = mediaUsesDefaultShape ? [formShape] : shapeKey(primary) === "rect" && metadataShape !== void 0 ? [metadataShape, primary, node?.shapeType, typeShape] : [primary, node?.shapeType, metadataShape, typeShape];
+  for (const candidate of candidates) {
+    if (candidate === void 0 || candidate === null) continue;
+    const key3 = shapeKey(candidate);
+    return { original: String(candidate), canonical: SHAPE_ALIASES.get(key3) ?? "rect", placeholderKind: mediaKind };
+  }
+  if (mediaKind) {
+    return formShape ? { original: String(formShape), canonical: SHAPE_ALIASES.get(shapeKey(formShape)), placeholderKind: mediaKind } : { original: mediaKind, canonical: mediaKind, placeholderKind: mediaKind };
+  }
+  return { original: "rect", canonical: "rect" };
+}
+function prepareNode(node = {}) {
+  const input = node && typeof node === "object" ? node : {};
+  const metadataInput = input.metadata && typeof input.metadata === "object" ? input.metadata : {};
+  const { original, canonical, placeholderKind } = shapeForNode(input);
+  const label = metadataField(metadataInput, "label") ?? input.label ?? input.text ?? input.value ?? "";
+  let lines = labelLines(label, input.labelType ?? metadataInput.labelType ?? "text");
+  const shapePlaceholder = shapeKey(original) !== "rect" && !SHAPE_ALIASES.has(shapeKey(original));
+  const prefixes = [];
+  if (shapePlaceholder) prefixes.push(`[${original}]`);
+  if (placeholderKind) prefixes.push(`[${placeholderKind}]`);
+  else if (canonical === "image" || canonical === "icon") prefixes.push(`[${canonical}]`);
+  if (prefixes.length) {
+    lines = lines.length === 1 && lines[0] === "" ? prefixes : [...prefixes, ...lines];
+  }
+  const widest = Math.max(0, ...lines.map(displayWidth));
+  const padding = 1;
+  const borderWidth = 2;
+  const borderHeight = 2;
+  const minimumWidth = canonical === "circle" || canonical === "diamond" ? 5 : canonical === "image" || canonical === "icon" ? 7 : 5;
+  const minimumHeight = canonical === "circle" || canonical === "diamond" ? 5 : 3;
+  let width = Math.max(minimumWidth, widest + padding * 2 + borderWidth);
+  let height = Math.max(minimumHeight, lines.length + borderHeight);
+  const originalProperties = { ...input };
+  delete originalProperties.metadata;
+  const metadata = { ...metadataInput };
+  if (metadata.originalShape === void 0) metadata.originalShape = original;
+  if (metadata.originalProperties === void 0) metadata.originalProperties = originalProperties;
+  if (shapePlaceholder || placeholderKind) {
+    metadata.placeholder = true;
+    if (shapePlaceholder) metadata.placeholderFor = original;
+    if (placeholderKind) metadata.placeholderKind = placeholderKind;
+  }
+  return { lines, shape: canonical, width, height, metadata, originalShape: original };
+}
+
+// src/place-labels.js
+function placeLabels(layout2) {
+  validateInput(layout2);
+  const boxes = layout2.boxes;
+  const edges = layout2.edges;
+  const obstacles = buildBoxObstacles(boxes);
+  const routeCells = /* @__PURE__ */ new Map();
+  const arrowCells = /* @__PURE__ */ new Set();
+  for (const edge of edges) {
+    validateRoute(edge);
+    const cells = segmentCellsForRoute(edge.points);
+    for (const cell of cells) {
+      const cellKey = key(cell.x, cell.y);
+      if (!routeCells.has(cellKey)) routeCells.set(cellKey, /* @__PURE__ */ new Set());
+      routeCells.get(cellKey).add(edge.id);
+    }
+    deriveArrowCells(edge, arrowCells);
+  }
+  const placed = [];
+  for (const edge of edges) {
+    if (!edge.label) continue;
+    const label = normalizeLabel(edge.label, edge.id);
+    const route = edge.points;
+    const candidate = findPlacement({
+      edge,
+      label,
+      route,
+      obstacles,
+      routeCells,
+      arrowCells,
+      placed,
+      bounds: layoutBounds(layout2, boxes, edges)
+    });
+    if (!candidate) {
+      throw new FlowInkError(`Cannot place label for edge ${edge.id} without hiding graph geometry.`, {
+        code: "LABEL_PLACEMENT_ERROR"
+      });
+    }
+    edge.label = { ...edge.label, ...label, x: candidate.x, y: candidate.y };
+    placed.push({ edgeId: edge.id, ...label, x: candidate.x, y: candidate.y });
+  }
+  translateAndExpand(layout2);
+  return layout2;
+}
+function validateInput(layout2) {
+  if (!layout2 || typeof layout2 !== "object" || !Array.isArray(layout2.boxes) || !Array.isArray(layout2.edges)) {
+    fail("Layout must contain boxes and edges arrays.", "INVALID_LAYOUT");
+  }
+  for (const box of layout2.boxes) {
+    if (!box || typeof box.id !== "string" || !Number.isInteger(box.x) || !Number.isInteger(box.y) || !Number.isInteger(box.width) || !Number.isInteger(box.height) || box.width < 1 || box.height < 1 || !Array.isArray(box.lines)) {
+      fail(`Layout box ${box?.id ?? "<unknown>"} is invalid.`, "INVALID_LAYOUT");
+    }
+  }
+  const ids = /* @__PURE__ */ new Set();
+  for (const edge of layout2.edges) {
+    if (!edge || typeof edge.id !== "string" || ids.has(edge.id)) fail(`Layout edge id is missing or duplicated: ${edge?.id ?? "<unknown>"}.`, "INVALID_LAYOUT");
+    ids.add(edge.id);
+    if (!Array.isArray(edge.points) || edge.points.length < 1) fail(`Layout edge ${edge.id} must have at least one point.`, "INVALID_LAYOUT");
+  }
+}
+function validateRoute(edge) {
+  for (const point of edge.points) {
+    if (!point || !Number.isInteger(point.x) || !Number.isInteger(point.y)) {
+      fail(`Layout edge ${edge.id} has an invalid route point.`, "INVALID_LAYOUT");
+    }
+  }
+  for (let i = 1; i < edge.points.length; i += 1) {
+    const a = edge.points[i - 1];
+    const b = edge.points[i];
+    if (a.x !== b.x && a.y !== b.y) fail(`Layout edge ${edge.id} is not orthogonal.`, "NON_ORTHOGONAL_EDGE");
+  }
+}
+function normalizeLabel(source, edgeId) {
+  if (!source || !Array.isArray(source.lines)) fail(`Label for edge ${edgeId} must provide lines.`, "INVALID_LAYOUT");
+  const lines = source.lines.flatMap((line) => String(line).replace(/\r\n?/g, "\n").split("\n"));
+  const measuredWidth = Math.max(0, ...lines.map((line) => displayWidth(line)));
+  const suppliedWidth = Number.isInteger(source.width) && source.width > 0 ? source.width : 0;
+  const suppliedHeight = Number.isInteger(source.height) && source.height > 0 ? source.height : 0;
+  return {
+    lines: lines.length ? lines : [""],
+    width: Math.max(1, measuredWidth, suppliedWidth),
+    height: Math.max(1, lines.length, suppliedHeight)
+  };
+}
+function buildBoxObstacles(boxes) {
+  const obstacles = /* @__PURE__ */ new Set();
+  for (const box of boxes) {
+    const isGroup = box.kind === "subgraph";
+    for (let y = box.y; y < box.y + box.height; y += 1) {
+      for (let x = box.x; x < box.x + box.width; x += 1) {
+        const border = x === box.x || x === box.x + box.width - 1 || y === box.y || y === box.y + box.height - 1;
+        const title = isGroup && y >= box.y + 1 && y < box.y + 1 + box.lines.length;
+        if (!isGroup || border || title) obstacles.add(key(x, y));
+      }
+    }
+  }
+  return obstacles;
+}
+function findPlacement({ edge, label, route, obstacles, routeCells, arrowCells, placed, bounds }) {
+  const segments = routeSegments(route).filter((segment2) => segment2.length > 0).sort((a, b) => b.length - a.length || a.index - b.index);
+  const maxGap = Math.max(8, bounds.width + bounds.height + label.width + label.height + 4);
+  for (let gap = 1; gap <= maxGap; gap += 1) {
+    for (const segment2 of segments) {
+      const candidates = adjacentCandidates(segment2, label, gap);
+      for (const candidate of candidates) {
+        if (clear(candidate, label, edge.id, false, obstacles, routeCells, arrowCells, placed)) return candidate;
+      }
+    }
+  }
+  const anchor2 = route[0];
+  const ringLimit = Math.max(8, bounds.width + bounds.height + label.width + label.height + 4);
+  for (let radius = 1; radius <= ringLimit; radius += 1) {
+    const ring = [
+      { x: anchor2.x - Math.floor(label.width / 2), y: anchor2.y - label.height - radius },
+      { x: anchor2.x - Math.floor(label.width / 2), y: anchor2.y + radius },
+      { x: anchor2.x - label.width - radius, y: anchor2.y - Math.floor(label.height / 2) },
+      { x: anchor2.x + radius, y: anchor2.y - Math.floor(label.height / 2) }
+    ];
+    for (const candidate of ring) {
+      if (clear(candidate, label, edge.id, false, obstacles, routeCells, arrowCells, placed)) return candidate;
+    }
+  }
+  if (label.height === 1) {
+    for (const segment2 of segments) {
+      const candidate = inlineCandidate(segment2, label);
+      if (candidate && clear(candidate, label, edge.id, true, obstacles, routeCells, arrowCells, placed) && connectedInline(candidate, label, edge.id, segment2, routeCells)) return candidate;
+    }
+  }
+  return null;
+}
+function routeSegments(points) {
+  const result = [];
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    result.push({ index: i - 1, a, b, horizontal: a.y === b.y, length: Math.abs(b.x - a.x) + Math.abs(b.y - a.y) });
+  }
+  return result;
+}
+function adjacentCandidates(segment2, label, gap) {
+  const { a, b } = segment2;
+  const midX = Math.floor((a.x + b.x) / 2);
+  const midY = Math.floor((a.y + b.y) / 2);
+  const candidates = [];
+  if (segment2.horizontal) {
+    const x = midX - Math.floor(label.width / 2);
+    candidates.push({ x, y: a.y - label.height - gap });
+    candidates.push({ x, y: a.y + gap });
+  } else {
+    const y = midY - Math.floor(label.height / 2);
+    candidates.push({ x: a.x - label.width - gap, y });
+    candidates.push({ x: a.x + gap, y });
+  }
+  return candidates;
+}
+function inlineCandidate(segment2, label) {
+  const { a, b } = segment2;
+  if (segment2.horizontal) return { x: Math.floor((a.x + b.x - label.width) / 2), y: a.y };
+  return { x: a.x, y: Math.floor((a.y + b.y - label.height) / 2) };
+}
+function clear(candidate, label, edgeId, inline, obstacles, routeCells, arrowCells, placed) {
+  for (let y = candidate.y; y < candidate.y + label.height; y += 1) {
+    for (let x = candidate.x; x < candidate.x + label.width; x += 1) {
+      const cellKey = key(x, y);
+      if (obstacles.has(cellKey) || arrowCells.has(cellKey)) return false;
+      const owners = routeCells.get(cellKey);
+      if (owners && (!inline || owners.size !== 1 || !owners.has(edgeId))) return false;
+      if (placed.some((other) => intersects(candidate, label, other))) return false;
+    }
+  }
+  for (let y = candidate.y - 1; y <= candidate.y + label.height; y += 1) {
+    for (let x = candidate.x - 1; x <= candidate.x + label.width; x += 1) {
+      const owners = routeCells.get(key(x, y));
+      if (owners && [...owners].some((owner) => owner !== edgeId)) return false;
+    }
+  }
+  const ownDistance = distanceToRoute(candidate, label, routeCells, edgeId, true);
+  const unrelatedDistance = distanceToRoute(candidate, label, routeCells, edgeId, false);
+  if (ownDistance >= unrelatedDistance) return false;
+  return true;
+}
+function distanceToRoute(candidate, label, routeCells, edgeId, own) {
+  let distance = Infinity;
+  for (const [cellKey, owners] of routeCells) {
+    const isOwn = owners.size === 1 && owners.has(edgeId);
+    if (isOwn !== own) continue;
+    const [x, y] = cellKey.split(",").map(Number);
+    distance = Math.min(distance, pointToRectDistance(x, y, candidate, label));
+    if (distance === 0) return 0;
+  }
+  return distance;
+}
+function pointToRectDistance(x, y, candidate, label) {
+  const dx = x < candidate.x ? candidate.x - x : x >= candidate.x + label.width ? x - (candidate.x + label.width - 1) : 0;
+  const dy = y < candidate.y ? candidate.y - y : y >= candidate.y + label.height ? y - (candidate.y + label.height - 1) : 0;
+  return dx + dy;
+}
+function connectedInline(candidate, label, edgeId, segment2, routeCells) {
+  let inside2 = false;
+  let outsideBefore = false;
+  let outsideAfter = false;
+  for (const cell of segmentCells(segment2.a, segment2.b)) {
+    if (cell.x >= candidate.x && cell.x < candidate.x + label.width && cell.y >= candidate.y && cell.y < candidate.y + label.height) {
+      inside2 = true;
+      const before = { x: cell.x - Math.sign(segment2.b.x - segment2.a.x), y: cell.y - Math.sign(segment2.b.y - segment2.a.y) };
+      const after = { x: cell.x + Math.sign(segment2.b.x - segment2.a.x), y: cell.y + Math.sign(segment2.b.y - segment2.a.y) };
+      if (routeCells.get(key(before.x, before.y))?.has(edgeId)) outsideBefore = true;
+      if (routeCells.get(key(after.x, after.y))?.has(edgeId)) outsideAfter = true;
+    }
+  }
+  return inside2 && outsideBefore && outsideAfter;
+}
+function intersects(a, aSize, b) {
+  return a.x < b.x + b.width && b.x < a.x + aSize.width && a.y < b.y + b.height && b.y < a.y + aSize.height;
+}
+function deriveArrowCells(edge, output) {
+  if (edge.points.length < 2) return;
+  const first = distinctPair(edge.points, true);
+  const last = distinctPair(edge.points, false);
+  if (edge.arrowStart && edge.arrowStart !== "none" && first) output.add(key(first.next.x, first.next.y));
+  if (edge.arrowEnd && edge.arrowEnd !== "none" && last) output.add(key(last.previous.x, last.previous.y));
+}
+function distinctPair(points, start) {
+  if (start) {
+    for (let i = 1; i < points.length; i += 1) {
+      if (points[i].x !== points[0].x || points[i].y !== points[0].y) return { next: oneStep(points[0], points[i]) };
+    }
+  } else {
+    for (let i = points.length - 2; i >= 0; i -= 1) {
+      if (points[i].x !== points.at(-1).x || points[i].y !== points.at(-1).y) return { previous: oneStep(points.at(-1), points[i]) };
+    }
+  }
+  return null;
+}
+function oneStep(from, toward) {
+  return { x: from.x + Math.sign(toward.x - from.x), y: from.y + Math.sign(toward.y - from.y) };
+}
+function segmentCells(a, b) {
+  const cells = [];
+  const dx = Math.sign(b.x - a.x);
+  const dy = Math.sign(b.y - a.y);
+  let x = a.x;
+  let y = a.y;
+  cells.push({ x, y });
+  while (x !== b.x || y !== b.y) {
+    x += dx;
+    y += dy;
+    cells.push({ x, y });
+  }
+  return cells;
+}
+function segmentCellsForRoute(points) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 1; i < points.length; i += 1) {
+    for (const cell of segmentCells(points[i - 1], points[i])) {
+      const cellKey = key(cell.x, cell.y);
+      if (!seen.has(cellKey)) {
+        seen.add(cellKey);
+        result.push(cell);
+      }
+    }
+  }
+  if (points.length === 1) result.push(points[0]);
+  return result;
+}
+function layoutBounds(layout2, boxes, edges) {
+  const xs = [0];
+  const ys = [0];
+  for (const box of boxes) {
+    xs.push(box.x, box.x + box.width);
+    ys.push(box.y, box.y + box.height);
+  }
+  for (const edge of edges) for (const point of edge.points) {
+    xs.push(point.x);
+    ys.push(point.y);
+  }
+  return { width: Math.max(1, Math.max(...xs) - Math.min(...xs) + (layout2.width || 0)), height: Math.max(1, Math.max(...ys) - Math.min(...ys) + (layout2.height || 0)) };
+}
+function translateAndExpand(layout2) {
+  const labels = layout2.edges.flatMap((edge) => edge.label ? [edge.label] : []);
+  const xValues = [0];
+  const yValues = [0];
+  for (const box of layout2.boxes) {
+    xValues.push(box.x);
+    yValues.push(box.y);
+  }
+  for (const edge of layout2.edges) for (const point of edge.points) {
+    xValues.push(point.x);
+    yValues.push(point.y);
+  }
+  for (const label of labels) {
+    xValues.push(label.x);
+    yValues.push(label.y);
+  }
+  const shiftX = Math.max(0, -Math.min(...xValues));
+  const shiftY = Math.max(0, -Math.min(...yValues));
+  if (shiftX || shiftY) {
+    for (const box of layout2.boxes) {
+      box.x += shiftX;
+      box.y += shiftY;
+    }
+    for (const edge of layout2.edges) {
+      for (const point of edge.points) {
+        point.x += shiftX;
+        point.y += shiftY;
+      }
+      if (edge.label) {
+        edge.label.x += shiftX;
+        edge.label.y += shiftY;
+      }
+    }
+  }
+  const width = Math.max(0, Number.isInteger(layout2.width) ? layout2.width + shiftX : 0);
+  const height = Math.max(0, Number.isInteger(layout2.height) ? layout2.height + shiftY : 0);
+  layout2.width = width;
+  layout2.height = height;
+  for (const box of layout2.boxes) {
+    layout2.width = Math.max(layout2.width, box.x + box.width);
+    layout2.height = Math.max(layout2.height, box.y + box.height);
+  }
+  for (const edge of layout2.edges) {
+    for (const point of edge.points) {
+      layout2.width = Math.max(layout2.width, point.x + 1);
+      layout2.height = Math.max(layout2.height, point.y + 1);
+    }
+    if (edge.label) {
+      layout2.width = Math.max(layout2.width, edge.label.x + edge.label.width);
+      layout2.height = Math.max(layout2.height, edge.label.y + edge.label.height);
+    }
+  }
+}
+function key(x, y) {
+  return `${x},${y}`;
+}
+function fail(message, code) {
+  throw new FlowInkError(message, { code });
+}
+
+// src/layout.js
+var elk = new ELK();
+var DIRECTIONS = Object.freeze({ TB: "DOWN", BT: "UP", LR: "RIGHT", RL: "LEFT" });
+async function layout(graph) {
+  const context = makeContext(graph);
+  let laidOut;
+  try {
+    laidOut = await elk.layout(toElkGraph(context));
+  } catch (cause) {
+    throw new FlowInkError(`ELK could not lay out the flowchart: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      code: "LAYOUT_ERROR",
+      cause
+    });
+  }
+  const result = fromElkGraph(context, laidOut);
+  if (needsWireClearance(context.graph, result)) expandGrid(result);
+  return placeLabels(result);
+}
+function needsWireClearance(graph, layoutGraph) {
+  const pairs = /* @__PURE__ */ new Set();
+  const reverse = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    const pair = pairKey(edge.source, edge.target);
+    if (pairs.has(pair) || reverse.has(pairKey(edge.target, edge.source))) return true;
+    pairs.add(pair);
+    reverse.add(pair);
+  }
+  const segments = layoutGraph.edges.flatMap((edge) => edge.points.slice(1).map((b, index) => ({
+    id: edge.id,
+    a: edge.points[index],
+    b,
+    horizontal: edge.points[index].y === b.y
+  })));
+  for (let i = 0; i < segments.length; i += 1) for (let j = i + 1; j < segments.length; j += 1) {
+    const a = segments[i];
+    const b = segments[j];
+    if (a.id === b.id || a.horizontal !== b.horizontal) continue;
+    const fixed = a.horizontal ? "y" : "x";
+    const varying = a.horizontal ? "x" : "y";
+    const distance = Math.abs(a.a[fixed] - b.a[fixed]);
+    const overlap = Math.min(Math.max(a.a[varying], a.b[varying]), Math.max(b.a[varying], b.b[varying])) - Math.max(Math.min(a.a[varying], a.b[varying]), Math.min(b.a[varying], b.b[varying]));
+    if (distance === 1 && overlap >= 1) return true;
+  }
+  return false;
+}
+function expandGrid(layoutGraph) {
+  for (const box of layoutGraph.boxes) {
+    box.x *= 2;
+    box.y *= 2;
+    box.width = Math.max(1, (box.width - 1) * 2 + 1);
+    box.height = Math.max(1, (box.height - 1) * 2 + 1);
+  }
+  for (const edge of layoutGraph.edges) {
+    for (const point of edge.points) {
+      point.x *= 2;
+      point.y *= 2;
+    }
+    if (edge.label) {
+      edge.label.x *= 2;
+      edge.label.y *= 2;
+      edge.label.width = Math.max(1, (edge.label.width - 1) * 2 + 1);
+      edge.label.height = Math.max(1, (edge.label.height - 1) * 2 + 1);
+    }
+  }
+  layoutGraph.width = Math.max(1, layoutGraph.width * 2);
+  layoutGraph.height = Math.max(1, layoutGraph.height * 2);
+}
+function makeContext(graph) {
+  if (!graph || typeof graph !== "object") invalid("A FlowGraph object is required.");
+  if (!Array.isArray(graph.nodes) || !Array.isArray(graph.edges) || !Array.isArray(graph.subgraphs)) {
+    invalid("FlowGraph must contain nodes, edges, and subgraphs arrays.");
+  }
+  if (!DIRECTIONS[graph.direction]) invalid(`Unsupported flow direction: ${String(graph.direction)}.`);
+  const subgraphs = /* @__PURE__ */ new Map();
+  for (const subgraph of graph.subgraphs) {
+    requireId(subgraph, "subgraph");
+    if (subgraphs.has(subgraph.id)) invalid(`Duplicate graph element id: ${subgraph.id}.`);
+    subgraphs.set(subgraph.id, subgraph);
+  }
+  const nodes = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    requireId(node, "node");
+    if (subgraphs.has(node.id)) continue;
+    if (nodes.has(node.id)) invalid(`Duplicate graph element id: ${node.id}.`);
+    nodes.set(node.id, node);
+  }
+  const parent = /* @__PURE__ */ new Map();
+  for (const node of nodes.values()) {
+    if (node.parentId !== void 0 && !subgraphs.has(node.parentId)) {
+      invalid(`Node ${node.id} refers to missing subgraph ${node.parentId}.`);
+    }
+    if (node.parentId !== void 0) parent.set(node.id, node.parentId);
+  }
+  for (const subgraph of subgraphs.values()) {
+    if (subgraph.parentId !== void 0 && !subgraphs.has(subgraph.parentId)) {
+      invalid(`Subgraph ${subgraph.id} refers to missing parent ${subgraph.parentId}.`);
+    }
+    if (subgraph.parentId !== void 0) parent.set(subgraph.id, subgraph.parentId);
+    for (const childId of subgraph.nodeIds ?? []) {
+      if (!nodes.has(childId) && !subgraphs.has(childId)) invalid(`Subgraph ${subgraph.id} refers to missing child ${childId}.`);
+      const previous = parent.get(childId);
+      if (previous !== void 0 && previous !== subgraph.id) {
+        invalid(`Graph element ${childId} has conflicting subgraph parents.`);
+      }
+      parent.set(childId, subgraph.id);
+    }
+  }
+  for (const id of [...nodes.keys(), ...subgraphs.keys()]) {
+    const seen = /* @__PURE__ */ new Set([id]);
+    let current = parent.get(id);
+    while (current !== void 0) {
+      if (seen.has(current)) invalid(`Cyclic subgraph containment involving ${id}.`);
+      seen.add(current);
+      current = parent.get(current);
+    }
+  }
+  for (const edge of graph.edges) {
+    requireId(edge, "edge");
+    if (!nodes.has(edge.source) && !subgraphs.has(edge.source)) invalid(`Edge ${edge.id} has missing source ${edge.source}.`);
+    if (!nodes.has(edge.target) && !subgraphs.has(edge.target)) invalid(`Edge ${edge.id} has missing target ${edge.target}.`);
+  }
+  const children = /* @__PURE__ */ new Map();
+  const order = /* @__PURE__ */ new Map();
+  const put = (id, index) => {
+    const p = parent.get(id);
+    const key3 = p ?? null;
+    if (!children.has(key3)) children.set(key3, []);
+    if (!children.get(key3).includes(id)) children.get(key3).push(id);
+    order.set(id, index);
+  };
+  graph.nodes.forEach((n, i) => put(n.id, i));
+  graph.subgraphs.forEach((s, i) => put(s.id, graph.nodes.length + i));
+  for (const list of children.values()) list.sort((a, b) => order.get(a) - order.get(b) || a.localeCompare(b));
+  const element = new Map([...nodes, ...subgraphs]);
+  const elkIds = /* @__PURE__ */ new Map();
+  let nodeIndex = 0;
+  let groupIndex = 0;
+  for (const id of nodes.keys()) elkIds.set(id, `n${nodeIndex++}`);
+  for (const id of subgraphs.keys()) elkIds.set(id, `g${groupIndex++}`);
+  const edgeElkIds = new Map(graph.edges.map((edge, index) => [edge.id, `e${index}`]));
+  const dimensions = /* @__PURE__ */ new Map();
+  for (const node of nodes.values()) {
+    const prepared = prepareNode(node);
+    const lines = Array.isArray(prepared.lines) ? prepared.lines.map(String) : [String(node.label ?? node.id)];
+    dimensions.set(node.id, {
+      lines,
+      shape: prepared.shape ?? node.shape ?? "rect",
+      width: positiveSize(prepared.width, maxWidth(lines, node.label)),
+      height: positiveSize(prepared.height, Math.max(3, lines.length + 2))
+    });
+  }
+  for (const subgraph of subgraphs.values()) {
+    const text = String(subgraph.label ?? subgraph.id);
+    const lines = labelLines(text, subgraph.metadata?.labelType ?? "text").map(String);
+    dimensions.set(subgraph.id, {
+      lines,
+      shape: "subgraph",
+      width: Math.max(3, maxWidth(lines, text) + 2),
+      height: Math.max(3, lines.length + 2)
+    });
+  }
+  const incident = /* @__PURE__ */ new Map();
+  for (const edge of graph.edges) {
+    incident.set(edge.source, (incident.get(edge.source) ?? 0) + 1);
+    incident.set(edge.target, (incident.get(edge.target) ?? 0) + 1);
+  }
+  for (const [id, count] of incident) {
+    const dim = dimensions.get(id);
+    if (!dim) continue;
+    const direction = contextDirection(graph, parent, subgraphs, id);
+    if (direction === "LR" || direction === "RL") dim.height = Math.max(dim.height, count * 2 + 1);
+    else dim.width = Math.max(dim.width, count * 2 + 1);
+  }
+  return { graph, nodes, subgraphs, element, parent, children, dimensions, order, elkIds, edgeElkIds };
+}
+function contextDirection(graph, parent, subgraphs, id) {
+  let current = id;
+  while (current !== void 0) {
+    const direction = subgraphs.get(current)?.direction;
+    if (direction) return direction;
+    current = parent.get(current);
+  }
+  return graph.direction;
+}
+function toElkGraph(context) {
+  const { graph } = context;
+  const root = {
+    id: "r0",
+    layoutOptions: commonLayoutOptions(DIRECTIONS[graph.direction]),
+    children: containerChildren(context, null),
+    edges: containerEdges(context, null)
+  };
+  return root;
+}
+function containerChildren(context, containerId) {
+  const ids = context.children.get(containerId) ?? [];
+  return ids.map((id) => {
+    const dim = context.dimensions.get(id);
+    if (context.subgraphs.has(id)) {
+      const subgraph = context.subgraphs.get(id);
+      const children = containerChildren(context, id);
+      const result = {
+        id: context.elkIds.get(id),
+        labels: [{ id: `l${context.elkIds.get(id)}`, text: subgraph.label ?? id, width: dim.width - 2, height: Math.max(1, dim.lines.length) }],
+        layoutOptions: commonLayoutOptions(subgraph.direction ? DIRECTIONS[subgraph.direction] : void 0, true, !hasExternalConnection(context, id)),
+        children,
+        edges: containerEdges(context, id)
+      };
+      if (children.length === 0) {
+        result.width = elkSize(dim.width);
+        result.height = elkSize(dim.height);
+      }
+      if (!result.layoutOptions["elk.direction"]) delete result.layoutOptions["elk.direction"];
+      return result;
+    }
+    return { id: context.elkIds.get(id), width: elkSize(dim.width), height: elkSize(dim.height), labels: [] };
+  });
+}
+function commonLayoutOptions(direction, nested = false, separateChildren = false) {
+  const options = {
+    "elk.algorithm": "layered",
+    ...direction ? { "elk.direction": direction } : {},
+    "elk.edgeRouting": "ORTHOGONAL",
+    "elk.hierarchyHandling": separateChildren ? "SEPARATE_CHILDREN" : "INCLUDE_CHILDREN",
+    "elk.json.shapeCoords": "ROOT",
+    "elk.json.edgeCoords": "ROOT",
+    ...nested ? {} : { "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES" },
+    "elk.layered.considerModelOrder.portModelOrder": "true",
+    "elk.layered.mergeEdges": "false",
+    "elk.layered.mergeHierarchyEdges": "false",
+    "elk.spacing.nodeNode": "2",
+    "elk.layered.spacing.nodeNodeBetweenLayers": "3",
+    "elk.layered.spacing.edgeNodeBetweenLayers": "2",
+    "elk.spacing.edgeEdge": "2",
+    "elk.spacing.edgeNode": "2",
+    "elk.spacing.nodeSelfLoop": "2",
+    "elk.padding": "[top=2,left=2,bottom=2,right=2]"
+  };
+  return options;
+}
+function hasExternalConnection(context, subgraphId) {
+  return context.graph.edges.some((edge) => {
+    const sourceInside = isDescendant(context, edge.source, subgraphId);
+    const targetInside = isDescendant(context, edge.target, subgraphId);
+    return sourceInside !== targetInside;
+  });
+}
+function isDescendant(context, id, ancestor) {
+  let current = context.parent.get(id);
+  while (current !== void 0) {
+    if (current === ancestor) return true;
+    current = context.parent.get(current);
+  }
+  return false;
+}
+function containerEdges(context, containerId) {
+  return context.graph.edges.filter((edge) => lowestCommonContainer(context, edge.source, edge.target) === containerId).map((edge) => {
+    const dim = context.dimensions.get(edge.id);
+    const result = {
+      id: context.edgeElkIds.get(edge.id),
+      sources: [context.elkIds.get(edge.source)],
+      targets: [context.elkIds.get(edge.target)]
+    };
+    if (edge.label) {
+      const lines = labelLines(edge.label, edge.labelType).map(String);
+      result.labels = [{ id: `l${context.edgeElkIds.get(edge.id)}`, text: lines.join("\n"), width: Math.max(1, maxWidth(lines, edge.label)), height: Math.max(1, lines.length) }];
+    }
+    return result;
+  });
+}
+function lowestCommonContainer(context, source, target) {
+  if (source === target) return context.parent.get(source) ?? null;
+  const ancestors = /* @__PURE__ */ new Set();
+  let current = source;
+  while (current !== void 0) {
+    ancestors.add(current);
+    current = context.parent.get(current);
+  }
+  ancestors.add(null);
+  current = target;
+  while (current !== void 0 && !ancestors.has(current)) current = context.parent.get(current);
+  const common = ancestors.has(current) ? current : null;
+  if (common !== null && !context.subgraphs.has(common)) return context.parent.get(common) ?? null;
+  return common;
+}
+function fromElkGraph(context, result) {
+  const internalElements = /* @__PURE__ */ new Map();
+  const internalFloatBoxes = /* @__PURE__ */ new Map();
+  walkOutput(result, internalElements, internalFloatBoxes, true);
+  const outputElements = /* @__PURE__ */ new Map();
+  const floatBoxes = /* @__PURE__ */ new Map();
+  for (const [publicId, internalId] of context.elkIds) {
+    const element = internalElements.get(internalId);
+    if (element) outputElements.set(publicId, element);
+    const float = internalFloatBoxes.get(internalId);
+    if (float) floatBoxes.set(publicId, float);
+  }
+  const boxes = [];
+  for (const [id, element] of context.element) {
+    const laid = outputElements.get(id);
+    if (!laid || !Number.isFinite(laid.x) || !Number.isFinite(laid.y)) {
+      invalid(`ELK returned no position for ${id}.`, "LAYOUT_MISSING_BOX");
+    }
+    const dim = context.dimensions.get(id);
+    const x = Math.floor(laid.x);
+    const y = Math.floor(laid.y);
+    const width2 = Math.max(dim.width, Math.ceil(laid.x + (laid.width ?? elkSize(dim.width))) - x + 1);
+    const height2 = Math.max(dim.height, Math.ceil(laid.y + (laid.height ?? elkSize(dim.height))) - y + 1);
+    boxes.push({ id, kind: context.subgraphs.has(id) ? "subgraph" : "node", x, y, width: width2, height: height2, lines: dim.lines, shape: dim.shape, ...context.parent.has(id) ? { parentId: context.parent.get(id) } : {} });
+  }
+  const boxById = new Map(boxes.map((box) => [box.id, box]));
+  context.__boxById = boxById;
+  const edgeOutputs = /* @__PURE__ */ new Map();
+  const internalEdges = /* @__PURE__ */ new Map();
+  walkEdges(result, internalEdges);
+  for (const [publicId, internalId] of context.edgeElkIds) {
+    const edge = internalEdges.get(internalId);
+    if (edge) edgeOutputs.set(publicId, edge);
+  }
+  const occupied = /* @__PURE__ */ new Map();
+  const placedLabels = [];
+  const routes = /* @__PURE__ */ new Map();
+  const endpointCounts = /* @__PURE__ */ new Map();
+  for (const item of context.graph.edges) {
+    endpointCounts.set(item.source, (endpointCounts.get(item.source) ?? 0) + 1);
+    endpointCounts.set(item.target, (endpointCounts.get(item.target) ?? 0) + 1);
+  }
+  const endpointRanks = /* @__PURE__ */ new Map();
+  for (const sourceEdge of context.graph.edges) {
+    const output = edgeOutputs.get(sourceEdge.id);
+    if (!output || !Array.isArray(output.sections) || output.sections.length === 0) {
+      invalid(`ELK returned no route for edge ${sourceEdge.id}.`, "LAYOUT_MISSING_EDGE");
+    }
+    const sourceBox = boxById.get(sourceEdge.source);
+    const targetBox = boxById.get(sourceEdge.target);
+    const sourceRank = endpointRanks.get(sourceEdge.source) ?? 0;
+    const targetRank = endpointRanks.get(sourceEdge.target) ?? 0;
+    endpointRanks.set(sourceEdge.source, sourceRank + 1);
+    endpointRanks.set(sourceEdge.target, targetRank + 1);
+    const sourceOffset = 2 * (sourceRank - Math.floor((endpointCounts.get(sourceEdge.source) ?? 1) / 2));
+    const targetOffset = 2 * (targetRank - Math.floor((endpointCounts.get(sourceEdge.target) ?? 1) / 2));
+    const route = routePoints(output, sourceBox, targetBox, floatBoxes, context, occupied, { sourceOffset, targetOffset }, sourceEdge.source === sourceEdge.target ? { rank: targetRank, count: endpointCounts.get(sourceEdge.target) ?? 1 } : void 0, sourceEdge.arrowStart, sourceEdge.arrowEnd);
+    if (route.length < 2) invalid(`ELK returned an empty route for edge ${sourceEdge.id}.`, "LAYOUT_EMPTY_EDGE");
+    routes.set(sourceEdge.id, route);
+    if (sourceEdge.stroke !== "invisible") addRouteToOccupied(occupied, route, sourceEdge, boxById);
+  }
+  const edges = [];
+  for (const sourceEdge of context.graph.edges) {
+    const output = edgeOutputs.get(sourceEdge.id);
+    const sourceBox = boxById.get(sourceEdge.source);
+    const route = routes.get(sourceEdge.id);
+    const label = sourceEdge.label ? edgeLabel(output, sourceEdge, route, sourceBox, boxById, placedLabels, routes) : void 0;
+    if (label) placedLabels.push({ ...label, route });
+    edges.push({ id: sourceEdge.id, points: route, arrowStart: sourceEdge.arrowStart ?? "none", arrowEnd: sourceEdge.arrowEnd ?? "none", stroke: sourceEdge.stroke ?? "normal", ...label ? { label } : {} });
+  }
+  const minX = Math.min(0, ...boxes.map((box) => box.x), ...edges.flatMap((edge) => edge.points.map((point) => point.x)));
+  const minY = Math.min(0, ...boxes.map((box) => box.y), ...edges.flatMap((edge) => edge.points.map((point) => point.y)));
+  if (minX !== 0 || minY !== 0) {
+    for (const box of boxes) {
+      box.x -= minX;
+      box.y -= minY;
+    }
+    for (const edge of edges) for (const point of edge.points) {
+      point.x -= minX;
+      point.y -= minY;
+    }
+    for (const edge of edges) if (edge.label) {
+      edge.label.x -= minX;
+      edge.label.y -= minY;
+    }
+  }
+  const width = Math.max(1, ...boxes.map((box) => box.x + box.width), ...edges.flatMap((edge) => edge.points.map((point) => point.x + 1)));
+  const height = Math.max(1, ...boxes.map((box) => box.y + box.height), ...edges.flatMap((edge) => edge.points.map((point) => point.y + 1)));
+  return { boxes, edges, width, height };
+}
+function walkOutput(node, elements, floatBoxes, isRoot = false) {
+  if (node?.id && !isRoot) {
+    elements.set(node.id, node);
+    if (Number.isFinite(node.x) && Number.isFinite(node.y)) floatBoxes.set(node.id, { x: node.x, y: node.y, width: node.width ?? 0, height: node.height ?? 0 });
+  }
+  for (const child of node?.children ?? []) walkOutput(child, elements, floatBoxes, false);
+}
+function walkEdges(node, edges) {
+  for (const edge of node?.edges ?? []) edges.set(edge.id, edge);
+  for (const child of node?.children ?? []) walkEdges(child, edges);
+}
+function routePoints(edge, sourceBox, targetBox, floatBoxes, context, occupied, endpointOffsets = {}, selfLoop, arrowStart = "none", arrowEnd = "none") {
+  if (!sourceBox || !targetBox) invalid(`An edge endpoint has no layout box.`, "LAYOUT_MISSING_BOX");
+  const sections = edge.sections;
+  if (selfLoop && sourceBox.id === targetBox.id) {
+    const custom = selfLoopRoute(sourceBox, selfLoop.rank, selfLoop.count);
+    if (!routeBlocked(custom, context.__boxById, allowedBoxes(context, sourceBox.id, targetBox.id), occupied, sourceBox.id, targetBox.id, arrowStart, arrowEnd)) return custom;
+  }
+  const raw = [];
+  for (const section of sections) {
+    const points2 = [section.startPoint, ...section.bendPoints ?? [], section.endPoint].filter(Boolean);
+    for (const point of points2) {
+      if (!raw.length || raw[raw.length - 1].x !== point.x || raw[raw.length - 1].y !== point.y) raw.push({ x: point.x, y: point.y });
+    }
+  }
+  if (raw.length < 2) return [];
+  const sourceFloat = floatBoxes.get(sourceBox.id);
+  const targetFloat = floatBoxes.get(targetBox.id);
+  const sourceAnchor = anchor(raw[0], raw[1], sourceFloat, sourceBox, endpointOffsets.sourceOffset ?? 0);
+  const targetAnchor = anchor(raw[raw.length - 1], raw[raw.length - 2], targetFloat, targetBox, endpointOffsets.targetOffset ?? 0);
+  raw[0] = sourceAnchor;
+  raw[raw.length - 1] = targetAnchor;
+  const points = orthogonalRound(raw);
+  points[0] = { ...sourceAnchor };
+  points[points.length - 1] = { ...targetAnchor };
+  restoreEndpointSegment(points, 0, 1);
+  restoreEndpointSegment(points, points.length - 1, -1);
+  nudgeRouteEndpoint(points, sourceBox, 0, 1, 0);
+  nudgeRouteEndpoint(points, targetBox, points.length - 1, -1, 0);
+  simplifyRoute(points);
+  const allowed = allowedBoxes(context, sourceBox.id, targetBox.id);
+  if (routeBlocked(points, context.__boxById, allowed, occupied, sourceBox.id, targetBox.id, arrowStart, arrowEnd)) {
+    const repaired = gridRepair(points[0], points[points.length - 1], context, sourceBox, targetBox, occupied, arrowStart, arrowEnd);
+    if (!repaired) invalid(`Integer grid routing collided while placing edge ${edge.id}.`, "LAYOUT_ROUTE_COLLISION");
+    return repaired;
+  }
+  return points;
+}
+function restoreEndpointSegment(points, index, neighborStep) {
+  const point = points[index];
+  const neighbor = points[index + neighborStep];
+  if (!point || !neighbor || point.x === neighbor.x || point.y === neighbor.y) return;
+  if (Math.abs(neighbor.x - point.x) >= Math.abs(neighbor.y - point.y)) neighbor.y = point.y;
+  else neighbor.x = point.x;
+}
+function selfLoopRoute(box, rank, count) {
+  const side = rank % 4;
+  const ring = Math.floor(rank / 4) + 2;
+  const left = box.x;
+  const right = box.x + box.width - 1;
+  const top = box.y;
+  const bottom = box.y + box.height - 1;
+  if (side === 0) {
+    const x = left - ring;
+    return [{ x: left, y: top + 1 }, { x, y: top + 1 }, { x, y: bottom - 1 }, { x: left, y: bottom - 1 }];
+  }
+  if (side === 1) {
+    const x = right + ring;
+    return [{ x: right, y: bottom - 1 }, { x, y: bottom - 1 }, { x, y: top + 1 }, { x: right, y: top + 1 }];
+  }
+  if (side === 2) {
+    const y2 = top - ring;
+    return [{ x: left + 1, y: top }, { x: left + 1, y: y2 }, { x: right - 1, y: y2 }, { x: right - 1, y: top }];
+  }
+  const y = bottom + ring;
+  return [{ x: right - 1, y: bottom }, { x: right - 1, y }, { x: left + 1, y }, { x: left + 1, y: bottom }];
+}
+function nudgeRouteEndpoint(points, box, index, neighborStep, offset) {
+  if (!offset || points.length < 2) return;
+  const point = points[index];
+  const neighbor = points[index + neighborStep];
+  if (!neighbor) return;
+  if (point.x === box.x || point.x === box.x + box.width - 1) {
+    point.y = Math.max(box.y, Math.min(box.y + box.height - 1, point.y + offset));
+    neighbor.y = point.y;
+  } else if (point.y === box.y || point.y === box.y + box.height - 1) {
+    point.x = Math.max(box.x, Math.min(box.x + box.width - 1, point.x + offset));
+    neighbor.x = point.x;
+  }
+}
+function anchor(point, neighbor, floatBox, box, offset = 0) {
+  const left = floatBox?.x ?? box.x;
+  const right = left + (floatBox?.width ?? box.width);
+  const top = floatBox?.y ?? box.y;
+  const bottom = top + (floatBox?.height ?? box.height);
+  const distances = [{ side: "left", value: Math.abs(point.x - left) }, { side: "right", value: Math.abs(point.x - right) }, { side: "top", value: Math.abs(point.y - top) }, { side: "bottom", value: Math.abs(point.y - bottom) }];
+  distances.sort((a, b) => a.value - b.value);
+  const side = distances[0].side;
+  if (side === "left" || side === "right") {
+    const center2 = box.y + Math.floor((box.height - 1) / 2);
+    const y = Math.max(box.y, Math.min(box.y + box.height - 1, center2 + offset));
+    return { x: side === "left" ? box.x : box.x + box.width - 1, y };
+  }
+  const center = box.x + Math.floor((box.width - 1) / 2);
+  const x = Math.max(box.x, Math.min(box.x + box.width - 1, center + offset));
+  return { x, y: side === "top" ? box.y : box.y + box.height - 1 };
+}
+function orthogonalRound(raw) {
+  const result = [{ x: Math.round(raw[0].x), y: Math.round(raw[0].y) }];
+  for (let i = 1; i < raw.length; i += 1) {
+    const current = { x: Math.round(raw[i].x), y: Math.round(raw[i].y) };
+    const previous = result[result.length - 1];
+    if (current.x === previous.x || current.y === previous.y) {
+      result.push(current);
+      continue;
+    }
+    if (Math.abs(current.x - previous.x) >= Math.abs(current.y - previous.y)) {
+      result.push({ x: current.x, y: previous.y });
+    } else {
+      result.push({ x: previous.x, y: current.y });
+    }
+    result.push(current);
+  }
+  return result;
+}
+function simplifyRoute(points) {
+  for (let i = points.length - 2; i > 0; i -= 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    const c = points[i + 1];
+    if (a.x === b.x && b.x === c.x || a.y === b.y && b.y === c.y) points.splice(i, 1);
+  }
+  return points;
+}
+function allowedBoxes(context, sourceId, targetId) {
+  const allowed = /* @__PURE__ */ new Set([sourceId, targetId]);
+  for (const id of context.element.keys()) {
+    if (isAncestor(context, id, sourceId) || isAncestor(context, id, targetId)) allowed.add(id);
+  }
+  return allowed;
+}
+function isAncestor(context, candidate, id) {
+  let current = context.parent.get(id);
+  while (current !== void 0) {
+    if (current === candidate) return true;
+    current = context.parent.get(current);
+  }
+  return false;
+}
+function routeBlocked(points, boxes, allowed, occupied, sourceId, targetId, arrowStart = "none", arrowEnd = "none") {
+  const pair = pairKey(sourceId, targetId);
+  const arrowCells = routeArrowKeys(points, arrowStart, arrowEnd);
+  for (let i = 1; i < points.length; i += 1) {
+    const orientation = points[i - 1].x === points[i].x ? "v" : "h";
+    for (const cell of segmentCells2(points[i - 1], points[i])) {
+      const existing = occupied.get(key2(cell.x, cell.y));
+      if (existing?.arrow || existing && arrowCells.has(key2(cell.x, cell.y)) || existing?.orientations.has(orientation)) return true;
+      for (const [id, box] of boxes) {
+        if (!box || !inside(cell, box) && !(box.kind === "node" && !allowed.has(id) && insideExpanded(cell, box, 1))) continue;
+        if (box.kind === "subgraph" && headerCell(cell, box)) return true;
+        if (box.kind === "node" && allowed.has(id)) {
+          const endpoint = key2(cell.x, cell.y) === key2(points[0].x, points[0].y) || key2(cell.x, cell.y) === key2(points.at(-1).x, points.at(-1).y);
+          if (!endpoint) return true;
+        } else if (!allowed.has(id)) return true;
+      }
+    }
+  }
+  return false;
+}
+function gridRepair(start, end, context, sourceBox, targetBox, occupied, arrowStart = "none", arrowEnd = "none") {
+  const boxes = context.__boxById;
+  if (!boxes) return null;
+  const sourceId = sourceBox.id;
+  const targetId = targetBox.id;
+  const pair = pairKey(sourceId, targetId);
+  const allowed = allowedBoxes(context, sourceId, targetId);
+  const directions = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+  const all = [...boxes.values()];
+  const starts = endpointCandidates(sourceBox, start);
+  const ends = endpointCandidates(targetBox, end);
+  for (const candidateStart of starts) for (const candidateEnd of ends) {
+    if (candidateStart.x === candidateEnd.x && candidateStart.y === candidateEnd.y && sourceId !== targetId) continue;
+    const startPoint = candidateStart;
+    const endPoint = candidateEnd;
+    for (const margin of [8, 16, 32, 64]) {
+      const minX = Math.min(startPoint.x, endPoint.x, ...all.map((b) => b.x)) - margin;
+      const maxX = Math.max(startPoint.x, endPoint.x, ...all.map((b) => b.x + b.width - 1)) + margin;
+      const minY = Math.min(startPoint.y, endPoint.y, ...all.map((b) => b.y)) - margin;
+      const maxY = Math.max(startPoint.y, endPoint.y, ...all.map((b) => b.y + b.height - 1)) + margin;
+      const queue = [startPoint];
+      const previous = /* @__PURE__ */ new Map([[key2(startPoint.x, startPoint.y), null]]);
+      const currentArrows = endpointArrowNeighborhood(startPoint, endPoint, arrowStart, arrowEnd);
+      const blocked = (x, y, orientation) => {
+        const cell = { x, y };
+        const existing = occupied.get(key2(x, y));
+        if (existing?.arrow || existing && currentArrows.has(key2(x, y)) || existing?.orientations.has(orientation)) return true;
+        for (const [id, box] of boxes) {
+          if (!inside(cell, box) && !(box.kind === "node" && !allowed.has(id) && insideExpanded(cell, box, 1))) continue;
+          if (box.kind === "subgraph" && headerCell(cell, box)) return true;
+          if (box.kind === "node" && allowed.has(id)) {
+            if (!(x === startPoint.x && y === startPoint.y) && !(x === endPoint.x && y === endPoint.y)) return true;
+          } else if (!allowed.has(id)) return true;
+        }
+        return false;
+      };
+      let head = 0;
+      while (head < queue.length) {
+        const current = queue[head++];
+        if (current.x === endPoint.x && current.y === endPoint.y) {
+          const path = [];
+          let cursor = current;
+          while (cursor) {
+            path.push(cursor);
+            cursor = previous.get(key2(cursor.x, cursor.y));
+          }
+          path.reverse();
+          return compress(path);
+        }
+        for (const [dx, dy] of directions) {
+          const x = current.x + dx;
+          const y = current.y + dy;
+          if (x < minX || x > maxX || y < minY || y > maxY || blocked(x, y, dx ? "h" : "v")) continue;
+          const k = key2(x, y);
+          if (previous.has(k)) continue;
+          previous.set(k, current);
+          queue.push({ x, y });
+        }
+      }
+    }
+  }
+  return null;
+}
+function endpointCandidates(box, preferred) {
+  const points = [];
+  for (let y = box.y; y < box.y + box.height; y += 1) {
+    for (let x = box.x; x < box.x + box.width; x += 1) {
+      if (x !== box.x && x !== box.x + box.width - 1 && y !== box.y && y !== box.y + box.height - 1) continue;
+      points.push({ x, y });
+    }
+  }
+  points.sort((a, b) => Math.abs(a.x - preferred.x) + Math.abs(a.y - preferred.y) - (Math.abs(b.x - preferred.x) + Math.abs(b.y - preferred.y)) || a.y - b.y || a.x - b.x);
+  return points.slice(0, 32);
+}
+function endpointArrowNeighborhood(start, end, arrowStart, arrowEnd) {
+  const cells = /* @__PURE__ */ new Set();
+  const add = (point) => {
+    for (const [dx, dy] of [[1, 0], [-1, 0], [0, 1], [0, -1]]) cells.add(key2(point.x + dx, point.y + dy));
+  };
+  if (arrowStart !== "none" && arrowStart !== void 0) add(start);
+  if (arrowEnd !== "none" && arrowEnd !== void 0) add(end);
+  return cells;
+}
+function headerCell(point, box) {
+  if (box.kind !== "subgraph" || point.y < box.y + 1 || point.y >= box.y + 1 + box.lines.length) return false;
+  const line = box.lines[point.y - box.y - 1] ?? "";
+  const left = box.x + 1 + Math.floor((Math.max(0, box.width - 2) - displayWidth(line)) / 2);
+  return point.x >= left && point.x < left + displayWidth(line);
+}
+function compress(points) {
+  if (points.length < 2) return points;
+  const result = [points[0]];
+  let dx = points[1].x - points[0].x;
+  let dy = points[1].y - points[0].y;
+  for (let i = 1; i < points.length - 1; i += 1) {
+    const ndx = points[i + 1].x - points[i].x;
+    const ndy = points[i + 1].y - points[i].y;
+    if (dx === 0 !== (ndx === 0)) result.push(points[i]);
+    dx = ndx;
+    dy = ndy;
+  }
+  result.push(points[points.length - 1]);
+  return result;
+}
+function addRouteToOccupied(occupied, points, edge, boxes) {
+  const sourceId = edge.source;
+  const targetId = edge.target;
+  for (let i = 1; i < points.length; i += 1) {
+    const orientation = points[i - 1].x === points[i].x ? "v" : "h";
+    for (const cell of segmentCells2(points[i - 1], points[i])) {
+      if (inside(cell, boxes.get(sourceId)) && cell !== points[0] || inside(cell, boxes.get(targetId)) && cell !== points.at(-1)) continue;
+      const cellKey = key2(cell.x, cell.y);
+      if (!occupied.has(cellKey)) occupied.set(cellKey, { orientations: /* @__PURE__ */ new Set(), pairs: /* @__PURE__ */ new Set() });
+      const entry = occupied.get(cellKey);
+      entry.orientations.add(orientation);
+      entry.pairs.add(pairKey(sourceId, targetId));
+      if (!entry.sources) entry.sources = /* @__PURE__ */ new Set();
+      entry.sources.add(sourceId);
+    }
+  }
+  markArrowOccupancy(occupied, points, edge.arrowStart, edge.arrowEnd);
+}
+function markArrowOccupancy(occupied, points, arrowStart, arrowEnd) {
+  const first = distinctRoutePair(points, true);
+  const last = distinctRoutePair(points, false);
+  for (const pair of [arrowStart !== "none" && arrowStart !== void 0 ? first : null, arrowEnd !== "none" && arrowEnd !== void 0 ? last : null]) {
+    if (!pair) continue;
+    const cell = key2(pair.next.x, pair.next.y);
+    if (!occupied.has(cell)) occupied.set(cell, { orientations: /* @__PURE__ */ new Set(), pairs: /* @__PURE__ */ new Set(), sources: /* @__PURE__ */ new Set() });
+    occupied.get(cell).arrow = true;
+  }
+}
+function distinctRoutePair(points, start) {
+  if (start) {
+    for (let i = 1; i < points.length; i += 1) if (points[i].x !== points[0].x || points[i].y !== points[0].y) return { next: oneStep2(points[0], points[i]) };
+  } else {
+    for (let i = points.length - 2; i >= 0; i -= 1) if (points[i].x !== points.at(-1).x || points[i].y !== points.at(-1).y) return { next: oneStep2(points.at(-1), points[i]) };
+  }
+  return null;
+}
+function oneStep2(end, toward) {
+  const dx = toward.x - end.x;
+  const dy = toward.y - end.y;
+  return Math.abs(dx) >= Math.abs(dy) ? { x: end.x + Math.sign(dx), y: end.y } : { x: end.x, y: end.y + Math.sign(dy) };
+}
+function routeArrowKeys(points, arrowStart = "none", arrowEnd = "none") {
+  const keys = /* @__PURE__ */ new Set();
+  const first = distinctRoutePair(points, true);
+  const last = distinctRoutePair(points, false);
+  if (arrowStart !== "none" && arrowStart !== void 0 && first) keys.add(key2(first.next.x, first.next.y));
+  if (arrowEnd !== "none" && arrowEnd !== void 0 && last) keys.add(key2(last.next.x, last.next.y));
+  return keys;
+}
+function segmentCells2(a, b) {
+  if (a.x !== b.x && a.y !== b.y) {
+    throw new FlowInkError(`Non-orthogonal segment from (${a.x},${a.y}) to (${b.x},${b.y}).`, { code: "NON_ORTHOGONAL_EDGE" });
+  }
+  const cells = [];
+  const dx = Math.sign(b.x - a.x);
+  const dy = Math.sign(b.y - a.y);
+  let x = a.x;
+  let y = a.y;
+  cells.push({ x, y });
+  while (x !== b.x || y !== b.y) {
+    x += dx;
+    y += dy;
+    cells.push({ x, y });
+  }
+  return cells;
+}
+function inside(point, box) {
+  return box && point.x >= box.x && point.x < box.x + box.width && point.y >= box.y && point.y < box.y + box.height;
+}
+function insideExpanded(point, box, margin) {
+  return point.x >= box.x - margin && point.x <= box.x + box.width - 1 + margin && point.y >= box.y - margin && point.y <= box.y + box.height - 1 + margin;
+}
+function edgeLabel(output, edge, route, sourceBox, boxes, placedLabels, routes) {
+  const source = output.labels?.[0];
+  const lines = labelLines(edge.label, edge.labelType).map(String);
+  const width = Math.max(1, Math.ceil(source?.width ?? maxWidth(lines, edge.label)));
+  const height = Math.max(1, Math.ceil(source?.height ?? lines.length));
+  let best = [route[0], route[1]];
+  let bestLength = -1;
+  for (let i = 1; i < route.length; i += 1) {
+    const length = Math.abs(route[i].x - route[i - 1].x) + Math.abs(route[i].y - route[i - 1].y);
+    if (length > bestLength) {
+      best = [route[i - 1], route[i]];
+      bestLength = length;
+    }
+  }
+  const [a, b] = best;
+  const midX = Math.floor((a.x + b.x) / 2);
+  const midY = Math.floor((a.y + b.y) / 2);
+  if (edge.source === edge.target && sourceBox) {
+    const routeMinX = Math.min(...route.map((point) => point.x));
+    const routeMaxX = Math.max(...route.map((point) => point.x));
+    const leftOfBox = routeMinX < sourceBox.x;
+    const y = Math.max(0, midY - Math.floor(height / 2));
+    const candidates2 = [
+      { x: leftOfBox ? routeMinX - width - 1 : routeMaxX + 2, y },
+      { x: leftOfBox ? routeMaxX + 2 : routeMinX - width - 1, y: y + height + 1 }
+    ];
+    for (const candidate of candidates2) {
+      if (candidate.x < 0 || labelCollides(candidate, width, height, route, boxes, placedLabels, routes)) continue;
+      return { ...candidate, lines, width, height };
+    }
+    return { x: Math.max(0, candidates2[0].x), y, lines, width, height };
+  }
+  const horizontal = b.y === a.y;
+  const centeredX = midX - Math.floor(width / 2);
+  const centeredY = midY - Math.floor(height / 2);
+  const candidates = horizontal ? [{ x: centeredX, y: centeredY - height - 1 }, { x: centeredX, y: centeredY + height + 1 }] : [{ x: centeredX - width - 1, y: centeredY }, { x: centeredX + width + 1, y: centeredY }];
+  candidates.push({ x: centeredX, y: centeredY });
+  for (const candidate of candidates) {
+    if (candidate.x < 0 || candidate.y < 0) continue;
+    if (labelCollides(candidate, width, height, route, boxes, placedLabels, routes)) continue;
+    return { ...candidate, lines, width, height };
+  }
+  return { x: Math.max(0, centeredX), y: Math.max(0, centeredY), lines, width, height };
+}
+function labelCollides(candidate, width, height, route, boxes, placedLabels, routes) {
+  const routeCells = /* @__PURE__ */ new Set();
+  for (const candidateRoute of routes.values()) {
+    for (let i = 1; i < candidateRoute.length; i += 1) for (const cell of segmentCells2(candidateRoute[i - 1], candidateRoute[i])) routeCells.add(key2(cell.x, cell.y));
+  }
+  for (let y = candidate.y; y < candidate.y + height; y += 1) {
+    for (let x = candidate.x; x < candidate.x + width; x += 1) {
+      if (routeCells.has(key2(x, y))) return true;
+      for (const box of boxes.values()) {
+        if (inside({ x, y }, box)) return true;
+      }
+    }
+  }
+  for (const label of placedLabels) {
+    if (candidate.x < label.x + label.width && label.x < candidate.x + width && candidate.y < label.y + label.height && label.y < candidate.y + height) return true;
+  }
+  return false;
+}
+function maxWidth(lines, fallback) {
+  if (lines.length > 0) return Math.max(1, ...lines.map((line) => Number(displayWidth(line))));
+  return Math.max(1, Number(displayWidth(String(fallback ?? ""))));
+}
+function positiveSize(value, fallback) {
+  return Number.isFinite(value) && value > 0 ? Math.max(1, Math.ceil(value)) : Math.max(1, Math.ceil(fallback));
+}
+function elkSize(cells) {
+  return Math.max(1, cells - 1);
+}
+function requireId(value, type) {
+  if (!value || typeof value.id !== "string" || value.id.length === 0) invalid(`Every ${type} must have a non-empty string id.`);
+}
+function invalid(message, code = "INVALID_GRAPH") {
+  throw new FlowInkError(message, { code });
+}
+function key2(x, y) {
+  return `${x},${y}`;
+}
+function pairKey(source, target) {
+  return `${source}\0${target}`;
+}
+
+// src/rasterize.js
+function rasterize(layout2, options = {}) {
+  const charset = options?.charset ?? "ascii";
+  if (charset !== "ascii" && charset !== "unicode") {
+    throw new FlowInkError('charset must be "ascii" or "unicode".', { code: "INVALID_OPTIONS" });
+  }
+  const checked = validateLayout(layout2);
+  const { boxes, edges, labels, width, height } = checked;
+  const grid = makeGrid(width, height);
+  const interior = buildInteriorMap(boxes, width, height);
+  const nodeBorders = buildNodeBorderMap(boxes, width, height);
+  const boxBorders = buildBoxBorderMap(boxes, width, height);
+  const endpointOwners = buildEndpointOwners(edges);
+  for (const edge of edges) drawEdge(grid, edge, interior, nodeBorders, boxBorders, endpointOwners, labels, charset);
+  for (const box of boxes) drawBox(grid, box, charset);
+  for (const edge of edges) {
+    if (edge.label) drawLabel(grid, edge.label, `edge ${edge.id}`, edge.id);
+  }
+  for (const edge of edges) drawArrows(grid, edge, boxes, charset);
+  return stringifyGrid(grid);
+}
+function validateLayout(layout2) {
+  if (!layout2 || typeof layout2 !== "object") fail2("Layout must be an object.", "INVALID_LAYOUT");
+  if (!Array.isArray(layout2.boxes) || !Array.isArray(layout2.edges)) {
+    fail2("Layout must contain boxes and edges arrays.", "INVALID_LAYOUT");
+  }
+  if (!Number.isInteger(layout2.width) || !Number.isInteger(layout2.height) || layout2.width < 0 || layout2.height < 0) {
+    fail2("Layout width and height must be non-negative integers.", "INVALID_LAYOUT");
+  }
+  const boxIds = /* @__PURE__ */ new Set();
+  const boxes = layout2.boxes.map((box, index) => {
+    if (!box || typeof box !== "object") fail2(`Layout box ${index} is invalid.`, "INVALID_LAYOUT");
+    if (typeof box.id !== "string" || boxIds.has(box.id)) fail2(`Layout box id is missing or duplicated: ${box.id ?? index}.`, "INVALID_LAYOUT");
+    boxIds.add(box.id);
+    for (const key3 of ["x", "y", "width", "height"]) {
+      if (!Number.isInteger(box[key3])) fail2(`Layout box ${box.id} has a non-integer ${key3}.`, "INVALID_LAYOUT");
+    }
+    if (box.x < 0 || box.y < 0 || box.width < 1 || box.height < 1) fail2(`Layout box ${box.id} has invalid geometry.`, "INVALID_LAYOUT");
+    if (!Array.isArray(box.lines)) fail2(`Layout box ${box.id} must provide lines.`, "INVALID_LAYOUT");
+    if (box.lines.some((line) => typeof line !== "string")) fail2(`Layout box ${box.id} has a non-string label line.`, "INVALID_LAYOUT");
+    return { ...box, shape: String(box.shape ?? "rect") };
+  });
+  for (let i = 0; i < boxes.length; i += 1) {
+    for (let j = i + 1; j < boxes.length; j += 1) {
+      if (partialBoxOverlap(boxes[i], boxes[j])) {
+        fail2(`Layout boxes ${boxes[i].id} and ${boxes[j].id} overlap.`, "BOX_OVERLAP");
+      }
+    }
+  }
+  const edgeIds = /* @__PURE__ */ new Set();
+  const edges = layout2.edges.map((edge, index) => {
+    if (!edge || typeof edge !== "object") fail2(`Layout edge ${index} is invalid.`, "INVALID_LAYOUT");
+    if (typeof edge.id !== "string" || edgeIds.has(edge.id)) fail2(`Layout edge id is missing or duplicated: ${edge.id ?? index}.`, "INVALID_LAYOUT");
+    edgeIds.add(edge.id);
+    if (!Array.isArray(edge.points) || edge.points.length < 1) fail2(`Layout edge ${edge.id} must have at least one point.`, "INVALID_LAYOUT");
+    const points = edge.points.map((point, pointIndex) => {
+      if (!point || !Number.isInteger(point.x) || !Number.isInteger(point.y) || point.x < 0 || point.y < 0) {
+        fail2(`Layout edge ${edge.id} has an invalid point at ${pointIndex}.`, "INVALID_LAYOUT");
+      }
+      return { x: point.x, y: point.y };
+    });
+    for (let i = 1; i < points.length; i += 1) {
+      if (points[i - 1].x !== points[i].x && points[i - 1].y !== points[i].y) {
+        fail2(`Layout edge ${edge.id} is not orthogonal.`, "NON_ORTHOGONAL_EDGE");
+      }
+    }
+    for (const arrow of [edge.arrowStart, edge.arrowEnd].filter((value) => value !== void 0)) {
+      if (!["none", "point", "circle", "cross"].includes(arrow)) fail2(`Layout edge ${edge.id} has an invalid arrow type.`, "INVALID_LAYOUT");
+    }
+    if (edge.stroke !== void 0 && !["normal", "thick", "dotted", "invisible"].includes(edge.stroke)) {
+      fail2(`Layout edge ${edge.id} has an invalid stroke.`, "INVALID_LAYOUT");
+    }
+    return {
+      ...edge,
+      points,
+      arrowStart: edge.arrowStart ?? "none",
+      arrowEnd: edge.arrowEnd ?? "none",
+      stroke: edge.stroke ?? "normal"
+    };
+  });
+  const labels = [];
+  for (const edge of edges) {
+    if (!edge.label) continue;
+    const label = normalizeLabel2(edge.label, `edge ${edge.id}`);
+    labels.push(label);
+  }
+  let width = layout2.width;
+  let height = layout2.height;
+  for (const box of boxes) {
+    width = Math.max(width, box.x + box.width);
+    height = Math.max(height, box.y + box.height);
+  }
+  for (const edge of edges) for (const point of edge.points) {
+    width = Math.max(width, point.x + 1);
+    height = Math.max(height, point.y + 1);
+  }
+  for (const label of labels) {
+    width = Math.max(width, label.x + label.width);
+    height = Math.max(height, label.y + label.height);
+  }
+  return { boxes, edges, labels, width, height };
+}
+function normalizeLabel2(label, owner) {
+  if (!label || !Number.isInteger(label.x) || !Number.isInteger(label.y) || label.x < 0 || label.y < 0 || !Array.isArray(label.lines)) {
+    fail2(`Label for ${owner} is invalid.`, "INVALID_LAYOUT");
+  }
+  if (label.lines.some((line) => typeof line !== "string")) fail2(`Label for ${owner} has a non-string line.`, "INVALID_LAYOUT");
+  const measured = Math.max(0, ...label.lines.map((line) => displayWidth(line)));
+  const width = Number.isInteger(label.width) && label.width >= measured ? label.width : measured;
+  const height = Number.isInteger(label.height) && label.height >= label.lines.length ? label.height : label.lines.length;
+  return { ...label, width, height };
+}
+function partialBoxOverlap(a, b) {
+  const overlap = a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+  if (!overlap) return false;
+  const contains = (outer, inner) => outer.kind === "subgraph" && outer.x <= inner.x && outer.y <= inner.y && outer.x + outer.width >= inner.x + inner.width && outer.y + outer.height >= inner.y + inner.height;
+  return !contains(a, b) && !contains(b, a);
+}
+function makeGrid(width, height) {
+  return Array.from({ length: height }, () => Array.from({ length: width }, () => ({ glyph: " ", kind: "empty", wide: false, edge: null })));
+}
+function buildInteriorMap(boxes, width, height) {
+  const map = /* @__PURE__ */ new Map();
+  const add = (x, y, box) => {
+    if (x < 0 || y < 0 || x >= width || y >= height) return;
+    const key3 = `${x},${y}`;
+    const old = map.get(key3);
+    if (old && old !== box.id) fail2(`Nested box interiors overlap at (${x},${y}).`, "BOX_OVERLAP");
+    map.set(key3, box.id);
+  };
+  for (const box of boxes) {
+    if (box.kind === "subgraph") continue;
+    for (let y = box.y + 1; y < box.y + box.height - 1; y += 1) {
+      for (let x = box.x + 1; x < box.x + box.width - 1; x += 1) add(x, y, box);
+    }
+  }
+  return map;
+}
+function buildNodeBorderMap(boxes, width, height) {
+  const map = /* @__PURE__ */ new Map();
+  for (const box of boxes) {
+    if (box.kind === "subgraph") continue;
+    for (const { x, y } of boxBorderCells(box, "ascii")) {
+      if (x >= 0 && y >= 0 && x < width && y < height) map.set(`${x},${y}`, box.id);
+    }
+  }
+  return map;
+}
+function buildBoxBorderMap(boxes, width, height) {
+  const map = /* @__PURE__ */ new Map();
+  for (const box of boxes) {
+    for (const { x, y } of boxBorderCells(box, "ascii")) {
+      if (x >= 0 && y >= 0 && x < width && y < height) map.set(`${x},${y}`, box.id);
+    }
+  }
+  return map;
+}
+function buildEndpointOwners(edges) {
+  const map = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    for (const point of [edge.points[0], edge.points.at(-1)]) {
+      const key3 = `${point.x},${point.y}`;
+      if (!map.has(key3)) map.set(key3, /* @__PURE__ */ new Set());
+      map.get(key3).add(edge.id);
+    }
+  }
+  return map;
+}
+function drawEdge(grid, edge, interior, nodeBorders, boxBorders, endpointOwners, labels, charset) {
+  if (edge.stroke === "invisible") return;
+  const points = edge.points;
+  const endpoints = /* @__PURE__ */ new Set([`${points[0].x},${points[0].y}`, `${points[points.length - 1].x},${points[points.length - 1].y}`]);
+  const legitimateSelfLoop = points[0].x === points.at(-1).x && points[0].y === points.at(-1).y && boxBorders.has(`${points[0].x},${points[0].y}`);
+  const cells = /* @__PURE__ */ new Map();
+  const add = (x, y, directions, segmentIndex = -1) => {
+    const cell = grid[y]?.[x];
+    if (!cell) fail2(`Edge ${edge.id} lies outside the layout.`, "LAYOUT_CLIP");
+    if (interior.has(`${x},${y}`)) fail2(`Edge ${edge.id} passes through a box interior at (${x},${y}).`, "EDGE_BOX_COLLISION");
+    if (nodeBorders.has(`${x},${y}`) && !endpoints.has(`${x},${y}`)) fail2(`Edge ${edge.id} crosses a non-endpoint node border at (${x},${y}).`, "EDGE_BOX_COLLISION");
+    const key3 = `${x},${y}`;
+    let route = cells.get(key3);
+    if (!route) {
+      route = { dirs: /* @__PURE__ */ new Set(), edgeIds: /* @__PURE__ */ new Set(), stroke: edge.stroke, segmentIndices: /* @__PURE__ */ new Set() };
+      cells.set(key3, route);
+    }
+    for (const direction of directions) route.dirs.add(direction);
+    route.edgeIds.add(edge.id);
+    route.segmentIndices.add(segmentIndex);
+    if (strokeRank(edge.stroke) > strokeRank(route.stroke)) route.stroke = edge.stroke;
+  };
+  if (points.length === 1) add(points[0].x, points[0].y, []);
+  for (let i = 1; i < points.length; i += 1) {
+    const a = points[i - 1];
+    const b = points[i];
+    const dx = Math.sign(b.x - a.x);
+    const dy = Math.sign(b.y - a.y);
+    const direction = dx ? dx > 0 ? "right" : "left" : dy > 0 ? "down" : "up";
+    const reverse = opposite(direction);
+    const count = Math.max(Math.abs(b.x - a.x), Math.abs(b.y - a.y));
+    for (let step = 0; step <= count; step += 1) {
+      const x = a.x + dx * step;
+      const y = a.y + dy * step;
+      add(x, y, step === 0 ? [direction] : step === count ? [reverse] : [direction, reverse], i - 1);
+    }
+  }
+  for (const [key3, route] of cells) {
+    const segments = [...route.segmentIndices].filter((index) => index >= 0).sort((a, b) => a - b);
+    const endpointBorder = endpointOwners.get(key3)?.has(edge.id) && boxBorders.has(key3);
+    if (segments.length > 1 && segments.at(-1) - segments[0] > 1 && !endpointBorder && !legitimateSelfLoop) {
+      fail2(`Edge ${edge.id} crosses itself at (${key3.replace(",", ",")}).`, "ROUTE_COLLISION");
+    }
+  }
+  for (const [key3, route] of cells) {
+    const [x, y] = key3.split(",").map(Number);
+    const cell = grid[y][x];
+    if (cell.kind === "label" || cell.kind === "box-label") fail2(`Edge ${edge.id} overwrites a label at (${x},${y}).`, "EDGE_LABEL_COLLISION");
+    if (!cell.edge) cell.edge = { dirs: /* @__PURE__ */ new Set(), edgeIds: /* @__PURE__ */ new Set(), stroke: route.stroke, edgeRoutes: /* @__PURE__ */ new Map() };
+    for (const [otherId, otherRoute] of cell.edge.edgeRoutes) {
+      const allowed = sharedIntersection(key3, edge.id, otherId, boxBorders, endpointOwners);
+      if (!allowed && !compatibleCrossing(route.dirs, otherRoute.dirs)) {
+        fail2(`Edges ${otherId} and ${edge.id} overlap ambiguously at (${x},${y}).`, "ROUTE_COLLISION");
+      }
+    }
+    cell.edge.edgeRoutes.set(edge.id, { dirs: new Set(route.dirs), segmentIndices: new Set(route.segmentIndices) });
+    for (const d of route.dirs) cell.edge.dirs.add(d);
+    for (const id of route.edgeIds) cell.edge.edgeIds.add(id);
+    if (strokeRank(route.stroke) > strokeRank(cell.edge.stroke)) cell.edge.stroke = route.stroke;
+    cell.kind = "edge";
+    cell.glyph = edgeGlyph(cell.edge.dirs, cell.edge.edgeIds, cell.edge.stroke, charset);
+  }
+  for (const label of labels) {
+    for (let y = label.y; y < label.y + label.height; y += 1) for (let x = label.x; x < label.x + label.width; x += 1) {
+      if (grid[y]?.[x]?.kind === "box-label") fail2(`Edge label overlaps a box label at (${x},${y}).`, "LABEL_COLLISION");
+    }
+  }
+}
+function sharedIntersection(key3, firstId, secondId, boxBorders, endpointOwners) {
+  const owners = endpointOwners.get(key3);
+  if (owners?.has(firstId) && owners.has(secondId)) return true;
+  return boxBorders.has(key3) && (!owners || owners.size === 0);
+}
+function compatibleCrossing(first, second) {
+  const firstHorizontal = first.has("left") && first.has("right") && !first.has("up") && !first.has("down");
+  const firstVertical = first.has("up") && first.has("down") && !first.has("left") && !first.has("right");
+  const secondHorizontal = second.has("left") && second.has("right") && !second.has("up") && !second.has("down");
+  const secondVertical = second.has("up") && second.has("down") && !second.has("left") && !second.has("right");
+  return firstHorizontal && secondVertical || firstVertical && secondHorizontal;
+}
+function drawBox(grid, box, charset) {
+  const cells = boxBorderCells(box, charset);
+  for (const { x, y, glyph } of cells) {
+    const cell = grid[y]?.[x];
+    if (!cell) fail2(`Box ${box.id} lies outside the layout.`, "LAYOUT_CLIP");
+    if (cell.kind === "box-label" || cell.kind === "label") fail2(`Box ${box.id} overwrites a label at (${x},${y}).`, "BOX_LABEL_COLLISION");
+    const route = cell.edge;
+    if (route && box.kind !== "subgraph") {
+      cell.edge = null;
+    }
+    cell.kind = "box";
+    cell.glyph = route && box.kind === "subgraph" ? borderWithRoute(glyph, route, charset) : glyph;
+  }
+  const innerWidth = Math.max(0, box.width - 2);
+  const innerHeight = Math.max(0, box.height - 2);
+  const lines = box.lines;
+  if (lines.length > innerHeight) fail2(`Box ${box.id} does not have enough height for its label.`, "BOX_LABEL_COLLISION");
+  const top = box.kind === "subgraph" ? box.y + 1 : box.y + 1 + Math.floor((innerHeight - lines.length) / 2);
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const lineWidth = displayWidth(line);
+    if (lineWidth > innerWidth) fail2(`Box ${box.id} does not have enough width for its label.`, "BOX_LABEL_COLLISION");
+    const left = box.x + 1 + Math.floor((innerWidth - lineWidth) / 2);
+    putText(grid, left, top + i, line, "box-label", `box ${box.id}`);
+  }
+}
+function boxBorderCells(box, charset) {
+  const out = [];
+  const { x, y, width: w, height: h } = box;
+  const shape = String(box.shape ?? "rect").toLowerCase();
+  const glyphs = charset === "unicode";
+  const put = (xx, yy, glyph) => out.push({ x: xx, y: yy, glyph });
+  if (w === 1 || h === 1) {
+    for (let yy = y; yy < y + h; yy += 1) for (let xx = x; xx < x + w; xx += 1) put(xx, yy, glyphs ? "\u2502" : "|");
+    return out;
+  }
+  const rounded = shape === "round" || shape === "rounded" || shape === "stadium" || shape === "circle";
+  if (rounded) {
+    const c = glyphs ? ["\u256D", "\u256E", "\u2570", "\u256F"] : ["/", "\\", "\\", "/"];
+    put(x, y, c[0]);
+    put(x + w - 1, y, c[1]);
+    put(x, y + h - 1, c[2]);
+    put(x + w - 1, y + h - 1, c[3]);
+    for (let xx = x + 1; xx < x + w - 1; xx += 1) {
+      put(xx, y, glyphs ? "\u2500" : "-");
+      put(xx, y + h - 1, glyphs ? "\u2500" : "-");
+    }
+    for (let yy = y + 1; yy < y + h - 1; yy += 1) {
+      put(x, yy, glyphs ? "\u2502" : "|");
+      put(x + w - 1, yy, glyphs ? "\u2502" : "|");
+    }
+    return out;
+  }
+  if (shape === "diamond" || shape === "rhombus") {
+    const slash = glyphs ? "\u2571" : "/";
+    const back = glyphs ? "\u2572" : "\\";
+    const vertical = glyphs ? "\u2502" : "|";
+    for (let xx = x + 1; xx < x + w - 1; xx += 1) {
+      put(xx, y, glyphs ? "\u2500" : "-");
+      put(xx, y + h - 1, glyphs ? "\u2500" : "-");
+    }
+    put(x, y, slash);
+    put(x + w - 1, y, back);
+    put(x, y + h - 1, back);
+    put(x + w - 1, y + h - 1, slash);
+    for (let yy = y + 1; yy < y + h - 1; yy += 1) {
+      const left = yy === y + Math.floor((h - 1) / 2) ? glyphs ? "\u25C1" : "<" : vertical;
+      const right = yy === y + Math.floor((h - 1) / 2) ? glyphs ? "\u25B7" : ">" : vertical;
+      put(x, yy, left);
+      put(x + w - 1, yy, right);
+    }
+    return out;
+  }
+  const corner = glyphs ? ["\u250C", "\u2510", "\u2514", "\u2518"] : ["+", "+", "+", "+"];
+  put(x, y, corner[0]);
+  put(x + w - 1, y, corner[1]);
+  put(x, y + h - 1, corner[2]);
+  put(x + w - 1, y + h - 1, corner[3]);
+  for (let xx = x + 1; xx < x + w - 1; xx += 1) {
+    put(xx, y, glyphs ? "\u2500" : "-");
+    put(xx, y + h - 1, glyphs ? "\u2500" : "-");
+  }
+  for (let yy = y + 1; yy < y + h - 1; yy += 1) {
+    put(x, yy, glyphs ? "\u2502" : "|");
+    put(x + w - 1, yy, glyphs ? "\u2502" : "|");
+  }
+  return out;
+}
+function borderWithRoute(border, route, charset) {
+  const horizontal = route.dirs.has("left") || route.dirs.has("right");
+  const vertical = route.dirs.has("up") || route.dirs.has("down");
+  if (horizontal && vertical) return charset === "unicode" ? "\u253C" : "+";
+  if (horizontal && route.dirs.has("left") && route.dirs.has("right")) return charset === "unicode" ? "\u2500" : "-";
+  if (vertical && route.dirs.has("up") && route.dirs.has("down")) return charset === "unicode" ? "\u2502" : "|";
+  return border;
+}
+function drawLabel(grid, label, owner, edgeId) {
+  for (let i = 0; i < label.lines.length; i += 1) putText(grid, label.x, label.y + i, label.lines[i], "label", owner, false, edgeId);
+}
+function putText(grid, x, y, text, kind, owner, allowRoute = false, allowedEdgeId = void 0) {
+  if (!grid[y]) fail2(`${owner} lies outside the layout.`, "LAYOUT_CLIP");
+  let column = x;
+  let previous = null;
+  for (const grapheme of segment(text)) {
+    const w = Math.max(0, displayWidth(grapheme));
+    if (w === 0) {
+      if (previous) previous.glyph += grapheme;
+      continue;
+    }
+    if (column < 0 || column + w > grid[y].length) fail2(`${owner} lies outside the layout.`, "LAYOUT_CLIP");
+    for (let offset = 0; offset < w; offset += 1) {
+      const cell = grid[y][column + offset];
+      const routeLabel = (kind === "label" || allowRoute) && cell.kind === "edge" && (!allowedEdgeId || cell.edge?.edgeIds.size === 1 && cell.edge.edgeIds.has(allowedEdgeId));
+      if (!routeLabel && (cell.kind === "box" || cell.kind === "edge" || cell.kind === "arrow" || cell.kind === "label" || cell.kind === "box-label")) {
+        fail2(`${owner} collides at (${column + offset},${y}).`, "LABEL_COLLISION");
+      }
+      cell.kind = kind;
+      cell.glyph = offset === 0 ? grapheme : "";
+      cell.wide = offset === 0 && w > 1;
+    }
+    previous = grid[y][column];
+    column += w;
+  }
+}
+function drawArrows(grid, edge, boxes, charset) {
+  if (edge.stroke === "invisible" || edge.points.length < 2) return;
+  const place = (kind, arrow, at, toward) => {
+    if (!arrow || arrow === "none") return;
+    const cell = grid[at.y]?.[at.x];
+    if (!cell) fail2(`Arrow for edge ${edge.id} lies outside the layout.`, "LAYOUT_CLIP");
+    if (cell.kind === "box-label" || cell.kind === "label") fail2(`Arrow for edge ${edge.id} overwrites a label.`, "EDGE_LABEL_COLLISION");
+    if (cell.kind === "box") fail2(`Arrow for edge ${edge.id} overwrites a box border.`, "EDGE_BOX_COLLISION");
+    if (cell.kind === "arrow") fail2(`Arrow for edge ${edge.id} overlaps another arrow.`, "ARROW_COLLISION");
+    if (cell.kind === "edge" && cell.edge && [...cell.edge.edgeIds].some((id) => id !== edge.id)) {
+      fail2(`Arrow for edge ${edge.id} hides another route.`, "ARROW_COLLISION");
+    }
+    const glyph = arrowGlyph(arrow, toward, charset);
+    cell.kind = "arrow";
+    cell.glyph = glyph;
+    cell.wide = false;
+  };
+  const first = distinctPair2(edge.points, true);
+  const last = distinctPair2(edge.points, false);
+  if (first) place("start", edge.arrowStart, first.next, opposite(directionBetween(first.current, first.next)));
+  if (last) place("end", edge.arrowEnd, last.previous, directionBetween(last.previous, last.current));
+}
+function distinctPair2(points, start) {
+  if (start) {
+    for (let i = 1; i < points.length; i += 1) if (points[i].x !== points[0].x || points[i].y !== points[0].y) return { current: points[0], next: oneStep3(points[0], points[i]) };
+  } else {
+    for (let i = points.length - 2; i >= 0; i -= 1) if (points[i].x !== points[points.length - 1].x || points[i].y !== points[points.length - 1].y) return { previous: oneStep3(points[points.length - 1], points[i]), current: points[points.length - 1] };
+  }
+  return null;
+}
+function oneStep3(end, toward) {
+  return { x: end.x + Math.sign(toward.x - end.x), y: end.y + Math.sign(toward.y - end.y) };
+}
+function directionBetween(a, b) {
+  if (b.x > a.x) return "right";
+  if (b.x < a.x) return "left";
+  if (b.y > a.y) return "down";
+  return "up";
+}
+function edgeGlyph(dirs, edgeIds, stroke, charset) {
+  if (dirs.size === 0) return charset === "unicode" ? "\xB7" : ".";
+  const has = (d) => dirs.has(d);
+  if (dirs.size >= 4) return charset === "unicode" ? edgeIds.size > 1 ? "\u2573" : "\u253C" : edgeIds.size > 1 ? "#" : "+";
+  if (dirs.size === 3) return charset === "unicode" ? "\u253C" : "+";
+  if (dirs.size === 2 && has("left") && has("right")) return charset === "unicode" ? unicodeStroke(stroke, "h") : asciiStroke(stroke, "h");
+  if (dirs.size === 2 && has("up") && has("down")) return charset === "unicode" ? unicodeStroke(stroke, "v") : asciiStroke(stroke, "v");
+  if (dirs.size === 2) {
+    if (charset === "ascii") return "+";
+    if (has("right") && has("down")) return "\u250C";
+    if (has("left") && has("down")) return "\u2510";
+    if (has("right") && has("up")) return "\u2514";
+    return "\u2518";
+  }
+  return charset === "unicode" ? has("left") || has("right") ? unicodeStroke(stroke, "h") : unicodeStroke(stroke, "v") : has("left") || has("right") ? asciiStroke(stroke, "h") : asciiStroke(stroke, "v");
+}
+function asciiStroke(stroke, axis) {
+  return stroke === "thick" ? axis === "h" ? "=" : "#" : stroke === "dotted" ? axis === "h" ? ":" : ":" : axis === "h" ? "-" : "|";
+}
+function unicodeStroke(stroke, axis) {
+  return stroke === "thick" ? axis === "h" ? "\u2501" : "\u2503" : stroke === "dotted" ? axis === "h" ? "\u2504" : "\u2506" : axis === "h" ? "\u2500" : "\u2502";
+}
+function strokeRank(stroke) {
+  return stroke === "thick" ? 3 : stroke === "normal" ? 2 : stroke === "dotted" ? 1 : 0;
+}
+function opposite(direction) {
+  return { left: "right", right: "left", up: "down", down: "up" }[direction];
+}
+function arrowGlyph(arrow, direction, charset) {
+  if (arrow === "circle") return charset === "unicode" ? "\u25CB" : "o";
+  if (arrow === "cross") return charset === "unicode" ? "\xD7" : "x";
+  if (charset === "unicode") return { left: "\u25C0", right: "\u25B6", up: "\u25B2", down: "\u25BC" }[direction] ?? "\u25B6";
+  return { left: "<", right: ">", up: "^", down: "v" }[direction] ?? ">";
+}
+function stringifyGrid(grid) {
+  if (!grid.length) return "";
+  let left = Infinity;
+  let right = -1;
+  for (const row of grid) {
+    for (let x = 0; x < row.length; x += 1) {
+      if (row[x].glyph && row[x].glyph !== " ") {
+        left = Math.min(left, x);
+        right = Math.max(right, x);
+      }
+    }
+  }
+  if (right < 0) return "";
+  const lines = grid.slice().map((row) => row.slice(left, right + 1).map((cell) => cell.glyph === "" ? "" : cell.glyph || " ").join("").replace(/[ \t]+$/u, ""));
+  while (lines.length && lines[lines.length - 1] === "") lines.pop();
+  while (lines.length && lines[0] === "") lines.shift();
+  return lines.join("\n");
+}
+function segment(value) {
+  if (typeof Intl !== "undefined" && Intl.Segmenter) return Array.from(new Intl.Segmenter(void 0, { granularity: "grapheme" }).segment(value), (item) => item.segment);
+  return Array.from(value);
+}
+function fail2(message, code) {
+  throw new FlowInkError(message, { code });
+}
+
+// src/index.js
+async function render(source, options = {}) {
+  if (!options || typeof options !== "object") {
+    throw new FlowInkError("Render options must be an object.", { code: "INVALID_OPTIONS" });
+  }
+  const charset = options.charset ?? "ascii";
+  if (charset !== "ascii" && charset !== "unicode") {
+    throw new FlowInkError('charset must be "ascii" or "unicode".', { code: "INVALID_OPTIONS" });
+  }
+  const graph = parse(source);
+  try {
+    return rasterize(await layout(graph), { charset });
+  } catch (cause) {
+    if (cause instanceof FlowInkError) throw cause;
+    throw new FlowInkError(`Cannot lay out this flowchart: ${cause instanceof Error ? cause.message : String(cause)}`, { code: "LAYOUT_ERROR", cause });
+  }
+}
+export {
+  FlowInkError,
+  parse,
+  render
+};
+//# sourceMappingURL=index.js.map