import { c as A, A as yt, B as ft, s as dt, g as pt, b as gt, a as mt, C as xt, h as W, i as kt } from './index-0e3b96e2.js';
import { d as _t, f as bt, a as vt, g as it } from './svgDrawCommon-5e1cfd1d-c2c81d4c.js';
import { a as Q } from './arc-5ac49f55.js';
import './index-9c042f98.js';
import './_plugin-vue_export-helper-c27b6911.js';
import './path-53f90ab3.js';
var G = (function () {
	var t = function (p, s, r, a) {
			for (r = r || {}, a = p.length; a--; r[p[a]] = s);
			return r;
		},
		e = [6, 8, 10, 11, 12, 14, 16, 17, 18],
		i = [1, 9],
		l = [1, 10],
		n = [1, 11],
		h = [1, 12],
		c = [1, 13],
		f = [1, 14],
		y = {
			trace: function () {},
			yy: {},
			symbols_: {
				error: 2,
				start: 3,
				journey: 4,
				document: 5,
				EOF: 6,
				line: 7,
				SPACE: 8,
				statement: 9,
				NEWLINE: 10,
				title: 11,
				acc_title: 12,
				acc_title_value: 13,
				acc_descr: 14,
				acc_descr_value: 15,
				acc_descr_multiline_value: 16,
				section: 17,
				taskName: 18,
				taskData: 19,
				$accept: 0,
				$end: 1,
			},
			terminals_: {
				2: 'error',
				4: 'journey',
				6: 'EOF',
				8: 'SPACE',
				10: 'NEWLINE',
				11: 'title',
				12: 'acc_title',
				13: 'acc_title_value',
				14: 'acc_descr',
				15: 'acc_descr_value',
				16: 'acc_descr_multiline_value',
				17: 'section',
				18: 'taskName',
				19: 'taskData',
			},
			productions_: [0, [3, 3], [5, 0], [5, 2], [7, 2], [7, 1], [7, 1], [7, 1], [9, 1], [9, 2], [9, 2], [9, 1], [9, 1], [9, 2]],
			performAction: function (s, r, a, u, d, o, w) {
				var k = o.length - 1;
				switch (d) {
					case 1:
						return o[k - 1];
					case 2:
						this.$ = [];
						break;
					case 3:
						o[k - 1].push(o[k]), (this.$ = o[k - 1]);
						break;
					case 4:
					case 5:
						this.$ = o[k];
						break;
					case 6:
					case 7:
						this.$ = [];
						break;
					case 8:
						u.setDiagramTitle(o[k].substr(6)), (this.$ = o[k].substr(6));
						break;
					case 9:
						(this.$ = o[k].trim()), u.setAccTitle(this.$);
						break;
					case 10:
					case 11:
						(this.$ = o[k].trim()), u.setAccDescription(this.$);
						break;
					case 12:
						u.addSection(o[k].substr(8)), (this.$ = o[k].substr(8));
						break;
					case 13:
						u.addTask(o[k - 1], o[k]), (this.$ = 'task');
						break;
				}
			},
			table: [
				{ 3: 1, 4: [1, 2] },
				{ 1: [3] },
				t(e, [2, 2], { 5: 3 }),
				{ 6: [1, 4], 7: 5, 8: [1, 6], 9: 7, 10: [1, 8], 11: i, 12: l, 14: n, 16: h, 17: c, 18: f },
				t(e, [2, 7], { 1: [2, 1] }),
				t(e, [2, 3]),
				{ 9: 15, 11: i, 12: l, 14: n, 16: h, 17: c, 18: f },
				t(e, [2, 5]),
				t(e, [2, 6]),
				t(e, [2, 8]),
				{ 13: [1, 16] },
				{ 15: [1, 17] },
				t(e, [2, 11]),
				t(e, [2, 12]),
				{ 19: [1, 18] },
				t(e, [2, 4]),
				t(e, [2, 9]),
				t(e, [2, 10]),
				t(e, [2, 13]),
			],
			defaultActions: {},
			parseError: function (s, r) {
				if (r.recoverable) this.trace(s);
				else {
					var a = new Error(s);
					throw ((a.hash = r), a);
				}
			},
			parse: function (s) {
				var r = this,
					a = [0],
					u = [],
					d = [null],
					o = [],
					w = this.table,
					k = '',
					R = 0,
					Z = 0,
					lt = 2,
					J = 1,
					ct = o.slice.call(arguments, 1),
					x = Object.create(this.lexer),
					S = { yy: {} };
				for (var z in this.yy) Object.prototype.hasOwnProperty.call(this.yy, z) && (S.yy[z] = this.yy[z]);
				x.setInput(s, S.yy), (S.yy.lexer = x), (S.yy.parser = this), typeof x.yylloc > 'u' && (x.yylloc = {});
				var Y = x.yylloc;
				o.push(Y);
				var ht = x.options && x.options.ranges;
				typeof S.yy.parseError == 'function' ? (this.parseError = S.yy.parseError) : (this.parseError = Object.getPrototypeOf(this).parseError);
				function ut() {
					var T;
					return (T = u.pop() || x.lex() || J), typeof T != 'number' && (T instanceof Array && ((u = T), (T = u.pop())), (T = r.symbols_[T] || T)), T;
				}
				for (var _, E, b, O, C = {}, N, $, K, B; ; ) {
					if (
						((E = a[a.length - 1]),
						this.defaultActions[E] ? (b = this.defaultActions[E]) : ((_ === null || typeof _ > 'u') && (_ = ut()), (b = w[E] && w[E][_])),
						typeof b > 'u' || !b.length || !b[0])
					) {
						var q = '';
						B = [];
						for (N in w[E]) this.terminals_[N] && N > lt && B.push("'" + this.terminals_[N] + "'");
						x.showPosition
							? (q =
									'Parse error on line ' +
									(R + 1) +
									`:
` +
									x.showPosition() +
									`
Expecting ` +
									B.join(', ') +
									", got '" +
									(this.terminals_[_] || _) +
									"'")
							: (q = 'Parse error on line ' + (R + 1) + ': Unexpected ' + (_ == J ? 'end of input' : "'" + (this.terminals_[_] || _) + "'")),
							this.parseError(q, { text: x.match, token: this.terminals_[_] || _, line: x.yylineno, loc: Y, expected: B });
					}
					if (b[0] instanceof Array && b.length > 1) throw new Error('Parse Error: multiple actions possible at state: ' + E + ', token: ' + _);
					switch (b[0]) {
						case 1:
							a.push(_),
								d.push(x.yytext),
								o.push(x.yylloc),
								a.push(b[1]),
								(_ = null),
								(Z = x.yyleng),
								(k = x.yytext),
								(R = x.yylineno),
								(Y = x.yylloc);
							break;
						case 2:
							if (
								(($ = this.productions_[b[1]][1]),
								(C.$ = d[d.length - $]),
								(C._$ = {
									first_line: o[o.length - ($ || 1)].first_line,
									last_line: o[o.length - 1].last_line,
									first_column: o[o.length - ($ || 1)].first_column,
									last_column: o[o.length - 1].last_column,
								}),
								ht && (C._$.range = [o[o.length - ($ || 1)].range[0], o[o.length - 1].range[1]]),
								(O = this.performAction.apply(C, [k, Z, R, S.yy, b[1], d, o].concat(ct))),
								typeof O < 'u')
							)
								return O;
							$ && ((a = a.slice(0, -1 * $ * 2)), (d = d.slice(0, -1 * $)), (o = o.slice(0, -1 * $))),
								a.push(this.productions_[b[1]][0]),
								d.push(C.$),
								o.push(C._$),
								(K = w[a[a.length - 2]][a[a.length - 1]]),
								a.push(K);
							break;
						case 3:
							return !0;
					}
				}
				return !0;
			},
		},
		m = (function () {
			var p = {
				EOF: 1,
				parseError: function (r, a) {
					if (this.yy.parser) this.yy.parser.parseError(r, a);
					else throw new Error(r);
				},
				setInput: function (s, r) {
					return (
						(this.yy = r || this.yy || {}),
						(this._input = s),
						(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 s = this._input[0];
					(this.yytext += s), this.yyleng++, this.offset++, (this.match += s), (this.matched += s);
					var r = s.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)),
						s
					);
				},
				unput: function (s) {
					var r = s.length,
						a = s.split(/(?:\r\n?|\n)/g);
					(this._input = s + this._input), (this.yytext = this.yytext.substr(0, this.yytext.length - r)), (this.offset -= r);
					var u = 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 d = this.yylloc.range;
					return (
						(this.yylloc = {
							first_line: this.yylloc.first_line,
							last_line: this.yylineno + 1,
							first_column: this.yylloc.first_column,
							last_column: a
								? (a.length === u.length ? this.yylloc.first_column : 0) + u[u.length - a.length].length - a[0].length
								: this.yylloc.first_column - r,
						}),
						this.options.ranges && (this.yylloc.range = [d[0], d[0] + this.yyleng - r]),
						(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 (s) {
					this.unput(this.match.slice(s));
				},
				pastInput: function () {
					var s = this.matched.substr(0, this.matched.length - this.match.length);
					return (s.length > 20 ? '...' : '') + s.substr(-20).replace(/\n/g, '');
				},
				upcomingInput: function () {
					var s = this.match;
					return s.length < 20 && (s += this._input.substr(0, 20 - s.length)), (s.substr(0, 20) + (s.length > 20 ? '...' : '')).replace(/\n/g, '');
				},
				showPosition: function () {
					var s = this.pastInput(),
						r = new Array(s.length + 1).join('-');
					return (
						s +
						this.upcomingInput() +
						`
` +
						r +
						'^'
					);
				},
				test_match: function (s, r) {
					var a, u, d;
					if (
						(this.options.backtrack_lexer &&
							((d = {
								yylineno: this.yylineno,
								yylloc: {
									first_line: this.yylloc.first_line,
									last_line: this.last_line,
									first_column: this.yylloc.first_column,
									last_column: this.yylloc.last_column,
								},
								yytext: this.yytext,
								match: this.match,
								matches: this.matches,
								matched: this.matched,
								yyleng: this.yyleng,
								offset: this.offset,
								_more: this._more,
								_input: this._input,
								yy: this.yy,
								conditionStack: this.conditionStack.slice(0),
								done: this.done,
							}),
							this.options.ranges && (d.yylloc.range = this.yylloc.range.slice(0))),
						(u = s[0].match(/(?:\r\n?|\n).*/g)),
						u && (this.yylineno += u.length),
						(this.yylloc = {
							first_line: this.yylloc.last_line,
							last_line: this.yylineno + 1,
							first_column: this.yylloc.last_column,
							last_column: u ? u[u.length - 1].length - u[u.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + s[0].length,
						}),
						(this.yytext += s[0]),
						(this.match += s[0]),
						(this.matches = s),
						(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(s[0].length)),
						(this.matched += s[0]),
						(a = this.performAction.call(this, this.yy, this, r, this.conditionStack[this.conditionStack.length - 1])),
						this.done && this._input && (this.done = !1),
						a)
					)
						return a;
					if (this._backtrack) {
						for (var o in d) this[o] = d[o];
						return !1;
					}
					return !1;
				},
				next: function () {
					if (this.done) return this.EOF;
					this._input || (this.done = !0);
					var s, r, a, u;
					this._more || ((this.yytext = ''), (this.match = ''));
					for (var d = this._currentRules(), o = 0; o < d.length; o++)
						if (((a = this._input.match(this.rules[d[o]])), a && (!r || a[0].length > r[0].length))) {
							if (((r = a), (u = o), this.options.backtrack_lexer)) {
								if (((s = this.test_match(a, d[o])), s !== !1)) return s;
								if (this._backtrack) {
									r = !1;
									continue;
								} else return !1;
							} else if (!this.options.flex) break;
						}
					return r
						? ((s = this.test_match(r, d[u])), s !== !1 ? s : !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 r = this.next();
					return r || this.lex();
				},
				begin: function (r) {
					this.conditionStack.push(r);
				},
				popState: function () {
					var r = this.conditionStack.length - 1;
					return r > 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 (r) {
					return (r = this.conditionStack.length - 1 - Math.abs(r || 0)), r >= 0 ? this.conditionStack[r] : 'INITIAL';
				},
				pushState: function (r) {
					this.begin(r);
				},
				stateStackSize: function () {
					return this.conditionStack.length;
				},
				options: { 'case-insensitive': !0 },
				performAction: function (r, a, u, d) {
					switch (u) {
						case 0:
							break;
						case 1:
							break;
						case 2:
							return 10;
						case 3:
							break;
						case 4:
							break;
						case 5:
							return 4;
						case 6:
							return 11;
						case 7:
							return this.begin('acc_title'), 12;
						case 8:
							return this.popState(), 'acc_title_value';
						case 9:
							return this.begin('acc_descr'), 14;
						case 10:
							return this.popState(), 'acc_descr_value';
						case 11:
							this.begin('acc_descr_multiline');
							break;
						case 12:
							this.popState();
							break;
						case 13:
							return 'acc_descr_multiline_value';
						case 14:
							return 17;
						case 15:
							return 18;
						case 16:
							return 19;
						case 17:
							return ':';
						case 18:
							return 6;
						case 19:
							return 'INVALID';
					}
				},
				rules: [
					/^(?:%(?!\{)[^\n]*)/i,
					/^(?:[^\}]%%[^\n]*)/i,
					/^(?:[\n]+)/i,
					/^(?:\s+)/i,
					/^(?:#[^\n]*)/i,
					/^(?:journey\b)/i,
					/^(?:title\s[^#\n;]+)/i,
					/^(?:accTitle\s*:\s*)/i,
					/^(?:(?!\n||)*[^\n]*)/i,
					/^(?:accDescr\s*:\s*)/i,
					/^(?:(?!\n||)*[^\n]*)/i,
					/^(?:accDescr\s*\{\s*)/i,
					/^(?:[\}])/i,
					/^(?:[^\}]*)/i,
					/^(?:section\s[^#:\n;]+)/i,
					/^(?:[^#:\n;]+)/i,
					/^(?::[^#\n;]+)/i,
					/^(?::)/i,
					/^(?:$)/i,
					/^(?:.)/i,
				],
				conditions: {
					acc_descr_multiline: { rules: [12, 13], inclusive: !1 },
					acc_descr: { rules: [10], inclusive: !1 },
					acc_title: { rules: [8], inclusive: !1 },
					INITIAL: { rules: [0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 14, 15, 16, 17, 18, 19], inclusive: !0 },
				},
			};
			return p;
		})();
	y.lexer = m;
	function g() {
		this.yy = {};
	}
	return (g.prototype = y), (y.Parser = g), new g();
})();
G.parser = G;
const wt = G;
let I = '';
const H = [],
	V = [],
	F = [],
	$t = function () {
		(H.length = 0), (V.length = 0), (I = ''), (F.length = 0), xt();
	},
	Tt = function (t) {
		(I = t), H.push(t);
	},
	Mt = function () {
		return H;
	},
	St = function () {
		let t = D();
		const e = 100;
		let i = 0;
		for (; !t && i < e; ) (t = D()), i++;
		return V.push(...F), V;
	},
	Et = function () {
		const t = [];
		return (
			V.forEach((i) => {
				i.people && t.push(...i.people);
			}),
			[...new Set(t)].sort()
		);
	},
	Pt = function (t, e) {
		const i = e.substr(1).split(':');
		let l = 0,
			n = [];
		i.length === 1 ? ((l = Number(i[0])), (n = [])) : ((l = Number(i[0])), (n = i[1].split(',')));
		const h = n.map((f) => f.trim()),
			c = { section: I, type: I, people: h, task: t, score: l };
		F.push(c);
	},
	At = function (t) {
		const e = { section: I, type: I, description: t, task: t, classes: [] };
		V.push(e);
	},
	D = function () {
		const t = function (i) {
			return F[i].processed;
		};
		let e = !0;
		for (const [i, l] of F.entries()) t(i), (e = e && l.processed);
		return e;
	},
	Ct = function () {
		return Et();
	},
	tt = {
		getConfig: () => A().journey,
		clear: $t,
		setDiagramTitle: yt,
		getDiagramTitle: ft,
		setAccTitle: dt,
		getAccTitle: pt,
		setAccDescription: gt,
		getAccDescription: mt,
		addSection: Tt,
		getSections: Mt,
		getTasks: St,
		addTask: Pt,
		addTaskOrg: At,
		getActors: Ct,
	},
	It = (t) => `.label {
    font-family: 'trebuchet ms', verdana, arial, sans-serif;
    font-family: var(--mermaid-font-family);
    color: ${t.textColor};
  }
  .mouth {
    stroke: #666;
  }

  line {
    stroke: ${t.textColor}
  }

  .legend {
    fill: ${t.textColor};
  }

  .label text {
    fill: #333;
  }
  .label {
    color: ${t.textColor}
  }

  .face {
    ${t.faceColor ? `fill: ${t.faceColor}` : 'fill: #FFF8DC'};
    stroke: #999;
  }

  .node rect,
  .node circle,
  .node ellipse,
  .node polygon,
  .node path {
    fill: ${t.mainBkg};
    stroke: ${t.nodeBorder};
    stroke-width: 1px;
  }

  .node .label {
    text-align: center;
  }
  .node.clickable {
    cursor: pointer;
  }

  .arrowheadPath {
    fill: ${t.arrowheadColor};
  }

  .edgePath .path {
    stroke: ${t.lineColor};
    stroke-width: 1.5px;
  }

  .flowchart-link {
    stroke: ${t.lineColor};
    fill: none;
  }

  .edgeLabel {
    background-color: ${t.edgeLabelBackground};
    rect {
      opacity: 0.5;
    }
    text-align: center;
  }

  .cluster rect {
  }

  .cluster text {
    fill: ${t.titleColor};
  }

  div.mermaidTooltip {
    position: absolute;
    text-align: center;
    max-width: 200px;
    padding: 2px;
    font-family: 'trebuchet ms', verdana, arial, sans-serif;
    font-family: var(--mermaid-font-family);
    font-size: 12px;
    background: ${t.tertiaryColor};
    border: 1px solid ${t.border2};
    border-radius: 2px;
    pointer-events: none;
    z-index: 100;
  }

  .task-type-0, .section-type-0  {
    ${t.fillType0 ? `fill: ${t.fillType0}` : ''};
  }
  .task-type-1, .section-type-1  {
    ${t.fillType0 ? `fill: ${t.fillType1}` : ''};
  }
  .task-type-2, .section-type-2  {
    ${t.fillType0 ? `fill: ${t.fillType2}` : ''};
  }
  .task-type-3, .section-type-3  {
    ${t.fillType0 ? `fill: ${t.fillType3}` : ''};
  }
  .task-type-4, .section-type-4  {
    ${t.fillType0 ? `fill: ${t.fillType4}` : ''};
  }
  .task-type-5, .section-type-5  {
    ${t.fillType0 ? `fill: ${t.fillType5}` : ''};
  }
  .task-type-6, .section-type-6  {
    ${t.fillType0 ? `fill: ${t.fillType6}` : ''};
  }
  .task-type-7, .section-type-7  {
    ${t.fillType0 ? `fill: ${t.fillType7}` : ''};
  }

  .actor-0 {
    ${t.actor0 ? `fill: ${t.actor0}` : ''};
  }
  .actor-1 {
    ${t.actor1 ? `fill: ${t.actor1}` : ''};
  }
  .actor-2 {
    ${t.actor2 ? `fill: ${t.actor2}` : ''};
  }
  .actor-3 {
    ${t.actor3 ? `fill: ${t.actor3}` : ''};
  }
  .actor-4 {
    ${t.actor4 ? `fill: ${t.actor4}` : ''};
  }
  .actor-5 {
    ${t.actor5 ? `fill: ${t.actor5}` : ''};
  }
`,
	Vt = It,
	U = function (t, e) {
		return _t(t, e);
	},
	Ft = function (t, e) {
		const l = t
				.append('circle')
				.attr('cx', e.cx)
				.attr('cy', e.cy)
				.attr('class', 'face')
				.attr('r', 15)
				.attr('stroke-width', 2)
				.attr('overflow', 'visible'),
			n = t.append('g');
		n
			.append('circle')
			.attr('cx', e.cx - 15 / 3)
			.attr('cy', e.cy - 15 / 3)
			.attr('r', 1.5)
			.attr('stroke-width', 2)
			.attr('fill', '#666')
			.attr('stroke', '#666'),
			n
				.append('circle')
				.attr('cx', e.cx + 15 / 3)
				.attr('cy', e.cy - 15 / 3)
				.attr('r', 1.5)
				.attr('stroke-width', 2)
				.attr('fill', '#666')
				.attr('stroke', '#666');
		function h(y) {
			const m = Q()
				.startAngle(Math.PI / 2)
				.endAngle(3 * (Math.PI / 2))
				.innerRadius(7.5)
				.outerRadius(6.8181818181818175);
			y.append('path')
				.attr('class', 'mouth')
				.attr('d', m)
				.attr('transform', 'translate(' + e.cx + ',' + (e.cy + 2) + ')');
		}
		function c(y) {
			const m = Q()
				.startAngle((3 * Math.PI) / 2)
				.endAngle(5 * (Math.PI / 2))
				.innerRadius(7.5)
				.outerRadius(6.8181818181818175);
			y.append('path')
				.attr('class', 'mouth')
				.attr('d', m)
				.attr('transform', 'translate(' + e.cx + ',' + (e.cy + 7) + ')');
		}
		function f(y) {
			y.append('line')
				.attr('class', 'mouth')
				.attr('stroke', 2)
				.attr('x1', e.cx - 5)
				.attr('y1', e.cy + 7)
				.attr('x2', e.cx + 5)
				.attr('y2', e.cy + 7)
				.attr('class', 'mouth')
				.attr('stroke-width', '1px')
				.attr('stroke', '#666');
		}
		return e.score > 3 ? h(n) : e.score < 3 ? c(n) : f(n), l;
	},
	rt = function (t, e) {
		const i = t.append('circle');
		return (
			i.attr('cx', e.cx),
			i.attr('cy', e.cy),
			i.attr('class', 'actor-' + e.pos),
			i.attr('fill', e.fill),
			i.attr('stroke', e.stroke),
			i.attr('r', e.r),
			i.class !== void 0 && i.attr('class', i.class),
			e.title !== void 0 && i.append('title').text(e.title),
			i
		);
	},
	at = function (t, e) {
		return bt(t, e);
	},
	Lt = function (t, e) {
		function i(n, h, c, f, y) {
			return (
				n + ',' + h + ' ' + (n + c) + ',' + h + ' ' + (n + c) + ',' + (h + f - y) + ' ' + (n + c - y * 1.2) + ',' + (h + f) + ' ' + n + ',' + (h + f)
			);
		}
		const l = t.append('polygon');
		l.attr('points', i(e.x, e.y, 50, 20, 7)), l.attr('class', 'labelBox'), (e.y = e.y + e.labelMargin), (e.x = e.x + 0.5 * e.labelMargin), at(t, e);
	},
	Rt = function (t, e, i) {
		const l = t.append('g'),
			n = it();
		(n.x = e.x),
			(n.y = e.y),
			(n.fill = e.fill),
			(n.width = i.width * e.taskCount + i.diagramMarginX * (e.taskCount - 1)),
			(n.height = i.height),
			(n.class = 'journey-section section-type-' + e.num),
			(n.rx = 3),
			(n.ry = 3),
			U(l, n),
			ot(i)(e.text, l, n.x, n.y, n.width, n.height, { class: 'journey-section section-type-' + e.num }, i, e.colour);
	};
let et = -1;
const Nt = function (t, e, i) {
		const l = e.x + i.width / 2,
			n = t.append('g');
		et++;
		const h = 300 + 5 * 30;
		n
			.append('line')
			.attr('id', 'task' + et)
			.attr('x1', l)
			.attr('y1', e.y)
			.attr('x2', l)
			.attr('y2', h)
			.attr('class', 'task-line')
			.attr('stroke-width', '1px')
			.attr('stroke-dasharray', '4 2')
			.attr('stroke', '#666'),
			Ft(n, { cx: l, cy: 300 + (5 - e.score) * 30, score: e.score });
		const c = it();
		(c.x = e.x),
			(c.y = e.y),
			(c.fill = e.fill),
			(c.width = i.width),
			(c.height = i.height),
			(c.class = 'task task-type-' + e.num),
			(c.rx = 3),
			(c.ry = 3),
			U(n, c);
		let f = e.x + 14;
		e.people.forEach((y) => {
			const m = e.actors[y].color,
				g = { cx: f, cy: e.y, r: 7, fill: m, stroke: '#000', title: y, pos: e.actors[y].position };
			rt(n, g), (f += 10);
		}),
			ot(i)(e.task, n, c.x, c.y, c.width, c.height, { class: 'task' }, i, e.colour);
	},
	Bt = function (t, e) {
		vt(t, e);
	},
	ot = (function () {
		function t(n, h, c, f, y, m, g, p) {
			const s = h
				.append('text')
				.attr('x', c + y / 2)
				.attr('y', f + m / 2 + 5)
				.style('font-color', p)
				.style('text-anchor', 'middle')
				.text(n);
			l(s, g);
		}
		function e(n, h, c, f, y, m, g, p, s) {
			const { taskFontSize: r, taskFontFamily: a } = p,
				u = n.split(/<br\s*\/?>/gi);
			for (let d = 0; d < u.length; d++) {
				const o = d * r - (r * (u.length - 1)) / 2,
					w = h
						.append('text')
						.attr('x', c + y / 2)
						.attr('y', f)
						.attr('fill', s)
						.style('text-anchor', 'middle')
						.style('font-size', r)
						.style('font-family', a);
				w
					.append('tspan')
					.attr('x', c + y / 2)
					.attr('dy', o)
					.text(u[d]),
					w
						.attr('y', f + m / 2)
						.attr('dominant-baseline', 'central')
						.attr('alignment-baseline', 'central'),
					l(w, g);
			}
		}
		function i(n, h, c, f, y, m, g, p) {
			const s = h.append('switch'),
				a = s
					.append('foreignObject')
					.attr('x', c)
					.attr('y', f)
					.attr('width', y)
					.attr('height', m)
					.attr('position', 'fixed')
					.append('xhtml:div')
					.style('display', 'table')
					.style('height', '100%')
					.style('width', '100%');
			a.append('div').attr('class', 'label').style('display', 'table-cell').style('text-align', 'center').style('vertical-align', 'middle').text(n),
				e(n, s, c, f, y, m, g, p),
				l(a, g);
		}
		function l(n, h) {
			for (const c in h) c in h && n.attr(c, h[c]);
		}
		return function (n) {
			return n.textPlacement === 'fo' ? i : n.textPlacement === 'old' ? t : e;
		};
	})(),
	jt = function (t) {
		t.append('defs')
			.append('marker')
			.attr('id', 'arrowhead')
			.attr('refX', 5)
			.attr('refY', 2)
			.attr('markerWidth', 6)
			.attr('markerHeight', 4)
			.attr('orient', 'auto')
			.append('path')
			.attr('d', 'M 0,0 V 4 L6,2 Z');
	},
	L = { drawRect: U, drawCircle: rt, drawSection: Rt, drawText: at, drawLabel: Lt, drawTask: Nt, drawBackgroundRect: Bt, initGraphics: jt },
	zt = function (t) {
		Object.keys(t).forEach(function (i) {
			j[i] = t[i];
		});
	},
	M = {};
function Yt(t) {
	const e = A().journey;
	let i = 60;
	Object.keys(M).forEach((l) => {
		const n = M[l].color,
			h = { cx: 20, cy: i, r: 7, fill: n, stroke: '#000', pos: M[l].position };
		L.drawCircle(t, h);
		const c = { x: 40, y: i + 7, fill: '#666', text: l, textMargin: e.boxTextMargin | 5 };
		L.drawText(t, c), (i += 20);
	});
}
const j = A().journey,
	P = j.leftMargin,
	Ot = function (t, e, i, l) {
		const n = A().journey,
			h = A().securityLevel;
		let c;
		h === 'sandbox' && (c = W('#i' + e));
		const f = h === 'sandbox' ? W(c.nodes()[0].contentDocument.body) : W('body');
		v.init();
		const y = f.select('#' + e);
		L.initGraphics(y);
		const m = l.db.getTasks(),
			g = l.db.getDiagramTitle(),
			p = l.db.getActors();
		for (const o in M) delete M[o];
		let s = 0;
		p.forEach((o) => {
			(M[o] = { color: n.actorColours[s % n.actorColours.length], position: s }), s++;
		}),
			Yt(y),
			v.insert(0, 0, P, Object.keys(M).length * 50),
			qt(y, m, 0);
		const r = v.getBounds();
		g && y.append('text').text(g).attr('x', P).attr('font-size', '4ex').attr('font-weight', 'bold').attr('y', 25);
		const a = r.stopy - r.starty + 2 * n.diagramMarginY,
			u = P + r.stopx + 2 * n.diagramMarginX;
		kt(y, a, u, n.useMaxWidth),
			y
				.append('line')
				.attr('x1', P)
				.attr('y1', n.height * 4)
				.attr('x2', u - P - 4)
				.attr('y2', n.height * 4)
				.attr('stroke-width', 4)
				.attr('stroke', 'black')
				.attr('marker-end', 'url(#arrowhead)');
		const d = g ? 70 : 0;
		y.attr('viewBox', `${r.startx} -25 ${u} ${a + d}`), y.attr('preserveAspectRatio', 'xMinYMin meet'), y.attr('height', a + d + 25);
	},
	v = {
		data: { startx: void 0, stopx: void 0, starty: void 0, stopy: void 0 },
		verticalPos: 0,
		sequenceItems: [],
		init: function () {
			(this.sequenceItems = []), (this.data = { startx: void 0, stopx: void 0, starty: void 0, stopy: void 0 }), (this.verticalPos = 0);
		},
		updateVal: function (t, e, i, l) {
			t[e] === void 0 ? (t[e] = i) : (t[e] = l(i, t[e]));
		},
		updateBounds: function (t, e, i, l) {
			const n = A().journey,
				h = this;
			let c = 0;
			function f(y) {
				return function (g) {
					c++;
					const p = h.sequenceItems.length - c + 1;
					h.updateVal(g, 'starty', e - p * n.boxMargin, Math.min),
						h.updateVal(g, 'stopy', l + p * n.boxMargin, Math.max),
						h.updateVal(v.data, 'startx', t - p * n.boxMargin, Math.min),
						h.updateVal(v.data, 'stopx', i + p * n.boxMargin, Math.max),
						y !== 'activation' &&
							(h.updateVal(g, 'startx', t - p * n.boxMargin, Math.min),
							h.updateVal(g, 'stopx', i + p * n.boxMargin, Math.max),
							h.updateVal(v.data, 'starty', e - p * n.boxMargin, Math.min),
							h.updateVal(v.data, 'stopy', l + p * n.boxMargin, Math.max));
				};
			}
			this.sequenceItems.forEach(f());
		},
		insert: function (t, e, i, l) {
			const n = Math.min(t, i),
				h = Math.max(t, i),
				c = Math.min(e, l),
				f = Math.max(e, l);
			this.updateVal(v.data, 'startx', n, Math.min),
				this.updateVal(v.data, 'starty', c, Math.min),
				this.updateVal(v.data, 'stopx', h, Math.max),
				this.updateVal(v.data, 'stopy', f, Math.max),
				this.updateBounds(n, c, h, f);
		},
		bumpVerticalPos: function (t) {
			(this.verticalPos = this.verticalPos + t), (this.data.stopy = this.verticalPos);
		},
		getVerticalPos: function () {
			return this.verticalPos;
		},
		getBounds: function () {
			return this.data;
		},
	},
	X = j.sectionFills,
	st = j.sectionColours,
	qt = function (t, e, i) {
		const l = A().journey;
		let n = '';
		const h = l.height * 2 + l.diagramMarginY,
			c = i + h;
		let f = 0,
			y = '#CCC',
			m = 'black',
			g = 0;
		for (const [p, s] of e.entries()) {
			if (n !== s.section) {
				(y = X[f % X.length]), (g = f % X.length), (m = st[f % st.length]);
				let a = 0;
				const u = s.section;
				for (let o = p; o < e.length && e[o].section == u; o++) a = a + 1;
				const d = { x: p * l.taskMargin + p * l.width + P, y: 50, text: s.section, fill: y, num: g, colour: m, taskCount: a };
				L.drawSection(t, d, l), (n = s.section), f++;
			}
			const r = s.people.reduce((a, u) => (M[u] && (a[u] = M[u]), a), {});
			(s.x = p * l.taskMargin + p * l.width + P),
				(s.y = c),
				(s.width = l.diagramMarginX),
				(s.height = l.diagramMarginY),
				(s.colour = m),
				(s.fill = y),
				(s.num = g),
				(s.actors = r),
				L.drawTask(t, s, l),
				v.insert(s.x, s.y, s.x + s.width + l.taskMargin, 300 + 5 * 30);
		}
	},
	nt = { setConf: zt, draw: Ot },
	Jt = {
		parser: wt,
		db: tt,
		renderer: nt,
		styles: Vt,
		init: (t) => {
			nt.setConf(t.journey), tt.clear();
		},
	};
export { Jt as diagram };