@digipair/skill-web-chatbot 0.91.0-0 → 0.91.0

package/blockDiagram-5dc23a45.esm.js

@@ -0,0 +1,2919 @@
+import { V as Vn, b0 as $t, c as L, j as B_, ah as Je$1, $ as $n, b as bt, O as Ol, B as B0 } from './index.esm2.js';
+import { a } from './clone-afc2f047.esm.js';
+import { e } from './channel-ebbc4130.esm.js';
+import { h as hr, g as gr, x as xr, u as ur, o as or, p as pr } from './edges-16357fde.esm.js';
+import { Z as Ze$1 } from './graph-0ee63739.esm.js';
+import { h } from './ordinal-5695958c.esm.js';
+import { r } from './Tableau10-558cc280.esm.js';
+import './createText-03b82060.esm.js';
+import './line-24d93f1b.esm.js';
+import './array-2ff2c7a6.esm.js';
+import './path-428ebac9.esm.js';
+import './init-f9637058.esm.js';
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var ee = function() {
+    var e = function e(D, l, s, r) {
+        for(s = s || {}, r = D.length; r--; s[D[r]] = l);
+        return s;
+    }, c = [
+        1,
+        7
+    ], u = [
+        1,
+        13
+    ], a = [
+        1,
+        14
+    ], i = [
+        1,
+        15
+    ], g = [
+        1,
+        19
+    ], o = [
+        1,
+        16
+    ], p = [
+        1,
+        17
+    ], f = [
+        1,
+        18
+    ], m = [
+        8,
+        30
+    ], S = [
+        8,
+        21,
+        28,
+        29,
+        30,
+        31,
+        32,
+        40,
+        44,
+        47
+    ], y = [
+        1,
+        23
+    ], z = [
+        1,
+        24
+    ], I = [
+        8,
+        15,
+        16,
+        21,
+        28,
+        29,
+        30,
+        31,
+        32,
+        40,
+        44,
+        47
+    ], w = [
+        8,
+        15,
+        16,
+        21,
+        27,
+        28,
+        29,
+        30,
+        31,
+        32,
+        40,
+        44,
+        47
+    ], C = [
+        1,
+        49
+    ], E = {
+        trace: function trace() {},
+        yy: {},
+        symbols_: {
+            error: 2,
+            spaceLines: 3,
+            SPACELINE: 4,
+            NL: 5,
+            separator: 6,
+            SPACE: 7,
+            EOF: 8,
+            start: 9,
+            BLOCK_DIAGRAM_KEY: 10,
+            document: 11,
+            stop: 12,
+            statement: 13,
+            link: 14,
+            LINK: 15,
+            START_LINK: 16,
+            LINK_LABEL: 17,
+            STR: 18,
+            nodeStatement: 19,
+            columnsStatement: 20,
+            SPACE_BLOCK: 21,
+            blockStatement: 22,
+            classDefStatement: 23,
+            cssClassStatement: 24,
+            styleStatement: 25,
+            node: 26,
+            SIZE: 27,
+            COLUMNS: 28,
+            "id-block": 29,
+            end: 30,
+            block: 31,
+            NODE_ID: 32,
+            nodeShapeNLabel: 33,
+            dirList: 34,
+            DIR: 35,
+            NODE_DSTART: 36,
+            NODE_DEND: 37,
+            BLOCK_ARROW_START: 38,
+            BLOCK_ARROW_END: 39,
+            classDef: 40,
+            CLASSDEF_ID: 41,
+            CLASSDEF_STYLEOPTS: 42,
+            DEFAULT: 43,
+            class: 44,
+            CLASSENTITY_IDS: 45,
+            STYLECLASS: 46,
+            style: 47,
+            STYLE_ENTITY_IDS: 48,
+            STYLE_DEFINITION_DATA: 49,
+            $accept: 0,
+            $end: 1
+        },
+        terminals_: {
+            2: "error",
+            4: "SPACELINE",
+            5: "NL",
+            7: "SPACE",
+            8: "EOF",
+            10: "BLOCK_DIAGRAM_KEY",
+            15: "LINK",
+            16: "START_LINK",
+            17: "LINK_LABEL",
+            18: "STR",
+            21: "SPACE_BLOCK",
+            27: "SIZE",
+            28: "COLUMNS",
+            29: "id-block",
+            30: "end",
+            31: "block",
+            32: "NODE_ID",
+            35: "DIR",
+            36: "NODE_DSTART",
+            37: "NODE_DEND",
+            38: "BLOCK_ARROW_START",
+            39: "BLOCK_ARROW_END",
+            40: "classDef",
+            41: "CLASSDEF_ID",
+            42: "CLASSDEF_STYLEOPTS",
+            43: "DEFAULT",
+            44: "class",
+            45: "CLASSENTITY_IDS",
+            46: "STYLECLASS",
+            47: "style",
+            48: "STYLE_ENTITY_IDS",
+            49: "STYLE_DEFINITION_DATA"
+        },
+        productions_: [
+            0,
+            [
+                3,
+                1
+            ],
+            [
+                3,
+                2
+            ],
+            [
+                3,
+                2
+            ],
+            [
+                6,
+                1
+            ],
+            [
+                6,
+                1
+            ],
+            [
+                6,
+                1
+            ],
+            [
+                9,
+                3
+            ],
+            [
+                12,
+                1
+            ],
+            [
+                12,
+                1
+            ],
+            [
+                12,
+                2
+            ],
+            [
+                12,
+                2
+            ],
+            [
+                11,
+                1
+            ],
+            [
+                11,
+                2
+            ],
+            [
+                14,
+                1
+            ],
+            [
+                14,
+                4
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                13,
+                1
+            ],
+            [
+                19,
+                3
+            ],
+            [
+                19,
+                2
+            ],
+            [
+                19,
+                1
+            ],
+            [
+                20,
+                1
+            ],
+            [
+                22,
+                4
+            ],
+            [
+                22,
+                3
+            ],
+            [
+                26,
+                1
+            ],
+            [
+                26,
+                2
+            ],
+            [
+                34,
+                1
+            ],
+            [
+                34,
+                2
+            ],
+            [
+                33,
+                3
+            ],
+            [
+                33,
+                4
+            ],
+            [
+                23,
+                3
+            ],
+            [
+                23,
+                3
+            ],
+            [
+                24,
+                3
+            ],
+            [
+                25,
+                3
+            ]
+        ],
+        performAction: function performAction(l, s, r, h, d, t, x) {
+            var n = t.length - 1;
+            switch(d){
+                case 4:
+                    h.getLogger().debug("Rule: separator (NL) ");
+                    break;
+                case 5:
+                    h.getLogger().debug("Rule: separator (Space) ");
+                    break;
+                case 6:
+                    h.getLogger().debug("Rule: separator (EOF) ");
+                    break;
+                case 7:
+                    h.getLogger().debug("Rule: hierarchy: ", t[n - 1]), h.setHierarchy(t[n - 1]);
+                    break;
+                case 8:
+                    h.getLogger().debug("Stop NL ");
+                    break;
+                case 9:
+                    h.getLogger().debug("Stop EOF ");
+                    break;
+                case 10:
+                    h.getLogger().debug("Stop NL2 ");
+                    break;
+                case 11:
+                    h.getLogger().debug("Stop EOF2 ");
+                    break;
+                case 12:
+                    h.getLogger().debug("Rule: statement: ", t[n]), typeof t[n].length == "number" ? this.$ = t[n] : this.$ = [
+                        t[n]
+                    ];
+                    break;
+                case 13:
+                    h.getLogger().debug("Rule: statement #2: ", t[n - 1]), this.$ = [
+                        t[n - 1]
+                    ].concat(t[n]);
+                    break;
+                case 14:
+                    h.getLogger().debug("Rule: link: ", t[n], l), this.$ = {
+                        edgeTypeStr: t[n],
+                        label: ""
+                    };
+                    break;
+                case 15:
+                    h.getLogger().debug("Rule: LABEL link: ", t[n - 3], t[n - 1], t[n]), this.$ = {
+                        edgeTypeStr: t[n],
+                        label: t[n - 1]
+                    };
+                    break;
+                case 18:
+                    var B = parseInt(t[n]), Y = h.generateId();
+                    this.$ = {
+                        id: Y,
+                        type: "space",
+                        label: "",
+                        width: B,
+                        children: []
+                    };
+                    break;
+                case 23:
+                    h.getLogger().debug("Rule: (nodeStatement link node) ", t[n - 2], t[n - 1], t[n], " typestr: ", t[n - 1].edgeTypeStr);
+                    var F = h.edgeStrToEdgeData(t[n - 1].edgeTypeStr);
+                    this.$ = [
+                        {
+                            id: t[n - 2].id,
+                            label: t[n - 2].label,
+                            type: t[n - 2].type,
+                            directions: t[n - 2].directions
+                        },
+                        {
+                            id: t[n - 2].id + "-" + t[n].id,
+                            start: t[n - 2].id,
+                            end: t[n].id,
+                            label: t[n - 1].label,
+                            type: "edge",
+                            directions: t[n].directions,
+                            arrowTypeEnd: F,
+                            arrowTypeStart: "arrow_open"
+                        },
+                        {
+                            id: t[n].id,
+                            label: t[n].label,
+                            type: h.typeStr2Type(t[n].typeStr),
+                            directions: t[n].directions
+                        }
+                    ];
+                    break;
+                case 24:
+                    h.getLogger().debug("Rule: nodeStatement (abc88 node size) ", t[n - 1], t[n]), this.$ = {
+                        id: t[n - 1].id,
+                        label: t[n - 1].label,
+                        type: h.typeStr2Type(t[n - 1].typeStr),
+                        directions: t[n - 1].directions,
+                        widthInColumns: parseInt(t[n], 10)
+                    };
+                    break;
+                case 25:
+                    h.getLogger().debug("Rule: nodeStatement (node) ", t[n]), this.$ = {
+                        id: t[n].id,
+                        label: t[n].label,
+                        type: h.typeStr2Type(t[n].typeStr),
+                        directions: t[n].directions,
+                        widthInColumns: 1
+                    };
+                    break;
+                case 26:
+                    h.getLogger().debug("APA123", this ? this : "na"), h.getLogger().debug("COLUMNS: ", t[n]), this.$ = {
+                        type: "column-setting",
+                        columns: t[n] === "auto" ? -1 : parseInt(t[n])
+                    };
+                    break;
+                case 27:
+                    h.getLogger().debug("Rule: id-block statement : ", t[n - 2], t[n - 1]), h.generateId(), this.$ = _object_spread_props(_object_spread({}, t[n - 2]), {
+                        type: "composite",
+                        children: t[n - 1]
+                    });
+                    break;
+                case 28:
+                    h.getLogger().debug("Rule: blockStatement : ", t[n - 2], t[n - 1], t[n]);
+                    var R = h.generateId();
+                    this.$ = {
+                        id: R,
+                        type: "composite",
+                        label: "",
+                        children: t[n - 1]
+                    };
+                    break;
+                case 29:
+                    h.getLogger().debug("Rule: node (NODE_ID separator): ", t[n]), this.$ = {
+                        id: t[n]
+                    };
+                    break;
+                case 30:
+                    h.getLogger().debug("Rule: node (NODE_ID nodeShapeNLabel separator): ", t[n - 1], t[n]), this.$ = {
+                        id: t[n - 1],
+                        label: t[n].label,
+                        typeStr: t[n].typeStr,
+                        directions: t[n].directions
+                    };
+                    break;
+                case 31:
+                    h.getLogger().debug("Rule: dirList: ", t[n]), this.$ = [
+                        t[n]
+                    ];
+                    break;
+                case 32:
+                    h.getLogger().debug("Rule: dirList: ", t[n - 1], t[n]), this.$ = [
+                        t[n - 1]
+                    ].concat(t[n]);
+                    break;
+                case 33:
+                    h.getLogger().debug("Rule: nodeShapeNLabel: ", t[n - 2], t[n - 1], t[n]), this.$ = {
+                        typeStr: t[n - 2] + t[n],
+                        label: t[n - 1]
+                    };
+                    break;
+                case 34:
+                    h.getLogger().debug("Rule: BLOCK_ARROW nodeShapeNLabel: ", t[n - 3], t[n - 2], " #3:", t[n - 1], t[n]), this.$ = {
+                        typeStr: t[n - 3] + t[n],
+                        label: t[n - 2],
+                        directions: t[n - 1]
+                    };
+                    break;
+                case 35:
+                case 36:
+                    this.$ = {
+                        type: "classDef",
+                        id: t[n - 1].trim(),
+                        css: t[n].trim()
+                    };
+                    break;
+                case 37:
+                    this.$ = {
+                        type: "applyClass",
+                        id: t[n - 1].trim(),
+                        styleClass: t[n].trim()
+                    };
+                    break;
+                case 38:
+                    this.$ = {
+                        type: "applyStyles",
+                        id: t[n - 1].trim(),
+                        stylesStr: t[n].trim()
+                    };
+                    break;
+            }
+        },
+        table: [
+            {
+                9: 1,
+                10: [
+                    1,
+                    2
+                ]
+            },
+            {
+                1: [
+                    3
+                ]
+            },
+            {
+                11: 3,
+                13: 4,
+                19: 5,
+                20: 6,
+                21: c,
+                22: 8,
+                23: 9,
+                24: 10,
+                25: 11,
+                26: 12,
+                28: u,
+                29: a,
+                31: i,
+                32: g,
+                40: o,
+                44: p,
+                47: f
+            },
+            {
+                8: [
+                    1,
+                    20
+                ]
+            },
+            e(m, [
+                2,
+                12
+            ], {
+                13: 4,
+                19: 5,
+                20: 6,
+                22: 8,
+                23: 9,
+                24: 10,
+                25: 11,
+                26: 12,
+                11: 21,
+                21: c,
+                28: u,
+                29: a,
+                31: i,
+                32: g,
+                40: o,
+                44: p,
+                47: f
+            }),
+            e(S, [
+                2,
+                16
+            ], {
+                14: 22,
+                15: y,
+                16: z
+            }),
+            e(S, [
+                2,
+                17
+            ]),
+            e(S, [
+                2,
+                18
+            ]),
+            e(S, [
+                2,
+                19
+            ]),
+            e(S, [
+                2,
+                20
+            ]),
+            e(S, [
+                2,
+                21
+            ]),
+            e(S, [
+                2,
+                22
+            ]),
+            e(I, [
+                2,
+                25
+            ], {
+                27: [
+                    1,
+                    25
+                ]
+            }),
+            e(S, [
+                2,
+                26
+            ]),
+            {
+                19: 26,
+                26: 12,
+                32: g
+            },
+            {
+                11: 27,
+                13: 4,
+                19: 5,
+                20: 6,
+                21: c,
+                22: 8,
+                23: 9,
+                24: 10,
+                25: 11,
+                26: 12,
+                28: u,
+                29: a,
+                31: i,
+                32: g,
+                40: o,
+                44: p,
+                47: f
+            },
+            {
+                41: [
+                    1,
+                    28
+                ],
+                43: [
+                    1,
+                    29
+                ]
+            },
+            {
+                45: [
+                    1,
+                    30
+                ]
+            },
+            {
+                48: [
+                    1,
+                    31
+                ]
+            },
+            e(w, [
+                2,
+                29
+            ], {
+                33: 32,
+                36: [
+                    1,
+                    33
+                ],
+                38: [
+                    1,
+                    34
+                ]
+            }),
+            {
+                1: [
+                    2,
+                    7
+                ]
+            },
+            e(m, [
+                2,
+                13
+            ]),
+            {
+                26: 35,
+                32: g
+            },
+            {
+                32: [
+                    2,
+                    14
+                ]
+            },
+            {
+                17: [
+                    1,
+                    36
+                ]
+            },
+            e(I, [
+                2,
+                24
+            ]),
+            {
+                11: 37,
+                13: 4,
+                14: 22,
+                15: y,
+                16: z,
+                19: 5,
+                20: 6,
+                21: c,
+                22: 8,
+                23: 9,
+                24: 10,
+                25: 11,
+                26: 12,
+                28: u,
+                29: a,
+                31: i,
+                32: g,
+                40: o,
+                44: p,
+                47: f
+            },
+            {
+                30: [
+                    1,
+                    38
+                ]
+            },
+            {
+                42: [
+                    1,
+                    39
+                ]
+            },
+            {
+                42: [
+                    1,
+                    40
+                ]
+            },
+            {
+                46: [
+                    1,
+                    41
+                ]
+            },
+            {
+                49: [
+                    1,
+                    42
+                ]
+            },
+            e(w, [
+                2,
+                30
+            ]),
+            {
+                18: [
+                    1,
+                    43
+                ]
+            },
+            {
+                18: [
+                    1,
+                    44
+                ]
+            },
+            e(I, [
+                2,
+                23
+            ]),
+            {
+                18: [
+                    1,
+                    45
+                ]
+            },
+            {
+                30: [
+                    1,
+                    46
+                ]
+            },
+            e(S, [
+                2,
+                28
+            ]),
+            e(S, [
+                2,
+                35
+            ]),
+            e(S, [
+                2,
+                36
+            ]),
+            e(S, [
+                2,
+                37
+            ]),
+            e(S, [
+                2,
+                38
+            ]),
+            {
+                37: [
+                    1,
+                    47
+                ]
+            },
+            {
+                34: 48,
+                35: C
+            },
+            {
+                15: [
+                    1,
+                    50
+                ]
+            },
+            e(S, [
+                2,
+                27
+            ]),
+            e(w, [
+                2,
+                33
+            ]),
+            {
+                39: [
+                    1,
+                    51
+                ]
+            },
+            {
+                34: 52,
+                35: C,
+                39: [
+                    2,
+                    31
+                ]
+            },
+            {
+                32: [
+                    2,
+                    15
+                ]
+            },
+            e(w, [
+                2,
+                34
+            ]),
+            {
+                39: [
+                    2,
+                    32
+                ]
+            }
+        ],
+        defaultActions: {
+            20: [
+                2,
+                7
+            ],
+            23: [
+                2,
+                14
+            ],
+            50: [
+                2,
+                15
+            ],
+            52: [
+                2,
+                32
+            ]
+        },
+        parseError: function parseError(l, s) {
+            if (s.recoverable) this.trace(l);
+            else {
+                var r = new Error(l);
+                throw r.hash = s, r;
+            }
+        },
+        parse: function parse(l) {
+            var s = this, r = [
+                0
+            ], h = [], d = [
+                null
+            ], t = [], x = this.table, n = "", B = 0, Y = 0, F = 2, R = 1, me = t.slice.call(arguments, 1), _ = Object.create(this.lexer), K = {
+                yy: {}
+            };
+            for(var Z in this.yy)Object.prototype.hasOwnProperty.call(this.yy, Z) && (K.yy[Z] = this.yy[Z]);
+            _.setInput(l, K.yy), K.yy.lexer = _, K.yy.parser = this, _type_of(_.yylloc) > "u" && (_.yylloc = {});
+            var J = _.yylloc;
+            t.push(J);
+            var be = _.options && _.options.ranges;
+            typeof K.yy.parseError == "function" ? this.parseError = K.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
+            function Ee() {
+                var P;
+                return P = h.pop() || _.lex() || R, typeof P != "number" && (_instanceof(P, Array) && (h = P, P = h.pop()), P = s.symbols_[P] || P), P;
+            }
+            for(var O, M, A, Q, W = {}, X, k, ae, G;;){
+                if (M = r[r.length - 1], this.defaultActions[M] ? A = this.defaultActions[M] : ((O === null || (typeof O === "undefined" ? "undefined" : _type_of(O)) > "u") && (O = Ee()), A = x[M] && x[M][O]), (typeof A === "undefined" ? "undefined" : _type_of(A)) > "u" || !A.length || !A[0]) {
+                    var $ = "";
+                    G = [];
+                    for(X in x[M])this.terminals_[X] && X > F && G.push("'" + this.terminals_[X] + "'");
+                    _.showPosition ? $ = "Parse error on line " + (B + 1) + ":\n" + _.showPosition() + "\nExpecting " + G.join(", ") + ", got '" + (this.terminals_[O] || O) + "'" : $ = "Parse error on line " + (B + 1) + ": Unexpected " + (O == R ? "end of input" : "'" + (this.terminals_[O] || O) + "'"), this.parseError($, {
+                        text: _.match,
+                        token: this.terminals_[O] || O,
+                        line: _.yylineno,
+                        loc: J,
+                        expected: G
+                    });
+                }
+                if (_instanceof(A[0], Array) && A.length > 1) throw new Error("Parse Error: multiple actions possible at state: " + M + ", token: " + O);
+                switch(A[0]){
+                    case 1:
+                        r.push(O), d.push(_.yytext), t.push(_.yylloc), r.push(A[1]), O = null, Y = _.yyleng, n = _.yytext, B = _.yylineno, J = _.yylloc;
+                        break;
+                    case 2:
+                        if (k = this.productions_[A[1]][1], W.$ = d[d.length - k], W._$ = {
+                            first_line: t[t.length - (k || 1)].first_line,
+                            last_line: t[t.length - 1].last_line,
+                            first_column: t[t.length - (k || 1)].first_column,
+                            last_column: t[t.length - 1].last_column
+                        }, be && (W._$.range = [
+                            t[t.length - (k || 1)].range[0],
+                            t[t.length - 1].range[1]
+                        ]), Q = this.performAction.apply(W, [
+                            n,
+                            Y,
+                            B,
+                            K.yy,
+                            A[1],
+                            d,
+                            t
+                        ].concat(me)), (typeof Q === "undefined" ? "undefined" : _type_of(Q)) < "u") return Q;
+                        k && (r = r.slice(0, -1 * k * 2), d = d.slice(0, -1 * k), t = t.slice(0, -1 * k)), r.push(this.productions_[A[1]][0]), d.push(W.$), t.push(W._$), ae = x[r[r.length - 2]][r[r.length - 1]], r.push(ae);
+                        break;
+                    case 3:
+                        return !0;
+                }
+            }
+            return !0;
+        }
+    }, v = function() {
+        var D = {
+            EOF: 1,
+            parseError: function parseError(s, r) {
+                if (this.yy.parser) this.yy.parser.parseError(s, r);
+                else throw new Error(s);
+            },
+            // resets the lexer, sets new input
+            setInput: function setInput(l, s) {
+                return this.yy = s || this.yy || {}, this._input = l, this._more = this._backtrack = this.done = !1, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = [
+                    "INITIAL"
+                ], this.yylloc = {
+                    first_line: 1,
+                    first_column: 0,
+                    last_line: 1,
+                    last_column: 0
+                }, this.options.ranges && (this.yylloc.range = [
+                    0,
+                    0
+                ]), this.offset = 0, this;
+            },
+            // consumes and returns one char from the input
+            input: function input() {
+                var l = this._input[0];
+                this.yytext += l, this.yyleng++, this.offset++, this.match += l, this.matched += l;
+                var s = l.match(/(?:\r\n?|\n).*/g);
+                return s ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), l;
+            },
+            // unshifts one char (or a string) into the input
+            unput: function unput(l) {
+                var s = l.length, r = l.split(/(?:\r\n?|\n)/g);
+                this._input = l + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - s), this.offset -= s;
+                var h = 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), r.length - 1 && (this.yylineno -= r.length - 1);
+                var d = this.yylloc.range;
+                return this.yylloc = {
+                    first_line: this.yylloc.first_line,
+                    last_line: this.yylineno + 1,
+                    first_column: this.yylloc.first_column,
+                    last_column: r ? (r.length === h.length ? this.yylloc.first_column : 0) + h[h.length - r.length].length - r[0].length : this.yylloc.first_column - s
+                }, this.options.ranges && (this.yylloc.range = [
+                    d[0],
+                    d[0] + this.yyleng - s
+                ]), this.yyleng = this.yytext.length, this;
+            },
+            // When called from action, caches matched text and appends it on next action
+            more: function more() {
+                return this._more = !0, 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 reject() {
+                if (this.options.backtrack_lexer) this._backtrack = !0;
+                else return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), {
+                    text: "",
+                    token: null,
+                    line: this.yylineno
+                });
+                return this;
+            },
+            // retain first n characters of the match
+            less: function less(l) {
+                this.unput(this.match.slice(l));
+            },
+            // displays already matched input, i.e. for error messages
+            pastInput: function pastInput() {
+                var l = this.matched.substr(0, this.matched.length - this.match.length);
+                return (l.length > 20 ? "..." : "") + l.substr(-20).replace(/\n/g, "");
+            },
+            // displays upcoming input, i.e. for error messages
+            upcomingInput: function upcomingInput() {
+                var l = this.match;
+                return l.length < 20 && (l += this._input.substr(0, 20 - l.length)), (l.substr(0, 20) + (l.length > 20 ? "..." : "")).replace(/\n/g, "");
+            },
+            // displays the character position where the lexing error occurred, i.e. for error messages
+            showPosition: function showPosition() {
+                var l = this.pastInput(), s = new Array(l.length + 1).join("-");
+                return l + this.upcomingInput() + "\n" + s + "^";
+            },
+            // test the lexed token: return FALSE when not a match, otherwise return token
+            test_match: function test_match(l, s) {
+                var r, h, d;
+                if (this.options.backtrack_lexer && (d = {
+                    yylineno: this.yylineno,
+                    yylloc: {
+                        first_line: this.yylloc.first_line,
+                        last_line: this.last_line,
+                        first_column: this.yylloc.first_column,
+                        last_column: this.yylloc.last_column
+                    },
+                    yytext: this.yytext,
+                    match: this.match,
+                    matches: this.matches,
+                    matched: this.matched,
+                    yyleng: this.yyleng,
+                    offset: this.offset,
+                    _more: this._more,
+                    _input: this._input,
+                    yy: this.yy,
+                    conditionStack: this.conditionStack.slice(0),
+                    done: this.done
+                }, this.options.ranges && (d.yylloc.range = this.yylloc.range.slice(0))), h = l[0].match(/(?:\r\n?|\n).*/g), h && (this.yylineno += h.length), this.yylloc = {
+                    first_line: this.yylloc.last_line,
+                    last_line: this.yylineno + 1,
+                    first_column: this.yylloc.last_column,
+                    last_column: h ? h[h.length - 1].length - h[h.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + l[0].length
+                }, this.yytext += l[0], this.match += l[0], this.matches = l, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [
+                    this.offset,
+                    this.offset += this.yyleng
+                ]), this._more = !1, this._backtrack = !1, this._input = this._input.slice(l[0].length), this.matched += l[0], r = this.performAction.call(this, this.yy, this, s, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = !1), r) return r;
+                if (this._backtrack) {
+                    for(var t in d)this[t] = d[t];
+                    return !1;
+                }
+                return !1;
+            },
+            // return next match in input
+            next: function next() {
+                if (this.done) return this.EOF;
+                this._input || (this.done = !0);
+                var l, s, r, h;
+                this._more || (this.yytext = "", this.match = "");
+                for(var d = this._currentRules(), t = 0; t < d.length; t++)if (r = this._input.match(this.rules[d[t]]), r && (!s || r[0].length > s[0].length)) {
+                    if (s = r, h = t, this.options.backtrack_lexer) {
+                        if (l = this.test_match(r, d[t]), l !== !1) return l;
+                        if (this._backtrack) {
+                            s = !1;
+                            continue;
+                        } else return !1;
+                    } else if (!this.options.flex) break;
+                }
+                return s ? (l = this.test_match(s, d[h]), l !== !1 ? l : !1) : this._input === "" ? this.EOF : 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 s = this.next();
+                return s || this.lex();
+            },
+            // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+            begin: function begin(s) {
+                this.conditionStack.push(s);
+            },
+            // pop the previously active lexer condition state off the condition stack
+            popState: function popState() {
+                var s = this.conditionStack.length - 1;
+                return s > 0 ? this.conditionStack.pop() : this.conditionStack[0];
+            },
+            // produce the lexer rule set which is active for the currently active lexer condition state
+            _currentRules: function _currentRules() {
+                return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1] ? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules : 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(s) {
+                return s = this.conditionStack.length - 1 - Math.abs(s || 0), s >= 0 ? this.conditionStack[s] : "INITIAL";
+            },
+            // alias for begin(condition)
+            pushState: function pushState(s) {
+                this.begin(s);
+            },
+            // return the number of states currently on the stack
+            stateStackSize: function stateStackSize() {
+                return this.conditionStack.length;
+            },
+            options: {},
+            performAction: function performAction(s, r, h, d) {
+                switch(h){
+                    case 0:
+                        return 10;
+                    case 1:
+                        return s.getLogger().debug("Found space-block"), 31;
+                    case 2:
+                        return s.getLogger().debug("Found nl-block"), 31;
+                    case 3:
+                        return s.getLogger().debug("Found space-block"), 29;
+                    case 4:
+                        s.getLogger().debug(".", r.yytext);
+                        break;
+                    case 5:
+                        s.getLogger().debug("_", r.yytext);
+                        break;
+                    case 6:
+                        return 5;
+                    case 7:
+                        return r.yytext = -1, 28;
+                    case 8:
+                        return r.yytext = r.yytext.replace(/columns\s+/, ""), s.getLogger().debug("COLUMNS (LEX)", r.yytext), 28;
+                    case 9:
+                        this.pushState("md_string");
+                        break;
+                    case 10:
+                        return "MD_STR";
+                    case 11:
+                        this.popState();
+                        break;
+                    case 12:
+                        this.pushState("string");
+                        break;
+                    case 13:
+                        s.getLogger().debug("LEX: POPPING STR:", r.yytext), this.popState();
+                        break;
+                    case 14:
+                        return s.getLogger().debug("LEX: STR end:", r.yytext), "STR";
+                    case 15:
+                        return r.yytext = r.yytext.replace(/space\:/, ""), s.getLogger().debug("SPACE NUM (LEX)", r.yytext), 21;
+                    case 16:
+                        return r.yytext = "1", s.getLogger().debug("COLUMNS (LEX)", r.yytext), 21;
+                    case 17:
+                        return 43;
+                    case 18:
+                        return "LINKSTYLE";
+                    case 19:
+                        return "INTERPOLATE";
+                    case 20:
+                        return this.pushState("CLASSDEF"), 40;
+                    case 21:
+                        return this.popState(), this.pushState("CLASSDEFID"), "DEFAULT_CLASSDEF_ID";
+                    case 22:
+                        return this.popState(), this.pushState("CLASSDEFID"), 41;
+                    case 23:
+                        return this.popState(), 42;
+                    case 24:
+                        return this.pushState("CLASS"), 44;
+                    case 25:
+                        return this.popState(), this.pushState("CLASS_STYLE"), 45;
+                    case 26:
+                        return this.popState(), 46;
+                    case 27:
+                        return this.pushState("STYLE_STMNT"), 47;
+                    case 28:
+                        return this.popState(), this.pushState("STYLE_DEFINITION"), 48;
+                    case 29:
+                        return this.popState(), 49;
+                    case 30:
+                        return this.pushState("acc_title"), "acc_title";
+                    case 31:
+                        return this.popState(), "acc_title_value";
+                    case 32:
+                        return this.pushState("acc_descr"), "acc_descr";
+                    case 33:
+                        return this.popState(), "acc_descr_value";
+                    case 34:
+                        this.pushState("acc_descr_multiline");
+                        break;
+                    case 35:
+                        this.popState();
+                        break;
+                    case 36:
+                        return "acc_descr_multiline_value";
+                    case 37:
+                        return 30;
+                    case 38:
+                        return this.popState(), s.getLogger().debug("Lex: (("), "NODE_DEND";
+                    case 39:
+                        return this.popState(), s.getLogger().debug("Lex: (("), "NODE_DEND";
+                    case 40:
+                        return this.popState(), s.getLogger().debug("Lex: ))"), "NODE_DEND";
+                    case 41:
+                        return this.popState(), s.getLogger().debug("Lex: (("), "NODE_DEND";
+                    case 42:
+                        return this.popState(), s.getLogger().debug("Lex: (("), "NODE_DEND";
+                    case 43:
+                        return this.popState(), s.getLogger().debug("Lex: (-"), "NODE_DEND";
+                    case 44:
+                        return this.popState(), s.getLogger().debug("Lex: -)"), "NODE_DEND";
+                    case 45:
+                        return this.popState(), s.getLogger().debug("Lex: (("), "NODE_DEND";
+                    case 46:
+                        return this.popState(), s.getLogger().debug("Lex: ]]"), "NODE_DEND";
+                    case 47:
+                        return this.popState(), s.getLogger().debug("Lex: ("), "NODE_DEND";
+                    case 48:
+                        return this.popState(), s.getLogger().debug("Lex: ])"), "NODE_DEND";
+                    case 49:
+                        return this.popState(), s.getLogger().debug("Lex: /]"), "NODE_DEND";
+                    case 50:
+                        return this.popState(), s.getLogger().debug("Lex: /]"), "NODE_DEND";
+                    case 51:
+                        return this.popState(), s.getLogger().debug("Lex: )]"), "NODE_DEND";
+                    case 52:
+                        return this.popState(), s.getLogger().debug("Lex: )"), "NODE_DEND";
+                    case 53:
+                        return this.popState(), s.getLogger().debug("Lex: ]>"), "NODE_DEND";
+                    case 54:
+                        return this.popState(), s.getLogger().debug("Lex: ]"), "NODE_DEND";
+                    case 55:
+                        return s.getLogger().debug("Lexa: -)"), this.pushState("NODE"), 36;
+                    case 56:
+                        return s.getLogger().debug("Lexa: (-"), this.pushState("NODE"), 36;
+                    case 57:
+                        return s.getLogger().debug("Lexa: ))"), this.pushState("NODE"), 36;
+                    case 58:
+                        return s.getLogger().debug("Lexa: )"), this.pushState("NODE"), 36;
+                    case 59:
+                        return s.getLogger().debug("Lex: ((("), this.pushState("NODE"), 36;
+                    case 60:
+                        return s.getLogger().debug("Lexa: )"), this.pushState("NODE"), 36;
+                    case 61:
+                        return s.getLogger().debug("Lexa: )"), this.pushState("NODE"), 36;
+                    case 62:
+                        return s.getLogger().debug("Lexa: )"), this.pushState("NODE"), 36;
+                    case 63:
+                        return s.getLogger().debug("Lexc: >"), this.pushState("NODE"), 36;
+                    case 64:
+                        return s.getLogger().debug("Lexa: (["), this.pushState("NODE"), 36;
+                    case 65:
+                        return s.getLogger().debug("Lexa: )"), this.pushState("NODE"), 36;
+                    case 66:
+                        return this.pushState("NODE"), 36;
+                    case 67:
+                        return this.pushState("NODE"), 36;
+                    case 68:
+                        return this.pushState("NODE"), 36;
+                    case 69:
+                        return this.pushState("NODE"), 36;
+                    case 70:
+                        return this.pushState("NODE"), 36;
+                    case 71:
+                        return this.pushState("NODE"), 36;
+                    case 72:
+                        return this.pushState("NODE"), 36;
+                    case 73:
+                        return s.getLogger().debug("Lexa: ["), this.pushState("NODE"), 36;
+                    case 74:
+                        return this.pushState("BLOCK_ARROW"), s.getLogger().debug("LEX ARR START"), 38;
+                    case 75:
+                        return s.getLogger().debug("Lex: NODE_ID", r.yytext), 32;
+                    case 76:
+                        return s.getLogger().debug("Lex: EOF", r.yytext), 8;
+                    case 77:
+                        this.pushState("md_string");
+                        break;
+                    case 78:
+                        this.pushState("md_string");
+                        break;
+                    case 79:
+                        return "NODE_DESCR";
+                    case 80:
+                        this.popState();
+                        break;
+                    case 81:
+                        s.getLogger().debug("Lex: Starting string"), this.pushState("string");
+                        break;
+                    case 82:
+                        s.getLogger().debug("LEX ARR: Starting string"), this.pushState("string");
+                        break;
+                    case 83:
+                        return s.getLogger().debug("LEX: NODE_DESCR:", r.yytext), "NODE_DESCR";
+                    case 84:
+                        s.getLogger().debug("LEX POPPING"), this.popState();
+                        break;
+                    case 85:
+                        s.getLogger().debug("Lex: =>BAE"), this.pushState("ARROW_DIR");
+                        break;
+                    case 86:
+                        return r.yytext = r.yytext.replace(/^,\s*/, ""), s.getLogger().debug("Lex (right): dir:", r.yytext), "DIR";
+                    case 87:
+                        return r.yytext = r.yytext.replace(/^,\s*/, ""), s.getLogger().debug("Lex (left):", r.yytext), "DIR";
+                    case 88:
+                        return r.yytext = r.yytext.replace(/^,\s*/, ""), s.getLogger().debug("Lex (x):", r.yytext), "DIR";
+                    case 89:
+                        return r.yytext = r.yytext.replace(/^,\s*/, ""), s.getLogger().debug("Lex (y):", r.yytext), "DIR";
+                    case 90:
+                        return r.yytext = r.yytext.replace(/^,\s*/, ""), s.getLogger().debug("Lex (up):", r.yytext), "DIR";
+                    case 91:
+                        return r.yytext = r.yytext.replace(/^,\s*/, ""), s.getLogger().debug("Lex (down):", r.yytext), "DIR";
+                    case 92:
+                        return r.yytext = "]>", s.getLogger().debug("Lex (ARROW_DIR end):", r.yytext), this.popState(), this.popState(), "BLOCK_ARROW_END";
+                    case 93:
+                        return s.getLogger().debug("Lex: LINK", "#" + r.yytext + "#"), 15;
+                    case 94:
+                        return s.getLogger().debug("Lex: LINK", r.yytext), 15;
+                    case 95:
+                        return s.getLogger().debug("Lex: LINK", r.yytext), 15;
+                    case 96:
+                        return s.getLogger().debug("Lex: LINK", r.yytext), 15;
+                    case 97:
+                        return s.getLogger().debug("Lex: START_LINK", r.yytext), this.pushState("LLABEL"), 16;
+                    case 98:
+                        return s.getLogger().debug("Lex: START_LINK", r.yytext), this.pushState("LLABEL"), 16;
+                    case 99:
+                        return s.getLogger().debug("Lex: START_LINK", r.yytext), this.pushState("LLABEL"), 16;
+                    case 100:
+                        this.pushState("md_string");
+                        break;
+                    case 101:
+                        return s.getLogger().debug("Lex: Starting string"), this.pushState("string"), "LINK_LABEL";
+                    case 102:
+                        return this.popState(), s.getLogger().debug("Lex: LINK", "#" + r.yytext + "#"), 15;
+                    case 103:
+                        return this.popState(), s.getLogger().debug("Lex: LINK", r.yytext), 15;
+                    case 104:
+                        return this.popState(), s.getLogger().debug("Lex: LINK", r.yytext), 15;
+                    case 105:
+                        return s.getLogger().debug("Lex: COLON", r.yytext), r.yytext = r.yytext.slice(1), 27;
+                }
+            },
+            rules: [
+                /^(?:block-beta\b)/,
+                /^(?:block\s+)/,
+                /^(?:block\n+)/,
+                /^(?:block:)/,
+                /^(?:[\s]+)/,
+                /^(?:[\n]+)/,
+                /^(?:((\u000D\u000A)|(\u000A)))/,
+                /^(?:columns\s+auto\b)/,
+                /^(?:columns\s+[\d]+)/,
+                /^(?:["][`])/,
+                /^(?:[^`"]+)/,
+                /^(?:[`]["])/,
+                /^(?:["])/,
+                /^(?:["])/,
+                /^(?:[^"]*)/,
+                /^(?:space[:]\d+)/,
+                /^(?:space\b)/,
+                /^(?:default\b)/,
+                /^(?:linkStyle\b)/,
+                /^(?:interpolate\b)/,
+                /^(?:classDef\s+)/,
+                /^(?:DEFAULT\s+)/,
+                /^(?:\w+\s+)/,
+                /^(?:[^\n]*)/,
+                /^(?:class\s+)/,
+                /^(?:(\w+)+((,\s*\w+)*))/,
+                /^(?:[^\n]*)/,
+                /^(?:style\s+)/,
+                /^(?:(\w+)+((,\s*\w+)*))/,
+                /^(?:[^\n]*)/,
+                /^(?:accTitle\s*:\s*)/,
+                /^(?:(?!\n||)*[^\n]*)/,
+                /^(?:accDescr\s*:\s*)/,
+                /^(?:(?!\n||)*[^\n]*)/,
+                /^(?:accDescr\s*\{\s*)/,
+                /^(?:[\}])/,
+                /^(?:[^\}]*)/,
+                /^(?:end\b\s*)/,
+                /^(?:\(\(\()/,
+                /^(?:\)\)\))/,
+                /^(?:[\)]\))/,
+                /^(?:\}\})/,
+                /^(?:\})/,
+                /^(?:\(-)/,
+                /^(?:-\))/,
+                /^(?:\(\()/,
+                /^(?:\]\])/,
+                /^(?:\()/,
+                /^(?:\]\))/,
+                /^(?:\\\])/,
+                /^(?:\/\])/,
+                /^(?:\)\])/,
+                /^(?:[\)])/,
+                /^(?:\]>)/,
+                /^(?:[\]])/,
+                /^(?:-\))/,
+                /^(?:\(-)/,
+                /^(?:\)\))/,
+                /^(?:\))/,
+                /^(?:\(\(\()/,
+                /^(?:\(\()/,
+                /^(?:\{\{)/,
+                /^(?:\{)/,
+                /^(?:>)/,
+                /^(?:\(\[)/,
+                /^(?:\()/,
+                /^(?:\[\[)/,
+                /^(?:\[\|)/,
+                /^(?:\[\()/,
+                /^(?:\)\)\))/,
+                /^(?:\[\\)/,
+                /^(?:\[\/)/,
+                /^(?:\[\\)/,
+                /^(?:\[)/,
+                /^(?:<\[)/,
+                /^(?:[^\(\[\n\-\)\{\}\s\<\>:]+)/,
+                /^(?:$)/,
+                /^(?:["][`])/,
+                /^(?:["][`])/,
+                /^(?:[^`"]+)/,
+                /^(?:[`]["])/,
+                /^(?:["])/,
+                /^(?:["])/,
+                /^(?:[^"]+)/,
+                /^(?:["])/,
+                /^(?:\]>\s*\()/,
+                /^(?:,?\s*right\s*)/,
+                /^(?:,?\s*left\s*)/,
+                /^(?:,?\s*x\s*)/,
+                /^(?:,?\s*y\s*)/,
+                /^(?:,?\s*up\s*)/,
+                /^(?:,?\s*down\s*)/,
+                /^(?:\)\s*)/,
+                /^(?:\s*[xo<]?--+[-xo>]\s*)/,
+                /^(?:\s*[xo<]?==+[=xo>]\s*)/,
+                /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,
+                /^(?:\s*~~[\~]+\s*)/,
+                /^(?:\s*[xo<]?--\s*)/,
+                /^(?:\s*[xo<]?==\s*)/,
+                /^(?:\s*[xo<]?-\.\s*)/,
+                /^(?:["][`])/,
+                /^(?:["])/,
+                /^(?:\s*[xo<]?--+[-xo>]\s*)/,
+                /^(?:\s*[xo<]?==+[=xo>]\s*)/,
+                /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/,
+                /^(?::\d+)/
+            ],
+            conditions: {
+                STYLE_DEFINITION: {
+                    rules: [
+                        29
+                    ],
+                    inclusive: !1
+                },
+                STYLE_STMNT: {
+                    rules: [
+                        28
+                    ],
+                    inclusive: !1
+                },
+                CLASSDEFID: {
+                    rules: [
+                        23
+                    ],
+                    inclusive: !1
+                },
+                CLASSDEF: {
+                    rules: [
+                        21,
+                        22
+                    ],
+                    inclusive: !1
+                },
+                CLASS_STYLE: {
+                    rules: [
+                        26
+                    ],
+                    inclusive: !1
+                },
+                CLASS: {
+                    rules: [
+                        25
+                    ],
+                    inclusive: !1
+                },
+                LLABEL: {
+                    rules: [
+                        100,
+                        101,
+                        102,
+                        103,
+                        104
+                    ],
+                    inclusive: !1
+                },
+                ARROW_DIR: {
+                    rules: [
+                        86,
+                        87,
+                        88,
+                        89,
+                        90,
+                        91,
+                        92
+                    ],
+                    inclusive: !1
+                },
+                BLOCK_ARROW: {
+                    rules: [
+                        77,
+                        82,
+                        85
+                    ],
+                    inclusive: !1
+                },
+                NODE: {
+                    rules: [
+                        38,
+                        39,
+                        40,
+                        41,
+                        42,
+                        43,
+                        44,
+                        45,
+                        46,
+                        47,
+                        48,
+                        49,
+                        50,
+                        51,
+                        52,
+                        53,
+                        54,
+                        78,
+                        81
+                    ],
+                    inclusive: !1
+                },
+                md_string: {
+                    rules: [
+                        10,
+                        11,
+                        79,
+                        80
+                    ],
+                    inclusive: !1
+                },
+                space: {
+                    rules: [],
+                    inclusive: !1
+                },
+                string: {
+                    rules: [
+                        13,
+                        14,
+                        83,
+                        84
+                    ],
+                    inclusive: !1
+                },
+                acc_descr_multiline: {
+                    rules: [
+                        35,
+                        36
+                    ],
+                    inclusive: !1
+                },
+                acc_descr: {
+                    rules: [
+                        33
+                    ],
+                    inclusive: !1
+                },
+                acc_title: {
+                    rules: [
+                        31
+                    ],
+                    inclusive: !1
+                },
+                INITIAL: {
+                    rules: [
+                        0,
+                        1,
+                        2,
+                        3,
+                        4,
+                        5,
+                        6,
+                        7,
+                        8,
+                        9,
+                        12,
+                        15,
+                        16,
+                        17,
+                        18,
+                        19,
+                        20,
+                        24,
+                        27,
+                        30,
+                        32,
+                        34,
+                        37,
+                        55,
+                        56,
+                        57,
+                        58,
+                        59,
+                        60,
+                        61,
+                        62,
+                        63,
+                        64,
+                        65,
+                        66,
+                        67,
+                        68,
+                        69,
+                        70,
+                        71,
+                        72,
+                        73,
+                        74,
+                        75,
+                        76,
+                        93,
+                        94,
+                        95,
+                        96,
+                        97,
+                        98,
+                        99,
+                        105
+                    ],
+                    inclusive: !0
+                }
+            }
+        };
+        return D;
+    }();
+    E.lexer = v;
+    function N() {
+        this.yy = {};
+    }
+    return N.prototype = E, E.Parser = N, new N();
+}();
+ee.parser = ee;
+var Pe = ee;
+var T = {}, ie = [], V = {};
+var oe = "color", ce = "fill", Fe = "bgFill", pe = ",", Ke = Vn();
+var j = {};
+var Me = function(e) {
+    return $n.sanitizeText(e, Ke);
+}, Ye = function Ye(e) {
+    var c = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+    j[e] === void 0 && (j[e] = {
+        id: e,
+        styles: [],
+        textStyles: []
+    });
+    var u = j[e];
+    c != null && c.split(pe).forEach(function(a) {
+        var i = a.replace(/([^;]*);/, "$1").trim();
+        if (a.match(oe)) {
+            var o = i.replace(ce, Fe).replace(oe, ce);
+            u.textStyles.push(o);
+        }
+        u.styles.push(i);
+    });
+}, We = function We(e) {
+    var c = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "";
+    var u = T[e];
+    c != null && (u.styles = c.split(pe));
+}, Ve = function Ve(e, c) {
+    e.split(",").forEach(function(u) {
+        var a = T[u];
+        if (a === void 0) {
+            var i = u.trim();
+            T[i] = {
+                id: i,
+                type: "na",
+                children: []
+            }, a = T[i];
+        }
+        a.classes || (a.classes = []), a.classes.push(c);
+    });
+}, fe = function(e, c) {
+    var u = e.flat(), a$1 = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = u[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var i = _step.value;
+            if (i.label && (i.label = Me(i.label)), i.type === "classDef") {
+                Ye(i.id, i.css);
+                continue;
+            }
+            if (i.type === "applyClass") {
+                Ve(i.id, (i == null ? void 0 : i.styleClass) || "");
+                continue;
+            }
+            if (i.type === "applyStyles") {
+                i != null && i.stylesStr && We(i.id, i == null ? void 0 : i.stylesStr);
+                continue;
+            }
+            if (i.type === "column-setting") c.columns = i.columns || -1;
+            else if (i.type === "edge") V[i.id] ? V[i.id]++ : V[i.id] = 1, i.id = V[i.id] + "-" + i.id, ie.push(i);
+            else {
+                i.label || (i.type === "composite" ? i.label = "" : i.label = i.id);
+                var g = !T[i.id];
+                if (g ? T[i.id] = i : (i.type !== "na" && (T[i.id].type = i.type), i.label !== i.id && (T[i.id].label = i.label)), i.children && fe(i.children, i), i.type === "space") {
+                    var o = i.width || 1;
+                    for(var p = 0; p < o; p++){
+                        var f = a(i);
+                        f.id = f.id + "-" + p, T[f.id] = f, a$1.push(f);
+                    }
+                } else g && a$1.push(i);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    c.children = a$1;
+};
+var re = [], U = {
+    id: "root",
+    type: "composite",
+    children: [],
+    columns: -1
+};
+var je = function() {
+    L.debug("Clear called"), B_(), U = {
+        id: "root",
+        type: "composite",
+        children: [],
+        columns: -1
+    }, T = {
+        root: U
+    }, re = [], j = {}, ie = [], V = {};
+};
+function Ue(e) {
+    switch(L.debug("typeStr2Type", e), e){
+        case "[]":
+            return "square";
+        case "()":
+            return L.debug("we have a round"), "round";
+        case "(())":
+            return "circle";
+        case ">]":
+            return "rect_left_inv_arrow";
+        case "{}":
+            return "diamond";
+        case "{{}}":
+            return "hexagon";
+        case "([])":
+            return "stadium";
+        case "[[]]":
+            return "subroutine";
+        case "[()]":
+            return "cylinder";
+        case "((()))":
+            return "doublecircle";
+        case "[//]":
+            return "lean_right";
+        case "[\\\\]":
+            return "lean_left";
+        case "[/\\]":
+            return "trapezoid";
+        case "[\\/]":
+            return "inv_trapezoid";
+        case "<[]>":
+            return "block_arrow";
+        default:
+            return "na";
+    }
+}
+function Xe(e) {
+    switch(L.debug("typeStr2Type", e), e){
+        case "==":
+            return "thick";
+        default:
+            return "normal";
+    }
+}
+function Ge(e) {
+    switch(e.trim()){
+        case "--x":
+            return "arrow_cross";
+        case "--o":
+            return "arrow_circle";
+        default:
+            return "arrow_point";
+    }
+}
+var le = 0;
+var He = function() {
+    return le++, "id-" + Math.random().toString(36).substr(2, 12) + "-" + le;
+}, qe = function(e) {
+    U.children = e, fe(e, U), re = U.children;
+}, Ze = function(e) {
+    var c = T[e];
+    return c ? c.columns ? c.columns : c.children ? c.children.length : -1 : -1;
+}, Je = function() {
+    return _to_consumable_array(Object.values(T));
+}, Qe = function() {
+    return re || [];
+}, $e = function() {
+    return ie;
+}, et = function(e) {
+    return T[e];
+}, tt = function(e) {
+    T[e.id] = e;
+}, st = function() {
+    return console;
+}, it = function it() {
+    return j;
+}, rt = {
+    getConfig: function() {
+        return $t().block;
+    },
+    typeStr2Type: Ue,
+    edgeTypeStr2Type: Xe,
+    edgeStrToEdgeData: Ge,
+    getLogger: st,
+    getBlocksFlat: Je,
+    getBlocks: Qe,
+    getEdges: $e,
+    setHierarchy: qe,
+    getBlock: et,
+    setBlock: tt,
+    getColumns: Ze,
+    getClasses: it,
+    clear: je,
+    generateId: He
+}, nt = rt, q = function(e$1, c) {
+    var u = e, a = u(e$1, "r"), i = u(e$1, "g"), g = u(e$1, "b");
+    return Je$1(a, i, g, c);
+}, at = function(e) {
+    return ".label {\n    font-family: ".concat(e.fontFamily, ";\n    color: ").concat(e.nodeTextColor || e.textColor, ";\n  }\n  .cluster-label text {\n    fill: ").concat(e.titleColor, ";\n  }\n  .cluster-label span,p {\n    color: ").concat(e.titleColor, ";\n  }\n\n\n\n  .label text,span,p {\n    fill: ").concat(e.nodeTextColor || e.textColor, ";\n    color: ").concat(e.nodeTextColor || e.textColor, ";\n  }\n\n  .node rect,\n  .node circle,\n  .node ellipse,\n  .node polygon,\n  .node path {\n    fill: ").concat(e.mainBkg, ";\n    stroke: ").concat(e.nodeBorder, ";\n    stroke-width: 1px;\n  }\n  .flowchart-label text {\n    text-anchor: middle;\n  }\n  // .flowchart-label .text-outer-tspan {\n  //   text-anchor: middle;\n  // }\n  // .flowchart-label .text-inner-tspan {\n  //   text-anchor: start;\n  // }\n\n  .node .label {\n    text-align: center;\n  }\n  .node.clickable {\n    cursor: pointer;\n  }\n\n  .arrowheadPath {\n    fill: ").concat(e.arrowheadColor, ";\n  }\n\n  .edgePath .path {\n    stroke: ").concat(e.lineColor, ";\n    stroke-width: 2.0px;\n  }\n\n  .flowchart-link {\n    stroke: ").concat(e.lineColor, ";\n    fill: none;\n  }\n\n  .edgeLabel {\n    background-color: ").concat(e.edgeLabelBackground, ";\n    rect {\n      opacity: 0.5;\n      background-color: ").concat(e.edgeLabelBackground, ";\n      fill: ").concat(e.edgeLabelBackground, ";\n    }\n    text-align: center;\n  }\n\n  /* For html labels only */\n  .labelBkg {\n    background-color: ").concat(q(e.edgeLabelBackground, 0.5), ";\n    // background-color:\n  }\n\n  .node .cluster {\n    // fill: ").concat(q(e.mainBkg, 0.5), ";\n    fill: ").concat(q(e.clusterBkg, 0.5), ";\n    stroke: ").concat(q(e.clusterBorder, 0.2), ";\n    box-shadow: rgba(50, 50, 93, 0.25) 0px 13px 27px -5px, rgba(0, 0, 0, 0.3) 0px 8px 16px -8px;\n    stroke-width: 1px;\n  }\n\n  .cluster text {\n    fill: ").concat(e.titleColor, ";\n  }\n\n  .cluster span,p {\n    color: ").concat(e.titleColor, ";\n  }\n  /* .cluster div {\n    color: ").concat(e.titleColor, ";\n  } */\n\n  div.mermaidTooltip {\n    position: absolute;\n    text-align: center;\n    max-width: 200px;\n    padding: 2px;\n    font-family: ").concat(e.fontFamily, ";\n    font-size: 12px;\n    background: ").concat(e.tertiaryColor, ";\n    border: 1px solid ").concat(e.border2, ";\n    border-radius: 2px;\n    pointer-events: none;\n    z-index: 100;\n  }\n\n  .flowchartTitleText {\n    text-anchor: middle;\n    font-size: 18px;\n    fill: ").concat(e.textColor, ";\n  }\n");
+}, ot = at;
+function Se(e, c) {
+    var u = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !1;
+    var z, I, w;
+    var a = e;
+    var i = "default";
+    (((z = a == null ? void 0 : a.classes) == null ? void 0 : z.length) || 0) > 0 && (i = ((a == null ? void 0 : a.classes) || []).join(" ")), i = i + " flowchart-label";
+    var g = 0, o = "", p;
+    switch(a.type){
+        case "round":
+            g = 5, o = "rect";
+            break;
+        case "composite":
+            g = 0, o = "composite", p = 0;
+            break;
+        case "square":
+            o = "rect";
+            break;
+        case "diamond":
+            o = "question";
+            break;
+        case "hexagon":
+            o = "hexagon";
+            break;
+        case "block_arrow":
+            o = "block_arrow";
+            break;
+        case "odd":
+            o = "rect_left_inv_arrow";
+            break;
+        case "lean_right":
+            o = "lean_right";
+            break;
+        case "lean_left":
+            o = "lean_left";
+            break;
+        case "trapezoid":
+            o = "trapezoid";
+            break;
+        case "inv_trapezoid":
+            o = "inv_trapezoid";
+            break;
+        case "rect_left_inv_arrow":
+            o = "rect_left_inv_arrow";
+            break;
+        case "circle":
+            o = "circle";
+            break;
+        case "ellipse":
+            o = "ellipse";
+            break;
+        case "stadium":
+            o = "stadium";
+            break;
+        case "subroutine":
+            o = "subroutine";
+            break;
+        case "cylinder":
+            o = "cylinder";
+            break;
+        case "group":
+            o = "rect";
+            break;
+        case "doublecircle":
+            o = "doublecircle";
+            break;
+        default:
+            o = "rect";
+    }
+    var f = B0((a == null ? void 0 : a.styles) || []), m = a.label, S = a.size || {
+        width: 0,
+        height: 0,
+        x: 0,
+        y: 0
+    };
+    return {
+        labelStyle: f.labelStyle,
+        shape: o,
+        labelText: m,
+        rx: g,
+        ry: g,
+        class: i,
+        style: f.style,
+        id: a.id,
+        directions: a.directions,
+        width: S.width,
+        height: S.height,
+        x: S.x,
+        y: S.y,
+        positioned: u,
+        intersect: void 0,
+        type: a.type,
+        padding: p !== null && p !== void 0 ? p : ((w = (I = $t()) == null ? void 0 : I.block) == null ? void 0 : w.padding) || 0
+    };
+}
+function ct(e, c, u) {
+    return _ct.apply(this, arguments);
+}
+function _ct() {
+    _ct = _async_to_generator(function(e, c, u) {
+        var a, i, g, o;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    a = Se(c, u, !1);
+                    if (a.type === "group") return [
+                        2
+                    ];
+                    return [
+                        4,
+                        or(e, a)
+                    ];
+                case 1:
+                    i = _state.sent(), g = i.node().getBBox(), o = u.getBlock(a.id);
+                    o.size = {
+                        width: g.width,
+                        height: g.height,
+                        x: 0,
+                        y: 0,
+                        node: i
+                    }, u.setBlock(o), i.remove();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _ct.apply(this, arguments);
+}
+function lt(e, c, u) {
+    return _lt.apply(this, arguments);
+}
+function _lt() {
+    _lt = _async_to_generator(function(e, c, u) {
+        var a, _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    a = Se(c, u, !0);
+                    _tmp = u.getBlock(a.id).type !== "space";
+                    if (!_tmp) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        or(e, a)
+                    ];
+                case 1:
+                    _tmp = (_state.sent(), c.intersect = a == null ? void 0 : a.intersect, pr(a));
+                    _state.label = 2;
+                case 2:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _lt.apply(this, arguments);
+}
+function ne(e, c, u, a) {
+    return _ne.apply(this, arguments);
+}
+function _ne() {
+    _ne = _async_to_generator(function(e, c, u, a) {
+        var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, i, _tmp, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        8,
+                        9,
+                        10
+                    ]);
+                    _iterator = c[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
+                    if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                        3,
+                        7
+                    ];
+                    i = _step.value;
+                    return [
+                        4,
+                        a(e, i, u)
+                    ];
+                case 3:
+                    _state.sent();
+                    _tmp = i.children;
+                    if (!_tmp) return [
+                        3,
+                        5
+                    ];
+                    return [
+                        4,
+                        ne(e, i.children, u, a)
+                    ];
+                case 4:
+                    _tmp = _state.sent();
+                    _state.label = 5;
+                case 5:
+                    _state.label = 6;
+                case 6:
+                    _iteratorNormalCompletion = true;
+                    return [
+                        3,
+                        2
+                    ];
+                case 7:
+                    return [
+                        3,
+                        10
+                    ];
+                case 8:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        10
+                    ];
+                case 9:
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 10:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _ne.apply(this, arguments);
+}
+function ht(e, c, u) {
+    return _ht.apply(this, arguments);
+}
+function _ht() {
+    _ht = _async_to_generator(function(e, c, u) {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        ne(e, c, u, ct)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _ht.apply(this, arguments);
+}
+function ut(e, c, u) {
+    return _ut.apply(this, arguments);
+}
+function _ut() {
+    _ut = _async_to_generator(function(e, c, u) {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        ne(e, c, u, lt)
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _ut.apply(this, arguments);
+}
+function gt(e, c, u, a, i) {
+    return _gt.apply(this, arguments);
+}
+function _gt() {
+    _gt = _async_to_generator(function(e, c, u, a, i) {
+        var g, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, o, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, o1, p, f, m, S, y, _tmp, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    g = new Ze$1({
+                        multigraph: !0,
+                        compound: !0
+                    });
+                    g.setGraph({
+                        rankdir: "TB",
+                        nodesep: 10,
+                        ranksep: 10,
+                        marginx: 8,
+                        marginy: 8
+                    });
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = u[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            o = _step.value;
+                            o.size && g.setNode(o.id, {
+                                width: o.size.width,
+                                height: o.size.height,
+                                intersect: o.intersect
+                            });
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        9,
+                        10,
+                        11
+                    ]);
+                    _iterator1 = c[Symbol.iterator]();
+                    _state.label = 2;
+                case 2:
+                    if (!!(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done)) return [
+                        3,
+                        8
+                    ];
+                    o1 = _step1.value;
+                    if (!(o1.start && o1.end)) return [
+                        3,
+                        7
+                    ];
+                    p = a.getBlock(o1.start), f = a.getBlock(o1.end);
+                    if (!(p != null && p.size && f != null && f.size)) return [
+                        3,
+                        7
+                    ];
+                    m = p.size, S = f.size, y = [
+                        {
+                            x: m.x,
+                            y: m.y
+                        },
+                        {
+                            x: m.x + (S.x - m.x) / 2,
+                            y: m.y + (S.y - m.y) / 2
+                        },
+                        {
+                            x: S.x,
+                            y: S.y
+                        }
+                    ];
+                    return [
+                        4,
+                        ur(e, {
+                            v: o1.start,
+                            w: o1.end,
+                            name: o1.id
+                        }, _object_spread_props(_object_spread({}, o1), {
+                            arrowTypeEnd: o1.arrowTypeEnd,
+                            arrowTypeStart: o1.arrowTypeStart,
+                            points: y,
+                            classes: "edge-thickness-normal edge-pattern-solid flowchart-link LS-a1 LE-b1"
+                        }), void 0, "block", g, i)
+                    ];
+                case 3:
+                    _state.sent();
+                    _tmp = o1.label;
+                    if (!_tmp) return [
+                        3,
+                        6
+                    ];
+                    return [
+                        4,
+                        xr(e, _object_spread_props(_object_spread({}, o1), {
+                            label: o1.label,
+                            labelStyle: "stroke: #333; stroke-width: 1.5px;fill:none;",
+                            arrowTypeEnd: o1.arrowTypeEnd,
+                            arrowTypeStart: o1.arrowTypeStart,
+                            points: y,
+                            classes: "edge-thickness-normal edge-pattern-solid flowchart-link LS-a1 LE-b1"
+                        }))
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        4,
+                        gr(_object_spread_props(_object_spread({}, o1), {
+                            x: y[1].x,
+                            y: y[1].y
+                        }), {
+                            originalPath: y
+                        })
+                    ];
+                case 5:
+                    _tmp = _state.sent();
+                    _state.label = 6;
+                case 6:
+                    _state.label = 7;
+                case 7:
+                    _iteratorNormalCompletion1 = true;
+                    return [
+                        3,
+                        2
+                    ];
+                case 8:
+                    return [
+                        3,
+                        11
+                    ];
+                case 9:
+                    err = _state.sent();
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                    return [
+                        3,
+                        11
+                    ];
+                case 10:
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                    return [
+                        7
+                    ];
+                case 11:
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return _gt.apply(this, arguments);
+}
+var he, ue;
+var b = ((ue = (he = Vn()) == null ? void 0 : he.block) == null ? void 0 : ue.padding) || 8;
+function dt(e, c) {
+    if (e === 0 || !Number.isInteger(e)) throw new Error("Columns must be an integer !== 0.");
+    if (c < 0 || !Number.isInteger(c)) throw new Error("Position must be a non-negative integer." + c);
+    if (e < 0) return {
+        px: c,
+        py: 0
+    };
+    if (e === 1) return {
+        px: 0,
+        py: c
+    };
+    var u = c % e, a = Math.floor(c / e);
+    return {
+        px: u,
+        py: a
+    };
+}
+var pt = function(e) {
+    var c = 0, u = 0;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = e.children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var a = _step.value;
+            var _ref = a.size || {
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0
+            }, i = _ref.width, g = _ref.height, o = _ref.x, p = _ref.y;
+            L.debug("getMaxChildSize abc95 child:", a.id, "width:", i, "height:", g, "x:", o, "y:", p, a.type), a.type !== "space" && (i > c && (c = i / (e.widthInColumns || 1)), g > u && (u = g));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {
+        width: c,
+        height: u
+    };
+};
+function te(e, c) {
+    var u = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0, a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 0;
+    var o, p, f, m, S, y, z, I, w, C, E;
+    L.debug("setBlockSizes abc95 (start)", e.id, (o = e == null ? void 0 : e.size) == null ? void 0 : o.x, "block width =", e == null ? void 0 : e.size, "sieblingWidth", u), (p = e == null ? void 0 : e.size) != null && p.width || (e.size = {
+        width: u,
+        height: a,
+        x: 0,
+        y: 0
+    });
+    var i = 0, g = 0;
+    if (((f = e.children) == null ? void 0 : f.length) > 0) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = e.children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var d = _step.value;
+                te(d, c);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        var v = pt(e);
+        i = v.width, g = v.height, L.debug("setBlockSizes abc95 maxWidth of", e.id, ":s children is ", i, g);
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = e.children[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var d1 = _step1.value;
+                d1.size && (L.debug("abc95 Setting size of children of ".concat(e.id, " id=").concat(d1.id, " ").concat(i, " ").concat(g, " ").concat(d1.size)), d1.size.width = i * (d1.widthInColumns || 1) + b * ((d1.widthInColumns || 1) - 1), d1.size.height = g, d1.size.x = 0, d1.size.y = 0, L.debug("abc95 updating size of ".concat(e.id, " children child:").concat(d1.id, " maxWidth:").concat(i, " maxHeight:").concat(g)));
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+        var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+        try {
+            for(var _iterator2 = e.children[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                var d2 = _step2.value;
+                te(d2, c, i, g);
+            }
+        } catch (err) {
+            _didIteratorError2 = true;
+            _iteratorError2 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                    _iterator2.return();
+                }
+            } finally{
+                if (_didIteratorError2) {
+                    throw _iteratorError2;
+                }
+            }
+        }
+        var N = e.columns || -1;
+        var D = 0;
+        var _iteratorNormalCompletion3 = true, _didIteratorError3 = false, _iteratorError3 = undefined;
+        try {
+            for(var _iterator3 = e.children[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true){
+                var d3 = _step3.value;
+                D += d3.widthInColumns || 1;
+            }
+        } catch (err) {
+            _didIteratorError3 = true;
+            _iteratorError3 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
+                    _iterator3.return();
+                }
+            } finally{
+                if (_didIteratorError3) {
+                    throw _iteratorError3;
+                }
+            }
+        }
+        var l = e.children.length;
+        N > 0 && N < D && (l = N), e.widthInColumns;
+        var s = Math.ceil(D / l);
+        var r = l * (i + b) + b, h = s * (g + b) + b;
+        if (r < u) {
+            L.debug("Detected to small siebling: abc95 ".concat(e.id, " sieblingWidth ").concat(u, " sieblingHeight ").concat(a, " width ").concat(r)), r = u, h = a;
+            var d4 = (u - l * b - b) / l, t = (a - s * b - b) / s;
+            L.debug("Size indata abc88", e.id, "childWidth", d4, "maxWidth", i), L.debug("Size indata abc88", e.id, "childHeight", t, "maxHeight", g), L.debug("Size indata abc88 xSize", l, "padding", b);
+            var _iteratorNormalCompletion4 = true, _didIteratorError4 = false, _iteratorError4 = undefined;
+            try {
+                for(var _iterator4 = e.children[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true){
+                    var x = _step4.value;
+                    x.size && (x.size.width = d4, x.size.height = t, x.size.x = 0, x.size.y = 0);
+                }
+            } catch (err) {
+                _didIteratorError4 = true;
+                _iteratorError4 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
+                        _iterator4.return();
+                    }
+                } finally{
+                    if (_didIteratorError4) {
+                        throw _iteratorError4;
+                    }
+                }
+            }
+        }
+        if (L.debug("abc95 (finale calc) ".concat(e.id, " xSize ").concat(l, " ySize ").concat(s, " columns ").concat(N).concat(e.children.length, " width=").concat(Math.max(r, ((m = e.size) == null ? void 0 : m.width) || 0))), r < (((S = e == null ? void 0 : e.size) == null ? void 0 : S.width) || 0)) {
+            r = ((y = e == null ? void 0 : e.size) == null ? void 0 : y.width) || 0;
+            var d5 = N > 0 ? Math.min(e.children.length, N) : e.children.length;
+            if (d5 > 0) {
+                var t1 = (r - d5 * b - b) / d5;
+                L.debug("abc95 (growing to fit) width", e.id, r, (z = e.size) == null ? void 0 : z.width, t1);
+                var _iteratorNormalCompletion5 = true, _didIteratorError5 = false, _iteratorError5 = undefined;
+                try {
+                    for(var _iterator5 = e.children[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true){
+                        var x1 = _step5.value;
+                        x1.size && (x1.size.width = t1);
+                    }
+                } catch (err) {
+                    _didIteratorError5 = true;
+                    _iteratorError5 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
+                            _iterator5.return();
+                        }
+                    } finally{
+                        if (_didIteratorError5) {
+                            throw _iteratorError5;
+                        }
+                    }
+                }
+            }
+        }
+        e.size = {
+            width: r,
+            height: h,
+            x: 0,
+            y: 0
+        };
+    }
+    L.debug("setBlockSizes abc94 (done)", e.id, (I = e == null ? void 0 : e.size) == null ? void 0 : I.x, (w = e == null ? void 0 : e.size) == null ? void 0 : w.width, (C = e == null ? void 0 : e.size) == null ? void 0 : C.y, (E = e == null ? void 0 : e.size) == null ? void 0 : E.height);
+}
+function Le(e, c) {
+    var a, i, g, o, p, f, m, S, y, z, I, w, C, E, v, N, D;
+    L.debug("abc85 layout blocks (=>layoutBlocks) ".concat(e.id, " x: ").concat((a = e == null ? void 0 : e.size) == null ? void 0 : a.x, " y: ").concat((i = e == null ? void 0 : e.size) == null ? void 0 : i.y, " width: ").concat((g = e == null ? void 0 : e.size) == null ? void 0 : g.width));
+    var u = e.columns || -1;
+    if (L.debug("layoutBlocks columns abc95", e.id, "=>", u, e), e.children && // find max width of children
+    e.children.length > 0) {
+        var l = ((p = (o = e == null ? void 0 : e.children[0]) == null ? void 0 : o.size) == null ? void 0 : p.width) || 0, s = e.children.length * l + (e.children.length - 1) * b;
+        L.debug("widthOfChildren 88", s, "posX");
+        var r = 0;
+        L.debug("abc91 block?.size?.x", e.id, (f = e == null ? void 0 : e.size) == null ? void 0 : f.x);
+        var h = (m = e == null ? void 0 : e.size) != null && m.x ? ((S = e == null ? void 0 : e.size) == null ? void 0 : S.x) + (-((y = e == null ? void 0 : e.size) == null ? void 0 : y.width) / 2 || 0) : -b, d = 0;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = e.children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var t = _step.value;
+                var x = e;
+                if (!t.size) continue;
+                var _t_size = t.size, n = _t_size.width, B = _t_size.height, _dt = dt(u, r), Y = _dt.px, F = _dt.py;
+                if (F != d && (d = F, h = (z = e == null ? void 0 : e.size) != null && z.x ? ((I = e == null ? void 0 : e.size) == null ? void 0 : I.x) + (-((w = e == null ? void 0 : e.size) == null ? void 0 : w.width) / 2 || 0) : -b, L.debug("New row in layout for block", e.id, " and child ", t.id, d)), L.debug("abc89 layout blocks (child) id: ".concat(t.id, " Pos: ").concat(r, " (px, py) ").concat(Y, ",").concat(F, " (").concat((C = x == null ? void 0 : x.size) == null ? void 0 : C.x, ",").concat((E = x == null ? void 0 : x.size) == null ? void 0 : E.y, ") parent: ").concat(x.id, " width: ").concat(n).concat(b)), x.size) {
+                    var R = n / 2;
+                    t.size.x = h + b + R, L.debug("abc91 layout blocks (calc) px, pyid:".concat(t.id, " startingPos=X").concat(h, " new startingPosX").concat(t.size.x, " ").concat(R, " padding=").concat(b, " width=").concat(n, " halfWidth=").concat(R, " => x:").concat(t.size.x, " y:").concat(t.size.y, " ").concat(t.widthInColumns, " (width * (child?.w || 1)) / 2 ").concat(n * ((t == null ? void 0 : t.widthInColumns) || 1) / 2)), h = t.size.x + R, t.size.y = x.size.y - x.size.height / 2 + F * (B + b) + B / 2 + b, L.debug("abc88 layout blocks (calc) px, pyid:".concat(t.id, "startingPosX").concat(h).concat(b).concat(R, "=>x:").concat(t.size.x, "y:").concat(t.size.y).concat(t.widthInColumns, "(width * (child?.w || 1)) / 2").concat(n * ((t == null ? void 0 : t.widthInColumns) || 1) / 2));
+                }
+                t.children && Le(t), r += (t == null ? void 0 : t.widthInColumns) || 1, L.debug("abc88 columnsPos", t, r);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    L.debug("layout blocks (<==layoutBlocks) ".concat(e.id, " x: ").concat((v = e == null ? void 0 : e.size) == null ? void 0 : v.x, " y: ").concat((N = e == null ? void 0 : e.size) == null ? void 0 : N.y, " width: ").concat((D = e == null ? void 0 : e.size) == null ? void 0 : D.width));
+}
+function xe(e) {
+    var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+        minX: 0,
+        minY: 0,
+        maxX: 0,
+        maxY: 0
+    }, c = _ref.minX, u = _ref.minY, a = _ref.maxX, i = _ref.maxY;
+    if (e.size && e.id !== "root") {
+        var _e_size = e.size, g = _e_size.x, o = _e_size.y, p = _e_size.width, f = _e_size.height;
+        g - p / 2 < c && (c = g - p / 2), o - f / 2 < u && (u = o - f / 2), g + p / 2 > a && (a = g + p / 2), o + f / 2 > i && (i = o + f / 2);
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    if (e.children) try {
+        for(var _iterator = e.children[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var g1 = _step.value;
+            var ref;
+            ref = xe(g1, {
+                minX: c,
+                minY: u,
+                maxX: a,
+                maxY: i
+            }), c = ref.minX, u = ref.minY, a = ref.maxX, i = ref.maxY, ref;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {
+        minX: c,
+        minY: u,
+        maxX: a,
+        maxY: i
+    };
+}
+function ft(e) {
+    var c = e.getBlock("root");
+    if (!c) return;
+    te(c, e, 0, 0), Le(c), L.debug("getBlocks", JSON.stringify(c, null, 2));
+    var _xe = xe(c), u = _xe.minX, a = _xe.minY, i = _xe.maxX, g = _xe.maxY, o = g - a, p = i - u;
+    return {
+        x: u,
+        y: a,
+        width: p,
+        height: o
+    };
+}
+var St = function St(e, c) {
+    return c.db.getClasses();
+}, Lt = function() {
+    var _ref = _async_to_generator(function(e, c, u, a) {
+        var _se, i, g, o, p, f, m, y, z, I, w, C, E, v, N, D, l;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _se = $t(), i = _se.securityLevel, g = _se.block, o = a.db;
+                    i === "sandbox" && (p = bt("#i" + c));
+                    f = i === "sandbox" ? bt(p.nodes()[0].contentDocument.body) : bt("body"), m = i === "sandbox" ? f.select('[id="'.concat(c, '"]')) : bt('[id="'.concat(c, '"]'));
+                    hr(m, [
+                        "point",
+                        "circle",
+                        "cross"
+                    ], a.type, c);
+                    y = o.getBlocks(), z = o.getBlocksFlat(), I = o.getEdges(), w = m.insert("g").attr("class", "block");
+                    return [
+                        4,
+                        ht(w, y, o)
+                    ];
+                case 1:
+                    _state.sent();
+                    C = ft(o);
+                    return [
+                        4,
+                        ut(w, y, o)
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        4,
+                        gt(w, I, z, o, c)
+                    ];
+                case 3:
+                    if (_state.sent(), C) {
+                        E = C, v = Math.max(1, Math.round(0.125 * (E.width / E.height))), N = E.height + v + 10, D = E.width + 10, l = g.useMaxWidth;
+                        Ol(m, N, D, !!l), L.debug("Here Bounds", C, E), m.attr("viewBox", "".concat(E.x - 5, " ").concat(E.y - 5, " ").concat(E.width + 10, " ").concat(E.height + 10));
+                    }
+                    h(r);
+                    return [
+                        2
+                    ];
+            }
+        });
+    });
+    return function Lt(e, c, u, a) {
+        return _ref.apply(this, arguments);
+    };
+}(), xt = {
+    draw: Lt,
+    getClasses: St
+}, Ct = {
+    parser: Pe,
+    db: nt,
+    renderer: xt,
+    styles: ot
+};
+
+export { Ct as diagram };