import { E as E_, L as L_, A as A_, F as F_, V as Vn, b as bt, O as Ol, m as B_, a as L, $ as $n } from './index.esm2.js';
import { Z as Ze$1 } from './graph-0ee63739.esm.js';
import { Y as Yt } from './layout-fd473db2.esm.js';
import { P } from './line-24d93f1b.esm.js';
import './array-2ff2c7a6.esm.js';
import './path-428ebac9.esm.js';

function _instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}
function _type_of(obj) {
    "@swc/helpers - typeof";
    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
var ce = function() {
    var e = function e(V, i, r, a) {
        for(r = r || {}, a = V.length; a--; r[V[a]] = i);
        return r;
    }, t = [
        1,
        3
    ], l = [
        1,
        4
    ], c = [
        1,
        5
    ], u = [
        1,
        6
    ], d = [
        5,
        6,
        8,
        9,
        11,
        13,
        31,
        32,
        33,
        34,
        35,
        36,
        44,
        62,
        63
    ], f = [
        1,
        18
    ], h = [
        2,
        7
    ], o = [
        1,
        22
    ], E = [
        1,
        23
    ], R = [
        1,
        24
    ], A = [
        1,
        25
    ], T = [
        1,
        26
    ], N = [
        1,
        27
    ], w = [
        1,
        20
    ], k = [
        1,
        28
    ], x = [
        1,
        29
    ], F = [
        62,
        63
    ], de = [
        5,
        8,
        9,
        11,
        13,
        31,
        32,
        33,
        34,
        35,
        36,
        44,
        51,
        53,
        62,
        63
    ], fe = [
        1,
        47
    ], pe = [
        1,
        48
    ], ye = [
        1,
        49
    ], _e = [
        1,
        50
    ], Ee = [
        1,
        51
    ], ge = [
        1,
        52
    ], Re = [
        1,
        53
    ], O = [
        53,
        54
    ], M = [
        1,
        64
    ], D = [
        1,
        60
    ], P = [
        1,
        61
    ], Y = [
        1,
        62
    ], U = [
        1,
        63
    ], B = [
        1,
        65
    ], j = [
        1,
        69
    ], z = [
        1,
        70
    ], X = [
        1,
        67
    ], J = [
        1,
        68
    ], m = [
        5,
        8,
        9,
        11,
        13,
        31,
        32,
        33,
        34,
        35,
        36,
        44,
        62,
        63
    ], ie = {
        trace: function trace() {},
        yy: {},
        symbols_: {
            error: 2,
            start: 3,
            directive: 4,
            NEWLINE: 5,
            RD: 6,
            diagram: 7,
            EOF: 8,
            acc_title: 9,
            acc_title_value: 10,
            acc_descr: 11,
            acc_descr_value: 12,
            acc_descr_multiline_value: 13,
            requirementDef: 14,
            elementDef: 15,
            relationshipDef: 16,
            requirementType: 17,
            requirementName: 18,
            STRUCT_START: 19,
            requirementBody: 20,
            ID: 21,
            COLONSEP: 22,
            id: 23,
            TEXT: 24,
            text: 25,
            RISK: 26,
            riskLevel: 27,
            VERIFYMTHD: 28,
            verifyType: 29,
            STRUCT_STOP: 30,
            REQUIREMENT: 31,
            FUNCTIONAL_REQUIREMENT: 32,
            INTERFACE_REQUIREMENT: 33,
            PERFORMANCE_REQUIREMENT: 34,
            PHYSICAL_REQUIREMENT: 35,
            DESIGN_CONSTRAINT: 36,
            LOW_RISK: 37,
            MED_RISK: 38,
            HIGH_RISK: 39,
            VERIFY_ANALYSIS: 40,
            VERIFY_DEMONSTRATION: 41,
            VERIFY_INSPECTION: 42,
            VERIFY_TEST: 43,
            ELEMENT: 44,
            elementName: 45,
            elementBody: 46,
            TYPE: 47,
            type: 48,
            DOCREF: 49,
            ref: 50,
            END_ARROW_L: 51,
            relationship: 52,
            LINE: 53,
            END_ARROW_R: 54,
            CONTAINS: 55,
            COPIES: 56,
            DERIVES: 57,
            SATISFIES: 58,
            VERIFIES: 59,
            REFINES: 60,
            TRACES: 61,
            unqString: 62,
            qString: 63,
            $accept: 0,
            $end: 1
        },
        terminals_: {
            2: "error",
            5: "NEWLINE",
            6: "RD",
            8: "EOF",
            9: "acc_title",
            10: "acc_title_value",
            11: "acc_descr",
            12: "acc_descr_value",
            13: "acc_descr_multiline_value",
            19: "STRUCT_START",
            21: "ID",
            22: "COLONSEP",
            24: "TEXT",
            26: "RISK",
            28: "VERIFYMTHD",
            30: "STRUCT_STOP",
            31: "REQUIREMENT",
            32: "FUNCTIONAL_REQUIREMENT",
            33: "INTERFACE_REQUIREMENT",
            34: "PERFORMANCE_REQUIREMENT",
            35: "PHYSICAL_REQUIREMENT",
            36: "DESIGN_CONSTRAINT",
            37: "LOW_RISK",
            38: "MED_RISK",
            39: "HIGH_RISK",
            40: "VERIFY_ANALYSIS",
            41: "VERIFY_DEMONSTRATION",
            42: "VERIFY_INSPECTION",
            43: "VERIFY_TEST",
            44: "ELEMENT",
            47: "TYPE",
            49: "DOCREF",
            51: "END_ARROW_L",
            53: "LINE",
            54: "END_ARROW_R",
            55: "CONTAINS",
            56: "COPIES",
            57: "DERIVES",
            58: "SATISFIES",
            59: "VERIFIES",
            60: "REFINES",
            61: "TRACES",
            62: "unqString",
            63: "qString"
        },
        productions_: [
            0,
            [
                3,
                3
            ],
            [
                3,
                2
            ],
            [
                3,
                4
            ],
            [
                4,
                2
            ],
            [
                4,
                2
            ],
            [
                4,
                1
            ],
            [
                7,
                0
            ],
            [
                7,
                2
            ],
            [
                7,
                2
            ],
            [
                7,
                2
            ],
            [
                7,
                2
            ],
            [
                7,
                2
            ],
            [
                14,
                5
            ],
            [
                20,
                5
            ],
            [
                20,
                5
            ],
            [
                20,
                5
            ],
            [
                20,
                5
            ],
            [
                20,
                2
            ],
            [
                20,
                1
            ],
            [
                17,
                1
            ],
            [
                17,
                1
            ],
            [
                17,
                1
            ],
            [
                17,
                1
            ],
            [
                17,
                1
            ],
            [
                17,
                1
            ],
            [
                27,
                1
            ],
            [
                27,
                1
            ],
            [
                27,
                1
            ],
            [
                29,
                1
            ],
            [
                29,
                1
            ],
            [
                29,
                1
            ],
            [
                29,
                1
            ],
            [
                15,
                5
            ],
            [
                46,
                5
            ],
            [
                46,
                5
            ],
            [
                46,
                2
            ],
            [
                46,
                1
            ],
            [
                16,
                5
            ],
            [
                16,
                5
            ],
            [
                52,
                1
            ],
            [
                52,
                1
            ],
            [
                52,
                1
            ],
            [
                52,
                1
            ],
            [
                52,
                1
            ],
            [
                52,
                1
            ],
            [
                52,
                1
            ],
            [
                18,
                1
            ],
            [
                18,
                1
            ],
            [
                23,
                1
            ],
            [
                23,
                1
            ],
            [
                25,
                1
            ],
            [
                25,
                1
            ],
            [
                45,
                1
            ],
            [
                45,
                1
            ],
            [
                48,
                1
            ],
            [
                48,
                1
            ],
            [
                50,
                1
            ],
            [
                50,
                1
            ]
        ],
        performAction: function performAction(i, r, a, n, p, s, W) {
            var _ = s.length - 1;
            switch(p){
                case 4:
                    this.$ = s[_].trim(), n.setAccTitle(this.$);
                    break;
                case 5:
                case 6:
                    this.$ = s[_].trim(), n.setAccDescription(this.$);
                    break;
                case 7:
                    this.$ = [];
                    break;
                case 13:
                    n.addRequirement(s[_ - 3], s[_ - 4]);
                    break;
                case 14:
                    n.setNewReqId(s[_ - 2]);
                    break;
                case 15:
                    n.setNewReqText(s[_ - 2]);
                    break;
                case 16:
                    n.setNewReqRisk(s[_ - 2]);
                    break;
                case 17:
                    n.setNewReqVerifyMethod(s[_ - 2]);
                    break;
                case 20:
                    this.$ = n.RequirementType.REQUIREMENT;
                    break;
                case 21:
                    this.$ = n.RequirementType.FUNCTIONAL_REQUIREMENT;
                    break;
                case 22:
                    this.$ = n.RequirementType.INTERFACE_REQUIREMENT;
                    break;
                case 23:
                    this.$ = n.RequirementType.PERFORMANCE_REQUIREMENT;
                    break;
                case 24:
                    this.$ = n.RequirementType.PHYSICAL_REQUIREMENT;
                    break;
                case 25:
                    this.$ = n.RequirementType.DESIGN_CONSTRAINT;
                    break;
                case 26:
                    this.$ = n.RiskLevel.LOW_RISK;
                    break;
                case 27:
                    this.$ = n.RiskLevel.MED_RISK;
                    break;
                case 28:
                    this.$ = n.RiskLevel.HIGH_RISK;
                    break;
                case 29:
                    this.$ = n.VerifyType.VERIFY_ANALYSIS;
                    break;
                case 30:
                    this.$ = n.VerifyType.VERIFY_DEMONSTRATION;
                    break;
                case 31:
                    this.$ = n.VerifyType.VERIFY_INSPECTION;
                    break;
                case 32:
                    this.$ = n.VerifyType.VERIFY_TEST;
                    break;
                case 33:
                    n.addElement(s[_ - 3]);
                    break;
                case 34:
                    n.setNewElementType(s[_ - 2]);
                    break;
                case 35:
                    n.setNewElementDocRef(s[_ - 2]);
                    break;
                case 38:
                    n.addRelationship(s[_ - 2], s[_], s[_ - 4]);
                    break;
                case 39:
                    n.addRelationship(s[_ - 2], s[_ - 4], s[_]);
                    break;
                case 40:
                    this.$ = n.Relationships.CONTAINS;
                    break;
                case 41:
                    this.$ = n.Relationships.COPIES;
                    break;
                case 42:
                    this.$ = n.Relationships.DERIVES;
                    break;
                case 43:
                    this.$ = n.Relationships.SATISFIES;
                    break;
                case 44:
                    this.$ = n.Relationships.VERIFIES;
                    break;
                case 45:
                    this.$ = n.Relationships.REFINES;
                    break;
                case 46:
                    this.$ = n.Relationships.TRACES;
                    break;
            }
        },
        table: [
            {
                3: 1,
                4: 2,
                6: t,
                9: l,
                11: c,
                13: u
            },
            {
                1: [
                    3
                ]
            },
            {
                3: 8,
                4: 2,
                5: [
                    1,
                    7
                ],
                6: t,
                9: l,
                11: c,
                13: u
            },
            {
                5: [
                    1,
                    9
                ]
            },
            {
                10: [
                    1,
                    10
                ]
            },
            {
                12: [
                    1,
                    11
                ]
            },
            e(d, [
                2,
                6
            ]),
            {
                3: 12,
                4: 2,
                6: t,
                9: l,
                11: c,
                13: u
            },
            {
                1: [
                    2,
                    2
                ]
            },
            {
                4: 17,
                5: f,
                7: 13,
                8: h,
                9: l,
                11: c,
                13: u,
                14: 14,
                15: 15,
                16: 16,
                17: 19,
                23: 21,
                31: o,
                32: E,
                33: R,
                34: A,
                35: T,
                36: N,
                44: w,
                62: k,
                63: x
            },
            e(d, [
                2,
                4
            ]),
            e(d, [
                2,
                5
            ]),
            {
                1: [
                    2,
                    1
                ]
            },
            {
                8: [
                    1,
                    30
                ]
            },
            {
                4: 17,
                5: f,
                7: 31,
                8: h,
                9: l,
                11: c,
                13: u,
                14: 14,
                15: 15,
                16: 16,
                17: 19,
                23: 21,
                31: o,
                32: E,
                33: R,
                34: A,
                35: T,
                36: N,
                44: w,
                62: k,
                63: x
            },
            {
                4: 17,
                5: f,
                7: 32,
                8: h,
                9: l,
                11: c,
                13: u,
                14: 14,
                15: 15,
                16: 16,
                17: 19,
                23: 21,
                31: o,
                32: E,
                33: R,
                34: A,
                35: T,
                36: N,
                44: w,
                62: k,
                63: x
            },
            {
                4: 17,
                5: f,
                7: 33,
                8: h,
                9: l,
                11: c,
                13: u,
                14: 14,
                15: 15,
                16: 16,
                17: 19,
                23: 21,
                31: o,
                32: E,
                33: R,
                34: A,
                35: T,
                36: N,
                44: w,
                62: k,
                63: x
            },
            {
                4: 17,
                5: f,
                7: 34,
                8: h,
                9: l,
                11: c,
                13: u,
                14: 14,
                15: 15,
                16: 16,
                17: 19,
                23: 21,
                31: o,
                32: E,
                33: R,
                34: A,
                35: T,
                36: N,
                44: w,
                62: k,
                63: x
            },
            {
                4: 17,
                5: f,
                7: 35,
                8: h,
                9: l,
                11: c,
                13: u,
                14: 14,
                15: 15,
                16: 16,
                17: 19,
                23: 21,
                31: o,
                32: E,
                33: R,
                34: A,
                35: T,
                36: N,
                44: w,
                62: k,
                63: x
            },
            {
                18: 36,
                62: [
                    1,
                    37
                ],
                63: [
                    1,
                    38
                ]
            },
            {
                45: 39,
                62: [
                    1,
                    40
                ],
                63: [
                    1,
                    41
                ]
            },
            {
                51: [
                    1,
                    42
                ],
                53: [
                    1,
                    43
                ]
            },
            e(F, [
                2,
                20
            ]),
            e(F, [
                2,
                21
            ]),
            e(F, [
                2,
                22
            ]),
            e(F, [
                2,
                23
            ]),
            e(F, [
                2,
                24
            ]),
            e(F, [
                2,
                25
            ]),
            e(de, [
                2,
                49
            ]),
            e(de, [
                2,
                50
            ]),
            {
                1: [
                    2,
                    3
                ]
            },
            {
                8: [
                    2,
                    8
                ]
            },
            {
                8: [
                    2,
                    9
                ]
            },
            {
                8: [
                    2,
                    10
                ]
            },
            {
                8: [
                    2,
                    11
                ]
            },
            {
                8: [
                    2,
                    12
                ]
            },
            {
                19: [
                    1,
                    44
                ]
            },
            {
                19: [
                    2,
                    47
                ]
            },
            {
                19: [
                    2,
                    48
                ]
            },
            {
                19: [
                    1,
                    45
                ]
            },
            {
                19: [
                    2,
                    53
                ]
            },
            {
                19: [
                    2,
                    54
                ]
            },
            {
                52: 46,
                55: fe,
                56: pe,
                57: ye,
                58: _e,
                59: Ee,
                60: ge,
                61: Re
            },
            {
                52: 54,
                55: fe,
                56: pe,
                57: ye,
                58: _e,
                59: Ee,
                60: ge,
                61: Re
            },
            {
                5: [
                    1,
                    55
                ]
            },
            {
                5: [
                    1,
                    56
                ]
            },
            {
                53: [
                    1,
                    57
                ]
            },
            e(O, [
                2,
                40
            ]),
            e(O, [
                2,
                41
            ]),
            e(O, [
                2,
                42
            ]),
            e(O, [
                2,
                43
            ]),
            e(O, [
                2,
                44
            ]),
            e(O, [
                2,
                45
            ]),
            e(O, [
                2,
                46
            ]),
            {
                54: [
                    1,
                    58
                ]
            },
            {
                5: M,
                20: 59,
                21: D,
                24: P,
                26: Y,
                28: U,
                30: B
            },
            {
                5: j,
                30: z,
                46: 66,
                47: X,
                49: J
            },
            {
                23: 71,
                62: k,
                63: x
            },
            {
                23: 72,
                62: k,
                63: x
            },
            e(m, [
                2,
                13
            ]),
            {
                22: [
                    1,
                    73
                ]
            },
            {
                22: [
                    1,
                    74
                ]
            },
            {
                22: [
                    1,
                    75
                ]
            },
            {
                22: [
                    1,
                    76
                ]
            },
            {
                5: M,
                20: 77,
                21: D,
                24: P,
                26: Y,
                28: U,
                30: B
            },
            e(m, [
                2,
                19
            ]),
            e(m, [
                2,
                33
            ]),
            {
                22: [
                    1,
                    78
                ]
            },
            {
                22: [
                    1,
                    79
                ]
            },
            {
                5: j,
                30: z,
                46: 80,
                47: X,
                49: J
            },
            e(m, [
                2,
                37
            ]),
            e(m, [
                2,
                38
            ]),
            e(m, [
                2,
                39
            ]),
            {
                23: 81,
                62: k,
                63: x
            },
            {
                25: 82,
                62: [
                    1,
                    83
                ],
                63: [
                    1,
                    84
                ]
            },
            {
                27: 85,
                37: [
                    1,
                    86
                ],
                38: [
                    1,
                    87
                ],
                39: [
                    1,
                    88
                ]
            },
            {
                29: 89,
                40: [
                    1,
                    90
                ],
                41: [
                    1,
                    91
                ],
                42: [
                    1,
                    92
                ],
                43: [
                    1,
                    93
                ]
            },
            e(m, [
                2,
                18
            ]),
            {
                48: 94,
                62: [
                    1,
                    95
                ],
                63: [
                    1,
                    96
                ]
            },
            {
                50: 97,
                62: [
                    1,
                    98
                ],
                63: [
                    1,
                    99
                ]
            },
            e(m, [
                2,
                36
            ]),
            {
                5: [
                    1,
                    100
                ]
            },
            {
                5: [
                    1,
                    101
                ]
            },
            {
                5: [
                    2,
                    51
                ]
            },
            {
                5: [
                    2,
                    52
                ]
            },
            {
                5: [
                    1,
                    102
                ]
            },
            {
                5: [
                    2,
                    26
                ]
            },
            {
                5: [
                    2,
                    27
                ]
            },
            {
                5: [
                    2,
                    28
                ]
            },
            {
                5: [
                    1,
                    103
                ]
            },
            {
                5: [
                    2,
                    29
                ]
            },
            {
                5: [
                    2,
                    30
                ]
            },
            {
                5: [
                    2,
                    31
                ]
            },
            {
                5: [
                    2,
                    32
                ]
            },
            {
                5: [
                    1,
                    104
                ]
            },
            {
                5: [
                    2,
                    55
                ]
            },
            {
                5: [
                    2,
                    56
                ]
            },
            {
                5: [
                    1,
                    105
                ]
            },
            {
                5: [
                    2,
                    57
                ]
            },
            {
                5: [
                    2,
                    58
                ]
            },
            {
                5: M,
                20: 106,
                21: D,
                24: P,
                26: Y,
                28: U,
                30: B
            },
            {
                5: M,
                20: 107,
                21: D,
                24: P,
                26: Y,
                28: U,
                30: B
            },
            {
                5: M,
                20: 108,
                21: D,
                24: P,
                26: Y,
                28: U,
                30: B
            },
            {
                5: M,
                20: 109,
                21: D,
                24: P,
                26: Y,
                28: U,
                30: B
            },
            {
                5: j,
                30: z,
                46: 110,
                47: X,
                49: J
            },
            {
                5: j,
                30: z,
                46: 111,
                47: X,
                49: J
            },
            e(m, [
                2,
                14
            ]),
            e(m, [
                2,
                15
            ]),
            e(m, [
                2,
                16
            ]),
            e(m, [
                2,
                17
            ]),
            e(m, [
                2,
                34
            ]),
            e(m, [
                2,
                35
            ])
        ],
        defaultActions: {
            8: [
                2,
                2
            ],
            12: [
                2,
                1
            ],
            30: [
                2,
                3
            ],
            31: [
                2,
                8
            ],
            32: [
                2,
                9
            ],
            33: [
                2,
                10
            ],
            34: [
                2,
                11
            ],
            35: [
                2,
                12
            ],
            37: [
                2,
                47
            ],
            38: [
                2,
                48
            ],
            40: [
                2,
                53
            ],
            41: [
                2,
                54
            ],
            83: [
                2,
                51
            ],
            84: [
                2,
                52
            ],
            86: [
                2,
                26
            ],
            87: [
                2,
                27
            ],
            88: [
                2,
                28
            ],
            90: [
                2,
                29
            ],
            91: [
                2,
                30
            ],
            92: [
                2,
                31
            ],
            93: [
                2,
                32
            ],
            95: [
                2,
                55
            ],
            96: [
                2,
                56
            ],
            98: [
                2,
                57
            ],
            99: [
                2,
                58
            ]
        },
        parseError: function parseError(i, r) {
            if (r.recoverable) this.trace(i);
            else {
                var a = new Error(i);
                throw a.hash = r, a;
            }
        },
        parse: function parse(i) {
            var r = this, a = [
                0
            ], n = [], p = [
                null
            ], s = [], W = this.table, _ = "", Z = 0, me = 0, Ve = 2, Ie = 1, qe = s.slice.call(arguments, 1), g = Object.create(this.lexer), L = {
                yy: {}
            };
            for(var re in this.yy)Object.prototype.hasOwnProperty.call(this.yy, re) && (L.yy[re] = this.yy[re]);
            g.setInput(i, L.yy), L.yy.lexer = g, L.yy.parser = this, _type_of(g.yylloc) > "u" && (g.yylloc = {});
            var se = g.yylloc;
            s.push(se);
            var Oe = g.options && g.options.ranges;
            typeof L.yy.parseError == "function" ? this.parseError = L.yy.parseError : this.parseError = Object.getPrototypeOf(this).parseError;
            function Le() {
                var v;
                return v = n.pop() || g.lex() || Ie, typeof v != "number" && (_instanceof(v, Array) && (n = v, v = n.pop()), v = r.symbols_[v] || v), v;
            }
            for(var I, C, S, ae, Q = {}, ee, $, be, te;;){
                if (C = a[a.length - 1], this.defaultActions[C] ? S = this.defaultActions[C] : ((I === null || (typeof I === "undefined" ? "undefined" : _type_of(I)) > "u") && (I = Le()), S = W[C] && W[C][I]), (typeof S === "undefined" ? "undefined" : _type_of(S)) > "u" || !S.length || !S[0]) {
                    var le = "";
                    te = [];
                    for(ee in W[C])this.terminals_[ee] && ee > Ve && te.push("'" + this.terminals_[ee] + "'");
                    g.showPosition ? le = "Parse error on line " + (Z + 1) + ":\n" + g.showPosition() + "\nExpecting " + te.join(", ") + ", got '" + (this.terminals_[I] || I) + "'" : le = "Parse error on line " + (Z + 1) + ": Unexpected " + (I == Ie ? "end of input" : "'" + (this.terminals_[I] || I) + "'"), this.parseError(le, {
                        text: g.match,
                        token: this.terminals_[I] || I,
                        line: g.yylineno,
                        loc: se,
                        expected: te
                    });
                }
                if (_instanceof(S[0], Array) && S.length > 1) throw new Error("Parse Error: multiple actions possible at state: " + C + ", token: " + I);
                switch(S[0]){
                    case 1:
                        a.push(I), p.push(g.yytext), s.push(g.yylloc), a.push(S[1]), I = null, me = g.yyleng, _ = g.yytext, Z = g.yylineno, se = g.yylloc;
                        break;
                    case 2:
                        if ($ = this.productions_[S[1]][1], Q.$ = p[p.length - $], Q._$ = {
                            first_line: s[s.length - ($ || 1)].first_line,
                            last_line: s[s.length - 1].last_line,
                            first_column: s[s.length - ($ || 1)].first_column,
                            last_column: s[s.length - 1].last_column
                        }, Oe && (Q._$.range = [
                            s[s.length - ($ || 1)].range[0],
                            s[s.length - 1].range[1]
                        ]), ae = this.performAction.apply(Q, [
                            _,
                            me,
                            Z,
                            L.yy,
                            S[1],
                            p,
                            s
                        ].concat(qe)), (typeof ae === "undefined" ? "undefined" : _type_of(ae)) < "u") return ae;
                        $ && (a = a.slice(0, -1 * $ * 2), p = p.slice(0, -1 * $), s = s.slice(0, -1 * $)), a.push(this.productions_[S[1]][0]), p.push(Q.$), s.push(Q._$), be = W[a[a.length - 2]][a[a.length - 1]], a.push(be);
                        break;
                    case 3:
                        return true;
                }
            }
            return true;
        }
    }, ve = function() {
        var V = {
            EOF: 1,
            parseError: function parseError(r, a) {
                if (this.yy.parser) this.yy.parser.parseError(r, a);
                else throw new Error(r);
            },
            // resets the lexer, sets new input
            setInput: function setInput(i, r) {
                return this.yy = r || this.yy || {}, this._input = i, this._more = this._backtrack = this.done = false, this.yylineno = this.yyleng = 0, this.yytext = this.matched = this.match = "", this.conditionStack = [
                    "INITIAL"
                ], this.yylloc = {
                    first_line: 1,
                    first_column: 0,
                    last_line: 1,
                    last_column: 0
                }, this.options.ranges && (this.yylloc.range = [
                    0,
                    0
                ]), this.offset = 0, this;
            },
            // consumes and returns one char from the input
            input: function input() {
                var i = this._input[0];
                this.yytext += i, this.yyleng++, this.offset++, this.match += i, this.matched += i;
                var r = i.match(/(?:\r\n?|\n).*/g);
                return r ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++, this.options.ranges && this.yylloc.range[1]++, this._input = this._input.slice(1), i;
            },
            // unshifts one char (or a string) into the input
            unput: function unput(i) {
                var r = i.length, a = i.split(/(?:\r\n?|\n)/g);
                this._input = i + this._input, this.yytext = this.yytext.substr(0, this.yytext.length - r), this.offset -= r;
                var n = 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), a.length - 1 && (this.yylineno -= a.length - 1);
                var p = 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: a ? (a.length === n.length ? this.yylloc.first_column : 0) + n[n.length - a.length].length - a[0].length : this.yylloc.first_column - r
                }, this.options.ranges && (this.yylloc.range = [
                    p[0],
                    p[0] + this.yyleng - r
                ]), 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 = true, 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 = true;
                else return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), {
                    text: "",
                    token: null,
                    line: this.yylineno
                });
                return this;
            },
            // retain first n characters of the match
            less: function less(i) {
                this.unput(this.match.slice(i));
            },
            // displays already matched input, i.e. for error messages
            pastInput: function pastInput() {
                var i = this.matched.substr(0, this.matched.length - this.match.length);
                return (i.length > 20 ? "..." : "") + i.substr(-20).replace(/\n/g, "");
            },
            // displays upcoming input, i.e. for error messages
            upcomingInput: function upcomingInput() {
                var i = this.match;
                return i.length < 20 && (i += this._input.substr(0, 20 - i.length)), (i.substr(0, 20) + (i.length > 20 ? "..." : "")).replace(/\n/g, "");
            },
            // displays the character position where the lexing error occurred, i.e. for error messages
            showPosition: function showPosition() {
                var i = this.pastInput(), r = new Array(i.length + 1).join("-");
                return i + this.upcomingInput() + "\n" + r + "^";
            },
            // test the lexed token: return FALSE when not a match, otherwise return token
            test_match: function test_match(i, r) {
                var a, n, p;
                if (this.options.backtrack_lexer && (p = {
                    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 && (p.yylloc.range = this.yylloc.range.slice(0))), n = i[0].match(/(?:\r\n?|\n).*/g), n && (this.yylineno += n.length), this.yylloc = {
                    first_line: this.yylloc.last_line,
                    last_line: this.yylineno + 1,
                    first_column: this.yylloc.last_column,
                    last_column: n ? n[n.length - 1].length - n[n.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + i[0].length
                }, this.yytext += i[0], this.match += i[0], this.matches = i, this.yyleng = this.yytext.length, this.options.ranges && (this.yylloc.range = [
                    this.offset,
                    this.offset += this.yyleng
                ]), this._more = false, this._backtrack = false, this._input = this._input.slice(i[0].length), this.matched += i[0], a = this.performAction.call(this, this.yy, this, r, this.conditionStack[this.conditionStack.length - 1]), this.done && this._input && (this.done = false), a) return a;
                if (this._backtrack) {
                    for(var s in p)this[s] = p[s];
                    return false;
                }
                return false;
            },
            // return next match in input
            next: function next() {
                if (this.done) return this.EOF;
                this._input || (this.done = true);
                var i, r, a, n;
                this._more || (this.yytext = "", this.match = "");
                for(var p = this._currentRules(), s = 0; s < p.length; s++)if (a = this._input.match(this.rules[p[s]]), a && (!r || a[0].length > r[0].length)) {
                    if (r = a, n = s, this.options.backtrack_lexer) {
                        if (i = this.test_match(a, p[s]), i !== false) return i;
                        if (this._backtrack) {
                            r = false;
                            continue;
                        } else return false;
                    } else if (!this.options.flex) break;
                }
                return r ? (i = this.test_match(r, p[n]), i !== false ? i : false) : 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 r = this.next();
                return r || this.lex();
            },
            // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
            begin: function begin(r) {
                this.conditionStack.push(r);
            },
            // pop the previously active lexer condition state off the condition stack
            popState: function popState() {
                var r = this.conditionStack.length - 1;
                return r > 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(r) {
                return r = this.conditionStack.length - 1 - Math.abs(r || 0), r >= 0 ? this.conditionStack[r] : "INITIAL";
            },
            // alias for begin(condition)
            pushState: function pushState(r) {
                this.begin(r);
            },
            // return the number of states currently on the stack
            stateStackSize: function stateStackSize() {
                return this.conditionStack.length;
            },
            options: {
                "case-insensitive": true
            },
            performAction: function performAction(r, a, n, p) {
                switch(n){
                    case 0:
                        return "title";
                    case 1:
                        return this.begin("acc_title"), 9;
                    case 2:
                        return this.popState(), "acc_title_value";
                    case 3:
                        return this.begin("acc_descr"), 11;
                    case 4:
                        return this.popState(), "acc_descr_value";
                    case 5:
                        this.begin("acc_descr_multiline");
                        break;
                    case 6:
                        this.popState();
                        break;
                    case 7:
                        return "acc_descr_multiline_value";
                    case 8:
                        return 5;
                    case 9:
                        break;
                    case 10:
                        break;
                    case 11:
                        break;
                    case 12:
                        return 8;
                    case 13:
                        return 6;
                    case 14:
                        return 19;
                    case 15:
                        return 30;
                    case 16:
                        return 22;
                    case 17:
                        return 21;
                    case 18:
                        return 24;
                    case 19:
                        return 26;
                    case 20:
                        return 28;
                    case 21:
                        return 31;
                    case 22:
                        return 32;
                    case 23:
                        return 33;
                    case 24:
                        return 34;
                    case 25:
                        return 35;
                    case 26:
                        return 36;
                    case 27:
                        return 37;
                    case 28:
                        return 38;
                    case 29:
                        return 39;
                    case 30:
                        return 40;
                    case 31:
                        return 41;
                    case 32:
                        return 42;
                    case 33:
                        return 43;
                    case 34:
                        return 44;
                    case 35:
                        return 55;
                    case 36:
                        return 56;
                    case 37:
                        return 57;
                    case 38:
                        return 58;
                    case 39:
                        return 59;
                    case 40:
                        return 60;
                    case 41:
                        return 61;
                    case 42:
                        return 47;
                    case 43:
                        return 49;
                    case 44:
                        return 51;
                    case 45:
                        return 54;
                    case 46:
                        return 53;
                    case 47:
                        this.begin("string");
                        break;
                    case 48:
                        this.popState();
                        break;
                    case 49:
                        return "qString";
                    case 50:
                        return a.yytext = a.yytext.trim(), 62;
                }
            },
            rules: [
                /^(?:title\s[^#\n;]+)/i,
                /^(?:accTitle\s*:\s*)/i,
                /^(?:(?!\n||)*[^\n]*)/i,
                /^(?:accDescr\s*:\s*)/i,
                /^(?:(?!\n||)*[^\n]*)/i,
                /^(?:accDescr\s*\{\s*)/i,
                /^(?:[\}])/i,
                /^(?:[^\}]*)/i,
                /^(?:(\r?\n)+)/i,
                /^(?:\s+)/i,
                /^(?:#[^\n]*)/i,
                /^(?:%[^\n]*)/i,
                /^(?:$)/i,
                /^(?:requirementDiagram\b)/i,
                /^(?:\{)/i,
                /^(?:\})/i,
                /^(?::)/i,
                /^(?:id\b)/i,
                /^(?:text\b)/i,
                /^(?:risk\b)/i,
                /^(?:verifyMethod\b)/i,
                /^(?:requirement\b)/i,
                /^(?:functionalRequirement\b)/i,
                /^(?:interfaceRequirement\b)/i,
                /^(?:performanceRequirement\b)/i,
                /^(?:physicalRequirement\b)/i,
                /^(?:designConstraint\b)/i,
                /^(?:low\b)/i,
                /^(?:medium\b)/i,
                /^(?:high\b)/i,
                /^(?:analysis\b)/i,
                /^(?:demonstration\b)/i,
                /^(?:inspection\b)/i,
                /^(?:test\b)/i,
                /^(?:element\b)/i,
                /^(?:contains\b)/i,
                /^(?:copies\b)/i,
                /^(?:derives\b)/i,
                /^(?:satisfies\b)/i,
                /^(?:verifies\b)/i,
                /^(?:refines\b)/i,
                /^(?:traces\b)/i,
                /^(?:type\b)/i,
                /^(?:docref\b)/i,
                /^(?:<-)/i,
                /^(?:->)/i,
                /^(?:-)/i,
                /^(?:["])/i,
                /^(?:["])/i,
                /^(?:[^"]*)/i,
                /^(?:[\w][^\r\n\{\<\>\-\=]*)/i
            ],
            conditions: {
                acc_descr_multiline: {
                    rules: [
                        6,
                        7
                    ],
                    inclusive: false
                },
                acc_descr: {
                    rules: [
                        4
                    ],
                    inclusive: false
                },
                acc_title: {
                    rules: [
                        2
                    ],
                    inclusive: false
                },
                unqString: {
                    rules: [],
                    inclusive: false
                },
                token: {
                    rules: [],
                    inclusive: false
                },
                string: {
                    rules: [
                        48,
                        49
                    ],
                    inclusive: false
                },
                INITIAL: {
                    rules: [
                        0,
                        1,
                        3,
                        5,
                        8,
                        9,
                        10,
                        11,
                        12,
                        13,
                        14,
                        15,
                        16,
                        17,
                        18,
                        19,
                        20,
                        21,
                        22,
                        23,
                        24,
                        25,
                        26,
                        27,
                        28,
                        29,
                        30,
                        31,
                        32,
                        33,
                        34,
                        35,
                        36,
                        37,
                        38,
                        39,
                        40,
                        41,
                        42,
                        43,
                        44,
                        45,
                        46,
                        47,
                        50
                    ],
                    inclusive: true
                }
            }
        };
        return V;
    }();
    ie.lexer = ve;
    function ne() {
        this.yy = {};
    }
    return ne.prototype = ie, ie.Parser = ne, new ne();
}();
ce.parser = ce;
var He = ce;
var ue = [], b = {}, K = {}, q = {}, G = {};
var We = {
    REQUIREMENT: "Requirement",
    FUNCTIONAL_REQUIREMENT: "Functional Requirement",
    INTERFACE_REQUIREMENT: "Interface Requirement",
    PERFORMANCE_REQUIREMENT: "Performance Requirement",
    PHYSICAL_REQUIREMENT: "Physical Requirement",
    DESIGN_CONSTRAINT: "Design Constraint"
}, Ke = {
    LOW_RISK: "Low",
    MED_RISK: "Medium",
    HIGH_RISK: "High"
}, Ge = {
    VERIFY_ANALYSIS: "Analysis",
    VERIFY_DEMONSTRATION: "Demonstration",
    VERIFY_INSPECTION: "Inspection",
    VERIFY_TEST: "Test"
}, je = {
    CONTAINS: "contains",
    COPIES: "copies",
    DERIVES: "derives",
    SATISFIES: "satisfies",
    VERIFIES: "verifies",
    REFINES: "refines",
    TRACES: "traces"
}, ze = function(e, t) {
    return K[e] === void 0 && (K[e] = {
        name: e,
        type: t,
        id: b.id,
        text: b.text,
        risk: b.risk,
        verifyMethod: b.verifyMethod
    }), b = {}, K[e];
}, Xe = function() {
    return K;
}, Je = function(e) {
    b !== void 0 && (b.id = e);
}, Ze = function(e) {
    b !== void 0 && (b.text = e);
}, et = function(e) {
    b !== void 0 && (b.risk = e);
}, tt = function(e) {
    b !== void 0 && (b.verifyMethod = e);
}, it = function(e) {
    return G[e] === void 0 && (G[e] = {
        name: e,
        type: q.type,
        docRef: q.docRef
    }, L.info("Added new requirement: ", e)), q = {}, G[e];
}, nt = function() {
    return G;
}, rt = function(e) {
    q !== void 0 && (q.type = e);
}, st = function(e) {
    q !== void 0 && (q.docRef = e);
}, at = function(e, t, l) {
    ue.push({
        type: e,
        src: t,
        dst: l
    });
}, lt = function() {
    return ue;
}, ot = function() {
    ue = [], b = {}, K = {}, q = {}, G = {}, B_();
}, ct = {
    RequirementType: We,
    RiskLevel: Ke,
    VerifyType: Ge,
    Relationships: je,
    getConfig: function() {
        return Vn().req;
    },
    addRequirement: ze,
    getRequirements: Xe,
    setNewReqId: Je,
    setNewReqText: Ze,
    setNewReqRisk: et,
    setNewReqVerifyMethod: tt,
    setAccTitle: F_,
    getAccTitle: A_,
    setAccDescription: L_,
    getAccDescription: E_,
    addElement: it,
    getElements: nt,
    setNewElementType: rt,
    setNewElementDocRef: st,
    addRelationship: at,
    getRelationships: lt,
    clear: ot
}, ht = function(e) {
    return "\n\n  marker {\n    fill: ".concat(e.relationColor, ";\n    stroke: ").concat(e.relationColor, ";\n  }\n\n  marker.cross {\n    stroke: ").concat(e.lineColor, ";\n  }\n\n  svg {\n    font-family: ").concat(e.fontFamily, ";\n    font-size: ").concat(e.fontSize, ";\n  }\n\n  .reqBox {\n    fill: ").concat(e.requirementBackground, ";\n    fill-opacity: 1.0;\n    stroke: ").concat(e.requirementBorderColor, ";\n    stroke-width: ").concat(e.requirementBorderSize, ";\n  }\n  \n  .reqTitle, .reqLabel{\n    fill:  ").concat(e.requirementTextColor, ";\n  }\n  .reqLabelBox {\n    fill: ").concat(e.relationLabelBackground, ";\n    fill-opacity: 1.0;\n  }\n\n  .req-title-line {\n    stroke: ").concat(e.requirementBorderColor, ";\n    stroke-width: ").concat(e.requirementBorderSize, ";\n  }\n  .relationshipLine {\n    stroke: ").concat(e.relationColor, ";\n    stroke-width: 1;\n  }\n  .relationshipLabel {\n    fill: ").concat(e.relationLabelColor, ";\n  }\n\n");
}, ut = ht, he = {
    CONTAINS: "contains",
    ARROW: "arrow"
}, dt = function(e, t) {
    var l = e.append("defs").append("marker").attr("id", he.CONTAINS + "_line_ending").attr("refX", 0).attr("refY", t.line_height / 2).attr("markerWidth", t.line_height).attr("markerHeight", t.line_height).attr("orient", "auto").append("g");
    l.append("circle").attr("cx", t.line_height / 2).attr("cy", t.line_height / 2).attr("r", t.line_height / 2).attr("fill", "none"), l.append("line").attr("x1", 0).attr("x2", t.line_height).attr("y1", t.line_height / 2).attr("y2", t.line_height / 2).attr("stroke-width", 1), l.append("line").attr("y1", 0).attr("y2", t.line_height).attr("x1", t.line_height / 2).attr("x2", t.line_height / 2).attr("stroke-width", 1), e.append("defs").append("marker").attr("id", he.ARROW + "_line_ending").attr("refX", t.line_height).attr("refY", 0.5 * t.line_height).attr("markerWidth", t.line_height).attr("markerHeight", t.line_height).attr("orient", "auto").append("path").attr("d", "M0,0\n      L".concat(t.line_height, ",").concat(t.line_height / 2, "\n      M").concat(t.line_height, ",").concat(t.line_height / 2, "\n      L0,").concat(t.line_height)).attr("stroke-width", 1);
}, xe = {
    ReqMarkers: he,
    insertLineEndings: dt
};
var y = {}, Se = 0;
var Ae = function(e, t) {
    return e.insert("rect", "#" + t).attr("class", "req reqBox").attr("x", 0).attr("y", 0).attr("width", y.rect_min_width + "px").attr("height", y.rect_min_height + "px");
}, we = function(e, t, l) {
    var c = y.rect_min_width / 2, u = e.append("text").attr("class", "req reqLabel reqTitle").attr("id", t).attr("x", c).attr("y", y.rect_padding).attr("dominant-baseline", "hanging"), d = 0;
    l.forEach(function(E) {
        d == 0 ? u.append("tspan").attr("text-anchor", "middle").attr("x", y.rect_min_width / 2).attr("dy", 0).text(E) : u.append("tspan").attr("text-anchor", "middle").attr("x", y.rect_min_width / 2).attr("dy", y.line_height * 0.75).text(E), d++;
    });
    var f = 1.5 * y.rect_padding, h = d * y.line_height * 0.75, o = f + h;
    return e.append("line").attr("class", "req-title-line").attr("x1", "0").attr("x2", y.rect_min_width).attr("y1", o).attr("y2", o), {
        titleNode: u,
        y: o
    };
}, $e = function(e, t, l, c) {
    var u = e.append("text").attr("class", "req reqLabel").attr("id", t).attr("x", y.rect_padding).attr("y", c).attr("dominant-baseline", "hanging"), d = 0;
    var f = 30;
    var h = [];
    return l.forEach(function(o) {
        var E = o.length;
        for(; E > f && d < 3;){
            var R = o.substring(0, f);
            o = o.substring(f, o.length), E = o.length, h[h.length] = R, d++;
        }
        if (d == 3) {
            var R1 = h[h.length - 1];
            h[h.length - 1] = R1.substring(0, R1.length - 4) + "...";
        } else h[h.length] = o;
        d = 0;
    }), h.forEach(function(o) {
        u.append("tspan").attr("x", y.rect_padding).attr("dy", y.line_height).text(o);
    }), u;
}, ft = function(e, t, l, c) {
    var u = t.node().getTotalLength(), d = t.node().getPointAtLength(u * 0.5), f = "rel" + Se;
    Se++;
    var o = e.append("text").attr("class", "req relationshipLabel").attr("id", f).attr("x", d.x).attr("y", d.y).attr("text-anchor", "middle").attr("dominant-baseline", "middle").text(c).node().getBBox();
    e.insert("rect", "#" + f).attr("class", "req reqLabelBox").attr("x", d.x - o.width / 2).attr("y", d.y - o.height / 2).attr("width", o.width).attr("height", o.height).attr("fill", "white").attr("fill-opacity", "85%");
}, pt = function pt(e, t, l, c, u) {
    var d = l.edge(H(t.src), H(t.dst)), f = P().x(function(o) {
        return o.x;
    }).y(function(o) {
        return o.y;
    }), h = e.insert("path", "#" + c).attr("class", "er relationshipLine").attr("d", f(d.points)).attr("fill", "none");
    t.type == u.db.Relationships.CONTAINS ? h.attr("marker-start", "url(" + $n.getUrl(y.arrowMarkerAbsolute) + "#" + t.type + "_line_ending)") : (h.attr("stroke-dasharray", "10,7"), h.attr("marker-end", "url(" + $n.getUrl(y.arrowMarkerAbsolute) + "#" + xe.ReqMarkers.ARROW + "_line_ending)")), ft(e, h, y, "<<".concat(t.type, ">>"));
}, yt = function(e, t, l) {
    Object.keys(e).forEach(function(c) {
        var u = e[c];
        c = H(c), L.info("Added new requirement: ", c);
        var d = l.append("g").attr("id", c), f = "req-" + c, h = Ae(d, f);
        var o = we(d, c + "_title", [
            "<<".concat(u.type, ">>"),
            "".concat(u.name)
        ]);
        $e(d, c + "_body", [
            "Id: ".concat(u.id),
            "Text: ".concat(u.text),
            "Risk: ".concat(u.risk),
            "Verification: ".concat(u.verifyMethod)
        ], o.y);
        var E = h.node().getBBox();
        t.setNode(c, {
            width: E.width,
            height: E.height,
            shape: "rect",
            id: c
        });
    });
}, _t = function(e, t, l) {
    Object.keys(e).forEach(function(c) {
        var u = e[c];
        var d = H(c), f = l.append("g").attr("id", d), h = "element-" + d, o = Ae(f, h);
        var E = we(f, h + "_title", [
            "<<Element>>",
            "".concat(c)
        ]);
        $e(f, h + "_body", [
            "Type: ".concat(u.type || "Not Specified"),
            "Doc Ref: ".concat(u.docRef || "None")
        ], E.y);
        var R = o.node().getBBox();
        t.setNode(d, {
            width: R.width,
            height: R.height,
            shape: "rect",
            id: d
        });
    });
}, Et = function(e, t) {
    return e.forEach(function(l) {
        var c = H(l.src), u = H(l.dst);
        t.setEdge(c, u, {
            relationship: l
        });
    }), e;
}, gt = function gt(e, t) {
    t.nodes().forEach(function(l) {
        l !== void 0 && t.node(l) !== void 0 && (e.select("#" + l), e.select("#" + l).attr("transform", "translate(" + (t.node(l).x - t.node(l).width / 2) + "," + (t.node(l).y - t.node(l).height / 2) + " )"));
    });
}, H = function(e) {
    return e.replace(/\s/g, "").replace(/\./g, "_");
}, Rt = function(e, t, l, c) {
    y = Vn().requirement;
    var u = y.securityLevel;
    var d;
    u === "sandbox" && (d = bt("#i" + t));
    var h = (u === "sandbox" ? bt(d.nodes()[0].contentDocument.body) : bt("body")).select("[id='".concat(t, "']"));
    xe.insertLineEndings(h, y);
    var o = new Ze$1({
        multigraph: false,
        compound: false,
        directed: true
    }).setGraph({
        rankdir: y.layoutDirection,
        marginx: 20,
        marginy: 20,
        nodesep: 100,
        edgesep: 100,
        ranksep: 100
    }).setDefaultEdgeLabel(function() {
        return {};
    });
    var E = c.db.getRequirements(), R = c.db.getElements(), A = c.db.getRelationships();
    yt(E, o, h), _t(R, o, h), Et(A, o), Yt(o), gt(h, o), A.forEach(function(x) {
        pt(h, x, o, t, c);
    });
    var T = y.rect_padding, N = h.node().getBBox(), w = N.width + T * 2, k = N.height + T * 2;
    Ol(h, k, w, y.useMaxWidth), h.attr("viewBox", "".concat(N.x - T, " ").concat(N.y - T, " ").concat(w, " ").concat(k));
}, mt = {
    draw: Rt
}, xt = {
    parser: He,
    db: ct,
    renderer: mt,
    styles: ut
};

export { xt as diagram };
