import { c as Te, s as Ce, g as Fe, b as Me, a as De, l as Ne, C as Pe, h as oe, i as Ye, j as ke } from './index-0e3b96e2.js';
import { G as Ue } from './graph-39d39682.js';
import { l as Be } from './layout-004a3162.js';
import { l as Qe } from './line-0981dc5a.js';
import './index-9c042f98.js';
import './_plugin-vue_export-helper-c27b6911.js';
import './array-9f3ba611.js';
import './path-53f90ab3.js';
var ce = (function () {
	var e = function (V, i, n, a) {
			for (n = n || {}, a = V.length; a--; n[V[a]] = i);
			return n;
		},
		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],
		p = [1, 18],
		h = [2, 7],
		o = [1, 22],
		g = [1, 23],
		R = [1, 24],
		A = [1, 25],
		T = [1, 26],
		N = [1, 27],
		v = [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],
		pe = [1, 47],
		fe = [1, 48],
		ye = [1, 49],
		_e = [1, 50],
		ge = [1, 51],
		Ee = [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 () {},
			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 (i, n, a, r, f, s, W) {
				var _ = s.length - 1;
				switch (f) {
					case 4:
						(this.$ = s[_].trim()), r.setAccTitle(this.$);
						break;
					case 5:
					case 6:
						(this.$ = s[_].trim()), r.setAccDescription(this.$);
						break;
					case 7:
						this.$ = [];
						break;
					case 13:
						r.addRequirement(s[_ - 3], s[_ - 4]);
						break;
					case 14:
						r.setNewReqId(s[_ - 2]);
						break;
					case 15:
						r.setNewReqText(s[_ - 2]);
						break;
					case 16:
						r.setNewReqRisk(s[_ - 2]);
						break;
					case 17:
						r.setNewReqVerifyMethod(s[_ - 2]);
						break;
					case 20:
						this.$ = r.RequirementType.REQUIREMENT;
						break;
					case 21:
						this.$ = r.RequirementType.FUNCTIONAL_REQUIREMENT;
						break;
					case 22:
						this.$ = r.RequirementType.INTERFACE_REQUIREMENT;
						break;
					case 23:
						this.$ = r.RequirementType.PERFORMANCE_REQUIREMENT;
						break;
					case 24:
						this.$ = r.RequirementType.PHYSICAL_REQUIREMENT;
						break;
					case 25:
						this.$ = r.RequirementType.DESIGN_CONSTRAINT;
						break;
					case 26:
						this.$ = r.RiskLevel.LOW_RISK;
						break;
					case 27:
						this.$ = r.RiskLevel.MED_RISK;
						break;
					case 28:
						this.$ = r.RiskLevel.HIGH_RISK;
						break;
					case 29:
						this.$ = r.VerifyType.VERIFY_ANALYSIS;
						break;
					case 30:
						this.$ = r.VerifyType.VERIFY_DEMONSTRATION;
						break;
					case 31:
						this.$ = r.VerifyType.VERIFY_INSPECTION;
						break;
					case 32:
						this.$ = r.VerifyType.VERIFY_TEST;
						break;
					case 33:
						r.addElement(s[_ - 3]);
						break;
					case 34:
						r.setNewElementType(s[_ - 2]);
						break;
					case 35:
						r.setNewElementDocRef(s[_ - 2]);
						break;
					case 38:
						r.addRelationship(s[_ - 2], s[_], s[_ - 4]);
						break;
					case 39:
						r.addRelationship(s[_ - 2], s[_ - 4], s[_]);
						break;
					case 40:
						this.$ = r.Relationships.CONTAINS;
						break;
					case 41:
						this.$ = r.Relationships.COPIES;
						break;
					case 42:
						this.$ = r.Relationships.DERIVES;
						break;
					case 43:
						this.$ = r.Relationships.SATISFIES;
						break;
					case 44:
						this.$ = r.Relationships.VERIFIES;
						break;
					case 45:
						this.$ = r.Relationships.REFINES;
						break;
					case 46:
						this.$ = r.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: p,
					7: 13,
					8: h,
					9: l,
					11: c,
					13: u,
					14: 14,
					15: 15,
					16: 16,
					17: 19,
					23: 21,
					31: o,
					32: g,
					33: R,
					34: A,
					35: T,
					36: N,
					44: v,
					62: k,
					63: x,
				},
				e(d, [2, 4]),
				e(d, [2, 5]),
				{ 1: [2, 1] },
				{ 8: [1, 30] },
				{
					4: 17,
					5: p,
					7: 31,
					8: h,
					9: l,
					11: c,
					13: u,
					14: 14,
					15: 15,
					16: 16,
					17: 19,
					23: 21,
					31: o,
					32: g,
					33: R,
					34: A,
					35: T,
					36: N,
					44: v,
					62: k,
					63: x,
				},
				{
					4: 17,
					5: p,
					7: 32,
					8: h,
					9: l,
					11: c,
					13: u,
					14: 14,
					15: 15,
					16: 16,
					17: 19,
					23: 21,
					31: o,
					32: g,
					33: R,
					34: A,
					35: T,
					36: N,
					44: v,
					62: k,
					63: x,
				},
				{
					4: 17,
					5: p,
					7: 33,
					8: h,
					9: l,
					11: c,
					13: u,
					14: 14,
					15: 15,
					16: 16,
					17: 19,
					23: 21,
					31: o,
					32: g,
					33: R,
					34: A,
					35: T,
					36: N,
					44: v,
					62: k,
					63: x,
				},
				{
					4: 17,
					5: p,
					7: 34,
					8: h,
					9: l,
					11: c,
					13: u,
					14: 14,
					15: 15,
					16: 16,
					17: 19,
					23: 21,
					31: o,
					32: g,
					33: R,
					34: A,
					35: T,
					36: N,
					44: v,
					62: k,
					63: x,
				},
				{
					4: 17,
					5: p,
					7: 35,
					8: h,
					9: l,
					11: c,
					13: u,
					14: 14,
					15: 15,
					16: 16,
					17: 19,
					23: 21,
					31: o,
					32: g,
					33: R,
					34: A,
					35: T,
					36: N,
					44: v,
					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: pe, 56: fe, 57: ye, 58: _e, 59: ge, 60: Ee, 61: Re },
				{ 52: 54, 55: pe, 56: fe, 57: ye, 58: _e, 59: ge, 60: Ee, 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 (i, n) {
				if (n.recoverable) this.trace(i);
				else {
					var a = new Error(i);
					throw ((a.hash = n), a);
				}
			},
			parse: function (i) {
				var n = this,
					a = [0],
					r = [],
					f = [null],
					s = [],
					W = this.table,
					_ = '',
					Z = 0,
					me = 0,
					Ve = 2,
					Ie = 1,
					qe = s.slice.call(arguments, 1),
					E = Object.create(this.lexer),
					L = { yy: {} };
				for (var ne in this.yy) Object.prototype.hasOwnProperty.call(this.yy, ne) && (L.yy[ne] = this.yy[ne]);
				E.setInput(i, L.yy), (L.yy.lexer = E), (L.yy.parser = this), typeof E.yylloc > 'u' && (E.yylloc = {});
				var se = E.yylloc;
				s.push(se);
				var Oe = E.options && E.options.ranges;
				typeof L.yy.parseError == 'function' ? (this.parseError = L.yy.parseError) : (this.parseError = Object.getPrototypeOf(this).parseError);
				function Le() {
					var $;
					return (
						($ = r.pop() || E.lex() || Ie), typeof $ != 'number' && ($ instanceof Array && ((r = $), ($ = r.pop())), ($ = n.symbols_[$] || $)), $
					);
				}
				for (var I, C, S, ae, Q = {}, ee, w, be, te; ; ) {
					if (
						((C = a[a.length - 1]),
						this.defaultActions[C] ? (S = this.defaultActions[C]) : ((I === null || typeof I > 'u') && (I = Le()), (S = W[C] && W[C][I])),
						typeof S > 'u' || !S.length || !S[0])
					) {
						var le = '';
						te = [];
						for (ee in W[C]) this.terminals_[ee] && ee > Ve && te.push("'" + this.terminals_[ee] + "'");
						E.showPosition
							? (le =
									'Parse error on line ' +
									(Z + 1) +
									`:
` +
									E.showPosition() +
									`
Expecting ` +
									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: E.match, token: this.terminals_[I] || I, line: E.yylineno, loc: se, expected: te });
					}
					if (S[0] instanceof 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),
								f.push(E.yytext),
								s.push(E.yylloc),
								a.push(S[1]),
								(I = null),
								(me = E.yyleng),
								(_ = E.yytext),
								(Z = E.yylineno),
								(se = E.yylloc);
							break;
						case 2:
							if (
								((w = this.productions_[S[1]][1]),
								(Q.$ = f[f.length - w]),
								(Q._$ = {
									first_line: s[s.length - (w || 1)].first_line,
									last_line: s[s.length - 1].last_line,
									first_column: s[s.length - (w || 1)].first_column,
									last_column: s[s.length - 1].last_column,
								}),
								Oe && (Q._$.range = [s[s.length - (w || 1)].range[0], s[s.length - 1].range[1]]),
								(ae = this.performAction.apply(Q, [_, me, Z, L.yy, S[1], f, s].concat(qe))),
								typeof ae < 'u')
							)
								return ae;
							w && ((a = a.slice(0, -1 * w * 2)), (f = f.slice(0, -1 * w)), (s = s.slice(0, -1 * w))),
								a.push(this.productions_[S[1]][0]),
								f.push(Q.$),
								s.push(Q._$),
								(be = W[a[a.length - 2]][a[a.length - 1]]),
								a.push(be);
							break;
						case 3:
							return !0;
					}
				}
				return !0;
			},
		},
		$e = (function () {
			var V = {
				EOF: 1,
				parseError: function (n, a) {
					if (this.yy.parser) this.yy.parser.parseError(n, a);
					else throw new Error(n);
				},
				setInput: function (i, n) {
					return (
						(this.yy = n || this.yy || {}),
						(this._input = i),
						(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
					);
				},
				input: function () {
					var i = this._input[0];
					(this.yytext += i), this.yyleng++, this.offset++, (this.match += i), (this.matched += i);
					var n = i.match(/(?:\r\n?|\n).*/g);
					return (
						n ? (this.yylineno++, this.yylloc.last_line++) : this.yylloc.last_column++,
						this.options.ranges && this.yylloc.range[1]++,
						(this._input = this._input.slice(1)),
						i
					);
				},
				unput: function (i) {
					var n = i.length,
						a = i.split(/(?:\r\n?|\n)/g);
					(this._input = i + this._input), (this.yytext = this.yytext.substr(0, this.yytext.length - n)), (this.offset -= n);
					var r = 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 f = 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 === r.length ? this.yylloc.first_column : 0) + r[r.length - a.length].length - a[0].length
								: this.yylloc.first_column - n,
						}),
						this.options.ranges && (this.yylloc.range = [f[0], f[0] + this.yyleng - n]),
						(this.yyleng = this.yytext.length),
						this
					);
				},
				more: function () {
					return (this._more = !0), this;
				},
				reject: function () {
					if (this.options.backtrack_lexer) this._backtrack = !0;
					else
						return this.parseError(
							'Lexical error on line ' +
								(this.yylineno + 1) +
								`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
` +
								this.showPosition(),
							{ text: '', token: null, line: this.yylineno }
						);
					return this;
				},
				less: function (i) {
					this.unput(this.match.slice(i));
				},
				pastInput: function () {
					var i = this.matched.substr(0, this.matched.length - this.match.length);
					return (i.length > 20 ? '...' : '') + i.substr(-20).replace(/\n/g, '');
				},
				upcomingInput: function () {
					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, '');
				},
				showPosition: function () {
					var i = this.pastInput(),
						n = new Array(i.length + 1).join('-');
					return (
						i +
						this.upcomingInput() +
						`
` +
						n +
						'^'
					);
				},
				test_match: function (i, n) {
					var a, r, f;
					if (
						(this.options.backtrack_lexer &&
							((f = {
								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 && (f.yylloc.range = this.yylloc.range.slice(0))),
						(r = i[0].match(/(?:\r\n?|\n).*/g)),
						r && (this.yylineno += r.length),
						(this.yylloc = {
							first_line: this.yylloc.last_line,
							last_line: this.yylineno + 1,
							first_column: this.yylloc.last_column,
							last_column: r ? r[r.length - 1].length - r[r.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 = !1),
						(this._backtrack = !1),
						(this._input = this._input.slice(i[0].length)),
						(this.matched += i[0]),
						(a = this.performAction.call(this, this.yy, this, n, this.conditionStack[this.conditionStack.length - 1])),
						this.done && this._input && (this.done = !1),
						a)
					)
						return a;
					if (this._backtrack) {
						for (var s in f) this[s] = f[s];
						return !1;
					}
					return !1;
				},
				next: function () {
					if (this.done) return this.EOF;
					this._input || (this.done = !0);
					var i, n, a, r;
					this._more || ((this.yytext = ''), (this.match = ''));
					for (var f = this._currentRules(), s = 0; s < f.length; s++)
						if (((a = this._input.match(this.rules[f[s]])), a && (!n || a[0].length > n[0].length))) {
							if (((n = a), (r = s), this.options.backtrack_lexer)) {
								if (((i = this.test_match(a, f[s])), i !== !1)) return i;
								if (this._backtrack) {
									n = !1;
									continue;
								} else return !1;
							} else if (!this.options.flex) break;
						}
					return n
						? ((i = this.test_match(n, f[r])), i !== !1 ? i : !1)
						: this._input === ''
						? this.EOF
						: this.parseError(
								'Lexical error on line ' +
									(this.yylineno + 1) +
									`. Unrecognized text.
` +
									this.showPosition(),
								{ text: '', token: null, line: this.yylineno }
						  );
				},
				lex: function () {
					var n = this.next();
					return n || this.lex();
				},
				begin: function (n) {
					this.conditionStack.push(n);
				},
				popState: function () {
					var n = this.conditionStack.length - 1;
					return n > 0 ? this.conditionStack.pop() : this.conditionStack[0];
				},
				_currentRules: function () {
					return this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]
						? this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules
						: this.conditions.INITIAL.rules;
				},
				topState: function (n) {
					return (n = this.conditionStack.length - 1 - Math.abs(n || 0)), n >= 0 ? this.conditionStack[n] : 'INITIAL';
				},
				pushState: function (n) {
					this.begin(n);
				},
				stateStackSize: function () {
					return this.conditionStack.length;
				},
				options: { 'case-insensitive': !0 },
				performAction: function (n, a, r, f) {
					switch (r) {
						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: !1 },
					acc_descr: { rules: [4], inclusive: !1 },
					acc_title: { rules: [2], inclusive: !1 },
					unqString: { rules: [], inclusive: !1 },
					token: { rules: [], inclusive: !1 },
					string: { rules: [48, 49], inclusive: !1 },
					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: !0,
					},
				},
			};
			return V;
		})();
	ie.lexer = $e;
	function re() {
		this.yy = {};
	}
	return (re.prototype = ie), (ie.Parser = re), new re();
})();
ce.parser = ce;
const He = ce;
let ue = [],
	b = {},
	K = {},
	q = {},
	G = {};
const 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 = (e, t) => (
		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 = () => K,
	Je = (e) => {
		b !== void 0 && (b.id = e);
	},
	Ze = (e) => {
		b !== void 0 && (b.text = e);
	},
	et = (e) => {
		b !== void 0 && (b.risk = e);
	},
	tt = (e) => {
		b !== void 0 && (b.verifyMethod = e);
	},
	it = (e) => (G[e] === void 0 && ((G[e] = { name: e, type: q.type, docRef: q.docRef }), Ne.info('Added new requirement: ', e)), (q = {}), G[e]),
	rt = () => G,
	nt = (e) => {
		q !== void 0 && (q.type = e);
	},
	st = (e) => {
		q !== void 0 && (q.docRef = e);
	},
	at = (e, t, l) => {
		ue.push({ type: e, src: t, dst: l });
	},
	lt = () => ue,
	ot = () => {
		(ue = []), (b = {}), (K = {}), (q = {}), (G = {}), Pe();
	},
	ct = {
		RequirementType: We,
		RiskLevel: Ke,
		VerifyType: Ge,
		Relationships: je,
		getConfig: () => Te().req,
		addRequirement: ze,
		getRequirements: Xe,
		setNewReqId: Je,
		setNewReqText: Ze,
		setNewReqRisk: et,
		setNewReqVerifyMethod: tt,
		setAccTitle: Ce,
		getAccTitle: Fe,
		setAccDescription: Me,
		getAccDescription: De,
		addElement: it,
		getElements: rt,
		setNewElementType: nt,
		setNewElementDocRef: st,
		addRelationship: at,
		getRelationships: lt,
		clear: ot,
	},
	ht = (e) => `

  marker {
    fill: ${e.relationColor};
    stroke: ${e.relationColor};
  }

  marker.cross {
    stroke: ${e.lineColor};
  }

  svg {
    font-family: ${e.fontFamily};
    font-size: ${e.fontSize};
  }

  .reqBox {
    fill: ${e.requirementBackground};
    fill-opacity: 1.0;
    stroke: ${e.requirementBorderColor};
    stroke-width: ${e.requirementBorderSize};
  }
  
  .reqTitle, .reqLabel{
    fill:  ${e.requirementTextColor};
  }
  .reqLabelBox {
    fill: ${e.relationLabelBackground};
    fill-opacity: 1.0;
  }

  .req-title-line {
    stroke: ${e.requirementBorderColor};
    stroke-width: ${e.requirementBorderSize};
  }
  .relationshipLine {
    stroke: ${e.relationColor};
    stroke-width: 1;
  }
  .relationshipLabel {
    fill: ${e.relationLabelColor};
  }

`,
	ut = ht,
	he = { CONTAINS: 'contains', ARROW: 'arrow' },
	dt = (e, t) => {
		let 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
      L${t.line_height},${t.line_height / 2}
      M${t.line_height},${t.line_height / 2}
      L0,${t.line_height}`
				)
				.attr('stroke-width', 1);
	},
	xe = { ReqMarkers: he, insertLineEndings: dt };
let y = {},
	Se = 0;
const Ae = (e, t) =>
		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'),
	ve = (e, t, l) => {
		let 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((g) => {
			d == 0
				? u
						.append('tspan')
						.attr('text-anchor', 'middle')
						.attr('x', y.rect_min_width / 2)
						.attr('dy', 0)
						.text(g)
				: u
						.append('tspan')
						.attr('text-anchor', 'middle')
						.attr('x', y.rect_min_width / 2)
						.attr('dy', y.line_height * 0.75)
						.text(g),
				d++;
		});
		let p = 1.5 * y.rect_padding,
			h = d * y.line_height * 0.75,
			o = p + 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 }
		);
	},
	we = (e, t, l, c) => {
		let 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;
		const p = 30;
		let h = [];
		return (
			l.forEach((o) => {
				let g = o.length;
				for (; g > p && d < 3; ) {
					let R = o.substring(0, p);
					(o = o.substring(p, o.length)), (g = o.length), (h[h.length] = R), d++;
				}
				if (d == 3) {
					let R = h[h.length - 1];
					h[h.length - 1] = R.substring(0, R.length - 4) + '...';
				} else h[h.length] = o;
				d = 0;
			}),
			h.forEach((o) => {
				u.append('tspan').attr('x', y.rect_padding).attr('dy', y.line_height).text(o);
			}),
			u
		);
	},
	pt = (e, t, l, c) => {
		const u = t.node().getTotalLength(),
			d = t.node().getPointAtLength(u * 0.5),
			p = 'rel' + Se;
		Se++;
		const o = e
			.append('text')
			.attr('class', 'req relationshipLabel')
			.attr('id', p)
			.attr('x', d.x)
			.attr('y', d.y)
			.attr('text-anchor', 'middle')
			.attr('dominant-baseline', 'middle')
			.text(c)
			.node()
			.getBBox();
		e.insert('rect', '#' + p)
			.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%');
	},
	ft = function (e, t, l, c, u) {
		const d = l.edge(H(t.src), H(t.dst)),
			p = Qe()
				.x(function (o) {
					return o.x;
				})
				.y(function (o) {
					return o.y;
				}),
			h = e
				.insert('path', '#' + c)
				.attr('class', 'er relationshipLine')
				.attr('d', p(d.points))
				.attr('fill', 'none');
		t.type == u.db.Relationships.CONTAINS
			? h.attr('marker-start', 'url(' + ke.getUrl(y.arrowMarkerAbsolute) + '#' + t.type + '_line_ending)')
			: (h.attr('stroke-dasharray', '10,7'),
			  h.attr('marker-end', 'url(' + ke.getUrl(y.arrowMarkerAbsolute) + '#' + xe.ReqMarkers.ARROW + '_line_ending)')),
			pt(e, h, y, `<<${t.type}>>`);
	},
	yt = (e, t, l) => {
		Object.keys(e).forEach((c) => {
			let u = e[c];
			(c = H(c)), Ne.info('Added new requirement: ', c);
			const d = l.append('g').attr('id', c),
				p = 'req-' + c,
				h = Ae(d, p);
			let o = ve(d, c + '_title', [`<<${u.type}>>`, `${u.name}`]);
			we(d, c + '_body', [`Id: ${u.id}`, `Text: ${u.text}`, `Risk: ${u.risk}`, `Verification: ${u.verifyMethod}`], o.y);
			const g = h.node().getBBox();
			t.setNode(c, { width: g.width, height: g.height, shape: 'rect', id: c });
		});
	},
	_t = (e, t, l) => {
		Object.keys(e).forEach((c) => {
			let u = e[c];
			const d = H(c),
				p = l.append('g').attr('id', d),
				h = 'element-' + d,
				o = Ae(p, h);
			let g = ve(p, h + '_title', ['<<Element>>', `${c}`]);
			we(p, h + '_body', [`Type: ${u.type || 'Not Specified'}`, `Doc Ref: ${u.docRef || 'None'}`], g.y);
			const R = o.node().getBBox();
			t.setNode(d, { width: R.width, height: R.height, shape: 'rect', id: d });
		});
	},
	gt = (e, t) => (
		e.forEach(function (l) {
			let c = H(l.src),
				u = H(l.dst);
			t.setEdge(c, u, { relationship: l });
		}),
		e
	),
	Et = function (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 = (e) => e.replace(/\s/g, '').replace(/\./g, '_'),
	Rt = (e, t, l, c) => {
		y = Te().requirement;
		const u = y.securityLevel;
		let d;
		u === 'sandbox' && (d = oe('#i' + t));
		const h = (u === 'sandbox' ? oe(d.nodes()[0].contentDocument.body) : oe('body')).select(`[id='${t}']`);
		xe.insertLineEndings(h, y);
		const o = new Ue({ multigraph: !1, compound: !1, directed: !0 })
			.setGraph({ rankdir: y.layoutDirection, marginx: 20, marginy: 20, nodesep: 100, edgesep: 100, ranksep: 100 })
			.setDefaultEdgeLabel(function () {
				return {};
			});
		let g = c.db.getRequirements(),
			R = c.db.getElements(),
			A = c.db.getRelationships();
		yt(g, o, h),
			_t(R, o, h),
			gt(A, o),
			Be(o),
			Et(h, o),
			A.forEach(function (x) {
				ft(h, x, o, t, c);
			});
		const T = y.rect_padding,
			N = h.node().getBBox(),
			v = N.width + T * 2,
			k = N.height + T * 2;
		Ye(h, k, v, y.useMaxWidth), h.attr('viewBox', `${N.x - T} ${N.y - T} ${v} ${k}`);
	},
	mt = { draw: Rt },
	vt = { parser: He, db: ct, renderer: mt, styles: ut };
export { vt as diagram };