From edc71934dc6c9a631641a5b361c9096830fbf8e5 Mon Sep 17 00:00:00 2001
From: David Evans <davidje13@users.noreply.github.com>
Date: Sat, 21 Apr 2018 20:24:54 +0100
Subject: [PATCH] Add commandline tool for generating SVG from code [#32]

---
 .../contents.xcworkspacedata                  |    3 +
 bin/sequence-diagram-svg.js                   |   46 +
 index.html                                    |    2 +-
 lib/sequence-diagram-web.js                   | 9969 +++++++++++++++++
 lib/sequence-diagram-web.min.js               |    1 +
 lib/sequence-diagram.js                       |  282 +-
 lib/sequence-diagram.min.js                   |    2 +-
 library.htm                                   |    6 +-
 package.json                                  |   11 +-
 scripts/rollup.config.js                      |    8 +
 scripts/standalone-web.mjs                    |   17 +
 scripts/standalone.mjs                        |   39 +-
 spec/support/karma.conf.js                    |    1 +
 spec/support/rollup.config.js                 |    1 +
 14 files changed, 10375 insertions(+), 13 deletions(-)
 create mode 100755 bin/sequence-diagram-svg.js
 create mode 100644 lib/sequence-diagram-web.js
 create mode 100644 lib/sequence-diagram-web.min.js
 create mode 100644 scripts/standalone-web.mjs

diff --git a/SequenceDiagram.xcworkspace/contents.xcworkspacedata b/SequenceDiagram.xcworkspace/contents.xcworkspacedata
index 1b3961b..5ee6cb9 100644
--- a/SequenceDiagram.xcworkspace/contents.xcworkspacedata
+++ b/SequenceDiagram.xcworkspace/contents.xcworkspacedata
@@ -16,6 +16,9 @@
    <FileRef
       location = "container:web">
    </FileRef>
+   <FileRef
+      location = "container:bin">
+   </FileRef>
    <FileRef
       location = "container:.gitignore">
    </FileRef>
diff --git a/bin/sequence-diagram-svg.js b/bin/sequence-diagram-svg.js
new file mode 100755
index 0000000..af212db
--- /dev/null
+++ b/bin/sequence-diagram-svg.js
@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+const {
+	headlessTextSizerFactory,
+	SequenceDiagram,
+	VirtualDocument,
+} = require('../lib/sequence-diagram');
+
+function render(code) {
+	const sd = new SequenceDiagram({
+		code,
+		document: new VirtualDocument(),
+		namespace: '',
+		textSizerFactory: headlessTextSizerFactory,
+	});
+
+	return sd.dom().outerHTML;
+}
+
+function read(pipe) {
+	return new Promise((resolve) => {
+		let all = '';
+		pipe.on('readable', () => {
+			const chunk = pipe.read();
+			if(chunk !== null) {
+				all += chunk;
+			}
+		});
+		pipe.on('end', () => {
+			resolve(all);
+		});
+	});
+}
+
+function getCodeArg() {
+	if(process.argv.length > 2 && process.argv[2] !== '-') {
+		return Promise.resolve(process.argv[2]);
+	} else {
+		process.stdin.setEncoding('utf8');
+		return read(process.stdin);
+	}
+}
+
+getCodeArg().then((code) => {
+	process.stdout.write(render(code) + '\n');
+});
diff --git a/index.html b/index.html
index 3125c3f..a039543 100644
--- a/index.html
+++ b/index.html
@@ -32,7 +32,7 @@
 
 <link rel="stylesheet" href="styles/editor.css">
 
-<script src="lib/sequence-diagram.min.js"></script>
+<script src="lib/sequence-diagram-web.min.js"></script>
 
 <script
 	src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.5/require.min.js"
diff --git a/lib/sequence-diagram-web.js b/lib/sequence-diagram-web.js
new file mode 100644
index 0000000..fae0364
--- /dev/null
+++ b/lib/sequence-diagram-web.js
@@ -0,0 +1,9969 @@
+(function () {
+	'use strict';
+
+	/* eslint-disable sort-keys */ // Maybe later
+
+	function optionsAttributes(attributes, options) {
+		const attrs = Object.assign({}, attributes['']);
+		options.forEach((opt) => {
+			Object.assign(attrs, attributes[opt] || {});
+		});
+		return attrs;
+	}
+
+	class WavePattern {
+		constructor(width, height) {
+			if(Array.isArray(height)) {
+				this.deltas = height;
+			} else {
+				this.deltas = [
+					0,
+					-height * 2 / 3,
+					-height,
+					-height * 2 / 3,
+					0,
+					height * 2 / 3,
+					height,
+					height * 2 / 3,
+				];
+			}
+			this.partWidth = width / this.deltas.length;
+		}
+
+		getDelta(p) {
+			return this.deltas[p % this.deltas.length];
+		}
+	}
+
+	class BaseTheme {
+		constructor(svg) {
+			this.svg = svg;
+		}
+
+		// PUBLIC API
+
+		reset() {
+			// No-op
+		}
+
+		addDefs() {
+			// No-op
+		}
+
+		getBlock(type) {
+			return this.blocks[type] || this.blocks[''];
+		}
+
+		getNote(type) {
+			return this.notes[type] || this.notes[''];
+		}
+
+		getDivider(type) {
+			return this.dividers[type] || this.dividers[''];
+		}
+
+		optionsAttributes(attributes, options) {
+			return optionsAttributes(attributes, options);
+		}
+
+		renderAgentLine({x, y0, y1, width, className, options}) {
+			const attrs = this.optionsAttributes(this.agentLineAttrs, options);
+			if(width > 0) {
+				return this.svg.box(attrs, {
+					x: x - width / 2,
+					y: y0,
+					width,
+					height: y1 - y0,
+				}).addClass(className);
+			} else {
+				return this.svg.line(attrs, {
+					'x1': x,
+					'x2': x,
+					'y1': y0,
+					'y2': y1,
+				}).addClass(className);
+			}
+		}
+
+		// INTERNAL HELPERS
+
+		renderArrowHead(attrs, {x, y, width, height, dir}) {
+			const wx = width * dir.dx;
+			const wy = width * dir.dy;
+			const hy = height * 0.5 * dir.dx;
+			const hx = -height * 0.5 * dir.dy;
+			return this.svg.el(attrs.fill === 'none' ? 'polyline' : 'polygon')
+				.attr('points', (
+					(x + wx - hx) + ' ' + (y + wy - hy) + ' ' +
+					x + ' ' + y + ' ' +
+					(x + wx + hx) + ' ' + (y + wy + hy)
+				))
+				.attrs(attrs);
+		}
+
+		renderTag(attrs, {x, y, width, height}) {
+			const {rx, ry} = attrs;
+			const x2 = x + width;
+			const y2 = y + height;
+
+			const line = (
+				'M' + x2 + ' ' + y +
+				'L' + x2 + ' ' + (y2 - ry) +
+				'L' + (x2 - rx) + ' ' + y2 +
+				'L' + x + ' ' + y2
+			);
+
+			const g = this.svg.el('g');
+
+			if(attrs.fill !== 'none') {
+				g.add(this.svg.el('path')
+					.attr('d', line + 'L' + x + ' ' + y)
+					.attrs(attrs)
+					.attr('stroke', 'none'));
+			}
+			if(attrs.stroke !== 'none') {
+				g.add(this.svg.el('path')
+					.attr('d', line)
+					.attrs(attrs)
+					.attr('fill', 'none'));
+			}
+
+			return g;
+		}
+
+		renderDB(attrs, position) {
+			const z = attrs['db-z'];
+			return this.svg.el('g').add(
+				this.svg.box({
+					'rx': position.width / 2,
+					'ry': z,
+				}, position).attrs(attrs),
+				this.svg.el('path')
+					.attr('d', (
+						'M' + position.x + ' ' + (position.y + z) +
+						'a' + (position.width / 2) + ' ' + z +
+						' 0 0 0 ' + position.width + ' 0'
+					))
+					.attrs(attrs)
+					.attr('fill', 'none')
+			);
+		}
+
+		renderRef(options, position) {
+			return {
+				shape: this.svg.box(options, position).attrs({'fill': 'none'}),
+				mask: this.svg.box(options, position).attrs({
+					'fill': '#000000',
+					'stroke': 'none',
+				}),
+				fill: this.svg.box(options, position).attrs({'stroke': 'none'}),
+			};
+		}
+
+		renderFlatConnect(
+			pattern,
+			attrs,
+			{x1, y1, x2, y2}
+		) {
+			return {
+				shape: this.svg.el('path')
+					.attr('d', this.svg.patternedLine(pattern)
+						.move(x1, y1)
+						.line(x2, y2)
+						.cap()
+						.asPath())
+					.attrs(attrs),
+				p1: {x: x1, y: y1},
+				p2: {x: x2, y: y2},
+			};
+		}
+
+		renderRevConnect(
+			pattern,
+			attrs,
+			{x1, y1, x2, y2, xR, rad}
+		) {
+			const maxRad = (y2 - y1) / 2;
+			const line = this.svg.patternedLine(pattern)
+				.move(x1, y1)
+				.line(xR, y1);
+			if(rad < maxRad) {
+				line
+					.arc(xR, y1 + rad, Math.PI / 2)
+					.line(xR + rad, y2 - rad)
+					.arc(xR, y2 - rad, Math.PI / 2);
+			} else {
+				line.arc(xR, (y1 + y2) / 2, Math.PI);
+			}
+			return {
+				shape: this.svg.el('path')
+					.attr('d', line
+						.line(x2, y2)
+						.cap()
+						.asPath())
+					.attrs(attrs),
+				p1: {x: x1, y: y1},
+				p2: {x: x2, y: y2},
+			};
+		}
+
+		renderLineDivider(
+			{lineAttrs},
+			{x, y, labelWidth, width, height}
+		) {
+			let shape = null;
+			const yPos = y + height / 2;
+			if(labelWidth > 0) {
+				shape = this.svg.el('g').add(
+					this.svg.line({'fill': 'none'}, {
+						'x1': x,
+						'x2': x + (width - labelWidth) / 2,
+						'y1': yPos,
+						'y2': yPos,
+					}).attrs(lineAttrs),
+					this.svg.line({'fill': 'none'}, {
+						'x1': x + (width + labelWidth) / 2,
+						'x2': x + width,
+						'y1': yPos,
+						'y2': yPos,
+					}).attrs(lineAttrs)
+				);
+			} else {
+				shape = this.svg.line({'fill': 'none'}, {
+					'x1': x,
+					'x2': x + width,
+					'y1': yPos,
+					'y2': yPos,
+				}).attrs(lineAttrs);
+			}
+			return {shape};
+		}
+
+		renderDelayDivider(
+			{dotSize, gapSize},
+			{x, y, width, height}
+		) {
+			const mask = this.svg.el('g');
+			for(let i = 0; i + gapSize <= height; i += dotSize + gapSize) {
+				mask.add(this.svg.box({
+					'fill': '#000000',
+				}, {
+					x,
+					y: y + i,
+					width,
+					height: gapSize,
+				}));
+			}
+			return {mask};
+		}
+
+		renderTearDivider(
+			{fadeBegin, fadeSize, pattern, zigWidth, zigHeight, lineAttrs},
+			{x, y, labelWidth, labelHeight, width, height, env}
+		) {
+			const maskGradID = env.addDef('tear-grad', () => {
+				const px = 100 / width;
+				return this.svg.linearGradient({}, [
+					{
+						'offset': (fadeBegin * px) + '%',
+						'stop-color': '#000000',
+					},
+					{
+						'offset': ((fadeBegin + fadeSize) * px) + '%',
+						'stop-color': '#FFFFFF',
+					},
+					{
+						'offset': (100 - (fadeBegin + fadeSize) * px) + '%',
+						'stop-color': '#FFFFFF',
+					},
+					{
+						'offset': (100 - fadeBegin * px) + '%',
+						'stop-color': '#000000',
+					},
+				]);
+			});
+			const shapeMask = this.svg.el('mask')
+				.attr('maskUnits', 'userSpaceOnUse')
+				.add(
+					this.svg.box({
+						'fill': 'url(#' + maskGradID + ')',
+					}, {
+						x,
+						y: y - 5,
+						width,
+						height: height + 10,
+					})
+				);
+			const shapeMaskID = env.addDef(shapeMask);
+
+			if(labelWidth > 0) {
+				shapeMask.add(this.svg.box({
+					'rx': 2,
+					'ry': 2,
+					'fill': '#000000',
+				}, {
+					'x': x + (width - labelWidth) / 2,
+					'y': y + (height - labelHeight) / 2 - 1,
+					'width': labelWidth,
+					'height': labelHeight + 2,
+				}));
+			}
+
+			const p = pattern || new WavePattern(zigWidth, [zigHeight, -zigHeight]);
+			let mask = null;
+
+			const pathTop = this.svg.patternedLine(p)
+				.move(x, y)
+				.line(x + width, y);
+
+			const shape = this.svg.el('g')
+				.attr('mask', 'url(#' + shapeMaskID + ')')
+				.add(
+					this.svg.el('path')
+						.attrs({
+							'd': pathTop.asPath(),
+							'fill': 'none',
+						})
+						.attrs(lineAttrs)
+				);
+
+			if(height > 0) {
+				const pathBase = this.svg.patternedLine(p)
+					.move(x, y + height)
+					.line(x + width, y + height);
+				shape.add(
+					this.svg.el('path')
+						.attrs({
+							'd': pathBase.asPath(),
+							'fill': 'none',
+						})
+						.attrs(lineAttrs)
+				);
+				pathTop
+					.line(pathBase.x, pathBase.y, {patterned: false})
+					.cap();
+				pathTop.points.push(...pathBase.points.reverse());
+				mask = this.svg.el('path').attrs({
+					'd': pathTop.asPath(),
+					'fill': '#000000',
+				});
+			}
+			return {shape, mask};
+		}
+	}
+
+	/* eslint-disable sort-keys */ // Maybe later
+
+	const FONT = 'sans-serif';
+	const LINE_HEIGHT = 1.3;
+
+	const WAVE = new WavePattern(6, 0.5);
+
+	const NOTE_ATTRS = {
+		'font-family': FONT,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT,
+	};
+
+	const DIVIDER_LABEL_ATTRS = {
+		'font-family': FONT,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT,
+		'text-anchor': 'middle',
+	};
+
+	class BasicTheme extends BaseTheme {
+		constructor(svg) {
+			super(svg);
+
+			const sharedBlockSection = {
+				padding: {
+					top: 3,
+					bottom: 2,
+				},
+				tag: {
+					padding: {
+						top: 1,
+						left: 3,
+						right: 3,
+						bottom: 0,
+					},
+					boxRenderer: this.renderTag.bind(this, {
+						'fill': '#FFFFFF',
+						'stroke': '#000000',
+						'stroke-width': 1,
+						'rx': 2,
+						'ry': 2,
+					}),
+					labelAttrs: {
+						'font-family': FONT,
+						'font-weight': 'bold',
+						'font-size': 9,
+						'line-height': LINE_HEIGHT,
+						'text-anchor': 'left',
+					},
+				},
+				label: {
+					minHeight: 4,
+					padding: {
+						top: 1,
+						left: 5,
+						right: 3,
+						bottom: 1,
+					},
+					labelAttrs: {
+						'font-family': FONT,
+						'font-size': 8,
+						'line-height': LINE_HEIGHT,
+						'text-anchor': 'left',
+					},
+				},
+			};
+
+			Object.assign(this, {
+				titleMargin: 10,
+				outerMargin: 5,
+				agentMargin: 10,
+				actionMargin: 10,
+				minActionMargin: 3,
+				agentLineHighlightRadius: 4,
+
+				agentCap: {
+					box: {
+						padding: {
+							top: 5,
+							left: 10,
+							right: 10,
+							bottom: 5,
+						},
+						arrowBottom: 5 + 12 * 1.3 / 2,
+						boxAttrs: {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						},
+						labelAttrs: {
+							'font-family': FONT,
+							'font-size': 12,
+							'line-height': LINE_HEIGHT,
+							'text-anchor': 'middle',
+						},
+					},
+					database: {
+						padding: {
+							top: 12,
+							left: 10,
+							right: 10,
+							bottom: 3,
+						},
+						arrowBottom: 5 + 12 * 1.3 / 2,
+						boxRenderer: this.renderDB.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+							'db-z': 5,
+						}),
+						labelAttrs: {
+							'font-family': FONT,
+							'font-size': 12,
+							'line-height': LINE_HEIGHT,
+							'text-anchor': 'middle',
+						},
+					},
+					cross: {
+						size: 20,
+						render: svg.crossFactory({
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+					},
+					bar: {
+						height: 4,
+						render: svg.boxFactory({
+							'fill': '#000000',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+					},
+					fade: {
+						width: 5,
+						height: 6,
+						extend: 1,
+					},
+					none: {
+						height: 10,
+					},
+				},
+
+				connect: {
+					loopbackRadius: 6,
+					line: {
+						'solid': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+							},
+							renderFlat: this.renderFlatConnect.bind(this, null),
+							renderRev: this.renderRevConnect.bind(this, null),
+						},
+						'dash': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+								'stroke-dasharray': '4, 2',
+							},
+							renderFlat: this.renderFlatConnect.bind(this, null),
+							renderRev: this.renderRevConnect.bind(this, null),
+						},
+						'wave': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+								'stroke-linejoin': 'round',
+								'stroke-linecap': 'round',
+							},
+							renderFlat: this.renderFlatConnect.bind(this, WAVE),
+							renderRev: this.renderRevConnect.bind(this, WAVE),
+						},
+					},
+					arrow: {
+						'single': {
+							width: 5,
+							height: 10,
+							render: this.renderArrowHead.bind(this),
+							attrs: {
+								'fill': '#000000',
+								'stroke-width': 0,
+								'stroke-linejoin': 'miter',
+							},
+						},
+						'double': {
+							width: 4,
+							height: 6,
+							render: this.renderArrowHead.bind(this),
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+								'stroke-linejoin': 'miter',
+							},
+						},
+						'cross': {
+							short: 7,
+							radius: 3,
+							render: svg.crossFactory({
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+							}),
+						},
+					},
+					label: {
+						padding: 6,
+						margin: {top: 2, bottom: 1},
+						attrs: {
+							'font-family': FONT,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT,
+							'text-anchor': 'middle',
+						},
+						loopbackAttrs: {
+							'font-family': FONT,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT,
+						},
+					},
+					source: {
+						radius: 2,
+						render: svg.circleFactory({
+							'fill': '#000000',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+					},
+					mask: {
+						padding: {
+							top: 0,
+							left: 3,
+							right: 3,
+							bottom: 1,
+						},
+					},
+				},
+
+				titleAttrs: {
+					'font-family': FONT,
+					'font-size': 20,
+					'line-height': LINE_HEIGHT,
+					'text-anchor': 'middle',
+					'class': 'title',
+				},
+
+				agentLineAttrs: {
+					'': {
+						'fill': 'none',
+						'stroke': '#000000',
+						'stroke-width': 1,
+					},
+					'red': {
+						'stroke': '#CC0000',
+					},
+				},
+				blocks: {
+					'ref': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: this.renderRef.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1.5,
+							'rx': 2,
+							'ry': 2,
+						}),
+						section: sharedBlockSection,
+					},
+					'': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: svg.boxFactory({
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 1.5,
+							'rx': 2,
+							'ry': 2,
+						}),
+						collapsedBoxRenderer: this.renderRef.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1.5,
+							'rx': 2,
+							'ry': 2,
+						}),
+						section: sharedBlockSection,
+						sepRenderer: svg.lineFactory({
+							'stroke': '#000000',
+							'stroke-width': 1.5,
+							'stroke-dasharray': '4, 2',
+						}),
+					},
+				},
+				notes: {
+					'text': {
+						margin: {top: 0, left: 2, right: 2, bottom: 0},
+						padding: {top: 2, left: 2, right: 2, bottom: 2},
+						overlap: {left: 10, right: 10},
+						boxRenderer: svg.boxFactory({
+							'fill': '#FFFFFF',
+						}),
+						labelAttrs: NOTE_ATTRS,
+					},
+					'note': {
+						margin: {top: 0, left: 5, right: 5, bottom: 0},
+						padding: {top: 5, left: 5, right: 10, bottom: 5},
+						overlap: {left: 10, right: 10},
+						boxRenderer: svg.noteFactory({
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}, {
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+						labelAttrs: NOTE_ATTRS,
+					},
+					'state': {
+						margin: {top: 0, left: 5, right: 5, bottom: 0},
+						padding: {top: 7, left: 7, right: 7, bottom: 7},
+						overlap: {left: 10, right: 10},
+						boxRenderer: svg.boxFactory({
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+							'rx': 10,
+							'ry': 10,
+						}),
+						labelAttrs: NOTE_ATTRS,
+					},
+				},
+				dividers: {
+					'': {
+						labelAttrs: DIVIDER_LABEL_ATTRS,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: () => ({}),
+					},
+					'line': {
+						labelAttrs: DIVIDER_LABEL_ATTRS,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 10,
+						margin: 0,
+						render: this.renderLineDivider.bind(this, {
+							lineAttrs: {
+								'stroke': '#000000',
+							},
+						}),
+					},
+					'delay': {
+						labelAttrs: DIVIDER_LABEL_ATTRS,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: this.renderDelayDivider.bind(this, {
+							dotSize: 1,
+							gapSize: 2,
+						}),
+					},
+					'tear': {
+						labelAttrs: DIVIDER_LABEL_ATTRS,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 10,
+						margin: 10,
+						render: this.renderTearDivider.bind(this, {
+							fadeBegin: 5,
+							fadeSize: 10,
+							zigWidth: 6,
+							zigHeight: 1,
+							lineAttrs: {
+								'stroke': '#000000',
+							},
+						}),
+					},
+				},
+			});
+		}
+	}
+
+	class Factory {
+		constructor() {
+			this.name = 'basic';
+		}
+
+		build(svg) {
+			return new BasicTheme(svg);
+		}
+	}
+
+	/* eslint-disable sort-keys */ // Maybe later
+
+	const FONT$1 = 'sans-serif';
+	const LINE_HEIGHT$1 = 1.3;
+
+	const WAVE$1 = new WavePattern(10, 1);
+
+	const NOTE_ATTRS$1 = {
+		'font-family': FONT$1,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT$1,
+	};
+
+	const DIVIDER_LABEL_ATTRS$1 = {
+		'font-family': FONT$1,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT$1,
+		'text-anchor': 'middle',
+	};
+
+	class ChunkyTheme extends BaseTheme {
+		constructor(svg) {
+			super(svg);
+
+			const sharedBlockSection = {
+				padding: {
+					top: 3,
+					bottom: 4,
+				},
+				tag: {
+					padding: {
+						top: 2,
+						left: 5,
+						right: 5,
+						bottom: 1,
+					},
+					boxRenderer: this.renderTag.bind(this, {
+						'fill': '#FFFFFF',
+						'stroke': '#000000',
+						'stroke-width': 2,
+						'rx': 3,
+						'ry': 3,
+					}),
+					labelAttrs: {
+						'font-family': FONT$1,
+						'font-weight': 'bold',
+						'font-size': 9,
+						'line-height': LINE_HEIGHT$1,
+						'text-anchor': 'left',
+					},
+				},
+				label: {
+					minHeight: 5,
+					padding: {
+						top: 2,
+						left: 5,
+						right: 3,
+						bottom: 1,
+					},
+					labelAttrs: {
+						'font-family': FONT$1,
+						'font-size': 8,
+						'line-height': LINE_HEIGHT$1,
+						'text-anchor': 'left',
+					},
+				},
+			};
+
+			Object.assign(this, {
+				titleMargin: 12,
+				outerMargin: 5,
+				agentMargin: 8,
+				actionMargin: 5,
+				minActionMargin: 5,
+				agentLineHighlightRadius: 4,
+
+				agentCap: {
+					box: {
+						padding: {
+							top: 1,
+							left: 3,
+							right: 3,
+							bottom: 1,
+						},
+						arrowBottom: 2 + 14 * 1.3 / 2,
+						boxAttrs: {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 3,
+							'rx': 4,
+							'ry': 4,
+						},
+						labelAttrs: {
+							'font-family': FONT$1,
+							'font-weight': 'bold',
+							'font-size': 14,
+							'line-height': LINE_HEIGHT$1,
+							'text-anchor': 'middle',
+						},
+					},
+					database: {
+						padding: {
+							top: 4,
+							left: 3,
+							right: 3,
+							bottom: 0,
+						},
+						arrowBottom: 2 + 14 * 1.3 / 2,
+						boxRenderer: this.renderDB.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 3,
+							'db-z': 2,
+						}),
+						labelAttrs: {
+							'font-family': FONT$1,
+							'font-weight': 'bold',
+							'font-size': 14,
+							'line-height': LINE_HEIGHT$1,
+							'text-anchor': 'middle',
+						},
+					},
+					cross: {
+						size: 20,
+						render: svg.crossFactory({
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 3,
+							'stroke-linecap': 'round',
+						}),
+					},
+					bar: {
+						height: 4,
+						render: svg.boxFactory({
+							'fill': '#000000',
+							'stroke': '#000000',
+							'stroke-width': 3,
+							'rx': 2,
+							'ry': 2,
+						}),
+					},
+					fade: {
+						width: 5,
+						height: 10,
+						extend: 1,
+					},
+					none: {
+						height: 10,
+					},
+				},
+
+				connect: {
+					loopbackRadius: 8,
+					line: {
+						'solid': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 3,
+							},
+							renderFlat: this.renderFlatConnect.bind(this, null),
+							renderRev: this.renderRevConnect.bind(this, null),
+						},
+						'dash': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 3,
+								'stroke-dasharray': '10, 4',
+							},
+							renderFlat: this.renderFlatConnect.bind(this, null),
+							renderRev: this.renderRevConnect.bind(this, null),
+						},
+						'wave': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 3,
+								'stroke-linejoin': 'round',
+								'stroke-linecap': 'round',
+							},
+							renderFlat: this.renderFlatConnect.bind(this, WAVE$1),
+							renderRev: this.renderRevConnect.bind(this, WAVE$1),
+						},
+					},
+					arrow: {
+						'single': {
+							width: 10,
+							height: 12,
+							render: this.renderArrowHead.bind(this),
+							attrs: {
+								'fill': '#000000',
+								'stroke': '#000000',
+								'stroke-width': 3,
+								'stroke-linejoin': 'round',
+							},
+						},
+						'double': {
+							width: 10,
+							height: 12,
+							render: this.renderArrowHead.bind(this),
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 3,
+								'stroke-linejoin': 'round',
+								'stroke-linecap': 'round',
+							},
+						},
+						'cross': {
+							short: 10,
+							radius: 5,
+							render: svg.crossFactory({
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 3,
+								'stroke-linejoin': 'round',
+								'stroke-linecap': 'round',
+							}),
+						},
+					},
+					label: {
+						padding: 7,
+						margin: {top: 2, bottom: 3},
+						attrs: {
+							'font-family': FONT$1,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT$1,
+							'text-anchor': 'middle',
+						},
+						loopbackAttrs: {
+							'font-family': FONT$1,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT$1,
+						},
+					},
+					source: {
+						radius: 5,
+						render: svg.circleFactory({
+							'fill': '#000000',
+							'stroke': '#000000',
+							'stroke-width': 3,
+						}),
+					},
+					mask: {
+						padding: {
+							top: 1,
+							left: 5,
+							right: 5,
+							bottom: 3,
+						},
+					},
+				},
+
+				titleAttrs: {
+					'font-family': FONT$1,
+					'font-weight': 'bolder',
+					'font-size': 20,
+					'line-height': LINE_HEIGHT$1,
+					'text-anchor': 'middle',
+					'class': 'title',
+				},
+
+				agentLineAttrs: {
+					'': {
+						'fill': 'none',
+						'stroke': '#000000',
+						'stroke-width': 3,
+					},
+					'red': {
+						'stroke': '#DD0000',
+					},
+				},
+				blocks: {
+					'ref': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: this.renderRef.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 4,
+							'rx': 5,
+							'ry': 5,
+						}),
+						section: sharedBlockSection,
+					},
+					'': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: svg.boxFactory({
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 4,
+							'rx': 5,
+							'ry': 5,
+						}),
+						collapsedBoxRenderer: this.renderRef.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 4,
+							'rx': 5,
+							'ry': 5,
+						}),
+						section: sharedBlockSection,
+						sepRenderer: svg.lineFactory({
+							'stroke': '#000000',
+							'stroke-width': 2,
+							'stroke-dasharray': '5, 3',
+						}),
+					},
+				},
+				notes: {
+					'text': {
+						margin: {top: 0, left: 2, right: 2, bottom: 0},
+						padding: {top: 2, left: 2, right: 2, bottom: 2},
+						overlap: {left: 10, right: 10},
+						boxRenderer: svg.boxFactory({
+							'fill': '#FFFFFF',
+						}),
+						labelAttrs: NOTE_ATTRS$1,
+					},
+					'note': {
+						margin: {top: 0, left: 5, right: 5, bottom: 0},
+						padding: {top: 3, left: 3, right: 10, bottom: 3},
+						overlap: {left: 10, right: 10},
+						boxRenderer: svg.noteFactory({
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 2,
+							'stroke-linejoin': 'round',
+						}, {
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+						labelAttrs: NOTE_ATTRS$1,
+					},
+					'state': {
+						margin: {top: 0, left: 5, right: 5, bottom: 0},
+						padding: {top: 5, left: 7, right: 7, bottom: 5},
+						overlap: {left: 10, right: 10},
+						boxRenderer: svg.boxFactory({
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 3,
+							'rx': 10,
+							'ry': 10,
+						}),
+						labelAttrs: NOTE_ATTRS$1,
+					},
+				},
+				dividers: {
+					'': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$1,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: () => ({}),
+					},
+					'line': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$1,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 10,
+						margin: 0,
+						render: this.renderLineDivider.bind(this, {
+							lineAttrs: {
+								'stroke': '#000000',
+								'stroke-width': 2,
+								'stroke-linecap': 'round',
+							},
+						}),
+					},
+					'delay': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$1,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: this.renderDelayDivider.bind(this, {
+							dotSize: 3,
+							gapSize: 3,
+						}),
+					},
+					'tear': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$1,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 10,
+						margin: 10,
+						render: this.renderTearDivider.bind(this, {
+							fadeBegin: 5,
+							fadeSize: 10,
+							zigWidth: 6,
+							zigHeight: 1,
+							lineAttrs: {
+								'stroke': '#000000',
+								'stroke-width': 2,
+								'stroke-linejoin': 'round',
+							},
+						}),
+					},
+				},
+			});
+		}
+	}
+
+	class Factory$1 {
+		constructor() {
+			this.name = 'chunky';
+		}
+
+		build(svg) {
+			return new ChunkyTheme(svg);
+		}
+	}
+
+	class EventObject {
+		constructor() {
+			this.listeners = new Map();
+			this.forwards = new Set();
+		}
+
+		addEventListener(type, callback) {
+			const l = this.listeners.get(type);
+			if(l) {
+				l.push(callback);
+			} else {
+				this.listeners.set(type, [callback]);
+			}
+		}
+
+		removeEventListener(type, fn) {
+			const l = this.listeners.get(type);
+			if(!l) {
+				return;
+			}
+			const i = l.indexOf(fn);
+			if(i !== -1) {
+				l.splice(i, 1);
+			}
+		}
+
+		on(type, fn) {
+			this.addEventListener(type, fn);
+			return this;
+		}
+
+		off(type, fn) {
+			this.removeEventListener(type, fn);
+			return this;
+		}
+
+		countEventListeners(type) {
+			return (this.listeners.get(type) || []).length;
+		}
+
+		removeAllEventListeners(type) {
+			if(type) {
+				this.listeners.delete(type);
+			} else {
+				this.listeners.clear();
+			}
+		}
+
+		addEventForwarding(target) {
+			this.forwards.add(target);
+		}
+
+		removeEventForwarding(target) {
+			this.forwards.delete(target);
+		}
+
+		removeAllEventForwardings() {
+			this.forwards.clear();
+		}
+
+		trigger(type, params = []) {
+			(this.listeners.get(type) || []).forEach(
+				(listener) => listener(...params)
+			);
+			this.forwards.forEach((fwd) => fwd.trigger(type, params));
+		}
+	}
+
+	const nodejs = (typeof window === 'undefined');
+
+	// Thanks, https://stackoverflow.com/a/23522755/1180785
+	const safari = (
+		!nodejs &&
+		(/^((?!chrome|android).)*safari/i).test(window.navigator.userAgent)
+	);
+
+	// Thanks, https://stackoverflow.com/a/9851769/1180785
+	const firefox = (
+		!nodejs &&
+		typeof window.InstallTrigger !== 'undefined'
+	);
+
+	class Exporter {
+		constructor() {
+			this.latestSVG = null;
+			this.latestInternalSVG = null;
+			this.canvas = null;
+			this.context = null;
+			this.indexPNG = 0;
+			this.latestPNGIndex = 0;
+			this.latestPNG = null;
+		}
+
+		getSVGContent(renderer) {
+			let code = renderer.dom().outerHTML;
+
+			/*
+			 * Firefox fails to render SVGs as <img> unless they have size
+			 * attributes on the <svg> tag, so we must set this when
+			 * exporting from any environment, in case it is opened in FireFox
+			 */
+			code = code.replace(
+				(/^<svg/),
+				'<svg width="' + (renderer.width || 1) +
+				'" height="' + (renderer.height || 1) + '" '
+			);
+
+			return code;
+		}
+
+		getSVGBlob(renderer) {
+			return new Blob(
+				[this.getSVGContent(renderer)],
+				{type: 'image/svg+xml'}
+			);
+		}
+
+		getSVGURL(renderer) {
+			const blob = this.getSVGBlob(renderer);
+			if(this.latestSVG) {
+				URL.revokeObjectURL(this.latestSVG);
+			}
+			this.latestSVG = URL.createObjectURL(blob);
+			return this.latestSVG;
+		}
+
+		getCanvas(renderer, resolution, callback) {
+			if(!this.canvas) {
+				window.devicePixelRatio = 1;
+				this.canvas = document.createElement('canvas');
+				this.context = this.canvas.getContext('2d');
+			}
+
+			const width = (renderer.width || 1) * resolution;
+			const height = (renderer.height || 1) * resolution;
+			const img = new Image(width, height);
+			let safariHackaround = null;
+			if(safari) {
+				/*
+				 * Safari fails to resize SVG images unless they are displayed
+				 * on the page somewhere, so we must add it before drawing the
+				 * image. For some reason, doing this inside the load listener
+				 * is too late, so we do it here and do our best to ensure it
+				 * doesn't change the page rendering (display:none fails too)
+				 */
+				safariHackaround = document.createElement('div');
+				safariHackaround.style.position = 'absolute';
+				safariHackaround.style.visibility = 'hidden';
+				safariHackaround.appendChild(img);
+				document.body.appendChild(safariHackaround);
+			}
+
+			const render = () => {
+				this.canvas.width = width;
+				this.canvas.height = height;
+				this.context.drawImage(img, 0, 0, width, height);
+				if(safariHackaround) {
+					document.body.removeChild(safariHackaround);
+				}
+				callback(this.canvas);
+			};
+
+			img.addEventListener('load', () => {
+				if(safariHackaround) {
+					// Wait for custom fonts to load (Safari takes a moment)
+					setTimeout(render, 50);
+				} else {
+					render();
+				}
+			}, {once: true});
+
+			img.src = this.getSVGURL(renderer);
+		}
+
+		getPNGBlob(renderer, resolution, callback) {
+			this.getCanvas(renderer, resolution, (canvas) => {
+				canvas.toBlob(callback, 'image/png');
+			});
+		}
+
+		getPNGURL(renderer, resolution, callback) {
+			++ this.indexPNG;
+			const index = this.indexPNG;
+
+			this.getPNGBlob(renderer, resolution, (blob) => {
+				const url = URL.createObjectURL(blob);
+				const isLatest = index >= this.latestPNGIndex;
+				if(isLatest) {
+					if(this.latestPNG) {
+						URL.revokeObjectURL(this.latestPNG);
+					}
+					this.latestPNG = url;
+					this.latestPNGIndex = index;
+					callback(url, true);
+				} else {
+					callback(url, false);
+					URL.revokeObjectURL(url);
+				}
+			});
+		}
+	}
+
+	function indexOf(list, element, equalityCheck = null) {
+		if(equalityCheck === null) {
+			return list.indexOf(element);
+		}
+		for(let i = 0; i < list.length; ++ i) {
+			if(equalityCheck(list[i], element)) {
+				return i;
+			}
+		}
+		return -1;
+	}
+
+	function mergeSets(target, b = null, equalityCheck = null) {
+		if(!b) {
+			return;
+		}
+		for(let i = 0; i < b.length; ++ i) {
+			if(indexOf(target, b[i], equalityCheck) === -1) {
+				target.push(b[i]);
+			}
+		}
+	}
+
+	function hasIntersection(a, b, equalityCheck = null) {
+		for(let i = 0; i < b.length; ++ i) {
+			if(indexOf(a, b[i], equalityCheck) !== -1) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	function removeAll(target, b = null, equalityCheck = null) {
+		if(!b) {
+			return;
+		}
+		for(let i = 0; i < b.length; ++ i) {
+			const p = indexOf(target, b[i], equalityCheck);
+			if(p !== -1) {
+				target.splice(p, 1);
+			}
+		}
+	}
+
+	function remove(list, item, equalityCheck = null) {
+		const p = indexOf(list, item, equalityCheck);
+		if(p !== -1) {
+			list.splice(p, 1);
+		}
+	}
+
+	function last(list) {
+		return list[list.length - 1];
+	}
+
+	function combineRecur(parts, position, current, target) {
+		if(position >= parts.length) {
+			target.push(current.slice());
+			return;
+		}
+		const choices = parts[position];
+		if(!Array.isArray(choices)) {
+			current.push(choices);
+			combineRecur(parts, position + 1, current, target);
+			current.pop();
+			return;
+		}
+		for(let i = 0; i < choices.length; ++ i) {
+			current.push(choices[i]);
+			combineRecur(parts, position + 1, current, target);
+			current.pop();
+		}
+	}
+
+	function combine(parts) {
+		const target = [];
+		combineRecur(parts, 0, [], target);
+		return target;
+	}
+
+	function flatMap(list, fn) {
+		const result = [];
+		list.forEach((item) => {
+			result.push(...fn(item));
+		});
+		return result;
+	}
+
+	/* eslint-disable max-lines */
+
+	class AgentState {
+		constructor({
+			visible = false,
+			locked = false,
+			blocked = false,
+			highlighted = false,
+			group = null,
+			covered = false,
+		} = {}) {
+			this.visible = visible;
+			this.locked = locked;
+			this.blocked = blocked;
+			this.highlighted = highlighted;
+			this.group = group;
+			this.covered = covered;
+		}
+	}
+	AgentState.LOCKED = new AgentState({locked: true});
+	AgentState.DEFAULT = new AgentState();
+
+	// Agent from Parser: {name, flags}
+	const PAgent = {
+		equals: (a, b) => (a.name === b.name),
+		hasFlag: (flag, has = true) => (pAgent) => (
+			pAgent.flags.includes(flag) === has),
+	};
+
+	// Agent from Generator: {id, formattedLabel, anchorRight}
+	const GAgent = {
+		equals: (a, b) => (a.id === b.id),
+		make: (id, {anchorRight = false, isVirtualSource = false} = {}) => ({
+			anchorRight,
+			id,
+			isVirtualSource,
+			options: [],
+		}),
+		indexOf: (list, gAgent) => indexOf(list, gAgent, GAgent.equals),
+		hasIntersection: (a, b) => hasIntersection(a, b, GAgent.equals),
+		addNearby: (target, reference, item, offset) => {
+			const p = indexOf(target, reference, GAgent.equals);
+			if(p === -1) {
+				target.push(item);
+			} else {
+				target.splice(p + offset, 0, item);
+			}
+		},
+	};
+
+	const NOTE_DEFAULT_G_AGENTS = {
+		'note over': [GAgent.make('['), GAgent.make(']')],
+		'note left': [GAgent.make('[')],
+		'note right': [GAgent.make(']')],
+	};
+
+	const SPECIAL_AGENT_IDS = ['[', ']'];
+
+	const MERGABLE = {
+		'agent begin': {
+			check: ['mode'],
+			merge: ['agentIDs'],
+			siblings: new Set(['agent highlight']),
+		},
+		'agent end': {
+			check: ['mode'],
+			merge: ['agentIDs'],
+			siblings: new Set(['agent highlight']),
+		},
+		'agent highlight': {
+			check: ['highlighted'],
+			merge: ['agentIDs'],
+			siblings: new Set(['agent begin', 'agent end']),
+		},
+	};
+
+	function mergableParallel(target, copy) {
+		const info = MERGABLE[target.type];
+		if(!info || target.type !== copy.type) {
+			return false;
+		}
+		if(info.check.some((c) => target[c] !== copy[c])) {
+			return false;
+		}
+		return true;
+	}
+
+	function performMerge(target, copy) {
+		const info = MERGABLE[target.type];
+		info.merge.forEach((m) => {
+			mergeSets(target[m], copy[m]);
+		});
+	}
+
+	function iterateRemoval(list, fn) {
+		for(let i = 0; i < list.length;) {
+			const rm = fn(list[i], i);
+			if(rm) {
+				list.splice(i, 1);
+			} else {
+				++ i;
+			}
+		}
+	}
+
+	function performParallelMergers(stages) {
+		iterateRemoval(stages, (stage, i) => {
+			for(let j = 0; j < i; ++ j) {
+				if(mergableParallel(stages[j], stage)) {
+					performMerge(stages[j], stage);
+					return true;
+				}
+			}
+			return false;
+		});
+	}
+
+	function findViableSequentialMergers(stages) {
+		const mergers = new Set();
+		const types = stages.map(({type}) => type);
+		types.forEach((type) => {
+			const info = MERGABLE[type];
+			if(!info) {
+				return;
+			}
+			if(types.every((t) => (type === t || info.siblings.has(t)))) {
+				mergers.add(type);
+			}
+		});
+		return mergers;
+	}
+
+	function performSequentialMergers(lastViable, viable, lastStages, stages) {
+		iterateRemoval(stages, (stage) => {
+			if(!lastViable.has(stage.type) || !viable.has(stage.type)) {
+				return false;
+			}
+			for(let j = 0; j < lastStages.length; ++ j) {
+				if(mergableParallel(lastStages[j], stage)) {
+					performMerge(lastStages[j], stage);
+					return true;
+				}
+			}
+			return false;
+		});
+	}
+
+	function optimiseStages(stages) {
+		let lastStages = [];
+		let lastViable = new Set();
+		for(let i = 0; i < stages.length;) {
+			const stage = stages[i];
+			let subStages = null;
+			if(stage.type === 'parallel') {
+				subStages = stage.stages;
+			} else {
+				subStages = [stage];
+			}
+
+			performParallelMergers(subStages);
+			const viable = findViableSequentialMergers(subStages);
+			performSequentialMergers(lastViable, viable, lastStages, subStages);
+
+			if(subStages.length === 0) {
+				stages.splice(i, 1);
+			} else {
+				if(stage.type === 'parallel' && subStages.length === 1) {
+					stages.splice(i, 1, subStages[0]);
+				}
+				lastViable = viable;
+				lastStages = subStages;
+				++ i;
+			}
+		}
+	}
+
+	function swapBegin(stage, mode) {
+		if(stage.type === 'agent begin') {
+			stage.mode = mode;
+			return true;
+		}
+		if(stage.type === 'parallel') {
+			let any = false;
+			stage.stages.forEach((subStage) => {
+				if(subStage.type === 'agent begin') {
+					subStage.mode = mode;
+					any = true;
+				}
+			});
+			return any;
+		}
+		return false;
+	}
+
+	function swapFirstBegin(stages, mode) {
+		for(let i = 0; i < stages.length; ++ i) {
+			if(swapBegin(stages[i], mode)) {
+				break;
+			}
+		}
+	}
+
+	function addBounds(allGAgents, gAgentL, gAgentR, involvedGAgents = null) {
+		remove(allGAgents, gAgentL, GAgent.equals);
+		remove(allGAgents, gAgentR, GAgent.equals);
+
+		let indexL = 0;
+		let indexR = allGAgents.length;
+		if(involvedGAgents) {
+			const found = (involvedGAgents
+				.map((gAgent) => GAgent.indexOf(allGAgents, gAgent))
+				.filter((p) => (p !== -1))
+			);
+			indexL = found.reduce((a, b) => Math.min(a, b), allGAgents.length);
+			indexR = found.reduce((a, b) => Math.max(a, b), indexL) + 1;
+		}
+
+		allGAgents.splice(indexL, 0, gAgentL);
+		allGAgents.splice(indexR + 1, 0, gAgentR);
+
+		return {indexL, indexR: indexR + 1};
+	}
+
+	class Generator {
+		constructor() {
+			this.agentStates = new Map();
+			this.agentAliases = new Map();
+			this.activeGroups = new Map();
+			this.gAgents = [];
+			this.labelPattern = null;
+			this.nextID = 0;
+			this.nesting = [];
+			this.markers = new Set();
+			this.currentSection = null;
+			this.currentNest = null;
+
+			this.stageHandlers = {
+				'block begin': this.handleBlockBegin.bind(this),
+				'block split': this.handleBlockSplit.bind(this),
+				'block end': this.handleBlockEnd.bind(this),
+				'group begin': this.handleGroupBegin.bind(this),
+				'mark': this.handleMark.bind(this),
+				'async': this.handleAsync.bind(this),
+				'agent define': this.handleAgentDefine.bind(this),
+				'agent options': this.handleAgentOptions.bind(this),
+				'agent begin': this.handleAgentBegin.bind(this),
+				'agent end': this.handleAgentEnd.bind(this),
+				'divider': this.handleDivider.bind(this),
+				'label pattern': this.handleLabelPattern.bind(this),
+				'connect': this.handleConnect.bind(this),
+				'connect-delay-begin': this.handleConnectDelayBegin.bind(this),
+				'connect-delay-end': this.handleConnectDelayEnd.bind(this),
+				'note over': this.handleNote.bind(this),
+				'note left': this.handleNote.bind(this),
+				'note right': this.handleNote.bind(this),
+				'note between': this.handleNote.bind(this),
+			};
+			this.expandGroupedGAgent = this.expandGroupedGAgent.bind(this);
+			this.handleStage = this.handleStage.bind(this);
+			this.toGAgent = this.toGAgent.bind(this);
+			this.endGroup = this.endGroup.bind(this);
+		}
+
+		toGAgent({name, alias, flags}) {
+			if(alias) {
+				if(this.agentAliases.has(name)) {
+					throw new Error(
+						'Cannot alias ' + name + '; it is already an alias'
+					);
+				}
+				const old = this.agentAliases.get(alias);
+				if(
+					(old && old !== alias) ||
+					this.gAgents.some((gAgent) => (gAgent.id === alias))
+				) {
+					throw new Error(
+						'Cannot use ' + alias +
+						' as an alias; it is already in use'
+					);
+				}
+				this.agentAliases.set(alias, name);
+			}
+			return GAgent.make(this.agentAliases.get(name) || name, {
+				isVirtualSource: flags.includes('source'),
+			});
+		}
+
+		addStage(stage, isVisible = true) {
+			if(!stage) {
+				return;
+			}
+			if(typeof stage.ln === 'undefined') {
+				stage.ln = this.latestLine;
+			}
+			this.currentSection.stages.push(stage);
+			if(isVisible) {
+				this.currentNest.hasContent = true;
+			}
+		}
+
+		addParallelStages(stages) {
+			const viableStages = stages.filter((stage) => Boolean(stage));
+			if(viableStages.length === 0) {
+				return;
+			}
+			if(viableStages.length === 1) {
+				this.addStage(viableStages[0]);
+				return;
+			}
+			viableStages.forEach((stage) => {
+				if(typeof stage.ln === 'undefined') {
+					stage.ln = this.latestLine;
+				}
+			});
+			this.addStage({
+				type: 'parallel',
+				stages: viableStages,
+			});
+		}
+
+		defineGAgents(gAgents) {
+			mergeSets(
+				this.currentNest.gAgents,
+				gAgents.filter((gAgent) => !SPECIAL_AGENT_IDS.includes(gAgent.id)),
+				GAgent.equals
+			);
+			mergeSets(this.gAgents, gAgents, GAgent.equals);
+		}
+
+		getGAgentState(gAgent) {
+			return this.agentStates.get(gAgent.id) || AgentState.DEFAULT;
+		}
+
+		updateGAgentState(gAgent, change) {
+			const state = this.agentStates.get(gAgent.id);
+			if(state) {
+				Object.assign(state, change);
+			} else {
+				this.agentStates.set(gAgent.id, new AgentState(change));
+			}
+		}
+
+		replaceGAgentState(gAgent, state) {
+			this.agentStates.set(gAgent.id, state);
+		}
+
+		validateGAgents(gAgents, {
+			allowGrouped = false,
+			allowCovered = false,
+			allowVirtual = false,
+		} = {}) {
+			gAgents.forEach((gAgent) => {
+				const state = this.getGAgentState(gAgent);
+				if(state.blocked && state.group === null) {
+					// Used to be a group alias; can never be reused
+					throw new Error('Duplicate agent name: ' + gAgent.id);
+				}
+				if(!allowCovered && state.covered) {
+					throw new Error(
+						'Agent ' + gAgent.id + ' is hidden behind group'
+					);
+				}
+				if(!allowGrouped && state.group !== null) {
+					throw new Error('Agent ' + gAgent.id + ' is in a group');
+				}
+				if(!allowVirtual && gAgent.isVirtualSource) {
+					throw new Error('cannot use message source here');
+				}
+				if(gAgent.id.startsWith('__')) {
+					throw new Error(gAgent.id + ' is a reserved name');
+				}
+			});
+		}
+
+		setGAgentVis(gAgents, visible, mode, checked = false) {
+			const seen = new Set();
+			const filteredGAgents = gAgents.filter((gAgent) => {
+				if(seen.has(gAgent.id)) {
+					return false;
+				}
+				seen.add(gAgent.id);
+				const state = this.getGAgentState(gAgent);
+				if(state.locked || state.blocked) {
+					if(checked) {
+						throw new Error('Cannot begin/end agent: ' + gAgent.id);
+					} else {
+						return false;
+					}
+				}
+				return state.visible !== visible;
+			});
+			if(filteredGAgents.length === 0) {
+				return null;
+			}
+			filteredGAgents.forEach((gAgent) => {
+				this.updateGAgentState(gAgent, {visible});
+			});
+			this.defineGAgents(filteredGAgents);
+
+			return {
+				type: (visible ? 'agent begin' : 'agent end'),
+				agentIDs: filteredGAgents.map((gAgent) => gAgent.id),
+				mode,
+			};
+		}
+
+		setGAgentHighlight(gAgents, highlighted, checked = false) {
+			const filteredGAgents = gAgents.filter((gAgent) => {
+				const state = this.getGAgentState(gAgent);
+				if(state.locked || state.blocked) {
+					if(checked) {
+						throw new Error('Cannot highlight agent: ' + gAgent.id);
+					} else {
+						return false;
+					}
+				}
+				return state.visible && (state.highlighted !== highlighted);
+			});
+			if(filteredGAgents.length === 0) {
+				return null;
+			}
+			filteredGAgents.forEach((gAgent) => {
+				this.updateGAgentState(gAgent, {highlighted});
+			});
+
+			return {
+				type: 'agent highlight',
+				agentIDs: filteredGAgents.map((gAgent) => gAgent.id),
+				highlighted,
+			};
+		}
+
+		_makeSection(header, stages) {
+			return {
+				header,
+				delayedConnections: new Map(),
+				stages,
+			};
+		}
+
+		_checkSectionEnd() {
+			const dcs = this.currentSection.delayedConnections;
+			if(dcs.size > 0) {
+				const dc = dcs.values().next().value;
+				throw new Error(
+					'Unused delayed connection "' + dc.tag +
+					'" at line ' + (dc.ln + 1)
+				);
+			}
+		}
+
+		beginNested(blockType, {tag, label, name, ln}) {
+			const leftGAgent = GAgent.make(name + '[', {anchorRight: true});
+			const rightGAgent = GAgent.make(name + ']');
+			const gAgents = [leftGAgent, rightGAgent];
+			const stages = [];
+			this.currentSection = this._makeSection({
+				type: 'block begin',
+				blockType,
+				tag: this.textFormatter(tag),
+				label: this.textFormatter(label),
+				canHide: true,
+				left: leftGAgent.id,
+				right: rightGAgent.id,
+				ln,
+			}, stages);
+			this.currentNest = {
+				blockType,
+				gAgents,
+				leftGAgent,
+				rightGAgent,
+				hasContent: false,
+				sections: [this.currentSection],
+			};
+			this.replaceGAgentState(leftGAgent, AgentState.LOCKED);
+			this.replaceGAgentState(rightGAgent, AgentState.LOCKED);
+			this.nesting.push(this.currentNest);
+
+			return {stages};
+		}
+
+		nextBlockName() {
+			const name = '__BLOCK' + this.nextID;
+			++ this.nextID;
+			return name;
+		}
+
+		nextVirtualAgentName() {
+			const name = '__' + this.nextID;
+			++ this.nextID;
+			return name;
+		}
+
+		handleBlockBegin({ln, blockType, tag, label}) {
+			this.beginNested(blockType, {
+				tag,
+				label,
+				name: this.nextBlockName(),
+				ln,
+			});
+		}
+
+		handleBlockSplit({ln, blockType, tag, label}) {
+			if(this.currentNest.blockType !== 'if') {
+				throw new Error(
+					'Invalid block nesting ("else" inside ' +
+					this.currentNest.blockType + ')'
+				);
+			}
+			this._checkSectionEnd();
+			this.currentSection = this._makeSection({
+				type: 'block split',
+				blockType,
+				tag: this.textFormatter(tag),
+				label: this.textFormatter(label),
+				left: this.currentNest.leftGAgent.id,
+				right: this.currentNest.rightGAgent.id,
+				ln,
+			}, []);
+			this.currentNest.sections.push(this.currentSection);
+		}
+
+		handleBlockEnd() {
+			if(this.nesting.length <= 1) {
+				throw new Error('Invalid block nesting (too many "end"s)');
+			}
+			this._checkSectionEnd();
+			const nested = this.nesting.pop();
+			this.currentNest = last(this.nesting);
+			this.currentSection = last(this.currentNest.sections);
+
+			if(nested.hasContent) {
+				this.defineGAgents(nested.gAgents);
+				addBounds(
+					this.gAgents,
+					nested.leftGAgent,
+					nested.rightGAgent,
+					nested.gAgents
+				);
+				nested.sections.forEach((section) => {
+					this.currentSection.stages.push(section.header);
+					this.currentSection.stages.push(...section.stages);
+				});
+				this.addStage({
+					type: 'block end',
+					left: nested.leftGAgent.id,
+					right: nested.rightGAgent.id,
+				});
+			} else {
+				throw new Error('Empty block');
+			}
+		}
+
+		makeGroupDetails(pAgents, alias) {
+			const gAgents = pAgents.map(this.toGAgent);
+			this.validateGAgents(gAgents);
+			if(this.agentStates.has(alias)) {
+				throw new Error('Duplicate agent name: ' + alias);
+			}
+			const name = this.nextBlockName();
+			const leftGAgent = GAgent.make(name + '[', {anchorRight: true});
+			const rightGAgent = GAgent.make(name + ']');
+			this.replaceGAgentState(leftGAgent, AgentState.LOCKED);
+			this.replaceGAgentState(rightGAgent, AgentState.LOCKED);
+			this.updateGAgentState(
+				GAgent.make(alias),
+				{blocked: true, group: alias}
+			);
+			this.defineGAgents([...gAgents, leftGAgent, rightGAgent]);
+			const {indexL, indexR} = addBounds(
+				this.gAgents,
+				leftGAgent,
+				rightGAgent,
+				gAgents
+			);
+
+			const gAgentsCovered = [];
+			const gAgentsContained = gAgents.slice();
+			for(let i = indexL + 1; i < indexR; ++ i) {
+				gAgentsCovered.push(this.gAgents[i]);
+			}
+			removeAll(gAgentsCovered, gAgentsContained, GAgent.equals);
+
+			return {
+				gAgents,
+				leftGAgent,
+				rightGAgent,
+				gAgentsContained,
+				gAgentsCovered,
+			};
+		}
+
+		handleGroupBegin({agents, blockType, tag, label, alias}) {
+			const details = this.makeGroupDetails(agents, alias);
+
+			details.gAgentsContained.forEach((gAgent) => {
+				this.updateGAgentState(gAgent, {group: alias});
+			});
+			details.gAgentsCovered.forEach((gAgent) => {
+				this.updateGAgentState(gAgent, {covered: true});
+			});
+			this.activeGroups.set(alias, details);
+			this.addStage(this.setGAgentVis(details.gAgents, true, 'box'));
+			this.addStage({
+				type: 'block begin',
+				blockType,
+				tag: this.textFormatter(tag),
+				canHide: false,
+				label: this.textFormatter(label),
+				left: details.leftGAgent.id,
+				right: details.rightGAgent.id,
+			});
+		}
+
+		endGroup({name}) {
+			const details = this.activeGroups.get(name);
+			if(!details) {
+				return null;
+			}
+			this.activeGroups.delete(name);
+
+			details.gAgentsContained.forEach((gAgent) => {
+				this.updateGAgentState(gAgent, {group: null});
+			});
+			details.gAgentsCovered.forEach((gAgent) => {
+				this.updateGAgentState(gAgent, {covered: false});
+			});
+			this.updateGAgentState(GAgent.make(name), {group: null});
+
+			return {
+				type: 'block end',
+				left: details.leftGAgent.id,
+				right: details.rightGAgent.id,
+			};
+		}
+
+		handleMark({name}) {
+			this.markers.add(name);
+			this.addStage({type: 'mark', name}, false);
+		}
+
+		handleDivider({mode, height, label}) {
+			this.addStage({
+				type: 'divider',
+				mode,
+				height,
+				formattedLabel: this.textFormatter(label),
+			}, false);
+		}
+
+		handleAsync({target}) {
+			if(target !== '' && !this.markers.has(target)) {
+				throw new Error('Unknown marker: ' + target);
+			}
+			this.addStage({type: 'async', target}, false);
+		}
+
+		handleLabelPattern({pattern}) {
+			this.labelPattern = pattern.slice();
+			for(let i = 0; i < this.labelPattern.length; ++ i) {
+				const part = this.labelPattern[i];
+				if(typeof part === 'object' && typeof part.start !== 'undefined') {
+					this.labelPattern[i] = Object.assign({
+						current: part.start,
+					}, part);
+				}
+			}
+		}
+
+		applyLabelPattern(label) {
+			let result = '';
+			const tokens = {label};
+			this.labelPattern.forEach((part) => {
+				if(typeof part === 'string') {
+					result += part;
+				} else if(typeof part.token !== 'undefined') {
+					result += tokens[part.token];
+				} else if(typeof part.current !== 'undefined') {
+					result += part.current.toFixed(part.dp);
+					part.current += part.inc;
+				}
+			});
+			return result;
+		}
+
+		expandGroupedGAgent(gAgent) {
+			const {group} = this.getGAgentState(gAgent);
+			if(!group) {
+				return [gAgent];
+			}
+			const details = this.activeGroups.get(group);
+			return [details.leftGAgent, details.rightGAgent];
+		}
+
+		expandGroupedGAgentConnection(gAgents) {
+			const gAgents1 = this.expandGroupedGAgent(gAgents[0]);
+			const gAgents2 = this.expandGroupedGAgent(gAgents[1]);
+			let ind1 = GAgent.indexOf(this.gAgents, gAgents1[0]);
+			let ind2 = GAgent.indexOf(this.gAgents, gAgents2[0]);
+			if(ind1 === -1) {
+				/*
+				 * Virtual sources written as '* -> Ref' will spawn to the left,
+				 * not the right (as non-virtual agents would)
+				 */
+				ind1 = gAgents1[0].isVirtualSource ? -1 : this.gAgents.length;
+			}
+			if(ind2 === -1) {
+				/*
+				 * Virtual and non-virtual agents written as 'Ref -> *' will
+				 * spawn to the right
+				 */
+				ind2 = this.gAgents.length;
+			}
+			if(ind1 === ind2) {
+				// Self-connection
+				return [last(gAgents1), last(gAgents2)];
+			} else if(ind1 < ind2) {
+				return [last(gAgents1), gAgents2[0]];
+			} else {
+				return [gAgents1[0], last(gAgents2)];
+			}
+		}
+
+		filterConnectFlags(pAgents) {
+			const beginGAgents = (pAgents
+				.filter(PAgent.hasFlag('begin'))
+				.map(this.toGAgent)
+			);
+			const endGAgents = (pAgents
+				.filter(PAgent.hasFlag('end'))
+				.map(this.toGAgent)
+			);
+			if(GAgent.hasIntersection(beginGAgents, endGAgents)) {
+				throw new Error('Cannot set agent visibility multiple times');
+			}
+
+			const startGAgents = (pAgents
+				.filter(PAgent.hasFlag('start'))
+				.map(this.toGAgent)
+			);
+			const stopGAgents = (pAgents
+				.filter(PAgent.hasFlag('stop'))
+				.map(this.toGAgent)
+			);
+			mergeSets(stopGAgents, endGAgents);
+			if(GAgent.hasIntersection(startGAgents, stopGAgents)) {
+				throw new Error('Cannot set agent highlighting multiple times');
+			}
+
+			this.validateGAgents(beginGAgents);
+			this.validateGAgents(endGAgents);
+			this.validateGAgents(startGAgents);
+			this.validateGAgents(stopGAgents);
+
+			return {beginGAgents, endGAgents, startGAgents, stopGAgents};
+		}
+
+		makeVirtualAgent(anchorRight) {
+			const virtualGAgent = GAgent.make(this.nextVirtualAgentName(), {
+				anchorRight,
+				isVirtualSource: true,
+			});
+			this.replaceGAgentState(virtualGAgent, AgentState.LOCKED);
+			return virtualGAgent;
+		}
+
+		addNearbyAgent(gAgentReference, gAgent, offset) {
+			GAgent.addNearby(
+				this.currentNest.gAgents,
+				gAgentReference,
+				gAgent,
+				offset
+			);
+			GAgent.addNearby(
+				this.gAgents,
+				gAgentReference,
+				gAgent,
+				offset
+			);
+		}
+
+		expandVirtualSourceAgents(gAgents) {
+			if(gAgents[0].isVirtualSource) {
+				if(gAgents[1].isVirtualSource) {
+					throw new Error('Cannot connect found messages');
+				}
+				if(SPECIAL_AGENT_IDS.includes(gAgents[1].id)) {
+					throw new Error(
+						'Cannot connect found messages to special agents'
+					);
+				}
+				const virtualGAgent = this.makeVirtualAgent(true);
+				this.addNearbyAgent(gAgents[1], virtualGAgent, 0);
+				return [virtualGAgent, gAgents[1]];
+			}
+			if(gAgents[1].isVirtualSource) {
+				if(SPECIAL_AGENT_IDS.includes(gAgents[0].id)) {
+					throw new Error(
+						'Cannot connect found messages to special agents'
+					);
+				}
+				const virtualGAgent = this.makeVirtualAgent(false);
+				this.addNearbyAgent(gAgents[0], virtualGAgent, 1);
+				return [gAgents[0], virtualGAgent];
+			}
+			return gAgents;
+		}
+
+		_handlePartialConnect(agents) {
+			const flags = this.filterConnectFlags(agents);
+
+			const gAgents = agents.map(this.toGAgent);
+			this.validateGAgents(gAgents, {
+				allowGrouped: true,
+				allowVirtual: true,
+			});
+
+			this.defineGAgents(flatMap(gAgents, this.expandGroupedGAgent)
+				.filter((gAgent) => !gAgent.isVirtualSource));
+
+			const implicitBeginGAgents = (agents
+				.filter(PAgent.hasFlag('begin', false))
+				.map(this.toGAgent)
+				.filter((gAgent) => !gAgent.isVirtualSource)
+			);
+			this.addStage(this.setGAgentVis(implicitBeginGAgents, true, 'box'));
+
+			return {flags, gAgents};
+		}
+
+		_makeConnectParallelStages(flags, connectStage) {
+			return [
+				this.setGAgentVis(flags.beginGAgents, true, 'box', true),
+				this.setGAgentHighlight(flags.startGAgents, true, true),
+				connectStage,
+				this.setGAgentHighlight(flags.stopGAgents, false, true),
+				this.setGAgentVis(flags.endGAgents, false, 'cross', true),
+			];
+		}
+
+		_isSelfConnect(agents) {
+			const gAgents = agents.map(this.toGAgent);
+			const expandedGAgents = this.expandGroupedGAgentConnection(gAgents);
+			if(expandedGAgents[0].id !== expandedGAgents[1].id) {
+				return false;
+			}
+			if(expandedGAgents.some((gAgent) => gAgent.isVirtualSource)) {
+				return false;
+			}
+			return true;
+		}
+
+		handleConnect({agents, label, options}) {
+			if(this._isSelfConnect(agents)) {
+				const tag = {};
+				this.handleConnectDelayBegin({
+					agent: agents[0],
+					tag,
+					options,
+					ln: 0,
+				});
+				this.handleConnectDelayEnd({
+					agent: agents[1],
+					tag,
+					label,
+					options,
+				});
+				return;
+			}
+
+			let {flags, gAgents} = this._handlePartialConnect(agents);
+
+			gAgents = this.expandGroupedGAgentConnection(gAgents);
+			gAgents = this.expandVirtualSourceAgents(gAgents);
+
+			const connectStage = {
+				type: 'connect',
+				agentIDs: gAgents.map((gAgent) => gAgent.id),
+				label: this.textFormatter(this.applyLabelPattern(label)),
+				options,
+			};
+
+			this.addParallelStages(this._makeConnectParallelStages(
+				flags,
+				connectStage
+			));
+		}
+
+		handleConnectDelayBegin({agent, tag, options, ln}) {
+			const dcs = this.currentSection.delayedConnections;
+			if(dcs.has(tag)) {
+				throw new Error('Duplicate delayed connection "' + tag + '"');
+			}
+
+			const {flags, gAgents} = this._handlePartialConnect([agent]);
+			const uniqueTag = this.nextVirtualAgentName();
+
+			const connectStage = {
+				type: 'connect-delay-begin',
+				tag: uniqueTag,
+				agentIDs: null,
+				label: null,
+				options,
+			};
+
+			dcs.set(tag, {tag, uniqueTag, ln, gAgents, connectStage});
+
+			this.addParallelStages(this._makeConnectParallelStages(
+				flags,
+				connectStage
+			));
+		}
+
+		handleConnectDelayEnd({agent, tag, label, options}) {
+			const dcs = this.currentSection.delayedConnections;
+			const dcInfo = dcs.get(tag);
+			if(!dcInfo) {
+				throw new Error('Unknown delayed connection "' + tag + '"');
+			}
+
+			let {flags, gAgents} = this._handlePartialConnect([agent]);
+
+			gAgents = this.expandGroupedGAgentConnection([
+				...dcInfo.gAgents,
+				...gAgents,
+			]);
+			gAgents = this.expandVirtualSourceAgents(gAgents);
+
+			let combinedOptions = dcInfo.connectStage.options;
+			if(combinedOptions.line !== options.line) {
+				throw new Error('Mismatched delayed connection arrows');
+			}
+			if(options.right) {
+				combinedOptions = Object.assign({}, combinedOptions, {
+					right: options.right,
+				});
+			}
+
+			Object.assign(dcInfo.connectStage, {
+				agentIDs: gAgents.map((gAgent) => gAgent.id),
+				label: this.textFormatter(this.applyLabelPattern(label)),
+				options: combinedOptions,
+			});
+
+			const connectEndStage = {
+				type: 'connect-delay-end',
+				tag: dcInfo.uniqueTag,
+			};
+
+			this.addParallelStages(this._makeConnectParallelStages(
+				flags,
+				connectEndStage
+			));
+
+			dcs.delete(tag);
+		}
+
+		handleNote({type, agents, mode, label}) {
+			let gAgents = null;
+			if(agents.length === 0) {
+				gAgents = NOTE_DEFAULT_G_AGENTS[type] || [];
+			} else {
+				gAgents = agents.map(this.toGAgent);
+			}
+
+			this.validateGAgents(gAgents, {allowGrouped: true});
+			gAgents = flatMap(gAgents, this.expandGroupedGAgent);
+			const agentIDs = gAgents.map((gAgent) => gAgent.id);
+			const uniqueAgents = new Set(agentIDs).size;
+			if(type === 'note between' && uniqueAgents < 2) {
+				throw new Error('note between requires at least 2 agents');
+			}
+
+			this.addStage(this.setGAgentVis(gAgents, true, 'box'));
+			this.defineGAgents(gAgents);
+
+			this.addStage({
+				type,
+				agentIDs,
+				mode,
+				label: this.textFormatter(label),
+			});
+		}
+
+		handleAgentDefine({agents}) {
+			const gAgents = agents.map(this.toGAgent);
+			this.validateGAgents(gAgents, {
+				allowGrouped: true,
+				allowCovered: true,
+			});
+			mergeSets(this.gAgents, gAgents, GAgent.equals);
+		}
+
+		handleAgentOptions({agent, options}) {
+			const gAgent = this.toGAgent(agent);
+			const gAgents = [gAgent];
+			this.validateGAgents(gAgents, {
+				allowGrouped: true,
+				allowCovered: true,
+			});
+			mergeSets(this.gAgents, gAgents, GAgent.equals);
+
+			this.gAgents
+				.filter(({id}) => (id === gAgent.id))
+				.forEach((storedGAgent) => {
+					mergeSets(storedGAgent.options, options);
+				});
+		}
+
+		handleAgentBegin({agents, mode}) {
+			const gAgents = agents.map(this.toGAgent);
+			this.validateGAgents(gAgents);
+			this.addStage(this.setGAgentVis(gAgents, true, mode, true));
+		}
+
+		handleAgentEnd({agents, mode}) {
+			const groupPAgents = (agents
+				.filter((pAgent) => this.activeGroups.has(pAgent.name))
+			);
+			const gAgents = (agents
+				.filter((pAgent) => !this.activeGroups.has(pAgent.name))
+				.map(this.toGAgent)
+			);
+			this.validateGAgents(gAgents);
+			this.addParallelStages([
+				this.setGAgentHighlight(gAgents, false),
+				this.setGAgentVis(gAgents, false, mode, true),
+				...groupPAgents.map(this.endGroup),
+			]);
+		}
+
+		handleStage(stage) {
+			this.latestLine = stage.ln;
+			try {
+				const handler = this.stageHandlers[stage.type];
+				if(!handler) {
+					throw new Error('Unknown command: ' + stage.type);
+				}
+				handler(stage);
+			} catch(e) {
+				if(typeof e === 'object' && e.message) {
+					e.message += ' at line ' + (stage.ln + 1);
+					throw e;
+				}
+			}
+		}
+
+		_reset() {
+			this.agentStates.clear();
+			this.markers.clear();
+			this.agentAliases.clear();
+			this.activeGroups.clear();
+			this.gAgents.length = 0;
+			this.nextID = 0;
+			this.nesting.length = 0;
+			this.labelPattern = [{token: 'label'}];
+		}
+
+		_finalise(globals) {
+			addBounds(
+				this.gAgents,
+				this.currentNest.leftGAgent,
+				this.currentNest.rightGAgent
+			);
+			optimiseStages(globals.stages);
+
+			this.gAgents.forEach((gAgent) => {
+				gAgent.formattedLabel = this.textFormatter(gAgent.id);
+			});
+		}
+
+		generate({stages, meta = {}}) {
+			this._reset();
+
+			this.textFormatter = meta.textFormatter;
+			const globals = this.beginNested('global', {
+				tag: '',
+				label: '',
+				name: '',
+				ln: 0,
+			});
+
+			stages.forEach(this.handleStage);
+
+			if(this.nesting.length !== 1) {
+				throw new Error(
+					'Unterminated section at line ' +
+					(this.currentSection.header.ln + 1)
+				);
+			}
+			if(this.activeGroups.size > 0) {
+				throw new Error('Unterminated group');
+			}
+
+			this._checkSectionEnd();
+
+			const terminators = meta.terminators || 'none';
+			this.addParallelStages([
+				this.setGAgentHighlight(this.gAgents, false),
+				this.setGAgentVis(this.gAgents, false, terminators),
+			]);
+
+			this._finalise(globals);
+
+			swapFirstBegin(globals.stages, meta.headers || 'box');
+
+			return {
+				meta: {
+					title: this.textFormatter(meta.title),
+					theme: meta.theme,
+					code: meta.code,
+				},
+				agents: this.gAgents.slice(),
+				stages: globals.stages,
+			};
+		}
+	}
+
+	/* eslint-disable sort-keys */ // Maybe later
+
+	const FONT$2 = 'monospace';
+	const LINE_HEIGHT$2 = 1.3;
+
+	const WAVE$2 = new WavePattern(6, [
+		+0,
+		-0.25,
+		-0.5,
+		-0.25,
+		+0,
+		+0.25,
+		+0.5,
+		+0.25,
+	]);
+
+	const NOTE_ATTRS$2 = {
+		'font-family': FONT$2,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT$2,
+	};
+
+	const DIVIDER_LABEL_ATTRS$2 = {
+		'font-family': FONT$2,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT$2,
+		'text-anchor': 'middle',
+	};
+
+	class MonospaceTheme extends BaseTheme {
+		constructor(svg) {
+			super(svg);
+
+			const sharedBlockSection = {
+				padding: {
+					top: 3,
+					bottom: 2,
+				},
+				tag: {
+					padding: {
+						top: 2,
+						left: 4,
+						right: 4,
+						bottom: 2,
+					},
+					boxRenderer: this.renderTag.bind(this, {
+						'fill': '#FFFFFF',
+						'stroke': '#000000',
+						'stroke-width': 1,
+						'rx': 3,
+						'ry': 3,
+					}),
+					labelAttrs: {
+						'font-family': FONT$2,
+						'font-weight': 'bold',
+						'font-size': 9,
+						'line-height': LINE_HEIGHT$2,
+						'text-anchor': 'left',
+					},
+				},
+				label: {
+					minHeight: 8,
+					padding: {
+						top: 2,
+						left: 8,
+						right: 8,
+						bottom: 2,
+					},
+					labelAttrs: {
+						'font-family': FONT$2,
+						'font-size': 8,
+						'line-height': LINE_HEIGHT$2,
+						'text-anchor': 'left',
+					},
+				},
+			};
+
+			Object.assign(this, {
+				titleMargin: 8,
+				outerMargin: 4,
+				agentMargin: 12,
+				actionMargin: 12,
+				minActionMargin: 4,
+				agentLineHighlightRadius: 4,
+
+				agentCap: {
+					box: {
+						padding: {
+							top: 4,
+							left: 8,
+							right: 8,
+							bottom: 4,
+						},
+						arrowBottom: 12,
+						boxAttrs: {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						},
+						labelAttrs: {
+							'font-family': FONT$2,
+							'font-size': 12,
+							'line-height': LINE_HEIGHT$2,
+							'text-anchor': 'middle',
+						},
+					},
+					database: {
+						padding: {
+							top: 9,
+							left: 8,
+							right: 8,
+							bottom: 3,
+						},
+						arrowBottom: 12,
+						boxRenderer: this.renderDB.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+							'db-z': 4,
+						}),
+						labelAttrs: {
+							'font-family': FONT$2,
+							'font-size': 12,
+							'line-height': LINE_HEIGHT$2,
+							'text-anchor': 'middle',
+						},
+					},
+					cross: {
+						size: 16,
+						render: svg.crossFactory({
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+					},
+					bar: {
+						height: 4,
+						render: svg.boxFactory({
+							'fill': '#000000',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+					},
+					fade: {
+						width: 5,
+						height: 8,
+						extend: 1,
+					},
+					none: {
+						height: 8,
+					},
+				},
+
+				connect: {
+					loopbackRadius: 4,
+					line: {
+						'solid': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+							},
+							renderFlat: this.renderFlatConnect.bind(this, null),
+							renderRev: this.renderRevConnect.bind(this, null),
+						},
+						'dash': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+								'stroke-dasharray': '4, 4',
+							},
+							renderFlat: this.renderFlatConnect.bind(this, null),
+							renderRev: this.renderRevConnect.bind(this, null),
+						},
+						'wave': {
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+							},
+							renderFlat: this.renderFlatConnect.bind(this, WAVE$2),
+							renderRev: this.renderRevConnect.bind(this, WAVE$2),
+						},
+					},
+					arrow: {
+						'single': {
+							width: 4,
+							height: 8,
+							render: this.renderArrowHead.bind(this),
+							attrs: {
+								'fill': '#000000',
+								'stroke-width': 0,
+								'stroke-linejoin': 'miter',
+							},
+						},
+						'double': {
+							width: 3,
+							height: 6,
+							render: this.renderArrowHead.bind(this),
+							attrs: {
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+								'stroke-linejoin': 'miter',
+							},
+						},
+						'cross': {
+							short: 8,
+							radius: 4,
+							render: svg.crossFactory({
+								'fill': 'none',
+								'stroke': '#000000',
+								'stroke-width': 1,
+							}),
+						},
+					},
+					label: {
+						padding: 4,
+						margin: {top: 2, bottom: 1},
+						attrs: {
+							'font-family': FONT$2,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT$2,
+							'text-anchor': 'middle',
+						},
+						loopbackAttrs: {
+							'font-family': FONT$2,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT$2,
+						},
+					},
+					source: {
+						radius: 2,
+						render: svg.circleFactory({
+							'fill': '#000000',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+					},
+					mask: {
+						padding: {
+							top: 0,
+							left: 3,
+							right: 3,
+							bottom: 1,
+						},
+					},
+				},
+
+				titleAttrs: {
+					'font-family': FONT$2,
+					'font-size': 20,
+					'line-height': LINE_HEIGHT$2,
+					'text-anchor': 'middle',
+					'class': 'title',
+				},
+
+				agentLineAttrs: {
+					'': {
+						'fill': 'none',
+						'stroke': '#000000',
+						'stroke-width': 1,
+					},
+					'red': {
+						'stroke': '#AA0000',
+					},
+				},
+				blocks: {
+					'ref': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: this.renderRef.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 2,
+						}),
+						section: sharedBlockSection,
+					},
+					'': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: svg.boxFactory({
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 2,
+						}),
+						collapsedBoxRenderer: this.renderRef.bind(this, {
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 2,
+						}),
+						section: sharedBlockSection,
+						sepRenderer: svg.lineFactory({
+							'stroke': '#000000',
+							'stroke-width': 2,
+							'stroke-dasharray': '8, 4',
+						}),
+					},
+				},
+				notes: {
+					'text': {
+						margin: {top: 0, left: 8, right: 8, bottom: 0},
+						padding: {top: 4, left: 4, right: 4, bottom: 4},
+						overlap: {left: 8, right: 8},
+						boxRenderer: svg.boxFactory({
+							'fill': '#FFFFFF',
+						}),
+						labelAttrs: NOTE_ATTRS$2,
+					},
+					'note': {
+						margin: {top: 0, left: 8, right: 8, bottom: 0},
+						padding: {top: 8, left: 8, right: 8, bottom: 8},
+						overlap: {left: 8, right: 8},
+						boxRenderer: svg.noteFactory({
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}, {
+							'fill': 'none',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+						labelAttrs: NOTE_ATTRS$2,
+					},
+					'state': {
+						margin: {top: 0, left: 8, right: 8, bottom: 0},
+						padding: {top: 8, left: 8, right: 8, bottom: 8},
+						overlap: {left: 8, right: 8},
+						boxRenderer: svg.boxFactory({
+							'fill': '#FFFFFF',
+							'stroke': '#000000',
+							'stroke-width': 1,
+							'rx': 8,
+							'ry': 8,
+						}),
+						labelAttrs: NOTE_ATTRS$2,
+					},
+				},
+				dividers: {
+					'': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$2,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: () => ({}),
+					},
+					'line': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$2,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 8,
+						margin: 0,
+						render: this.renderLineDivider.bind(this, {
+							lineAttrs: {
+								'stroke': '#000000',
+							},
+						}),
+					},
+					'delay': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$2,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: this.renderDelayDivider.bind(this, {
+							dotSize: 2,
+							gapSize: 2,
+						}),
+					},
+					'tear': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$2,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 8,
+						margin: 8,
+						render: this.renderTearDivider.bind(this, {
+							fadeBegin: 4,
+							fadeSize: 4,
+							zigWidth: 4,
+							zigHeight: 1,
+							lineAttrs: {
+								'stroke': '#000000',
+							},
+						}),
+					},
+				},
+			});
+		}
+	}
+
+	class Factory$2 {
+		constructor() {
+			this.name = 'monospace';
+		}
+
+		build(svg) {
+			return new MonospaceTheme(svg);
+		}
+	}
+
+	/* eslint-disable max-lines */
+
+	const CM_ERROR = {type: 'error line-error', suggest: false, then: {'': 0}};
+
+	function textTo(exit, suggest = false) {
+		return {
+			type: 'string',
+			suggest,
+			then: Object.assign({'': 0}, exit),
+		};
+	}
+
+	function suggestionsEqual(a, b) {
+		return (
+			(a.v === b.v) &&
+			(a.prefix === b.prefix) &&
+			(a.suffix === b.suffix) &&
+			(a.q === b.q)
+		);
+	}
+
+	const AGENT_INFO_TYPES = [
+		'database',
+		'red',
+	];
+
+	const makeCommands = ((() => {
+		/*
+		 * The order of commands inside "then" blocks directly influences the
+		 * order they are displayed to the user in autocomplete menus.
+		 * This relies on the fact that common JS engines maintain insertion
+		 * order in objects, though this is not guaranteed. It could be switched
+		 * to use Map objects instead for strict compliance, at the cost of
+		 * extra syntax.
+		 */
+
+		function agentListTo(exit, next = 1) {
+			return {
+				type: 'variable',
+				suggest: {known: 'Agent'},
+				then: Object.assign({}, exit, {
+					'': 0,
+					',': {type: 'operator', then: {'': next}},
+				}),
+			};
+		}
+
+		const end = {type: '', suggest: '\n', then: {}};
+		const hiddenEnd = {type: '', suggest: false, then: {}};
+		const textToEnd = textTo({'\n': end});
+		const colonTextToEnd = {
+			type: 'operator',
+			then: {'': textToEnd, '\n': hiddenEnd},
+		};
+		const aliasListToEnd = agentListTo({
+			'\n': end,
+			'as': {type: 'keyword', then: {
+				'': {type: 'variable', suggest: {known: 'Agent'}, then: {
+					'': 0,
+					',': {type: 'operator', then: {'': 3}},
+					'\n': end,
+				}},
+			}},
+		});
+		const agentListToText = agentListTo({':': colonTextToEnd});
+
+		const agentToOptText = {
+			type: 'variable',
+			suggest: {known: 'Agent'},
+			then: {
+				'': 0,
+				':': {type: 'operator', then: {
+					'': textToEnd,
+					'\n': hiddenEnd,
+				}},
+				'\n': end,
+			},
+		};
+		const referenceName = {
+			':': {type: 'operator', then: {
+				'': textTo({
+					'as': {type: 'keyword', then: {
+						'': {
+							type: 'variable',
+							suggest: {known: 'Agent'},
+							then: {
+								'': 0,
+								'\n': end,
+							},
+						},
+					}},
+				}),
+			}},
+		};
+		const refDef = {type: 'keyword', then: Object.assign({
+			'over': {type: 'keyword', then: {
+				'': agentListTo(referenceName),
+			}},
+		}, referenceName)};
+
+		const divider = {
+			'\n': end,
+			':': {type: 'operator', then: {
+				'': textToEnd,
+				'\n': hiddenEnd,
+			}},
+			'with': {type: 'keyword', suggest: ['with height '], then: {
+				'height': {type: 'keyword', then: {
+					'': {type: 'number', suggest: ['6 ', '30 '], then: {
+						'\n': end,
+						':': {type: 'operator', then: {
+							'': textToEnd,
+							'\n': hiddenEnd,
+						}},
+					}},
+				}},
+			}},
+		};
+
+		function simpleList(type, keywords, exit) {
+			const first = {};
+			const recur = Object.assign({}, exit);
+
+			keywords.forEach((keyword) => {
+				first[keyword] = {type, then: recur};
+				recur[keyword] = 0;
+			});
+
+			return first;
+		}
+
+		function optionalKeywords(type, keywords, then) {
+			const result = Object.assign({}, then);
+			keywords.forEach((keyword) => {
+				result[keyword] = {type, then};
+			});
+			return result;
+		}
+
+		const agentInfoList = optionalKeywords(
+			'keyword',
+			['a', 'an'],
+			simpleList('keyword', AGENT_INFO_TYPES, {'\n': end})
+		);
+
+		function makeSideNote(side) {
+			return {
+				type: 'keyword',
+				suggest: [side + ' of ', side + ': '],
+				then: {
+					'of': {type: 'keyword', then: {
+						'': agentListToText,
+					}},
+					':': {type: 'operator', then: {
+						'': textToEnd,
+					}},
+					'': agentListToText,
+				},
+			};
+		}
+
+		function makeOpBlock({exit, sourceExit, blankExit}) {
+			const op = {type: 'operator', then: {
+				'+': CM_ERROR,
+				'-': CM_ERROR,
+				'*': CM_ERROR,
+				'!': CM_ERROR,
+				'': exit,
+			}};
+			return {
+				'+': {type: 'operator', then: {
+					'+': CM_ERROR,
+					'-': CM_ERROR,
+					'*': op,
+					'!': CM_ERROR,
+					'': exit,
+				}},
+				'-': {type: 'operator', then: {
+					'+': CM_ERROR,
+					'-': CM_ERROR,
+					'*': op,
+					'!': {type: 'operator', then: {
+						'+': CM_ERROR,
+						'-': CM_ERROR,
+						'*': CM_ERROR,
+						'!': CM_ERROR,
+						'': exit,
+					}},
+					'': exit,
+				}},
+				'*': {type: 'operator', then: Object.assign({
+					'+': op,
+					'-': op,
+					'*': CM_ERROR,
+					'!': CM_ERROR,
+					'': exit,
+				}, sourceExit || exit)},
+				'!': op,
+				'': blankExit || exit,
+			};
+		}
+
+		function makeCMConnect(arrows) {
+			const connect = {
+				type: 'keyword',
+				then: Object.assign({}, makeOpBlock({
+					exit: agentToOptText,
+					sourceExit: {
+						':': colonTextToEnd,
+						'\n': hiddenEnd,
+					},
+				}), {
+					'...': {type: 'operator', then: {
+						'': {
+							type: 'variable',
+							suggest: {known: 'DelayedAgent'},
+							then: {
+								'': 0,
+								':': CM_ERROR,
+								'\n': end,
+							},
+						},
+					}},
+				}),
+			};
+
+			const connectors = {};
+			arrows.forEach((arrow) => (connectors[arrow] = connect));
+
+			const labelIndicator = {
+				type: 'operator',
+				override: 'Label',
+				then: {},
+			};
+
+			const hiddenLabelIndicator = {
+				type: 'operator',
+				suggest: false,
+				override: 'Label',
+				then: {},
+			};
+
+			const firstAgent = {
+				type: 'variable',
+				suggest: {known: 'Agent'},
+				then: Object.assign({
+					'': 0,
+				}, connectors, {
+					':': labelIndicator,
+				}),
+			};
+
+			const firstAgentDelayed = {
+				type: 'variable',
+				suggest: {known: 'DelayedAgent'},
+				then: Object.assign({
+					'': 0,
+					':': hiddenLabelIndicator,
+				}, connectors),
+			};
+
+			const firstAgentNoFlags = Object.assign({}, firstAgent, {
+				then: Object.assign({}, firstAgent.then, {
+					'is': {type: 'keyword', then: agentInfoList},
+				}),
+			});
+
+			return Object.assign({
+				'...': {type: 'operator', then: {
+					'': firstAgentDelayed,
+				}},
+			}, makeOpBlock({
+				exit: firstAgent,
+				sourceExit: Object.assign({
+					'': firstAgent,
+					':': hiddenLabelIndicator,
+				}, connectors),
+				blankExit: firstAgentNoFlags,
+			}));
+		}
+
+		const commonGroup = {type: 'keyword', then: {
+			'': textToEnd,
+			':': {type: 'operator', then: {
+				'': textToEnd,
+			}},
+			'\n': end,
+		}};
+
+		const BASE_THEN = {
+			'title': {type: 'keyword', then: {
+				'': textToEnd,
+			}},
+			'theme': {type: 'keyword', then: {
+				'': {
+					type: 'string',
+					suggest: {
+						global: 'themes',
+						suffix: '\n',
+					},
+					then: {
+						'': 0,
+						'\n': end,
+					},
+				},
+			}},
+			'headers': {type: 'keyword', then: {
+				'none': {type: 'keyword', then: {}},
+				'cross': {type: 'keyword', then: {}},
+				'box': {type: 'keyword', then: {}},
+				'fade': {type: 'keyword', then: {}},
+				'bar': {type: 'keyword', then: {}},
+			}},
+			'terminators': {type: 'keyword', then: {
+				'none': {type: 'keyword', then: {}},
+				'cross': {type: 'keyword', then: {}},
+				'box': {type: 'keyword', then: {}},
+				'fade': {type: 'keyword', then: {}},
+				'bar': {type: 'keyword', then: {}},
+			}},
+			'divider': {type: 'keyword', then: Object.assign({
+				'line': {type: 'keyword', then: divider},
+				'space': {type: 'keyword', then: divider},
+				'delay': {type: 'keyword', then: divider},
+				'tear': {type: 'keyword', then: divider},
+			}, divider)},
+			'define': {type: 'keyword', then: {
+				'': aliasListToEnd,
+				'as': CM_ERROR,
+			}},
+			'begin': {type: 'keyword', then: {
+				'': aliasListToEnd,
+				'reference': refDef,
+				'as': CM_ERROR,
+			}},
+			'end': {type: 'keyword', then: {
+				'': aliasListToEnd,
+				'as': CM_ERROR,
+				'\n': end,
+			}},
+			'if': commonGroup,
+			'else': {type: 'keyword', suggest: ['else\n', 'else if: '], then: {
+				'if': {type: 'keyword', suggest: 'if: ', then: {
+					'': textToEnd,
+					':': {type: 'operator', then: {
+						'': textToEnd,
+					}},
+				}},
+				'\n': end,
+			}},
+			'repeat': commonGroup,
+			'group': commonGroup,
+			'note': {type: 'keyword', then: {
+				'over': {type: 'keyword', then: {
+					'': agentListToText,
+				}},
+				'left': makeSideNote('left'),
+				'right': makeSideNote('right'),
+				'between': {type: 'keyword', then: {
+					'': agentListTo({':': CM_ERROR}, agentListToText),
+				}},
+			}},
+			'state': {type: 'keyword', suggest: 'state over ', then: {
+				'over': {type: 'keyword', then: {
+					'': {
+						type: 'variable',
+						suggest: {known: 'Agent'},
+						then: {
+							'': 0,
+							',': CM_ERROR,
+							':': colonTextToEnd,
+						},
+					},
+				}},
+			}},
+			'text': {type: 'keyword', then: {
+				'left': makeSideNote('left'),
+				'right': makeSideNote('right'),
+			}},
+			'autolabel': {type: 'keyword', then: {
+				'off': {type: 'keyword', then: {}},
+				'': textTo({'\n': end}, [
+					{v: '<label>', suffix: '\n', q: true},
+					{v: '[<inc>] <label>', suffix: '\n', q: true},
+					{v: '[<inc 1,0.01>] <label>', suffix: '\n', q: true},
+				]),
+			}},
+			'simultaneously': {type: 'keyword', then: {
+				':': {type: 'operator', then: {}},
+				'with': {type: 'keyword', then: {
+					'': {type: 'variable', suggest: {known: 'Label'}, then: {
+						'': 0,
+						':': {type: 'operator', then: {}},
+					}},
+				}},
+			}},
+		};
+
+		return (arrows) => ({
+			type: 'error line-error',
+			then: Object.assign({}, BASE_THEN, makeCMConnect(arrows)),
+		});
+	})());
+
+	function cmCappedToken(token, current) {
+		if(Object.keys(current.then).length > 0) {
+			return {v: token, suffix: ' ', q: false};
+		} else {
+			return {v: token, suffix: '\n', q: false};
+		}
+	}
+
+	function cmGetSuggestions(state, token, current) {
+		let suggestions = current.suggest;
+		if(!Array.isArray(suggestions)) {
+			suggestions = [suggestions];
+		}
+
+		return flatMap(suggestions, (suggest) => {
+			if(suggest === false) {
+				return [];
+			} else if(typeof suggest === 'object') {
+				if(suggest.known) {
+					return state['known' + suggest.known] || [];
+				} else {
+					return [suggest];
+				}
+			} else if(typeof suggest === 'string' && suggest) {
+				return [{v: suggest, q: (token === '')}];
+			} else {
+				return [cmCappedToken(token, current)];
+			}
+		});
+	}
+
+	function cmMakeCompletions(state, path) {
+		const comp = [];
+		const current = last(path);
+		Object.keys(current.then).forEach((token) => {
+			let next = current.then[token];
+			if(typeof next === 'number') {
+				next = path[path.length - next - 1];
+			}
+			mergeSets(
+				comp,
+				cmGetSuggestions(state, token, next),
+				suggestionsEqual
+			);
+		});
+		return comp;
+	}
+
+	function updateSuggestion(state, locals, token, {suggest, override}) {
+		let known = null;
+		if(typeof suggest === 'object' && suggest.known) {
+			known = suggest.known;
+		}
+		if(locals.type && known !== locals.type) {
+			if(override) {
+				locals.type = override;
+			}
+			mergeSets(
+				state['known' + locals.type],
+				[{v: locals.value, suffix: ' ', q: true}],
+				suggestionsEqual
+			);
+			locals.type = '';
+			locals.value = '';
+		}
+		if(known) {
+			locals.type = known;
+			if(locals.value) {
+				locals.value += token.s;
+			}
+			locals.value += token.v;
+		}
+	}
+
+	function cmCheckToken(state, eol, commands) {
+		const suggestions = {
+			type: '',
+			value: '',
+		};
+		let current = commands;
+		const path = [current];
+
+		state.line.forEach((token, i) => {
+			if(i === state.line.length - 1) {
+				state.completions = cmMakeCompletions(state, path);
+			}
+			const keywordToken = token.q ? '' : token.v;
+			let found = current.then[keywordToken];
+			if(typeof found === 'undefined') {
+				found = current.then[''];
+				state.isVar = true;
+			} else {
+				state.isVar = token.q;
+			}
+			if(typeof found === 'number') {
+				path.length -= found;
+			} else {
+				path.push(found || CM_ERROR);
+			}
+			current = last(path);
+			updateSuggestion(state, suggestions, token, current);
+		});
+		if(eol) {
+			updateSuggestion(state, suggestions, null, {});
+		}
+		state.nextCompletions = cmMakeCompletions(state, path);
+		state.valid = (
+			Boolean(current.then['\n']) ||
+			Object.keys(current.then).length === 0
+		);
+		return current.type;
+	}
+
+	function getInitialToken(block) {
+		const baseToken = (block.baseToken || {});
+		return {
+			value: baseToken.v || '',
+			quoted: baseToken.q || false,
+		};
+	}
+
+	class Mode {
+		constructor(tokenDefinitions, arrows) {
+			this.tokenDefinitions = tokenDefinitions;
+			this.commands = makeCommands(arrows);
+			this.lineComment = '#';
+		}
+
+		startState() {
+			return {
+				currentType: -1,
+				current: '',
+				currentSpace: '',
+				currentQuoted: false,
+				knownAgent: [],
+				knownDelayedAgent: [],
+				knownLabel: [],
+				beginCompletions: cmMakeCompletions({}, [this.commands]),
+				completions: [],
+				nextCompletions: [],
+				valid: true,
+				isVar: true,
+				line: [],
+				indent: 0,
+			};
+		}
+
+		_matchPattern(stream, pattern, consume) {
+			if(!pattern) {
+				return null;
+			}
+			pattern.lastIndex = 0;
+			return stream.match(pattern, consume);
+		}
+
+		_tokenBegin(stream, state) {
+			state.currentSpace = '';
+			for(let lastChar = ''; !stream.eol(); lastChar = stream.next()) {
+				state.currentSpace += lastChar;
+				for(let i = 0; i < this.tokenDefinitions.length; ++ i) {
+					const block = this.tokenDefinitions[i];
+					if(this._matchPattern(stream, block.start, true)) {
+						state.currentType = i;
+						const {value, quoted} = getInitialToken(block);
+						state.current = value;
+						state.currentQuoted = quoted;
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+
+		_tokenCheckEscape(stream, state, block) {
+			const match = this._matchPattern(stream, block.escape, true);
+			if(match) {
+				state.current += block.escapeWith(match);
+			}
+		}
+
+		_addToken(state) {
+			state.line.push({
+				v: state.current,
+				s: state.currentSpace,
+				q: state.currentQuoted,
+			});
+		}
+
+		_tokenEndFound(stream, state, block, match) {
+			state.currentType = -1;
+			if(block.includeEnd) {
+				state.current += match[0];
+			}
+			if(block.omit) {
+				return 'comment';
+			}
+			this._addToken(state);
+			return cmCheckToken(state, stream.eol(), this.commands);
+		}
+
+		_tokenEOLFound(stream, state, block) {
+			state.current += '\n';
+			if(block.omit) {
+				return 'comment';
+			}
+			this._addToken(state);
+			const type = cmCheckToken(state, false, this.commands);
+			state.line.pop();
+			return type;
+		}
+
+		_tokenEnd(stream, state) {
+			for(;;) {
+				const block = this.tokenDefinitions[state.currentType];
+				this._tokenCheckEscape(stream, state, block);
+				if(block.end) {
+					const match = this._matchPattern(stream, block.end, true);
+					if(match) {
+						return this._tokenEndFound(stream, state, block, match);
+					}
+				} else {
+					return this._tokenEndFound(stream, state, block, null);
+				}
+				if(stream.eol()) {
+					return this._tokenEOLFound(stream, state, block);
+				}
+				state.current += stream.next();
+			}
+		}
+
+		token(stream, state) {
+			state.completions = state.nextCompletions;
+			state.isVar = true;
+			if(stream.sol() && state.currentType === -1) {
+				state.line.length = 0;
+			}
+			let type = '';
+			if(state.currentType !== -1 || this._tokenBegin(stream, state)) {
+				type = this._tokenEnd(stream, state);
+			}
+			if(state.currentType === -1 && stream.eol() && !state.valid) {
+				return 'line-error ' + type;
+			} else {
+				return type;
+			}
+		}
+
+		indent(state) {
+			return state.indent;
+		}
+	}
+
+	function execAt(str, reg, i) {
+		reg.lastIndex = i;
+		return reg.exec(str);
+	}
+
+	function unescape(match) {
+		if(match[1] === 'n') {
+			return '\n';
+		}
+		return match[1];
+	}
+
+	const TOKENS = [
+		{end: /(?=\n)|$/y, omit: true, start: /#/y},
+		{
+			baseToken: {q: true},
+			end: /"/y,
+			escape: /\\(.)/y,
+			escapeWith: unescape,
+			start: /"/y,
+		},
+		{baseToken: {v: '...'}, start: /\.\.\./y},
+		{end: /(?=[ \t\r\n:+~\-*!<>,])|$/y, start: /(?=[^ \t\r\n:+~\-*!<>,])/y},
+		{
+			end: /(?=[^~\-<>x])|[-~]x|[<>](?=x)|$/y,
+			includeEnd: true,
+			start: /(?=[~\-<])/y,
+		},
+		{baseToken: {v: ','}, start: /,/y},
+		{baseToken: {v: ':'}, start: /:/y},
+		{baseToken: {v: '!'}, start: /!/y},
+		{baseToken: {v: '+'}, start: /\+/y},
+		{baseToken: {v: '*'}, start: /\*/y},
+		{baseToken: {v: '\n'}, start: /\n/y},
+	];
+
+	function tokFindBegin(src, i) {
+		for(let j = 0; j < TOKENS.length; ++ j) {
+			const block = TOKENS[j];
+			const match = execAt(src, block.start, i);
+			if(match) {
+				return {
+					appendSpace: '',
+					appendValue: '',
+					end: !block.end,
+					newBlock: block,
+					skip: match[0].length,
+				};
+			}
+		}
+		return {
+			appendSpace: src[i],
+			appendValue: '',
+			end: false,
+			newBlock: null,
+			skip: 1,
+		};
+	}
+
+	function tokContinuePart(src, i, block) {
+		if(block.escape) {
+			const match = execAt(src, block.escape, i);
+			if(match) {
+				return {
+					appendSpace: '',
+					appendValue: block.escapeWith(match),
+					end: false,
+					newBlock: null,
+					skip: match[0].length,
+				};
+			}
+		}
+		const match = execAt(src, block.end, i);
+		if(match) {
+			return {
+				appendSpace: '',
+				appendValue: block.includeEnd ? match[0] : '',
+				end: true,
+				newBlock: null,
+				skip: match[0].length,
+			};
+		}
+		return {
+			appendSpace: '',
+			appendValue: src[i],
+			end: false,
+			newBlock: null,
+			skip: 1,
+		};
+	}
+
+	function tokAdvance(src, i, block) {
+		if(block) {
+			return tokContinuePart(src, i, block);
+		} else {
+			return tokFindBegin(src, i);
+		}
+	}
+
+	function copyPos(pos) {
+		return {ch: pos.ch, i: pos.i, ln: pos.ln};
+	}
+
+	function advancePos(pos, src, steps) {
+		for(let i = 0; i < steps; ++ i) {
+			++ pos.ch;
+			if(src[pos.i + i] === '\n') {
+				++ pos.ln;
+				pos.ch = 0;
+			}
+		}
+		pos.i += steps;
+	}
+
+	class TokenState {
+		constructor(src) {
+			this.src = src;
+			this.block = null;
+			this.token = null;
+			this.pos = {ch: 0, i: 0, ln: 0};
+			this.reset();
+		}
+
+		isOver() {
+			return this.pos.i > this.src.length;
+		}
+
+		reset() {
+			this.token = {b: null, e: null, q: false, s: '', v: ''};
+			this.block = null;
+		}
+
+		beginToken(advance) {
+			this.block = advance.newBlock;
+			Object.assign(this.token, this.block.baseToken);
+			this.token.b = copyPos(this.pos);
+		}
+
+		endToken() {
+			let tok = null;
+			if(!this.block.omit) {
+				this.token.e = copyPos(this.pos);
+				tok = this.token;
+			}
+			this.reset();
+			return tok;
+		}
+
+		advance() {
+			const advance = tokAdvance(this.src, this.pos.i, this.block);
+
+			if(advance.newBlock) {
+				this.beginToken(advance);
+			}
+
+			this.token.s += advance.appendSpace;
+			this.token.v += advance.appendValue;
+			advancePos(this.pos, this.src, advance.skip);
+
+			if(advance.end) {
+				return this.endToken();
+			} else {
+				return null;
+			}
+		}
+	}
+
+	function posStr(pos) {
+		return 'line ' + (pos.ln + 1) + ', character ' + pos.ch;
+	}
+
+	class Tokeniser {
+		tokenise(src) {
+			const tokens = [];
+			const state = new TokenState(src);
+			while(!state.isOver()) {
+				const token = state.advance();
+				if(token) {
+					tokens.push(token);
+				}
+			}
+			if(state.block) {
+				throw new Error(
+					'Unterminated literal (began at ' +
+					posStr(state.token.b) + ')'
+				);
+			}
+			return tokens;
+		}
+
+		getCodeMirrorMode(arrows) {
+			return new Mode(TOKENS, arrows);
+		}
+
+		splitLines(tokens) {
+			const lines = [];
+			let line = [];
+			tokens.forEach((token) => {
+				if(!token.q && token.v === '\n') {
+					if(line.length > 0) {
+						lines.push(line);
+						line = [];
+					}
+				} else {
+					line.push(token);
+				}
+			});
+			if(line.length > 0) {
+				lines.push(line);
+			}
+			return lines;
+		}
+	}
+
+	const LABEL_PATTERN = /(.*?)<([^<>]*)>/g;
+	const DP_PATTERN = /\.([0-9]*)/;
+
+	function countDP(value) {
+		const match = DP_PATTERN.exec(value);
+		if(!match || !match[1]) {
+			return 0;
+		}
+		return match[1].length;
+	}
+
+	function parseCounter(args) {
+		let start = 1;
+		let inc = 1;
+		let dp = 0;
+
+		if(args[0]) {
+			start = Number(args[0]);
+			dp = Math.max(dp, countDP(args[0]));
+		}
+		if(args[1]) {
+			inc = Number(args[1]);
+			dp = Math.max(dp, countDP(args[1]));
+		}
+
+		if(Number.isNaN(start) || Number.isNaN(inc)) {
+			return null;
+		}
+
+		return {dp, inc, start};
+	}
+
+	function parseToken(token) {
+		if(token === 'label') {
+			return {token: 'label'};
+		}
+
+		const p = token.indexOf(' ');
+		let type = null;
+		let args = null;
+		if(p === -1) {
+			type = token;
+			args = [];
+		} else {
+			type = token.substr(0, p);
+			args = token.substr(p + 1).split(',');
+		}
+
+		let result = null;
+		if(type === 'inc') {
+			result = parseCounter(args);
+		}
+
+		return result || ('<' + token + '>');
+	}
+
+	function parsePattern(raw) {
+		const pattern = [];
+		let match = null;
+		let end = 0;
+		LABEL_PATTERN.lastIndex = 0;
+		while((match = LABEL_PATTERN.exec(raw))) {
+			if(match[1]) {
+				pattern.push(match[1]);
+			}
+			if(match[2]) {
+				pattern.push(parseToken(match[2]));
+			}
+			end = LABEL_PATTERN.lastIndex;
+		}
+		const remainder = raw.substr(end);
+		if(remainder) {
+			pattern.push(remainder);
+		}
+		return pattern;
+	}
+
+	const STYLES = [
+		{
+			attrs: {'font-style': 'italic'},
+			begin: /[\s_~`]\*(?=\S)/g,
+			end: /\S\*(?=[\s_~`])/g,
+		}, {
+			attrs: {'font-style': 'italic'},
+			begin: /[\s*~`]_(?=\S)/g,
+			end: /\S_(?=[\s*~`])/g,
+		}, {
+			attrs: {'font-weight': 'bolder'},
+			begin: /[\s_~`]\*\*(?=\S)/g,
+			end: /\S\*\*(?=[\s_~`])/g,
+		}, {
+			attrs: {'font-weight': 'bolder'},
+			begin: /[\s*~`]__(?=\S)/g,
+			end: /\S__(?=[\s*~`])/g,
+		}, {
+			attrs: {'text-decoration': 'line-through'},
+			begin: /[\s_*`]~(?=\S)/g,
+			end: /\S~(?=[\s_*`])/g,
+		}, {
+			attrs: {'font-family': 'monospace'},
+			begin: /[\s_*~.]`(?=\S)/g,
+			end: /\S`(?=[\s_*~.])/g,
+		},
+	];
+
+	function findNext(line, p, active) {
+		const virtLine = ' ' + line + ' ';
+		let styleIndex = -1;
+		let bestStart = virtLine.length;
+		let bestEnd = 0;
+
+		STYLES.forEach(({begin, end}, ind) => {
+			const search = active[ind] ? end : begin;
+			search.lastIndex = p;
+			const m = search.exec(virtLine);
+			if(m && (
+				m.index < bestStart ||
+				(m.index === bestStart && search.lastIndex > bestEnd)
+			)) {
+				styleIndex = ind;
+				bestStart = m.index;
+				bestEnd = search.lastIndex;
+			}
+		});
+
+		return {end: bestEnd - 1, start: bestStart, styleIndex};
+	}
+
+	function combineAttrs(activeCount, active) {
+		if(!activeCount) {
+			return null;
+		}
+		const attrs = {};
+		active.forEach((on, ind) => {
+			if(on) {
+				Object.assign(attrs, STYLES[ind].attrs);
+			}
+		});
+		return attrs;
+	}
+
+	function parseMarkdown(text) {
+		if(!text) {
+			return [];
+		}
+
+		const active = STYLES.map(() => false);
+		let activeCount = 0;
+		let attrs = null;
+		const lines = text.split('\n');
+		const result = [];
+		lines.forEach((line) => {
+			const parts = [];
+			let p = 0;
+			for(;;) {
+				const {styleIndex, start, end} = findNext(line, p, active);
+				if(styleIndex === -1) {
+					break;
+				}
+				if(active[styleIndex]) {
+					active[styleIndex] = false;
+					-- activeCount;
+				} else {
+					active[styleIndex] = true;
+					++ activeCount;
+				}
+				if(start > p) {
+					parts.push({attrs, text: line.substring(p, start)});
+				}
+				attrs = combineAttrs(activeCount, active);
+				p = end;
+			}
+			if(p < line.length) {
+				parts.push({attrs, text: line.substr(p)});
+			}
+			result.push(parts);
+		});
+		return result;
+	}
+
+	/* eslint-disable max-lines */
+
+	const BLOCK_TYPES = {
+		'if': {
+			type: 'block begin',
+			blockType: 'if',
+			tag: 'if',
+			skip: [],
+		},
+		'else': {
+			type: 'block split',
+			blockType: 'else',
+			tag: 'else',
+			skip: ['if'],
+		},
+		'repeat': {
+			type: 'block begin',
+			blockType: 'repeat',
+			tag: 'repeat',
+			skip: [],
+		},
+		'group': {
+			type: 'block begin',
+			blockType: 'group',
+			tag: '',
+			skip: [],
+		},
+	};
+
+	const CONNECT = {
+		types: ((() => {
+			const lTypes = [
+				{tok: '', type: 0},
+				{tok: '<', type: 1},
+				{tok: '<<', type: 2},
+			];
+			const mTypes = [
+				{tok: '-', type: 'solid'},
+				{tok: '--', type: 'dash'},
+				{tok: '~', type: 'wave'},
+			];
+			const rTypes = [
+				{tok: '', type: 0},
+				{tok: '>', type: 1},
+				{tok: '>>', type: 2},
+				{tok: 'x', type: 3},
+			];
+			const arrows = (combine([lTypes, mTypes, rTypes])
+				.filter((arrow) => (arrow[0].type !== 0 || arrow[2].type !== 0))
+			);
+
+			const types = new Map();
+
+			arrows.forEach((arrow) => {
+				types.set(arrow.map((part) => part.tok).join(''), {
+					line: arrow[1].type,
+					left: arrow[0].type,
+					right: arrow[2].type,
+				});
+			});
+
+			return types;
+		})()),
+
+		agentFlags: {
+			'*': {flag: 'begin', allowBlankName: true, blankNameFlag: 'source'},
+			'+': {flag: 'start'},
+			'-': {flag: 'stop'},
+			'!': {flag: 'end'},
+		},
+	};
+
+	const TERMINATOR_TYPES = [
+		'none',
+		'box',
+		'cross',
+		'fade',
+		'bar',
+	];
+
+	const NOTE_TYPES = {
+		'text': {
+			mode: 'text',
+			types: {
+				'left': {type: 'note left', skip: ['of'], min: 0, max: null},
+				'right': {type: 'note right', skip: ['of'], min: 0, max: null},
+			},
+		},
+		'note': {
+			mode: 'note',
+			types: {
+				'over': {type: 'note over', skip: [], min: 0, max: null},
+				'left': {type: 'note left', skip: ['of'], min: 0, max: null},
+				'right': {type: 'note right', skip: ['of'], min: 0, max: null},
+				'between': {type: 'note between', skip: [], min: 2, max: null},
+			},
+		},
+		'state': {
+			mode: 'state',
+			types: {
+				'over': {type: 'note over', skip: [], min: 1, max: 1},
+			},
+		},
+	};
+
+	const DIVIDER_TYPES = {
+		'line': {defaultHeight: 6},
+		'space': {defaultHeight: 6},
+		'delay': {defaultHeight: 30},
+		'tear': {defaultHeight: 6},
+	};
+
+	const AGENT_MANIPULATION_TYPES = {
+		'define': {type: 'agent define'},
+		'begin': {type: 'agent begin', mode: 'box'},
+		'end': {type: 'agent end', mode: 'cross'},
+	};
+
+	function makeError(message, token = null) {
+		let suffix = '';
+		if(token) {
+			suffix = (
+				' at line ' + (token.b.ln + 1) +
+				', character ' + token.b.ch
+			);
+		}
+		return new Error(message + suffix);
+	}
+
+	function joinLabel(line, begin = 0, end = null) {
+		if(end === null) {
+			end = line.length;
+		}
+		if(end <= begin) {
+			return '';
+		}
+		let result = line[begin].v;
+		for(let i = begin + 1; i < end; ++ i) {
+			result += line[i].s + line[i].v;
+		}
+		return result;
+	}
+
+	function readNumber(line, begin = 0, end = null, def = Number.NAN) {
+		const text = joinLabel(line, begin, end);
+		return Number(text || def);
+	}
+
+	function tokenKeyword(token) {
+		if(!token || token.q) {
+			return null;
+		}
+		return token.v;
+	}
+
+	function skipOver(line, start, skip, error = null) {
+		for(let i = 0; i < skip.length; ++ i) {
+			const expected = skip[i];
+			const token = line[start + i];
+			if(tokenKeyword(token) !== expected) {
+				if(error) {
+					throw makeError(
+						error + '; expected "' + expected + '"',
+						token
+					);
+				} else {
+					return start;
+				}
+			}
+		}
+		return start + skip.length;
+	}
+
+	function findToken(line, tokens, {
+		start = 0,
+		limit = null,
+		orEnd = false,
+	} = {}) {
+		if(limit === null) {
+			limit = line.length;
+		}
+		if(!Array.isArray(tokens)) {
+			tokens = [tokens];
+		}
+		for(let i = start; i <= limit - tokens.length; ++ i) {
+			if(skipOver(line, i, tokens) !== i) {
+				return i;
+			}
+		}
+		return orEnd ? limit : -1;
+	}
+
+	function findFirstToken(line, tokenMap, {start = 0, limit = null} = {}) {
+		if(limit === null) {
+			limit = line.length;
+		}
+		for(let pos = start; pos < limit; ++ pos) {
+			const value = tokenMap.get(tokenKeyword(line[pos]));
+			if(value) {
+				return {pos, value};
+			}
+		}
+		return null;
+	}
+
+	function readAgentAlias(line, start, end, {enableAlias, allowBlankName}) {
+		let aliasSep = -1;
+		if(enableAlias) {
+			aliasSep = findToken(line, 'as', {start});
+		}
+		if(aliasSep === -1 || aliasSep >= end) {
+			aliasSep = end;
+		}
+		if(start >= aliasSep && !allowBlankName) {
+			let errPosToken = line[start];
+			if(!errPosToken) {
+				errPosToken = {b: last(line).e};
+			}
+			throw makeError('Missing agent name', errPosToken);
+		}
+		return {
+			name: joinLabel(line, start, aliasSep),
+			alias: joinLabel(line, aliasSep + 1, end),
+		};
+	}
+
+	function readAgent(line, start, end, {
+		flagTypes = {},
+		aliases = false,
+	} = {}) {
+		const flags = [];
+		const blankNameFlags = [];
+		let p = start;
+		let allowBlankName = false;
+		for(; p < end; ++ p) {
+			const token = line[p];
+			const rawFlag = tokenKeyword(token);
+			const flag = flagTypes[rawFlag];
+			if(!flag) {
+				break;
+			}
+			if(flags.includes(flag.flag)) {
+				throw makeError('Duplicate agent flag: ' + rawFlag, token);
+			}
+			allowBlankName = allowBlankName || Boolean(flag.allowBlankName);
+			flags.push(flag.flag);
+			blankNameFlags.push(flag.blankNameFlag);
+		}
+		const {name, alias} = readAgentAlias(line, p, end, {
+			enableAlias: aliases,
+			allowBlankName,
+		});
+		return {
+			name,
+			alias,
+			flags: name ? flags : blankNameFlags,
+		};
+	}
+
+	function readAgentList(line, start, end, readAgentOpts) {
+		const list = [];
+		let currentStart = -1;
+		for(let i = start; i < end; ++ i) {
+			const token = line[i];
+			if(tokenKeyword(token) === ',') {
+				if(currentStart !== -1) {
+					list.push(readAgent(line, currentStart, i, readAgentOpts));
+					currentStart = -1;
+				}
+			} else if(currentStart === -1) {
+				currentStart = i;
+			}
+		}
+		if(currentStart !== -1) {
+			list.push(readAgent(line, currentStart, end, readAgentOpts));
+		}
+		return list;
+	}
+
+	const PARSERS = [
+		(line, meta) => { // Title
+			if(tokenKeyword(line[0]) !== 'title') {
+				return null;
+			}
+
+			meta.title = joinLabel(line, 1);
+			return true;
+		},
+
+		(line, meta) => { // Theme
+			if(tokenKeyword(line[0]) !== 'theme') {
+				return null;
+			}
+
+			meta.theme = joinLabel(line, 1);
+			return true;
+		},
+
+		(line, meta) => { // Terminators
+			if(tokenKeyword(line[0]) !== 'terminators') {
+				return null;
+			}
+
+			const type = tokenKeyword(line[1]);
+			if(!type) {
+				throw makeError('Unspecified termination', line[0]);
+			}
+			if(TERMINATOR_TYPES.indexOf(type) === -1) {
+				throw makeError('Unknown termination "' + type + '"', line[1]);
+			}
+			meta.terminators = type;
+			return true;
+		},
+
+		(line, meta) => { // Headers
+			if(tokenKeyword(line[0]) !== 'headers') {
+				return null;
+			}
+
+			const type = tokenKeyword(line[1]);
+			if(!type) {
+				throw makeError('Unspecified header', line[0]);
+			}
+			if(TERMINATOR_TYPES.indexOf(type) === -1) {
+				throw makeError('Unknown header "' + type + '"', line[1]);
+			}
+			meta.headers = type;
+			return true;
+		},
+
+		(line) => { // Divider
+			if(tokenKeyword(line[0]) !== 'divider') {
+				return null;
+			}
+
+			const labelSep = findToken(line, ':', {orEnd: true});
+			const heightSep = findToken(line, ['with', 'height'], {
+				limit: labelSep,
+				orEnd: true,
+			});
+
+			const mode = joinLabel(line, 1, heightSep) || 'line';
+			if(!DIVIDER_TYPES[mode]) {
+				throw makeError('Unknown divider type', line[1]);
+			}
+
+			const height = readNumber(
+				line,
+				heightSep + 2,
+				labelSep,
+				DIVIDER_TYPES[mode].defaultHeight
+			);
+			if(Number.isNaN(height) || height < 0) {
+				throw makeError('Invalid divider height', line[heightSep + 2]);
+			}
+
+			return {
+				type: 'divider',
+				mode,
+				height,
+				label: joinLabel(line, labelSep + 1),
+			};
+		},
+
+		(line) => { // Autolabel
+			if(tokenKeyword(line[0]) !== 'autolabel') {
+				return null;
+			}
+
+			let raw = null;
+			if(tokenKeyword(line[1]) === 'off') {
+				raw = '<label>';
+			} else {
+				raw = joinLabel(line, 1);
+			}
+			return {
+				type: 'label pattern',
+				pattern: parsePattern(raw),
+			};
+		},
+
+		(line) => { // Block
+			if(tokenKeyword(line[0]) === 'end' && line.length === 1) {
+				return {type: 'block end'};
+			}
+
+			const type = BLOCK_TYPES[tokenKeyword(line[0])];
+			if(!type) {
+				return null;
+			}
+			let skip = 1;
+			if(line.length > skip) {
+				skip = skipOver(line, skip, type.skip, 'Invalid block command');
+			}
+			skip = skipOver(line, skip, [':']);
+			return {
+				type: type.type,
+				blockType: type.blockType,
+				tag: type.tag,
+				label: joinLabel(line, skip),
+			};
+		},
+
+		(line) => { // Begin reference
+			if(
+				tokenKeyword(line[0]) !== 'begin' ||
+				tokenKeyword(line[1]) !== 'reference'
+			) {
+				return null;
+			}
+			let agents = [];
+			const labelSep = findToken(line, ':');
+			if(tokenKeyword(line[2]) === 'over' && labelSep > 3) {
+				agents = readAgentList(line, 3, labelSep);
+			} else if(labelSep !== 2) {
+				throw makeError('Expected ":" or "over"', line[2]);
+			}
+			const def = readAgent(
+				line,
+				labelSep + 1,
+				line.length,
+				{aliases: true}
+			);
+			if(!def.alias) {
+				throw makeError('Reference must have an alias', line[labelSep]);
+			}
+			return {
+				type: 'group begin',
+				agents,
+				blockType: 'ref',
+				tag: 'ref',
+				label: def.name,
+				alias: def.alias,
+			};
+		},
+
+		(line) => { // Agent
+			const type = AGENT_MANIPULATION_TYPES[tokenKeyword(line[0])];
+			if(!type || line.length <= 1) {
+				return null;
+			}
+			return Object.assign({
+				agents: readAgentList(line, 1, line.length, {aliases: true}),
+			}, type);
+		},
+
+		(line) => { // Async
+			if(tokenKeyword(line[0]) !== 'simultaneously') {
+				return null;
+			}
+			if(tokenKeyword(last(line)) !== ':') {
+				return null;
+			}
+			let target = '';
+			if(line.length > 2) {
+				if(tokenKeyword(line[1]) !== 'with') {
+					return null;
+				}
+				target = joinLabel(line, 2, line.length - 1);
+			}
+			return {
+				type: 'async',
+				target,
+			};
+		},
+
+		(line) => { // Note
+			const mode = NOTE_TYPES[tokenKeyword(line[0])];
+			const labelSep = findToken(line, ':');
+			if(!mode || labelSep === -1) {
+				return null;
+			}
+			const type = mode.types[tokenKeyword(line[1])];
+			if(!type) {
+				return null;
+			}
+			let skip = 2;
+			skip = skipOver(line, skip, type.skip);
+			const agents = readAgentList(line, skip, labelSep);
+			if(agents.length < type.min) {
+				throw makeError('Too few agents for ' + mode.mode, line[0]);
+			}
+			if(type.max !== null && agents.length > type.max) {
+				throw makeError('Too many agents for ' + mode.mode, line[0]);
+			}
+			return {
+				type: type.type,
+				agents,
+				mode: mode.mode,
+				label: joinLabel(line, labelSep + 1),
+			};
+		},
+
+		(line) => { // Connect
+			const labelSep = findToken(line, ':', {orEnd: true});
+			const connectionToken = findFirstToken(
+				line,
+				CONNECT.types,
+				{start: 0, limit: labelSep - 1}
+			);
+			if(!connectionToken) {
+				return null;
+			}
+
+			const connectPos = connectionToken.pos;
+
+			const readOpts = {
+				flagTypes: CONNECT.agentFlags,
+			};
+
+			if(tokenKeyword(line[0]) === '...') {
+				return {
+					type: 'connect-delay-end',
+					tag: joinLabel(line, 1, connectPos),
+					agent: readAgent(line, connectPos + 1, labelSep, readOpts),
+					label: joinLabel(line, labelSep + 1),
+					options: connectionToken.value,
+				};
+			} else if(tokenKeyword(line[connectPos + 1]) === '...') {
+				if(labelSep !== line.length) {
+					throw makeError(
+						'Cannot label beginning of delayed connection',
+						line[labelSep]
+					);
+				}
+				return {
+					type: 'connect-delay-begin',
+					tag: joinLabel(line, connectPos + 2, labelSep),
+					agent: readAgent(line, 0, connectPos, readOpts),
+					options: connectionToken.value,
+				};
+			} else {
+				return {
+					type: 'connect',
+					agents: [
+						readAgent(line, 0, connectPos, readOpts),
+						readAgent(line, connectPos + 1, labelSep, readOpts),
+					],
+					label: joinLabel(line, labelSep + 1),
+					options: connectionToken.value,
+				};
+			}
+		},
+
+		(line) => { // Marker
+			if(line.length < 2 || tokenKeyword(last(line)) !== ':') {
+				return null;
+			}
+			return {
+				type: 'mark',
+				name: joinLabel(line, 0, line.length - 1),
+			};
+		},
+
+		(line) => { // Options
+			const sepPos = findToken(line, 'is');
+			if(sepPos < 1) {
+				return null;
+			}
+			const indefiniteArticles = ['a', 'an'];
+			let optionsBegin = sepPos + 1;
+			if(indefiniteArticles.includes(tokenKeyword(line[optionsBegin]))) {
+				++ optionsBegin;
+			}
+			if(optionsBegin === line.length) {
+				throw makeError('Empty agent options', {b: last(line).e});
+			}
+			const agent = readAgent(line, 0, sepPos);
+			const options = [];
+			for(let i = optionsBegin; i < line.length; ++ i) {
+				options.push(line[i].v);
+			}
+			return {
+				type: 'agent options',
+				agent,
+				options,
+			};
+		},
+	];
+
+	function parseLine(line, {meta, stages}) {
+		let stage = null;
+		for(let i = 0; i < PARSERS.length; ++ i) {
+			stage = PARSERS[i](line, meta);
+			if(stage) {
+				break;
+			}
+		}
+		if(!stage) {
+			throw makeError(
+				'Unrecognised command: ' + joinLabel(line),
+				line[0]
+			);
+		}
+		if(typeof stage === 'object') {
+			stage.ln = line[0].b.ln;
+			stages.push(stage);
+		}
+	}
+
+	const SHARED_TOKENISER = new Tokeniser();
+
+	class Parser {
+		getCodeMirrorMode() {
+			return SHARED_TOKENISER.getCodeMirrorMode(
+				Array.from(CONNECT.types.keys())
+			);
+		}
+
+		parseLines(lines, src) {
+			const result = {
+				meta: {
+					title: '',
+					theme: '',
+					code: src,
+					terminators: 'none',
+					headers: 'box',
+					textFormatter: parseMarkdown,
+				},
+				stages: [],
+			};
+
+			lines.forEach((line) => parseLine(line, result));
+
+			return result;
+		}
+
+		parse(src) {
+			const tokens = SHARED_TOKENISER.tokenise(src);
+			const lines = SHARED_TOKENISER.splitLines(tokens);
+			return this.parseLines(lines, src);
+		}
+	}
+
+	/* eslint-disable spaced-comment */
+	/* eslint-disable capitalized-comments */
+
+	class BaseComponent {
+		makeState(/*state*/) {
+			// Override if required
+		}
+
+		resetState(state) {
+			// Override if required
+			this.makeState(state);
+		}
+
+		prepareMeasurements(/*stage, {
+			renderer,
+			theme,
+			agentInfos,
+			textSizer,
+			state,
+			components,
+		}*/) {
+			// Override if required
+		}
+
+		separationPre(/*stage, {
+			renderer,
+			theme,
+			agentInfos,
+			visibleAgentIDs,
+			momentaryAgentIDs,
+			textSizer,
+			addSpacing,
+			addSeparation,
+			state,
+			components,
+		}*/) {
+			// Override if required
+		}
+
+		separation(/*stage, {
+			renderer,
+			theme,
+			agentInfos,
+			visibleAgentIDs,
+			momentaryAgentIDs,
+			textSizer,
+			addSpacing,
+			addSeparation,
+			state,
+			components,
+		}*/) {
+			// Override if required
+		}
+
+		renderPre(/*stage, {
+			renderer,
+			theme,
+			agentInfos,
+			textSizer,
+			state,
+			components,
+		}*/) {
+			// Override if required
+			// Return {topShift, agentIDs, asynchronousY}
+		}
+
+		render(/*stage, {
+			renderer,
+			topY,
+			primaryY,
+			fillLayer,
+			blockLayer,
+			theme,
+			agentInfos,
+			svg,
+			textSizer,
+			addDef,
+			makeRegion,
+			state,
+			components,
+		}*/) {
+			// Override if required
+			// Return bottom Y coordinate
+		}
+
+		renderHidden(/*stage, {
+			(same args as render, with primaryY = topY)
+		}*/) {
+			// Override if required
+		}
+
+		shouldHide(/*stage, {
+			renderer,
+			theme,
+			agentInfos,
+			textSizer,
+			state,
+			components,
+		}*/) {
+			// Override if required
+			// Return {self, nest}
+		}
+	}
+
+	function cleanRenderPreResult({
+		agentIDs = [],
+		topShift = 0,
+		y = null,
+		asynchronousY = null,
+	} = {}, currentY = null) {
+		let ts = topShift;
+		if(y !== null && currentY !== null) {
+			ts = Math.max(ts, y - currentY);
+		}
+		return {
+			agentIDs,
+			asynchronousY: (asynchronousY === null) ? currentY : asynchronousY,
+			topShift: ts,
+			y,
+		};
+	}
+
+	const components = new Map();
+
+	function register(name, component) {
+		components.set(name, component);
+	}
+
+	function getComponents() {
+		return components;
+	}
+
+	const OUTLINE_ATTRS = {
+		'class': 'outline',
+		'fill': 'transparent',
+	};
+
+	class CapBox {
+		getConfig(options, env) {
+			let config = null;
+			if(options.includes('database')) {
+				config = env.theme.agentCap.database;
+			}
+			return config || env.theme.agentCap.box;
+		}
+
+		prepareMeasurements({formattedLabel, options}, env) {
+			const config = this.getConfig(options, env);
+			env.textSizer.expectMeasure(config.labelAttrs, formattedLabel);
+		}
+
+		separation({formattedLabel, options}, env) {
+			const config = this.getConfig(options, env);
+			const width = (
+				env.textSizer.measure(config.labelAttrs, formattedLabel).width +
+				config.padding.left +
+				config.padding.right
+			);
+
+			return {
+				left: width / 2,
+				radius: width / 2,
+				right: width / 2,
+			};
+		}
+
+		topShift({formattedLabel, options}, env) {
+			const config = this.getConfig(options, env);
+			const height = (
+				env.textSizer.measureHeight(config.labelAttrs, formattedLabel) +
+				config.padding.top +
+				config.padding.bottom
+			);
+			return Math.max(0, height - config.arrowBottom);
+		}
+
+		render(y, {x, formattedLabel, options}, env) {
+			const config = this.getConfig(options, env);
+
+			const text = env.svg.boxedText(config, formattedLabel, {x, y});
+
+			env.makeRegion().add(
+				text,
+				env.svg.box(OUTLINE_ATTRS, {
+					height: text.height,
+					width: text.width,
+					x: x - text.width / 2,
+					y,
+				})
+			);
+
+			return {
+				height: text.height,
+				lineBottom: text.height,
+				lineTop: 0,
+			};
+		}
+	}
+
+	class CapCross {
+		prepareMeasurements() {
+			// No-op
+		}
+
+		separation(agentInfo, env) {
+			const config = env.theme.agentCap.cross;
+			return {
+				left: config.size / 2,
+				radius: 0,
+				right: config.size / 2,
+			};
+		}
+
+		topShift(agentInfo, env) {
+			const config = env.theme.agentCap.cross;
+			return config.size / 2;
+		}
+
+		render(y, {x, options}, env) {
+			const config = env.theme.agentCap.cross;
+			const d = config.size / 2;
+
+			env.makeRegion().add(
+				config.render({
+					options,
+					radius: d,
+					x,
+					y: y + d,
+				}),
+				env.svg.box(OUTLINE_ATTRS, {
+					height: d * 2,
+					width: d * 2,
+					x: x - d,
+					y,
+				})
+			);
+
+			return {
+				height: d * 2,
+				lineBottom: d,
+				lineTop: d,
+			};
+		}
+	}
+
+	class CapBar {
+		prepareMeasurements({formattedLabel}, env) {
+			const config = env.theme.agentCap.box;
+			env.textSizer.expectMeasure(config.labelAttrs, formattedLabel);
+		}
+
+		separation({formattedLabel}, env) {
+			const config = env.theme.agentCap.box;
+			const width = (
+				env.textSizer.measure(config.labelAttrs, formattedLabel).width +
+				config.padding.left +
+				config.padding.right
+			);
+
+			return {
+				left: width / 2,
+				radius: width / 2,
+				right: width / 2,
+			};
+		}
+
+		topShift(agentInfo, env) {
+			const config = env.theme.agentCap.bar;
+			return config.height / 2;
+		}
+
+		render(y, {x, formattedLabel, options}, env) {
+			const boxCfg = env.theme.agentCap.box;
+			const barCfg = env.theme.agentCap.bar;
+			const width = (
+				env.textSizer.measure(boxCfg.labelAttrs, formattedLabel).width +
+				boxCfg.padding.left +
+				boxCfg.padding.right
+			);
+			const {height} = barCfg;
+
+			env.makeRegion().add(
+				barCfg.render({
+					height,
+					options,
+					width,
+					x: x - width / 2,
+					y,
+				}),
+				env.svg.box(OUTLINE_ATTRS, {
+					height,
+					width,
+					x: x - width / 2,
+					y,
+				})
+			);
+
+			return {
+				height,
+				lineBottom: height,
+				lineTop: 0,
+			};
+		}
+	}
+
+	class CapFade {
+		prepareMeasurements() {
+			// No-op
+		}
+
+		separation({currentRad}) {
+			return {
+				left: currentRad,
+				radius: currentRad,
+				right: currentRad,
+			};
+		}
+
+		topShift(agentInfo, env, isBegin) {
+			const config = env.theme.agentCap.fade;
+			return isBegin ? config.height : 0;
+		}
+
+		render(y, {x}, env, isBegin) {
+			const config = env.theme.agentCap.fade;
+			const ratio = config.height / (config.height + config.extend);
+
+			const gradID = env.addDef(isBegin ? 'FadeIn' : 'FadeOut', () => (
+				env.svg.linearGradient({
+					'x1': '0%',
+					'x2': '0%',
+					'y1': isBegin ? '100%' : '0%',
+					'y2': isBegin ? '0%' : '100%',
+				}, [
+					{
+						'offset': '0%',
+						'stop-color': '#FFFFFF',
+					},
+					{
+						'offset': (100 * ratio).toFixed(3) + '%',
+						'stop-color': '#000000',
+					},
+				])
+			));
+
+			env.lineMaskLayer.add(env.svg.box({
+				'fill': 'url(#' + gradID + ')',
+			}, {
+				height: config.height + config.extend,
+				width: config.width,
+				x: x - config.width / 2,
+				y: y - (isBegin ? config.extend : 0),
+			}));
+
+			env.makeRegion().add(env.svg.box(OUTLINE_ATTRS, {
+				height: config.height,
+				width: config.width,
+				x: x - config.width / 2,
+				y,
+			}));
+
+			return {
+				height: config.height,
+				lineBottom: 0,
+				lineTop: config.height,
+			};
+		}
+	}
+
+	class CapNone {
+		prepareMeasurements() {
+			// No-op
+		}
+
+		separation({currentRad}) {
+			return {
+				left: currentRad,
+				radius: currentRad,
+				right: currentRad,
+			};
+		}
+
+		topShift(agentInfo, env) {
+			const config = env.theme.agentCap.none;
+			return config.height;
+		}
+
+		render(y, {x}, env) {
+			const config = env.theme.agentCap.none;
+
+			const w = 10;
+			env.makeRegion().add(env.svg.box(OUTLINE_ATTRS, {
+				height: config.height,
+				width: w,
+				x: x - w / 2,
+				y,
+			}));
+
+			return {
+				height: config.height,
+				lineBottom: 0,
+				lineTop: config.height,
+			};
+		}
+	}
+
+	const AGENT_CAPS = {
+		'bar': new CapBar(),
+		'box': new CapBox(),
+		'cross': new CapCross(),
+		'fade': new CapFade(),
+		'none': new CapNone(),
+	};
+
+	class AgentCap extends BaseComponent {
+		constructor(begin) {
+			super();
+			this.begin = begin;
+		}
+
+		prepareMeasurements({mode, agentIDs}, env) {
+			agentIDs.forEach((id) => {
+				const agentInfo = env.agentInfos.get(id);
+				const cap = AGENT_CAPS[mode];
+				cap.prepareMeasurements(agentInfo, env, this.begin);
+			});
+		}
+
+		separationPre({mode, agentIDs}, env) {
+			agentIDs.forEach((id) => {
+				const agentInfo = env.agentInfos.get(id);
+				const cap = AGENT_CAPS[mode];
+				const sep = cap.separation(agentInfo, env, this.begin);
+				env.addSpacing(id, sep);
+				agentInfo.currentMaxRad = Math.max(
+					agentInfo.currentMaxRad,
+					sep.radius
+				);
+			});
+		}
+
+		separation({agentIDs}, env) {
+			if(this.begin) {
+				mergeSets(env.visibleAgentIDs, agentIDs);
+			} else {
+				removeAll(env.visibleAgentIDs, agentIDs);
+			}
+		}
+
+		renderPre({mode, agentIDs}, env) {
+			let maxTopShift = 0;
+			agentIDs.forEach((id) => {
+				const agentInfo = env.agentInfos.get(id);
+				const cap = AGENT_CAPS[mode];
+				const topShift = cap.topShift(agentInfo, env, this.begin);
+				maxTopShift = Math.max(maxTopShift, topShift);
+
+				const r = cap.separation(agentInfo, env, this.begin).radius;
+				agentInfo.currentMaxRad = Math.max(agentInfo.currentMaxRad, r);
+			});
+			return {
+				agentIDs,
+				topShift: maxTopShift,
+			};
+		}
+
+		render({mode, agentIDs}, env) {
+			let maxEnd = 0;
+			agentIDs.forEach((id) => {
+				const agentInfo = env.agentInfos.get(id);
+				const cap = AGENT_CAPS[mode];
+				const topShift = cap.topShift(agentInfo, env, this.begin);
+				const y0 = env.primaryY - topShift;
+				const shifts = cap.render(y0, agentInfo, env, this.begin);
+				maxEnd = Math.max(maxEnd, y0 + shifts.height);
+				if(this.begin) {
+					env.drawAgentLine(id, y0 + shifts.lineBottom);
+				} else {
+					env.drawAgentLine(id, y0 + shifts.lineTop, true);
+				}
+			});
+			return maxEnd + env.theme.actionMargin;
+		}
+
+		renderHidden({agentIDs}, env) {
+			agentIDs.forEach((id) => {
+				env.drawAgentLine(id, env.topY, !this.begin);
+			});
+		}
+	}
+
+	register('agent begin', new AgentCap(true));
+	register('agent end', new AgentCap(false));
+
+	class AgentHighlight extends BaseComponent {
+		radius(highlighted, env) {
+			return highlighted ? env.theme.agentLineHighlightRadius : 0;
+		}
+
+		separationPre({agentIDs, highlighted}, env) {
+			const r = this.radius(highlighted, env);
+			agentIDs.forEach((id) => {
+				const agentInfo = env.agentInfos.get(id);
+				agentInfo.currentRad = r;
+				agentInfo.currentMaxRad = Math.max(agentInfo.currentMaxRad, r);
+			});
+		}
+
+		renderPre({agentIDs, highlighted}, env) {
+			const r = this.radius(highlighted, env);
+			agentIDs.forEach((id) => {
+				const agentInfo = env.agentInfos.get(id);
+				agentInfo.currentMaxRad = Math.max(agentInfo.currentMaxRad, r);
+			});
+		}
+
+		render({agentIDs, highlighted}, env) {
+			const r = this.radius(highlighted, env);
+			agentIDs.forEach((id) => {
+				env.drawAgentLine(id, env.primaryY);
+				env.agentInfos.get(id).currentRad = r;
+			});
+			return env.primaryY + env.theme.actionMargin;
+		}
+
+		renderHidden(stage, env) {
+			this.render(stage, env);
+		}
+	}
+
+	register('agent highlight', new AgentHighlight());
+
+	const OUTLINE_ATTRS$1 = {
+		'class': 'outline',
+		'fill': 'transparent',
+	};
+
+	class BlockSplit extends BaseComponent {
+		prepareMeasurements({left, tag, label}, env) {
+			const blockInfo = env.state.blocks.get(left);
+			const config = env.theme.getBlock(blockInfo.type).section;
+			env.textSizer.expectMeasure(config.tag.labelAttrs, tag);
+			env.textSizer.expectMeasure(config.label.labelAttrs, label);
+		}
+
+		separation({left, right, tag, label}, env) {
+			const blockInfo = env.state.blocks.get(left);
+			const config = env.theme.getBlock(blockInfo.type).section;
+			const width = (
+				env.textSizer.measure(config.tag.labelAttrs, tag).width +
+				config.tag.padding.left +
+				config.tag.padding.right +
+				env.textSizer.measure(config.label.labelAttrs, label).width +
+				config.label.padding.left +
+				config.label.padding.right
+			);
+			env.addSeparation(left, right, width);
+		}
+
+		renderPre({left, right}) {
+			return {
+				agentIDs: [left, right],
+			};
+		}
+
+		render({left, right, tag, label}, env, first = false) {
+			const blockInfo = env.state.blocks.get(left);
+			const config = env.theme.getBlock(blockInfo.type);
+			const agentInfoL = env.agentInfos.get(left);
+			const agentInfoR = env.agentInfos.get(right);
+
+			let y = env.primaryY;
+
+			if(!first) {
+				y += config.section.padding.bottom;
+			}
+
+			const clickable = env.makeRegion();
+
+			const tagRender = env.svg.boxedText({
+				boxAttrs: config.section.tag.boxAttrs,
+				boxRenderer: config.section.tag.boxRenderer,
+				labelAttrs: config.section.tag.labelAttrs,
+				padding: config.section.tag.padding,
+			}, tag, {x: agentInfoL.x, y});
+
+			const labelRender = env.svg.boxedText({
+				boxAttrs: {'fill': '#000000'},
+				labelAttrs: config.section.label.labelAttrs,
+				padding: config.section.label.padding,
+			}, label, {x: agentInfoL.x + tagRender.width, y});
+
+			const labelHeight = Math.max(
+				Math.max(tagRender.height, labelRender.height),
+				config.section.label.minHeight
+			);
+
+			blockInfo.hold.add(tagRender.box);
+			env.lineMaskLayer.add(labelRender.box);
+			clickable.add(
+				env.svg.box(OUTLINE_ATTRS$1, {
+					height: labelHeight,
+					width: agentInfoR.x - agentInfoL.x,
+					x: agentInfoL.x,
+					y,
+				}),
+				tagRender.label,
+				labelRender.label
+			);
+
+			if(!first) {
+				blockInfo.hold.add(config.sepRenderer({
+					'x1': agentInfoL.x,
+					'x2': agentInfoR.x,
+					'y1': y,
+					'y2': y,
+				}));
+			} else if(blockInfo.canHide) {
+				clickable.addClass(blockInfo.hide ? 'collapsed' : 'expanded');
+			}
+
+			return y + labelHeight + config.section.padding.top;
+		}
+	}
+
+	class BlockBegin extends BlockSplit {
+		makeState(state) {
+			state.blocks = new Map();
+		}
+
+		resetState(state) {
+			state.blocks.clear();
+		}
+
+		storeBlockInfo(stage, env) {
+			const {canHide} = stage;
+			const blockInfo = {
+				canHide,
+				hide: canHide && env.renderer.isCollapsed(stage.ln),
+				hold: null,
+				startY: null,
+				type: stage.blockType,
+			};
+			env.state.blocks.set(stage.left, blockInfo);
+			return blockInfo;
+		}
+
+		prepareMeasurements(stage, env) {
+			this.storeBlockInfo(stage, env);
+			super.prepareMeasurements(stage, env);
+		}
+
+		separationPre(stage, env) {
+			this.storeBlockInfo(stage, env);
+			super.separationPre(stage, env);
+		}
+
+		separation(stage, env) {
+			mergeSets(env.visibleAgentIDs, [stage.left, stage.right]);
+			super.separation(stage, env);
+		}
+
+		renderPre(stage, env) {
+			const blockInfo = this.storeBlockInfo(stage, env);
+
+			const config = env.theme.getBlock(blockInfo.type);
+
+			return {
+				agentIDs: [stage.left, stage.right],
+				topShift: config.margin.top,
+			};
+		}
+
+		render(stage, env) {
+			const hold = env.svg.el('g');
+			env.blockLayer.add(hold);
+
+			const blockInfo = env.state.blocks.get(stage.left);
+			blockInfo.hold = hold;
+			blockInfo.startY = env.primaryY;
+
+			return super.render(stage, env, true);
+		}
+
+		shouldHide({left}, env) {
+			const blockInfo = env.state.blocks.get(left);
+			return {
+				nest: blockInfo.hide ? 1 : 0,
+				self: false,
+			};
+		}
+	}
+
+	class BlockEnd extends BaseComponent {
+		separation({left, right}, env) {
+			removeAll(env.visibleAgentIDs, [left, right]);
+		}
+
+		renderPre({left, right}, env) {
+			const blockInfo = env.state.blocks.get(left);
+			const config = env.theme.getBlock(blockInfo.type);
+
+			return {
+				agentIDs: [left, right],
+				topShift: config.section.padding.bottom,
+			};
+		}
+
+		render({left, right}, env) {
+			const blockInfo = env.state.blocks.get(left);
+			const config = env.theme.getBlock(blockInfo.type);
+			const agentInfoL = env.agentInfos.get(left);
+			const agentInfoR = env.agentInfos.get(right);
+
+			let renderFn = config.boxRenderer;
+			if(blockInfo.hide) {
+				renderFn = config.collapsedBoxRenderer || renderFn;
+			}
+
+			let shapes = renderFn({
+				height: env.primaryY - blockInfo.startY,
+				width: agentInfoR.x - agentInfoL.x,
+				x: agentInfoL.x,
+				y: blockInfo.startY,
+			});
+			if(!shapes.shape) {
+				shapes = {shape: shapes};
+			}
+
+			blockInfo.hold.add(shapes.shape);
+			env.fillLayer.add(shapes.fill);
+			env.lineMaskLayer.add(shapes.mask);
+
+			return env.primaryY + config.margin.bottom + env.theme.actionMargin;
+		}
+
+		shouldHide({left}, env) {
+			const blockInfo = env.state.blocks.get(left);
+			return {
+				nest: blockInfo.hide ? -1 : 0,
+				self: false,
+			};
+		}
+	}
+
+	register('block begin', new BlockBegin());
+	register('block split', new BlockSplit());
+	register('block end', new BlockEnd());
+
+	/* eslint-disable sort-keys */ // Maybe later
+
+	const OUTLINE_ATTRS$2 = {
+		'class': 'outline',
+		'fill': 'transparent',
+	};
+
+	class Arrowhead {
+		constructor(propName) {
+			this.propName = propName;
+		}
+
+		getConfig(theme) {
+			return theme.connect.arrow[this.propName];
+		}
+
+		short(theme) {
+			const arrow = this.getConfig(theme);
+			const join = arrow.attrs['stroke-linejoin'] || 'miter';
+			const t = arrow.attrs['stroke-width'] * 0.5;
+			const lineStroke = theme.agentLineAttrs['']['stroke-width'] * 0.5;
+			if(join === 'round') {
+				return lineStroke + t;
+			} else {
+				const h = arrow.height / 2;
+				const w = arrow.width;
+				const arrowDistance = t * Math.sqrt((w * w) / (h * h) + 1);
+				return lineStroke + arrowDistance;
+			}
+		}
+
+		render(layer, theme, pt, dir) {
+			const config = this.getConfig(theme);
+			const short = this.short(theme);
+			layer.add(config.render(config.attrs, {
+				x: pt.x + short * dir.dx,
+				y: pt.y + short * dir.dy,
+				width: config.width,
+				height: config.height,
+				dir,
+			}));
+		}
+
+		width(theme) {
+			return this.short(theme) + this.getConfig(theme).width;
+		}
+
+		height(theme) {
+			return this.getConfig(theme).height;
+		}
+
+		lineGap(theme, lineAttrs) {
+			const arrow = this.getConfig(theme);
+			const short = this.short(theme);
+			if(arrow.attrs.fill === 'none') {
+				const h = arrow.height / 2;
+				const w = arrow.width;
+				const safe = short + (lineAttrs['stroke-width'] / 2) * (w / h);
+				return (short + safe) / 2;
+			} else {
+				return short + arrow.width / 2;
+			}
+		}
+	}
+
+	class Arrowcross {
+		getConfig(theme) {
+			return theme.connect.arrow.cross;
+		}
+
+		render(layer, theme, pt, dir) {
+			const config = this.getConfig(theme);
+			layer.add(config.render({
+				x: pt.x + config.short * dir.dx,
+				y: pt.y + config.short * dir.dy,
+				radius: config.radius,
+			}));
+		}
+
+		width(theme) {
+			const config = this.getConfig(theme);
+			return config.short + config.radius;
+		}
+
+		height(theme) {
+			return this.getConfig(theme).radius * 2;
+		}
+
+		lineGap(theme) {
+			return this.getConfig(theme).short;
+		}
+	}
+
+	const ARROWHEADS = [
+		{
+			render: () => null,
+			width: () => 0,
+			height: () => 0,
+			lineGap: () => 0,
+		},
+		new Arrowhead('single'),
+		new Arrowhead('double'),
+		new Arrowcross(),
+	];
+
+	class Connect extends BaseComponent {
+		prepareMeasurements({agentIDs, label}, env) {
+			const config = env.theme.connect;
+			const loopback = (agentIDs[0] === agentIDs[1]);
+			const labelAttrs = (loopback ?
+				config.label.loopbackAttrs : config.label.attrs);
+
+			env.textSizer.expectMeasure(labelAttrs, label);
+		}
+
+		separationPre({agentIDs}, env) {
+			const r = env.theme.connect.source.radius;
+			agentIDs.forEach((id) => {
+				const agentInfo = env.agentInfos.get(id);
+				if(!agentInfo.isVirtualSource) {
+					return;
+				}
+				agentInfo.currentRad = r;
+				agentInfo.currentMaxRad = Math.max(agentInfo.currentMaxRad, r);
+			});
+		}
+
+		separation({label, agentIDs, options}, env) {
+			const config = env.theme.connect;
+
+			const lArrow = ARROWHEADS[options.left];
+			const rArrow = ARROWHEADS[options.right];
+
+			const loopback = (agentIDs[0] === agentIDs[1]);
+			const labelAttrs = (loopback ?
+				config.label.loopbackAttrs : config.label.attrs);
+
+			let labelWidth = env.textSizer.measure(labelAttrs, label).width;
+			if(labelWidth > 0) {
+				labelWidth += config.label.padding * 2;
+			}
+
+			const info1 = env.agentInfos.get(agentIDs[0]);
+			if(loopback) {
+				env.addSpacing(agentIDs[0], {
+					left: 0,
+					right: (
+						info1.currentMaxRad +
+						Math.max(
+							labelWidth + lArrow.width(env.theme),
+							rArrow.width(env.theme)
+						) +
+						config.loopbackRadius
+					),
+				});
+			} else {
+				const info2 = env.agentInfos.get(agentIDs[1]);
+				env.addSeparation(
+					agentIDs[0],
+					agentIDs[1],
+
+					info1.currentMaxRad +
+					info2.currentMaxRad +
+					labelWidth +
+					Math.max(
+						lArrow.width(env.theme),
+						rArrow.width(env.theme)
+					) * 2
+				);
+			}
+
+			mergeSets(env.momentaryAgentIDs, agentIDs);
+		}
+
+		renderRevArrowLine({x1, y1, x2, y2, xR}, options, env, clickable) {
+			const config = env.theme.connect;
+			const line = config.line[options.line];
+			const lArrow = ARROWHEADS[options.left];
+			const rArrow = ARROWHEADS[options.right];
+
+			const dx1 = lArrow.lineGap(env.theme, line.attrs);
+			const dx2 = rArrow.lineGap(env.theme, line.attrs);
+			const rendered = line.renderRev(line.attrs, {
+				x1: x1 + dx1,
+				y1,
+				x2: x2 + dx2,
+				y2,
+				xR,
+				rad: config.loopbackRadius,
+			});
+			clickable.add(rendered.shape);
+
+			lArrow.render(clickable, env.theme, {
+				x: rendered.p1.x - dx1,
+				y: rendered.p1.y,
+			}, {dx: 1, dy: 0});
+
+			rArrow.render(clickable, env.theme, {
+				x: rendered.p2.x - dx2,
+				y: rendered.p2.y,
+			}, {dx: 1, dy: 0});
+		}
+
+		renderSelfConnect({label, agentIDs, options}, env, from, yBegin) {
+			const config = env.theme.connect;
+
+			const lArrow = ARROWHEADS[options.left];
+			const rArrow = ARROWHEADS[options.right];
+
+			const to = env.agentInfos.get(agentIDs[1]);
+
+			const height = label ? (
+				env.textSizer.measureHeight(config.label.attrs, label) +
+				config.label.margin.top +
+				config.label.margin.bottom
+			) : 0;
+
+			const xL = (
+				from.x + from.currentMaxRad +
+				lArrow.width(env.theme) +
+				(label ? config.label.padding : 0)
+			);
+
+			const renderedText = env.svg.boxedText({
+				padding: config.mask.padding,
+				boxAttrs: {'fill': '#000000'},
+				labelAttrs: config.label.loopbackAttrs,
+			}, label, {
+				x: xL - config.mask.padding.left,
+				y: yBegin - height + config.label.margin.top,
+			});
+
+			const labelW = (label ? (
+				renderedText.width +
+				config.label.padding -
+				config.mask.padding.left -
+				config.mask.padding.right
+			) : 0);
+
+			const xR = Math.max(
+				to.x + to.currentMaxRad + rArrow.width(env.theme),
+				xL + labelW
+			);
+
+			const raise = Math.max(height, lArrow.height(env.theme) / 2);
+			const arrowDip = rArrow.height(env.theme) / 2;
+
+			env.lineMaskLayer.add(renderedText.box);
+			const clickable = env.makeRegion().add(
+				env.svg.box(OUTLINE_ATTRS$2, {
+					'x': from.x,
+					'y': yBegin - raise,
+					'width': xR + config.loopbackRadius - from.x,
+					'height': raise + env.primaryY - yBegin + arrowDip,
+				}),
+				renderedText.label
+			);
+
+			this.renderRevArrowLine({
+				x1: from.x + from.currentMaxRad,
+				y1: yBegin,
+				x2: to.x + to.currentMaxRad,
+				y2: env.primaryY,
+				xR,
+			}, options, env, clickable);
+
+			return (
+				env.primaryY +
+				Math.max(arrowDip, 0) +
+				env.theme.actionMargin
+			);
+		}
+
+		renderArrowLine({x1, y1, x2, y2}, options, env, clickable) {
+			const config = env.theme.connect;
+			const line = config.line[options.line];
+			const lArrow = ARROWHEADS[options.left];
+			const rArrow = ARROWHEADS[options.right];
+
+			const len = Math.sqrt(
+				(x2 - x1) * (x2 - x1) +
+				(y2 - y1) * (y2 - y1)
+			);
+			const d1 = lArrow.lineGap(env.theme, line.attrs);
+			const d2 = rArrow.lineGap(env.theme, line.attrs);
+			const dx = (x2 - x1) / len;
+			const dy = (y2 - y1) / len;
+
+			const rendered = line.renderFlat(line.attrs, {
+				x1: x1 + d1 * dx,
+				y1: y1 + d1 * dy,
+				x2: x2 - d2 * dx,
+				y2: y2 - d2 * dy,
+			});
+			clickable.add(rendered.shape);
+
+			const p1 = {x: rendered.p1.x - d1 * dx, y: rendered.p1.y - d1 * dy};
+			const p2 = {x: rendered.p2.x + d2 * dx, y: rendered.p2.y + d2 * dy};
+
+			lArrow.render(clickable, env.theme, p1, {dx, dy});
+			rArrow.render(clickable, env.theme, p2, {dx: -dx, dy: -dy});
+
+			return {
+				p1,
+				p2,
+				lArrow,
+				rArrow,
+			};
+		}
+
+		renderVirtualSources({from, to, rendered}, env, clickable) {
+			const config = env.theme.connect.source;
+
+			if(from.isVirtualSource) {
+				clickable.add(config.render({
+					x: rendered.p1.x - config.radius,
+					y: rendered.p1.y,
+					radius: config.radius,
+				}));
+			}
+			if(to.isVirtualSource) {
+				clickable.add(config.render({
+					x: rendered.p2.x + config.radius,
+					y: rendered.p2.y,
+					radius: config.radius,
+				}));
+			}
+		}
+
+		renderSimpleLabel(label, {layer, x1, x2, y1, y2, height}, env) {
+			const config = env.theme.connect;
+
+			const midX = (x1 + x2) / 2;
+			const midY = (y1 + y2) / 2;
+
+			let labelLayer = layer;
+			const boxAttrs = {'fill': '#000000'};
+			if(y1 !== y2) {
+				const angle = Math.atan((y2 - y1) / (x2 - x1));
+				const transform = (
+					'rotate(' +
+					(angle * 180 / Math.PI) +
+					' ' + midX + ',' + midY +
+					')'
+				);
+				boxAttrs.transform = transform;
+				labelLayer = env.svg.el('g').attr('transform', transform);
+				layer.add(labelLayer);
+			}
+
+			const text = env.svg.boxedText({
+				padding: config.mask.padding,
+				boxAttrs,
+				labelAttrs: config.label.attrs,
+			}, label, {
+				x: midX,
+				y: midY + config.label.margin.top - height,
+			});
+			env.lineMaskLayer.add(text.box);
+			labelLayer.add(text.label);
+		}
+
+		renderSimpleConnect({label, agentIDs, options}, env, from, yBegin) {
+			const config = env.theme.connect;
+			const to = env.agentInfos.get(agentIDs[1]);
+
+			const dir = (from.x < to.x) ? 1 : -1;
+
+			const height = (
+				env.textSizer.measureHeight(config.label.attrs, label) +
+				config.label.margin.top +
+				config.label.margin.bottom
+			);
+
+			const x1 = from.x + from.currentMaxRad * dir;
+			const x2 = to.x - to.currentMaxRad * dir;
+
+			const clickable = env.makeRegion();
+
+			const rendered = this.renderArrowLine({
+				x1,
+				y1: yBegin,
+				x2,
+				y2: env.primaryY,
+			}, options, env, clickable);
+
+			const arrowSpread = Math.max(
+				rendered.lArrow.height(env.theme),
+				rendered.rArrow.height(env.theme)
+			) / 2;
+
+			const lift = Math.max(height, arrowSpread);
+
+			this.renderVirtualSources({from, to, rendered}, env, clickable);
+
+			clickable.add(env.svg.el('path')
+				.attrs(OUTLINE_ATTRS$2)
+				.attr('d', (
+					'M' + x1 + ',' + (yBegin - lift) +
+					'L' + x2 + ',' + (env.primaryY - lift) +
+					'L' + x2 + ',' + (env.primaryY + arrowSpread) +
+					'L' + x1 + ',' + (yBegin + arrowSpread) +
+					'Z'
+				)));
+
+			this.renderSimpleLabel(label, {
+				layer: clickable,
+				x1,
+				y1: yBegin,
+				x2,
+				y2: env.primaryY,
+				height,
+			}, env);
+
+			return env.primaryY + Math.max(
+				arrowSpread + env.theme.minActionMargin,
+				env.theme.actionMargin
+			);
+		}
+
+		renderPre({label, agentIDs, options}, env) {
+			const config = env.theme.connect;
+
+			const lArrow = ARROWHEADS[options.left];
+			const rArrow = ARROWHEADS[options.right];
+
+			const height = (
+				env.textSizer.measureHeight(config.label.attrs, label) +
+				config.label.margin.top +
+				config.label.margin.bottom
+			);
+
+			let arrowH = lArrow.height(env.theme);
+			if(agentIDs[0] !== agentIDs[1]) {
+				arrowH = Math.max(arrowH, rArrow.height(env.theme));
+			}
+
+			return {
+				agentIDs,
+				topShift: Math.max(arrowH / 2, height),
+			};
+		}
+
+		render(stage, env, from = null, yBegin = null) {
+			let yb = yBegin;
+			let f = from;
+			if(from === null) {
+				f = env.agentInfos.get(stage.agentIDs[0]);
+				yb = env.primaryY;
+			}
+			if(stage.agentIDs[0] === stage.agentIDs[1]) {
+				return this.renderSelfConnect(stage, env, f, yb);
+			} else {
+				return this.renderSimpleConnect(stage, env, f, yb);
+			}
+		}
+	}
+
+	class ConnectDelayBegin extends Connect {
+		makeState(state) {
+			state.delayedConnections = new Map();
+		}
+
+		resetState(state) {
+			state.delayedConnections.clear();
+		}
+
+		separation(stage, env) {
+			super.separation(stage, env);
+			mergeSets(env.momentaryAgentIDs, [stage.agentIDs[0]]);
+		}
+
+		renderPre(stage, env) {
+			return Object.assign(super.renderPre(stage, env), {
+				agentIDs: [stage.agentIDs[0]],
+			});
+		}
+
+		render(stage, env) {
+			const dc = env.state.delayedConnections;
+			dc.set(stage.tag, {
+				stage,
+				from: Object.assign({}, env.agentInfos.get(stage.agentIDs[0])),
+				y: env.primaryY,
+			});
+			return env.primaryY + env.theme.actionMargin;
+		}
+
+		renderHidden(stage, env) {
+			this.render(stage, env);
+		}
+	}
+
+	class ConnectDelayEnd extends Connect {
+		prepareMeasurements() {
+			// No-op
+		}
+
+		separationPre() {
+			// No-op
+		}
+
+		separation() {
+			// No-op
+		}
+
+		renderPre({tag}, env) {
+			const config = env.theme.connect;
+
+			const dc = env.state.delayedConnections;
+			const begin = dc.get(tag);
+			const beginStage = begin.stage;
+			const agentIDs = [beginStage.agentIDs[1]];
+
+			if(beginStage.agentIDs[0] === beginStage.agentIDs[1]) {
+				return {
+					agentIDs,
+					y: begin.y + config.loopbackRadius * 2,
+				};
+			}
+
+			return Object.assign(super.renderPre(beginStage, env), {agentIDs});
+		}
+
+		render({tag}, env) {
+			const dc = env.state.delayedConnections;
+			const begin = dc.get(tag);
+			return super.render(begin.stage, env, begin.from, begin.y);
+		}
+	}
+
+	register('connect', new Connect());
+	register('connect-delay-begin', new ConnectDelayBegin());
+	register('connect-delay-end', new ConnectDelayEnd());
+
+	const OUTLINE_ATTRS$3 = {
+		'class': 'outline',
+		'fill': 'transparent',
+	};
+
+	class Divider extends BaseComponent {
+		prepareMeasurements({mode, formattedLabel}, env) {
+			const config = env.theme.getDivider(mode);
+			env.textSizer.expectMeasure(config.labelAttrs, formattedLabel);
+		}
+
+		separation({mode, formattedLabel}, env) {
+			const config = env.theme.getDivider(mode);
+
+			const width = (
+				env.textSizer.measure(config.labelAttrs, formattedLabel).width +
+				config.padding.left +
+				config.padding.right
+			);
+
+			env.addSeparation('[', ']', width);
+			env.addSpacing('[', {left: config.extend, right: 0});
+			env.addSpacing(']', {left: 0, right: config.extend});
+		}
+
+		renderPre() {
+			return {
+				agentIDs: ['[', ']'],
+			};
+		}
+
+		render({mode, height, formattedLabel}, env) {
+			const config = env.theme.getDivider(mode);
+
+			const left = env.agentInfos.get('[');
+			const right = env.agentInfos.get(']');
+
+			let labelWidth = 0;
+			let labelHeight = 0;
+			if(formattedLabel) {
+				labelHeight = env.textSizer.measureHeight(
+					config.labelAttrs,
+					formattedLabel
+				);
+			}
+
+			const fullHeight = Math.max(height, labelHeight) + config.margin;
+
+			let labelText = null;
+			if(formattedLabel) {
+				const boxed = env.svg.boxedText({
+					boxAttrs: {'fill': '#000000'},
+					labelAttrs: config.labelAttrs,
+					padding: config.padding,
+				}, formattedLabel, {
+					x: (left.x + right.x) / 2,
+					y: (
+						env.primaryY +
+						(fullHeight - labelHeight) / 2 -
+						config.padding.top
+					),
+				});
+				env.fullMaskLayer.add(boxed.box);
+				labelText = boxed.label;
+				labelWidth = boxed.width;
+			}
+
+			const {shape, mask} = config.render({
+				env,
+				height,
+				labelHeight,
+				labelWidth,
+				width: right.x - left.x + config.extend * 2,
+				x: left.x - config.extend,
+				y: env.primaryY + (fullHeight - height) / 2,
+			});
+			env.fullMaskLayer.add(mask);
+
+			env.makeRegion({unmasked: true}).add(
+				env.svg.box(OUTLINE_ATTRS$3, {
+					'height': fullHeight,
+					'width': right.x - left.x + config.extend * 2,
+					'x': left.x - config.extend,
+					'y': env.primaryY,
+				}),
+				shape,
+				labelText
+			);
+
+			return env.primaryY + fullHeight + env.theme.actionMargin;
+		}
+	}
+
+	register('divider', new Divider());
+
+	class Mark extends BaseComponent {
+		makeState(state) {
+			state.marks = new Map();
+		}
+
+		resetState(state) {
+			state.marks.clear();
+		}
+
+		render({name}, {topY, state}) {
+			state.marks.set(name, topY);
+		}
+
+		renderHidden(stage, env) {
+			this.render(stage, env);
+		}
+	}
+
+	class Async extends BaseComponent {
+		renderPre({target}, {state}) {
+			let y = 0;
+			if(target && state.marks) {
+				y = state.marks.get(target) || 0;
+			}
+			return {
+				asynchronousY: y,
+			};
+		}
+	}
+
+	register('mark', new Mark());
+	register('async', new Async());
+
+	/* eslint-disable complexity */ // Temporary ignore while switching linter
+
+	const OUTLINE_ATTRS$4 = {
+		'class': 'outline',
+		'fill': 'transparent',
+	};
+
+	function findExtremes(agentInfos, agentIDs) {
+		let min = null;
+		let max = null;
+		agentIDs.forEach((id) => {
+			const info = agentInfos.get(id);
+			if(min === null || info.index < min.index) {
+				min = info;
+			}
+			if(max === null || info.index > max.index) {
+				max = info;
+			}
+		});
+		return {
+			left: min.id,
+			right: max.id,
+		};
+	}
+
+	class NoteComponent extends BaseComponent {
+		prepareMeasurements({mode, label}, env) {
+			const config = env.theme.getNote(mode);
+			env.textSizer.expectMeasure(config.labelAttrs, label);
+		}
+
+		renderPre({agentIDs}) {
+			return {agentIDs};
+		}
+
+		renderNote({
+			xMid = null,
+			x0 = null,
+			x1 = null,
+			mode,
+			label,
+		}, env) {
+			const config = env.theme.getNote(mode);
+
+			const y = env.topY + config.margin.top + config.padding.top;
+			const labelNode = env.svg.formattedText(config.labelAttrs, label);
+			const size = env.textSizer.measure(labelNode);
+
+			const fullW = (
+				size.width +
+				config.padding.left +
+				config.padding.right
+			);
+			const fullH = (
+				config.padding.top +
+				size.height +
+				config.padding.bottom
+			);
+			if(x0 === null && xMid !== null) {
+				x0 = xMid - fullW / 2;
+			}
+			if(x1 === null && x0 !== null) {
+				x1 = x0 + fullW;
+			} else if(x0 === null) {
+				x0 = x1 - fullW;
+			}
+			switch(config.labelAttrs['text-anchor']) {
+			case 'middle':
+				labelNode.set({
+					x: (
+						x0 + config.padding.left +
+						x1 - config.padding.right
+					) / 2,
+					y,
+				});
+				break;
+			case 'end':
+				labelNode.set({x: x1 - config.padding.right, y});
+				break;
+			default:
+				labelNode.set({x: x0 + config.padding.left, y});
+				break;
+			}
+
+			env.makeRegion().add(
+				config.boxRenderer({
+					height: fullH,
+					width: x1 - x0,
+					x: x0,
+					y: env.topY + config.margin.top,
+				}),
+				env.svg.box(OUTLINE_ATTRS$4, {
+					height: fullH,
+					width: x1 - x0,
+					x: x0,
+					y: env.topY + config.margin.top,
+				}),
+				labelNode
+			);
+
+			return (
+				env.topY +
+				config.margin.top +
+				fullH +
+				config.margin.bottom +
+				env.theme.actionMargin
+			);
+		}
+	}
+
+	class NoteOver extends NoteComponent {
+		separation({agentIDs, mode, label}, env) {
+			const config = env.theme.getNote(mode);
+			const width = (
+				env.textSizer.measure(config.labelAttrs, label).width +
+				config.padding.left +
+				config.padding.right
+			);
+
+			const {left, right} = findExtremes(env.agentInfos, agentIDs);
+			const infoL = env.agentInfos.get(left);
+			const infoR = env.agentInfos.get(right);
+			if(infoL === infoR) {
+				env.addSpacing(left, {
+					left: width / 2,
+					right: width / 2,
+				});
+			} else {
+				const hangL = infoL.currentMaxRad + config.overlap.left;
+				const hangR = infoR.currentMaxRad + config.overlap.right;
+
+				env.addSeparation(left, right, width - hangL - hangR);
+
+				env.addSpacing(left, {left: hangL, right: 0});
+				env.addSpacing(right, {left: 0, right: hangR});
+			}
+		}
+
+		render({agentIDs, mode, label}, env) {
+			const config = env.theme.getNote(mode);
+
+			const {left, right} = findExtremes(env.agentInfos, agentIDs);
+			const infoL = env.agentInfos.get(left);
+			const infoR = env.agentInfos.get(right);
+			if(infoL === infoR) {
+				const xMid = infoL.x;
+				return this.renderNote({
+					label,
+					mode,
+					xMid,
+				}, env);
+			} else {
+				return this.renderNote({
+					label,
+					mode,
+					x0: infoL.x - infoL.currentMaxRad - config.overlap.left,
+					x1: infoR.x + infoR.currentMaxRad + config.overlap.right,
+				}, env);
+			}
+		}
+	}
+
+	class NoteSide extends NoteComponent {
+		constructor(isRight) {
+			super();
+			this.isRight = isRight;
+		}
+
+		separation({agentIDs, mode, label}, env) {
+			const config = env.theme.getNote(mode);
+			const {left, right} = findExtremes(env.agentInfos, agentIDs);
+			const width = (
+				env.textSizer.measure(config.labelAttrs, label).width +
+				config.padding.left +
+				config.padding.right +
+				config.margin.left +
+				config.margin.right
+			);
+
+			if(this.isRight) {
+				const info = env.agentInfos.get(right);
+				env.addSpacing(right, {
+					left: 0,
+					right: width + info.currentMaxRad,
+				});
+			} else {
+				const info = env.agentInfos.get(left);
+				env.addSpacing(left, {
+					left: width + info.currentMaxRad,
+					right: 0,
+				});
+			}
+		}
+
+		render({agentIDs, mode, label}, env) {
+			const config = env.theme.getNote(mode);
+			const {left, right} = findExtremes(env.agentInfos, agentIDs);
+			if(this.isRight) {
+				const info = env.agentInfos.get(right);
+				const x0 = info.x + info.currentMaxRad + config.margin.left;
+				return this.renderNote({
+					label,
+					mode,
+					x0,
+				}, env);
+			} else {
+				const info = env.agentInfos.get(left);
+				const x1 = info.x - info.currentMaxRad - config.margin.right;
+				return this.renderNote({
+					label,
+					mode,
+					x1,
+				}, env);
+			}
+		}
+	}
+
+	class NoteBetween extends NoteComponent {
+		separation({agentIDs, mode, label}, env) {
+			const config = env.theme.getNote(mode);
+			const {left, right} = findExtremes(env.agentInfos, agentIDs);
+			const infoL = env.agentInfos.get(left);
+			const infoR = env.agentInfos.get(right);
+
+			env.addSeparation(
+				left,
+				right,
+
+				env.textSizer.measure(config.labelAttrs, label).width +
+				config.padding.left +
+				config.padding.right +
+				config.margin.left +
+				config.margin.right +
+				infoL.currentMaxRad +
+				infoR.currentMaxRad
+			);
+		}
+
+		render({agentIDs, mode, label}, env) {
+			const {left, right} = findExtremes(env.agentInfos, agentIDs);
+			const infoL = env.agentInfos.get(left);
+			const infoR = env.agentInfos.get(right);
+			const xMid = (
+				infoL.x + infoL.currentMaxRad +
+				infoR.x - infoR.currentMaxRad
+			) / 2;
+
+			return this.renderNote({
+				label,
+				mode,
+				xMid,
+			}, env);
+		}
+	}
+
+	register('note over', new NoteOver());
+	register('note left', new NoteSide(false));
+	register('note right', new NoteSide(true));
+	register('note between', new NoteBetween());
+
+	function nullableMax(a = null, b = null) {
+		if(a === null) {
+			return b;
+		}
+		if(b === null) {
+			return a;
+		}
+		return Math.max(a, b);
+	}
+
+	function mergeResults(a, b) {
+		mergeSets(a.agentIDs, b.agentIDs);
+		return {
+			agentIDs: a.agentIDs,
+			asynchronousY: nullableMax(a.asynchronousY, b.asynchronousY),
+			topShift: Math.max(a.topShift, b.topShift),
+			y: nullableMax(a.y, b.y),
+		};
+	}
+
+	class Parallel extends BaseComponent {
+		invokeChildren(stage, env, methodName) {
+			return stage.stages.map((subStage) => {
+				const component = env.components.get(subStage.type);
+				return component[methodName](subStage, env);
+			});
+		}
+
+		prepareMeasurements(stage, env) {
+			this.invokeChildren(stage, env, 'prepareMeasurements');
+		}
+
+		separationPre(stage, env) {
+			this.invokeChildren(stage, env, 'separationPre');
+		}
+
+		separation(stage, env) {
+			this.invokeChildren(stage, env, 'separation');
+		}
+
+		renderPre(stage, env) {
+			const baseResults = {
+				agentIDs: [],
+				asynchronousY: null,
+				topShift: 0,
+			};
+
+			return this.invokeChildren(stage, env, 'renderPre')
+				.map((r) => cleanRenderPreResult(r))
+				.reduce(mergeResults, baseResults);
+		}
+
+		render(stage, env) {
+			const originalMakeRegion = env.makeRegion;
+			let bottomY = 0;
+			stage.stages.forEach((subStage) => {
+				env.makeRegion = (options = {}) => (
+					originalMakeRegion(Object.assign({
+						stageOverride: subStage,
+					}, options))
+				);
+
+				const component = env.components.get(subStage.type);
+				const baseY = component.render(subStage, env) || 0;
+				bottomY = Math.max(bottomY, baseY);
+			});
+			env.makeRegion = originalMakeRegion;
+			return bottomY;
+		}
+
+		renderHidden(stage, env) {
+			this.invokeChildren(stage, env, 'renderHidden');
+		}
+
+		shouldHide(stage, env) {
+			const baseResults = {
+				nest: 0,
+				self: false,
+			};
+			return this.invokeChildren(stage, env, 'shouldHide')
+				.reduce((result, {self = false, nest = 0} = {}) => ({
+					nest: result.nest + nest,
+					self: result.self || Boolean(self),
+				}), baseResults);
+		}
+	}
+
+	register('parallel', new Parallel());
+
+	function make(value, document) {
+		if(typeof value === 'string') {
+			return document.createTextNode(value);
+		} else if(typeof value === 'number') {
+			return document.createTextNode(value.toString(10));
+		} else if(typeof value === 'object' && value.element) {
+			return value.element;
+		} else {
+			return value;
+		}
+	}
+
+	function unwrap(node) {
+		if(node === null) {
+			return null;
+		} else if(node.element) {
+			return node.element;
+		} else {
+			return node;
+		}
+	}
+
+	class WrappedElement {
+		constructor(element) {
+			this.element = element;
+		}
+
+		addBefore(child = null, before = null) {
+			if(child === null) {
+				return this;
+			} else if(Array.isArray(child)) {
+				for(const c of child) {
+					this.addBefore(c, before);
+				}
+			} else {
+				const childElement = make(child, this.element.ownerDocument);
+				this.element.insertBefore(childElement, unwrap(before));
+			}
+			return this;
+		}
+
+		add(...child) {
+			return this.addBefore(child, null);
+		}
+
+		del(child = null) {
+			if(child !== null) {
+				this.element.removeChild(unwrap(child));
+			}
+			return this;
+		}
+
+		attr(key, value) {
+			this.element.setAttribute(key, value);
+			return this;
+		}
+
+		attrs(attrs) {
+			for(const k in attrs) {
+				if(Object.prototype.hasOwnProperty.call(attrs, k)) {
+					this.element.setAttribute(k, attrs[k]);
+				}
+			}
+			return this;
+		}
+
+		styles(styles) {
+			for(const k in styles) {
+				if(Object.prototype.hasOwnProperty.call(styles, k)) {
+					this.element.style[k] = styles[k];
+				}
+			}
+			return this;
+		}
+
+		setClass(cls) {
+			return this.attr('class', cls);
+		}
+
+		addClass(cls) {
+			const classes = this.element.getAttribute('class');
+			if(!classes) {
+				return this.setClass(cls);
+			}
+			const list = classes.split(' ');
+			if(list.includes(cls)) {
+				return this;
+			}
+			list.push(cls);
+			return this.attr('class', list.join(' '));
+		}
+
+		delClass(cls) {
+			const classes = this.element.getAttribute('class');
+			if(!classes) {
+				return this;
+			}
+			const list = classes.split(' ');
+			const p = list.indexOf(cls);
+			if(p !== -1) {
+				list.splice(p, 1);
+				this.attr('class', list.join(' '));
+			}
+			return this;
+		}
+
+		text(text) {
+			this.element.textContent = text;
+			return this;
+		}
+
+		on(event, callback, options = {}) {
+			if(Array.isArray(event)) {
+				for(const e of event) {
+					this.on(e, callback, options);
+				}
+			} else {
+				this.element.addEventListener(event, callback, options);
+			}
+			return this;
+		}
+
+		off(event, callback, options = {}) {
+			if(Array.isArray(event)) {
+				for(const e of event) {
+					this.off(e, callback, options);
+				}
+			} else {
+				this.element.removeEventListener(event, callback, options);
+			}
+			return this;
+		}
+
+		val(value) {
+			this.element.value = value;
+			return this;
+		}
+
+		select(start, end = null) {
+			this.element.selectionStart = start;
+			this.element.selectionEnd = (end === null) ? start : end;
+			return this;
+		}
+
+		focus() {
+			this.element.focus();
+			return this;
+		}
+
+		focussed() {
+			return this.element === this.element.ownerDocument.activeElement;
+		}
+
+		empty() {
+			while(this.element.childNodes.length > 0) {
+				this.element.removeChild(this.element.lastChild);
+			}
+			return this;
+		}
+
+		attach(parent) {
+			unwrap(parent).appendChild(this.element);
+			return this;
+		}
+
+		detach() {
+			this.element.parentNode.removeChild(this.element);
+			return this;
+		}
+	}
+
+	class DOMWrapper {
+		constructor(document) {
+			if(!document) {
+				throw new Error('Missing document!');
+			}
+			this.document = document;
+			this.wrap = this.wrap.bind(this);
+			this.el = this.el.bind(this);
+			this.txt = this.txt.bind(this);
+		}
+
+		wrap(element) {
+			if(element.element) {
+				return element;
+			} else {
+				return new WrappedElement(element);
+			}
+		}
+
+		el(tag, namespace = null) {
+			let element = null;
+			if(namespace === null) {
+				element = this.document.createElement(tag);
+			} else {
+				element = this.document.createElementNS(namespace, tag);
+			}
+			return new WrappedElement(element);
+		}
+
+		txt(content = '') {
+			return this.document.createTextNode(content);
+		}
+	}
+
+	function merge(state, newState) {
+		for(const k in state) {
+			if(Object.prototype.hasOwnProperty.call(state, k)) {
+				if(newState[k] !== null && typeof newState[k] !== 'undefined') {
+					state[k] = newState[k];
+				}
+			}
+		}
+	}
+
+	function populateSvgTextLine(svg, node, formattedLine) {
+		if(!Array.isArray(formattedLine)) {
+			throw new Error('Invalid formatted text line: ' + formattedLine);
+		}
+		formattedLine.forEach(({text, attrs}) => {
+			if(attrs) {
+				node.add(svg.el('tspan').attrs(attrs).add(text));
+			} else {
+				node.add(text);
+			}
+		});
+	}
+
+	const EMPTY = [];
+
+	class SVGTextBlock {
+		constructor(container, svg, initialState = {}) {
+			this.container = container;
+			this.svg = svg;
+			this.state = {
+				attrs: {},
+				formatted: EMPTY,
+				x: 0,
+				y: 0,
+			};
+			this.lines = [];
+			this.set(initialState);
+		}
+
+		_rebuildLines(count) {
+			if(count > this.lines.length) {
+				while(this.lines.length < count) {
+					this.lines.push({
+						latest: '',
+						node: this.svg.el('text')
+							.attr('x', this.state.x)
+							.attrs(this.state.attrs)
+							.attach(this.container),
+					});
+				}
+			} else {
+				while(this.lines.length > count) {
+					this.lines.pop().node.detach();
+				}
+			}
+		}
+
+		_reset() {
+			this._rebuildLines(0);
+		}
+
+		_renderText() {
+			const {formatted} = this.state;
+
+			if(!formatted || !formatted.length) {
+				this._reset();
+				return;
+			}
+			if(!Array.isArray(formatted)) {
+				throw new Error('Invalid formatted text: ' + formatted);
+			}
+
+			this._rebuildLines(formatted.length);
+
+			this.lines.forEach((ln, i) => {
+				const id = JSON.stringify(formatted[i]);
+				if(id !== ln.latest) {
+					ln.node.empty();
+					populateSvgTextLine(this.svg, ln.node, formatted[i]);
+					ln.latest = id;
+				}
+			});
+		}
+
+		_updateX() {
+			this.lines.forEach(({node}) => {
+				node.attr('x', this.state.x);
+			});
+		}
+
+		_updateY() {
+			const sizer = this.svg.textSizer;
+			let curY = this.state.y;
+			for(let i = 0; i < this.lines.length; ++ i) {
+				const line = [this.state.formatted[i]];
+				const baseline = sizer.baseline(this.state.attrs, line);
+				this.lines[i].node.attr('y', curY + baseline);
+				curY += sizer.measureHeight(this.state.attrs, line);
+			}
+		}
+
+		set(newState) {
+			const oldState = Object.assign({}, this.state);
+			merge(this.state, newState);
+
+			if(this.state.attrs !== oldState.attrs) {
+				this._reset();
+				oldState.formatted = EMPTY;
+			}
+
+			const oldLines = this.lines.length;
+
+			if(this.state.formatted !== oldState.formatted) {
+				this._renderText();
+			}
+
+			if(this.state.x !== oldState.x) {
+				this._updateX();
+			}
+
+			if(this.state.y !== oldState.y || this.lines.length !== oldLines) {
+				this._updateY();
+			}
+		}
+	}
+
+	class TextSizer {
+		constructor(svg) {
+			this.svg = svg;
+			this.testers = this.svg.el('g').attrs({
+				// Firefox fails to measure non-displayed text
+				'display': firefox ? 'block' : 'none',
+				'visibility': 'hidden',
+			});
+			this.container = svg.body;
+		}
+
+		baseline({attrs}) {
+			return Number(attrs['font-size']);
+		}
+
+		measureHeight({attrs, formatted}) {
+			const size = this.baseline({attrs, formatted});
+			const lineHeight = size * (Number(attrs['line-height']) || 1);
+			return formatted.length * lineHeight;
+		}
+
+		prepMeasurement(attrs, formatted) {
+			const node = this.svg.el('text')
+				.attrs(attrs)
+				.attach(this.testers);
+			populateSvgTextLine(this.svg, node, formatted);
+			return node;
+		}
+
+		prepComplete() {
+			this.container.add(this.testers);
+		}
+
+		performMeasurement(node) {
+			return node.element.getComputedTextLength();
+		}
+
+		teardown() {
+			this.container.del(this.testers.empty());
+		}
+	}
+
+	class PatternedLine {
+		constructor(pattern = null, phase = 0) {
+			this.pattern = pattern;
+			this.dw = pattern && pattern.partWidth;
+			this.points = [];
+			this.phase = phase;
+			this.x = null;
+			this.y = null;
+			this.disconnect = 0;
+		}
+
+		_nextDelta() {
+			return this.pattern.getDelta(this.phase ++);
+		}
+
+		_link() {
+			if(this.disconnect === 2) {
+				this.points.push(this.x + ' ' + this.y);
+				this.disconnect = 0;
+			}
+		}
+
+		cap() {
+			if(this.disconnect > 0) {
+				this.points.push(this.x + ' ' + this.y);
+				this.disconnect = 0;
+			}
+			return this;
+		}
+
+		move(x, y) {
+			this.cap();
+			this.x = x;
+			this.y = y;
+			this.disconnect = 2;
+			return this;
+		}
+
+		line(x, y, {patterned = true} = {}) {
+			if(this.pattern && patterned) {
+				const len = Math.sqrt(
+					(x - this.x) * (x - this.x) +
+					(y - this.y) * (y - this.y)
+				);
+				const dx1 = (x - this.x) / len;
+				const dy1 = (y - this.y) / len;
+				const dx2 = -dy1;
+				const dy2 = dx1;
+
+				for(let pos = 0; pos + this.dw <= len; pos += this.dw) {
+					const delta = this._nextDelta();
+					this.points.push(
+						(this.x + pos * dx1 + delta * dx2) + ' ' +
+						(this.y + pos * dy1 + delta * dy2)
+					);
+				}
+				this.disconnect = 1;
+			} else {
+				this._link();
+				this.disconnect = 2;
+			}
+
+			this.x = x;
+			this.y = y;
+			return this;
+		}
+
+		arc(cx, cy, theta) {
+			const radius = Math.sqrt(
+				(cx - this.x) * (cx - this.x) +
+				(cy - this.y) * (cy - this.y)
+			);
+			const theta1 = Math.atan2(this.x - cx, cy - this.y);
+			const nextX = cx + Math.sin(theta1 + theta) * radius;
+			const nextY = cy - Math.cos(theta1 + theta) * radius;
+
+			if(this.pattern) {
+				const dir = (theta < 0 ? 1 : -1);
+				const dt = this.dw / radius;
+
+				for(let t = theta1; t + dt <= theta1 + theta; t += dt) {
+					const delta = this._nextDelta() * dir;
+					this.points.push(
+						(cx + Math.sin(t) * (radius + delta)) + ' ' +
+						(cy - Math.cos(t) * (radius + delta))
+					);
+				}
+				this.disconnect = 1;
+			} else {
+				this.points.push(
+					this.x + ' ' + this.y +
+					'A' + radius + ' ' + radius + ' 0 ' +
+					((Math.abs(theta) >= Math.PI) ? '1 ' : '0 ') +
+					((theta < 0) ? '0 ' : '1 ') +
+					nextX + ' ' + nextY
+				);
+				this.disconnect = 0;
+			}
+
+			this.x = nextX;
+			this.y = nextY;
+
+			return this;
+		}
+
+		asPath() {
+			this._link();
+			return 'M' + this.points.join('L');
+		}
+	}
+
+	const NS = 'http://www.w3.org/2000/svg';
+
+	function calculateAnchor(x, attrs, padding) {
+		let shift = 0;
+		let anchorX = x;
+		switch(attrs['text-anchor']) {
+		case 'middle':
+			shift = 0.5;
+			anchorX += (padding.left - padding.right) / 2;
+			break;
+		case 'end':
+			shift = 1;
+			anchorX -= padding.right;
+			break;
+		default:
+			shift = 0;
+			anchorX += padding.left;
+			break;
+		}
+		return {anchorX, shift};
+	}
+
+	const defaultTextSizerFactory = (svg) => new TextSizer(svg);
+
+	class TextSizerWrapper {
+		constructor(sizer) {
+			this.sizer = sizer;
+			this.cache = new Map();
+			this.active = null;
+		}
+
+		_expectMeasure({attrs, formatted}) {
+			if(!formatted.length) {
+				return null;
+			}
+
+			const attrKey = JSON.stringify(attrs);
+			let attrCache = this.cache.get(attrKey);
+			if(!attrCache) {
+				attrCache = {
+					attrs,
+					lines: new Map(),
+				};
+				this.cache.set(attrKey, attrCache);
+			}
+
+			formatted.forEach((line) => {
+				if(!line.length) {
+					return;
+				}
+
+				const labelKey = JSON.stringify(line);
+				if(!attrCache.lines.has(labelKey)) {
+					attrCache.lines.set(labelKey, {
+						formatted: line,
+						width: null,
+					});
+				}
+			});
+
+			return attrCache;
+		}
+
+		_measureLine(attrCache, line) {
+			if(!line.length) {
+				return 0;
+			}
+
+			const labelKey = JSON.stringify(line);
+			const cache = attrCache.lines.get(labelKey);
+			if(cache.width === null) {
+				window.console.warn('Performing unexpected measurement', line);
+				this.performMeasurements();
+			}
+			return cache.width;
+		}
+
+		_measureWidth(opts) {
+			if(!opts.formatted.length) {
+				return 0;
+			}
+
+			const attrCache = this._expectMeasure(opts);
+
+			return (opts.formatted
+				.map((line) => this._measureLine(attrCache, line))
+				.reduce((a, b) => Math.max(a, b), 0)
+			);
+		}
+
+		_getMeasurementOpts(attrs, formatted) {
+			const result = {attrs, formatted};
+			if(!formatted) {
+				if(attrs.textBlock) {
+					result.attrs = attrs.textBlock.state.attrs;
+					result.formatted = attrs.textBlock.state.formatted;
+				} else if(attrs.state) {
+					result.attrs = attrs.state.attrs;
+					result.formatted = attrs.state.formatted;
+				}
+				result.formatted = result.formatted || [];
+			}
+			if(!Array.isArray(result.formatted)) {
+				throw new Error('Invalid formatted text: ' + result.formatted);
+			}
+			return result;
+		}
+
+		expectMeasure(attrs, formatted) {
+			const opts = this._getMeasurementOpts(attrs, formatted);
+			this._expectMeasure(opts);
+		}
+
+		performMeasurementsPre() {
+			this.active = [];
+			this.cache.forEach(({attrs, lines}) => {
+				lines.forEach((cacheLine) => {
+					if(cacheLine.width === null) {
+						this.active.push({
+							cacheLine,
+							data: this.sizer.prepMeasurement(
+								attrs,
+								cacheLine.formatted
+							),
+						});
+					}
+				});
+			});
+
+			if(this.active.length) {
+				this.sizer.prepComplete();
+			}
+		}
+
+		performMeasurementsAct() {
+			this.active.forEach(({data, cacheLine}) => {
+				cacheLine.width = this.sizer.performMeasurement(data);
+			});
+		}
+
+		performMeasurementsPost() {
+			if(this.active.length) {
+				this.sizer.teardown();
+			}
+			this.active = null;
+		}
+
+		performMeasurements() {
+			/*
+			 * Batch as many measurements as possible into a single DOM
+			 * change, since getComputedTextLength forces a reflow.
+			 */
+
+			try {
+				this.performMeasurementsPre();
+				this.performMeasurementsAct();
+			} finally {
+				this.performMeasurementsPost();
+			}
+		}
+
+		measure(attrs, formatted) {
+			const opts = this._getMeasurementOpts(attrs, formatted);
+			return {
+				height: this.sizer.measureHeight(opts),
+				width: this._measureWidth(opts),
+			};
+		}
+
+		baseline(attrs, formatted) {
+			const opts = this._getMeasurementOpts(attrs, formatted);
+			return this.sizer.baseline(opts);
+		}
+
+		measureHeight(attrs, formatted) {
+			const opts = this._getMeasurementOpts(attrs, formatted);
+			return this.sizer.measureHeight(opts);
+		}
+
+		resetCache() {
+			this.cache.clear();
+		}
+	}
+
+	class SVG {
+		constructor(domWrapper, textSizerFactory = null) {
+			this.dom = domWrapper;
+			this.body = this.el('svg').attr('xmlns', NS).attr('version', '1.1');
+			const fn = (textSizerFactory || defaultTextSizerFactory);
+			this.textSizer = new TextSizerWrapper(fn(this));
+
+			this.txt = this.txt.bind(this);
+			this.el = this.el.bind(this);
+		}
+
+		linearGradient(attrs, stops) {
+			return this.el('linearGradient')
+				.attrs(attrs)
+				.add(stops.map((stop) => this.el('stop').attrs(stop)));
+		}
+
+		patternedLine(pattern = null, phase = 0) {
+			return new PatternedLine(pattern, phase);
+		}
+
+		txt(content) {
+			return this.dom.txt(content);
+		}
+
+		el(tag, namespace = NS) {
+			return this.dom.el(tag, namespace);
+		}
+
+		box(attrs, {height, width, x, y}) {
+			return this.el('rect').attrs(attrs).attrs({height, width, x, y});
+		}
+
+		boxFactory(attrs) {
+			return this.box.bind(this, attrs);
+		}
+
+		line(attrs, {x1, x2, y1, y2}) {
+			return this.el('line').attrs(attrs).attrs({x1, x2, y1, y2});
+		}
+
+		lineFactory(attrs) {
+			return this.line.bind(this, attrs);
+		}
+
+		circle(attrs, {x, y, radius}) {
+			return this.el('circle')
+				.attrs({
+					'cx': x,
+					'cy': y,
+					'r': radius,
+				})
+				.attrs(attrs);
+		}
+
+		circleFactory(attrs) {
+			return this.circle.bind(this, attrs);
+		}
+
+		cross(attrs, {x, y, radius}) {
+			return this.el('path')
+				.attr('d', (
+					'M' + (x - radius) + ' ' + (y - radius) +
+					'l' + (radius * 2) + ' ' + (radius * 2) +
+					'm0 ' + (-radius * 2) +
+					'l' + (-radius * 2) + ' ' + (radius * 2)
+				))
+				.attrs(attrs);
+		}
+
+		crossFactory(attrs) {
+			return this.cross.bind(this, attrs);
+		}
+
+		note(attrs, flickAttrs, {height, width, x, y}) {
+			const x0 = x;
+			const x1 = x + width;
+			const y0 = y;
+			const y1 = y + height;
+			const flick = 7;
+
+			return this.el('g').add(
+				this.el('polygon')
+					.attr('points', (
+						x0 + ' ' + y0 + ' ' +
+						(x1 - flick) + ' ' + y0 + ' ' +
+						x1 + ' ' + (y0 + flick) + ' ' +
+						x1 + ' ' + y1 + ' ' +
+						x0 + ' ' + y1
+					))
+					.attrs(attrs),
+				this.el('polyline')
+					.attr('points', (
+						(x1 - flick) + ' ' + y0 + ' ' +
+						(x1 - flick) + ' ' + (y0 + flick) + ' ' +
+						x1 + ' ' + (y0 + flick)
+					))
+					.attrs(flickAttrs)
+			);
+		}
+
+		noteFactory(attrs, flickAttrs) {
+			return this.note.bind(this, attrs, flickAttrs);
+		}
+
+		formattedText(attrs = {}, formatted = [], {x, y} = {}) {
+			const container = this.el('g');
+			const txt = new SVGTextBlock(container, this, {
+				attrs,
+				formatted,
+				x,
+				y,
+			});
+			return Object.assign(container, {
+				set: (state) => txt.set(state),
+				textBlock: txt,
+			});
+		}
+
+		formattedTextFactory(attrs) {
+			return this.formattedText.bind(this, attrs);
+		}
+
+		boxedText({
+			padding,
+			labelAttrs,
+			boxAttrs = {},
+			boxRenderer = null,
+		}, formatted, {x, y}) {
+			if(!formatted || !formatted.length) {
+				return Object.assign(this.el('g'), {
+					box: null,
+					height: 0,
+					label: null,
+					width: 0,
+				});
+			}
+
+			const {shift, anchorX} = calculateAnchor(x, labelAttrs, padding);
+
+			const label = this.formattedText(labelAttrs, formatted, {
+				x: anchorX,
+				y: y + padding.top,
+			});
+
+			const size = this.textSizer.measure(label);
+			const width = (size.width + padding.left + padding.right);
+			const height = (size.height + padding.top + padding.bottom);
+
+			const boxFn = boxRenderer || this.boxFactory(boxAttrs);
+			const box = boxFn({
+				height,
+				width,
+				x: anchorX - size.width * shift - padding.left,
+				y,
+			});
+
+			return Object.assign(this.el('g').add(box, label), {
+				box,
+				height,
+				label,
+				width,
+			});
+		}
+
+		boxedTextFactory(options) {
+			return this.boxedText.bind(this, options);
+		}
+	}
+
+	/* eslint-disable max-lines */
+
+	function findExtremes$1(agentInfos, agentIDs) {
+		let min = null;
+		let max = null;
+		agentIDs.forEach((id) => {
+			const info = agentInfos.get(id);
+			if(min === null || info.index < min.index) {
+				min = info;
+			}
+			if(max === null || info.index > max.index) {
+				max = info;
+			}
+		});
+		return {
+			left: min.id,
+			right: max.id,
+		};
+	}
+
+	function makeThemes(themes) {
+		if(themes.length === 0) {
+			throw new Error('Cannot render without a theme');
+		}
+		const themeMap = new Map();
+		themes.forEach((theme) => {
+			themeMap.set(theme.name, theme);
+		});
+		themeMap.set('', themes[0]);
+		return themeMap;
+	}
+
+	let globalNamespace = 0;
+
+	function parseNamespace(namespace) {
+		if(namespace === null) {
+			return 'R' + (globalNamespace ++);
+		}
+		return namespace;
+	}
+
+	class Renderer extends EventObject {
+		constructor({
+			themes = [],
+			namespace = null,
+			components = null,
+			document,
+			textSizerFactory = null,
+		} = {}) {
+			super();
+
+			this._bindMethods();
+
+			this.state = {};
+			this.width = 0;
+			this.height = 0;
+			this.themes = makeThemes(themes);
+			this.themeBuilder = null;
+			this.theme = null;
+			this.namespace = parseNamespace(namespace);
+			this.components = components || getComponents();
+			this.svg = new SVG(new DOMWrapper(document), textSizerFactory);
+			this.knownThemeDefs = new Set();
+			this.knownDefs = new Set();
+			this.highlights = new Map();
+			this.collapsed = new Set();
+			this.currentHighlight = -1;
+			this.buildStaticElements();
+			this.components.forEach((component) => {
+				component.makeState(this.state);
+			});
+		}
+
+		_bindMethods() {
+			this.separationStage = this.separationStage.bind(this);
+			this.prepareMeasurementsStage =
+				this.prepareMeasurementsStage.bind(this);
+			this.renderStage = this.renderStage.bind(this);
+			this.addThemeDef = this.addThemeDef.bind(this);
+			this.addDef = this.addDef.bind(this);
+		}
+
+		addTheme(theme) {
+			this.themes.set(theme.name, theme);
+		}
+
+		buildStaticElements() {
+			const {el} = this.svg;
+
+			this.metaCode = this.svg.txt();
+			this.themeDefs = el('defs');
+			this.defs = el('defs');
+			this.fullMask = el('mask').attrs({
+				'id': this.namespace + 'FullMask',
+				'maskUnits': 'userSpaceOnUse',
+			});
+			this.lineMask = el('mask').attrs({
+				'id': this.namespace + 'LineMask',
+				'maskUnits': 'userSpaceOnUse',
+			});
+			this.fullMaskReveal = el('rect').attr('fill', '#FFFFFF');
+			this.lineMaskReveal = el('rect').attr('fill', '#FFFFFF');
+			this.backgroundFills = el('g');
+			this.agentLines = el('g')
+				.attr('mask', 'url(#' + this.namespace + 'LineMask)');
+			this.blocks = el('g');
+			this.shapes = el('g');
+			this.unmaskedShapes = el('g');
+			this.title = this.svg.formattedText();
+
+			this.svg.body.add(
+				this.svg.el('metadata')
+					.add(this.metaCode),
+				this.themeDefs,
+				this.defs,
+				this.backgroundFills,
+				el('g')
+					.attr('mask', 'url(#' + this.namespace + 'FullMask)')
+					.add(
+						this.agentLines,
+						this.blocks,
+						this.shapes
+					),
+				this.unmaskedShapes,
+				this.title
+			);
+		}
+
+		addThemeDef(name, generator) {
+			const namespacedName = this.namespace + name;
+			if(!this.knownThemeDefs.has(name)) {
+				this.knownThemeDefs.add(name);
+				this.themeDefs.add(generator().attr('id', namespacedName));
+			}
+			return namespacedName;
+		}
+
+		addDef(name, generator) {
+			let nm = name;
+			let gen = generator;
+
+			if(typeof generator !== 'function') {
+				nm = 'P' + this.knownDefs.size;
+				gen = () => name;
+			}
+
+			const namespacedName = this.namespace + nm;
+			if(!this.knownDefs.has(nm)) {
+				this.knownDefs.add(nm);
+				this.defs.add(gen().attr('id', namespacedName));
+			}
+			return namespacedName;
+		}
+
+		addSeparation(agentID1, agentID2, dist) {
+			const info1 = this.agentInfos.get(agentID1);
+			const info2 = this.agentInfos.get(agentID2);
+
+			const d1 = info1.separations.get(agentID2) || 0;
+			info1.separations.set(agentID2, Math.max(d1, dist));
+
+			const d2 = info2.separations.get(agentID1) || 0;
+			info2.separations.set(agentID1, Math.max(d2, dist));
+		}
+
+		checkHidden(stage) {
+			const component = this.components.get(stage.type);
+			const env = {
+				agentInfos: this.agentInfos,
+				components: this.components,
+				renderer: this,
+				state: this.state,
+				textSizer: this.svg.textSizer,
+				theme: this.theme,
+			};
+
+			const hide = component.shouldHide(stage, env) || {};
+
+			const wasHidden = (this.hideNest > 0);
+			this.hideNest += hide.nest || 0;
+			const isHidden = (this.hideNest > 0);
+
+			if(this.hideNest < 0) {
+				throw new Error('Unexpected nesting in ' + stage.type);
+			}
+			if(wasHidden === isHidden) {
+				return isHidden;
+			} else {
+				return Boolean(hide.self);
+			}
+		}
+
+		separationStage(stage) {
+			const agentSpaces = new Map();
+			const agentIDs = this.visibleAgentIDs.slice();
+			const seps = [];
+
+			const addSpacing = (agentID, {left, right}) => {
+				const current = agentSpaces.get(agentID);
+				current.left = Math.max(current.left, left);
+				current.right = Math.max(current.right, right);
+			};
+
+			const addSeparation = (agentID1, agentID2, dist) => {
+				seps.push({agentID1, agentID2, dist});
+			};
+
+			this.agentInfos.forEach((agentInfo) => {
+				const rad = agentInfo.currentRad;
+				agentInfo.currentMaxRad = rad;
+				agentSpaces.set(agentInfo.id, {left: rad, right: rad});
+			});
+
+			const env = {
+				addSeparation,
+				addSpacing,
+				agentInfos: this.agentInfos,
+				components: this.components,
+				momentaryAgentIDs: agentIDs,
+				renderer: this,
+				state: this.state,
+				textSizer: this.svg.textSizer,
+				theme: this.theme,
+				visibleAgentIDs: this.visibleAgentIDs,
+			};
+
+			const component = this.components.get(stage.type);
+			if(!component) {
+				throw new Error('Unknown component: ' + stage.type);
+			}
+
+			component.separationPre(stage, env);
+			component.separation(stage, env);
+
+			if(this.checkHidden(stage)) {
+				return;
+			}
+
+			mergeSets(agentIDs, this.visibleAgentIDs);
+
+			seps.forEach(({agentID1, agentID2, dist}) => {
+				this.addSeparation(agentID1, agentID2, dist);
+			});
+
+			agentIDs.forEach((agentIDR) => {
+				const infoR = this.agentInfos.get(agentIDR);
+				const sepR = agentSpaces.get(agentIDR);
+				infoR.maxRPad = Math.max(infoR.maxRPad, sepR.right);
+				infoR.maxLPad = Math.max(infoR.maxLPad, sepR.left);
+				agentIDs.forEach((agentIDL) => {
+					const infoL = this.agentInfos.get(agentIDL);
+					if(infoL.index >= infoR.index) {
+						return;
+					}
+					const sepL = agentSpaces.get(agentIDL);
+					this.addSeparation(
+						agentIDR,
+						agentIDL,
+						sepR.left + sepL.right + this.theme.agentMargin
+					);
+				});
+			});
+		}
+
+		prepareMeasurementsStage(stage) {
+			const env = {
+				agentInfos: this.agentInfos,
+				components: this.components,
+				renderer: this,
+				state: this.state,
+				textSizer: this.svg.textSizer,
+				theme: this.theme,
+			};
+
+			const component = this.components.get(stage.type);
+			if(!component) {
+				throw new Error('Unknown component: ' + stage.type);
+			}
+
+			component.prepareMeasurements(stage, env);
+		}
+
+		checkAgentRange(agentIDs, topY = 0) {
+			if(agentIDs.length === 0) {
+				return topY;
+			}
+			const {left, right} = findExtremes$1(this.agentInfos, agentIDs);
+			const leftX = this.agentInfos.get(left).x;
+			const rightX = this.agentInfos.get(right).x;
+			let baseY = topY;
+			this.agentInfos.forEach((agentInfo) => {
+				if(agentInfo.x >= leftX && agentInfo.x <= rightX) {
+					baseY = Math.max(baseY, agentInfo.latestY);
+				}
+			});
+			return baseY;
+		}
+
+		markAgentRange(agentIDs, y) {
+			if(agentIDs.length === 0) {
+				return;
+			}
+			const {left, right} = findExtremes$1(this.agentInfos, agentIDs);
+			const leftX = this.agentInfos.get(left).x;
+			const rightX = this.agentInfos.get(right).x;
+			this.agentInfos.forEach((agentInfo) => {
+				if(agentInfo.x >= leftX && agentInfo.x <= rightX) {
+					agentInfo.latestY = y;
+				}
+			});
+		}
+
+		drawAgentLine(agentInfo, toY) {
+			if(
+				agentInfo.latestYStart !== null &&
+				toY > agentInfo.latestYStart
+			) {
+				this.agentLines.add(this.theme.renderAgentLine({
+					className: 'agent-' + agentInfo.index + '-line',
+					options: agentInfo.options,
+					width: agentInfo.currentRad * 2,
+					x: agentInfo.x,
+					y0: agentInfo.latestYStart,
+					y1: toY,
+				}));
+			}
+		}
+
+		addHighlightObject(line, o) {
+			let list = this.highlights.get(line);
+			if(!list) {
+				list = [];
+				this.highlights.set(line, list);
+			}
+			list.push(o);
+		}
+
+		forwardEvent(source, sourceEvent, forwardEvent, forwardArgs) {
+			source.on(
+				sourceEvent,
+				this.trigger.bind(this, forwardEvent, forwardArgs)
+			);
+		}
+
+		renderStage(stage) {
+			this.agentInfos.forEach((agentInfo) => {
+				const rad = agentInfo.currentRad;
+				agentInfo.currentMaxRad = rad;
+			});
+
+			const envPre = {
+				agentInfos: this.agentInfos,
+				components: this.components,
+				renderer: this,
+				state: this.state,
+				textSizer: this.svg.textSizer,
+				theme: this.theme,
+			};
+			const component = this.components.get(stage.type);
+			const result = component.renderPre(stage, envPre);
+			const {agentIDs, topShift, asynchronousY} =
+				cleanRenderPreResult(result, this.currentY);
+
+			const topY = this.checkAgentRange(agentIDs, asynchronousY);
+
+			const makeRegion = ({
+				stageOverride = null,
+				unmasked = false,
+			} = {}) => {
+				const o = this.svg.el('g').setClass('region');
+				const targetStage = (stageOverride || stage);
+				this.addHighlightObject(targetStage.ln, o);
+				this.forwardEvent(o, 'mouseenter', 'mouseover', [targetStage]);
+				this.forwardEvent(o, 'mouseleave', 'mouseout', [targetStage]);
+				this.forwardEvent(o, 'click', 'click', [targetStage]);
+				this.forwardEvent(o, 'dblclick', 'dblclick', [targetStage]);
+				return o.attach(unmasked ? this.unmaskedShapes : this.shapes);
+			};
+
+			const env = {
+				addDef: this.addDef,
+				agentInfos: this.agentInfos,
+				blockLayer: this.blocks,
+				components: this.components,
+				drawAgentLine: (agentID, toY, andStop = false) => {
+					const agentInfo = this.agentInfos.get(agentID);
+					this.drawAgentLine(agentInfo, toY);
+					agentInfo.latestYStart = andStop ? null : toY;
+				},
+				fillLayer: this.backgroundFills,
+				fullMaskLayer: this.fullMask,
+				lineMaskLayer: this.lineMask,
+				makeRegion,
+				primaryY: topY + topShift,
+				renderer: this,
+				state: this.state,
+				svg: this.svg,
+				textSizer: this.svg.textSizer,
+				theme: this.theme,
+				topY,
+			};
+
+			let bottomY = topY;
+			if(this.checkHidden(stage)) {
+				env.primaryY = topY;
+				component.renderHidden(stage, env);
+			} else {
+				bottomY = Math.max(bottomY, component.render(stage, env) || 0);
+			}
+
+			this.markAgentRange(agentIDs, bottomY);
+			this.currentY = bottomY;
+		}
+
+		positionAgents() {
+			// Map guarantees insertion-order iteration
+			const orderedInfos = [];
+			this.agentInfos.forEach((agentInfo) => {
+				let currentX = 0;
+				agentInfo.separations.forEach((dist, otherAgent) => {
+					const otherAgentInfo = this.agentInfos.get(otherAgent);
+					if(otherAgentInfo.index < agentInfo.index) {
+						currentX = Math.max(currentX, otherAgentInfo.x + dist);
+					}
+				});
+				agentInfo.x = currentX;
+				orderedInfos.push(agentInfo);
+			});
+
+			let previousInfo = {x: 0};
+			orderedInfos.reverse().forEach((agentInfo) => {
+				let currentX = previousInfo.x;
+				previousInfo = agentInfo;
+				if(!agentInfo.anchorRight) {
+					return;
+				}
+				agentInfo.separations.forEach((dist, otherAgent) => {
+					const otherAgentInfo = this.agentInfos.get(otherAgent);
+					if(otherAgentInfo.index > agentInfo.index) {
+						currentX = Math.min(currentX, otherAgentInfo.x - dist);
+					}
+				});
+				agentInfo.x = currentX;
+			});
+
+			this.agentInfos.forEach(({x, maxRPad, maxLPad}) => {
+				this.minX = Math.min(this.minX, x - maxLPad);
+				this.maxX = Math.max(this.maxX, x + maxRPad);
+			});
+		}
+
+		buildAgentInfos(agents) {
+			this.agentInfos = new Map();
+			agents.forEach((agent, index) => {
+				this.agentInfos.set(agent.id, {
+					anchorRight: agent.anchorRight,
+					currentMaxRad: 0,
+					currentRad: 0,
+					formattedLabel: agent.formattedLabel,
+					id: agent.id,
+					index,
+					isVirtualSource: agent.isVirtualSource,
+					latestY: 0,
+					latestYStart: null,
+					maxLPad: 0,
+					maxRPad: 0,
+					options: agent.options,
+					separations: new Map(),
+					x: null,
+				});
+			});
+		}
+
+		updateBounds(stagesHeight) {
+			const cx = (this.minX + this.maxX) / 2;
+			const titleSize = this.svg.textSizer.measure(this.title);
+			const titleY = ((titleSize.height > 0) ?
+				(-this.theme.titleMargin - titleSize.height) : 0
+			);
+			this.title.set({x: cx, y: titleY});
+
+			const halfTitleWidth = titleSize.width / 2;
+			const margin = this.theme.outerMargin;
+			const x0 = Math.min(this.minX, cx - halfTitleWidth) - margin;
+			const x1 = Math.max(this.maxX, cx + halfTitleWidth) + margin;
+			const y0 = titleY - margin;
+			const y1 = stagesHeight + margin;
+
+			this.width = x1 - x0;
+			this.height = y1 - y0;
+
+			const fullSize = {
+				'height': this.height,
+				'width': this.width,
+				'x': x0,
+				'y': y0,
+			};
+
+			this.fullMaskReveal.attrs(fullSize);
+			this.lineMaskReveal.attrs(fullSize);
+
+			this.svg.body.attr('viewBox', (
+				x0 + ' ' + y0 + ' ' +
+				this.width + ' ' + this.height
+			));
+		}
+
+		_resetState() {
+			this.components.forEach((component) => {
+				component.resetState(this.state);
+			});
+			this.currentY = 0;
+			this.hideNest = 0;
+		}
+
+		_reset(theme) {
+			if(theme) {
+				this.knownThemeDefs.clear();
+				this.themeDefs.empty();
+			}
+
+			this.knownDefs.clear();
+			this.highlights.clear();
+			this.defs.empty();
+			this.fullMask.empty();
+			this.lineMask.empty();
+			this.backgroundFills.empty();
+			this.agentLines.empty();
+			this.blocks.empty();
+			this.shapes.empty();
+			this.unmaskedShapes.empty();
+			this.defs.add(
+				this.fullMask.add(this.fullMaskReveal),
+				this.lineMask.add(this.lineMaskReveal)
+			);
+			this._resetState();
+		}
+
+		setHighlight(line = null) {
+			const ln = (line === null) ? -1 : line;
+			if(this.currentHighlight === ln) {
+				return;
+			}
+			if(this.highlights.has(this.currentHighlight)) {
+				this.highlights.get(this.currentHighlight).forEach((o) => {
+					o.delClass('focus');
+				});
+			}
+			if(this.highlights.has(ln)) {
+				this.highlights.get(ln).forEach((o) => {
+					o.addClass('focus');
+				});
+			}
+			this.currentHighlight = ln;
+		}
+
+		isCollapsed(line) {
+			return this.collapsed.has(line);
+		}
+
+		setCollapseAll(collapsed) {
+			if(collapsed) {
+				throw new Error('Cannot collapse all');
+			} else {
+				if(this.collapsed.size === 0) {
+					return false;
+				}
+				this.collapsed.clear();
+			}
+			return true;
+		}
+
+		_setCollapsed(line, collapsed) {
+			if(typeof line !== 'number') {
+				return false;
+			}
+			if(collapsed === this.isCollapsed(line)) {
+				return false;
+			}
+			if(collapsed) {
+				this.collapsed.add(line);
+			} else {
+				this.collapsed.delete(line);
+			}
+			return true;
+		}
+
+		setCollapsed(line, collapsed = true) {
+			if(line === null) {
+				return this.setCollapseAll(collapsed);
+			}
+			if(Array.isArray(line)) {
+				return line
+					.map((ln) => this._setCollapsed(ln, collapsed))
+					.some((changed) => changed);
+			}
+			return this._setCollapsed(line, collapsed);
+		}
+
+		_switchTheme(name) {
+			const oldThemeBuilder = this.themeBuilder;
+			this.themeBuilder = this.getThemeNamed(name);
+			if(this.themeBuilder !== oldThemeBuilder) {
+				this.theme = this.themeBuilder.build(this.svg);
+			}
+			this.theme.reset();
+
+			return (this.themeBuilder !== oldThemeBuilder);
+		}
+
+		optimisedRenderPreReflow(sequence) {
+			const themeChanged = this._switchTheme(sequence.meta.theme);
+			this._reset(themeChanged);
+
+			this.metaCode.nodeValue = sequence.meta.code;
+			this.theme.addDefs(this.addThemeDef);
+
+			this.title.set({
+				attrs: this.theme.titleAttrs,
+				formatted: sequence.meta.title,
+			});
+			this.svg.textSizer.expectMeasure(this.title);
+
+			this.minX = 0;
+			this.maxX = 0;
+
+			this.buildAgentInfos(sequence.agents);
+
+			sequence.stages.forEach(this.prepareMeasurementsStage);
+			this._resetState();
+			this.svg.textSizer.performMeasurementsPre();
+		}
+
+		optimisedRenderReflow() {
+			this.svg.textSizer.performMeasurementsAct();
+		}
+
+		optimisedRenderPostReflow(sequence) {
+			this.visibleAgentIDs = ['[', ']'];
+			sequence.stages.forEach(this.separationStage);
+			this._resetState();
+
+			this.positionAgents();
+
+			sequence.stages.forEach(this.renderStage);
+			const bottomY = this.checkAgentRange(['[', ']'], this.currentY);
+
+			const stagesHeight = Math.max(bottomY - this.theme.actionMargin, 0);
+			this.updateBounds(stagesHeight);
+
+			const prevHighlight = this.currentHighlight;
+			this.currentHighlight = -1;
+			this.setHighlight(prevHighlight);
+
+			this.svg.textSizer.performMeasurementsPost();
+			this.svg.textSizer.resetCache();
+		}
+
+		render(sequence) {
+			this.optimisedRenderPreReflow(sequence);
+			this.optimisedRenderReflow();
+			this.optimisedRenderPostReflow(sequence);
+		}
+
+		getThemeNames() {
+			return (Array.from(this.themes.keys())
+				.filter((name) => (name !== ''))
+			);
+		}
+
+		getThemes() {
+			return this.getThemeNames().map((name) => this.themes.get(name));
+		}
+
+		getThemeNamed(themeName) {
+			const theme = this.themes.get(themeName);
+			if(theme) {
+				return theme;
+			}
+			return this.themes.get('');
+		}
+
+		getAgentX(id) {
+			return this.agentInfos.get(id).x;
+		}
+
+		dom() {
+			return this.svg.body.element;
+		}
+	}
+
+	/*
+	 * Handlee font, by Joe Prince
+	 * Downloaded from Google Fonts and converted to Base64 for embedding in
+	 * generated SVGs
+	 * https://fonts.google.com/specimen/Handlee
+	 * base64 -b64 \
+	 *   < *.woff2 \
+	 *   | sed -e "s/^/"$'\t'$'\t'$'\t'"'/" -e "s/$/' +/" \
+	 *   > handlee.woff2.b64
+	 */
+
+	/* License
+
+	SIL OPEN FONT LICENSE
+	Version 1.1 - 26 February 2007
+
+	PREAMBLE
+	The goals of the Open Font License (OFL) are to stimulate worldwide
+	development of collaborative font projects, to support the font creation
+	efforts of academic and linguistic communities, and to provide a free and
+	open framework in which fonts may be shared and improved in partnership
+	with others.
+
+	The OFL allows the licensed fonts to be used, studied, modified and
+	redistributed freely as long as they are not sold by themselves. The
+	fonts, including any derivative works, can be bundled, embedded,
+	redistributed and/or sold with any software provided that any reserved
+	names are not used by derivative works. The fonts and derivatives,
+	however, cannot be released under any other type of license. The
+	requirement for fonts to remain under this license does not apply
+	to any document created using the fonts or their derivatives.
+
+	DEFINITIONS
+	"Font Software" refers to the set of files released by the Copyright
+	Holder(s) under this license and clearly marked as such. This may
+	include source files, build scripts and documentation.
+
+	"Reserved Font Name" refers to any names specified as such after the
+	copyright statement(s).
+
+	"Original Version" refers to the collection of Font Software components as
+	distributed by the Copyright Holder(s).
+
+	"Modified Version" refers to any derivative made by adding to, deleting,
+	or substituting — in part or in whole — any of the components of the
+	Original Version, by changing formats or by porting the Font Software to a
+	new environment.
+
+	"Author" refers to any designer, engineer, programmer, technical
+	writer or other person who contributed to the Font Software.
+
+	PERMISSION & CONDITIONS
+	Permission is hereby granted, free of charge, to any person obtaining
+	a copy of the Font Software, to use, study, copy, merge, embed, modify,
+	redistribute, and sell modified and unmodified copies of the Font
+	Software, subject to the following conditions:
+
+	1) Neither the Font Software nor any of its individual components,
+	in Original or Modified Versions, may be sold by itself.
+
+	2) Original or Modified Versions of the Font Software may be bundled,
+	redistributed and/or sold with any software, provided that each copy
+	contains the above copyright notice and this license. These can be
+	included either as stand-alone text files, human-readable headers or
+	in the appropriate machine-readable metadata fields within text or
+	binary files as long as those fields can be easily viewed by the user.
+
+	3) No Modified Version of the Font Software may use the Reserved Font
+	Name(s) unless explicit written permission is granted by the corresponding
+	Copyright Holder. This restriction only applies to the primary font name as
+	presented to the users.
+
+	4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+	Software shall not be used to promote, endorse or advertise any
+	Modified Version, except to acknowledge the contribution(s) of the
+	Copyright Holder(s) and the Author(s) or with their explicit written
+	permission.
+
+	5) The Font Software, modified or unmodified, in part or in whole,
+	must be distributed entirely under this license, and must not be
+	distributed under any other license. The requirement for fonts to
+	remain under this license does not apply to any document created
+	using the Font Software.
+
+	TERMINATION
+	This license becomes null and void if any of the above conditions are
+	not met.
+
+	DISCLAIMER
+	THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+	OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+	COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+	INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+	DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+	FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+	OTHER DEALINGS IN THE FONT SOFTWARE.
+
+	*/
+
+	var Handlee = {
+		name: 'Handlee',
+		woff2: (
+			'd09GMgABAAAAAD3EAA4AAAAAi4QAAD1qAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' +
+			'GhYbxV4cKgZgAIF8EQgKgbpIgZNlC4MGAAE2AiQDhggEIAWEDgeDKxuhdSXsmCEe' +
+			'ByC2jBgVNYuS+mQUpZq0k+z/vyY3BgzxIa3ugqhFRlV1T4WqHliFgkLvX+Fguaf/' +
+			'tXTReCMU5hvZIfpErawhdoJhvGi60udSmcpUmZV+33txIHLMbEhRhomyZs7N2ods' +
+			'iOl7OmXseNPFL9fnzsBxPmouBP/3/Wbmvt+Om/2FCihaDcM063gCEX9NLAt4u0Mw' +
+			't27RRQwYMGqMWgUxxtioahM7sANfMfL9svpDv1r7QwmKw9y7bx3k5w1Kx2CplAiG' +
+			'qIJEAx6gUICjf39+y0xK/qS6vwbT8sAy+yrlEHe3vNdJ+jauiqvOOWRpffhe8mec' +
+			'SXiGF4IGTtgLKLV2M6lzDvAXO0QkRtk8v62KREEBwaihHQPHQUZ7YfchZmHtcm8+' +
+			'Z6+az/v4cS/auKr51LlyEhygfzOnr94kmRQnbJcIXjvUGdVV1xbM/AtMwQWbE4Nk' +
+			'WTgj7VNM7tsSphi6w7Xer64GAF9ZWaEQhamQGZvYSbJ32eOle7QPGCaZ8v8BQACc' +
+			'a4LR5sPtg6JABnLj1wL8AT7Ig0UXwD88/7/XfvbvhPOLI9BloMsIxZsiDEJjTHLf' +
+			'vMw6c9alqsNd71f1JrRMfmuZUDJl+RESNELxW1Gh1Kq+QyiUQwiLBqH532XN5lbd' +
+			'0eXiwCGbNynX8me2JbTMXE2omWuTmaWEddCFA4eSW9ospRR3QvI8/vf70bJLSBva' +
+			'prCxqOq7/933bfWsOurVtGuIZKolhswQGbJVhtI2JyxEQs+omyBJQJ8+owwHUkQk' +
+			'9Jq/DeT7/htzRkREiHgi8hDpxlIJr0M6CN3euB9bfbmXPn+2CXsKDDCEMYJ7/34I' +
+			'cAYeiOz8vQ8DOCFHDXS5TvYA4vNtWwMgggPgFUc9PbY0ADRwdw846HXQ9qjp/yfP' +
+			'OqIoWmIoLqQrIZ6SqqBHYVhYHuwXuBjuB6+DD8Cvwm8h4Ag1woQoQNQhBhDLkELk' +
+			'EPJTVBHqK/QJ9DOMB3MNm4x9hJuNe49vIxAJfYTnRDKxhrSKLCU/oRRQvqE+o1XR' +
+			'ntOL6AMMPGOC8Q3Ty2KzVrCesC3srRwkh85xcJo4/3D7eEjeVj6Xr+EfFrgEt4Ry' +
+			'4VzhXyKtyCRyiLJEJaI+0YholbhEXCVuEfeJDaikK5mTGlM7t1SUSKl6LLDOJUBR' +
+			'QUACHMOBIhCAIEYMExlJsDBRRCQllJBOGWW4qaWODJppJpN22vEyYoSPMeOyWGyx' +
+			'HJZbLpeNNstj2oxCzjqvHATKXNhGKJv4sVkAM92BP3MEW+Ire+UeHEou02UugSF/' +
+			'Rs/TIybjDymoqi7KSkiF6oAu1aMNYyukNRbNnNoSLHVMXEt37sm9Y7bg5hdVaCbs' +
+			'i/upZWaddaJAqWgRL6FlVUXVott4B+lhffVQrslH4jEyVTyVfQSAYVb8waSwLLM8' +
+			'lCJTlUVxSVrBOnhX1cOGOUw6YRhaoC1hu9k5e/ToQ7yNH5zSuXZ9Z+6+7Un407GQ' +
+			'SJOH0uPsndyp/KgsbYABNaImzMyhwcMcf9/0Z2zgmLtn3ntcEcqFVFwkT6TkY+O7' +
+			'OCirR7zNn7Z//Pv7/3yfhr7CluKlI3OuXUNRTscMuL1AKYjzN0Ae6LtWimNVo6hT' +
+			'clTRajlvSzraXc2eRl8+cK7xR/jY6eTC49n92zeszJcQcIXM0BGeuqtkki1yWT6T' +
+			'Elmqowa+D+34DJgKSwUPcGccS++aWAi1OMar1CLtuRSePK/6ut9vZHYEDEVDpTW5' +
+			'jKNMJZghGbqPVUzlRunA+JHtSjqM0zxcWjT7qY49n08atNHzpffVINN4Sq/G5oZr' +
+			'DyLo07HU38/J87ubnQy1SGHDkest3yN4eqbkt2+w16d440jae0Jdv779BDgORYvk' +
+			'OjdUeiSZsjnjUOuomIiEfN/GMVP2ZXp+spVRjBi0OHXFqNqouqloUb7TM2lYgCpX' +
+			'4spEhauytaSujarNNy1tg472oP2zGjLaao7U4+aEmzJf3Cy3Ws0ZVf64WnKYneVC' +
+			'PornpBypzk3RdtK3weAEo4HAoJsRumuZG366FYc1HApypjYODbVCFJNEa/JZqktf' +
+			'LNNmX+RaqWA0l3U96YoNC0yRp+gLfE6Jhxv0kzvpAdHTOSmVJwreSIFVQRGWmApk' +
+			'URDAYnFuuw49BuWYtUs6ny/TD1g7cR5nLxyVN+dm7ktapYkWT+tMKaMisSAsTAQA' +
+			'FAb33mwfHyIaPhKOyQk9RdnVO98TgFlCHKpmpX8FX9uhTlNd+7fkyXx79JB5zvUC' +
+			'IdTnPykMxMl1l5immsxKMVsAqpWi9ZJ5H9QKrMoXBs0GB2wz81mt9nUG9ocqTWOk' +
+			'N7Y24U0dzpzeaoXXJvcWbO5u7IoHtQmyRp24X2fnOVpekShDlQUBzGvKyytUgVHJ' +
+			'Il0yChoEQRAAQdfdpKd92cAsGCwGbC9mOtflVkzWIH5wQP17NTlxkZe5KC+mAlkA' +
+			'gJkUWlBAoG7unUMaRvbNdgqQpqtpgZH7CggKAlgcsNkWNgY5WTxFgyP5CWjMqTeb' +
+			'3PNQv/BC7LPnUoXWzyZ3RmELJHQgIeRG1VM2MbOhni57avjglIAW+aSBntktvobY' +
+			'TcKALMrfG/Qn+N/YBGfmuO6ee49RhiTEp9U8TH7N22n/jWTq3GXpREGtUuZEPRzq' +
+			'JyxZiOa8xx+mTw79qklH/htTU8mt8HWfbf6y/cvu6oPSB80VCqAwUWrlBatUzHSY' +
+			'hSwYODGrRWbEAy8IWFpwLk2f0AioQrUB4wDAJ6NPSQTgsFhQrFgQJw4HRBtMyY0V' +
+			'3HQ6Qgl8Noc84AJ5jD7CC7pmIv+v7CJvaK0ERwZELmUt/qzFCYo68lgwA7WNecRJ' +
+			'al+RD1+HElgzOTaUCgwjcDqLxYnNuhqevCOoFljO3ijgFI6QfCEH0cMtmUB7qZ8d' +
+			'Wq6Rx+uOKrfVfPDl7tDFBzQOhcNE0Nhkdgmx4rcWUA1IIH4ZZ2Zw0ZY5Iojjd1J5' +
+			'S99pihV9irnNXQ+wF7oVjvL7fyfciJfiTiT9MJgJEoAcQfFwQaJ6uOiRkgfL9ioe' +
+			'qYprSIOnZR7mUR7hAR7m9Wv5qaF9zWMjP449MPHu1EMzL+ghbsWGv+b3X/z04y99' +
+			'8rVPv/j5z776/jefW4hZVevhd7///v9+/OpPX/3tzh9fu/vN7uyDBQonj0RGaB9X' +
+			'II6cPIJhQdFJVeTCjhtgAUEsgHxEQ1rUXJ1pZUjnvcHl/694s5dHAWaCYNhfIbfR' +
+			'nMyV+mZ0n1lyaQDgQnr94jaFQiwznRxOcag6KmqU7JXZihO7nL3V1uk47jpJNESp' +
+			'MYwemgialHToM5PChX4B8HrQ3WtwtyAgkH5kwLR8mnI0r40K4XY1VcSxABaNEY2G' +
+			'o0B0RFcPem91hmxe4qk8CCZjX/gZzpWXXivjRqGhkC6OEUkYPg0rEGJin9ZlfUGj' +
+			'ixecSAxtco4Ql8/1LG6p3VgOyH0VCb4yGY5zhnPhNN6pa+ApfBv0XeYptxuoLlrQ' +
+			'BRniAiQGsccaORvFX77Mf4ye7rcyWTFS9Q9Bxny2s77Irv/1DPbtD/w5xDRjI8HY' +
+			'xERzampmL9q/m8Lw43znxYGvDix4rSDWSN9f+u3m3endzgNKAvj3zFEO9SbcKpRN' +
+			'YSnOoey4g28cFhoRY8dd7KG7YXKsGCo0YmE02GO3GIQfvoai2BaJNi9nSmdZARih' +
+			'NqIH2lT4VZjkBhpBSpGSssW917pp2/WOVPSpIoNpiSwBjsGnyIIleD+4h+mSLcd6' +
+			'jrGrdI+9O2zNjdAA16dbSs3S9zM1QWoX0MfLZu90fXoo1LAKZM4MPbY9A4TVmeSX' +
+			'mhq03uuKNJMz00PRTAFMoBKp83+ilmbt/Efu+XrxroJ1WBqB8ouoXmZrrLyq4nZd' +
+			'+mD8wZTK9GZq5OjIkfxM6uX+wbJLXVlvnG6zt038QJVYEn8VtWKbFRdD2Rppo91l' +
+			'qJfiVVbdGO/yKnciaQvYoFdfXnouYwOXmstJWjyT3NR2cDOpkwS4sODUhg1rZGuU' +
+			'XBLjCoE4ol2nSCDZfOppxa25+IAlvNgHOgbD88HiAAAD4IC6K5Pv2IsGloJhbO2s' +
+			'YPS7UDHHSCYOIBwkA+4hKTrx5ZQoesVUrJOdLRRuGjQbp+KfXdJNaU/Kist5XF6M' +
+			'xEnucQqiIkV1yR8HWS1Qq1SEQZVIzLtVz3LQyzIEC92WDq1g1p50V3hsFT4ji93q' +
+			'HFRxlZthwaXhQoUGS+ZKzC8xGHRlhBbRCBLUiONaao4UyDjWTqysQ5QjWLkMcsQR' +
+			'S2woVNzq9Lge5TuG3z4aZiY517CJI11C7p0ynbnlbjBdxPXnJS8IO25VJSC25goi' +
+			'Mu2Snu2AM5361usYnnUz2ayNRl017ABzf+cE70ZbnZCTa27zAYw8ykqsWSouI8vb' +
+			'WsHr5mmdqtkEkJsGE5Ox3eyQ3DE9wOsiiPnJrM4g3Gg2yW+m2rSVqw1pZGN1m3un' +
+			'968zQOI31gnCHtyD0ZbNhJ9uXpFyupDQY+5yOFFTzMkOhxCJAbgWJcc0GaCiSc/l' +
+			'COUMOB0AaQhCKSjWQxYQRKGyEgDluuyJDEsr5L9xOx12OkOBaivgYs5i09nZ2ukQ' +
+			'K1dyiGFEICug/fIe4N+wAA/7Qo7Bt8tfOxHG6JJ+B2eXAh/RC+3g/+CaxWXumDkY' +
+			'5ZQ+Sqepw0dzT/NP0l2RZFUCg6MKcM4lGDGZPjLt38KzFTgbnM6A3IqSJiQ7SI3r' +
+			'6VNwZRo/Vz0U38luR39+jyashWIExGBWQ+lUQwwod8k5DeYpCGOPCRMyUWMlI6g6' +
+			'vsAo4kQ5xxwreaSM7wc3GNjALXxeLhfToKSo4CAwEZQLOmkXBWwULhIva1+47RnK' +
+			'ak3fgmZDei4ux42tUeioCccNSGniMxYlQTA4XGSWPrfEHMGAzlj52YeTDxobyYMz' +
+			'Vb8WcjGvlPxdepTrSVkl0EHzntW/yQVm1pjmloETsSMiZBQVUNZFox7mLrl7kvoT' +
+			'SOAYQUHBkZAiAIDcA6cJRBeRR3ooc207xTV6rkO9Uy4JZVNYiGG9XpZdGWqpEKFi' +
+			'dPG0Pm0EOUgcyWYfGcOZx+b04/XYR3Ksj1d6MqHRhyVKzw0cuc+VH8MKMDs8ZL53' +
+			'99OmSMDM2AW3DCwuFsHlioQ1spv886heJjG7AnYncSByPXcGjQPHSo8y0qw012vN' +
+			'jxX9gqpLi4ylyKgqnajeqpqsoaopb21t97RD7TnWh6tj06FaU5yRyBKbOX3y93Wo' +
+			'B99eikR4hT9BSLiJIOCUaB4+AlnI6qjAQVSEsxh16mdqNFINuWBQoDgVgUByM/9H' +
+			'/7FhH8TlGIRCAciF6XltWFgcsTkmMImBYCgWhVyquTTCNTv1rBC9U7ed2gjYSkEd' +
+			'wbqqCJC1SeT0ORIPOUYh94BX1sLUBxH5q6M2rm1dskL+xKT84SP6dF6dvVfDwJLF' +
+			'Cm8tygb5I3qK3mC09LQKNZckZJwSUkIpIW/s3xWfNc6u3FfvzNEPOWCuh+zwg3bB' +
+			'vZRx4PhLTbkdzjadznJ7QLXLOAVn7JnW2sLMUnvQwypQ3Vl6sx9seTAnYwRsYZ90' +
+			'v7+YE4sgfnt/51yA96vn8Jeaf4BcvvwNuOa9z+TltaUV6BBv/xjbzo2A8RmLF0Fm' +
+			'AHiI4wDbRtKhO8+BgTTgfvJbxPO3yGSALbbZY79DTjjlunue+NN/Plhk5JV8lE8W' +
+			'dMJN+AmK4IgM8cf8ALBls2122O+go04666YHvvZ3j7jvpBFOwkv6b4MP9TcX58Kc' +
+			'd9qMkz5y3DFHHXbIAQOz4K/8/curjTZYa5UJDADxcFCQikTsHV9y0+U+6w/AzUJT' +
+			'76y7DwWDAFkN+ibCWvN73b6CRjwS6GwhQFeDjBvufWF9+Y1iqQi/ssyNCHsEfGjl' +
+			'4sXQF0/+RBYyDn93PfCe+Rv5jZEXAElXlutg/6DzqCnQ/7D5EwCKxJ4jc2oEIbAK' +
+			'0t5stXSyUpE6lYCYtIxqlHFCVRUYXYv0dtbvyaQTjbtMFXRx3yyKqj/1q9UKtx3b' +
+			'snJcq2gntl61tZHF1J26qGPtdG00r+f7/rY2MLNC01ge7lOFBJQn5D1KpxDqIU9H' +
+			'UAbIszJWlU3ERYxi5OtINELipnRc2iUv4yUSh4FBJq90PJNNEKMY+R1IPZLVLTEw' +
+			'diAty8pqxChGHgfYvVHiXImDE1YhRvEIJG0161gjdT22WCJGMZGvgaQAmwh1W+d6' +
+			'XEfarhzxxpYWsUQfRZIDRcxGAN4v9u7HjJTYKkfyCrDEgNoTFqflHMxQlcBqaHIk' +
+			'xofGhhwEKtSqI25KAo6X0f5A16QZfMx0EG2XU3bNakAsRinrn1mtqNFqFX3uHG08' +
+			'qiat72zxPP8u7Wzc3dlgq7zsxoEnIjkR8IGGWA2aySuoonsKQ117x5u/iwK9XL5U' +
+			'b+8Sc1N7R/dSIErgsZCRoWoW3b3wXUiVDUQIYlSfmDjAVL2/eT5HKxYvSQ2Xr8zj' +
+			'DXUWlvosujQxsuMX/P2EMlIzuE6VmcdFtQC1MUmel/BCGe2thONf9wKdYP/mw9NU' +
+			'3V9Va2wV3Vi2K6IGJSch6u4Y8Q54yenE5S3HdoJk3VCV1I1QM4yBUsJu0eGn5/pJ' +
+			'dP2pAMcuBlf+LHyFnJrVpp+jnNKOPuRh/E3pZuO9kKUKTVfjXG0KCn6v9cN9RjWx' +
+			'XC7XXSgU46eB/j4ShpyFkpkz1ENrsTRBBbAAqDqQ3wsvFXzHkQgQKsrn+IX6BHKt' +
+			'IU0N0+5IbmbUItbl3MAmsUOfa4/45ZWktKE5OYMnlLWq827prUQYcy1RRC9OMfCq' +
+			'qkUVg6MIHti+tXcJJ8rIFDJYcwqg6soB7ubGcoAVStktBWrlC3jeiIXHzaeOOG60' +
+			'mBI62FB+A5cHANhXIIR0tFylJqtQL2Y8wQwWaRGryAj7DT7bLb15NeyQbnvx2sBL' +
+			'manJgK0x185xSmRnObotg3GUBVApFq2GKucqVOO1lpbbWGRalI8HqihQ6QwyeELZ' +
+			'dT0aDPSX5xKYxdFXXt84wp7zL48wxHLEgDJG6qMU6OnydD1O3C6hveCtRVD2yf0o' +
+			'8za1NGjVM61jU/dy94m8QvfJDXSKTEU8NKkmeMwQcuQ8R2uNZD6FRuyV6Oxi3OeE' +
+			'IqqeGMMu5s3i6MuUQpWXia19PTggagERm87qa/VL2a19WtYYeOvp5bShFm1zsZmf' +
+			'wRhZzkhZzyuYRAdfhGVQFswKaAqmavO5kEbG/d/BXJq+5s49qOWcrs3VMgUkmMJB' +
+			'Y1slGK27sMRY1tGw1qrz8GSqbplioBbjEasQBbupS1RuXhqORZmVlqYj77aYRMxV' +
+			'obLWN/K+wzcjBt5w2hEgiHXb5GZn3x7ecoJm8h+ug95JAWNo0lR8hC9htWePN/IR' +
+			'YhDvcLSmm+AeIc1JiCa+NufJFa298UMsVUbOesegNWFQ2MVmOUsadqpx5+RzudlQ' +
+			'u573AHEPGSENgbgp29fMLx54oTZFUyyCnibJdI1xgWWCRWNrae0afmJ/4UORLg0x' +
+			'pvt3TOmgKMXGwOOdezd1Y/Y09HjyDJpBTrj6C2O67iAVMfBAtdR6uHvD8n5AQv6j' +
+			'MqGfSydi1yFMLIAGBMDPE0xHIDOqf+g4ul7e7ErAa1ORQkBkaCLV6vxnr4rU5Ilh' +
+			'QyU/3Cnfsk0cELfgLt7ei/X6MlqVqiYmL0QXwH9nEbOkgy2zzYcFpGm6H3VGBAUr' +
+			'0KTIMXktwjUupr6Ykk/jJscYIjAKxx09JHepX9FEf0kYFImON2azl10zxOd58M1P' +
+			'Fl1PJsiFeWakMXJ2JD2bbg+RP8U+49dRL2bTTf7W/z39gNz8YVOE3wW+agdT0Cei' +
+			'kSXk8duJYlJpA3uK6UCFCVfPh8B/VwRdV0/XyR7Ob37kW5TL+p7pfYI5+0sZfDg0' +
+			'Ouwd4oWogUeqJWAFbMWBYw9SMBV2jahWzetBNH08RNiPhUM9QjssuPtgBd/5a6t0' +
+			'CUY8w8A1C50Lb5z+tYkR+hv6ViqL1oYbL7QHojdhL9FYrc9gbZL0ZnXbhKicIupV' +
+			'khSAl+wOVCVmTm6ZcEMgVbmFjsoMoqCTSHcNmponknf6smbMEQgu2qzzsqUzkb6/' +
+			'PUS+UyjvWI7qVMU5/pACb7bNeMtp2sHPetzNYqzvXOVozLHS2hsc+519257bUnLM' +
+			'TnY4X9o9QHQaz0Qm+Yb87g71UjDG+3Bfk301REZ/F/8HwWyohGqLMgGxqSVsfkYE' +
+			'WG9v5XMiMb5V/PF/hsJB8MK/xCvltp+SGhiovEXLuRoeHnY1ed8mSxMsAN/lbYzM' +
+			'10tru3dTQ6HfFwsb3vY+HXq0B+bqLqUeeo6q6oAmIZCGs8BXot//XGyqcPRzM7Su' +
+			'rqYe3ZNAaiHJ0Bdavqkxs70HtNJti5yqo2/P+HaeyKeqpZ5UO2au4qUuIg6l/QWc' +
+			'fWmBvaO1tUbdrlNRgYguIEKh/emPU2Exgc2+2sZDdq7Ucruzdk0V35yBRTbgc44Q' +
+			'UYBqueAvcHSbumWIVgXdizJfQMdgLJS3q47TMFIZWXkUccy6119+vfhy0+/Fa7vc' +
+			'rcPAWag5ESGJsru+o51IGnk6VmG/RQAgI4tX1jBVkUCnrR357Bv3qngHHTm3QmA7' +
+			'4OGszU+44iJS6LaAPdskku2o1Weoou+wF7ZYzBLp/QkzllWoogp0aj9St6t0jMsk' +
+			'ZI8eTFBVrZaTX75w7Yzt5k3aibTe6MP+bf7eAq6n2wODOWKtJDZ7XfymoUrAdmbQ' +
+			'dQ6f4OqAcmNwLSs4ViTkefZtv+RowjH7pMHvRhc/LQQVQrk3gyIjvfb4h++kIG4r' +
+			'mBdosa+QSQe0MTHSpLA6R7d2q93Z1+3bV/jys9RCo9FWo+Wrb05ztDAJH+Kruf6Z' +
+			'sjuYm0nEcnKVdjDh74uhkasiFqsTtZ6CxKiEbAiX4aoNkY3MBhY3Fdftsw6LbsW0' +
+			'syg1/9ISFAoNBgH1V8+DlpfWOMzsg/Y45meoupym15eviQxGCrHsgGb1gLOdvCX0' +
+			'LjUH7nkKPoZPgUWbeBbLXN40akcYDxLhEO4YoeqOaqHKMawpOWRrI1NslmP3UaEP' +
+			'P126qZ5uOu7ISMELfTEkfHBCYpcN2cW3rd+2CtnZWOZjwiihW+HsyFlv2Ovll8zU' +
+			'ZdzLTbHIDV/rtv75Q1Mc/XJ81DOyGd84PQVew3aGtB+mjJC3CG6X+HAWVBXhC/Fx' +
+			'TgEzZ8+mrwG1Nkma84OFEljYLglooOrxZws3VoL0p9Cui/+UULM4Lj9lcD1N081G' +
+			'+TOWUrAXOI6PObQ20q8sZbbW6RjXgCrJf7jV1x0hFr21Mxk0Lbl+Xhmdyth8udPR' +
+			'SHWP+7wPDEqlEaoudNlsa/Y7DnKQrnJ1QfkrepJ4jnTEtCXImL59BWGF/lbTRL9g' +
+			'4NHafItFqfd6SbqYguqUJv9SUV454KzvkNy60uUA5YsvnsmyXZPo/pcinGArd7jp' +
+			'0ZeToAVOHQn0w72rW85alQ7FXoyaxIVXEdPGz2WlYk+uGEjPUpWPrXWzbSNvj8W6' +
+			'dAaDsGrhrqLt1TpUsGhZ1xVq6daxaJSH6JsBAR9+OkeEDiDu6X50ERpU5XfM1Dq+' +
+			'P1D18MLD08FPtevemdThe5lHcx5PrphtbaW58o3uSSHdGG+c0s8I42fL+qRV4BzG' +
+			'4yFYWC17mFzB0Z8gX2zTCQunrpf0kjyDdo1psG9uhTPp+crlyvX1r4vtmnBGUVkN' +
+			'tslLC+nmf5fcUtInBvu8OaXZc30v3rSVpBGviI3SZtqNK2lu68edxhFXuLyIsOQd' +
+			'R6/YaDHpOjVn8IZagCXxiqCxI5a3AAtJ1wbW5aaxVNKN4FU6JciRlUMTHaZzXq3Y' +
+			'Jr5LlPRBDJjaf3eKL+3jqKqW3aGwZe5NZcnbBrUJoW9q5GoHUGHjjMUy6aa0oluB' +
+			'DkZyr5C35FqDbQilWGlrBPefmvQ4wVp7Qx7efbp5pxQguoSzkpx1Rv0lal1WFHvn' +
+			'1XQaF9WMEcY7hcxy+VL52vD+MWrkcz+vCArx+LzZ9C9z0mIZkWJ7Nfq96xpb5Txt' +
+			'j7XWchmfyhpqlqOc2wucidonSszBySNP+O0D/7p7cnpdzPH3bOCjUuXeu9JewOn6' +
+			'vK38z96BNIcXPwXvvO0dRCsZFgV6jfq203Lk5bYzIeLe8biN59yzvofidHluqzxB' +
+			'1/GcaniTpBPkfT7SKUN6r6QCNOQyKdCg3pes6MWGzR5iJiQ36We/vT3U36RNnqo5' +
+			'ahlD+1TjbHegXTStQlqmH9hhRRThhYPwlk4yFEXWclImNj03A6ENcJeWf0ICNw+L' +
+			'pzVZnGCWyAEBWB9bJ5RCUJLTG9tI2lGTJENGkjZddJfL8VFUhNCiWwu7Wxwv/TfV' +
+			'VCzlWVpn3i+Ixm5mLam0lqSIGttOfDxuixikxB+m0K5xH9bGnAIaSiQCyzs5f9Iz' +
+			'3TY35/V1efrqn9DePuSWCCca2+/0m0GSIWofGIpwyLxPTTKtzSxUMiWtMJnulPzX' +
+			'ECpMOVIVZYtX4s6sGTEvxeaGLRyDOEkHXkxHF4NRqDQo2WQJOidUBdMgGhSuEWu1' +
+			'LSYOlJqZetLR3XRFNOPWZ02eUbaTR0QeL6eLKY3hT+wMJ/ei1VRtCXtdG7v2wvRi' +
+			'wHBjHhucYYjZZ8ZmKGlDM/SjzJMUJ5iOZYvFcha7giZh4BaU9LOgnnrm2Nva/dqz' +
+			'pn2vuNLSSiiSlpKWTUu3CY7GSsFiiBPgpibhXvBd8QhJTdwfyztVVPMDfzovG3tv' +
+			'4DgaHzy3u5fFdG9qA3N7iCg0oTC59sKoJVmSSpScFAGNCtJNgZwkkkORhcVP8+mr' +
+			'dbV7io9IdnRaON+Ejex6xbeEeX4RFgSxTIjaRdzFeKjxT3YwOnBZr8x5ZKy0O7M3' +
+			'k+9eZgvjof3kz/RElKWpB00Vn2RF/FkuC7OX59n0AG9MywR7CJvJ3BeoND4quFB1' +
+			'stdExMRU/JbZsu4RfTkw+ouLtdtHlgm6V99hlD9xX973XOZySlX3HywWj1iuE62r' +
+			'Wc6NWpMcPSWIuSR63R8OfuLGYVSnL/ZGMm9BztMLcP/Yyd6O20Dm0SF++KXYa0QO' +
+			'nbAEpd0sYimnFGtIYUCbEpBJ2kIVtyLxOKbDMjeCMXcraQZ3E07eSvoCdx5OAfvd' +
+			'lBaxoowmiBV1wUiZLKcniIwmK3r0L9NwrBSClfs5jkXiyZqVN4/Nozze2uzXxHEN' +
+			'fvpUg0U/TMHeUlNS0mbwLLKA4WSumqrYiZ4h6PAduLQGKIGvhxLVj8cKcId9uJQi' +
+			'Pe5f8O86UIdaw6K1evQm+0FomwUHOQSyDV87w3xPD4Rya38M7HkDWQhs6NVsOmQl' +
+			'xDE7OTYcilzMMHzmQ8HgdoXL3p6bzR6Pz9K6IOuRsdZZ3w8LdBwVhzZy+z1kLZBq' +
+			'moylT3Iqcur+eIpMUie9Tm496xmMEeVs6T5cu7H/6IGwxLjisFNNLFWyOqskLc6f' +
+			'IRtJXIgI2Z8YFXU2noIAzT9TNLwgAi1NSkMiKzG/oZgMdL1/NRBGrCTLo5MXmH+g' +
+			'v+GS7xrmRVOwLTzKkUoheehpK5ZMJOvc24BlDuVyEYJGJpaWE/biFr0glYF775uO' +
+			'XXmx40IEHEPCEXx7Pv73i7dOTUahYQCyFAkwe6jyus/ON19VvOPImj49Da5de8/3' +
+			'J2XCJOP4I9s2ykgOd/RejzI1HsuiES2KPCoUnYcK1CFQyeKKtbOjGeeqOny236wx' +
+			'q48QXDTf2fhXGQgVEnQQwyGdWrxIhhFDBkUjg2S+omaqmACHNMRgftPhEbshcCs0' +
+			'iSIYbwGvMO4ggtBPXLi1zj3NjCV95DWAocCzSMNcpIjMNLFyoJEGUI5E83EUHQrk' +
+			'Ctb4HVa9858C85+PBFPZhjn3E7K2bVZSERBK1rb7CWCk9EhecHzH1muTeanbV9Ze' +
+			'bjpY8eBbR0dJ/JJJ3VhzdmKwIY4oySnRUDp4yV+AvdtyHpUxrBgyihWIrCLQTPMk' +
+			'rHefC3xumwlcTv0VTkD43VUj/g4seWVcNTESTRMra5oa6tsn5+Y26PWSu/+TWfP8' +
+			'u/Md9k+eP9GBvmB3TL83LqF83KvD5iRrvGsGc0OLg6MiENgIZnm+J7bQYYxwGCIl' +
+			'kMu/83+4XlYqvRHu0UszyFNeIrCvQH2DFcjQNPR0uRFCXfQXhMLesuwvJHKlHxpl' +
+			'MP4chK5HzdELV0H7uFBo6KR0d0LcEO1LjciQ8Gf5T5AUcMX7DCZxrW1lW83IWoiT' +
+			'mCwmBWVtnhhzNekJeiwExdJuKo5Myq+pthb/iUY3wkkh++gbVEDA2x2d5G2F8d5a' +
+			'wf6fo9ZPiqKNR0YsSpO1obRmTtzA61zb3MK0maWDPgmL0nWHpCf5SSqDs1yB/D/Z' +
+			'2u2z3CsBP5sKiVpDLc5SR8sD0i+uHFGwSEiFcVXpKWhE9PQTf22dbC4pBaTtlRVz' +
+			'vFqz0jyiiymOzziRfHJYadnrzw1eHF/9ZVOwLcOmXuXbd3DoKi2hOGp/BkmXbvL5' +
+			'z6rihWWUci8ETg753MuDpcMhIa66FJBJxKeuogM3q6CgVqMzmvM7Vq5pSoNYEVXG' +
+			'64Q6agAb80KSnR4MVyYvqPxDou3oA4n5h/wOKYTylthSlkUZFjREDwBjR2iz8Izs' +
+			'eEE0UUJjk59HdnanUVGh2LW4EWJjx0xOOphAYM3GkFPDROKbq/dT26KV8V9+R5ym' +
+			'ocOTKhP62+szsOqRnKtuHR6pAf1uHdL0hsKboF2DXpQFf9H7FkgaS2AcIvX6fdw0' +
+			'9CKLoARpCqzZED4zyapdXd9gSWEWtyOnS5ZYbp08xpdiPXOawqQ7//X/LnJmbTtt' +
+			'Ie1jvV/TnF9vmeMqrJ7EUgrhOh4NAyEJ1aZUTaHBt1Angizz/+AOxLaBYs+eEmdf' +
+			'UY1qfoPKWMaVp1lilqc3aJhHMzg2Cu5XVmH5Ra06vVS5dKmk1mNN8icOIwlYSj5N' +
+			'UdU9+mFmAV1m4nssV0lCZVY6WAZ/JUQ3p9OPJ9fBHmWiZ9OnnPGX/HGVaBulkewS' +
+			'lImsKvv2W0uKGsOPCaZ5Z0+HH89KzxxUdmDLSrGf5iMSGY1MD/AloGw6WM/WXG+s' +
+			'r7zeRC9LGyqqzntyQtd43ymTRa0oCNJtdFw4RjVDN+y+4DvlX8jz8qegHb3rOvOI' +
+			'eaIDYCzy91x7e5FMtXl+ReaO3KZlk2/yTL8EDheblRlX894fmJzliVlX0rXM6lsL' +
+			'UAg31GL4hNpMaqgIXBnu23JveqlD3Z+Zs7A58bfq4f3755nyg9NJhl5Mj27qxnqQ' +
+			'/MVqaMr5oHDpfai7bUc1XgDuOzqAKQHtV/wMicJAuupfaA5twaQ/ouGvLnu2WbwJ' +
+			'Q7yIjtmmguR5GJRpXRn8W3Dyi3O8Z1sM/3Zr0aigI5C6k82Y5KUChYosdaKbTCgy' +
+			'YkEoLUgfW/hGDye8wVVR3Puj2JicEsAFU2EaGnMOe8GbEMLRPbuMx9fPO/f9H3uc' +
+			'4wnfPOY601OkQeMXnq3pOTyna47GE5XS3cEl3+wkAPWeH0X45ci6O2gzaVDY4olB' +
+			'fJuJutNCR10uGBWNiQ+z15AuibGjQV7cQWkX7VoqUr4ITJ3FXAT//+loawiEfIPZ' +
+			'EssHA6ecjNi09oz2BkNzTMGY4qfJnyqV2btp/3YmScD689Bf1CqfdHaR3RudPCnH' +
+			'B1QsW9ac7Cgo+dM75tRg9LkVKf2lHWtbdELFLngLJVRQC5Mek+DAhp3wk5WI3CPh' +
+			'N2HhfMmtiI0YLLz6L3jhUjIP5E1OkccZ2sIG32hWg5+nzT23qC2OjO65AOlCIi5Q' +
+			'vuPiliN6UqGHk2xtxpbMPEdBbcsJJjzjGAxshI+8lGJaABhIQdd+kH+KHPOirtGp' +
+			'DOahZVuZ2fq+qp0f5cxalFysi4OPKBE7D8VEwUYkcszGD9V3zhDA2cjEob3m5b0t' +
+			'2azLR9fnaBfyKnMXzK91s8XDS1b3TO7ei9mz/vXUJuDTr8N3iBL2ZDIqx1e1Pb84' +
+			'n7SlCtLcgI2xHDMshqajKRBHvPkjW9hnYF7f8YXZnySHwHXg4ezPuqp9H6okjXxU' +
+			'+lBxzR3evnjX0fEi06H5XTlLmlLKDX3nwxmZbtXWhXOT6svilgxx82Nc5aq1z73e' +
+			's2U7CEFg+VnoCtEx9hS+5nM8BDhc95pLVTF6b21opl3zMlVWhPuntuJ9cVgk4mW6' +
+			'kijNLC12Hhgu8/gY6DVUzwpPm/3PNMw5G1iKdbG87K0p4NBH2aysZKyLEyUnLhD9' +
+			'0aBIHvI12K0BbJeoiFMkcgWFp8a41jV25h1ICcQt4RR8tN0ZWmDod5lUxvhyboek' +
+			'XGZMa1S5AX5NWFbaG3wcP51Vi0mh3MfsSg3EJcAPpNL1xkmsIAaUHHnZdUQiuLyc' +
+			'XBfQ4bMlZY3dC7Us0ktG0lpOrEyZo9D1umflaSK9GH5p50GA2z9Lgm2VOHyknF9j' +
+			'XI2Jv3CKos4aR+XEN6ti98R8mnjFOxpu8n2v6gydm3gFfHQlkDpoI/ZswmaxUn8X' +
+			'qyyl/uv4G7krT23mlxTi/2POkxfbdcUJ2QQHe1zAShtWCvRubO4K3krtSFWy+YZN' +
+			'eVLEMVFqApd8bJnoBa5uGTrfP2JHFHSDCCRdzdrfui8+6+Q3b7BfkSVlLf0fnYPF' +
+			'ZEVn6DPS1AE4lyGlvm4kuVutn1xvcIt+J3OcBbVr5qzWDfo514jQIC1ptbKxx8+3' +
+			'gvF9KAae2fhr3v8V18SE7wNMh4fmLlv2dRx2QJgutARnFY+CpunDWM4MBhnduvcm' +
+			'vLQvxj6SEIQ0bHF7urHjEkyPrd4yK6WDjF0fxBaDaV5YJpNMYy0pwfeziFXiryid' +
+			'BE7mOhgTT15zBJ+zmxAeLQoDvA8nY/fYmeq10i5hMuruPbZcmCztAlbSEIy1WER3' +
+			'seuJfJjQP6tEUkmkixH6YQPVg2aPmLG7w9V9EBoBaFtB2bH+MDxMFikaDawv+UzY' +
+			'sya2zr2RwViCI+ROVFxh7FSdAhOpDsymC+hzZDQMOTy1DYlgYAeAMvUSBpVCQUrS' +
+			'+WWucrxjmINyl6aCDhG8xZdwhIGcMj8uSQq6vRvjUul6P/3dHZy6Knx7YUusm2us' +
+			'hjYRipzfc6JLP8uKvROjj3QAy7VjYlQx/QUgRbwf++doy3d0R3bPqpDZheWDnvxu' +
+			'gmXh/F7/7xJtE7aYhgjBiTPMrPo8DwbM7ZD6Fd3T8UuTKgS99fGpkfGxT8+/42Lg' +
+			'iomuDTllrsrwiuFMXY3OAngREoVPwV0cIVxKt8O87Y1ngixRqpK10vmZFUl+H/7m' +
+			'whrh3jxsoR+huW+Z+Z42eUmoIE+gTKsPWhDLA/Wf0lDxNn3Zr1/HC3HfLxpxlVrK' +
+			'stbEL2qp6LSFhfrWNPlYx0LtcUJ99Cq+2jOHYj8BxpHU0CEsnfjX0Lct35Noibx0' +
+			'GJEqqT0cfrWoVp74lI4qFp1XD9f/3org4jwoNYv0zga5w8vFXKpygp9f5Ertfixz' +
+			'PCLv96b5D63miFB3QMGjH9imchK0kJteWjOgbVrkPzu7WHMRl5ImLhQnFc8USeLd' +
+			'KjEO6K6hz0a6RQpizU41+pjqv+4gVQ5uGKbDrFVBGL1m3A1usCoHOwwfYuRwxZFz' +
+			'BTuUc5kyMPw1UhPyNVsYBuXCQyrDNC8u5WvoNXBPGYA8Ee1kHYMPg54hnv/fmVgs' +
+			'RkIb3YV+MZwXn4z9lqoMYHFxPCd+ehG+SlRm1ITxz+CJfPFzMO97YDYDI+ICOru6' +
+			'brsx/uOdMcsscYXOszZMkFVMDvEWRERK5FaZ0hvLc9O6Ym+REelZKPgktqY8NJQH' +
+			'cjNLN18QI4tmd+kRmbjlltN2YMH4ZI1xBmKZAZKKspOWg+qjuDEGyIVimujpOdff' +
+			'KqMiq4GPfbRWpcjXQ1eu0M9G6Da4uBHqHFiZHJIVjE1jSRP5yEHIInTJKHjOWqjk' +
+			'C/hFzM8L5XrmU8L2N5vBXR6VFRSYixyFjFJzubKwfkwy795qNneEnov4BtJIThGO' +
+			'OAAGZiLmz3DS/2qRhSo9sH4wLKwFC38717L24/45F3x1pcMuAj7FuKLtvcSYU7/O' +
+			'vSReng7ahFAXeamUi3AhubSllNqC4KJuZ+GWem/jcGlC3uFMno/lGAtDZlHFWmOe' +
+			'sVTbD7qXMXuh1Wmoqg3/3fVgWuuzIMPefPWEXvy1ny7cN5teEZSTEtVGaGWmWhif' +
+			'sF3xE5HBeuNzcSlYVxzAHOJcZLQys5m/Sy7Gwy4HEDJkNo0uzJlo4GF7BK9yoigh' +
+			'IldYF4haOMFx6IIcn3oZPvZVlbHBnKpaFi7jBhPS3hvla19HiC57GT7O56EJ9c70' +
+			'mCxNtDyQsocI4qZCXpE3vwxXAg8BmqqfxWiGWkmI5WSMFZrKlh67IKtihwXHQj34' +
+			'9iCPlPKIo0QxPH7CBu71Xtji52D+nUXFS6K9z7P3v6sYiv/PzmMkUPvdslxZjrqv' +
+			'QTs3OX2bjea8FzEKcN+MCAnjvGRuinpBkJve3fVGTfqhZUX429XTV/m/1u6Rl58B' +
+			'1tb/c5JqtTWF+DTss9C9DN+EYpmMKlAz9H4/x8NEAtPqYEUTHeskqXyLU2S+6ES6' +
+			'zuhwrqdeMI0xPrNe2WLKs0fkaAD3LpKLXUYfNzQGpScs6xOM0HRRjaH52w5XKb4M' +
+			'ZHRuVlrM0ctml/d+pqZypv5KbN4anqKdAIFbbCrMML6Gl5A24Cu8nWdkCDb1WwJD' +
+			'LbG+Kg58DXQm//sPd43N2+w4XTk0BRYQv4gr5yKKBqOmBUwRxYtLoUFTwVLjKnyP' +
+			'gFFKbd6Lj6Owf5r5YiDaJww0SwZYOib/KF/fag11jyzZAX7BY+XMv8U2fpiNmo3L' +
+			'l+R890D8wCQwi/l5Qvf/WvKaX58aEDcWQqpW5i1Iu8yG+VBOiQ4k3MILGQIC9SrU' +
+			'R3Ggbt8DUB84/EuRv0qAnRWCWhhAqAu2BDKOyPHS4/T0w2ENUUCf3ccLLAgB6DKl' +
+			'BHmM/C+ZcVlgTkerrODTRTIGpoCUYHZrZfVuhSYio190hxQdkKKLlrdlxc0Go3cz' +
+			'PX/PUtbQ/TkfLBR+9qeKGJYvmgfJkMGwc7EMoigODYHatNk6j38a5ICXBfEQ6DEM' +
+			'WAbGV/BgD4ch3XDbDU3G36I9VDWCRQ0jEBd1yI8kWJ9tVy8OZBDg9KjsjMD1Fam+' +
+			'2OTYaDKhI7WFsSD3ecA+oXgjBlUWahlzK/ubSzlpdNYUx8lzF0RU0z+3QbKZODK4' +
+			'UlMCo4fHE1mcIB2EYdvbjaBk6qi1r3Lvr8tY/tW9einA0//rPnJTL+DkSRM+WYwk' +
+			'SHGCHgNAf2BduCQ8Knm/A1Ikwv1BqENQ/oKA8oWkEP/haF7QePhIZHKg06Y55Zc0' +
+			'uWx7OiMAjUdE13ergtMYbE4aKyKgbvjH8gi9yZlQxA9ibvdvPN6pSpReDtz7XbMt' +
+			'BstuDwELhwhhBEGgg5X4QAoLMRE5P7NCmOBB8tTu15fv/tmzBxzbOhtdNtn7aPvQ' +
+			'12ObSnr27S7YufI3IjNNIIhw6RtS8kJYNj866hE9kySMSrX+aAU/5UGd/rAXGg5+' +
+			'ASlUG2RWCWp8ugwl7XYd7EQYWRHq2jrlwoLKCeL5jIRUPmYDk/jT/3B6e94qn7RJ' +
+			'Dse9Jh5rp8ov1xxXEN2u7pBtme4TEfXug7Sf+zfvxzqosk+HQUz6/MkT5PMH8Wem' +
+			'18PRsrbp/d8eWFGTVBC+Oyrzefcoagj2K8nCyLEEhemq+OFuTTPnHva39rR/lFie' +
+			'KFauYeAiL+FoKA/hJTswgX1ShwcBuQXeWnt8RV1uW0iwkdKh7dTGxO0Cx5+h7QY4' +
+			'30PA+mywIYRNQiDiVaqPGRnUiu+elfzVjIA2CgktHscLpGulH4LkQqFvIFnpy6KR' +
+			'RBcGNGVMeA7zlGhk4ywvp52bi4Zngu9XZmUHxpbiHLRxN2fBvjgYOIIMq4tmC2Mv' +
+			'/RZbhDaFnCq2eyZLmCXMaXqRmCLMhsFod3Cz0ZmMb4Nn0mTrCYD34RSMoJjGpD5F' +
+			'P0ac1l6ktOHC9mjgHHQOEbo2sgp2Qpk7ryTTZC943R64wdGNOXcYTWOCEkX26rP1' +
+			'G1WyXqwuiZh7A3OTikJqk7lKAeQpHRdY0iEmI4jmalByvjIlKsP7e+7Zmjhm1HT8' +
+			'6tDVIHTaZFeVx9t+Pz1AVVysOOz3cGVGSXCPW5+0IqLuIpR/NgDyq5MKUYmARcQB' +
+			'3+mhSRzMDn/Od/SysO8KXbdSzNXM6VV3x/QrPu5evn5UzRQs3qpTxdWH9sjpR/Yf' +
+			'9jBOSGFIh1+qi3VcoNEiaBlcP76XtuzVEhBRSU6NODOC/llU77aFAij0ICUgKDuF' +
+			'6w4nMPmD2ZciiXKePzQY8sIGttphihTrJBy1R49tjxJ/JnU8vaYE1iwk/L04EsE+' +
+			'HoMkN5sQ/4LFqijo2oBDOCvI7wp39Up8ZEusbd/rqfsuL6RJTuJu90eQ2tKxB09B' +
+			'ReRS2Hwrut2tYLFVZAsSi9bkzbwFN3cHuM7ltUIVSRrZgMg9AoNOUHr6t7Zhl87r' +
+			'S//MRj0vU1QCQifTOxUTwMYsQkIP17/wNiLT4UGidsMU2sdF1cZUzqLkEDTsxq1K' +
+			'huDfw5hVWGHsTbyq5AhZt3G0eeATYnZO6ZiI/KKF1QqiWgFNo9BEhdVLBaE6wZjl' +
+			'oxtwiEOnHj6MfJ0humz1bmtt/VRl4V0+Q7y66NRwrBa9riypNKelbK/MeI9KJKVN' +
+			'LKY2nRV71qcWyCNjEofmdT7C9nQ1sAwEFzzQcFT4fIfCWPoehAMy4eFMkz5e0NlN' +
+			'rcVjhV27pou2/2oOeDZHzi1iJFgHPGvtglTqGa5eQZxjTikviDMP+M/M5RdRf2Qm' +
+			'y+aU2fc7Rwrj4lL+SNW77cGX0xbJ6zwpSek/W7XOM+KmS/MSUXu6qajTFjD/uVH4' +
+			'+oPLH3TDVuE9PPPwDYfH2NB+F3FK5p+NhSB3dzZuw2zy0BEkriC9qsoYrdKnVxGX' +
+			'4pcjLMECOQYGryaML0z2LTyaW6gbKfCY6bmeJGPvpmr8WMZSXT7noHz3JDkEYI/B' +
+			'VcAF48kwq+A0F8QZ11DBE2DJhlTCZ3ZzChdn8x1JrbcIz3fswc7BkjMrQqFGPOOb' +
+			'N8bZCIUpZGLr2Mq0yJTXTBnGM00vnZsEu/VOsM/JxMj/0KOSS+ypODsVKbsHiRvr' +
+			'LXiFyCZNEatzImbP6/sdrHxHSb/Bx5XY42YCYNW4Y64waTXmuLlA1GJcZI8Is3Rv' +
+			'8ioyJ+v7kgC4x/OZ9GQn0H9DPKrC9W+nT7ZDPf+PUFFybS6BZB+Tyr7B8zMwSA0A' +
+			'2POQyFQY+Rs8Un0WErdFOIj8Q9kzVHMvMoOOjRe6v/2AFUaEPenk3pFOhdaS/2qt' +
+			'jZtECzkBFirMmraFE/WGDZGI611QluzrtOzKijxHYcWcjkXDnTqppURqT2sUNIyn' +
+			'8+BMnQZ4+gJKpyFYKszaqhOeoZCwVbXqs39w3we22fpX6feYYmXN1LWj6VVdzUSe' +
+			'vLGE02UF2uba3Ysvdvbzjlv9TExU9uXqh/6weHjJatjIFvrY2r+nNoET0cj7enL7' +
+			'a6LimLKBbMzdvGxtkTU3i2LjW0ty2mLTjHl9ljhT/bajkFmsHFL97D6dXpbmNKj2' +
+			'hnupQ0RkZi6rE2rygUEk8n+A+vvtR6bng0Cw6d/XaGItgXpqwUok4ipY8j2yrvdR' +
+			'5qgdcj5DxG/mk7YohEVg4RSfU8cUCD1sUnVsHktkYr3yyGT2kNuHZczgztPJPE4d' +
+			'n/QF7hA9WL3HwXc/yR1BwiLFFhKf3yxiNH3EFa0ZeaGXc87yxKbo9S59cJZd89qm' +
+			'rG/gtz5PUBg0J+ve5ZIoBO6H0OlWquJiOVBN17duYVDehB5uxHO8VAWuHL0F5zbx' +
+			'dX32LGdoEfPpcLE5KHNXztdrCzi5L7lKKkQYYYs4hIx8ReFkYATjB3fMcWVb2Kad' +
+			'9Sdiz547l1dteAv/Vqb8fJ4ANCdo7W5wUBhnRPkJAFvQgN6G/5EBP+HV7PdWAwn8' +
+			'5p8tzy/w5+q52mCISx67cg0IgMDDz+leoYn/R3PYTwB8ti59OaJ++aZlZWM7Q6A5' +
+			'0dyuf+q5EbB81VYHd+XkPezjJTXw9Kl9AXyL1CSqDIp4+H1NplsoJ2mk8ucPdN/8' +
+			'mq4QMV1fJqHjGbW/YjUmWjdKGpTwICAxTgaKzCL8gaAsGt+KeCWJlwQ+JCxH6otd' +
+			'niD130lwx/l1gqtnwnqVUgd3OZJ7p003PwFeyvBLmBzjjSVz5EseBOAZocLbyDmI' +
+			'1GOd/3qtAhqvF51lbhN8k8XYKNAFWmM41on1Kb6lyM4I6a4Syzg9L8BL4jwjwIeC' +
+			'fMhfLWjcgouf6LlKxyf1yzyQyB/0rZPkE1p/EeR9UV4X7AJqj+JYUR9iIZ6Hz01i' +
+			'HMXzZL13CksnLp9IVI6fShD3hDlXaHfJChTgLX4+ZeqhaGuFtIaoz2ksFugRGjvY' +
+			'Wy+2GWJ+E+uQEGWCW0nifgIORz05bDwEz2+EcTpEt/ESbltZDh9u8bk8JQE1DVEy' +
+			'0XA2irYO2lZPBw6H6HauFnDO3MMz/C1LhyUQVQzZlSEK1O60MCxHhA/5uzlDr5PB' +
+			'x+JaSjdQwMgpQZwWptFdOijlYbr3JAOS+5nabThuIu4DmSmae14QhnVwI+Dp23Sw' +
+			'AhhIE9MUwZu7IYguAJUbd8Po+OpuOKHCuxG4xivyJt5PiijSx2kzNjZ1t1RXVrWJ' +
+			'L24CCSF29dEIWx+X1Vd39ZTy1tYbGlpDT0fNJu1l/d0dqpfaV5Rd71wbN40WOkHf' +
+			'DW+rCus0VOUtHaFlh6uNos0bxbaWDy8Vn1VZXTlWUb2b91eV7XWsWhyNNNdm3lDK' +
+			'1bXdq4nbx7Rbv5Am864ZdqJRxa5GO9PHpglZjqn0ZulqqamNlzDq6nWqV1sqQ5uW' +
+			'ZG99lRlTP3z4/iVw968DnxaQhFS/xRpWdHxXGG53OF1uj9fnPydIimZYLnARDIUj' +
+			'fPRyp3+9Qly8TiRT6Uw2l38kyXqD0WS2WG12hzM5JTXNle7O8GR6fVnZObl5+QWF' +
+			'RcVbxsZRWmHCAvOst8tco5aatNJsFy++s9uUfT5Z/09J6SJln916dWt/Z3fvttsH' +
+			'h/9Tudi9k8Ydc9RU19bXNWzS2NzU0tre1tHZ1dPd2993wmaDA0OGnXR/wCEPzjtD' +
+			'jjhu2qURx1x+3R5nnI2W/z0OAAA='
+		),
+	};
+
+	class Random {
+		// Xorshift+ 64-bit random generator https://en.wikipedia.org/wiki/Xorshift
+
+		constructor() {
+			this.s = new Uint32Array(4);
+		}
+
+		reset() {
+			// Arbitrary random seed with roughly balanced 1s / 0s
+			// (taken from running Math.random a few times)
+			this.s[0] = 0x177E9C74;
+			this.s[1] = 0xAE6FFDCE;
+			this.s[2] = 0x3CF4F32B;
+			this.s[3] = 0x46449F88;
+		}
+
+		nextFloat() {
+			/* eslint-disable no-bitwise */ // Bit-ops are part of the algorithm
+			/* eslint-disable prefer-destructuring */ // Clearer this way
+			const range = 0x100000000;
+			let x0 = this.s[0];
+			let x1 = this.s[1];
+			const y0 = this.s[2];
+			const y1 = this.s[3];
+			this.s[0] = y0;
+			this.s[1] = y1;
+			x0 ^= (x0 << 23) | (x1 >>> 9);
+			x1 ^= (x1 << 23);
+			this.s[2] = x0 ^ y0 ^ (x0 >>> 17) ^ (y0 >>> 26);
+			this.s[3] = (
+				x1 ^ y1 ^
+				((x0 << 15) | (x1 >>> 17)) ^
+				((y0 << 6) | (y1 >>> 26))
+			);
+			return (((this.s[3] + y1) >>> 0) % range) / range;
+			/* eslint-enable no-bitwise */
+			/* eslint-enable prefer-destructuring */
+		}
+	}
+
+	/* eslint-disable max-lines */
+
+	const FONT$3 = Handlee.name;
+	const FONT_FAMILY = '\'' + FONT$3 + '\',cursive';
+	const LINE_HEIGHT$3 = 1.5;
+	const MAX_CHAOS = 5;
+
+	const PENCIL = {
+		normal: {
+			'stroke': 'rgba(0,0,0,0.7)',
+			'stroke-width': 0.8,
+			'stroke-linejoin': 'round',
+			'stroke-linecap': 'round',
+		},
+		thick: {
+			'stroke': 'rgba(0,0,0,0.8)',
+			'stroke-width': 1.2,
+			'stroke-linejoin': 'round',
+			'stroke-linecap': 'round',
+		},
+	};
+
+	const NOTE_ATTRS$3 = {
+		'font-family': FONT_FAMILY,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT$3,
+	};
+
+	const DIVIDER_LABEL_ATTRS$3 = {
+		'font-family': FONT_FAMILY,
+		'font-size': 8,
+		'line-height': LINE_HEIGHT$3,
+		'text-anchor': 'middle',
+	};
+
+	const RIGHT = {};
+	const LEFT = {};
+
+	class SketchWavePattern {
+		constructor(width, handedness) {
+			this.deltas = [
+				+0.0,
+				-0.3,
+				-0.6,
+				-0.75,
+				-0.45,
+				+0.0,
+				+0.45,
+				+0.75,
+				+0.6,
+				+0.3,
+			];
+			if(handedness !== RIGHT) {
+				this.deltas.reverse();
+			}
+			this.partWidth = 6 / this.deltas.length;
+		}
+
+		getDelta(p) {
+			return this.deltas[p % this.deltas.length] + Math.sin(p * 0.03) * 0.5;
+		}
+	}
+
+	function clamp(v, low, high) {
+		return Math.max(low, Math.min(high, v));
+	}
+
+	class SketchTheme extends BaseTheme {
+		constructor(svg, handedness = RIGHT) {
+			super(svg);
+
+			this.handedness = (handedness === RIGHT) ? 1 : -1;
+			this.random = new Random();
+			this.wave = new SketchWavePattern(4, handedness);
+
+			const sharedBlockSection = {
+				padding: {
+					top: 3,
+					bottom: 2,
+				},
+				tag: {
+					padding: {
+						top: 2,
+						left: 3,
+						right: 5,
+						bottom: 0,
+					},
+					boxRenderer: this.renderTag.bind(this),
+					labelAttrs: {
+						'font-family': FONT_FAMILY,
+						'font-weight': 'bold',
+						'font-size': 9,
+						'line-height': LINE_HEIGHT$3,
+						'text-anchor': 'left',
+					},
+				},
+				label: {
+					minHeight: 6,
+					padding: {
+						top: 2,
+						left: 5,
+						right: 3,
+						bottom: 1,
+					},
+					labelAttrs: {
+						'font-family': FONT_FAMILY,
+						'font-size': 8,
+						'line-height': LINE_HEIGHT$3,
+						'text-anchor': 'left',
+					},
+				},
+			};
+
+			Object.assign(this, {
+				titleMargin: 10,
+				outerMargin: 5,
+				agentMargin: 10,
+				actionMargin: 10,
+				minActionMargin: 3,
+				agentLineHighlightRadius: 4,
+
+				agentCap: {
+					box: {
+						padding: {
+							top: 5,
+							left: 10,
+							right: 10,
+							bottom: 5,
+						},
+						arrowBottom: 5 + 12 * 1.3 / 2,
+						labelAttrs: {
+							'font-family': FONT_FAMILY,
+							'font-size': 12,
+							'line-height': LINE_HEIGHT$3,
+							'text-anchor': 'middle',
+						},
+						boxRenderer: this.renderBox.bind(this),
+					},
+					database: {
+						padding: {
+							top: 12,
+							left: 10,
+							right: 10,
+							bottom: 2,
+						},
+						arrowBottom: 5 + 12 * 1.3 / 2,
+						boxRenderer: this.renderDB.bind(this, Object.assign({
+							'fill': '#FFFFFF',
+							'db-z': 5,
+						}, PENCIL.normal)),
+						labelAttrs: {
+							'font-family': FONT$3,
+							'font-size': 12,
+							'line-height': LINE_HEIGHT$3,
+							'text-anchor': 'middle',
+						},
+					},
+					cross: {
+						size: 15,
+						render: this.renderCross.bind(this),
+					},
+					bar: {
+						height: 6,
+						render: this.renderBar.bind(this),
+					},
+					fade: {
+						width: Math.ceil(MAX_CHAOS * 2 + 2),
+						height: 6,
+						extend: Math.ceil(MAX_CHAOS * 0.3 + 1),
+					},
+					none: {
+						height: 10,
+					},
+				},
+
+				connect: {
+					loopbackRadius: 6,
+					line: {
+						'solid': {
+							attrs: Object.assign({
+								'fill': 'none',
+							}, PENCIL.normal),
+							renderFlat: this.renderFlatConnect.bind(this),
+							renderRev: this.renderRevConnect.bind(this),
+						},
+						'dash': {
+							attrs: Object.assign({
+								'fill': 'none',
+								'stroke-dasharray': '4, 2',
+							}, PENCIL.normal),
+							renderFlat: this.renderFlatConnect.bind(this),
+							renderRev: this.renderRevConnect.bind(this),
+						},
+						'wave': {
+							attrs: Object.assign({
+								'fill': 'none',
+								'stroke-linejoin': 'round',
+								'stroke-linecap': 'round',
+							}, PENCIL.normal),
+							renderFlat: this.renderFlatConnectWave.bind(this),
+							renderRev: this.renderRevConnectWave.bind(this),
+						},
+					},
+					arrow: {
+						'single': {
+							width: 5,
+							height: 6,
+							attrs: Object.assign({
+								'fill': 'rgba(0,0,0,0.9)',
+							}, PENCIL.normal),
+							render: this.renderArrowHead.bind(this),
+						},
+						'double': {
+							width: 4,
+							height: 8,
+							attrs: Object.assign({
+								'fill': 'none',
+							}, PENCIL.normal),
+							render: this.renderArrowHead.bind(this),
+						},
+						'cross': {
+							short: 5,
+							radius: 3,
+							render: this.renderCross.bind(this),
+						},
+					},
+					label: {
+						padding: 6,
+						margin: {top: 2, bottom: 1},
+						attrs: {
+							'font-family': FONT_FAMILY,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT$3,
+							'text-anchor': 'middle',
+						},
+						loopbackAttrs: {
+							'font-family': FONT_FAMILY,
+							'font-size': 8,
+							'line-height': LINE_HEIGHT$3,
+						},
+					},
+					source: {
+						radius: 1,
+						render: svg.circleFactory({
+							'fill': '#000000',
+							'stroke': '#000000',
+							'stroke-width': 1,
+						}),
+					},
+					mask: {
+						padding: {
+							top: 0,
+							left: 3,
+							right: 3,
+							bottom: 1,
+						},
+					},
+				},
+
+				titleAttrs: {
+					'font-family': FONT_FAMILY,
+					'font-size': 20,
+					'line-height': LINE_HEIGHT$3,
+					'text-anchor': 'middle',
+					'class': 'title',
+				},
+
+				agentLineAttrs: {
+					'': Object.assign({
+						'fill': 'none',
+					}, PENCIL.normal),
+					'red': {
+						'stroke': 'rgba(200,40,0,0.8)',
+					},
+				},
+				blocks: {
+					'ref': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: this.renderRefBlock.bind(this),
+						section: sharedBlockSection,
+					},
+					'': {
+						margin: {
+							top: 0,
+							bottom: 0,
+						},
+						boxRenderer: this.renderBlock.bind(this),
+						collapsedBoxRenderer: this.renderMinBlock.bind(this),
+						section: sharedBlockSection,
+						sepRenderer: this.renderSeparator.bind(this),
+					},
+				},
+				notes: {
+					'text': {
+						margin: {top: 0, left: 6, right: 6, bottom: 0},
+						padding: {top: 2, left: 2, right: 2, bottom: 2},
+						overlap: {left: 10, right: 10},
+						boxRenderer: svg.boxFactory({
+							'fill': '#FFFFFF',
+						}),
+						labelAttrs: NOTE_ATTRS$3,
+					},
+					'note': {
+						margin: {top: 0, left: 5, right: 5, bottom: 0},
+						padding: {top: 5, left: 5, right: 10, bottom: 5},
+						overlap: {left: 10, right: 10},
+						boxRenderer: this.renderNote.bind(this),
+						labelAttrs: NOTE_ATTRS$3,
+					},
+					'state': {
+						margin: {top: 0, left: 5, right: 5, bottom: 0},
+						padding: {top: 7, left: 7, right: 7, bottom: 7},
+						overlap: {left: 10, right: 10},
+						boxRenderer: this.renderState.bind(this),
+						labelAttrs: NOTE_ATTRS$3,
+					},
+				},
+				dividers: {
+					'': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$3,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: () => ({}),
+					},
+					'line': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$3,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 10,
+						margin: 0,
+						render: this.renderLineDivider.bind(this),
+					},
+					'delay': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$3,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 0,
+						margin: 0,
+						render: this.renderDelayDivider.bind(this, {
+							dotSize: 1,
+							gapSize: 2,
+						}),
+					},
+					'tear': {
+						labelAttrs: DIVIDER_LABEL_ATTRS$3,
+						padding: {top: 2, left: 5, right: 5, bottom: 2},
+						extend: 10,
+						margin: 10,
+						render: this.renderTearDivider.bind(this, {
+							fadeBegin: 5,
+							fadeSize: 10,
+							pattern: this.wave,
+							lineAttrs: PENCIL.normal,
+						}),
+					},
+				},
+			});
+		}
+
+		reset() {
+			this.random.reset();
+		}
+
+		addDefs(builder) {
+			builder('sketch_font', () => {
+				const style = this.svg.el('style', null);
+				// Font must be embedded for exporting as SVG / PNG
+				style.text(
+					'@font-face{' +
+					'font-family:"' + Handlee.name + '";' +
+					'src:url("data:font/woff2;base64,' + Handlee.woff2 + '");' +
+					'}'
+				);
+				return style;
+			});
+		}
+
+		vary(range, centre = 0) {
+			if(!range) {
+				return centre;
+			}
+			// Cosine distribution [-pi/2 pi/2] scaled to [-range range]
+			const rand = this.random.nextFloat(); // [0 1)
+			return centre + Math.asin(rand * 2 - 1) * 2 * range / Math.PI;
+		}
+
+		lineNodes(p1, p2, {
+			var1 = 1,
+			var2 = 1,
+			varX = 1,
+			varY = 1,
+			move = true,
+		}) {
+			const length = Math.sqrt(
+				(p2.x - p1.x) * (p2.x - p1.x) +
+				(p2.y - p1.y) * (p2.y - p1.y)
+			);
+			const rough = Math.min(Math.sqrt(length) * 0.2, MAX_CHAOS);
+			const x1 = this.vary(var1 * varX * rough, p1.x);
+			const y1 = this.vary(var1 * varY * rough, p1.y);
+			const x2 = this.vary(var2 * varX * rough, p2.x);
+			const y2 = this.vary(var2 * varY * rough, p2.y);
+
+			// -1 = p1 higher, 1 = p2 higher
+			const upper = clamp((y1 - y2) / (Math.abs(x1 - x2) + 0.001), -1, 1);
+			const frac = upper / 6 + 0.5;
+
+			/*
+			 * Line curve is to top / left (simulates right-handed drawing)
+			 * or top / right (left-handed)
+			 */
+			const curveX = this.vary(0.5, 0.5) * rough;
+			const curveY = this.vary(0.5, 0.5) * rough;
+			const xc = x1 * (1 - frac) + x2 * frac - curveX * this.handedness;
+			const yc = y1 * (1 - frac) + y2 * frac - curveY;
+			const nodes = (
+				(move ? ('M' + x1 + ' ' + y1) : '') +
+				'C' + xc + ' ' + yc +
+				',' + x2 + ' ' + y2 +
+				',' + x2 + ' ' + y2
+			);
+			return {
+				nodes,
+				p1: {x: x1, y: y1},
+				p2: {x: x2, y: y2},
+			};
+		}
+
+		renderLine(p1, p2, lineOptions) {
+			const line = this.lineNodes(p1, p2, lineOptions);
+			return this.svg.el('path')
+				.attrs({
+					'd': line.nodes,
+					'fill': 'none',
+					'stroke-dasharray': lineOptions.dash ? '6, 5' : 'none',
+				})
+				.attrs(lineOptions.attrs || (
+					lineOptions.thick ? PENCIL.thick : PENCIL.normal
+				));
+		}
+
+		boxNodes({x, y, width, height}) {
+			const lT = this.lineNodes(
+				{x, y},
+				{x: x + width, y},
+				{}
+			);
+			const lB = this.lineNodes(
+				{x: x + width, y: y + height},
+				{x, y: y + height},
+				{move: false}
+			);
+			const lR = this.lineNodes(
+				lT.p2,
+				lB.p1,
+				{var1: 0, var2: 0, move: false}
+			);
+			const lL = this.lineNodes(
+				lB.p2,
+				lT.p1,
+				{var1: 0, var2: 0.3, move: false}
+			);
+
+			return lT.nodes + lR.nodes + lB.nodes + lL.nodes;
+		}
+
+		renderBox(position, {fill = null, thick = false, attrs = null} = {}) {
+			return this.svg.el('path')
+				.attrs({
+					'd': this.boxNodes(position),
+					'fill': fill || '#FFFFFF',
+				})
+				.attrs(attrs || (thick ? PENCIL.thick : PENCIL.normal));
+		}
+
+		renderNote({x, y, width, height}) {
+			const flickSize = 5;
+			const lT = this.lineNodes(
+				{x, y},
+				{x: x + width - flickSize, y},
+				{}
+			);
+			const lF = this.lineNodes(
+				lT.p2,
+				{x: x + width, y: y + flickSize},
+				{move: false, var1: 0}
+			);
+			const lB = this.lineNodes(
+				{x: x + width, y: y + height},
+				{x, y: y + height},
+				{move: false}
+			);
+			const lR = this.lineNodes(
+				lF.p2,
+				lB.p1,
+				{var1: 0, var2: 0, move: false}
+			);
+			const lL = this.lineNodes(
+				lB.p2,
+				lT.p1,
+				{var1: 0, var2: 0.3, move: false}
+			);
+			const lF1 = this.lineNodes(
+				lF.p1,
+				{x: x + width - flickSize, y: y + flickSize},
+				{var1: 0.3}
+			);
+			const lF2 = this.lineNodes(
+				lF1.p2,
+				lF.p2,
+				{var1: 0, move: false}
+			);
+
+			return this.svg.el('g').add(
+				this.svg.el('path')
+					.attrs({
+						'd': (
+							lT.nodes +
+							lF.nodes +
+							lR.nodes +
+							lB.nodes +
+							lL.nodes
+						),
+						'fill': '#FFFFFF',
+					})
+					.attrs(PENCIL.normal),
+				this.svg.el('path')
+					.attrs({
+						'd': lF1.nodes + lF2.nodes,
+						'fill': 'none',
+					})
+					.attrs(PENCIL.normal)
+			);
+		}
+
+		renderLineDivider({x, y, labelWidth, width, height}) {
+			let shape = null;
+			const yPos = y + height / 2;
+			if(labelWidth > 0) {
+				shape = this.svg.el('g').add(
+					this.renderLine(
+						{x, y: yPos},
+						{x: x + (width - labelWidth) / 2, y: yPos},
+						{}
+					),
+					this.renderLine(
+						{x: x + (width + labelWidth) / 2, y: yPos},
+						{x: x + width, y: yPos},
+						{}
+					)
+				);
+			} else {
+				shape = this.renderLine(
+					{x, y: yPos},
+					{x: x + width, y: yPos},
+					{}
+				);
+			}
+			return {shape};
+		}
+
+		renderFlatConnect(attrs, {x1, y1, x2, y2}) {
+			const ln = this.lineNodes(
+				{x: x1, y: y1},
+				{x: x2, y: y2},
+				{varX: 0.3}
+			);
+			return {
+				shape: this.svg.el('path').attr('d', ln.nodes).attrs(attrs),
+				p1: ln.p1,
+				p2: ln.p2,
+			};
+		}
+
+		renderRevConnect(attrs, {x1, y1, x2, y2, xR}) {
+			const variance = Math.min((xR - x1) * 0.06, 3);
+			const overshoot = Math.min((xR - x1) * 0.5, 6);
+			const p1x = x1 + this.vary(variance, -1);
+			const p1y = y1 + this.vary(variance, -1);
+			const b1x = xR - overshoot * this.vary(0.2, 1);
+			const b1y = y1 - this.vary(1, 2);
+			const p2x = xR;
+			const p2y = y1 + this.vary(1, 1);
+			const b2x = xR;
+			const b2y = y2 + this.vary(2);
+			const p3x = x2 + this.vary(variance, -1);
+			const p3y = y2 + this.vary(variance, -1);
+
+			return {
+				shape: this.svg.el('path')
+					.attr('d', (
+						'M' + p1x + ' ' + p1y +
+						'C' + p1x + ' ' + p1y +
+						',' + b1x + ' ' + b1y +
+						',' + p2x + ' ' + p2y +
+						'S' + b2x + ' ' + b2y +
+						',' + p3x + ' ' + p3y
+					))
+					.attrs(attrs),
+				p1: {x: p1x, y: p1y},
+				p2: {x: p3x, y: p3y},
+			};
+		}
+
+		renderFlatConnectWave(attrs, {x1, y1, x2, y2}) {
+			const x1v = x1 + this.vary(0.3);
+			const x2v = x2 + this.vary(0.3);
+			const y1v = y1 + this.vary(1);
+			const y2v = y2 + this.vary(1);
+			return {
+				shape: this.svg.el('path')
+					.attr('d', this.svg.patternedLine(this.wave)
+						.move(x1v, y1v)
+						.line(x2v, y2v)
+						.cap()
+						.asPath())
+					.attrs(attrs),
+				p1: {x: x1v, y: y1v},
+				p2: {x: x2v, y: y2v},
+			};
+		}
+
+		renderRevConnectWave(attrs, {x1, y1, x2, y2, xR}) {
+			const x1v = x1 + this.vary(0.3);
+			const x2v = x2 + this.vary(0.3);
+			const y1v = y1 + this.vary(1);
+			const y2v = y2 + this.vary(1);
+			return {
+				shape: this.svg.el('path')
+					.attr('d', this.svg.patternedLine(this.wave)
+						.move(x1v, y1v)
+						.line(xR, y1)
+						.arc(xR, (y1 + y2) / 2, Math.PI)
+						.line(x2v, y2v)
+						.cap()
+						.asPath())
+					.attrs(attrs),
+				p1: {x: x1v, y: y1v},
+				p2: {x: x2v, y: y2v},
+			};
+		}
+
+		renderArrowHead(attrs, {x, y, width, height, dir}) {
+			const w = width * this.vary(0.2, 1);
+			const h = height * this.vary(0.3, 1);
+			const wx = w * dir.dx;
+			const wy = w * dir.dy;
+			const hy = h * 0.5 * dir.dx;
+			const hx = -h * 0.5 * dir.dy;
+			const l1 = this.lineNodes(
+				{x: x + wx - hx, y: y + wy - hy},
+				{x, y},
+				{var1: 2.0, var2: 0.2}
+			);
+			const l2 = this.lineNodes(
+				l1.p2,
+				{x: x + wx + hx, y: y + wy + hy},
+				{var1: 0, var2: 2.0, move: false}
+			);
+			const l3 = (attrs.fill === 'none') ? {nodes: ''} : this.lineNodes(
+				l2.p2,
+				l1.p1,
+				{var1: 0, var2: 0, move: false}
+			);
+			return this.svg.el('path')
+				.attr('d', l1.nodes + l2.nodes + l3.nodes)
+				.attrs(attrs);
+		}
+
+		renderState({x, y, width, height}) {
+			const dx = Math.min(width * 0.06, 3);
+			const dy = Math.min(height * 0.06, 3);
+			const tlX = x + dx * this.vary(0.6, 1);
+			const tlY = y + dy * this.vary(0.6, 1);
+			const trX = x + width - dx * this.vary(0.6, 1);
+			const trY = y + dy * this.vary(0.6, 1);
+			const blX = x + dx * this.vary(0.6, 1);
+			const blY = y + height - dy * this.vary(0.6, 1);
+			const brX = x + width - dx * this.vary(0.6, 1);
+			const brY = y + height - dy * this.vary(0.6, 1);
+			const mX = x + width / 2;
+			const mY = y + height / 2;
+			const cx = dx * this.vary(0.2, 1.2);
+			const cy = dy * this.vary(0.2, 1.2);
+			const bentT = y - Math.min(width * 0.005, 1);
+			const bentB = y + height - Math.min(width * 0.01, 2);
+			const bentL = x - Math.min(height * 0.01, 2) * this.handedness;
+			const bentR = bentL + width;
+
+			return this.svg.el('path')
+				.attr('d', (
+					'M' + tlX + ' ' + tlY +
+					'C' + (tlX + cx) + ' ' + (tlY - cy) +
+					',' + (mX - width * this.vary(0.03, 0.3)) + ' ' + bentT +
+					',' + mX + ' ' + bentT +
+					'S' + (trX - cx) + ' ' + (trY - cy) +
+					',' + trX + ' ' + trY +
+					'S' + bentR + ' ' + (mY - height * this.vary(0.03, 0.3)) +
+					',' + bentR + ' ' + mY +
+					'S' + (brX + cx) + ' ' + (brY - cy) +
+					',' + brX + ' ' + brY +
+					'S' + (mX + width * this.vary(0.03, 0.3)) + ' ' + bentB +
+					',' + mX + ' ' + bentB +
+					'S' + (blX + cx) + ' ' + (blY + cy) +
+					',' + blX + ' ' + blY +
+					'S' + bentL + ' ' + (mY + height * this.vary(0.03, 0.3)) +
+					',' + bentL + ' ' + mY +
+					'S' + (tlX - cx) + ' ' + (tlY + cy) +
+					',' + tlX + ' ' + tlY +
+					'Z'
+				))
+				.attr('fill', '#FFFFFF')
+				.attrs(PENCIL.normal);
+		}
+
+		renderRefBlock(position) {
+			const nodes = this.boxNodes(position);
+			return {
+				shape: this.svg.el('path')
+					.attrs({'d': nodes, 'fill': 'none'})
+					.attrs(PENCIL.thick),
+				mask: this.svg.el('path')
+					.attrs({'d': nodes, 'fill': '#000000'}),
+				fill: this.svg.el('path')
+					.attrs({'d': nodes, 'fill': '#FFFFFF'}),
+			};
+		}
+
+		renderBlock(position) {
+			return this.renderBox(position, {fill: 'none', thick: true});
+		}
+
+		renderMinBlock(position) {
+			return this.renderRefBlock(position);
+		}
+
+		renderTag({x, y, width, height}) {
+			const x2 = x + width;
+			const y2 = y + height;
+
+			const l1 = this.lineNodes(
+				{x: x2 + 3, y},
+				{x: x2 - 2, y: y2},
+				{}
+			);
+			const l2 = this.lineNodes(
+				l1.p2,
+				{x, y: y2 + 1},
+				{var1: 0, move: false}
+			);
+
+			const line = l1.nodes + l2.nodes;
+
+			return this.svg.el('g').add(
+				this.svg.el('path')
+					.attrs({
+						'd': line + 'L' + x + ' ' + y,
+						'fill': '#FFFFFF',
+					}),
+				this.svg.el('path')
+					.attrs({
+						'd': line,
+						'fill': '#FFFFFF',
+					})
+					.attrs(PENCIL.normal)
+			);
+		}
+
+		renderSeparator({x1, y1, x2, y2}) {
+			return this.renderLine(
+				{x: x1, y: y1},
+				{x: x2, y: y2},
+				{thick: true, dash: true}
+			);
+		}
+
+		renderBar({x, y, width, height}) {
+			return this.renderBox({x, y, width, height}, {fill: '#000000'});
+		}
+
+		renderCross({x, y, radius}) {
+			const r1 = this.vary(0.2, 1) * radius;
+			const l1 = this.lineNodes(
+				{x: x - r1, y: y - r1},
+				{x: x + r1, y: y + r1},
+				{}
+			);
+			const r2 = this.vary(0.2, 1) * radius;
+			const l2 = this.lineNodes(
+				{x: x + r2, y: y - r2},
+				{x: x - r2, y: y + r2},
+				{}
+			);
+
+			return this.svg.el('path')
+				.attrs({
+					'd': l1.nodes + l2.nodes,
+					'fill': 'none',
+				})
+				.attrs(PENCIL.normal);
+		}
+
+		renderAgentLine({x, y0, y1, width, className, options}) {
+			const attrs = this.optionsAttributes(this.agentLineAttrs, options);
+			if(width > 0) {
+				return this.renderBox({
+					x: x - width / 2,
+					y: y0,
+					width,
+					height: y1 - y0,
+				}, {fill: 'none', attrs}).setClass(className);
+			} else {
+				return this.renderLine(
+					{x, y: y0},
+					{x, y: y1},
+					{varY: 0.3, attrs}
+				).setClass(className);
+			}
+		}
+	}
+
+	class Factory$3 {
+		constructor(handedness = RIGHT) {
+			const right = (handedness === RIGHT);
+			this.name = right ? 'sketch' : 'sketch left handed';
+			this.handedness = handedness;
+		}
+
+		build(svg) {
+			return new SketchTheme(svg, this.handedness);
+		}
+	}
+
+	Object.assign(Factory$3, {RIGHT, LEFT});
+
+	/* eslint-disable complexity */ // Temporary ignore while switching linter
+
+	const TRIMMER = /^([ \t]*)(.*)$/;
+	const SQUASH = {
+		after: '.!+', // Cannot squash after * or - in all cases
+		end: /[ \t\r\n]$/,
+		start: /^[ \t\r\n:,]/,
+	};
+	const ONGOING_QUOTE = /^"(\\.|[^"])*$/;
+	const REQUIRED_QUOTED = /[\r\n:,"<>\-~]/;
+	const QUOTE_ESCAPE = /["\\]/g;
+
+	function suggestionsEqual$1(a, b) {
+		return (
+			(a.v === b.v) &&
+			(a.prefix === b.prefix) &&
+			(a.suffix === b.suffix) &&
+			(a.q === b.q)
+		);
+	}
+
+	function makeRangeFrom(cm, line, chFrom) {
+		const ln = cm.getLine(line);
+		const ranges = {
+			squash: {ch: chFrom, line},
+			word: {ch: chFrom, line},
+		};
+		if(chFrom > 0 && ln[chFrom - 1] === ' ') {
+			if(SQUASH.after.includes(ln[chFrom - 2])) {
+				ranges.word.ch --;
+			}
+			ranges.squash.ch --;
+		}
+		return ranges;
+	}
+
+	function makeRangeTo(cm, line, chTo) {
+		const ln = cm.getLine(line);
+		const ranges = {
+			squash: {ch: chTo, line},
+			word: {ch: chTo, line},
+		};
+		if(ln[chTo] === ' ') {
+			ranges.squash.ch ++;
+		}
+		return ranges;
+	}
+
+	function wrapQuote({v, q, prefix = '', suffix = ''}, quote) {
+		const quo = (quote || !REQUIRED_QUOTED.test(v)) ? quote : '"';
+		return (
+			prefix +
+			((quo && q) ? (quo + v.replace(QUOTE_ESCAPE, '\\$&') + quo) : v) +
+			suffix
+		);
+	}
+
+	function makeHintItem(entry, ranges, quote) {
+		const quoted = wrapQuote(entry, quote);
+		const from = entry.q ? ranges.fromVar : ranges.fromKey;
+		if(quoted === '\n') {
+			return {
+				className: 'pick-virtual',
+				displayFrom: null,
+				displayText: '<END>',
+				from: from.squash,
+				text: '\n',
+				to: ranges.to.squash,
+			};
+		} else {
+			return {
+				className: null,
+				displayFrom: from.word,
+				displayText: quoted.trim(),
+				from: SQUASH.start.test(quoted) ? from.squash : from.word,
+				text: quoted,
+				to: SQUASH.end.test(quoted) ? ranges.to.squash : ranges.to.word,
+			};
+		}
+	}
+
+	function getGlobals({global, prefix = '', suffix = ''}, globals) {
+		const identified = globals[global];
+		if(!identified) {
+			return [];
+		}
+		return identified.map((item) => ({prefix, q: true, suffix, v: item}));
+	}
+
+	function populateGlobals(suggestions, globals = {}) {
+		for(let i = 0; i < suggestions.length;) {
+			if(suggestions[i].global) {
+				const identified = getGlobals(suggestions[i], globals);
+				mergeSets(suggestions, identified, suggestionsEqual$1);
+				suggestions.splice(i, 1);
+			} else {
+				++ i;
+			}
+		}
+	}
+
+	function getTokensUpTo(cm, pos) {
+		const tokens = cm.getLineTokens(pos.line);
+		for(let p = 0; p < tokens.length; ++ p) {
+			if(tokens[p].end >= pos.ch) {
+				tokens.length = p + 1;
+				break;
+			}
+		}
+		return tokens;
+	}
+
+	function getVariablePartial(tokens, pos) {
+		let partial = '';
+		let start = 0;
+		let fin = 0;
+		tokens.forEach((token) => {
+			if(token.state.isVar) {
+				partial += token.string;
+				fin = token.end;
+			} else {
+				partial = '';
+				start = token.end;
+			}
+		});
+		if(fin > pos.ch) {
+			partial = partial.substr(0, pos.ch - start);
+		}
+		const parts = TRIMMER.exec(partial);
+		partial = parts[2];
+		let quote = '';
+		if(ONGOING_QUOTE.test(partial)) {
+			quote = partial.charAt(0);
+			partial = partial.substr(1);
+		}
+		return {
+			from: start + parts[1].length,
+			partial,
+			quote,
+			valid: fin >= start,
+		};
+	}
+
+	function getKeywordPartial(token, pos) {
+		let partial = token.string;
+		if(token.end > pos.ch) {
+			partial = partial.substr(0, pos.ch - token.start);
+		}
+		const parts = TRIMMER.exec(partial);
+		return {
+			from: token.start + parts[1].length,
+			partial: parts[2],
+			valid: true,
+		};
+	}
+
+	function suggestDropdownLocation(list, fromKey) {
+		let p = null;
+		list.forEach(({displayFrom}) => {
+			if(displayFrom) {
+				if(
+					!p ||
+					displayFrom.line > p.line ||
+					(displayFrom.line === p.line && displayFrom.ch > p.ch)
+				) {
+					p = displayFrom;
+				}
+			}
+		});
+		return p || fromKey.word;
+	}
+
+	function partialMatch(v, p) {
+		return p.valid && v.startsWith(p.partial);
+	}
+
+	function getHints(cm, options) {
+		const cur = cm.getCursor();
+		const tokens = getTokensUpTo(cm, cur);
+		const token = last(tokens) || cm.getTokenAt(cur);
+		const pVar = getVariablePartial(tokens, cur);
+		const pKey = getKeywordPartial(token, cur);
+
+		const continuation = (cur.ch > 0 && token.state.line.length > 0);
+		let comp = (continuation ?
+			token.state.completions :
+			token.state.beginCompletions
+		);
+		if(!continuation) {
+			comp = comp.concat(token.state.knownAgent);
+		}
+
+		populateGlobals(comp, cm.options.globals);
+
+		const ranges = {
+			fromKey: makeRangeFrom(cm, cur.line, pKey.from),
+			fromVar: makeRangeFrom(cm, cur.line, pVar.from),
+			to: makeRangeTo(cm, cur.line, token.end),
+		};
+		let selfValid = null;
+		const list = (comp
+			.filter((o) => (
+				(o.q || !pVar.quote) &&
+				partialMatch(o.v, o.q ? pVar : pKey)
+			))
+			.map((o) => {
+				if(!options.completeSingle) {
+					if(o.v === (o.q ? pVar : pKey).partial) {
+						selfValid = o;
+						return null;
+					}
+				}
+				return makeHintItem(o, ranges, pVar.quote);
+			})
+			.filter((opt) => (opt !== null))
+		);
+		if(selfValid && list.length > 0) {
+			list.unshift(makeHintItem(selfValid, ranges, pVar.quote));
+		}
+
+		return {
+			from: suggestDropdownLocation(list, ranges.fromKey),
+			list,
+			to: ranges.to.word,
+		};
+	}
+
+	const themes = [
+		new Factory(),
+		new Factory$2(),
+		new Factory$1(),
+		new Factory$3(Factory$3.RIGHT),
+		new Factory$3(Factory$3.LEFT),
+	];
+
+	const SharedParser = new Parser();
+	const SharedGenerator = new Generator();
+	const CMMode = SharedParser.getCodeMirrorMode();
+
+	function registerCodeMirrorMode(CodeMirror, modeName = 'sequence') {
+		const cm = CodeMirror || window.CodeMirror;
+		cm.defineMode(modeName, () => CMMode);
+		cm.registerHelper('hint', modeName, getHints);
+	}
+
+	function addTheme(theme) {
+		themes.push(theme);
+	}
+
+	function extractCodeFromSVG(svg) {
+		const dom = new DOMParser().parseFromString(svg, 'image/svg+xml');
+		const meta = dom.querySelector('metadata');
+		if(!meta) {
+			return '';
+		}
+		return meta.textContent;
+	}
+
+	function renderAll(diagrams) {
+		const errors = [];
+		function storeError(sd, e) {
+			errors.push(e);
+		}
+
+		diagrams.forEach((diagram) => {
+			diagram.addEventListener('error', storeError);
+			diagram.optimisedRenderPreReflow();
+		});
+		diagrams.forEach((diagram) => {
+			diagram.optimisedRenderReflow();
+		});
+		diagrams.forEach((diagram) => {
+			diagram.optimisedRenderPostReflow();
+			diagram.removeEventListener('error', storeError);
+		});
+
+		if(errors.length > 0) {
+			throw errors;
+		}
+	}
+
+	function pickDocument(container) {
+		if(container) {
+			return container.ownerDocument || null;
+		} else if(typeof window === 'undefined') {
+			return null;
+		} else {
+			return window.document;
+		}
+	}
+
+	class SequenceDiagram extends EventObject {
+		/* eslint-disable complexity */ // Just some defaults
+		constructor(code = null, options = {}) {
+			/* eslint-enable complexity */
+			super();
+
+			let opts = null;
+			if(code && typeof code === 'object') {
+				opts = code;
+				this.code = opts.code;
+			} else {
+				opts = options;
+				this.code = code;
+			}
+
+			Object.assign(this, {
+				exporter: new Exporter(),
+				generator: SharedGenerator,
+				isInteractive: false,
+				latestProcessed: null,
+				parser: SharedParser,
+				registerCodeMirrorMode,
+				renderer: new Renderer(Object.assign({
+					document: pickDocument(opts.container),
+					themes,
+				}, opts)),
+				textSizerFactory: opts.textSizerFactory || null,
+			});
+
+			this.renderer.addEventForwarding(this);
+
+			if(opts.container) {
+				opts.container.appendChild(this.dom());
+			}
+			if(opts.interactive) {
+				this.addInteractivity();
+			}
+			if(typeof this.code === 'string' && opts.render !== false) {
+				this.render();
+			}
+		}
+
+		clone(options = {}) {
+			const reference = (options.container || this.renderer.dom());
+
+			return new SequenceDiagram(Object.assign({
+				code: this.code,
+				components: this.renderer.components,
+				container: null,
+				document: reference.ownerDocument,
+				interactive: this.isInteractive,
+				namespace: null,
+				textSizerFactory: this.textSizerFactory,
+				themes: this.renderer.getThemes(),
+			}, options));
+		}
+
+		set(code = '', {render = true} = {}) {
+			if(this.code === code) {
+				return;
+			}
+
+			this.code = code;
+			if(render) {
+				this.render();
+			}
+		}
+
+		process(code) {
+			const parsed = this.parser.parse(code);
+			return this.generator.generate(parsed);
+		}
+
+		addTheme(theme) {
+			this.renderer.addTheme(theme);
+		}
+
+		setHighlight(line) {
+			this.renderer.setHighlight(line);
+		}
+
+		isCollapsed(line) {
+			return this.renderer.isCollapsed(line);
+		}
+
+		setCollapsed(line, collapsed = true, {render = true} = {}) {
+			if(!this.renderer.setCollapsed(line, collapsed)) {
+				return false;
+			}
+			if(render && this.latestProcessed) {
+				this.render(this.latestProcessed);
+			}
+			return true;
+		}
+
+		collapse(line, options) {
+			return this.setCollapsed(line, true, options);
+		}
+
+		expand(line, options) {
+			return this.setCollapsed(line, false, options);
+		}
+
+		toggleCollapsed(line, options) {
+			return this.setCollapsed(line, !this.isCollapsed(line), options);
+		}
+
+		expandAll(options) {
+			return this.setCollapsed(null, false, options);
+		}
+
+		getThemeNames() {
+			return this.renderer.getThemeNames();
+		}
+
+		getThemes() {
+			return this.renderer.getThemes();
+		}
+
+		getSVGSynchronous() {
+			return this.exporter.getSVGURL(this.renderer);
+		}
+
+		getSVG() {
+			return Promise.resolve({
+				latest: true,
+				url: this.getSVGSynchronous(),
+			});
+		}
+
+		getCanvas({resolution = 1, size = null} = {}) {
+			if(size) {
+				this.renderer.width = size.width;
+				this.renderer.height = size.height;
+			}
+			return new Promise((resolve) => {
+				this.exporter.getCanvas(this.renderer, resolution, resolve);
+			});
+		}
+
+		getPNG({resolution = 1, size = null} = {}) {
+			if(size) {
+				this.renderer.width = size.width;
+				this.renderer.height = size.height;
+			}
+			return new Promise((resolve) => {
+				this.exporter.getPNGURL(
+					this.renderer,
+					resolution,
+					(url, latest) => {
+						resolve({latest, url});
+					}
+				);
+			});
+		}
+
+		getSize() {
+			return {
+				height: this.renderer.height,
+				width: this.renderer.width,
+			};
+		}
+
+		_revertParent(state) {
+			const dom = this.renderer.dom();
+			if(dom.parentNode !== state.originalParent) {
+				dom.parentNode.removeChild(dom);
+				if(state.originalParent) {
+					state.originalParent.appendChild(dom);
+				}
+			}
+		}
+
+		_sendRenderError(e) {
+			this._revertParent(this.renderState);
+			this.renderState.error = true;
+			this.trigger('error', [this, e]);
+		}
+
+		optimisedRenderPreReflow(processed = null) {
+			const dom = this.renderer.dom();
+			this.renderState = {
+				error: false,
+				originalParent: dom.parentNode,
+				processed,
+			};
+			const state = this.renderState;
+
+			if(!dom.isConnected) {
+				if(state.originalParent) {
+					state.originalParent.removeChild(dom);
+				}
+				dom.ownerDocument.body.appendChild(dom);
+			}
+
+			try {
+				if(!state.processed) {
+					state.processed = this.process(this.code);
+				}
+				this.renderer.optimisedRenderPreReflow(state.processed);
+			} catch(e) {
+				this._sendRenderError(e);
+			}
+		}
+
+		optimisedRenderReflow() {
+			try {
+				if(!this.renderState.error) {
+					this.renderer.optimisedRenderReflow();
+				}
+			} catch(e) {
+				this._sendRenderError(e);
+			}
+		}
+
+		optimisedRenderPostReflow() {
+			const state = this.renderState;
+
+			try {
+				if(!state.error) {
+					this.renderer.optimisedRenderPostReflow(state.processed);
+				}
+			} catch(e) {
+				this._sendRenderError(e);
+			}
+
+			this.renderState = null;
+
+			if(!state.error) {
+				this._revertParent(state);
+				this.latestProcessed = state.processed;
+				this.trigger('render', [this]);
+			}
+		}
+
+		render(processed = null) {
+			let latestError = null;
+			function storeError(sd, e) {
+				latestError = e;
+			}
+			this.addEventListener('error', storeError);
+
+			this.optimisedRenderPreReflow(processed);
+			this.optimisedRenderReflow();
+			this.optimisedRenderPostReflow();
+
+			this.removeEventListener('error', storeError);
+			if(latestError) {
+				throw latestError;
+			}
+		}
+
+		setContainer(node = null) {
+			const dom = this.dom();
+			if(dom.parentNode) {
+				dom.parentNode.removeChild(dom);
+			}
+			if(node) {
+				node.appendChild(dom);
+			}
+		}
+
+		addInteractivity() {
+			if(this.isInteractive) {
+				return;
+			}
+			this.isInteractive = true;
+
+			this.addEventListener('click', (element) => {
+				this.toggleCollapsed(element.ln);
+			});
+		}
+
+		extractCodeFromSVG(svg) {
+			return extractCodeFromSVG(svg);
+		}
+
+		renderAll(diagrams) {
+			return renderAll(diagrams);
+		}
+
+		dom() {
+			return this.renderer.dom();
+		}
+	}
+
+	function datasetBoolean(value) {
+		return typeof value !== 'undefined' && value !== 'false';
+	}
+
+	function parseTagOptions(element) {
+		return {
+			interactive: datasetBoolean(element.dataset.sdInteractive),
+			namespace: element.dataset.sdNamespace || null,
+		};
+	}
+
+	function convertOne(element, code = null, options = {}) {
+		if(element.tagName === 'svg') {
+			return null;
+		}
+
+		const tagOptions = parseTagOptions(element);
+
+		const diagram = new SequenceDiagram(
+			(code === null) ? element.textContent : code,
+			Object.assign(tagOptions, options)
+		);
+		const newElement = diagram.dom();
+		const attrs = element.attributes;
+		for(let i = 0; i < attrs.length; ++ i) {
+			newElement.setAttribute(
+				attrs[i].nodeName,
+				attrs[i].nodeValue
+			);
+		}
+		element.parentNode.replaceChild(newElement, element);
+		return diagram;
+	}
+
+	function convert(elements, code = null, options = {}) {
+		let c = null;
+		let opts = null;
+		if(code && typeof code === 'object') {
+			opts = code;
+			c = opts.code;
+		} else {
+			opts = options;
+			c = code;
+		}
+
+		if(Array.isArray(elements)) {
+			const nodrawOpts = Object.assign({}, opts, {render: false});
+			const diagrams = elements.map((el) => convertOne(el, c, nodrawOpts));
+			if(opts.render !== false) {
+				renderAll(diagrams);
+			}
+			return diagrams;
+		} else {
+			return convertOne(elements, c, opts);
+		}
+	}
+
+	function convertAll(root = null, className = 'sequence-diagram') {
+		let r = null;
+		let cls = null;
+		if(typeof root === 'string') {
+			r = null;
+			cls = root;
+		} else {
+			r = root;
+			cls = className;
+		}
+
+		let elements = null;
+		if(r && typeof r.length !== 'undefined') {
+			elements = r;
+		} else {
+			elements = (r || window.document).getElementsByClassName(cls);
+		}
+
+		// Convert from "live" collection to static to avoid infinite loops:
+		const els = [];
+		for(let i = 0; i < elements.length; ++ i) {
+			els.push(elements[i]);
+		}
+
+		// Convert elements
+		convert(els);
+	}
+
+	function getDefaultThemeNames() {
+		return themes.map((theme) => theme.name);
+	}
+
+	Object.assign(SequenceDiagram, {
+		Exporter,
+		Generator,
+		Parser,
+		Renderer,
+		addTheme,
+		convert,
+		convertAll,
+		extractCodeFromSVG,
+		getDefaultThemeNames,
+		registerCodeMirrorMode,
+		renderAll,
+		themes,
+	});
+
+	if(typeof exports !== 'undefined') {
+		exports.SequenceDiagram = SequenceDiagram;
+	} else if(window.define && window.define.amd) {
+		window.define(() => SequenceDiagram);
+	} else {
+		window.document.addEventListener('DOMContentLoaded', () => {
+			SequenceDiagram.convertAll();
+		}, {once: true});
+
+		if(window.CodeMirror) {
+			SequenceDiagram.registerCodeMirrorMode(window.CodeMirror);
+		}
+
+		window.SequenceDiagram = SequenceDiagram;
+	}
+
+}());
diff --git a/lib/sequence-diagram-web.min.js b/lib/sequence-diagram-web.min.js
new file mode 100644
index 0000000..24d405f
--- /dev/null
+++ b/lib/sequence-diagram-web.min.js
@@ -0,0 +1 @@
+!function(){"use strict";function t(t,e,n=null){if(null===n)return t.indexOf(e);for(let s=0;s<t.length;++s)if(n(t[s],e))return s;return-1}function e(e,n=null,s=null){if(n)for(let r=0;r<n.length;++r)-1===t(e,n[r],s)&&e.push(n[r])}function n(e,n=null,s=null){if(n)for(let r=0;r<n.length;++r){const i=t(e,n[r],s);-1!==i&&e.splice(i,1)}}function s(e,n,s=null){const r=t(e,n,s);-1!==r&&e.splice(r,1)}function r(t){return t[t.length-1]}function i(t,e,n,s){if(e>=t.length)return void s.push(n.slice());const r=t[e];if(!Array.isArray(r))return n.push(r),i(t,e+1,n,s),void n.pop();for(let a=0;a<r.length;++a)n.push(r[a]),i(t,e+1,n,s),n.pop()}function a(t,e){const n=[];return t.forEach(t=>{n.push(...e(t))}),n}function o(t,e){const n=St[t.type];return!(!n||t.type!==e.type)&&!n.check.some(n=>t[n]!==e[n])}function h(t,n){St[t.type].merge.forEach(s=>{e(t[s],n[s])})}function l(t,e){for(let n=0;n<t.length;){e(t[n],n)?t.splice(n,1):++n}}function d(t){l(t,(e,n)=>{for(let s=0;s<n;++s)if(o(t[s],e))return h(t[s],e),!0;return!1})}function g(t){const e=new Set,n=t.map(({type:t})=>t);return n.forEach(t=>{const s=St[t];s&&n.every(e=>t===e||s.siblings.has(e))&&e.add(t)}),e}function c(t,e,n,s){l(s,s=>{if(!t.has(s.type)||!e.has(s.type))return!1;for(let t=0;t<n.length;++t)if(o(n[t],s))return h(n[t],s),!0;return!1})}function u(t,e){if("agent begin"===t.type)return t.mode=e,!0;if("parallel"===t.type){let n=!1;return t.stages.forEach(t=>{"agent begin"===t.type&&(t.mode=e,n=!0)}),n}return!1}function p(t,e,n,r=null){s(t,e,At.equals),s(t,n,At.equals);let i=0,a=t.length;if(r){const e=r.map(e=>At.indexOf(t,e)).filter(t=>-1!==t);i=e.reduce((t,e)=>Math.min(t,e),t.length),a=e.reduce((t,e)=>Math.max(t,e),i)+1}return t.splice(i,0,e),t.splice(a+1,0,n),{indexL:i,indexR:a+1}}function f(t,e=!1){return{type:"string",suggest:e,then:Object.assign({"":0},t)}}function m(t,e){return t.v===e.v&&t.prefix===e.prefix&&t.suffix===e.suffix&&t.q===e.q}function b(t,e,n){let s=n.suggest;return Array.isArray(s)||(s=[s]),a(s,s=>!1===s?[]:"object"==typeof s?s.known?t["known"+s.known]||[]:[s]:"string"==typeof s&&s?[{v:s,q:""===e}]:[function(t,e){return Object.keys(e.then).length>0?{v:t,suffix:" ",q:!1}:{v:t,suffix:"\n",q:!1}}(e,n)])}function y(t,n){const s=[],i=r(n);return Object.keys(i.then).forEach(r=>{let a=i.then[r];"number"==typeof a&&(a=n[n.length-a-1]),e(s,b(t,r,a),m)}),s}function x(t,n,s,{suggest:r,override:i}){let a=null;"object"==typeof r&&r.known&&(a=r.known),n.type&&a!==n.type&&(i&&(n.type=i),e(t["known"+n.type],[{v:n.value,suffix:" ",q:!0}],m),n.type="",n.value=""),a&&(n.type=a,n.value&&(n.value+=s.s),n.value+=s.v)}function k(t,e,n){const s={type:"",value:""};let i=n;const a=[i];return t.line.forEach((e,n)=>{n===t.line.length-1&&(t.completions=y(t,a));const o=e.q?"":e.v;let h=i.then[o];void 0===h?(h=i.then[""],t.isVar=!0):t.isVar=e.q,"number"==typeof h?a.length-=h:a.push(h||Nt),i=r(a),x(t,s,e,i)}),e&&x(t,s,null,{}),t.nextCompletions=y(t,a),t.valid=Boolean(i.then["\n"])||0===Object.keys(i.then).length,i.type}function w(t){const e=t.baseToken||{};return{value:e.v||"",quoted:e.q||!1}}function v(t,e,n){return e.lastIndex=n,e.exec(t)}function A(t,e,n){return n?function(t,e,n){if(n.escape){const s=v(t,n.escape,e);if(s)return{appendSpace:"",appendValue:n.escapeWith(s),end:!1,newBlock:null,skip:s[0].length}}const s=v(t,n.end,e);return s?{appendSpace:"",appendValue:n.includeEnd?s[0]:"",end:!0,newBlock:null,skip:s[0].length}:{appendSpace:"",appendValue:t[e],end:!1,newBlock:null,skip:1}}(t,e,n):function(t,e){for(let n=0;n<Vt.length;++n){const s=Vt[n],r=v(t,s.start,e);if(r)return{appendSpace:"",appendValue:"",end:!s.end,newBlock:s,skip:r[0].length}}return{appendSpace:t[e],appendValue:"",end:!1,newBlock:null,skip:1}}(t,e)}function F(t){return{ch:t.ch,i:t.i,ln:t.ln}}function M(t){const e=jt.exec(t);return e&&e[1]?e[1].length:0}function S(t){if("label"===t)return{token:"label"};const e=t.indexOf(" ");let n=null,s=null;-1===e?(n=t,s=[]):(n=t.substr(0,e),s=t.substr(e+1).split(","));let r=null;return"inc"===n&&(r=function(t){let e=1,n=1,s=0;return t[0]&&(e=Number(t[0]),s=Math.max(s,M(t[0]))),t[1]&&(n=Number(t[1]),s=Math.max(s,M(t[1]))),Number.isNaN(e)||Number.isNaN(n)?null:{dp:s,inc:n,start:e}}(s)),r||"<"+t+">"}function R(t,e,n){const s=" "+t+" ";let r=-1,i=s.length,a=0;return qt.forEach(({begin:t,end:o},h)=>{const l=n[h]?o:t;l.lastIndex=e;const d=l.exec(s);d&&(d.index<i||d.index===i&&l.lastIndex>a)&&(r=h,i=d.index,a=l.lastIndex)}),{end:a-1,start:i,styleIndex:r}}function C(t,e){if(!t)return null;const n={};return e.forEach((t,e)=>{t&&Object.assign(n,qt[e].attrs)}),n}function E(t){if(!t)return[];const e=qt.map(()=>!1);let n=0,s=null;const r=[];return t.split("\n").forEach(t=>{const i=[];let a=0;for(;;){const{styleIndex:r,start:o,end:h}=R(t,a,e);if(-1===r)break;e[r]?(e[r]=!1,--n):(e[r]=!0,++n),o>a&&i.push({attrs:s,text:t.substring(a,o)}),s=C(n,e),a=h}a<t.length&&i.push({attrs:s,text:t.substr(a)}),r.push(i)}),r}function G(t,e=null){let n="";return e&&(n=" at line "+(e.b.ln+1)+", character "+e.b.ch),new Error(t+n)}function I(t,e=0,n=null){if(null===n&&(n=t.length),n<=e)return"";let s=t[e].v;for(let r=e+1;r<n;++r)s+=t[r].s+t[r].v;return s}function D(t){return!t||t.q?null:t.v}function L(t,e,n,s=null){for(let r=0;r<n.length;++r){const i=n[r],a=t[e+r];if(D(a)!==i){if(s)throw G(s+'; expected "'+i+'"',a);return e}}return e+n.length}function N(t,e,{start:n=0,limit:s=null,orEnd:r=!1}={}){null===s&&(s=t.length),Array.isArray(e)||(e=[e]);for(let r=n;r<=s-e.length;++r)if(L(t,r,e)!==r)return r;return r?s:-1}function z(t,e,n,{flagTypes:s={},aliases:i=!1}={}){const a=[],o=[];let h=e,l=!1;for(;h<n;++h){const e=t[h],n=D(e),r=s[n];if(!r)break;if(a.includes(r.flag))throw G("Duplicate agent flag: "+n,e);l=l||Boolean(r.allowBlankName),a.push(r.flag),o.push(r.blankNameFlag)}const{name:d,alias:g}=function(t,e,n,{enableAlias:s,allowBlankName:i}){let a=-1;if(s&&(a=N(t,"as",{start:e})),(-1===a||a>=n)&&(a=n),e>=a&&!i){let n=t[e];throw n||(n={b:r(t).e}),G("Missing agent name",n)}return{name:I(t,e,a),alias:I(t,a+1,n)}}(t,h,n,{enableAlias:i,allowBlankName:l});return{name:d,alias:g,flags:d?a:o}}function O(t,e,n,s){const r=[];let i=-1;for(let a=e;a<n;++a){","===D(t[a])?-1!==i&&(r.push(z(t,i,a,s)),i=-1):-1===i&&(i=a)}return-1!==i&&r.push(z(t,i,n,s)),r}function B({agentIDs:t=[],topShift:e=0,y:n=null,asynchronousY:s=null}={},r=null){let i=e;return null!==n&&null!==r&&(i=Math.max(i,n-r)),{agentIDs:t,asynchronousY:null===s?r:s,topShift:i,y:n}}function V(t,e){te.set(t,e)}function H(){return te}function T(t,e){let n=null,s=null;return e.forEach(e=>{const r=t.get(e);(null===n||r.index<n.index)&&(n=r),(null===s||r.index>s.index)&&(s=r)}),{left:n.id,right:s.id}}function P(t=null,e=null){return null===t?e:null===e?t:Math.max(t,e)}function j(t,n){return e(t.agentIDs,n.agentIDs),{agentIDs:t.agentIDs,asynchronousY:P(t.asynchronousY,n.asynchronousY),topShift:Math.max(t.topShift,n.topShift),y:P(t.y,n.y)}}function q(t){return null===t?null:t.element?t.element:t}function Y(t,e,n){if(!Array.isArray(n))throw new Error("Invalid formatted text line: "+n);n.forEach(({text:n,attrs:s})=>{s?e.add(t.el("tspan").attrs(s).add(n)):e.add(n)})}function W(t,e){let n=null,s=null;return e.forEach(e=>{const r=t.get(e);(null===n||r.index<n.index)&&(n=r),(null===s||r.index>s.index)&&(s=r)}),{left:n.id,right:s.id}}function U(t,e){return t.v===e.v&&t.prefix===e.prefix&&t.suffix===e.suffix&&t.q===e.q}function X(t,e,n){const s=t.getLine(e),r={squash:{ch:n,line:e},word:{ch:n,line:e}};return n>0&&" "===s[n-1]&&(tn.after.includes(s[n-2])&&r.word.ch--,r.squash.ch--),r}function Q(t,e,n){const s=function({v:t,q:e,prefix:n="",suffix:s=""},r){const i=r||!nn.test(t)?r:'"';return n+(i&&e?i+t.replace(sn,"\\$&")+i:t)+s}(t,n),r=t.q?e.fromVar:e.fromKey;return"\n"===s?{className:"pick-virtual",displayFrom:null,displayText:"<END>",from:r.squash,text:"\n",to:e.to.squash}:{className:null,displayFrom:r.word,displayText:s.trim(),from:tn.start.test(s)?r.squash:r.word,text:s,to:tn.end.test(s)?e.to.squash:e.to.word}}function J({global:t,prefix:e="",suffix:n=""},s){const r=s[t];return r?r.map(t=>({prefix:e,q:!0,suffix:n,v:t})):[]}function Z(t,n){const s=t.getCursor(),i=function(t,e){const n=t.getLineTokens(e.line);for(let t=0;t<n.length;++t)if(n[t].end>=e.ch){n.length=t+1;break}return n}(t,s),a=r(i)||t.getTokenAt(s),o=function(t,e){let n="",s=0,r=0;t.forEach(t=>{t.state.isVar?(n+=t.string,r=t.end):(n="",s=t.end)}),r>e.ch&&(n=n.substr(0,e.ch-s));const i=$e.exec(n);n=i[2];let a="";return en.test(n)&&(a=n.charAt(0),n=n.substr(1)),{from:s+i[1].length,partial:n,quote:a,valid:r>=s}}(i,s),h=function(t,e){let n=t.string;t.end>e.ch&&(n=n.substr(0,e.ch-t.start));const s=$e.exec(n);return{from:t.start+s[1].length,partial:s[2],valid:!0}}(a,s),l=s.ch>0&&a.state.line.length>0;let d=l?a.state.completions:a.state.beginCompletions;l||(d=d.concat(a.state.knownAgent)),function(t,n={}){for(let s=0;s<t.length;)t[s].global?(e(t,J(t[s],n),U),t.splice(s,1)):++s}(d,t.options.globals);const g={fromKey:X(t,s.line,h.from),fromVar:X(t,s.line,o.from),to:function(t,e,n){const s={squash:{ch:n,line:e},word:{ch:n,line:e}};return" "===t.getLine(e)[n]&&s.squash.ch++,s}(t,s.line,a.end)};let c=null;const u=d.filter(t=>(t.q||!o.quote)&&function(t,e){return e.valid&&t.startsWith(e.partial)}(t.v,t.q?o:h)).map(t=>n.completeSingle||t.v!==(t.q?o:h).partial?Q(t,g,o.quote):(c=t,null)).filter(t=>null!==t);return c&&u.length>0&&u.unshift(Q(c,g,o.quote)),{from:function(t,e){let n=null;return t.forEach(({displayFrom:t})=>{t&&(!n||t.line>n.line||t.line===n.line&&t.ch>n.ch)&&(n=t)}),n||e.word}(u,g.fromKey),list:u,to:g.to.word}}function K(t,e="sequence"){const n=t||window.CodeMirror;n.defineMode(e,()=>hn),n.registerHelper("hint",e,Z)}function _(t){const e=(new DOMParser).parseFromString(t,"image/svg+xml").querySelector("metadata");return e?e.textContent:""}function $(t){function e(t,e){n.push(e)}const n=[];if(t.forEach(t=>{t.addEventListener("error",e),t.optimisedRenderPreReflow()}),t.forEach(t=>{t.optimisedRenderReflow()}),t.forEach(t=>{t.optimisedRenderPostReflow(),t.removeEventListener("error",e)}),n.length>0)throw n}function tt(t,e=null,n={}){if("svg"===t.tagName)return null;const s=function(t){return{interactive:function(t){return void 0!==t&&"false"!==t}(t.dataset.sdInteractive),namespace:t.dataset.sdNamespace||null}}(t),r=new ln(null===e?t.textContent:e,Object.assign(s,n)),i=r.dom(),a=t.attributes;for(let t=0;t<a.length;++t)i.setAttribute(a[t].nodeName,a[t].nodeValue);return t.parentNode.replaceChild(i,t),r}function et(t,e=null,n={}){let s=null,r=null;if(e&&"object"==typeof e?s=(r=e).code:(r=n,s=e),Array.isArray(t)){const e=Object.assign({},r,{render:!1}),n=t.map(t=>tt(t,s,e));return!1!==r.render&&$(n),n}return tt(t,s,r)}class nt{constructor(t,e){Array.isArray(e)?this.deltas=e:this.deltas=[0,2*-e/3,-e,2*-e/3,0,2*e/3,e,2*e/3],this.partWidth=t/this.deltas.length}getDelta(t){return this.deltas[t%this.deltas.length]}}class st{constructor(t){this.svg=t}reset(){}addDefs(){}getBlock(t){return this.blocks[t]||this.blocks[""]}getNote(t){return this.notes[t]||this.notes[""]}getDivider(t){return this.dividers[t]||this.dividers[""]}optionsAttributes(t,e){return function(t,e){const n=Object.assign({},t[""]);return e.forEach(e=>{Object.assign(n,t[e]||{})}),n}(t,e)}renderAgentLine({x:t,y0:e,y1:n,width:s,className:r,options:i}){const a=this.optionsAttributes(this.agentLineAttrs,i);return s>0?this.svg.box(a,{x:t-s/2,y:e,width:s,height:n-e}).addClass(r):this.svg.line(a,{x1:t,x2:t,y1:e,y2:n}).addClass(r)}renderArrowHead(t,{x:e,y:n,width:s,height:r,dir:i}){const a=s*i.dx,o=s*i.dy,h=.5*r*i.dx,l=.5*-r*i.dy;return this.svg.el("none"===t.fill?"polyline":"polygon").attr("points",e+a-l+" "+(n+o-h)+" "+e+" "+n+" "+(e+a+l)+" "+(n+o+h)).attrs(t)}renderTag(t,{x:e,y:n,width:s,height:r}){const{rx:i,ry:a}=t,o=e+s,h=n+r,l="M"+o+" "+n+"L"+o+" "+(h-a)+"L"+(o-i)+" "+h+"L"+e+" "+h,d=this.svg.el("g");return"none"!==t.fill&&d.add(this.svg.el("path").attr("d",l+"L"+e+" "+n).attrs(t).attr("stroke","none")),"none"!==t.stroke&&d.add(this.svg.el("path").attr("d",l).attrs(t).attr("fill","none")),d}renderDB(t,e){const n=t["db-z"];return this.svg.el("g").add(this.svg.box({rx:e.width/2,ry:n},e).attrs(t),this.svg.el("path").attr("d","M"+e.x+" "+(e.y+n)+"a"+e.width/2+" "+n+" 0 0 0 "+e.width+" 0").attrs(t).attr("fill","none"))}renderRef(t,e){return{shape:this.svg.box(t,e).attrs({fill:"none"}),mask:this.svg.box(t,e).attrs({fill:"#000000",stroke:"none"}),fill:this.svg.box(t,e).attrs({stroke:"none"})}}renderFlatConnect(t,e,{x1:n,y1:s,x2:r,y2:i}){return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(t).move(n,s).line(r,i).cap().asPath()).attrs(e),p1:{x:n,y:s},p2:{x:r,y:i}}}renderRevConnect(t,e,{x1:n,y1:s,x2:r,y2:i,xR:a,rad:o}){const h=(i-s)/2,l=this.svg.patternedLine(t).move(n,s).line(a,s);return o<h?l.arc(a,s+o,Math.PI/2).line(a+o,i-o).arc(a,i-o,Math.PI/2):l.arc(a,(s+i)/2,Math.PI),{shape:this.svg.el("path").attr("d",l.line(r,i).cap().asPath()).attrs(e),p1:{x:n,y:s},p2:{x:r,y:i}}}renderLineDivider({lineAttrs:t},{x:e,y:n,labelWidth:s,width:r,height:i}){let a=null;const o=n+i/2;return a=s>0?this.svg.el("g").add(this.svg.line({fill:"none"},{x1:e,x2:e+(r-s)/2,y1:o,y2:o}).attrs(t),this.svg.line({fill:"none"},{x1:e+(r+s)/2,x2:e+r,y1:o,y2:o}).attrs(t)):this.svg.line({fill:"none"},{x1:e,x2:e+r,y1:o,y2:o}).attrs(t),{shape:a}}renderDelayDivider({dotSize:t,gapSize:e},{x:n,y:s,width:r,height:i}){const a=this.svg.el("g");for(let o=0;o+e<=i;o+=t+e)a.add(this.svg.box({fill:"#000000"},{x:n,y:s+o,width:r,height:e}));return{mask:a}}renderTearDivider({fadeBegin:t,fadeSize:e,pattern:n,zigWidth:s,zigHeight:r,lineAttrs:i},{x:a,y:o,labelWidth:h,labelHeight:l,width:d,height:g,env:c}){const u=c.addDef("tear-grad",()=>{const n=100/d;return this.svg.linearGradient({},[{offset:t*n+"%","stop-color":"#000000"},{offset:(t+e)*n+"%","stop-color":"#FFFFFF"},{offset:100-(t+e)*n+"%","stop-color":"#FFFFFF"},{offset:100-t*n+"%","stop-color":"#000000"}])}),p=this.svg.el("mask").attr("maskUnits","userSpaceOnUse").add(this.svg.box({fill:"url(#"+u+")"},{x:a,y:o-5,width:d,height:g+10})),f=c.addDef(p);h>0&&p.add(this.svg.box({rx:2,ry:2,fill:"#000000"},{x:a+(d-h)/2,y:o+(g-l)/2-1,width:h,height:l+2}));const m=n||new nt(s,[r,-r]);let b=null;const y=this.svg.patternedLine(m).move(a,o).line(a+d,o),x=this.svg.el("g").attr("mask","url(#"+f+")").add(this.svg.el("path").attrs({d:y.asPath(),fill:"none"}).attrs(i));if(g>0){const t=this.svg.patternedLine(m).move(a,o+g).line(a+d,o+g);x.add(this.svg.el("path").attrs({d:t.asPath(),fill:"none"}).attrs(i)),y.line(t.x,t.y,{patterned:!1}).cap(),y.points.push(...t.points.reverse()),b=this.svg.el("path").attrs({d:y.asPath(),fill:"#000000"})}return{shape:x,mask:b}}}const rt="sans-serif",it=new nt(6,.5),at={"font-family":rt,"font-size":8,"line-height":1.3},ot={"font-family":rt,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class ht extends st{constructor(t){super(t);const e={padding:{top:3,bottom:2},tag:{padding:{top:1,left:3,right:3,bottom:0},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:2,ry:2}),labelAttrs:{"font-family":rt,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:4,padding:{top:1,left:5,right:3,bottom:1},labelAttrs:{"font-family":rt,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:10,outerMargin:5,agentMargin:10,actionMargin:10,minActionMargin:3,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:5,left:10,right:10,bottom:5},arrowBottom:12.8,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":1},labelAttrs:{"font-family":rt,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:12,left:10,right:10,bottom:3},arrowBottom:12.8,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,"db-z":5}),labelAttrs:{"font-family":rt,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},cross:{size:20,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},fade:{width:5,height:6,extend:1},none:{height:10}},connect:{loopbackRadius:6,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-dasharray":"4, 2"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"round","stroke-linecap":"round"},renderFlat:this.renderFlatConnect.bind(this,it),renderRev:this.renderRevConnect.bind(this,it)}},arrow:{single:{width:5,height:10,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000","stroke-width":0,"stroke-linejoin":"miter"}},double:{width:4,height:6,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"miter"}},cross:{short:7,radius:3,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})}},label:{padding:6,margin:{top:2,bottom:1},attrs:{"font-family":rt,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":rt,"font-size":8,"line-height":1.3}},source:{radius:2,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":rt,"font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":1},red:{stroke:"#CC0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":1.5,"stroke-dasharray":"4, 2"})}},notes:{text:{margin:{top:0,left:2,right:2,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:at},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:5,right:10,bottom:5},overlap:{left:10,right:10},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:at},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:7,left:7,right:7,bottom:7},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:10,ry:10}),labelAttrs:at}},dividers:{"":{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000"}})},delay:{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:1,gapSize:2})},tear:{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,zigWidth:6,zigHeight:1,lineAttrs:{stroke:"#000000"}})}}})}}class lt{constructor(){this.name="basic"}build(t){return new ht(t)}}const dt="sans-serif",gt=new nt(10,1),ct={"font-family":dt,"font-size":8,"line-height":1.3},ut={"font-family":dt,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class pt extends st{constructor(t){super(t);const e={padding:{top:3,bottom:4},tag:{padding:{top:2,left:5,right:5,bottom:1},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2,rx:3,ry:3}),labelAttrs:{"font-family":dt,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:5,padding:{top:2,left:5,right:3,bottom:1},labelAttrs:{"font-family":dt,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:12,outerMargin:5,agentMargin:8,actionMargin:5,minActionMargin:5,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:1,left:3,right:3,bottom:1},arrowBottom:11.1,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":3,rx:4,ry:4},labelAttrs:{"font-family":dt,"font-weight":"bold","font-size":14,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:4,left:3,right:3,bottom:0},arrowBottom:11.1,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":3,"db-z":2}),labelAttrs:{"font-family":dt,"font-weight":"bold","font-size":14,"line-height":1.3,"text-anchor":"middle"}},cross:{size:20,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":3,"stroke-linecap":"round"})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":3,rx:2,ry:2})},fade:{width:5,height:10,extend:1},none:{height:10}},connect:{loopbackRadius:8,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":3},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-dasharray":"10, 4"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"},renderFlat:this.renderFlatConnect.bind(this,gt),renderRev:this.renderRevConnect.bind(this,gt)}},arrow:{single:{width:10,height:12,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round"}},double:{width:10,height:12,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"}},cross:{short:10,radius:5,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"})}},label:{padding:7,margin:{top:2,bottom:3},attrs:{"font-family":dt,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":dt,"font-size":8,"line-height":1.3}},source:{radius:5,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":3})},mask:{padding:{top:1,left:5,right:5,bottom:3}}},titleAttrs:{"font-family":dt,"font-weight":"bolder","font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":3},red:{stroke:"#DD0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":4,rx:5,ry:5}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":4,rx:5,ry:5}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":4,rx:5,ry:5}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":2,"stroke-dasharray":"5, 3"})}},notes:{text:{margin:{top:0,left:2,right:2,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:ct},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:3,left:3,right:10,bottom:3},overlap:{left:10,right:10},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":2,"stroke-linejoin":"round"},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:ct},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:7,right:7,bottom:5},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":3,rx:10,ry:10}),labelAttrs:ct}},dividers:{"":{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000","stroke-width":2,"stroke-linecap":"round"}})},delay:{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:3,gapSize:3})},tear:{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,zigWidth:6,zigHeight:1,lineAttrs:{stroke:"#000000","stroke-width":2,"stroke-linejoin":"round"}})}}})}}class ft{constructor(){this.name="chunky"}build(t){return new pt(t)}}class mt{constructor(){this.listeners=new Map,this.forwards=new Set}addEventListener(t,e){const n=this.listeners.get(t);n?n.push(e):this.listeners.set(t,[e])}removeEventListener(t,e){const n=this.listeners.get(t);if(!n)return;const s=n.indexOf(e);-1!==s&&n.splice(s,1)}on(t,e){return this.addEventListener(t,e),this}off(t,e){return this.removeEventListener(t,e),this}countEventListeners(t){return(this.listeners.get(t)||[]).length}removeAllEventListeners(t){t?this.listeners.delete(t):this.listeners.clear()}addEventForwarding(t){this.forwards.add(t)}removeEventForwarding(t){this.forwards.delete(t)}removeAllEventForwardings(){this.forwards.clear()}trigger(t,e=[]){(this.listeners.get(t)||[]).forEach(t=>t(...e)),this.forwards.forEach(n=>n.trigger(t,e))}}const bt="undefined"==typeof window,yt=!bt&&/^((?!chrome|android).)*safari/i.test(window.navigator.userAgent),xt=!bt&&void 0!==window.InstallTrigger;class kt{constructor(){this.latestSVG=null,this.latestInternalSVG=null,this.canvas=null,this.context=null,this.indexPNG=0,this.latestPNGIndex=0,this.latestPNG=null}getSVGContent(t){let e=t.dom().outerHTML;return e=e.replace(/^<svg/,'<svg width="'+(t.width||1)+'" height="'+(t.height||1)+'" ')}getSVGBlob(t){return new Blob([this.getSVGContent(t)],{type:"image/svg+xml"})}getSVGURL(t){const e=this.getSVGBlob(t);return this.latestSVG&&URL.revokeObjectURL(this.latestSVG),this.latestSVG=URL.createObjectURL(e),this.latestSVG}getCanvas(t,e,n){this.canvas||(window.devicePixelRatio=1,this.canvas=document.createElement("canvas"),this.context=this.canvas.getContext("2d"));const s=(t.width||1)*e,r=(t.height||1)*e,i=new Image(s,r);let a=null;yt&&((a=document.createElement("div")).style.position="absolute",a.style.visibility="hidden",a.appendChild(i),document.body.appendChild(a));const o=()=>{this.canvas.width=s,this.canvas.height=r,this.context.drawImage(i,0,0,s,r),a&&document.body.removeChild(a),n(this.canvas)};i.addEventListener("load",()=>{a?setTimeout(o,50):o()},{once:!0}),i.src=this.getSVGURL(t)}getPNGBlob(t,e,n){this.getCanvas(t,e,t=>{t.toBlob(n,"image/png")})}getPNGURL(t,e,n){++this.indexPNG;const s=this.indexPNG;this.getPNGBlob(t,e,t=>{const e=URL.createObjectURL(t);s>=this.latestPNGIndex?(this.latestPNG&&URL.revokeObjectURL(this.latestPNG),this.latestPNG=e,this.latestPNGIndex=s,n(e,!0)):(n(e,!1),URL.revokeObjectURL(e))})}}class wt{constructor({visible:t=!1,locked:e=!1,blocked:n=!1,highlighted:s=!1,group:r=null,covered:i=!1}={}){this.visible=t,this.locked=e,this.blocked=n,this.highlighted=s,this.group=r,this.covered=i}}wt.LOCKED=new wt({locked:!0}),wt.DEFAULT=new wt;const vt={equals:(t,e)=>t.name===e.name,hasFlag:(t,e=!0)=>n=>n.flags.includes(t)===e},At={equals:(t,e)=>t.id===e.id,make:(t,{anchorRight:e=!1,isVirtualSource:n=!1}={})=>({anchorRight:e,id:t,isVirtualSource:n,options:[]}),indexOf:(e,n)=>t(e,n,At.equals),hasIntersection:(e,n)=>(function(e,n,s=null){for(let r=0;r<n.length;++r)if(-1!==t(e,n[r],s))return!0;return!1})(e,n,At.equals),addNearby:(e,n,s,r)=>{const i=t(e,n,At.equals);-1===i?e.push(s):e.splice(i+r,0,s)}},Ft={"note over":[At.make("["),At.make("]")],"note left":[At.make("[")],"note right":[At.make("]")]},Mt=["[","]"],St={"agent begin":{check:["mode"],merge:["agentIDs"],siblings:new Set(["agent highlight"])},"agent end":{check:["mode"],merge:["agentIDs"],siblings:new Set(["agent highlight"])},"agent highlight":{check:["highlighted"],merge:["agentIDs"],siblings:new Set(["agent begin","agent end"])}};class Rt{constructor(){this.agentStates=new Map,this.agentAliases=new Map,this.activeGroups=new Map,this.gAgents=[],this.labelPattern=null,this.nextID=0,this.nesting=[],this.markers=new Set,this.currentSection=null,this.currentNest=null,this.stageHandlers={"block begin":this.handleBlockBegin.bind(this),"block split":this.handleBlockSplit.bind(this),"block end":this.handleBlockEnd.bind(this),"group begin":this.handleGroupBegin.bind(this),mark:this.handleMark.bind(this),async:this.handleAsync.bind(this),"agent define":this.handleAgentDefine.bind(this),"agent options":this.handleAgentOptions.bind(this),"agent begin":this.handleAgentBegin.bind(this),"agent end":this.handleAgentEnd.bind(this),divider:this.handleDivider.bind(this),"label pattern":this.handleLabelPattern.bind(this),connect:this.handleConnect.bind(this),"connect-delay-begin":this.handleConnectDelayBegin.bind(this),"connect-delay-end":this.handleConnectDelayEnd.bind(this),"note over":this.handleNote.bind(this),"note left":this.handleNote.bind(this),"note right":this.handleNote.bind(this),"note between":this.handleNote.bind(this)},this.expandGroupedGAgent=this.expandGroupedGAgent.bind(this),this.handleStage=this.handleStage.bind(this),this.toGAgent=this.toGAgent.bind(this),this.endGroup=this.endGroup.bind(this)}toGAgent({name:t,alias:e,flags:n}){if(e){if(this.agentAliases.has(t))throw new Error("Cannot alias "+t+"; it is already an alias");const n=this.agentAliases.get(e);if(n&&n!==e||this.gAgents.some(t=>t.id===e))throw new Error("Cannot use "+e+" as an alias; it is already in use");this.agentAliases.set(e,t)}return At.make(this.agentAliases.get(t)||t,{isVirtualSource:n.includes("source")})}addStage(t,e=!0){t&&(void 0===t.ln&&(t.ln=this.latestLine),this.currentSection.stages.push(t),e&&(this.currentNest.hasContent=!0))}addParallelStages(t){const e=t.filter(t=>Boolean(t));0!==e.length&&(1!==e.length?(e.forEach(t=>{void 0===t.ln&&(t.ln=this.latestLine)}),this.addStage({type:"parallel",stages:e})):this.addStage(e[0]))}defineGAgents(t){e(this.currentNest.gAgents,t.filter(t=>!Mt.includes(t.id)),At.equals),e(this.gAgents,t,At.equals)}getGAgentState(t){return this.agentStates.get(t.id)||wt.DEFAULT}updateGAgentState(t,e){const n=this.agentStates.get(t.id);n?Object.assign(n,e):this.agentStates.set(t.id,new wt(e))}replaceGAgentState(t,e){this.agentStates.set(t.id,e)}validateGAgents(t,{allowGrouped:e=!1,allowCovered:n=!1,allowVirtual:s=!1}={}){t.forEach(t=>{const r=this.getGAgentState(t);if(r.blocked&&null===r.group)throw new Error("Duplicate agent name: "+t.id);if(!n&&r.covered)throw new Error("Agent "+t.id+" is hidden behind group");if(!e&&null!==r.group)throw new Error("Agent "+t.id+" is in a group");if(!s&&t.isVirtualSource)throw new Error("cannot use message source here");if(t.id.startsWith("__"))throw new Error(t.id+" is a reserved name")})}setGAgentVis(t,e,n,s=!1){const r=new Set,i=t.filter(t=>{if(r.has(t.id))return!1;r.add(t.id);const n=this.getGAgentState(t);if(n.locked||n.blocked){if(s)throw new Error("Cannot begin/end agent: "+t.id);return!1}return n.visible!==e});return 0===i.length?null:(i.forEach(t=>{this.updateGAgentState(t,{visible:e})}),this.defineGAgents(i),{type:e?"agent begin":"agent end",agentIDs:i.map(t=>t.id),mode:n})}setGAgentHighlight(t,e,n=!1){const s=t.filter(t=>{const s=this.getGAgentState(t);if(s.locked||s.blocked){if(n)throw new Error("Cannot highlight agent: "+t.id);return!1}return s.visible&&s.highlighted!==e});return 0===s.length?null:(s.forEach(t=>{this.updateGAgentState(t,{highlighted:e})}),{type:"agent highlight",agentIDs:s.map(t=>t.id),highlighted:e})}_makeSection(t,e){return{header:t,delayedConnections:new Map,stages:e}}_checkSectionEnd(){const t=this.currentSection.delayedConnections;if(t.size>0){const e=t.values().next().value;throw new Error('Unused delayed connection "'+e.tag+'" at line '+(e.ln+1))}}beginNested(t,{tag:e,label:n,name:s,ln:r}){const i=At.make(s+"[",{anchorRight:!0}),a=At.make(s+"]"),o=[i,a],h=[];return this.currentSection=this._makeSection({type:"block begin",blockType:t,tag:this.textFormatter(e),label:this.textFormatter(n),canHide:!0,left:i.id,right:a.id,ln:r},h),this.currentNest={blockType:t,gAgents:o,leftGAgent:i,rightGAgent:a,hasContent:!1,sections:[this.currentSection]},this.replaceGAgentState(i,wt.LOCKED),this.replaceGAgentState(a,wt.LOCKED),this.nesting.push(this.currentNest),{stages:h}}nextBlockName(){const t="__BLOCK"+this.nextID;return++this.nextID,t}nextVirtualAgentName(){const t="__"+this.nextID;return++this.nextID,t}handleBlockBegin({ln:t,blockType:e,tag:n,label:s}){this.beginNested(e,{tag:n,label:s,name:this.nextBlockName(),ln:t})}handleBlockSplit({ln:t,blockType:e,tag:n,label:s}){if("if"!==this.currentNest.blockType)throw new Error('Invalid block nesting ("else" inside '+this.currentNest.blockType+")");this._checkSectionEnd(),this.currentSection=this._makeSection({type:"block split",blockType:e,tag:this.textFormatter(n),label:this.textFormatter(s),left:this.currentNest.leftGAgent.id,right:this.currentNest.rightGAgent.id,ln:t},[]),this.currentNest.sections.push(this.currentSection)}handleBlockEnd(){if(this.nesting.length<=1)throw new Error('Invalid block nesting (too many "end"s)');this._checkSectionEnd();const t=this.nesting.pop();if(this.currentNest=r(this.nesting),this.currentSection=r(this.currentNest.sections),!t.hasContent)throw new Error("Empty block");this.defineGAgents(t.gAgents),p(this.gAgents,t.leftGAgent,t.rightGAgent,t.gAgents),t.sections.forEach(t=>{this.currentSection.stages.push(t.header),this.currentSection.stages.push(...t.stages)}),this.addStage({type:"block end",left:t.leftGAgent.id,right:t.rightGAgent.id})}makeGroupDetails(t,e){const s=t.map(this.toGAgent);if(this.validateGAgents(s),this.agentStates.has(e))throw new Error("Duplicate agent name: "+e);const r=this.nextBlockName(),i=At.make(r+"[",{anchorRight:!0}),a=At.make(r+"]");this.replaceGAgentState(i,wt.LOCKED),this.replaceGAgentState(a,wt.LOCKED),this.updateGAgentState(At.make(e),{blocked:!0,group:e}),this.defineGAgents([...s,i,a]);const{indexL:o,indexR:h}=p(this.gAgents,i,a,s),l=[],d=s.slice();for(let t=o+1;t<h;++t)l.push(this.gAgents[t]);return n(l,d,At.equals),{gAgents:s,leftGAgent:i,rightGAgent:a,gAgentsContained:d,gAgentsCovered:l}}handleGroupBegin({agents:t,blockType:e,tag:n,label:s,alias:r}){const i=this.makeGroupDetails(t,r);i.gAgentsContained.forEach(t=>{this.updateGAgentState(t,{group:r})}),i.gAgentsCovered.forEach(t=>{this.updateGAgentState(t,{covered:!0})}),this.activeGroups.set(r,i),this.addStage(this.setGAgentVis(i.gAgents,!0,"box")),this.addStage({type:"block begin",blockType:e,tag:this.textFormatter(n),canHide:!1,label:this.textFormatter(s),left:i.leftGAgent.id,right:i.rightGAgent.id})}endGroup({name:t}){const e=this.activeGroups.get(t);return e?(this.activeGroups.delete(t),e.gAgentsContained.forEach(t=>{this.updateGAgentState(t,{group:null})}),e.gAgentsCovered.forEach(t=>{this.updateGAgentState(t,{covered:!1})}),this.updateGAgentState(At.make(t),{group:null}),{type:"block end",left:e.leftGAgent.id,right:e.rightGAgent.id}):null}handleMark({name:t}){this.markers.add(t),this.addStage({type:"mark",name:t},!1)}handleDivider({mode:t,height:e,label:n}){this.addStage({type:"divider",mode:t,height:e,formattedLabel:this.textFormatter(n)},!1)}handleAsync({target:t}){if(""!==t&&!this.markers.has(t))throw new Error("Unknown marker: "+t);this.addStage({type:"async",target:t},!1)}handleLabelPattern({pattern:t}){this.labelPattern=t.slice();for(let t=0;t<this.labelPattern.length;++t){const e=this.labelPattern[t];"object"==typeof e&&void 0!==e.start&&(this.labelPattern[t]=Object.assign({current:e.start},e))}}applyLabelPattern(t){let e="";const n={label:t};return this.labelPattern.forEach(t=>{"string"==typeof t?e+=t:void 0!==t.token?e+=n[t.token]:void 0!==t.current&&(e+=t.current.toFixed(t.dp),t.current+=t.inc)}),e}expandGroupedGAgent(t){const{group:e}=this.getGAgentState(t);if(!e)return[t];const n=this.activeGroups.get(e);return[n.leftGAgent,n.rightGAgent]}expandGroupedGAgentConnection(t){const e=this.expandGroupedGAgent(t[0]),n=this.expandGroupedGAgent(t[1]);let s=At.indexOf(this.gAgents,e[0]),i=At.indexOf(this.gAgents,n[0]);return-1===s&&(s=e[0].isVirtualSource?-1:this.gAgents.length),-1===i&&(i=this.gAgents.length),s===i?[r(e),r(n)]:s<i?[r(e),n[0]]:[e[0],r(n)]}filterConnectFlags(t){const n=t.filter(vt.hasFlag("begin")).map(this.toGAgent),s=t.filter(vt.hasFlag("end")).map(this.toGAgent);if(At.hasIntersection(n,s))throw new Error("Cannot set agent visibility multiple times");const r=t.filter(vt.hasFlag("start")).map(this.toGAgent),i=t.filter(vt.hasFlag("stop")).map(this.toGAgent);if(e(i,s),At.hasIntersection(r,i))throw new Error("Cannot set agent highlighting multiple times");return this.validateGAgents(n),this.validateGAgents(s),this.validateGAgents(r),this.validateGAgents(i),{beginGAgents:n,endGAgents:s,startGAgents:r,stopGAgents:i}}makeVirtualAgent(t){const e=At.make(this.nextVirtualAgentName(),{anchorRight:t,isVirtualSource:!0});return this.replaceGAgentState(e,wt.LOCKED),e}addNearbyAgent(t,e,n){At.addNearby(this.currentNest.gAgents,t,e,n),At.addNearby(this.gAgents,t,e,n)}expandVirtualSourceAgents(t){if(t[0].isVirtualSource){if(t[1].isVirtualSource)throw new Error("Cannot connect found messages");if(Mt.includes(t[1].id))throw new Error("Cannot connect found messages to special agents");const e=this.makeVirtualAgent(!0);return this.addNearbyAgent(t[1],e,0),[e,t[1]]}if(t[1].isVirtualSource){if(Mt.includes(t[0].id))throw new Error("Cannot connect found messages to special agents");const e=this.makeVirtualAgent(!1);return this.addNearbyAgent(t[0],e,1),[t[0],e]}return t}_handlePartialConnect(t){const e=this.filterConnectFlags(t),n=t.map(this.toGAgent);this.validateGAgents(n,{allowGrouped:!0,allowVirtual:!0}),this.defineGAgents(a(n,this.expandGroupedGAgent).filter(t=>!t.isVirtualSource));const s=t.filter(vt.hasFlag("begin",!1)).map(this.toGAgent).filter(t=>!t.isVirtualSource);return this.addStage(this.setGAgentVis(s,!0,"box")),{flags:e,gAgents:n}}_makeConnectParallelStages(t,e){return[this.setGAgentVis(t.beginGAgents,!0,"box",!0),this.setGAgentHighlight(t.startGAgents,!0,!0),e,this.setGAgentHighlight(t.stopGAgents,!1,!0),this.setGAgentVis(t.endGAgents,!1,"cross",!0)]}_isSelfConnect(t){const e=t.map(this.toGAgent),n=this.expandGroupedGAgentConnection(e);return n[0].id===n[1].id&&!n.some(t=>t.isVirtualSource)}handleConnect({agents:t,label:e,options:n}){if(this._isSelfConnect(t)){const s={};return this.handleConnectDelayBegin({agent:t[0],tag:s,options:n,ln:0}),void this.handleConnectDelayEnd({agent:t[1],tag:s,label:e,options:n})}let{flags:s,gAgents:r}=this._handlePartialConnect(t);r=this.expandGroupedGAgentConnection(r);const i={type:"connect",agentIDs:(r=this.expandVirtualSourceAgents(r)).map(t=>t.id),label:this.textFormatter(this.applyLabelPattern(e)),options:n};this.addParallelStages(this._makeConnectParallelStages(s,i))}handleConnectDelayBegin({agent:t,tag:e,options:n,ln:s}){const r=this.currentSection.delayedConnections;if(r.has(e))throw new Error('Duplicate delayed connection "'+e+'"');const{flags:i,gAgents:a}=this._handlePartialConnect([t]),o=this.nextVirtualAgentName(),h={type:"connect-delay-begin",tag:o,agentIDs:null,label:null,options:n};r.set(e,{tag:e,uniqueTag:o,ln:s,gAgents:a,connectStage:h}),this.addParallelStages(this._makeConnectParallelStages(i,h))}handleConnectDelayEnd({agent:t,tag:e,label:n,options:s}){const r=this.currentSection.delayedConnections,i=r.get(e);if(!i)throw new Error('Unknown delayed connection "'+e+'"');let{flags:a,gAgents:o}=this._handlePartialConnect([t]);o=this.expandGroupedGAgentConnection([...i.gAgents,...o]),o=this.expandVirtualSourceAgents(o);let h=i.connectStage.options;if(h.line!==s.line)throw new Error("Mismatched delayed connection arrows");s.right&&(h=Object.assign({},h,{right:s.right})),Object.assign(i.connectStage,{agentIDs:o.map(t=>t.id),label:this.textFormatter(this.applyLabelPattern(n)),options:h});const l={type:"connect-delay-end",tag:i.uniqueTag};this.addParallelStages(this._makeConnectParallelStages(a,l)),r.delete(e)}handleNote({type:t,agents:e,mode:n,label:s}){let r=null;r=0===e.length?Ft[t]||[]:e.map(this.toGAgent),this.validateGAgents(r,{allowGrouped:!0});const i=(r=a(r,this.expandGroupedGAgent)).map(t=>t.id),o=new Set(i).size;if("note between"===t&&o<2)throw new Error("note between requires at least 2 agents");this.addStage(this.setGAgentVis(r,!0,"box")),this.defineGAgents(r),this.addStage({type:t,agentIDs:i,mode:n,label:this.textFormatter(s)})}handleAgentDefine({agents:t}){const n=t.map(this.toGAgent);this.validateGAgents(n,{allowGrouped:!0,allowCovered:!0}),e(this.gAgents,n,At.equals)}handleAgentOptions({agent:t,options:n}){const s=this.toGAgent(t),r=[s];this.validateGAgents(r,{allowGrouped:!0,allowCovered:!0}),e(this.gAgents,r,At.equals),this.gAgents.filter(({id:t})=>t===s.id).forEach(t=>{e(t.options,n)})}handleAgentBegin({agents:t,mode:e}){const n=t.map(this.toGAgent);this.validateGAgents(n),this.addStage(this.setGAgentVis(n,!0,e,!0))}handleAgentEnd({agents:t,mode:e}){const n=t.filter(t=>this.activeGroups.has(t.name)),s=t.filter(t=>!this.activeGroups.has(t.name)).map(this.toGAgent);this.validateGAgents(s),this.addParallelStages([this.setGAgentHighlight(s,!1),this.setGAgentVis(s,!1,e,!0),...n.map(this.endGroup)])}handleStage(t){this.latestLine=t.ln;try{const e=this.stageHandlers[t.type];if(!e)throw new Error("Unknown command: "+t.type);e(t)}catch(e){if("object"==typeof e&&e.message)throw e.message+=" at line "+(t.ln+1),e}}_reset(){this.agentStates.clear(),this.markers.clear(),this.agentAliases.clear(),this.activeGroups.clear(),this.gAgents.length=0,this.nextID=0,this.nesting.length=0,this.labelPattern=[{token:"label"}]}_finalise(t){p(this.gAgents,this.currentNest.leftGAgent,this.currentNest.rightGAgent),function(t){let e=[],n=new Set;for(let s=0;s<t.length;){const r=t[s];let i=null;d(i="parallel"===r.type?r.stages:[r]);const a=g(i);c(n,a,e,i),0===i.length?t.splice(s,1):("parallel"===r.type&&1===i.length&&t.splice(s,1,i[0]),n=a,e=i,++s)}}(t.stages),this.gAgents.forEach(t=>{t.formattedLabel=this.textFormatter(t.id)})}generate({stages:t,meta:e={}}){this._reset(),this.textFormatter=e.textFormatter;const n=this.beginNested("global",{tag:"",label:"",name:"",ln:0});if(t.forEach(this.handleStage),1!==this.nesting.length)throw new Error("Unterminated section at line "+(this.currentSection.header.ln+1));if(this.activeGroups.size>0)throw new Error("Unterminated group");this._checkSectionEnd();const s=e.terminators||"none";return this.addParallelStages([this.setGAgentHighlight(this.gAgents,!1),this.setGAgentVis(this.gAgents,!1,s)]),this._finalise(n),function(t,e){for(let n=0;n<t.length&&!u(t[n],e);++n);}(n.stages,e.headers||"box"),{meta:{title:this.textFormatter(e.title),theme:e.theme,code:e.code},agents:this.gAgents.slice(),stages:n.stages}}}const Ct="monospace",Et=new nt(6,[0,-.25,-.5,-.25,0,.25,.5,.25]),Gt={"font-family":Ct,"font-size":8,"line-height":1.3},It={"font-family":Ct,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class Dt extends st{constructor(t){super(t);const e={padding:{top:3,bottom:2},tag:{padding:{top:2,left:4,right:4,bottom:2},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:3,ry:3}),labelAttrs:{"font-family":Ct,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:8,padding:{top:2,left:8,right:8,bottom:2},labelAttrs:{"font-family":Ct,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:8,outerMargin:4,agentMargin:12,actionMargin:12,minActionMargin:4,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:4,left:8,right:8,bottom:4},arrowBottom:12,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":1},labelAttrs:{"font-family":Ct,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:9,left:8,right:8,bottom:3},arrowBottom:12,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,"db-z":4}),labelAttrs:{"font-family":Ct,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},cross:{size:16,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},fade:{width:5,height:8,extend:1},none:{height:8}},connect:{loopbackRadius:4,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-dasharray":"4, 4"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,Et),renderRev:this.renderRevConnect.bind(this,Et)}},arrow:{single:{width:4,height:8,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000","stroke-width":0,"stroke-linejoin":"miter"}},double:{width:3,height:6,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"miter"}},cross:{short:8,radius:4,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})}},label:{padding:4,margin:{top:2,bottom:1},attrs:{"font-family":Ct,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":Ct,"font-size":8,"line-height":1.3}},source:{radius:2,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":Ct,"font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":1},red:{stroke:"#AA0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":2}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":2,"stroke-dasharray":"8, 4"})}},notes:{text:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:4,left:4,right:4,bottom:4},overlap:{left:8,right:8},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:Gt},note:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:8,left:8,right:8,bottom:8},overlap:{left:8,right:8},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:Gt},state:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:8,left:8,right:8,bottom:8},overlap:{left:8,right:8},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:8,ry:8}),labelAttrs:Gt}},dividers:{"":{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:8,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000"}})},delay:{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:2,gapSize:2})},tear:{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:8,margin:8,render:this.renderTearDivider.bind(this,{fadeBegin:4,fadeSize:4,zigWidth:4,zigHeight:1,lineAttrs:{stroke:"#000000"}})}}})}}class Lt{constructor(){this.name="monospace"}build(t){return new Dt(t)}}const Nt={type:"error line-error",suggest:!1,then:{"":0}},zt=["database","red"],Ot=(()=>{function t(t,e=1){return{type:"variable",suggest:{known:"Agent"},then:Object.assign({},t,{"":0,",":{type:"operator",then:{"":e}}})}}function e(t){return{type:"keyword",suggest:[t+" of ",t+": "],then:{of:{type:"keyword",then:{"":h}},":":{type:"operator",then:{"":i}},"":h}}}function n({exit:t,sourceExit:e,blankExit:n}){const s={type:"operator",then:{"+":Nt,"-":Nt,"*":Nt,"!":Nt,"":t}};return{"+":{type:"operator",then:{"+":Nt,"-":Nt,"*":s,"!":Nt,"":t}},"-":{type:"operator",then:{"+":Nt,"-":Nt,"*":s,"!":{type:"operator",then:{"+":Nt,"-":Nt,"*":Nt,"!":Nt,"":t}},"":t}},"*":{type:"operator",then:Object.assign({"+":s,"-":s,"*":Nt,"!":Nt,"":t},e||t)},"!":s,"":n||t}}const s={type:"",suggest:"\n",then:{}},r={type:"",suggest:!1,then:{}},i=f({"\n":s}),a={type:"operator",then:{"":i,"\n":r}},o=t({"\n":s,as:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,",":{type:"operator",then:{"":3}},"\n":s}}}}}),h=t({":":a}),l={type:"variable",suggest:{known:"Agent"},then:{"":0,":":{type:"operator",then:{"":i,"\n":r}},"\n":s}},d={":":{type:"operator",then:{"":f({as:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,"\n":s}}}}})}}},g={type:"keyword",then:Object.assign({over:{type:"keyword",then:{"":t(d)}}},d)},c={"\n":s,":":{type:"operator",then:{"":i,"\n":r}},with:{type:"keyword",suggest:["with height "],then:{height:{type:"keyword",then:{"":{type:"number",suggest:["6 ","30 "],then:{"\n":s,":":{type:"operator",then:{"":i,"\n":r}}}}}}}}},u=function(t,e,n){const s=Object.assign({},n);return e.forEach(e=>{s[e]={type:t,then:n}}),s}("keyword",["a","an"],function(t,e,n){const s={},r=Object.assign({},n);return e.forEach(e=>{s[e]={type:t,then:r},r[e]=0}),s}("keyword",zt,{"\n":s})),p={type:"keyword",then:{"":i,":":{type:"operator",then:{"":i}},"\n":s}},m={title:{type:"keyword",then:{"":i}},theme:{type:"keyword",then:{"":{type:"string",suggest:{global:"themes",suffix:"\n"},then:{"":0,"\n":s}}}},headers:{type:"keyword",then:{none:{type:"keyword",then:{}},cross:{type:"keyword",then:{}},box:{type:"keyword",then:{}},fade:{type:"keyword",then:{}},bar:{type:"keyword",then:{}}}},terminators:{type:"keyword",then:{none:{type:"keyword",then:{}},cross:{type:"keyword",then:{}},box:{type:"keyword",then:{}},fade:{type:"keyword",then:{}},bar:{type:"keyword",then:{}}}},divider:{type:"keyword",then:Object.assign({line:{type:"keyword",then:c},space:{type:"keyword",then:c},delay:{type:"keyword",then:c},tear:{type:"keyword",then:c}},c)},define:{type:"keyword",then:{"":o,as:Nt}},begin:{type:"keyword",then:{"":o,reference:g,as:Nt}},end:{type:"keyword",then:{"":o,as:Nt,"\n":s}},if:p,else:{type:"keyword",suggest:["else\n","else if: "],then:{if:{type:"keyword",suggest:"if: ",then:{"":i,":":{type:"operator",then:{"":i}}}},"\n":s}},repeat:p,group:p,note:{type:"keyword",then:{over:{type:"keyword",then:{"":h}},left:e("left"),right:e("right"),between:{type:"keyword",then:{"":t({":":Nt},h)}}}},state:{type:"keyword",suggest:"state over ",then:{over:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,",":Nt,":":a}}}}}},text:{type:"keyword",then:{left:e("left"),right:e("right")}},autolabel:{type:"keyword",then:{off:{type:"keyword",then:{}},"":f({"\n":s},[{v:"<label>",suffix:"\n",q:!0},{v:"[<inc>] <label>",suffix:"\n",q:!0},{v:"[<inc 1,0.01>] <label>",suffix:"\n",q:!0}])}},simultaneously:{type:"keyword",then:{":":{type:"operator",then:{}},with:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Label"},then:{"":0,":":{type:"operator",then:{}}}}}}}}};return t=>({type:"error line-error",then:Object.assign({},m,function(t){const e={type:"keyword",then:Object.assign({},n({exit:l,sourceExit:{":":a,"\n":r}}),{"...":{type:"operator",then:{"":{type:"variable",suggest:{known:"DelayedAgent"},then:{"":0,":":Nt,"\n":s}}}}})},i={};t.forEach(t=>i[t]=e);const o={type:"operator",suggest:!1,override:"Label",then:{}},h={type:"variable",suggest:{known:"Agent"},then:Object.assign({"":0},i,{":":{type:"operator",override:"Label",then:{}}})},d={type:"variable",suggest:{known:"DelayedAgent"},then:Object.assign({"":0,":":o},i)},g=Object.assign({},h,{then:Object.assign({},h.then,{is:{type:"keyword",then:u}})});return Object.assign({"...":{type:"operator",then:{"":d}}},n({exit:h,sourceExit:Object.assign({"":h,":":o},i),blankExit:g}))}(t))})})();class Bt{constructor(t,e){this.tokenDefinitions=t,this.commands=Ot(e),this.lineComment="#"}startState(){return{currentType:-1,current:"",currentSpace:"",currentQuoted:!1,knownAgent:[],knownDelayedAgent:[],knownLabel:[],beginCompletions:y({},[this.commands]),completions:[],nextCompletions:[],valid:!0,isVar:!0,line:[],indent:0}}_matchPattern(t,e,n){return e?(e.lastIndex=0,t.match(e,n)):null}_tokenBegin(t,e){e.currentSpace="";for(let n="";!t.eol();n=t.next()){e.currentSpace+=n;for(let n=0;n<this.tokenDefinitions.length;++n){const s=this.tokenDefinitions[n];if(this._matchPattern(t,s.start,!0)){e.currentType=n;const{value:t,quoted:r}=w(s);return e.current=t,e.currentQuoted=r,!0}}}return!1}_tokenCheckEscape(t,e,n){const s=this._matchPattern(t,n.escape,!0);s&&(e.current+=n.escapeWith(s))}_addToken(t){t.line.push({v:t.current,s:t.currentSpace,q:t.currentQuoted})}_tokenEndFound(t,e,n,s){return e.currentType=-1,n.includeEnd&&(e.current+=s[0]),n.omit?"comment":(this._addToken(e),k(e,t.eol(),this.commands))}_tokenEOLFound(t,e,n){if(e.current+="\n",n.omit)return"comment";this._addToken(e);const s=k(e,!1,this.commands);return e.line.pop(),s}_tokenEnd(t,e){for(;;){const n=this.tokenDefinitions[e.currentType];if(this._tokenCheckEscape(t,e,n),!n.end)return this._tokenEndFound(t,e,n,null);{const s=this._matchPattern(t,n.end,!0);if(s)return this._tokenEndFound(t,e,n,s)}if(t.eol())return this._tokenEOLFound(t,e,n);e.current+=t.next()}}token(t,e){e.completions=e.nextCompletions,e.isVar=!0,t.sol()&&-1===e.currentType&&(e.line.length=0);let n="";return(-1!==e.currentType||this._tokenBegin(t,e))&&(n=this._tokenEnd(t,e)),-1===e.currentType&&t.eol()&&!e.valid?"line-error "+n:n}indent(t){return t.indent}}const Vt=[{end:/(?=\n)|$/y,omit:!0,start:/#/y},{baseToken:{q:!0},end:/"/y,escape:/\\(.)/y,escapeWith:function(t){return"n"===t[1]?"\n":t[1]},start:/"/y},{baseToken:{v:"..."},start:/\.\.\./y},{end:/(?=[ \t\r\n:+~\-*!<>,])|$/y,start:/(?=[^ \t\r\n:+~\-*!<>,])/y},{end:/(?=[^~\-<>x])|[-~]x|[<>](?=x)|$/y,includeEnd:!0,start:/(?=[~\-<])/y},{baseToken:{v:","},start:/,/y},{baseToken:{v:":"},start:/:/y},{baseToken:{v:"!"},start:/!/y},{baseToken:{v:"+"},start:/\+/y},{baseToken:{v:"*"},start:/\*/y},{baseToken:{v:"\n"},start:/\n/y}];class Ht{constructor(t){this.src=t,this.block=null,this.token=null,this.pos={ch:0,i:0,ln:0},this.reset()}isOver(){return this.pos.i>this.src.length}reset(){this.token={b:null,e:null,q:!1,s:"",v:""},this.block=null}beginToken(t){this.block=t.newBlock,Object.assign(this.token,this.block.baseToken),this.token.b=F(this.pos)}endToken(){let t=null;return this.block.omit||(this.token.e=F(this.pos),t=this.token),this.reset(),t}advance(){const t=A(this.src,this.pos.i,this.block);return t.newBlock&&this.beginToken(t),this.token.s+=t.appendSpace,this.token.v+=t.appendValue,function(t,e,n){for(let s=0;s<n;++s)++t.ch,"\n"===e[t.i+s]&&(++t.ln,t.ch=0);t.i+=n}(this.pos,this.src,t.skip),t.end?this.endToken():null}}class Tt{tokenise(t){const e=[],n=new Ht(t);for(;!n.isOver();){const t=n.advance();t&&e.push(t)}if(n.block)throw new Error("Unterminated literal (began at "+function(t){return"line "+(t.ln+1)+", character "+t.ch}(n.token.b)+")");return e}getCodeMirrorMode(t){return new Bt(Vt,t)}splitLines(t){const e=[];let n=[];return t.forEach(t=>{t.q||"\n"!==t.v?n.push(t):n.length>0&&(e.push(n),n=[])}),n.length>0&&e.push(n),e}}const Pt=/(.*?)<([^<>]*)>/g,jt=/\.([0-9]*)/,qt=[{attrs:{"font-style":"italic"},begin:/[\s_~`]\*(?=\S)/g,end:/\S\*(?=[\s_~`])/g},{attrs:{"font-style":"italic"},begin:/[\s*~`]_(?=\S)/g,end:/\S_(?=[\s*~`])/g},{attrs:{"font-weight":"bolder"},begin:/[\s_~`]\*\*(?=\S)/g,end:/\S\*\*(?=[\s_~`])/g},{attrs:{"font-weight":"bolder"},begin:/[\s*~`]__(?=\S)/g,end:/\S__(?=[\s*~`])/g},{attrs:{"text-decoration":"line-through"},begin:/[\s_*`]~(?=\S)/g,end:/\S~(?=[\s_*`])/g},{attrs:{"font-family":"monospace"},begin:/[\s_*~.]`(?=\S)/g,end:/\S`(?=[\s_*~.])/g}],Yt={if:{type:"block begin",blockType:"if",tag:"if",skip:[]},else:{type:"block split",blockType:"else",tag:"else",skip:["if"]},repeat:{type:"block begin",blockType:"repeat",tag:"repeat",skip:[]},group:{type:"block begin",blockType:"group",tag:"",skip:[]}},Wt={types:(()=>{const t=function(t){const e=[];return i(t,0,[],e),e}([[{tok:"",type:0},{tok:"<",type:1},{tok:"<<",type:2}],[{tok:"-",type:"solid"},{tok:"--",type:"dash"},{tok:"~",type:"wave"}],[{tok:"",type:0},{tok:">",type:1},{tok:">>",type:2},{tok:"x",type:3}]]).filter(t=>0!==t[0].type||0!==t[2].type),e=new Map;return t.forEach(t=>{e.set(t.map(t=>t.tok).join(""),{line:t[1].type,left:t[0].type,right:t[2].type})}),e})(),agentFlags:{"*":{flag:"begin",allowBlankName:!0,blankNameFlag:"source"},"+":{flag:"start"},"-":{flag:"stop"},"!":{flag:"end"}}},Ut=["none","box","cross","fade","bar"],Xt={text:{mode:"text",types:{left:{type:"note left",skip:["of"],min:0,max:null},right:{type:"note right",skip:["of"],min:0,max:null}}},note:{mode:"note",types:{over:{type:"note over",skip:[],min:0,max:null},left:{type:"note left",skip:["of"],min:0,max:null},right:{type:"note right",skip:["of"],min:0,max:null},between:{type:"note between",skip:[],min:2,max:null}}},state:{mode:"state",types:{over:{type:"note over",skip:[],min:1,max:1}}}},Qt={line:{defaultHeight:6},space:{defaultHeight:6},delay:{defaultHeight:30},tear:{defaultHeight:6}},Jt={define:{type:"agent define"},begin:{type:"agent begin",mode:"box"},end:{type:"agent end",mode:"cross"}},Zt=[(t,e)=>"title"!==D(t[0])?null:(e.title=I(t,1),!0),(t,e)=>"theme"!==D(t[0])?null:(e.theme=I(t,1),!0),(t,e)=>{if("terminators"!==D(t[0]))return null;const n=D(t[1]);if(!n)throw G("Unspecified termination",t[0]);if(-1===Ut.indexOf(n))throw G('Unknown termination "'+n+'"',t[1]);return e.terminators=n,!0},(t,e)=>{if("headers"!==D(t[0]))return null;const n=D(t[1]);if(!n)throw G("Unspecified header",t[0]);if(-1===Ut.indexOf(n))throw G('Unknown header "'+n+'"',t[1]);return e.headers=n,!0},t=>{if("divider"!==D(t[0]))return null;const e=N(t,":",{orEnd:!0}),n=N(t,["with","height"],{limit:e,orEnd:!0}),s=I(t,1,n)||"line";if(!Qt[s])throw G("Unknown divider type",t[1]);const r=function(t,e=0,n=null,s=Number.NAN){const r=I(t,e,n);return Number(r||s)}(t,n+2,e,Qt[s].defaultHeight);if(Number.isNaN(r)||r<0)throw G("Invalid divider height",t[n+2]);return{type:"divider",mode:s,height:r,label:I(t,e+1)}},t=>{if("autolabel"!==D(t[0]))return null;let e=null;return e="off"===D(t[1])?"<label>":I(t,1),{type:"label pattern",pattern:function(t){const e=[];let n=null,s=0;for(Pt.lastIndex=0;n=Pt.exec(t);)n[1]&&e.push(n[1]),n[2]&&e.push(S(n[2])),s=Pt.lastIndex;const r=t.substr(s);return r&&e.push(r),e}(e)}},t=>{if("end"===D(t[0])&&1===t.length)return{type:"block end"};const e=Yt[D(t[0])];if(!e)return null;let n=1;return t.length>n&&(n=L(t,n,e.skip,"Invalid block command")),n=L(t,n,[":"]),{type:e.type,blockType:e.blockType,tag:e.tag,label:I(t,n)}},t=>{if("begin"!==D(t[0])||"reference"!==D(t[1]))return null;let e=[];const n=N(t,":");if("over"===D(t[2])&&n>3)e=O(t,3,n);else if(2!==n)throw G('Expected ":" or "over"',t[2]);const s=z(t,n+1,t.length,{aliases:!0});if(!s.alias)throw G("Reference must have an alias",t[n]);return{type:"group begin",agents:e,blockType:"ref",tag:"ref",label:s.name,alias:s.alias}},t=>{const e=Jt[D(t[0])];return!e||t.length<=1?null:Object.assign({agents:O(t,1,t.length,{aliases:!0})},e)},t=>{if("simultaneously"!==D(t[0]))return null;if(":"!==D(r(t)))return null;let e="";if(t.length>2){if("with"!==D(t[1]))return null;e=I(t,2,t.length-1)}return{type:"async",target:e}},t=>{const e=Xt[D(t[0])],n=N(t,":");if(!e||-1===n)return null;const s=e.types[D(t[1])];if(!s)return null;let r=2;const i=O(t,r=L(t,r,s.skip),n);if(i.length<s.min)throw G("Too few agents for "+e.mode,t[0]);if(null!==s.max&&i.length>s.max)throw G("Too many agents for "+e.mode,t[0]);return{type:s.type,agents:i,mode:e.mode,label:I(t,n+1)}},t=>{const e=N(t,":",{orEnd:!0}),n=function(t,e,{start:n=0,limit:s=null}={}){null===s&&(s=t.length);for(let r=n;r<s;++r){const n=e.get(D(t[r]));if(n)return{pos:r,value:n}}return null}(t,Wt.types,{start:0,limit:e-1});if(!n)return null;const s=n.pos,r={flagTypes:Wt.agentFlags};if("..."===D(t[0]))return{type:"connect-delay-end",tag:I(t,1,s),agent:z(t,s+1,e,r),label:I(t,e+1),options:n.value};if("..."===D(t[s+1])){if(e!==t.length)throw G("Cannot label beginning of delayed connection",t[e]);return{type:"connect-delay-begin",tag:I(t,s+2,e),agent:z(t,0,s,r),options:n.value}}return{type:"connect",agents:[z(t,0,s,r),z(t,s+1,e,r)],label:I(t,e+1),options:n.value}},t=>t.length<2||":"!==D(r(t))?null:{type:"mark",name:I(t,0,t.length-1)},t=>{const e=N(t,"is");if(e<1)return null;let n=e+1;if(["a","an"].includes(D(t[n]))&&++n,n===t.length)throw G("Empty agent options",{b:r(t).e});const s=z(t,0,e),i=[];for(let e=n;e<t.length;++e)i.push(t[e].v);return{type:"agent options",agent:s,options:i}}],Kt=new Tt;class _t{getCodeMirrorMode(){return Kt.getCodeMirrorMode(Array.from(Wt.types.keys()))}parseLines(t,e){const n={meta:{title:"",theme:"",code:e,terminators:"none",headers:"box",textFormatter:E},stages:[]};return t.forEach(t=>(function(t,{meta:e,stages:n}){let s=null;for(let n=0;n<Zt.length&&!(s=Zt[n](t,e));++n);if(!s)throw G("Unrecognised command: "+I(t),t[0]);"object"==typeof s&&(s.ln=t[0].b.ln,n.push(s))})(t,n)),n}parse(t){const e=Kt.tokenise(t),n=Kt.splitLines(e);return this.parseLines(n,t)}}class $t{makeState(){}resetState(t){this.makeState(t)}prepareMeasurements(){}separationPre(){}separation(){}renderPre(){}render(){}renderHidden(){}shouldHide(){}}const te=new Map,ee={class:"outline",fill:"transparent"};class ne{getConfig(t,e){let n=null;return t.includes("database")&&(n=e.theme.agentCap.database),n||e.theme.agentCap.box}prepareMeasurements({formattedLabel:t,options:e},n){const s=this.getConfig(e,n);n.textSizer.expectMeasure(s.labelAttrs,t)}separation({formattedLabel:t,options:e},n){const s=this.getConfig(e,n),r=n.textSizer.measure(s.labelAttrs,t).width+s.padding.left+s.padding.right;return{left:r/2,radius:r/2,right:r/2}}topShift({formattedLabel:t,options:e},n){const s=this.getConfig(e,n),r=n.textSizer.measureHeight(s.labelAttrs,t)+s.padding.top+s.padding.bottom;return Math.max(0,r-s.arrowBottom)}render(t,{x:e,formattedLabel:n,options:s},r){const i=this.getConfig(s,r),a=r.svg.boxedText(i,n,{x:e,y:t});return r.makeRegion().add(a,r.svg.box(ee,{height:a.height,width:a.width,x:e-a.width/2,y:t})),{height:a.height,lineBottom:a.height,lineTop:0}}}class se{prepareMeasurements(){}separation(t,e){const n=e.theme.agentCap.cross;return{left:n.size/2,radius:0,right:n.size/2}}topShift(t,e){return e.theme.agentCap.cross.size/2}render(t,{x:e,options:n},s){const r=s.theme.agentCap.cross,i=r.size/2;return s.makeRegion().add(r.render({options:n,radius:i,x:e,y:t+i}),s.svg.box(ee,{height:2*i,width:2*i,x:e-i,y:t})),{height:2*i,lineBottom:i,lineTop:i}}}class re{prepareMeasurements({formattedLabel:t},e){const n=e.theme.agentCap.box;e.textSizer.expectMeasure(n.labelAttrs,t)}separation({formattedLabel:t},e){const n=e.theme.agentCap.box,s=e.textSizer.measure(n.labelAttrs,t).width+n.padding.left+n.padding.right;return{left:s/2,radius:s/2,right:s/2}}topShift(t,e){return e.theme.agentCap.bar.height/2}render(t,{x:e,formattedLabel:n,options:s},r){const i=r.theme.agentCap.box,a=r.theme.agentCap.bar,o=r.textSizer.measure(i.labelAttrs,n).width+i.padding.left+i.padding.right,{height:h}=a;return r.makeRegion().add(a.render({height:h,options:s,width:o,x:e-o/2,y:t}),r.svg.box(ee,{height:h,width:o,x:e-o/2,y:t})),{height:h,lineBottom:h,lineTop:0}}}class ie{prepareMeasurements(){}separation({currentRad:t}){return{left:t,radius:t,right:t}}topShift(t,e,n){const s=e.theme.agentCap.fade;return n?s.height:0}render(t,{x:e},n,s){const r=n.theme.agentCap.fade,i=r.height/(r.height+r.extend),a=n.addDef(s?"FadeIn":"FadeOut",()=>n.svg.linearGradient({x1:"0%",x2:"0%",y1:s?"100%":"0%",y2:s?"0%":"100%"},[{offset:"0%","stop-color":"#FFFFFF"},{offset:(100*i).toFixed(3)+"%","stop-color":"#000000"}]));return n.lineMaskLayer.add(n.svg.box({fill:"url(#"+a+")"},{height:r.height+r.extend,width:r.width,x:e-r.width/2,y:t-(s?r.extend:0)})),n.makeRegion().add(n.svg.box(ee,{height:r.height,width:r.width,x:e-r.width/2,y:t})),{height:r.height,lineBottom:0,lineTop:r.height}}}class ae{prepareMeasurements(){}separation({currentRad:t}){return{left:t,radius:t,right:t}}topShift(t,e){return e.theme.agentCap.none.height}render(t,{x:e},n){const s=n.theme.agentCap.none;return n.makeRegion().add(n.svg.box(ee,{height:s.height,width:10,x:e-5,y:t})),{height:s.height,lineBottom:0,lineTop:s.height}}}const oe={bar:new re,box:new ne,cross:new se,fade:new ie,none:new ae};class he extends $t{constructor(t){super(),this.begin=t}prepareMeasurements({mode:t,agentIDs:e},n){e.forEach(e=>{const s=n.agentInfos.get(e);oe[t].prepareMeasurements(s,n,this.begin)})}separationPre({mode:t,agentIDs:e},n){e.forEach(e=>{const s=n.agentInfos.get(e),r=oe[t].separation(s,n,this.begin);n.addSpacing(e,r),s.currentMaxRad=Math.max(s.currentMaxRad,r.radius)})}separation({agentIDs:t},s){this.begin?e(s.visibleAgentIDs,t):n(s.visibleAgentIDs,t)}renderPre({mode:t,agentIDs:e},n){let s=0;return e.forEach(e=>{const r=n.agentInfos.get(e),i=oe[t],a=i.topShift(r,n,this.begin);s=Math.max(s,a);const o=i.separation(r,n,this.begin).radius;r.currentMaxRad=Math.max(r.currentMaxRad,o)}),{agentIDs:e,topShift:s}}render({mode:t,agentIDs:e},n){let s=0;return e.forEach(e=>{const r=n.agentInfos.get(e),i=oe[t],a=i.topShift(r,n,this.begin),o=n.primaryY-a,h=i.render(o,r,n,this.begin);s=Math.max(s,o+h.height),this.begin?n.drawAgentLine(e,o+h.lineBottom):n.drawAgentLine(e,o+h.lineTop,!0)}),s+n.theme.actionMargin}renderHidden({agentIDs:t},e){t.forEach(t=>{e.drawAgentLine(t,e.topY,!this.begin)})}}V("agent begin",new he(!0)),V("agent end",new he(!1));class le extends $t{radius(t,e){return t?e.theme.agentLineHighlightRadius:0}separationPre({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);t.forEach(t=>{const e=n.agentInfos.get(t);e.currentRad=s,e.currentMaxRad=Math.max(e.currentMaxRad,s)})}renderPre({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);t.forEach(t=>{const e=n.agentInfos.get(t);e.currentMaxRad=Math.max(e.currentMaxRad,s)})}render({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);return t.forEach(t=>{n.drawAgentLine(t,n.primaryY),n.agentInfos.get(t).currentRad=s}),n.primaryY+n.theme.actionMargin}renderHidden(t,e){this.render(t,e)}}V("agent highlight",new le);const de={class:"outline",fill:"transparent"};class ge extends $t{prepareMeasurements({left:t,tag:e,label:n},s){const r=s.state.blocks.get(t),i=s.theme.getBlock(r.type).section;s.textSizer.expectMeasure(i.tag.labelAttrs,e),s.textSizer.expectMeasure(i.label.labelAttrs,n)}separation({left:t,right:e,tag:n,label:s},r){const i=r.state.blocks.get(t),a=r.theme.getBlock(i.type).section,o=r.textSizer.measure(a.tag.labelAttrs,n).width+a.tag.padding.left+a.tag.padding.right+r.textSizer.measure(a.label.labelAttrs,s).width+a.label.padding.left+a.label.padding.right;r.addSeparation(t,e,o)}renderPre({left:t,right:e}){return{agentIDs:[t,e]}}render({left:t,right:e,tag:n,label:s},r,i=!1){const a=r.state.blocks.get(t),o=r.theme.getBlock(a.type),h=r.agentInfos.get(t),l=r.agentInfos.get(e);let d=r.primaryY;i||(d+=o.section.padding.bottom);const g=r.makeRegion(),c=r.svg.boxedText({boxAttrs:o.section.tag.boxAttrs,boxRenderer:o.section.tag.boxRenderer,labelAttrs:o.section.tag.labelAttrs,padding:o.section.tag.padding},n,{x:h.x,y:d}),u=r.svg.boxedText({boxAttrs:{fill:"#000000"},labelAttrs:o.section.label.labelAttrs,padding:o.section.label.padding},s,{x:h.x+c.width,y:d}),p=Math.max(Math.max(c.height,u.height),o.section.label.minHeight);return a.hold.add(c.box),r.lineMaskLayer.add(u.box),g.add(r.svg.box(de,{height:p,width:l.x-h.x,x:h.x,y:d}),c.label,u.label),i?a.canHide&&g.addClass(a.hide?"collapsed":"expanded"):a.hold.add(o.sepRenderer({x1:h.x,x2:l.x,y1:d,y2:d})),d+p+o.section.padding.top}}class ce extends ge{makeState(t){t.blocks=new Map}resetState(t){t.blocks.clear()}storeBlockInfo(t,e){const{canHide:n}=t,s={canHide:n,hide:n&&e.renderer.isCollapsed(t.ln),hold:null,startY:null,type:t.blockType};return e.state.blocks.set(t.left,s),s}prepareMeasurements(t,e){this.storeBlockInfo(t,e),super.prepareMeasurements(t,e)}separationPre(t,e){this.storeBlockInfo(t,e),super.separationPre(t,e)}separation(t,n){e(n.visibleAgentIDs,[t.left,t.right]),super.separation(t,n)}renderPre(t,e){const n=this.storeBlockInfo(t,e),s=e.theme.getBlock(n.type);return{agentIDs:[t.left,t.right],topShift:s.margin.top}}render(t,e){const n=e.svg.el("g");e.blockLayer.add(n);const s=e.state.blocks.get(t.left);return s.hold=n,s.startY=e.primaryY,super.render(t,e,!0)}shouldHide({left:t},e){return{nest:e.state.blocks.get(t).hide?1:0,self:!1}}}class ue extends $t{separation({left:t,right:e},s){n(s.visibleAgentIDs,[t,e])}renderPre({left:t,right:e},n){const s=n.state.blocks.get(t);return{agentIDs:[t,e],topShift:n.theme.getBlock(s.type).section.padding.bottom}}render({left:t,right:e},n){const s=n.state.blocks.get(t),r=n.theme.getBlock(s.type),i=n.agentInfos.get(t),a=n.agentInfos.get(e);let o=r.boxRenderer;s.hide&&(o=r.collapsedBoxRenderer||o);let h=o({height:n.primaryY-s.startY,width:a.x-i.x,x:i.x,y:s.startY});return h.shape||(h={shape:h}),s.hold.add(h.shape),n.fillLayer.add(h.fill),n.lineMaskLayer.add(h.mask),n.primaryY+r.margin.bottom+n.theme.actionMargin}shouldHide({left:t},e){return{nest:e.state.blocks.get(t).hide?-1:0,self:!1}}}V("block begin",new ce),V("block split",new ge),V("block end",new ue);const pe={class:"outline",fill:"transparent"};class fe{constructor(t){this.propName=t}getConfig(t){return t.connect.arrow[this.propName]}short(t){const e=this.getConfig(t),n=e.attrs["stroke-linejoin"]||"miter",s=.5*e.attrs["stroke-width"],r=.5*t.agentLineAttrs[""]["stroke-width"];if("round"===n)return r+s;{const t=e.height/2,n=e.width;return r+s*Math.sqrt(n*n/(t*t)+1)}}render(t,e,n,s){const r=this.getConfig(e),i=this.short(e);t.add(r.render(r.attrs,{x:n.x+i*s.dx,y:n.y+i*s.dy,width:r.width,height:r.height,dir:s}))}width(t){return this.short(t)+this.getConfig(t).width}height(t){return this.getConfig(t).height}lineGap(t,e){const n=this.getConfig(t),s=this.short(t);if("none"===n.attrs.fill){const t=n.height/2,r=n.width;return(s+(s+e["stroke-width"]/2*(r/t)))/2}return s+n.width/2}}class me{getConfig(t){return t.connect.arrow.cross}render(t,e,n,s){const r=this.getConfig(e);t.add(r.render({x:n.x+r.short*s.dx,y:n.y+r.short*s.dy,radius:r.radius}))}width(t){const e=this.getConfig(t);return e.short+e.radius}height(t){return 2*this.getConfig(t).radius}lineGap(t){return this.getConfig(t).short}}const be=[{render:()=>null,width:()=>0,height:()=>0,lineGap:()=>0},new fe("single"),new fe("double"),new me];class ye extends $t{prepareMeasurements({agentIDs:t,label:e},n){const s=n.theme.connect,r=t[0]===t[1]?s.label.loopbackAttrs:s.label.attrs;n.textSizer.expectMeasure(r,e)}separationPre({agentIDs:t},e){const n=e.theme.connect.source.radius;t.forEach(t=>{const s=e.agentInfos.get(t);s.isVirtualSource&&(s.currentRad=n,s.currentMaxRad=Math.max(s.currentMaxRad,n))})}separation({label:t,agentIDs:n,options:s},r){const i=r.theme.connect,a=be[s.left],o=be[s.right],h=n[0]===n[1],l=h?i.label.loopbackAttrs:i.label.attrs;let d=r.textSizer.measure(l,t).width;d>0&&(d+=2*i.label.padding);const g=r.agentInfos.get(n[0]);if(h)r.addSpacing(n[0],{left:0,right:g.currentMaxRad+Math.max(d+a.width(r.theme),o.width(r.theme))+i.loopbackRadius});else{const t=r.agentInfos.get(n[1]);r.addSeparation(n[0],n[1],g.currentMaxRad+t.currentMaxRad+d+2*Math.max(a.width(r.theme),o.width(r.theme)))}e(r.momentaryAgentIDs,n)}renderRevArrowLine({x1:t,y1:e,x2:n,y2:s,xR:r},i,a,o){const h=a.theme.connect,l=h.line[i.line],d=be[i.left],g=be[i.right],c=d.lineGap(a.theme,l.attrs),u=g.lineGap(a.theme,l.attrs),p=l.renderRev(l.attrs,{x1:t+c,y1:e,x2:n+u,y2:s,xR:r,rad:h.loopbackRadius});o.add(p.shape),d.render(o,a.theme,{x:p.p1.x-c,y:p.p1.y},{dx:1,dy:0}),g.render(o,a.theme,{x:p.p2.x-u,y:p.p2.y},{dx:1,dy:0})}renderSelfConnect({label:t,agentIDs:e,options:n},s,r,i){const a=s.theme.connect,o=be[n.left],h=be[n.right],l=s.agentInfos.get(e[1]),d=t?s.textSizer.measureHeight(a.label.attrs,t)+a.label.margin.top+a.label.margin.bottom:0,g=r.x+r.currentMaxRad+o.width(s.theme)+(t?a.label.padding:0),c=s.svg.boxedText({padding:a.mask.padding,boxAttrs:{fill:"#000000"},labelAttrs:a.label.loopbackAttrs},t,{x:g-a.mask.padding.left,y:i-d+a.label.margin.top}),u=t?c.width+a.label.padding-a.mask.padding.left-a.mask.padding.right:0,p=Math.max(l.x+l.currentMaxRad+h.width(s.theme),g+u),f=Math.max(d,o.height(s.theme)/2),m=h.height(s.theme)/2;s.lineMaskLayer.add(c.box);const b=s.makeRegion().add(s.svg.box(pe,{x:r.x,y:i-f,width:p+a.loopbackRadius-r.x,height:f+s.primaryY-i+m}),c.label);return this.renderRevArrowLine({x1:r.x+r.currentMaxRad,y1:i,x2:l.x+l.currentMaxRad,y2:s.primaryY,xR:p},n,s,b),s.primaryY+Math.max(m,0)+s.theme.actionMargin}renderArrowLine({x1:t,y1:e,x2:n,y2:s},r,i,a){const o=i.theme.connect.line[r.line],h=be[r.left],l=be[r.right],d=Math.sqrt((n-t)*(n-t)+(s-e)*(s-e)),g=h.lineGap(i.theme,o.attrs),c=l.lineGap(i.theme,o.attrs),u=(n-t)/d,p=(s-e)/d,f=o.renderFlat(o.attrs,{x1:t+g*u,y1:e+g*p,x2:n-c*u,y2:s-c*p});a.add(f.shape);const m={x:f.p1.x-g*u,y:f.p1.y-g*p},b={x:f.p2.x+c*u,y:f.p2.y+c*p};return h.render(a,i.theme,m,{dx:u,dy:p}),l.render(a,i.theme,b,{dx:-u,dy:-p}),{p1:m,p2:b,lArrow:h,rArrow:l}}renderVirtualSources({from:t,to:e,rendered:n},s,r){const i=s.theme.connect.source;t.isVirtualSource&&r.add(i.render({x:n.p1.x-i.radius,y:n.p1.y,radius:i.radius})),e.isVirtualSource&&r.add(i.render({x:n.p2.x+i.radius,y:n.p2.y,radius:i.radius}))}renderSimpleLabel(t,{layer:e,x1:n,x2:s,y1:r,y2:i,height:a},o){const h=o.theme.connect,l=(n+s)/2,d=(r+i)/2;let g=e;const c={fill:"#000000"};if(r!==i){const t="rotate("+180*Math.atan((i-r)/(s-n))/Math.PI+" "+l+","+d+")";c.transform=t,g=o.svg.el("g").attr("transform",t),e.add(g)}const u=o.svg.boxedText({padding:h.mask.padding,boxAttrs:c,labelAttrs:h.label.attrs},t,{x:l,y:d+h.label.margin.top-a});o.lineMaskLayer.add(u.box),g.add(u.label)}renderSimpleConnect({label:t,agentIDs:e,options:n},s,r,i){const a=s.theme.connect,o=s.agentInfos.get(e[1]),h=r.x<o.x?1:-1,l=s.textSizer.measureHeight(a.label.attrs,t)+a.label.margin.top+a.label.margin.bottom,d=r.x+r.currentMaxRad*h,g=o.x-o.currentMaxRad*h,c=s.makeRegion(),u=this.renderArrowLine({x1:d,y1:i,x2:g,y2:s.primaryY},n,s,c),p=Math.max(u.lArrow.height(s.theme),u.rArrow.height(s.theme))/2,f=Math.max(l,p);return this.renderVirtualSources({from:r,to:o,rendered:u},s,c),c.add(s.svg.el("path").attrs(pe).attr("d","M"+d+","+(i-f)+"L"+g+","+(s.primaryY-f)+"L"+g+","+(s.primaryY+p)+"L"+d+","+(i+p)+"Z")),this.renderSimpleLabel(t,{layer:c,x1:d,y1:i,x2:g,y2:s.primaryY,height:l},s),s.primaryY+Math.max(p+s.theme.minActionMargin,s.theme.actionMargin)}renderPre({label:t,agentIDs:e,options:n},s){const r=s.theme.connect,i=be[n.left],a=be[n.right],o=s.textSizer.measureHeight(r.label.attrs,t)+r.label.margin.top+r.label.margin.bottom;let h=i.height(s.theme);return e[0]!==e[1]&&(h=Math.max(h,a.height(s.theme))),{agentIDs:e,topShift:Math.max(h/2,o)}}render(t,e,n=null,s=null){let r=s,i=n;return null===n&&(i=e.agentInfos.get(t.agentIDs[0]),r=e.primaryY),t.agentIDs[0]===t.agentIDs[1]?this.renderSelfConnect(t,e,i,r):this.renderSimpleConnect(t,e,i,r)}}class xe extends ye{makeState(t){t.delayedConnections=new Map}resetState(t){t.delayedConnections.clear()}separation(t,n){super.separation(t,n),e(n.momentaryAgentIDs,[t.agentIDs[0]])}renderPre(t,e){return Object.assign(super.renderPre(t,e),{agentIDs:[t.agentIDs[0]]})}render(t,e){return e.state.delayedConnections.set(t.tag,{stage:t,from:Object.assign({},e.agentInfos.get(t.agentIDs[0])),y:e.primaryY}),e.primaryY+e.theme.actionMargin}renderHidden(t,e){this.render(t,e)}}class ke extends ye{prepareMeasurements(){}separationPre(){}separation(){}renderPre({tag:t},e){const n=e.theme.connect,s=e.state.delayedConnections.get(t),r=s.stage,i=[r.agentIDs[1]];return r.agentIDs[0]===r.agentIDs[1]?{agentIDs:i,y:s.y+2*n.loopbackRadius}:Object.assign(super.renderPre(r,e),{agentIDs:i})}render({tag:t},e){const n=e.state.delayedConnections.get(t);return super.render(n.stage,e,n.from,n.y)}}V("connect",new ye),V("connect-delay-begin",new xe),V("connect-delay-end",new ke);const we={class:"outline",fill:"transparent"};class ve extends $t{prepareMeasurements({mode:t,formattedLabel:e},n){const s=n.theme.getDivider(t);n.textSizer.expectMeasure(s.labelAttrs,e)}separation({mode:t,formattedLabel:e},n){const s=n.theme.getDivider(t),r=n.textSizer.measure(s.labelAttrs,e).width+s.padding.left+s.padding.right;n.addSeparation("[","]",r),n.addSpacing("[",{left:s.extend,right:0}),n.addSpacing("]",{left:0,right:s.extend})}renderPre(){return{agentIDs:["[","]"]}}render({mode:t,height:e,formattedLabel:n},s){const r=s.theme.getDivider(t),i=s.agentInfos.get("["),a=s.agentInfos.get("]");let o=0,h=0;n&&(h=s.textSizer.measureHeight(r.labelAttrs,n));const l=Math.max(e,h)+r.margin;let d=null;if(n){const t=s.svg.boxedText({boxAttrs:{fill:"#000000"},labelAttrs:r.labelAttrs,padding:r.padding},n,{x:(i.x+a.x)/2,y:s.primaryY+(l-h)/2-r.padding.top});s.fullMaskLayer.add(t.box),d=t.label,o=t.width}const{shape:g,mask:c}=r.render({env:s,height:e,labelHeight:h,labelWidth:o,width:a.x-i.x+2*r.extend,x:i.x-r.extend,y:s.primaryY+(l-e)/2});return s.fullMaskLayer.add(c),s.makeRegion({unmasked:!0}).add(s.svg.box(we,{height:l,width:a.x-i.x+2*r.extend,x:i.x-r.extend,y:s.primaryY}),g,d),s.primaryY+l+s.theme.actionMargin}}V("divider",new ve);class Ae extends $t{makeState(t){t.marks=new Map}resetState(t){t.marks.clear()}render({name:t},{topY:e,state:n}){n.marks.set(t,e)}renderHidden(t,e){this.render(t,e)}}class Fe extends $t{renderPre({target:t},{state:e}){let n=0;return t&&e.marks&&(n=e.marks.get(t)||0),{asynchronousY:n}}}V("mark",new Ae),V("async",new Fe);const Me={class:"outline",fill:"transparent"};class Se extends $t{prepareMeasurements({mode:t,label:e},n){const s=n.theme.getNote(t);n.textSizer.expectMeasure(s.labelAttrs,e)}renderPre({agentIDs:t}){return{agentIDs:t}}renderNote({xMid:t=null,x0:e=null,x1:n=null,mode:s,label:r},i){const a=i.theme.getNote(s),o=i.topY+a.margin.top+a.padding.top,h=i.svg.formattedText(a.labelAttrs,r),l=i.textSizer.measure(h),d=l.width+a.padding.left+a.padding.right,g=a.padding.top+l.height+a.padding.bottom;switch(null===e&&null!==t&&(e=t-d/2),null===n&&null!==e?n=e+d:null===e&&(e=n-d),a.labelAttrs["text-anchor"]){case"middle":h.set({x:(e+a.padding.left+n-a.padding.right)/2,y:o});break;case"end":h.set({x:n-a.padding.right,y:o});break;default:h.set({x:e+a.padding.left,y:o})}return i.makeRegion().add(a.boxRenderer({height:g,width:n-e,x:e,y:i.topY+a.margin.top}),i.svg.box(Me,{height:g,width:n-e,x:e,y:i.topY+a.margin.top}),h),i.topY+a.margin.top+g+a.margin.bottom+i.theme.actionMargin}}class Re extends Se{separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),i=s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right,{left:a,right:o}=T(s.agentInfos,t),h=s.agentInfos.get(a),l=s.agentInfos.get(o);if(h===l)s.addSpacing(a,{left:i/2,right:i/2});else{const t=h.currentMaxRad+r.overlap.left,e=l.currentMaxRad+r.overlap.right;s.addSeparation(a,o,i-t-e),s.addSpacing(a,{left:t,right:0}),s.addSpacing(o,{left:0,right:e})}}render({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t),o=s.agentInfos.get(i),h=s.agentInfos.get(a);if(o===h){const t=o.x;return this.renderNote({label:n,mode:e,xMid:t},s)}return this.renderNote({label:n,mode:e,x0:o.x-o.currentMaxRad-r.overlap.left,x1:h.x+h.currentMaxRad+r.overlap.right},s)}}class Ce extends Se{constructor(t){super(),this.isRight=t}separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t),o=s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right+r.margin.left+r.margin.right;if(this.isRight){const t=s.agentInfos.get(a);s.addSpacing(a,{left:0,right:o+t.currentMaxRad})}else{const t=s.agentInfos.get(i);s.addSpacing(i,{left:o+t.currentMaxRad,right:0})}}render({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t);if(this.isRight){const t=s.agentInfos.get(a),i=t.x+t.currentMaxRad+r.margin.left;return this.renderNote({label:n,mode:e,x0:i},s)}{const t=s.agentInfos.get(i),a=t.x-t.currentMaxRad-r.margin.right;return this.renderNote({label:n,mode:e,x1:a},s)}}}class Ee extends Se{separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t),o=s.agentInfos.get(i),h=s.agentInfos.get(a);s.addSeparation(i,a,s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right+r.margin.left+r.margin.right+o.currentMaxRad+h.currentMaxRad)}render({agentIDs:t,mode:e,label:n},s){const{left:r,right:i}=T(s.agentInfos,t),a=s.agentInfos.get(r),o=s.agentInfos.get(i),h=(a.x+a.currentMaxRad+o.x-o.currentMaxRad)/2;return this.renderNote({label:n,mode:e,xMid:h},s)}}V("note over",new Re),V("note left",new Ce(!1)),V("note right",new Ce(!0)),V("note between",new Ee);class Ge extends $t{invokeChildren(t,e,n){return t.stages.map(t=>{return e.components.get(t.type)[n](t,e)})}prepareMeasurements(t,e){this.invokeChildren(t,e,"prepareMeasurements")}separationPre(t,e){this.invokeChildren(t,e,"separationPre")}separation(t,e){this.invokeChildren(t,e,"separation")}renderPre(t,e){return this.invokeChildren(t,e,"renderPre").map(t=>B(t)).reduce(j,{agentIDs:[],asynchronousY:null,topShift:0})}render(t,e){const n=e.makeRegion;let s=0;return t.stages.forEach(t=>{e.makeRegion=((e={})=>n(Object.assign({stageOverride:t},e)));const r=e.components.get(t.type).render(t,e)||0;s=Math.max(s,r)}),e.makeRegion=n,s}renderHidden(t,e){this.invokeChildren(t,e,"renderHidden")}shouldHide(t,e){return this.invokeChildren(t,e,"shouldHide").reduce((t,{self:e=!1,nest:n=0}={})=>({nest:t.nest+n,self:t.self||Boolean(e)}),{nest:0,self:!1})}}V("parallel",new Ge);class Ie{constructor(t){this.element=t}addBefore(t=null,e=null){if(null===t)return this;if(Array.isArray(t))for(const n of t)this.addBefore(n,e);else{const n=function(t,e){return"string"==typeof t?e.createTextNode(t):"number"==typeof t?e.createTextNode(t.toString(10)):"object"==typeof t&&t.element?t.element:t}(t,this.element.ownerDocument);this.element.insertBefore(n,q(e))}return this}add(...t){return this.addBefore(t,null)}del(t=null){return null!==t&&this.element.removeChild(q(t)),this}attr(t,e){return this.element.setAttribute(t,e),this}attrs(t){for(const e in t)Object.prototype.hasOwnProperty.call(t,e)&&this.element.setAttribute(e,t[e]);return this}styles(t){for(const e in t)Object.prototype.hasOwnProperty.call(t,e)&&(this.element.style[e]=t[e]);return this}setClass(t){return this.attr("class",t)}addClass(t){const e=this.element.getAttribute("class");if(!e)return this.setClass(t);const n=e.split(" ");return n.includes(t)?this:(n.push(t),this.attr("class",n.join(" ")))}delClass(t){const e=this.element.getAttribute("class");if(!e)return this;const n=e.split(" "),s=n.indexOf(t);return-1!==s&&(n.splice(s,1),this.attr("class",n.join(" "))),this}text(t){return this.element.textContent=t,this}on(t,e,n={}){if(Array.isArray(t))for(const s of t)this.on(s,e,n);else this.element.addEventListener(t,e,n);return this}off(t,e,n={}){if(Array.isArray(t))for(const s of t)this.off(s,e,n);else this.element.removeEventListener(t,e,n);return this}val(t){return this.element.value=t,this}select(t,e=null){return this.element.selectionStart=t,this.element.selectionEnd=null===e?t:e,this}focus(){return this.element.focus(),this}focussed(){return this.element===this.element.ownerDocument.activeElement}empty(){for(;this.element.childNodes.length>0;)this.element.removeChild(this.element.lastChild);return this}attach(t){return q(t).appendChild(this.element),this}detach(){return this.element.parentNode.removeChild(this.element),this}}class De{constructor(t){if(!t)throw new Error("Missing document!");this.document=t,this.wrap=this.wrap.bind(this),this.el=this.el.bind(this),this.txt=this.txt.bind(this)}wrap(t){return t.element?t:new Ie(t)}el(t,e=null){let n=null;return n=null===e?this.document.createElement(t):this.document.createElementNS(e,t),new Ie(n)}txt(t=""){return this.document.createTextNode(t)}}const Le=[];class Ne{constructor(t,e,n={}){this.container=t,this.svg=e,this.state={attrs:{},formatted:Le,x:0,y:0},this.lines=[],this.set(n)}_rebuildLines(t){if(t>this.lines.length)for(;this.lines.length<t;)this.lines.push({latest:"",node:this.svg.el("text").attr("x",this.state.x).attrs(this.state.attrs).attach(this.container)});else for(;this.lines.length>t;)this.lines.pop().node.detach()}_reset(){this._rebuildLines(0)}_renderText(){const{formatted:t}=this.state;if(t&&t.length){if(!Array.isArray(t))throw new Error("Invalid formatted text: "+t);this._rebuildLines(t.length),this.lines.forEach((e,n)=>{const s=JSON.stringify(t[n]);s!==e.latest&&(e.node.empty(),Y(this.svg,e.node,t[n]),e.latest=s)})}else this._reset()}_updateX(){this.lines.forEach(({node:t})=>{t.attr("x",this.state.x)})}_updateY(){const t=this.svg.textSizer;let e=this.state.y;for(let n=0;n<this.lines.length;++n){const s=[this.state.formatted[n]],r=t.baseline(this.state.attrs,s);this.lines[n].node.attr("y",e+r),e+=t.measureHeight(this.state.attrs,s)}}set(t){const e=Object.assign({},this.state);!function(t,e){for(const n in t)Object.prototype.hasOwnProperty.call(t,n)&&null!==e[n]&&void 0!==e[n]&&(t[n]=e[n])}(this.state,t),this.state.attrs!==e.attrs&&(this._reset(),e.formatted=Le);const n=this.lines.length;this.state.formatted!==e.formatted&&this._renderText(),this.state.x!==e.x&&this._updateX(),this.state.y===e.y&&this.lines.length===n||this._updateY()}}class ze{constructor(t){this.svg=t,this.testers=this.svg.el("g").attrs({display:xt?"block":"none",visibility:"hidden"}),this.container=t.body}baseline({attrs:t}){return Number(t["font-size"])}measureHeight({attrs:t,formatted:e}){const n=this.baseline({attrs:t,formatted:e})*(Number(t["line-height"])||1);return e.length*n}prepMeasurement(t,e){const n=this.svg.el("text").attrs(t).attach(this.testers);return Y(this.svg,n,e),n}prepComplete(){this.container.add(this.testers)}performMeasurement(t){return t.element.getComputedTextLength()}teardown(){this.container.del(this.testers.empty())}}class Oe{constructor(t=null,e=0){this.pattern=t,this.dw=t&&t.partWidth,this.points=[],this.phase=e,this.x=null,this.y=null,this.disconnect=0}_nextDelta(){return this.pattern.getDelta(this.phase++)}_link(){2===this.disconnect&&(this.points.push(this.x+" "+this.y),this.disconnect=0)}cap(){return this.disconnect>0&&(this.points.push(this.x+" "+this.y),this.disconnect=0),this}move(t,e){return this.cap(),this.x=t,this.y=e,this.disconnect=2,this}line(t,e,{patterned:n=!0}={}){if(this.pattern&&n){const n=Math.sqrt((t-this.x)*(t-this.x)+(e-this.y)*(e-this.y)),s=(t-this.x)/n,r=(e-this.y)/n,i=-r,a=s;for(let t=0;t+this.dw<=n;t+=this.dw){const e=this._nextDelta();this.points.push(this.x+t*s+e*i+" "+(this.y+t*r+e*a))}this.disconnect=1}else this._link(),this.disconnect=2;return this.x=t,this.y=e,this}arc(t,e,n){const s=Math.sqrt((t-this.x)*(t-this.x)+(e-this.y)*(e-this.y)),r=Math.atan2(this.x-t,e-this.y),i=t+Math.sin(r+n)*s,a=e-Math.cos(r+n)*s;if(this.pattern){const i=n<0?1:-1,a=this.dw/s;for(let o=r;o+a<=r+n;o+=a){const n=this._nextDelta()*i;this.points.push(t+Math.sin(o)*(s+n)+" "+(e-Math.cos(o)*(s+n)))}this.disconnect=1}else this.points.push(this.x+" "+this.y+"A"+s+" "+s+" 0 "+(Math.abs(n)>=Math.PI?"1 ":"0 ")+(n<0?"0 ":"1 ")+i+" "+a),this.disconnect=0;return this.x=i,this.y=a,this}asPath(){return this._link(),"M"+this.points.join("L")}}const Be="http://www.w3.org/2000/svg";class Ve{constructor(t){this.sizer=t,this.cache=new Map,this.active=null}_expectMeasure({attrs:t,formatted:e}){if(!e.length)return null;const n=JSON.stringify(t);let s=this.cache.get(n);return s||(s={attrs:t,lines:new Map},this.cache.set(n,s)),e.forEach(t=>{if(!t.length)return;const e=JSON.stringify(t);s.lines.has(e)||s.lines.set(e,{formatted:t,width:null})}),s}_measureLine(t,e){if(!e.length)return 0;const n=JSON.stringify(e),s=t.lines.get(n);return null===s.width&&(window.console.warn("Performing unexpected measurement",e),this.performMeasurements()),s.width}_measureWidth(t){if(!t.formatted.length)return 0;const e=this._expectMeasure(t);return t.formatted.map(t=>this._measureLine(e,t)).reduce((t,e)=>Math.max(t,e),0)}_getMeasurementOpts(t,e){const n={attrs:t,formatted:e};if(e||(t.textBlock?(n.attrs=t.textBlock.state.attrs,n.formatted=t.textBlock.state.formatted):t.state&&(n.attrs=t.state.attrs,n.formatted=t.state.formatted),n.formatted=n.formatted||[]),!Array.isArray(n.formatted))throw new Error("Invalid formatted text: "+n.formatted);return n}expectMeasure(t,e){const n=this._getMeasurementOpts(t,e);this._expectMeasure(n)}performMeasurementsPre(){this.active=[],this.cache.forEach(({attrs:t,lines:e})=>{e.forEach(e=>{null===e.width&&this.active.push({cacheLine:e,data:this.sizer.prepMeasurement(t,e.formatted)})})}),this.active.length&&this.sizer.prepComplete()}performMeasurementsAct(){this.active.forEach(({data:t,cacheLine:e})=>{e.width=this.sizer.performMeasurement(t)})}performMeasurementsPost(){this.active.length&&this.sizer.teardown(),this.active=null}performMeasurements(){try{this.performMeasurementsPre(),this.performMeasurementsAct()}finally{this.performMeasurementsPost()}}measure(t,e){const n=this._getMeasurementOpts(t,e);return{height:this.sizer.measureHeight(n),width:this._measureWidth(n)}}baseline(t,e){const n=this._getMeasurementOpts(t,e);return this.sizer.baseline(n)}measureHeight(t,e){const n=this._getMeasurementOpts(t,e);return this.sizer.measureHeight(n)}resetCache(){this.cache.clear()}}class He{constructor(t,e=null){this.dom=t,this.body=this.el("svg").attr("xmlns",Be).attr("version","1.1");const n=e||(t=>new ze(t));this.textSizer=new Ve(n(this)),this.txt=this.txt.bind(this),this.el=this.el.bind(this)}linearGradient(t,e){return this.el("linearGradient").attrs(t).add(e.map(t=>this.el("stop").attrs(t)))}patternedLine(t=null,e=0){return new Oe(t,e)}txt(t){return this.dom.txt(t)}el(t,e=Be){return this.dom.el(t,e)}box(t,{height:e,width:n,x:s,y:r}){return this.el("rect").attrs(t).attrs({height:e,width:n,x:s,y:r})}boxFactory(t){return this.box.bind(this,t)}line(t,{x1:e,x2:n,y1:s,y2:r}){return this.el("line").attrs(t).attrs({x1:e,x2:n,y1:s,y2:r})}lineFactory(t){return this.line.bind(this,t)}circle(t,{x:e,y:n,radius:s}){return this.el("circle").attrs({cx:e,cy:n,r:s}).attrs(t)}circleFactory(t){return this.circle.bind(this,t)}cross(t,{x:e,y:n,radius:s}){return this.el("path").attr("d","M"+(e-s)+" "+(n-s)+"l"+2*s+" "+2*s+"m0 "+2*-s+"l"+2*-s+" "+2*s).attrs(t)}crossFactory(t){return this.cross.bind(this,t)}note(t,e,{height:n,width:s,x:r,y:i}){const a=r,o=r+s,h=i,l=i+n;return this.el("g").add(this.el("polygon").attr("points",a+" "+h+" "+(o-7)+" "+h+" "+o+" "+(h+7)+" "+o+" "+l+" "+a+" "+l).attrs(t),this.el("polyline").attr("points",o-7+" "+h+" "+(o-7)+" "+(h+7)+" "+o+" "+(h+7)).attrs(e))}noteFactory(t,e){return this.note.bind(this,t,e)}formattedText(t={},e=[],{x:n,y:s}={}){const r=this.el("g"),i=new Ne(r,this,{attrs:t,formatted:e,x:n,y:s});return Object.assign(r,{set:t=>i.set(t),textBlock:i})}formattedTextFactory(t){return this.formattedText.bind(this,t)}boxedText({padding:t,labelAttrs:e,boxAttrs:n={},boxRenderer:s=null},r,{x:i,y:a}){if(!r||!r.length)return Object.assign(this.el("g"),{box:null,height:0,label:null,width:0});const{shift:o,anchorX:h}=function(t,e,n){let s=0,r=t;switch(e["text-anchor"]){case"middle":s=.5,r+=(n.left-n.right)/2;break;case"end":s=1,r-=n.right;break;default:s=0,r+=n.left}return{anchorX:r,shift:s}}(i,e,t),l=this.formattedText(e,r,{x:h,y:a+t.top}),d=this.textSizer.measure(l),g=d.width+t.left+t.right,c=d.height+t.top+t.bottom,u=(s||this.boxFactory(n))({height:c,width:g,x:h-d.width*o-t.left,y:a});return Object.assign(this.el("g").add(u,l),{box:u,height:c,label:l,width:g})}boxedTextFactory(t){return this.boxedText.bind(this,t)}}let Te=0;class Pe extends mt{constructor({themes:t=[],namespace:e=null,components:n=null,document:s,textSizerFactory:r=null}={}){super(),this._bindMethods(),this.state={},this.width=0,this.height=0,this.themes=function(t){if(0===t.length)throw new Error("Cannot render without a theme");const e=new Map;return t.forEach(t=>{e.set(t.name,t)}),e.set("",t[0]),e}(t),this.themeBuilder=null,this.theme=null,this.namespace=function(t){return null===t?"R"+Te++:t}(e),this.components=n||H(),this.svg=new He(new De(s),r),this.knownThemeDefs=new Set,this.knownDefs=new Set,this.highlights=new Map,this.collapsed=new Set,this.currentHighlight=-1,this.buildStaticElements(),this.components.forEach(t=>{t.makeState(this.state)})}_bindMethods(){this.separationStage=this.separationStage.bind(this),this.prepareMeasurementsStage=this.prepareMeasurementsStage.bind(this),this.renderStage=this.renderStage.bind(this),this.addThemeDef=this.addThemeDef.bind(this),this.addDef=this.addDef.bind(this)}addTheme(t){this.themes.set(t.name,t)}buildStaticElements(){const{el:t}=this.svg;this.metaCode=this.svg.txt(),this.themeDefs=t("defs"),this.defs=t("defs"),this.fullMask=t("mask").attrs({id:this.namespace+"FullMask",maskUnits:"userSpaceOnUse"}),this.lineMask=t("mask").attrs({id:this.namespace+"LineMask",maskUnits:"userSpaceOnUse"}),this.fullMaskReveal=t("rect").attr("fill","#FFFFFF"),this.lineMaskReveal=t("rect").attr("fill","#FFFFFF"),this.backgroundFills=t("g"),this.agentLines=t("g").attr("mask","url(#"+this.namespace+"LineMask)"),this.blocks=t("g"),this.shapes=t("g"),this.unmaskedShapes=t("g"),this.title=this.svg.formattedText(),this.svg.body.add(this.svg.el("metadata").add(this.metaCode),this.themeDefs,this.defs,this.backgroundFills,t("g").attr("mask","url(#"+this.namespace+"FullMask)").add(this.agentLines,this.blocks,this.shapes),this.unmaskedShapes,this.title)}addThemeDef(t,e){const n=this.namespace+t;return this.knownThemeDefs.has(t)||(this.knownThemeDefs.add(t),this.themeDefs.add(e().attr("id",n))),n}addDef(t,e){let n=t,s=e;"function"!=typeof e&&(n="P"+this.knownDefs.size,s=(()=>t));const r=this.namespace+n;return this.knownDefs.has(n)||(this.knownDefs.add(n),this.defs.add(s().attr("id",r))),r}addSeparation(t,e,n){const s=this.agentInfos.get(t),r=this.agentInfos.get(e),i=s.separations.get(e)||0;s.separations.set(e,Math.max(i,n));const a=r.separations.get(t)||0;r.separations.set(t,Math.max(a,n))}checkHidden(t){const e=this.components.get(t.type),n={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},s=e.shouldHide(t,n)||{},r=this.hideNest>0;this.hideNest+=s.nest||0;const i=this.hideNest>0;if(this.hideNest<0)throw new Error("Unexpected nesting in "+t.type);return r===i?i:Boolean(s.self)}separationStage(t){const n=new Map,s=this.visibleAgentIDs.slice(),r=[];this.agentInfos.forEach(t=>{const e=t.currentRad;t.currentMaxRad=e,n.set(t.id,{left:e,right:e})});const i={addSeparation:(t,e,n)=>{r.push({agentID1:t,agentID2:e,dist:n})},addSpacing:(t,{left:e,right:s})=>{const r=n.get(t);r.left=Math.max(r.left,e),r.right=Math.max(r.right,s)},agentInfos:this.agentInfos,components:this.components,momentaryAgentIDs:s,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme,visibleAgentIDs:this.visibleAgentIDs},a=this.components.get(t.type);if(!a)throw new Error("Unknown component: "+t.type);a.separationPre(t,i),a.separation(t,i),this.checkHidden(t)||(e(s,this.visibleAgentIDs),r.forEach(({agentID1:t,agentID2:e,dist:n})=>{this.addSeparation(t,e,n)}),s.forEach(t=>{const e=this.agentInfos.get(t),r=n.get(t);e.maxRPad=Math.max(e.maxRPad,r.right),e.maxLPad=Math.max(e.maxLPad,r.left),s.forEach(s=>{if(this.agentInfos.get(s).index>=e.index)return;const i=n.get(s);this.addSeparation(t,s,r.left+i.right+this.theme.agentMargin)})}))}prepareMeasurementsStage(t){const e={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},n=this.components.get(t.type);if(!n)throw new Error("Unknown component: "+t.type);n.prepareMeasurements(t,e)}checkAgentRange(t,e=0){if(0===t.length)return e;const{left:n,right:s}=W(this.agentInfos,t),r=this.agentInfos.get(n).x,i=this.agentInfos.get(s).x;let a=e;return this.agentInfos.forEach(t=>{t.x>=r&&t.x<=i&&(a=Math.max(a,t.latestY))}),a}markAgentRange(t,e){if(0===t.length)return;const{left:n,right:s}=W(this.agentInfos,t),r=this.agentInfos.get(n).x,i=this.agentInfos.get(s).x;this.agentInfos.forEach(t=>{t.x>=r&&t.x<=i&&(t.latestY=e)})}drawAgentLine(t,e){null!==t.latestYStart&&e>t.latestYStart&&this.agentLines.add(this.theme.renderAgentLine({className:"agent-"+t.index+"-line",options:t.options,width:2*t.currentRad,x:t.x,y0:t.latestYStart,y1:e}))}addHighlightObject(t,e){let n=this.highlights.get(t);n||(n=[],this.highlights.set(t,n)),n.push(e)}forwardEvent(t,e,n,s){t.on(e,this.trigger.bind(this,n,s))}renderStage(t){this.agentInfos.forEach(t=>{const e=t.currentRad;t.currentMaxRad=e});const e={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},n=this.components.get(t.type),s=n.renderPre(t,e),{agentIDs:r,topShift:i,asynchronousY:a}=B(s,this.currentY),o=this.checkAgentRange(r,a),h={addDef:this.addDef,agentInfos:this.agentInfos,blockLayer:this.blocks,components:this.components,drawAgentLine:(t,e,n=!1)=>{const s=this.agentInfos.get(t);this.drawAgentLine(s,e),s.latestYStart=n?null:e},fillLayer:this.backgroundFills,fullMaskLayer:this.fullMask,lineMaskLayer:this.lineMask,makeRegion:({stageOverride:e=null,unmasked:n=!1}={})=>{const s=this.svg.el("g").setClass("region"),r=e||t;return this.addHighlightObject(r.ln,s),this.forwardEvent(s,"mouseenter","mouseover",[r]),this.forwardEvent(s,"mouseleave","mouseout",[r]),this.forwardEvent(s,"click","click",[r]),this.forwardEvent(s,"dblclick","dblclick",[r]),s.attach(n?this.unmaskedShapes:this.shapes)},primaryY:o+i,renderer:this,state:this.state,svg:this.svg,textSizer:this.svg.textSizer,theme:this.theme,topY:o};let l=o;this.checkHidden(t)?(h.primaryY=o,n.renderHidden(t,h)):l=Math.max(l,n.render(t,h)||0),this.markAgentRange(r,l),this.currentY=l}positionAgents(){const t=[];this.agentInfos.forEach(e=>{let n=0;e.separations.forEach((t,s)=>{const r=this.agentInfos.get(s);r.index<e.index&&(n=Math.max(n,r.x+t))}),e.x=n,t.push(e)});let e={x:0};t.reverse().forEach(t=>{let n=e.x;e=t,t.anchorRight&&(t.separations.forEach((e,s)=>{const r=this.agentInfos.get(s);r.index>t.index&&(n=Math.min(n,r.x-e))}),t.x=n)}),this.agentInfos.forEach(({x:t,maxRPad:e,maxLPad:n})=>{this.minX=Math.min(this.minX,t-n),this.maxX=Math.max(this.maxX,t+e)})}buildAgentInfos(t){this.agentInfos=new Map,t.forEach((t,e)=>{this.agentInfos.set(t.id,{anchorRight:t.anchorRight,currentMaxRad:0,currentRad:0,formattedLabel:t.formattedLabel,id:t.id,index:e,isVirtualSource:t.isVirtualSource,latestY:0,latestYStart:null,maxLPad:0,maxRPad:0,options:t.options,separations:new Map,x:null})})}updateBounds(t){const e=(this.minX+this.maxX)/2,n=this.svg.textSizer.measure(this.title),s=n.height>0?-this.theme.titleMargin-n.height:0;this.title.set({x:e,y:s});const r=n.width/2,i=this.theme.outerMargin,a=Math.min(this.minX,e-r)-i,o=Math.max(this.maxX,e+r)+i,h=s-i,l=t+i;this.width=o-a,this.height=l-h;const d={height:this.height,width:this.width,x:a,y:h};this.fullMaskReveal.attrs(d),this.lineMaskReveal.attrs(d),this.svg.body.attr("viewBox",a+" "+h+" "+this.width+" "+this.height)}_resetState(){this.components.forEach(t=>{t.resetState(this.state)}),this.currentY=0,this.hideNest=0}_reset(t){t&&(this.knownThemeDefs.clear(),this.themeDefs.empty()),this.knownDefs.clear(),this.highlights.clear(),this.defs.empty(),this.fullMask.empty(),this.lineMask.empty(),this.backgroundFills.empty(),this.agentLines.empty(),this.blocks.empty(),this.shapes.empty(),this.unmaskedShapes.empty(),this.defs.add(this.fullMask.add(this.fullMaskReveal),this.lineMask.add(this.lineMaskReveal)),this._resetState()}setHighlight(t=null){const e=null===t?-1:t;this.currentHighlight!==e&&(this.highlights.has(this.currentHighlight)&&this.highlights.get(this.currentHighlight).forEach(t=>{t.delClass("focus")}),this.highlights.has(e)&&this.highlights.get(e).forEach(t=>{t.addClass("focus")}),this.currentHighlight=e)}isCollapsed(t){return this.collapsed.has(t)}setCollapseAll(t){if(t)throw new Error("Cannot collapse all");return 0!==this.collapsed.size&&(this.collapsed.clear(),!0)}_setCollapsed(t,e){return"number"==typeof t&&(e!==this.isCollapsed(t)&&(e?this.collapsed.add(t):this.collapsed.delete(t),!0))}setCollapsed(t,e=!0){return null===t?this.setCollapseAll(e):Array.isArray(t)?t.map(t=>this._setCollapsed(t,e)).some(t=>t):this._setCollapsed(t,e)}_switchTheme(t){const e=this.themeBuilder;return this.themeBuilder=this.getThemeNamed(t),this.themeBuilder!==e&&(this.theme=this.themeBuilder.build(this.svg)),this.theme.reset(),this.themeBuilder!==e}optimisedRenderPreReflow(t){const e=this._switchTheme(t.meta.theme);this._reset(e),this.metaCode.nodeValue=t.meta.code,this.theme.addDefs(this.addThemeDef),this.title.set({attrs:this.theme.titleAttrs,formatted:t.meta.title}),this.svg.textSizer.expectMeasure(this.title),this.minX=0,this.maxX=0,this.buildAgentInfos(t.agents),t.stages.forEach(this.prepareMeasurementsStage),this._resetState(),this.svg.textSizer.performMeasurementsPre()}optimisedRenderReflow(){this.svg.textSizer.performMeasurementsAct()}optimisedRenderPostReflow(t){this.visibleAgentIDs=["[","]"],t.stages.forEach(this.separationStage),this._resetState(),this.positionAgents(),t.stages.forEach(this.renderStage);const e=this.checkAgentRange(["[","]"],this.currentY),n=Math.max(e-this.theme.actionMargin,0);this.updateBounds(n);const s=this.currentHighlight;this.currentHighlight=-1,this.setHighlight(s),this.svg.textSizer.performMeasurementsPost(),this.svg.textSizer.resetCache()}render(t){this.optimisedRenderPreReflow(t),this.optimisedRenderReflow(),this.optimisedRenderPostReflow(t)}getThemeNames(){return Array.from(this.themes.keys()).filter(t=>""!==t)}getThemes(){return this.getThemeNames().map(t=>this.themes.get(t))}getThemeNamed(t){const e=this.themes.get(t);return e||this.themes.get("")}getAgentX(t){return this.agentInfos.get(t).x}dom(){return this.svg.body.element}}var je={name:"Handlee",woff2:"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"};class qe{constructor(){this.s=new Uint32Array(4)}reset(){this.s[0]=394173556,this.s[1]=2926575054,this.s[2]=1022685995,this.s[3]=1178902408}nextFloat(){let t=this.s[0],e=this.s[1];const n=this.s[2],s=this.s[3];return this.s[0]=n,this.s[1]=s,t^=t<<23|e>>>9,e^=e<<23,this.s[2]=t^n^t>>>17^n>>>26,this.s[3]=e^s^(t<<15|e>>>17)^(n<<6|s>>>26),(this.s[3]+s>>>0)%4294967296/4294967296}}const Ye=je.name,We="'"+Ye+"',cursive",Ue={normal:{stroke:"rgba(0,0,0,0.7)","stroke-width":.8,"stroke-linejoin":"round","stroke-linecap":"round"},thick:{stroke:"rgba(0,0,0,0.8)","stroke-width":1.2,"stroke-linejoin":"round","stroke-linecap":"round"}},Xe={"font-family":We,"font-size":8,"line-height":1.5},Qe={"font-family":We,"font-size":8,"line-height":1.5,"text-anchor":"middle"},Je={};class Ze{constructor(t,e){this.deltas=[0,-.3,-.6,-.75,-.45,0,.45,.75,.6,.3],e!==Je&&this.deltas.reverse(),this.partWidth=6/this.deltas.length}getDelta(t){return this.deltas[t%this.deltas.length]+.5*Math.sin(.03*t)}}class Ke extends st{constructor(t,e=Je){super(t),this.handedness=e===Je?1:-1,this.random=new qe,this.wave=new Ze(4,e);const n={padding:{top:3,bottom:2},tag:{padding:{top:2,left:3,right:5,bottom:0},boxRenderer:this.renderTag.bind(this),labelAttrs:{"font-family":We,"font-weight":"bold","font-size":9,"line-height":1.5,"text-anchor":"left"}},label:{minHeight:6,padding:{top:2,left:5,right:3,bottom:1},labelAttrs:{"font-family":We,"font-size":8,"line-height":1.5,"text-anchor":"left"}}};Object.assign(this,{titleMargin:10,outerMargin:5,agentMargin:10,actionMargin:10,minActionMargin:3,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:5,left:10,right:10,bottom:5},arrowBottom:12.8,labelAttrs:{"font-family":We,"font-size":12,"line-height":1.5,"text-anchor":"middle"},boxRenderer:this.renderBox.bind(this)},database:{padding:{top:12,left:10,right:10,bottom:2},arrowBottom:12.8,boxRenderer:this.renderDB.bind(this,Object.assign({fill:"#FFFFFF","db-z":5},Ue.normal)),labelAttrs:{"font-family":Ye,"font-size":12,"line-height":1.5,"text-anchor":"middle"}},cross:{size:15,render:this.renderCross.bind(this)},bar:{height:6,render:this.renderBar.bind(this)},fade:{width:Math.ceil(12),height:6,extend:Math.ceil(2.5)},none:{height:10}},connect:{loopbackRadius:6,line:{solid:{attrs:Object.assign({fill:"none"},Ue.normal),renderFlat:this.renderFlatConnect.bind(this),renderRev:this.renderRevConnect.bind(this)},dash:{attrs:Object.assign({fill:"none","stroke-dasharray":"4, 2"},Ue.normal),renderFlat:this.renderFlatConnect.bind(this),renderRev:this.renderRevConnect.bind(this)},wave:{attrs:Object.assign({fill:"none","stroke-linejoin":"round","stroke-linecap":"round"},Ue.normal),renderFlat:this.renderFlatConnectWave.bind(this),renderRev:this.renderRevConnectWave.bind(this)}},arrow:{single:{width:5,height:6,attrs:Object.assign({fill:"rgba(0,0,0,0.9)"},Ue.normal),render:this.renderArrowHead.bind(this)},double:{width:4,height:8,attrs:Object.assign({fill:"none"},Ue.normal),render:this.renderArrowHead.bind(this)},cross:{short:5,radius:3,render:this.renderCross.bind(this)}},label:{padding:6,margin:{top:2,bottom:1},attrs:{"font-family":We,"font-size":8,"line-height":1.5,"text-anchor":"middle"},loopbackAttrs:{"font-family":We,"font-size":8,"line-height":1.5}},source:{radius:1,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":We,"font-size":20,"line-height":1.5,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":Object.assign({fill:"none"},Ue.normal),red:{stroke:"rgba(200,40,0,0.8)"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRefBlock.bind(this),section:n},"":{margin:{top:0,bottom:0},boxRenderer:this.renderBlock.bind(this),collapsedBoxRenderer:this.renderMinBlock.bind(this),section:n,sepRenderer:this.renderSeparator.bind(this)}},notes:{text:{margin:{top:0,left:6,right:6,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:Xe},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:5,right:10,bottom:5},overlap:{left:10,right:10},boxRenderer:this.renderNote.bind(this),labelAttrs:Xe},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:7,left:7,right:7,bottom:7},overlap:{left:10,right:10},boxRenderer:this.renderState.bind(this),labelAttrs:Xe}},dividers:{"":{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this)},delay:{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:1,gapSize:2})},tear:{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,pattern:this.wave,lineAttrs:Ue.normal})}}})}reset(){this.random.reset()}addDefs(t){t("sketch_font",()=>{const t=this.svg.el("style",null);return t.text('@font-face{font-family:"'+je.name+'";src:url("data:font/woff2;base64,'+je.woff2+'");}'),t})}vary(t,e=0){if(!t)return e;const n=this.random.nextFloat();return e+2*Math.asin(2*n-1)*t/Math.PI}lineNodes(t,e,{var1:n=1,var2:s=1,varX:r=1,varY:i=1,move:a=!0}){const o=Math.sqrt((e.x-t.x)*(e.x-t.x)+(e.y-t.y)*(e.y-t.y)),h=Math.min(.2*Math.sqrt(o),5),l=this.vary(n*r*h,t.x),d=this.vary(n*i*h,t.y),g=this.vary(s*r*h,e.x),c=this.vary(s*i*h,e.y),u=function(t,e,n){return Math.max(e,Math.min(n,t))}((d-c)/(Math.abs(l-g)+.001),-1,1)/6+.5,p=this.vary(.5,.5)*h,f=this.vary(.5,.5)*h,m=l*(1-u)+g*u-p*this.handedness;return{nodes:(a?"M"+l+" "+d:"")+"C"+m+" "+(d*(1-u)+c*u-f)+","+g+" "+c+","+g+" "+c,p1:{x:l,y:d},p2:{x:g,y:c}}}renderLine(t,e,n){const s=this.lineNodes(t,e,n);return this.svg.el("path").attrs({d:s.nodes,fill:"none","stroke-dasharray":n.dash?"6, 5":"none"}).attrs(n.attrs||(n.thick?Ue.thick:Ue.normal))}boxNodes({x:t,y:e,width:n,height:s}){const r=this.lineNodes({x:t,y:e},{x:t+n,y:e},{}),i=this.lineNodes({x:t+n,y:e+s},{x:t,y:e+s},{move:!1}),a=this.lineNodes(r.p2,i.p1,{var1:0,var2:0,move:!1}),o=this.lineNodes(i.p2,r.p1,{var1:0,var2:.3,move:!1});return r.nodes+a.nodes+i.nodes+o.nodes}renderBox(t,{fill:e=null,thick:n=!1,attrs:s=null}={}){return this.svg.el("path").attrs({d:this.boxNodes(t),fill:e||"#FFFFFF"}).attrs(s||(n?Ue.thick:Ue.normal))}renderNote({x:t,y:e,width:n,height:s}){const r=this.lineNodes({x:t,y:e},{x:t+n-5,y:e},{}),i=this.lineNodes(r.p2,{x:t+n,y:e+5},{move:!1,var1:0}),a=this.lineNodes({x:t+n,y:e+s},{x:t,y:e+s},{move:!1}),o=this.lineNodes(i.p2,a.p1,{var1:0,var2:0,move:!1}),h=this.lineNodes(a.p2,r.p1,{var1:0,var2:.3,move:!1}),l=this.lineNodes(i.p1,{x:t+n-5,y:e+5},{var1:.3}),d=this.lineNodes(l.p2,i.p2,{var1:0,move:!1});return this.svg.el("g").add(this.svg.el("path").attrs({d:r.nodes+i.nodes+o.nodes+a.nodes+h.nodes,fill:"#FFFFFF"}).attrs(Ue.normal),this.svg.el("path").attrs({d:l.nodes+d.nodes,fill:"none"}).attrs(Ue.normal))}renderLineDivider({x:t,y:e,labelWidth:n,width:s,height:r}){let i=null;const a=e+r/2;return i=n>0?this.svg.el("g").add(this.renderLine({x:t,y:a},{x:t+(s-n)/2,y:a},{}),this.renderLine({x:t+(s+n)/2,y:a},{x:t+s,y:a},{})):this.renderLine({x:t,y:a},{x:t+s,y:a},{}),{shape:i}}renderFlatConnect(t,{x1:e,y1:n,x2:s,y2:r}){const i=this.lineNodes({x:e,y:n},{x:s,y:r},{varX:.3});return{shape:this.svg.el("path").attr("d",i.nodes).attrs(t),p1:i.p1,p2:i.p2}}renderRevConnect(t,{x1:e,y1:n,x2:s,y2:r,xR:i}){const a=Math.min(.06*(i-e),3),o=Math.min(.5*(i-e),6),h=e+this.vary(a,-1),l=n+this.vary(a,-1),d=i-o*this.vary(.2,1),g=n-this.vary(1,2),c=i,u=n+this.vary(1,1),p=i,f=r+this.vary(2),m=s+this.vary(a,-1),b=r+this.vary(a,-1);return{shape:this.svg.el("path").attr("d","M"+h+" "+l+"C"+h+" "+l+","+d+" "+g+","+c+" "+u+"S"+p+" "+f+","+m+" "+b).attrs(t),p1:{x:h,y:l},p2:{x:m,y:b}}}renderFlatConnectWave(t,{x1:e,y1:n,x2:s,y2:r}){const i=e+this.vary(.3),a=s+this.vary(.3),o=n+this.vary(1),h=r+this.vary(1);return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(this.wave).move(i,o).line(a,h).cap().asPath()).attrs(t),p1:{x:i,y:o},p2:{x:a,y:h}}}renderRevConnectWave(t,{x1:e,y1:n,x2:s,y2:r,xR:i}){const a=e+this.vary(.3),o=s+this.vary(.3),h=n+this.vary(1),l=r+this.vary(1);return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(this.wave).move(a,h).line(i,n).arc(i,(n+r)/2,Math.PI).line(o,l).cap().asPath()).attrs(t),p1:{x:a,y:h},p2:{x:o,y:l}}}renderArrowHead(t,{x:e,y:n,width:s,height:r,dir:i}){const a=s*this.vary(.2,1),o=r*this.vary(.3,1),h=a*i.dx,l=a*i.dy,d=.5*o*i.dx,g=.5*-o*i.dy,c=this.lineNodes({x:e+h-g,y:n+l-d},{x:e,y:n},{var1:2,var2:.2}),u=this.lineNodes(c.p2,{x:e+h+g,y:n+l+d},{var1:0,var2:2,move:!1}),p="none"===t.fill?{nodes:""}:this.lineNodes(u.p2,c.p1,{var1:0,var2:0,move:!1});return this.svg.el("path").attr("d",c.nodes+u.nodes+p.nodes).attrs(t)}renderState({x:t,y:e,width:n,height:s}){const r=Math.min(.06*n,3),i=Math.min(.06*s,3),a=t+r*this.vary(.6,1),o=e+i*this.vary(.6,1),h=t+n-r*this.vary(.6,1),l=e+i*this.vary(.6,1),d=t+r*this.vary(.6,1),g=e+s-i*this.vary(.6,1),c=t+n-r*this.vary(.6,1),u=e+s-i*this.vary(.6,1),p=t+n/2,f=e+s/2,m=r*this.vary(.2,1.2),b=i*this.vary(.2,1.2),y=e-Math.min(.005*n,1),x=e+s-Math.min(.01*n,2),k=t-Math.min(.01*s,2)*this.handedness,w=k+n;return this.svg.el("path").attr("d","M"+a+" "+o+"C"+(a+m)+" "+(o-b)+","+(p-n*this.vary(.03,.3))+" "+y+","+p+" "+y+"S"+(h-m)+" "+(l-b)+","+h+" "+l+"S"+w+" "+(f-s*this.vary(.03,.3))+","+w+" "+f+"S"+(c+m)+" "+(u-b)+","+c+" "+u+"S"+(p+n*this.vary(.03,.3))+" "+x+","+p+" "+x+"S"+(d+m)+" "+(g+b)+","+d+" "+g+"S"+k+" "+(f+s*this.vary(.03,.3))+","+k+" "+f+"S"+(a-m)+" "+(o+b)+","+a+" "+o+"Z").attr("fill","#FFFFFF").attrs(Ue.normal)}renderRefBlock(t){const e=this.boxNodes(t);return{shape:this.svg.el("path").attrs({d:e,fill:"none"}).attrs(Ue.thick),mask:this.svg.el("path").attrs({d:e,fill:"#000000"}),fill:this.svg.el("path").attrs({d:e,fill:"#FFFFFF"})}}renderBlock(t){return this.renderBox(t,{fill:"none",thick:!0})}renderMinBlock(t){return this.renderRefBlock(t)}renderTag({x:t,y:e,width:n,height:s}){const r=t+n,i=e+s,a=this.lineNodes({x:r+3,y:e},{x:r-2,y:i},{}),o=this.lineNodes(a.p2,{x:t,y:i+1},{var1:0,move:!1}),h=a.nodes+o.nodes;return this.svg.el("g").add(this.svg.el("path").attrs({d:h+"L"+t+" "+e,fill:"#FFFFFF"}),this.svg.el("path").attrs({d:h,fill:"#FFFFFF"}).attrs(Ue.normal))}renderSeparator({x1:t,y1:e,x2:n,y2:s}){return this.renderLine({x:t,y:e},{x:n,y:s},{thick:!0,dash:!0})}renderBar({x:t,y:e,width:n,height:s}){return this.renderBox({x:t,y:e,width:n,height:s},{fill:"#000000"})}renderCross({x:t,y:e,radius:n}){const s=this.vary(.2,1)*n,r=this.lineNodes({x:t-s,y:e-s},{x:t+s,y:e+s},{}),i=this.vary(.2,1)*n,a=this.lineNodes({x:t+i,y:e-i},{x:t-i,y:e+i},{});return this.svg.el("path").attrs({d:r.nodes+a.nodes,fill:"none"}).attrs(Ue.normal)}renderAgentLine({x:t,y0:e,y1:n,width:s,className:r,options:i}){const a=this.optionsAttributes(this.agentLineAttrs,i);return s>0?this.renderBox({x:t-s/2,y:e,width:s,height:n-e},{fill:"none",attrs:a}).setClass(r):this.renderLine({x:t,y:e},{x:t,y:n},{varY:.3,attrs:a}).setClass(r)}}class _e{constructor(t=Je){const e=t===Je;this.name=e?"sketch":"sketch left handed",this.handedness=t}build(t){return new Ke(t,this.handedness)}}Object.assign(_e,{RIGHT:Je,LEFT:{}});const $e=/^([ \t]*)(.*)$/,tn={after:".!+",end:/[ \t\r\n]$/,start:/^[ \t\r\n:,]/},en=/^"(\\.|[^"])*$/,nn=/[\r\n:,"<>\-~]/,sn=/["\\]/g,rn=[new lt,new Lt,new ft,new _e(_e.RIGHT),new _e(_e.LEFT)],an=new _t,on=new Rt,hn=an.getCodeMirrorMode();class ln extends mt{constructor(t=null,e={}){super();let n=null;t&&"object"==typeof t?(n=t,this.code=n.code):(n=e,this.code=t),Object.assign(this,{exporter:new kt,generator:on,isInteractive:!1,latestProcessed:null,parser:an,registerCodeMirrorMode:K,renderer:new Pe(Object.assign({document:function(t){return t?t.ownerDocument||null:"undefined"==typeof window?null:window.document}(n.container),themes:rn},n)),textSizerFactory:n.textSizerFactory||null}),this.renderer.addEventForwarding(this),n.container&&n.container.appendChild(this.dom()),n.interactive&&this.addInteractivity(),"string"==typeof this.code&&!1!==n.render&&this.render()}clone(t={}){const e=t.container||this.renderer.dom();return new ln(Object.assign({code:this.code,components:this.renderer.components,container:null,document:e.ownerDocument,interactive:this.isInteractive,namespace:null,textSizerFactory:this.textSizerFactory,themes:this.renderer.getThemes()},t))}set(t="",{render:e=!0}={}){this.code!==t&&(this.code=t,e&&this.render())}process(t){const e=this.parser.parse(t);return this.generator.generate(e)}addTheme(t){this.renderer.addTheme(t)}setHighlight(t){this.renderer.setHighlight(t)}isCollapsed(t){return this.renderer.isCollapsed(t)}setCollapsed(t,e=!0,{render:n=!0}={}){return!!this.renderer.setCollapsed(t,e)&&(n&&this.latestProcessed&&this.render(this.latestProcessed),!0)}collapse(t,e){return this.setCollapsed(t,!0,e)}expand(t,e){return this.setCollapsed(t,!1,e)}toggleCollapsed(t,e){return this.setCollapsed(t,!this.isCollapsed(t),e)}expandAll(t){return this.setCollapsed(null,!1,t)}getThemeNames(){return this.renderer.getThemeNames()}getThemes(){return this.renderer.getThemes()}getSVGSynchronous(){return this.exporter.getSVGURL(this.renderer)}getSVG(){return Promise.resolve({latest:!0,url:this.getSVGSynchronous()})}getCanvas({resolution:t=1,size:e=null}={}){return e&&(this.renderer.width=e.width,this.renderer.height=e.height),new Promise(e=>{this.exporter.getCanvas(this.renderer,t,e)})}getPNG({resolution:t=1,size:e=null}={}){return e&&(this.renderer.width=e.width,this.renderer.height=e.height),new Promise(e=>{this.exporter.getPNGURL(this.renderer,t,(t,n)=>{e({latest:n,url:t})})})}getSize(){return{height:this.renderer.height,width:this.renderer.width}}_revertParent(t){const e=this.renderer.dom();e.parentNode!==t.originalParent&&(e.parentNode.removeChild(e),t.originalParent&&t.originalParent.appendChild(e))}_sendRenderError(t){this._revertParent(this.renderState),this.renderState.error=!0,this.trigger("error",[this,t])}optimisedRenderPreReflow(t=null){const e=this.renderer.dom();this.renderState={error:!1,originalParent:e.parentNode,processed:t};const n=this.renderState;e.isConnected||(n.originalParent&&n.originalParent.removeChild(e),e.ownerDocument.body.appendChild(e));try{n.processed||(n.processed=this.process(this.code)),this.renderer.optimisedRenderPreReflow(n.processed)}catch(t){this._sendRenderError(t)}}optimisedRenderReflow(){try{this.renderState.error||this.renderer.optimisedRenderReflow()}catch(t){this._sendRenderError(t)}}optimisedRenderPostReflow(){const t=this.renderState;try{t.error||this.renderer.optimisedRenderPostReflow(t.processed)}catch(t){this._sendRenderError(t)}this.renderState=null,t.error||(this._revertParent(t),this.latestProcessed=t.processed,this.trigger("render",[this]))}render(t=null){function e(t,e){n=e}let n=null;if(this.addEventListener("error",e),this.optimisedRenderPreReflow(t),this.optimisedRenderReflow(),this.optimisedRenderPostReflow(),this.removeEventListener("error",e),n)throw n}setContainer(t=null){const e=this.dom();e.parentNode&&e.parentNode.removeChild(e),t&&t.appendChild(e)}addInteractivity(){this.isInteractive||(this.isInteractive=!0,this.addEventListener("click",t=>{this.toggleCollapsed(t.ln)}))}extractCodeFromSVG(t){return _(t)}renderAll(t){return $(t)}dom(){return this.renderer.dom()}}Object.assign(ln,{Exporter:kt,Generator:Rt,Parser:_t,Renderer:Pe,addTheme:function(t){rn.push(t)},convert:et,convertAll:function(t=null,e="sequence-diagram"){let n=null,s=null;"string"==typeof t?(n=null,s=t):(n=t,s=e);let r=null;r=n&&void 0!==n.length?n:(n||window.document).getElementsByClassName(s);const i=[];for(let t=0;t<r.length;++t)i.push(r[t]);et(i)},extractCodeFromSVG:_,getDefaultThemeNames:function(){return rn.map(t=>t.name)},registerCodeMirrorMode:K,renderAll:$,themes:rn}),"undefined"!=typeof exports?exports.SequenceDiagram=ln:window.define&&window.define.amd?window.define(()=>ln):(window.document.addEventListener("DOMContentLoaded",()=>{ln.convertAll()},{once:!0}),window.CodeMirror&&ln.registerCodeMirrorMode(window.CodeMirror),window.SequenceDiagram=ln)}();
\ No newline at end of file
diff --git a/lib/sequence-diagram.js b/lib/sequence-diagram.js
index 8cb854e..3573a27 100644
--- a/lib/sequence-diagram.js
+++ b/lib/sequence-diagram.js
@@ -9950,9 +9950,285 @@
 		themes,
 	});
 
-	const def = window.define;
-	if(def && def.amd) {
-		def(() => SequenceDiagram);
+	function encodeChar(c) {
+		return '&#' + c.charCodeAt(0).toString(10) + ';';
+	}
+
+	function escapeHTML(text) {
+		return text.replace(/[^\r\n\t -%'-;=?-~]/g, encodeChar);
+	}
+
+	function escapeQuoted(text) {
+		return text.replace(/[^\r\n\t !#$%(-;=?-~]/g, encodeChar);
+	}
+
+	class TextNode {
+		constructor(content) {
+			this.parentNode = null;
+			this.nodeValue = content;
+		}
+
+		contains() {
+			return false;
+		}
+
+		get textContent() {
+			return this.nodeValue;
+		}
+
+		set textContent(value) {
+			this.nodeValue = value;
+		}
+
+		get isConnected() {
+			if(this.parentNode !== null) {
+				return this.parentNode.isConnected;
+			}
+			return false;
+		}
+
+		get innerHTML() {
+			return escapeHTML(this.nodeValue);
+		}
+
+		get outerHTML() {
+			return this.innerHTML;
+		}
+	}
+
+	class ElementNode {
+		constructor(ownerDocument, tag, namespace) {
+			this.ownerDocument = ownerDocument;
+			this.tagName = tag;
+			this.namespaceURI = namespace;
+			this.parentNode = null;
+			this.childNodes = [];
+			this.attributes = new Map();
+			this.listeners = new Map();
+		}
+
+		setAttribute(key, value) {
+			let v = null;
+			if(typeof value === 'number') {
+				v = value.toString(10);
+			} else if(typeof value === 'string') {
+				v = value;
+			} else {
+				throw new Error('Bad value ' + value + ' for attribute ' + key);
+			}
+			this.attributes.set(key, v);
+		}
+
+		getAttribute(key) {
+			return this.attributes.get(key);
+		}
+
+		addEventListener(event, fn) {
+			let list = this.listeners.get(event);
+			if(!list) {
+				list = [];
+				this.listeners.set(event, list);
+			}
+			list.push(fn);
+		}
+
+		removeEventListener(event, fn) {
+			const list = this.listeners.get(event) || [];
+			const index = list.indexOf(fn);
+			if(index !== -1) {
+				list.splice(index, 1);
+			}
+		}
+
+		dispatchEvent(e) {
+			const list = this.listeners.get(e.type) || [];
+			list.forEach((fn) => fn(e));
+		}
+
+		contains(descendant) {
+			let check = descendant;
+			while(check) {
+				if(check === this) {
+					return true;
+				}
+				check = check.parentNode;
+			}
+			return false;
+		}
+
+		getElementsByTagName(tag) {
+			const result = [];
+			this.traverseDescendants((o) => {
+				if(o.tagName === tag) {
+					result.push(o);
+				}
+			});
+			return result;
+		}
+
+		getElementsByClassName(className) {
+			const result = [];
+			const check = ' ' + className + ' ';
+			this.traverseDescendants((o) => {
+				const cls = ' ' + (o.getAttribute('class') || '') + ' ';
+				if(cls.indexOf(check) !== -1) {
+					result.push(o);
+				}
+			});
+			return result;
+		}
+
+		traverseDescendants(fn) {
+			if(fn(this) === false) {
+				return;
+			}
+			for(const child of this.childNodes) {
+				if(child.traverseDescendants) {
+					child.traverseDescendants(fn);
+				}
+			}
+		}
+
+		get firstChild() {
+			return this.childNodes[0] || null;
+		}
+
+		get lastChild() {
+			return this.childNodes[this.childNodes.length - 1] || null;
+		}
+
+		indexOf(child) {
+			const index = this.childNodes.indexOf(child);
+			if(index === -1) {
+				throw new Error(child + ' is not a child of ' + this);
+			}
+			return index;
+		}
+
+		insertBefore(child, existingChild) {
+			if(child.contains(this)) {
+				throw new Error('Cyclic node structures are not permitted');
+			}
+			if(child.parentNode !== null) {
+				child.parentNode.removeChild(child);
+			}
+			if(existingChild === null) {
+				this.childNodes.push(child);
+			} else {
+				this.childNodes.splice(this.indexOf(existingChild), 0, child);
+			}
+			child.parentNode = this;
+			return child;
+		}
+
+		appendChild(child) {
+			return this.insertBefore(child, null);
+		}
+
+		removeChild(child) {
+			this.childNodes.splice(this.indexOf(child), 1);
+			child.parentNode = null;
+			return child;
+		}
+
+		replaceChild(newChild, oldChild) {
+			if(newChild === oldChild) {
+				return oldChild;
+			}
+			this.insertBefore(newChild, oldChild);
+			return this.removeChild(oldChild);
+		}
+
+		get isConnected() {
+			return true;
+		}
+
+		get textContent() {
+			let text = '';
+			for(const child of this.childNodes) {
+				text += child.textContent;
+			}
+			return text;
+		}
+
+		set textContent(value) {
+			for(const child of this.childNodes) {
+				child.parentNode = null;
+			}
+			this.childNodes.length = 0;
+			this.appendChild(new TextNode(value));
+		}
+
+		get innerHTML() {
+			let html = '';
+			for(const child of this.childNodes) {
+				html += child.outerHTML;
+			}
+			return html;
+		}
+
+		get outerHTML() {
+			let attrs = '';
+			for(const [key, value] of this.attributes) {
+				attrs += ' ' + key + '="' + escapeQuoted(value) + '"';
+			}
+			return (
+				'<' + this.tagName + attrs + '>' +
+				this.innerHTML +
+				'</' + this.tagName + '>'
+			);
+		}
+	}
+
+	class VirtualDocument {
+		createElement(tag) {
+			return new ElementNode(this, tag, '');
+		}
+
+		createElementNS(ns, tag) {
+			return new ElementNode(this, tag, ns || '');
+		}
+
+		createTextNode(content) {
+			return new TextNode(content);
+		}
+	}
+
+	class UnitaryTextSizer {
+		// Simplified text sizer, which assumes all characters render as
+		// 1x1 px squares for repeatable renders in all browsers
+
+		baseline() {
+			return 1;
+		}
+
+		measureHeight({formatted}) {
+			return formatted.length;
+		}
+
+		prepMeasurement(attrs, formatted) {
+			return formatted;
+		}
+
+		prepComplete() {
+			// No-op
+		}
+
+		performMeasurement(data) {
+			return data.reduce((total, part) => total + part.text.length, 0);
+		}
+
+		teardown() {
+			// No-op
+		}
+	}
+
+	if(typeof exports !== 'undefined') {
+		exports.SequenceDiagram = SequenceDiagram;
+		exports.VirtualDocument = VirtualDocument;
+		exports.headlessTextSizerFactory = () => new UnitaryTextSizer();
+	} else if(window.define && window.define.amd) {
+		window.define(() => SequenceDiagram);
 	} else {
 		window.document.addEventListener('DOMContentLoaded', () => {
 			SequenceDiagram.convertAll();
diff --git a/lib/sequence-diagram.min.js b/lib/sequence-diagram.min.js
index 8e10225..8538438 100644
--- a/lib/sequence-diagram.min.js
+++ b/lib/sequence-diagram.min.js
@@ -1 +1 @@
-!function(){"use strict";function t(t,e,n=null){if(null===n)return t.indexOf(e);for(let s=0;s<t.length;++s)if(n(t[s],e))return s;return-1}function e(e,n=null,s=null){if(n)for(let r=0;r<n.length;++r)-1===t(e,n[r],s)&&e.push(n[r])}function n(e,n=null,s=null){if(n)for(let r=0;r<n.length;++r){const i=t(e,n[r],s);-1!==i&&e.splice(i,1)}}function s(e,n,s=null){const r=t(e,n,s);-1!==r&&e.splice(r,1)}function r(t){return t[t.length-1]}function i(t,e,n,s){if(e>=t.length)return void s.push(n.slice());const r=t[e];if(!Array.isArray(r))return n.push(r),i(t,e+1,n,s),void n.pop();for(let a=0;a<r.length;++a)n.push(r[a]),i(t,e+1,n,s),n.pop()}function a(t,e){const n=[];return t.forEach(t=>{n.push(...e(t))}),n}function o(t,e){const n=St[t.type];return!(!n||t.type!==e.type)&&!n.check.some(n=>t[n]!==e[n])}function h(t,n){St[t.type].merge.forEach(s=>{e(t[s],n[s])})}function l(t,e){for(let n=0;n<t.length;){e(t[n],n)?t.splice(n,1):++n}}function d(t){l(t,(e,n)=>{for(let s=0;s<n;++s)if(o(t[s],e))return h(t[s],e),!0;return!1})}function g(t){const e=new Set,n=t.map(({type:t})=>t);return n.forEach(t=>{const s=St[t];s&&n.every(e=>t===e||s.siblings.has(e))&&e.add(t)}),e}function c(t,e,n,s){l(s,s=>{if(!t.has(s.type)||!e.has(s.type))return!1;for(let t=0;t<n.length;++t)if(o(n[t],s))return h(n[t],s),!0;return!1})}function u(t,e){if("agent begin"===t.type)return t.mode=e,!0;if("parallel"===t.type){let n=!1;return t.stages.forEach(t=>{"agent begin"===t.type&&(t.mode=e,n=!0)}),n}return!1}function p(t,e,n,r=null){s(t,e,At.equals),s(t,n,At.equals);let i=0,a=t.length;if(r){const e=r.map(e=>At.indexOf(t,e)).filter(t=>-1!==t);i=e.reduce((t,e)=>Math.min(t,e),t.length),a=e.reduce((t,e)=>Math.max(t,e),i)+1}return t.splice(i,0,e),t.splice(a+1,0,n),{indexL:i,indexR:a+1}}function f(t,e=!1){return{type:"string",suggest:e,then:Object.assign({"":0},t)}}function m(t,e){return t.v===e.v&&t.prefix===e.prefix&&t.suffix===e.suffix&&t.q===e.q}function b(t,e,n){let s=n.suggest;return Array.isArray(s)||(s=[s]),a(s,s=>!1===s?[]:"object"==typeof s?s.known?t["known"+s.known]||[]:[s]:"string"==typeof s&&s?[{v:s,q:""===e}]:[function(t,e){return Object.keys(e.then).length>0?{v:t,suffix:" ",q:!1}:{v:t,suffix:"\n",q:!1}}(e,n)])}function y(t,n){const s=[],i=r(n);return Object.keys(i.then).forEach(r=>{let a=i.then[r];"number"==typeof a&&(a=n[n.length-a-1]),e(s,b(t,r,a),m)}),s}function x(t,n,s,{suggest:r,override:i}){let a=null;"object"==typeof r&&r.known&&(a=r.known),n.type&&a!==n.type&&(i&&(n.type=i),e(t["known"+n.type],[{v:n.value,suffix:" ",q:!0}],m),n.type="",n.value=""),a&&(n.type=a,n.value&&(n.value+=s.s),n.value+=s.v)}function k(t,e,n){const s={type:"",value:""};let i=n;const a=[i];return t.line.forEach((e,n)=>{n===t.line.length-1&&(t.completions=y(t,a));const o=e.q?"":e.v;let h=i.then[o];void 0===h?(h=i.then[""],t.isVar=!0):t.isVar=e.q,"number"==typeof h?a.length-=h:a.push(h||Nt),i=r(a),x(t,s,e,i)}),e&&x(t,s,null,{}),t.nextCompletions=y(t,a),t.valid=Boolean(i.then["\n"])||0===Object.keys(i.then).length,i.type}function w(t){const e=t.baseToken||{};return{value:e.v||"",quoted:e.q||!1}}function v(t,e,n){return e.lastIndex=n,e.exec(t)}function A(t,e,n){return n?function(t,e,n){if(n.escape){const s=v(t,n.escape,e);if(s)return{appendSpace:"",appendValue:n.escapeWith(s),end:!1,newBlock:null,skip:s[0].length}}const s=v(t,n.end,e);return s?{appendSpace:"",appendValue:n.includeEnd?s[0]:"",end:!0,newBlock:null,skip:s[0].length}:{appendSpace:"",appendValue:t[e],end:!1,newBlock:null,skip:1}}(t,e,n):function(t,e){for(let n=0;n<Vt.length;++n){const s=Vt[n],r=v(t,s.start,e);if(r)return{appendSpace:"",appendValue:"",end:!s.end,newBlock:s,skip:r[0].length}}return{appendSpace:t[e],appendValue:"",end:!1,newBlock:null,skip:1}}(t,e)}function F(t){return{ch:t.ch,i:t.i,ln:t.ln}}function M(t){const e=jt.exec(t);return e&&e[1]?e[1].length:0}function S(t){if("label"===t)return{token:"label"};const e=t.indexOf(" ");let n=null,s=null;-1===e?(n=t,s=[]):(n=t.substr(0,e),s=t.substr(e+1).split(","));let r=null;return"inc"===n&&(r=function(t){let e=1,n=1,s=0;return t[0]&&(e=Number(t[0]),s=Math.max(s,M(t[0]))),t[1]&&(n=Number(t[1]),s=Math.max(s,M(t[1]))),Number.isNaN(e)||Number.isNaN(n)?null:{dp:s,inc:n,start:e}}(s)),r||"<"+t+">"}function R(t,e,n){const s=" "+t+" ";let r=-1,i=s.length,a=0;return qt.forEach(({begin:t,end:o},h)=>{const l=n[h]?o:t;l.lastIndex=e;const d=l.exec(s);d&&(d.index<i||d.index===i&&l.lastIndex>a)&&(r=h,i=d.index,a=l.lastIndex)}),{end:a-1,start:i,styleIndex:r}}function C(t,e){if(!t)return null;const n={};return e.forEach((t,e)=>{t&&Object.assign(n,qt[e].attrs)}),n}function E(t){if(!t)return[];const e=qt.map(()=>!1);let n=0,s=null;const r=[];return t.split("\n").forEach(t=>{const i=[];let a=0;for(;;){const{styleIndex:r,start:o,end:h}=R(t,a,e);if(-1===r)break;e[r]?(e[r]=!1,--n):(e[r]=!0,++n),o>a&&i.push({attrs:s,text:t.substring(a,o)}),s=C(n,e),a=h}a<t.length&&i.push({attrs:s,text:t.substr(a)}),r.push(i)}),r}function G(t,e=null){let n="";return e&&(n=" at line "+(e.b.ln+1)+", character "+e.b.ch),new Error(t+n)}function I(t,e=0,n=null){if(null===n&&(n=t.length),n<=e)return"";let s=t[e].v;for(let r=e+1;r<n;++r)s+=t[r].s+t[r].v;return s}function D(t){return!t||t.q?null:t.v}function L(t,e,n,s=null){for(let r=0;r<n.length;++r){const i=n[r],a=t[e+r];if(D(a)!==i){if(s)throw G(s+'; expected "'+i+'"',a);return e}}return e+n.length}function N(t,e,{start:n=0,limit:s=null,orEnd:r=!1}={}){null===s&&(s=t.length),Array.isArray(e)||(e=[e]);for(let r=n;r<=s-e.length;++r)if(L(t,r,e)!==r)return r;return r?s:-1}function z(t,e,n,{flagTypes:s={},aliases:i=!1}={}){const a=[],o=[];let h=e,l=!1;for(;h<n;++h){const e=t[h],n=D(e),r=s[n];if(!r)break;if(a.includes(r.flag))throw G("Duplicate agent flag: "+n,e);l=l||Boolean(r.allowBlankName),a.push(r.flag),o.push(r.blankNameFlag)}const{name:d,alias:g}=function(t,e,n,{enableAlias:s,allowBlankName:i}){let a=-1;if(s&&(a=N(t,"as",{start:e})),(-1===a||a>=n)&&(a=n),e>=a&&!i){let n=t[e];throw n||(n={b:r(t).e}),G("Missing agent name",n)}return{name:I(t,e,a),alias:I(t,a+1,n)}}(t,h,n,{enableAlias:i,allowBlankName:l});return{name:d,alias:g,flags:d?a:o}}function O(t,e,n,s){const r=[];let i=-1;for(let a=e;a<n;++a){","===D(t[a])?-1!==i&&(r.push(z(t,i,a,s)),i=-1):-1===i&&(i=a)}return-1!==i&&r.push(z(t,i,n,s)),r}function B({agentIDs:t=[],topShift:e=0,y:n=null,asynchronousY:s=null}={},r=null){let i=e;return null!==n&&null!==r&&(i=Math.max(i,n-r)),{agentIDs:t,asynchronousY:null===s?r:s,topShift:i,y:n}}function V(t,e){te.set(t,e)}function H(){return te}function T(t,e){let n=null,s=null;return e.forEach(e=>{const r=t.get(e);(null===n||r.index<n.index)&&(n=r),(null===s||r.index>s.index)&&(s=r)}),{left:n.id,right:s.id}}function P(t=null,e=null){return null===t?e:null===e?t:Math.max(t,e)}function j(t,n){return e(t.agentIDs,n.agentIDs),{agentIDs:t.agentIDs,asynchronousY:P(t.asynchronousY,n.asynchronousY),topShift:Math.max(t.topShift,n.topShift),y:P(t.y,n.y)}}function q(t){return null===t?null:t.element?t.element:t}function Y(t,e,n){if(!Array.isArray(n))throw new Error("Invalid formatted text line: "+n);n.forEach(({text:n,attrs:s})=>{s?e.add(t.el("tspan").attrs(s).add(n)):e.add(n)})}function W(t,e){let n=null,s=null;return e.forEach(e=>{const r=t.get(e);(null===n||r.index<n.index)&&(n=r),(null===s||r.index>s.index)&&(s=r)}),{left:n.id,right:s.id}}function U(t,e){return t.v===e.v&&t.prefix===e.prefix&&t.suffix===e.suffix&&t.q===e.q}function X(t,e,n){const s=t.getLine(e),r={squash:{ch:n,line:e},word:{ch:n,line:e}};return n>0&&" "===s[n-1]&&(tn.after.includes(s[n-2])&&r.word.ch--,r.squash.ch--),r}function Q(t,e,n){const s=function({v:t,q:e,prefix:n="",suffix:s=""},r){const i=r||!nn.test(t)?r:'"';return n+(i&&e?i+t.replace(sn,"\\$&")+i:t)+s}(t,n),r=t.q?e.fromVar:e.fromKey;return"\n"===s?{className:"pick-virtual",displayFrom:null,displayText:"<END>",from:r.squash,text:"\n",to:e.to.squash}:{className:null,displayFrom:r.word,displayText:s.trim(),from:tn.start.test(s)?r.squash:r.word,text:s,to:tn.end.test(s)?e.to.squash:e.to.word}}function J({global:t,prefix:e="",suffix:n=""},s){const r=s[t];return r?r.map(t=>({prefix:e,q:!0,suffix:n,v:t})):[]}function Z(t,n){const s=t.getCursor(),i=function(t,e){const n=t.getLineTokens(e.line);for(let t=0;t<n.length;++t)if(n[t].end>=e.ch){n.length=t+1;break}return n}(t,s),a=r(i)||t.getTokenAt(s),o=function(t,e){let n="",s=0,r=0;t.forEach(t=>{t.state.isVar?(n+=t.string,r=t.end):(n="",s=t.end)}),r>e.ch&&(n=n.substr(0,e.ch-s));const i=$e.exec(n);n=i[2];let a="";return en.test(n)&&(a=n.charAt(0),n=n.substr(1)),{from:s+i[1].length,partial:n,quote:a,valid:r>=s}}(i,s),h=function(t,e){let n=t.string;t.end>e.ch&&(n=n.substr(0,e.ch-t.start));const s=$e.exec(n);return{from:t.start+s[1].length,partial:s[2],valid:!0}}(a,s),l=s.ch>0&&a.state.line.length>0;let d=l?a.state.completions:a.state.beginCompletions;l||(d=d.concat(a.state.knownAgent)),function(t,n={}){for(let s=0;s<t.length;)t[s].global?(e(t,J(t[s],n),U),t.splice(s,1)):++s}(d,t.options.globals);const g={fromKey:X(t,s.line,h.from),fromVar:X(t,s.line,o.from),to:function(t,e,n){const s={squash:{ch:n,line:e},word:{ch:n,line:e}};return" "===t.getLine(e)[n]&&s.squash.ch++,s}(t,s.line,a.end)};let c=null;const u=d.filter(t=>(t.q||!o.quote)&&function(t,e){return e.valid&&t.startsWith(e.partial)}(t.v,t.q?o:h)).map(t=>n.completeSingle||t.v!==(t.q?o:h).partial?Q(t,g,o.quote):(c=t,null)).filter(t=>null!==t);return c&&u.length>0&&u.unshift(Q(c,g,o.quote)),{from:function(t,e){let n=null;return t.forEach(({displayFrom:t})=>{t&&(!n||t.line>n.line||t.line===n.line&&t.ch>n.ch)&&(n=t)}),n||e.word}(u,g.fromKey),list:u,to:g.to.word}}function K(t,e="sequence"){const n=t||window.CodeMirror;n.defineMode(e,()=>hn),n.registerHelper("hint",e,Z)}function _(t){const e=(new DOMParser).parseFromString(t,"image/svg+xml").querySelector("metadata");return e?e.textContent:""}function $(t){function e(t,e){n.push(e)}const n=[];if(t.forEach(t=>{t.addEventListener("error",e),t.optimisedRenderPreReflow()}),t.forEach(t=>{t.optimisedRenderReflow()}),t.forEach(t=>{t.optimisedRenderPostReflow(),t.removeEventListener("error",e)}),n.length>0)throw n}function tt(t,e=null,n={}){if("svg"===t.tagName)return null;const s=function(t){return{interactive:function(t){return void 0!==t&&"false"!==t}(t.dataset.sdInteractive),namespace:t.dataset.sdNamespace||null}}(t),r=new ln(null===e?t.textContent:e,Object.assign(s,n)),i=r.dom(),a=t.attributes;for(let t=0;t<a.length;++t)i.setAttribute(a[t].nodeName,a[t].nodeValue);return t.parentNode.replaceChild(i,t),r}function et(t,e=null,n={}){let s=null,r=null;if(e&&"object"==typeof e?s=(r=e).code:(r=n,s=e),Array.isArray(t)){const e=Object.assign({},r,{render:!1}),n=t.map(t=>tt(t,s,e));return!1!==r.render&&$(n),n}return tt(t,s,r)}class nt{constructor(t,e){Array.isArray(e)?this.deltas=e:this.deltas=[0,2*-e/3,-e,2*-e/3,0,2*e/3,e,2*e/3],this.partWidth=t/this.deltas.length}getDelta(t){return this.deltas[t%this.deltas.length]}}class st{constructor(t){this.svg=t}reset(){}addDefs(){}getBlock(t){return this.blocks[t]||this.blocks[""]}getNote(t){return this.notes[t]||this.notes[""]}getDivider(t){return this.dividers[t]||this.dividers[""]}optionsAttributes(t,e){return function(t,e){const n=Object.assign({},t[""]);return e.forEach(e=>{Object.assign(n,t[e]||{})}),n}(t,e)}renderAgentLine({x:t,y0:e,y1:n,width:s,className:r,options:i}){const a=this.optionsAttributes(this.agentLineAttrs,i);return s>0?this.svg.box(a,{x:t-s/2,y:e,width:s,height:n-e}).addClass(r):this.svg.line(a,{x1:t,x2:t,y1:e,y2:n}).addClass(r)}renderArrowHead(t,{x:e,y:n,width:s,height:r,dir:i}){const a=s*i.dx,o=s*i.dy,h=.5*r*i.dx,l=.5*-r*i.dy;return this.svg.el("none"===t.fill?"polyline":"polygon").attr("points",e+a-l+" "+(n+o-h)+" "+e+" "+n+" "+(e+a+l)+" "+(n+o+h)).attrs(t)}renderTag(t,{x:e,y:n,width:s,height:r}){const{rx:i,ry:a}=t,o=e+s,h=n+r,l="M"+o+" "+n+"L"+o+" "+(h-a)+"L"+(o-i)+" "+h+"L"+e+" "+h,d=this.svg.el("g");return"none"!==t.fill&&d.add(this.svg.el("path").attr("d",l+"L"+e+" "+n).attrs(t).attr("stroke","none")),"none"!==t.stroke&&d.add(this.svg.el("path").attr("d",l).attrs(t).attr("fill","none")),d}renderDB(t,e){const n=t["db-z"];return this.svg.el("g").add(this.svg.box({rx:e.width/2,ry:n},e).attrs(t),this.svg.el("path").attr("d","M"+e.x+" "+(e.y+n)+"a"+e.width/2+" "+n+" 0 0 0 "+e.width+" 0").attrs(t).attr("fill","none"))}renderRef(t,e){return{shape:this.svg.box(t,e).attrs({fill:"none"}),mask:this.svg.box(t,e).attrs({fill:"#000000",stroke:"none"}),fill:this.svg.box(t,e).attrs({stroke:"none"})}}renderFlatConnect(t,e,{x1:n,y1:s,x2:r,y2:i}){return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(t).move(n,s).line(r,i).cap().asPath()).attrs(e),p1:{x:n,y:s},p2:{x:r,y:i}}}renderRevConnect(t,e,{x1:n,y1:s,x2:r,y2:i,xR:a,rad:o}){const h=(i-s)/2,l=this.svg.patternedLine(t).move(n,s).line(a,s);return o<h?l.arc(a,s+o,Math.PI/2).line(a+o,i-o).arc(a,i-o,Math.PI/2):l.arc(a,(s+i)/2,Math.PI),{shape:this.svg.el("path").attr("d",l.line(r,i).cap().asPath()).attrs(e),p1:{x:n,y:s},p2:{x:r,y:i}}}renderLineDivider({lineAttrs:t},{x:e,y:n,labelWidth:s,width:r,height:i}){let a=null;const o=n+i/2;return a=s>0?this.svg.el("g").add(this.svg.line({fill:"none"},{x1:e,x2:e+(r-s)/2,y1:o,y2:o}).attrs(t),this.svg.line({fill:"none"},{x1:e+(r+s)/2,x2:e+r,y1:o,y2:o}).attrs(t)):this.svg.line({fill:"none"},{x1:e,x2:e+r,y1:o,y2:o}).attrs(t),{shape:a}}renderDelayDivider({dotSize:t,gapSize:e},{x:n,y:s,width:r,height:i}){const a=this.svg.el("g");for(let o=0;o+e<=i;o+=t+e)a.add(this.svg.box({fill:"#000000"},{x:n,y:s+o,width:r,height:e}));return{mask:a}}renderTearDivider({fadeBegin:t,fadeSize:e,pattern:n,zigWidth:s,zigHeight:r,lineAttrs:i},{x:a,y:o,labelWidth:h,labelHeight:l,width:d,height:g,env:c}){const u=c.addDef("tear-grad",()=>{const n=100/d;return this.svg.linearGradient({},[{offset:t*n+"%","stop-color":"#000000"},{offset:(t+e)*n+"%","stop-color":"#FFFFFF"},{offset:100-(t+e)*n+"%","stop-color":"#FFFFFF"},{offset:100-t*n+"%","stop-color":"#000000"}])}),p=this.svg.el("mask").attr("maskUnits","userSpaceOnUse").add(this.svg.box({fill:"url(#"+u+")"},{x:a,y:o-5,width:d,height:g+10})),f=c.addDef(p);h>0&&p.add(this.svg.box({rx:2,ry:2,fill:"#000000"},{x:a+(d-h)/2,y:o+(g-l)/2-1,width:h,height:l+2}));const m=n||new nt(s,[r,-r]);let b=null;const y=this.svg.patternedLine(m).move(a,o).line(a+d,o),x=this.svg.el("g").attr("mask","url(#"+f+")").add(this.svg.el("path").attrs({d:y.asPath(),fill:"none"}).attrs(i));if(g>0){const t=this.svg.patternedLine(m).move(a,o+g).line(a+d,o+g);x.add(this.svg.el("path").attrs({d:t.asPath(),fill:"none"}).attrs(i)),y.line(t.x,t.y,{patterned:!1}).cap(),y.points.push(...t.points.reverse()),b=this.svg.el("path").attrs({d:y.asPath(),fill:"#000000"})}return{shape:x,mask:b}}}const rt="sans-serif",it=new nt(6,.5),at={"font-family":rt,"font-size":8,"line-height":1.3},ot={"font-family":rt,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class ht extends st{constructor(t){super(t);const e={padding:{top:3,bottom:2},tag:{padding:{top:1,left:3,right:3,bottom:0},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:2,ry:2}),labelAttrs:{"font-family":rt,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:4,padding:{top:1,left:5,right:3,bottom:1},labelAttrs:{"font-family":rt,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:10,outerMargin:5,agentMargin:10,actionMargin:10,minActionMargin:3,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:5,left:10,right:10,bottom:5},arrowBottom:12.8,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":1},labelAttrs:{"font-family":rt,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:12,left:10,right:10,bottom:3},arrowBottom:12.8,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,"db-z":5}),labelAttrs:{"font-family":rt,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},cross:{size:20,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},fade:{width:5,height:6,extend:1},none:{height:10}},connect:{loopbackRadius:6,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-dasharray":"4, 2"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"round","stroke-linecap":"round"},renderFlat:this.renderFlatConnect.bind(this,it),renderRev:this.renderRevConnect.bind(this,it)}},arrow:{single:{width:5,height:10,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000","stroke-width":0,"stroke-linejoin":"miter"}},double:{width:4,height:6,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"miter"}},cross:{short:7,radius:3,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})}},label:{padding:6,margin:{top:2,bottom:1},attrs:{"font-family":rt,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":rt,"font-size":8,"line-height":1.3}},source:{radius:2,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":rt,"font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":1},red:{stroke:"#CC0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":1.5,"stroke-dasharray":"4, 2"})}},notes:{text:{margin:{top:0,left:2,right:2,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:at},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:5,right:10,bottom:5},overlap:{left:10,right:10},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:at},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:7,left:7,right:7,bottom:7},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:10,ry:10}),labelAttrs:at}},dividers:{"":{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000"}})},delay:{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:1,gapSize:2})},tear:{labelAttrs:ot,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,zigWidth:6,zigHeight:1,lineAttrs:{stroke:"#000000"}})}}})}}class lt{constructor(){this.name="basic"}build(t){return new ht(t)}}const dt="sans-serif",gt=new nt(10,1),ct={"font-family":dt,"font-size":8,"line-height":1.3},ut={"font-family":dt,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class pt extends st{constructor(t){super(t);const e={padding:{top:3,bottom:4},tag:{padding:{top:2,left:5,right:5,bottom:1},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2,rx:3,ry:3}),labelAttrs:{"font-family":dt,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:5,padding:{top:2,left:5,right:3,bottom:1},labelAttrs:{"font-family":dt,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:12,outerMargin:5,agentMargin:8,actionMargin:5,minActionMargin:5,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:1,left:3,right:3,bottom:1},arrowBottom:11.1,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":3,rx:4,ry:4},labelAttrs:{"font-family":dt,"font-weight":"bold","font-size":14,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:4,left:3,right:3,bottom:0},arrowBottom:11.1,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":3,"db-z":2}),labelAttrs:{"font-family":dt,"font-weight":"bold","font-size":14,"line-height":1.3,"text-anchor":"middle"}},cross:{size:20,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":3,"stroke-linecap":"round"})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":3,rx:2,ry:2})},fade:{width:5,height:10,extend:1},none:{height:10}},connect:{loopbackRadius:8,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":3},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-dasharray":"10, 4"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"},renderFlat:this.renderFlatConnect.bind(this,gt),renderRev:this.renderRevConnect.bind(this,gt)}},arrow:{single:{width:10,height:12,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round"}},double:{width:10,height:12,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"}},cross:{short:10,radius:5,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"})}},label:{padding:7,margin:{top:2,bottom:3},attrs:{"font-family":dt,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":dt,"font-size":8,"line-height":1.3}},source:{radius:5,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":3})},mask:{padding:{top:1,left:5,right:5,bottom:3}}},titleAttrs:{"font-family":dt,"font-weight":"bolder","font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":3},red:{stroke:"#DD0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":4,rx:5,ry:5}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":4,rx:5,ry:5}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":4,rx:5,ry:5}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":2,"stroke-dasharray":"5, 3"})}},notes:{text:{margin:{top:0,left:2,right:2,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:ct},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:3,left:3,right:10,bottom:3},overlap:{left:10,right:10},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":2,"stroke-linejoin":"round"},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:ct},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:7,right:7,bottom:5},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":3,rx:10,ry:10}),labelAttrs:ct}},dividers:{"":{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000","stroke-width":2,"stroke-linecap":"round"}})},delay:{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:3,gapSize:3})},tear:{labelAttrs:ut,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,zigWidth:6,zigHeight:1,lineAttrs:{stroke:"#000000","stroke-width":2,"stroke-linejoin":"round"}})}}})}}class ft{constructor(){this.name="chunky"}build(t){return new pt(t)}}class mt{constructor(){this.listeners=new Map,this.forwards=new Set}addEventListener(t,e){const n=this.listeners.get(t);n?n.push(e):this.listeners.set(t,[e])}removeEventListener(t,e){const n=this.listeners.get(t);if(!n)return;const s=n.indexOf(e);-1!==s&&n.splice(s,1)}on(t,e){return this.addEventListener(t,e),this}off(t,e){return this.removeEventListener(t,e),this}countEventListeners(t){return(this.listeners.get(t)||[]).length}removeAllEventListeners(t){t?this.listeners.delete(t):this.listeners.clear()}addEventForwarding(t){this.forwards.add(t)}removeEventForwarding(t){this.forwards.delete(t)}removeAllEventForwardings(){this.forwards.clear()}trigger(t,e=[]){(this.listeners.get(t)||[]).forEach(t=>t(...e)),this.forwards.forEach(n=>n.trigger(t,e))}}const bt="undefined"==typeof window,yt=!bt&&/^((?!chrome|android).)*safari/i.test(window.navigator.userAgent),xt=!bt&&void 0!==window.InstallTrigger;class kt{constructor(){this.latestSVG=null,this.latestInternalSVG=null,this.canvas=null,this.context=null,this.indexPNG=0,this.latestPNGIndex=0,this.latestPNG=null}getSVGContent(t){let e=t.dom().outerHTML;return e=e.replace(/^<svg/,'<svg width="'+(t.width||1)+'" height="'+(t.height||1)+'" ')}getSVGBlob(t){return new Blob([this.getSVGContent(t)],{type:"image/svg+xml"})}getSVGURL(t){const e=this.getSVGBlob(t);return this.latestSVG&&URL.revokeObjectURL(this.latestSVG),this.latestSVG=URL.createObjectURL(e),this.latestSVG}getCanvas(t,e,n){this.canvas||(window.devicePixelRatio=1,this.canvas=document.createElement("canvas"),this.context=this.canvas.getContext("2d"));const s=(t.width||1)*e,r=(t.height||1)*e,i=new Image(s,r);let a=null;yt&&((a=document.createElement("div")).style.position="absolute",a.style.visibility="hidden",a.appendChild(i),document.body.appendChild(a));const o=()=>{this.canvas.width=s,this.canvas.height=r,this.context.drawImage(i,0,0,s,r),a&&document.body.removeChild(a),n(this.canvas)};i.addEventListener("load",()=>{a?setTimeout(o,50):o()},{once:!0}),i.src=this.getSVGURL(t)}getPNGBlob(t,e,n){this.getCanvas(t,e,t=>{t.toBlob(n,"image/png")})}getPNGURL(t,e,n){++this.indexPNG;const s=this.indexPNG;this.getPNGBlob(t,e,t=>{const e=URL.createObjectURL(t);s>=this.latestPNGIndex?(this.latestPNG&&URL.revokeObjectURL(this.latestPNG),this.latestPNG=e,this.latestPNGIndex=s,n(e,!0)):(n(e,!1),URL.revokeObjectURL(e))})}}class wt{constructor({visible:t=!1,locked:e=!1,blocked:n=!1,highlighted:s=!1,group:r=null,covered:i=!1}={}){this.visible=t,this.locked=e,this.blocked=n,this.highlighted=s,this.group=r,this.covered=i}}wt.LOCKED=new wt({locked:!0}),wt.DEFAULT=new wt;const vt={equals:(t,e)=>t.name===e.name,hasFlag:(t,e=!0)=>n=>n.flags.includes(t)===e},At={equals:(t,e)=>t.id===e.id,make:(t,{anchorRight:e=!1,isVirtualSource:n=!1}={})=>({anchorRight:e,id:t,isVirtualSource:n,options:[]}),indexOf:(e,n)=>t(e,n,At.equals),hasIntersection:(e,n)=>(function(e,n,s=null){for(let r=0;r<n.length;++r)if(-1!==t(e,n[r],s))return!0;return!1})(e,n,At.equals),addNearby:(e,n,s,r)=>{const i=t(e,n,At.equals);-1===i?e.push(s):e.splice(i+r,0,s)}},Ft={"note over":[At.make("["),At.make("]")],"note left":[At.make("[")],"note right":[At.make("]")]},Mt=["[","]"],St={"agent begin":{check:["mode"],merge:["agentIDs"],siblings:new Set(["agent highlight"])},"agent end":{check:["mode"],merge:["agentIDs"],siblings:new Set(["agent highlight"])},"agent highlight":{check:["highlighted"],merge:["agentIDs"],siblings:new Set(["agent begin","agent end"])}};class Rt{constructor(){this.agentStates=new Map,this.agentAliases=new Map,this.activeGroups=new Map,this.gAgents=[],this.labelPattern=null,this.nextID=0,this.nesting=[],this.markers=new Set,this.currentSection=null,this.currentNest=null,this.stageHandlers={"block begin":this.handleBlockBegin.bind(this),"block split":this.handleBlockSplit.bind(this),"block end":this.handleBlockEnd.bind(this),"group begin":this.handleGroupBegin.bind(this),mark:this.handleMark.bind(this),async:this.handleAsync.bind(this),"agent define":this.handleAgentDefine.bind(this),"agent options":this.handleAgentOptions.bind(this),"agent begin":this.handleAgentBegin.bind(this),"agent end":this.handleAgentEnd.bind(this),divider:this.handleDivider.bind(this),"label pattern":this.handleLabelPattern.bind(this),connect:this.handleConnect.bind(this),"connect-delay-begin":this.handleConnectDelayBegin.bind(this),"connect-delay-end":this.handleConnectDelayEnd.bind(this),"note over":this.handleNote.bind(this),"note left":this.handleNote.bind(this),"note right":this.handleNote.bind(this),"note between":this.handleNote.bind(this)},this.expandGroupedGAgent=this.expandGroupedGAgent.bind(this),this.handleStage=this.handleStage.bind(this),this.toGAgent=this.toGAgent.bind(this),this.endGroup=this.endGroup.bind(this)}toGAgent({name:t,alias:e,flags:n}){if(e){if(this.agentAliases.has(t))throw new Error("Cannot alias "+t+"; it is already an alias");const n=this.agentAliases.get(e);if(n&&n!==e||this.gAgents.some(t=>t.id===e))throw new Error("Cannot use "+e+" as an alias; it is already in use");this.agentAliases.set(e,t)}return At.make(this.agentAliases.get(t)||t,{isVirtualSource:n.includes("source")})}addStage(t,e=!0){t&&(void 0===t.ln&&(t.ln=this.latestLine),this.currentSection.stages.push(t),e&&(this.currentNest.hasContent=!0))}addParallelStages(t){const e=t.filter(t=>Boolean(t));0!==e.length&&(1!==e.length?(e.forEach(t=>{void 0===t.ln&&(t.ln=this.latestLine)}),this.addStage({type:"parallel",stages:e})):this.addStage(e[0]))}defineGAgents(t){e(this.currentNest.gAgents,t.filter(t=>!Mt.includes(t.id)),At.equals),e(this.gAgents,t,At.equals)}getGAgentState(t){return this.agentStates.get(t.id)||wt.DEFAULT}updateGAgentState(t,e){const n=this.agentStates.get(t.id);n?Object.assign(n,e):this.agentStates.set(t.id,new wt(e))}replaceGAgentState(t,e){this.agentStates.set(t.id,e)}validateGAgents(t,{allowGrouped:e=!1,allowCovered:n=!1,allowVirtual:s=!1}={}){t.forEach(t=>{const r=this.getGAgentState(t);if(r.blocked&&null===r.group)throw new Error("Duplicate agent name: "+t.id);if(!n&&r.covered)throw new Error("Agent "+t.id+" is hidden behind group");if(!e&&null!==r.group)throw new Error("Agent "+t.id+" is in a group");if(!s&&t.isVirtualSource)throw new Error("cannot use message source here");if(t.id.startsWith("__"))throw new Error(t.id+" is a reserved name")})}setGAgentVis(t,e,n,s=!1){const r=new Set,i=t.filter(t=>{if(r.has(t.id))return!1;r.add(t.id);const n=this.getGAgentState(t);if(n.locked||n.blocked){if(s)throw new Error("Cannot begin/end agent: "+t.id);return!1}return n.visible!==e});return 0===i.length?null:(i.forEach(t=>{this.updateGAgentState(t,{visible:e})}),this.defineGAgents(i),{type:e?"agent begin":"agent end",agentIDs:i.map(t=>t.id),mode:n})}setGAgentHighlight(t,e,n=!1){const s=t.filter(t=>{const s=this.getGAgentState(t);if(s.locked||s.blocked){if(n)throw new Error("Cannot highlight agent: "+t.id);return!1}return s.visible&&s.highlighted!==e});return 0===s.length?null:(s.forEach(t=>{this.updateGAgentState(t,{highlighted:e})}),{type:"agent highlight",agentIDs:s.map(t=>t.id),highlighted:e})}_makeSection(t,e){return{header:t,delayedConnections:new Map,stages:e}}_checkSectionEnd(){const t=this.currentSection.delayedConnections;if(t.size>0){const e=t.values().next().value;throw new Error('Unused delayed connection "'+e.tag+'" at line '+(e.ln+1))}}beginNested(t,{tag:e,label:n,name:s,ln:r}){const i=At.make(s+"[",{anchorRight:!0}),a=At.make(s+"]"),o=[i,a],h=[];return this.currentSection=this._makeSection({type:"block begin",blockType:t,tag:this.textFormatter(e),label:this.textFormatter(n),canHide:!0,left:i.id,right:a.id,ln:r},h),this.currentNest={blockType:t,gAgents:o,leftGAgent:i,rightGAgent:a,hasContent:!1,sections:[this.currentSection]},this.replaceGAgentState(i,wt.LOCKED),this.replaceGAgentState(a,wt.LOCKED),this.nesting.push(this.currentNest),{stages:h}}nextBlockName(){const t="__BLOCK"+this.nextID;return++this.nextID,t}nextVirtualAgentName(){const t="__"+this.nextID;return++this.nextID,t}handleBlockBegin({ln:t,blockType:e,tag:n,label:s}){this.beginNested(e,{tag:n,label:s,name:this.nextBlockName(),ln:t})}handleBlockSplit({ln:t,blockType:e,tag:n,label:s}){if("if"!==this.currentNest.blockType)throw new Error('Invalid block nesting ("else" inside '+this.currentNest.blockType+")");this._checkSectionEnd(),this.currentSection=this._makeSection({type:"block split",blockType:e,tag:this.textFormatter(n),label:this.textFormatter(s),left:this.currentNest.leftGAgent.id,right:this.currentNest.rightGAgent.id,ln:t},[]),this.currentNest.sections.push(this.currentSection)}handleBlockEnd(){if(this.nesting.length<=1)throw new Error('Invalid block nesting (too many "end"s)');this._checkSectionEnd();const t=this.nesting.pop();if(this.currentNest=r(this.nesting),this.currentSection=r(this.currentNest.sections),!t.hasContent)throw new Error("Empty block");this.defineGAgents(t.gAgents),p(this.gAgents,t.leftGAgent,t.rightGAgent,t.gAgents),t.sections.forEach(t=>{this.currentSection.stages.push(t.header),this.currentSection.stages.push(...t.stages)}),this.addStage({type:"block end",left:t.leftGAgent.id,right:t.rightGAgent.id})}makeGroupDetails(t,e){const s=t.map(this.toGAgent);if(this.validateGAgents(s),this.agentStates.has(e))throw new Error("Duplicate agent name: "+e);const r=this.nextBlockName(),i=At.make(r+"[",{anchorRight:!0}),a=At.make(r+"]");this.replaceGAgentState(i,wt.LOCKED),this.replaceGAgentState(a,wt.LOCKED),this.updateGAgentState(At.make(e),{blocked:!0,group:e}),this.defineGAgents([...s,i,a]);const{indexL:o,indexR:h}=p(this.gAgents,i,a,s),l=[],d=s.slice();for(let t=o+1;t<h;++t)l.push(this.gAgents[t]);return n(l,d,At.equals),{gAgents:s,leftGAgent:i,rightGAgent:a,gAgentsContained:d,gAgentsCovered:l}}handleGroupBegin({agents:t,blockType:e,tag:n,label:s,alias:r}){const i=this.makeGroupDetails(t,r);i.gAgentsContained.forEach(t=>{this.updateGAgentState(t,{group:r})}),i.gAgentsCovered.forEach(t=>{this.updateGAgentState(t,{covered:!0})}),this.activeGroups.set(r,i),this.addStage(this.setGAgentVis(i.gAgents,!0,"box")),this.addStage({type:"block begin",blockType:e,tag:this.textFormatter(n),canHide:!1,label:this.textFormatter(s),left:i.leftGAgent.id,right:i.rightGAgent.id})}endGroup({name:t}){const e=this.activeGroups.get(t);return e?(this.activeGroups.delete(t),e.gAgentsContained.forEach(t=>{this.updateGAgentState(t,{group:null})}),e.gAgentsCovered.forEach(t=>{this.updateGAgentState(t,{covered:!1})}),this.updateGAgentState(At.make(t),{group:null}),{type:"block end",left:e.leftGAgent.id,right:e.rightGAgent.id}):null}handleMark({name:t}){this.markers.add(t),this.addStage({type:"mark",name:t},!1)}handleDivider({mode:t,height:e,label:n}){this.addStage({type:"divider",mode:t,height:e,formattedLabel:this.textFormatter(n)},!1)}handleAsync({target:t}){if(""!==t&&!this.markers.has(t))throw new Error("Unknown marker: "+t);this.addStage({type:"async",target:t},!1)}handleLabelPattern({pattern:t}){this.labelPattern=t.slice();for(let t=0;t<this.labelPattern.length;++t){const e=this.labelPattern[t];"object"==typeof e&&void 0!==e.start&&(this.labelPattern[t]=Object.assign({current:e.start},e))}}applyLabelPattern(t){let e="";const n={label:t};return this.labelPattern.forEach(t=>{"string"==typeof t?e+=t:void 0!==t.token?e+=n[t.token]:void 0!==t.current&&(e+=t.current.toFixed(t.dp),t.current+=t.inc)}),e}expandGroupedGAgent(t){const{group:e}=this.getGAgentState(t);if(!e)return[t];const n=this.activeGroups.get(e);return[n.leftGAgent,n.rightGAgent]}expandGroupedGAgentConnection(t){const e=this.expandGroupedGAgent(t[0]),n=this.expandGroupedGAgent(t[1]);let s=At.indexOf(this.gAgents,e[0]),i=At.indexOf(this.gAgents,n[0]);return-1===s&&(s=e[0].isVirtualSource?-1:this.gAgents.length),-1===i&&(i=this.gAgents.length),s===i?[r(e),r(n)]:s<i?[r(e),n[0]]:[e[0],r(n)]}filterConnectFlags(t){const n=t.filter(vt.hasFlag("begin")).map(this.toGAgent),s=t.filter(vt.hasFlag("end")).map(this.toGAgent);if(At.hasIntersection(n,s))throw new Error("Cannot set agent visibility multiple times");const r=t.filter(vt.hasFlag("start")).map(this.toGAgent),i=t.filter(vt.hasFlag("stop")).map(this.toGAgent);if(e(i,s),At.hasIntersection(r,i))throw new Error("Cannot set agent highlighting multiple times");return this.validateGAgents(n),this.validateGAgents(s),this.validateGAgents(r),this.validateGAgents(i),{beginGAgents:n,endGAgents:s,startGAgents:r,stopGAgents:i}}makeVirtualAgent(t){const e=At.make(this.nextVirtualAgentName(),{anchorRight:t,isVirtualSource:!0});return this.replaceGAgentState(e,wt.LOCKED),e}addNearbyAgent(t,e,n){At.addNearby(this.currentNest.gAgents,t,e,n),At.addNearby(this.gAgents,t,e,n)}expandVirtualSourceAgents(t){if(t[0].isVirtualSource){if(t[1].isVirtualSource)throw new Error("Cannot connect found messages");if(Mt.includes(t[1].id))throw new Error("Cannot connect found messages to special agents");const e=this.makeVirtualAgent(!0);return this.addNearbyAgent(t[1],e,0),[e,t[1]]}if(t[1].isVirtualSource){if(Mt.includes(t[0].id))throw new Error("Cannot connect found messages to special agents");const e=this.makeVirtualAgent(!1);return this.addNearbyAgent(t[0],e,1),[t[0],e]}return t}_handlePartialConnect(t){const e=this.filterConnectFlags(t),n=t.map(this.toGAgent);this.validateGAgents(n,{allowGrouped:!0,allowVirtual:!0}),this.defineGAgents(a(n,this.expandGroupedGAgent).filter(t=>!t.isVirtualSource));const s=t.filter(vt.hasFlag("begin",!1)).map(this.toGAgent).filter(t=>!t.isVirtualSource);return this.addStage(this.setGAgentVis(s,!0,"box")),{flags:e,gAgents:n}}_makeConnectParallelStages(t,e){return[this.setGAgentVis(t.beginGAgents,!0,"box",!0),this.setGAgentHighlight(t.startGAgents,!0,!0),e,this.setGAgentHighlight(t.stopGAgents,!1,!0),this.setGAgentVis(t.endGAgents,!1,"cross",!0)]}_isSelfConnect(t){const e=t.map(this.toGAgent),n=this.expandGroupedGAgentConnection(e);return n[0].id===n[1].id&&!n.some(t=>t.isVirtualSource)}handleConnect({agents:t,label:e,options:n}){if(this._isSelfConnect(t)){const s={};return this.handleConnectDelayBegin({agent:t[0],tag:s,options:n,ln:0}),void this.handleConnectDelayEnd({agent:t[1],tag:s,label:e,options:n})}let{flags:s,gAgents:r}=this._handlePartialConnect(t);r=this.expandGroupedGAgentConnection(r);const i={type:"connect",agentIDs:(r=this.expandVirtualSourceAgents(r)).map(t=>t.id),label:this.textFormatter(this.applyLabelPattern(e)),options:n};this.addParallelStages(this._makeConnectParallelStages(s,i))}handleConnectDelayBegin({agent:t,tag:e,options:n,ln:s}){const r=this.currentSection.delayedConnections;if(r.has(e))throw new Error('Duplicate delayed connection "'+e+'"');const{flags:i,gAgents:a}=this._handlePartialConnect([t]),o=this.nextVirtualAgentName(),h={type:"connect-delay-begin",tag:o,agentIDs:null,label:null,options:n};r.set(e,{tag:e,uniqueTag:o,ln:s,gAgents:a,connectStage:h}),this.addParallelStages(this._makeConnectParallelStages(i,h))}handleConnectDelayEnd({agent:t,tag:e,label:n,options:s}){const r=this.currentSection.delayedConnections,i=r.get(e);if(!i)throw new Error('Unknown delayed connection "'+e+'"');let{flags:a,gAgents:o}=this._handlePartialConnect([t]);o=this.expandGroupedGAgentConnection([...i.gAgents,...o]),o=this.expandVirtualSourceAgents(o);let h=i.connectStage.options;if(h.line!==s.line)throw new Error("Mismatched delayed connection arrows");s.right&&(h=Object.assign({},h,{right:s.right})),Object.assign(i.connectStage,{agentIDs:o.map(t=>t.id),label:this.textFormatter(this.applyLabelPattern(n)),options:h});const l={type:"connect-delay-end",tag:i.uniqueTag};this.addParallelStages(this._makeConnectParallelStages(a,l)),r.delete(e)}handleNote({type:t,agents:e,mode:n,label:s}){let r=null;r=0===e.length?Ft[t]||[]:e.map(this.toGAgent),this.validateGAgents(r,{allowGrouped:!0});const i=(r=a(r,this.expandGroupedGAgent)).map(t=>t.id),o=new Set(i).size;if("note between"===t&&o<2)throw new Error("note between requires at least 2 agents");this.addStage(this.setGAgentVis(r,!0,"box")),this.defineGAgents(r),this.addStage({type:t,agentIDs:i,mode:n,label:this.textFormatter(s)})}handleAgentDefine({agents:t}){const n=t.map(this.toGAgent);this.validateGAgents(n,{allowGrouped:!0,allowCovered:!0}),e(this.gAgents,n,At.equals)}handleAgentOptions({agent:t,options:n}){const s=this.toGAgent(t),r=[s];this.validateGAgents(r,{allowGrouped:!0,allowCovered:!0}),e(this.gAgents,r,At.equals),this.gAgents.filter(({id:t})=>t===s.id).forEach(t=>{e(t.options,n)})}handleAgentBegin({agents:t,mode:e}){const n=t.map(this.toGAgent);this.validateGAgents(n),this.addStage(this.setGAgentVis(n,!0,e,!0))}handleAgentEnd({agents:t,mode:e}){const n=t.filter(t=>this.activeGroups.has(t.name)),s=t.filter(t=>!this.activeGroups.has(t.name)).map(this.toGAgent);this.validateGAgents(s),this.addParallelStages([this.setGAgentHighlight(s,!1),this.setGAgentVis(s,!1,e,!0),...n.map(this.endGroup)])}handleStage(t){this.latestLine=t.ln;try{const e=this.stageHandlers[t.type];if(!e)throw new Error("Unknown command: "+t.type);e(t)}catch(e){if("object"==typeof e&&e.message)throw e.message+=" at line "+(t.ln+1),e}}_reset(){this.agentStates.clear(),this.markers.clear(),this.agentAliases.clear(),this.activeGroups.clear(),this.gAgents.length=0,this.nextID=0,this.nesting.length=0,this.labelPattern=[{token:"label"}]}_finalise(t){p(this.gAgents,this.currentNest.leftGAgent,this.currentNest.rightGAgent),function(t){let e=[],n=new Set;for(let s=0;s<t.length;){const r=t[s];let i=null;d(i="parallel"===r.type?r.stages:[r]);const a=g(i);c(n,a,e,i),0===i.length?t.splice(s,1):("parallel"===r.type&&1===i.length&&t.splice(s,1,i[0]),n=a,e=i,++s)}}(t.stages),this.gAgents.forEach(t=>{t.formattedLabel=this.textFormatter(t.id)})}generate({stages:t,meta:e={}}){this._reset(),this.textFormatter=e.textFormatter;const n=this.beginNested("global",{tag:"",label:"",name:"",ln:0});if(t.forEach(this.handleStage),1!==this.nesting.length)throw new Error("Unterminated section at line "+(this.currentSection.header.ln+1));if(this.activeGroups.size>0)throw new Error("Unterminated group");this._checkSectionEnd();const s=e.terminators||"none";return this.addParallelStages([this.setGAgentHighlight(this.gAgents,!1),this.setGAgentVis(this.gAgents,!1,s)]),this._finalise(n),function(t,e){for(let n=0;n<t.length&&!u(t[n],e);++n);}(n.stages,e.headers||"box"),{meta:{title:this.textFormatter(e.title),theme:e.theme,code:e.code},agents:this.gAgents.slice(),stages:n.stages}}}const Ct="monospace",Et=new nt(6,[0,-.25,-.5,-.25,0,.25,.5,.25]),Gt={"font-family":Ct,"font-size":8,"line-height":1.3},It={"font-family":Ct,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class Dt extends st{constructor(t){super(t);const e={padding:{top:3,bottom:2},tag:{padding:{top:2,left:4,right:4,bottom:2},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:3,ry:3}),labelAttrs:{"font-family":Ct,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:8,padding:{top:2,left:8,right:8,bottom:2},labelAttrs:{"font-family":Ct,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:8,outerMargin:4,agentMargin:12,actionMargin:12,minActionMargin:4,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:4,left:8,right:8,bottom:4},arrowBottom:12,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":1},labelAttrs:{"font-family":Ct,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:9,left:8,right:8,bottom:3},arrowBottom:12,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,"db-z":4}),labelAttrs:{"font-family":Ct,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},cross:{size:16,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},fade:{width:5,height:8,extend:1},none:{height:8}},connect:{loopbackRadius:4,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-dasharray":"4, 4"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,Et),renderRev:this.renderRevConnect.bind(this,Et)}},arrow:{single:{width:4,height:8,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000","stroke-width":0,"stroke-linejoin":"miter"}},double:{width:3,height:6,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"miter"}},cross:{short:8,radius:4,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})}},label:{padding:4,margin:{top:2,bottom:1},attrs:{"font-family":Ct,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":Ct,"font-size":8,"line-height":1.3}},source:{radius:2,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":Ct,"font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":1},red:{stroke:"#AA0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":2}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":2,"stroke-dasharray":"8, 4"})}},notes:{text:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:4,left:4,right:4,bottom:4},overlap:{left:8,right:8},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:Gt},note:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:8,left:8,right:8,bottom:8},overlap:{left:8,right:8},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:Gt},state:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:8,left:8,right:8,bottom:8},overlap:{left:8,right:8},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:8,ry:8}),labelAttrs:Gt}},dividers:{"":{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:8,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000"}})},delay:{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:2,gapSize:2})},tear:{labelAttrs:It,padding:{top:2,left:5,right:5,bottom:2},extend:8,margin:8,render:this.renderTearDivider.bind(this,{fadeBegin:4,fadeSize:4,zigWidth:4,zigHeight:1,lineAttrs:{stroke:"#000000"}})}}})}}class Lt{constructor(){this.name="monospace"}build(t){return new Dt(t)}}const Nt={type:"error line-error",suggest:!1,then:{"":0}},zt=["database","red"],Ot=(()=>{function t(t,e=1){return{type:"variable",suggest:{known:"Agent"},then:Object.assign({},t,{"":0,",":{type:"operator",then:{"":e}}})}}function e(t){return{type:"keyword",suggest:[t+" of ",t+": "],then:{of:{type:"keyword",then:{"":h}},":":{type:"operator",then:{"":i}},"":h}}}function n({exit:t,sourceExit:e,blankExit:n}){const s={type:"operator",then:{"+":Nt,"-":Nt,"*":Nt,"!":Nt,"":t}};return{"+":{type:"operator",then:{"+":Nt,"-":Nt,"*":s,"!":Nt,"":t}},"-":{type:"operator",then:{"+":Nt,"-":Nt,"*":s,"!":{type:"operator",then:{"+":Nt,"-":Nt,"*":Nt,"!":Nt,"":t}},"":t}},"*":{type:"operator",then:Object.assign({"+":s,"-":s,"*":Nt,"!":Nt,"":t},e||t)},"!":s,"":n||t}}const s={type:"",suggest:"\n",then:{}},r={type:"",suggest:!1,then:{}},i=f({"\n":s}),a={type:"operator",then:{"":i,"\n":r}},o=t({"\n":s,as:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,",":{type:"operator",then:{"":3}},"\n":s}}}}}),h=t({":":a}),l={type:"variable",suggest:{known:"Agent"},then:{"":0,":":{type:"operator",then:{"":i,"\n":r}},"\n":s}},d={":":{type:"operator",then:{"":f({as:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,"\n":s}}}}})}}},g={type:"keyword",then:Object.assign({over:{type:"keyword",then:{"":t(d)}}},d)},c={"\n":s,":":{type:"operator",then:{"":i,"\n":r}},with:{type:"keyword",suggest:["with height "],then:{height:{type:"keyword",then:{"":{type:"number",suggest:["6 ","30 "],then:{"\n":s,":":{type:"operator",then:{"":i,"\n":r}}}}}}}}},u=function(t,e,n){const s=Object.assign({},n);return e.forEach(e=>{s[e]={type:t,then:n}}),s}("keyword",["a","an"],function(t,e,n){const s={},r=Object.assign({},n);return e.forEach(e=>{s[e]={type:t,then:r},r[e]=0}),s}("keyword",zt,{"\n":s})),p={type:"keyword",then:{"":i,":":{type:"operator",then:{"":i}},"\n":s}},m={title:{type:"keyword",then:{"":i}},theme:{type:"keyword",then:{"":{type:"string",suggest:{global:"themes",suffix:"\n"},then:{"":0,"\n":s}}}},headers:{type:"keyword",then:{none:{type:"keyword",then:{}},cross:{type:"keyword",then:{}},box:{type:"keyword",then:{}},fade:{type:"keyword",then:{}},bar:{type:"keyword",then:{}}}},terminators:{type:"keyword",then:{none:{type:"keyword",then:{}},cross:{type:"keyword",then:{}},box:{type:"keyword",then:{}},fade:{type:"keyword",then:{}},bar:{type:"keyword",then:{}}}},divider:{type:"keyword",then:Object.assign({line:{type:"keyword",then:c},space:{type:"keyword",then:c},delay:{type:"keyword",then:c},tear:{type:"keyword",then:c}},c)},define:{type:"keyword",then:{"":o,as:Nt}},begin:{type:"keyword",then:{"":o,reference:g,as:Nt}},end:{type:"keyword",then:{"":o,as:Nt,"\n":s}},if:p,else:{type:"keyword",suggest:["else\n","else if: "],then:{if:{type:"keyword",suggest:"if: ",then:{"":i,":":{type:"operator",then:{"":i}}}},"\n":s}},repeat:p,group:p,note:{type:"keyword",then:{over:{type:"keyword",then:{"":h}},left:e("left"),right:e("right"),between:{type:"keyword",then:{"":t({":":Nt},h)}}}},state:{type:"keyword",suggest:"state over ",then:{over:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,",":Nt,":":a}}}}}},text:{type:"keyword",then:{left:e("left"),right:e("right")}},autolabel:{type:"keyword",then:{off:{type:"keyword",then:{}},"":f({"\n":s},[{v:"<label>",suffix:"\n",q:!0},{v:"[<inc>] <label>",suffix:"\n",q:!0},{v:"[<inc 1,0.01>] <label>",suffix:"\n",q:!0}])}},simultaneously:{type:"keyword",then:{":":{type:"operator",then:{}},with:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Label"},then:{"":0,":":{type:"operator",then:{}}}}}}}}};return t=>({type:"error line-error",then:Object.assign({},m,function(t){const e={type:"keyword",then:Object.assign({},n({exit:l,sourceExit:{":":a,"\n":r}}),{"...":{type:"operator",then:{"":{type:"variable",suggest:{known:"DelayedAgent"},then:{"":0,":":Nt,"\n":s}}}}})},i={};t.forEach(t=>i[t]=e);const o={type:"operator",suggest:!1,override:"Label",then:{}},h={type:"variable",suggest:{known:"Agent"},then:Object.assign({"":0},i,{":":{type:"operator",override:"Label",then:{}}})},d={type:"variable",suggest:{known:"DelayedAgent"},then:Object.assign({"":0,":":o},i)},g=Object.assign({},h,{then:Object.assign({},h.then,{is:{type:"keyword",then:u}})});return Object.assign({"...":{type:"operator",then:{"":d}}},n({exit:h,sourceExit:Object.assign({"":h,":":o},i),blankExit:g}))}(t))})})();class Bt{constructor(t,e){this.tokenDefinitions=t,this.commands=Ot(e),this.lineComment="#"}startState(){return{currentType:-1,current:"",currentSpace:"",currentQuoted:!1,knownAgent:[],knownDelayedAgent:[],knownLabel:[],beginCompletions:y({},[this.commands]),completions:[],nextCompletions:[],valid:!0,isVar:!0,line:[],indent:0}}_matchPattern(t,e,n){return e?(e.lastIndex=0,t.match(e,n)):null}_tokenBegin(t,e){e.currentSpace="";for(let n="";!t.eol();n=t.next()){e.currentSpace+=n;for(let n=0;n<this.tokenDefinitions.length;++n){const s=this.tokenDefinitions[n];if(this._matchPattern(t,s.start,!0)){e.currentType=n;const{value:t,quoted:r}=w(s);return e.current=t,e.currentQuoted=r,!0}}}return!1}_tokenCheckEscape(t,e,n){const s=this._matchPattern(t,n.escape,!0);s&&(e.current+=n.escapeWith(s))}_addToken(t){t.line.push({v:t.current,s:t.currentSpace,q:t.currentQuoted})}_tokenEndFound(t,e,n,s){return e.currentType=-1,n.includeEnd&&(e.current+=s[0]),n.omit?"comment":(this._addToken(e),k(e,t.eol(),this.commands))}_tokenEOLFound(t,e,n){if(e.current+="\n",n.omit)return"comment";this._addToken(e);const s=k(e,!1,this.commands);return e.line.pop(),s}_tokenEnd(t,e){for(;;){const n=this.tokenDefinitions[e.currentType];if(this._tokenCheckEscape(t,e,n),!n.end)return this._tokenEndFound(t,e,n,null);{const s=this._matchPattern(t,n.end,!0);if(s)return this._tokenEndFound(t,e,n,s)}if(t.eol())return this._tokenEOLFound(t,e,n);e.current+=t.next()}}token(t,e){e.completions=e.nextCompletions,e.isVar=!0,t.sol()&&-1===e.currentType&&(e.line.length=0);let n="";return(-1!==e.currentType||this._tokenBegin(t,e))&&(n=this._tokenEnd(t,e)),-1===e.currentType&&t.eol()&&!e.valid?"line-error "+n:n}indent(t){return t.indent}}const Vt=[{end:/(?=\n)|$/y,omit:!0,start:/#/y},{baseToken:{q:!0},end:/"/y,escape:/\\(.)/y,escapeWith:function(t){return"n"===t[1]?"\n":t[1]},start:/"/y},{baseToken:{v:"..."},start:/\.\.\./y},{end:/(?=[ \t\r\n:+~\-*!<>,])|$/y,start:/(?=[^ \t\r\n:+~\-*!<>,])/y},{end:/(?=[^~\-<>x])|[-~]x|[<>](?=x)|$/y,includeEnd:!0,start:/(?=[~\-<])/y},{baseToken:{v:","},start:/,/y},{baseToken:{v:":"},start:/:/y},{baseToken:{v:"!"},start:/!/y},{baseToken:{v:"+"},start:/\+/y},{baseToken:{v:"*"},start:/\*/y},{baseToken:{v:"\n"},start:/\n/y}];class Ht{constructor(t){this.src=t,this.block=null,this.token=null,this.pos={ch:0,i:0,ln:0},this.reset()}isOver(){return this.pos.i>this.src.length}reset(){this.token={b:null,e:null,q:!1,s:"",v:""},this.block=null}beginToken(t){this.block=t.newBlock,Object.assign(this.token,this.block.baseToken),this.token.b=F(this.pos)}endToken(){let t=null;return this.block.omit||(this.token.e=F(this.pos),t=this.token),this.reset(),t}advance(){const t=A(this.src,this.pos.i,this.block);return t.newBlock&&this.beginToken(t),this.token.s+=t.appendSpace,this.token.v+=t.appendValue,function(t,e,n){for(let s=0;s<n;++s)++t.ch,"\n"===e[t.i+s]&&(++t.ln,t.ch=0);t.i+=n}(this.pos,this.src,t.skip),t.end?this.endToken():null}}class Tt{tokenise(t){const e=[],n=new Ht(t);for(;!n.isOver();){const t=n.advance();t&&e.push(t)}if(n.block)throw new Error("Unterminated literal (began at "+function(t){return"line "+(t.ln+1)+", character "+t.ch}(n.token.b)+")");return e}getCodeMirrorMode(t){return new Bt(Vt,t)}splitLines(t){const e=[];let n=[];return t.forEach(t=>{t.q||"\n"!==t.v?n.push(t):n.length>0&&(e.push(n),n=[])}),n.length>0&&e.push(n),e}}const Pt=/(.*?)<([^<>]*)>/g,jt=/\.([0-9]*)/,qt=[{attrs:{"font-style":"italic"},begin:/[\s_~`]\*(?=\S)/g,end:/\S\*(?=[\s_~`])/g},{attrs:{"font-style":"italic"},begin:/[\s*~`]_(?=\S)/g,end:/\S_(?=[\s*~`])/g},{attrs:{"font-weight":"bolder"},begin:/[\s_~`]\*\*(?=\S)/g,end:/\S\*\*(?=[\s_~`])/g},{attrs:{"font-weight":"bolder"},begin:/[\s*~`]__(?=\S)/g,end:/\S__(?=[\s*~`])/g},{attrs:{"text-decoration":"line-through"},begin:/[\s_*`]~(?=\S)/g,end:/\S~(?=[\s_*`])/g},{attrs:{"font-family":"monospace"},begin:/[\s_*~.]`(?=\S)/g,end:/\S`(?=[\s_*~.])/g}],Yt={if:{type:"block begin",blockType:"if",tag:"if",skip:[]},else:{type:"block split",blockType:"else",tag:"else",skip:["if"]},repeat:{type:"block begin",blockType:"repeat",tag:"repeat",skip:[]},group:{type:"block begin",blockType:"group",tag:"",skip:[]}},Wt={types:(()=>{const t=function(t){const e=[];return i(t,0,[],e),e}([[{tok:"",type:0},{tok:"<",type:1},{tok:"<<",type:2}],[{tok:"-",type:"solid"},{tok:"--",type:"dash"},{tok:"~",type:"wave"}],[{tok:"",type:0},{tok:">",type:1},{tok:">>",type:2},{tok:"x",type:3}]]).filter(t=>0!==t[0].type||0!==t[2].type),e=new Map;return t.forEach(t=>{e.set(t.map(t=>t.tok).join(""),{line:t[1].type,left:t[0].type,right:t[2].type})}),e})(),agentFlags:{"*":{flag:"begin",allowBlankName:!0,blankNameFlag:"source"},"+":{flag:"start"},"-":{flag:"stop"},"!":{flag:"end"}}},Ut=["none","box","cross","fade","bar"],Xt={text:{mode:"text",types:{left:{type:"note left",skip:["of"],min:0,max:null},right:{type:"note right",skip:["of"],min:0,max:null}}},note:{mode:"note",types:{over:{type:"note over",skip:[],min:0,max:null},left:{type:"note left",skip:["of"],min:0,max:null},right:{type:"note right",skip:["of"],min:0,max:null},between:{type:"note between",skip:[],min:2,max:null}}},state:{mode:"state",types:{over:{type:"note over",skip:[],min:1,max:1}}}},Qt={line:{defaultHeight:6},space:{defaultHeight:6},delay:{defaultHeight:30},tear:{defaultHeight:6}},Jt={define:{type:"agent define"},begin:{type:"agent begin",mode:"box"},end:{type:"agent end",mode:"cross"}},Zt=[(t,e)=>"title"!==D(t[0])?null:(e.title=I(t,1),!0),(t,e)=>"theme"!==D(t[0])?null:(e.theme=I(t,1),!0),(t,e)=>{if("terminators"!==D(t[0]))return null;const n=D(t[1]);if(!n)throw G("Unspecified termination",t[0]);if(-1===Ut.indexOf(n))throw G('Unknown termination "'+n+'"',t[1]);return e.terminators=n,!0},(t,e)=>{if("headers"!==D(t[0]))return null;const n=D(t[1]);if(!n)throw G("Unspecified header",t[0]);if(-1===Ut.indexOf(n))throw G('Unknown header "'+n+'"',t[1]);return e.headers=n,!0},t=>{if("divider"!==D(t[0]))return null;const e=N(t,":",{orEnd:!0}),n=N(t,["with","height"],{limit:e,orEnd:!0}),s=I(t,1,n)||"line";if(!Qt[s])throw G("Unknown divider type",t[1]);const r=function(t,e=0,n=null,s=Number.NAN){const r=I(t,e,n);return Number(r||s)}(t,n+2,e,Qt[s].defaultHeight);if(Number.isNaN(r)||r<0)throw G("Invalid divider height",t[n+2]);return{type:"divider",mode:s,height:r,label:I(t,e+1)}},t=>{if("autolabel"!==D(t[0]))return null;let e=null;return e="off"===D(t[1])?"<label>":I(t,1),{type:"label pattern",pattern:function(t){const e=[];let n=null,s=0;for(Pt.lastIndex=0;n=Pt.exec(t);)n[1]&&e.push(n[1]),n[2]&&e.push(S(n[2])),s=Pt.lastIndex;const r=t.substr(s);return r&&e.push(r),e}(e)}},t=>{if("end"===D(t[0])&&1===t.length)return{type:"block end"};const e=Yt[D(t[0])];if(!e)return null;let n=1;return t.length>n&&(n=L(t,n,e.skip,"Invalid block command")),n=L(t,n,[":"]),{type:e.type,blockType:e.blockType,tag:e.tag,label:I(t,n)}},t=>{if("begin"!==D(t[0])||"reference"!==D(t[1]))return null;let e=[];const n=N(t,":");if("over"===D(t[2])&&n>3)e=O(t,3,n);else if(2!==n)throw G('Expected ":" or "over"',t[2]);const s=z(t,n+1,t.length,{aliases:!0});if(!s.alias)throw G("Reference must have an alias",t[n]);return{type:"group begin",agents:e,blockType:"ref",tag:"ref",label:s.name,alias:s.alias}},t=>{const e=Jt[D(t[0])];return!e||t.length<=1?null:Object.assign({agents:O(t,1,t.length,{aliases:!0})},e)},t=>{if("simultaneously"!==D(t[0]))return null;if(":"!==D(r(t)))return null;let e="";if(t.length>2){if("with"!==D(t[1]))return null;e=I(t,2,t.length-1)}return{type:"async",target:e}},t=>{const e=Xt[D(t[0])],n=N(t,":");if(!e||-1===n)return null;const s=e.types[D(t[1])];if(!s)return null;let r=2;const i=O(t,r=L(t,r,s.skip),n);if(i.length<s.min)throw G("Too few agents for "+e.mode,t[0]);if(null!==s.max&&i.length>s.max)throw G("Too many agents for "+e.mode,t[0]);return{type:s.type,agents:i,mode:e.mode,label:I(t,n+1)}},t=>{const e=N(t,":",{orEnd:!0}),n=function(t,e,{start:n=0,limit:s=null}={}){null===s&&(s=t.length);for(let r=n;r<s;++r){const n=e.get(D(t[r]));if(n)return{pos:r,value:n}}return null}(t,Wt.types,{start:0,limit:e-1});if(!n)return null;const s=n.pos,r={flagTypes:Wt.agentFlags};if("..."===D(t[0]))return{type:"connect-delay-end",tag:I(t,1,s),agent:z(t,s+1,e,r),label:I(t,e+1),options:n.value};if("..."===D(t[s+1])){if(e!==t.length)throw G("Cannot label beginning of delayed connection",t[e]);return{type:"connect-delay-begin",tag:I(t,s+2,e),agent:z(t,0,s,r),options:n.value}}return{type:"connect",agents:[z(t,0,s,r),z(t,s+1,e,r)],label:I(t,e+1),options:n.value}},t=>t.length<2||":"!==D(r(t))?null:{type:"mark",name:I(t,0,t.length-1)},t=>{const e=N(t,"is");if(e<1)return null;let n=e+1;if(["a","an"].includes(D(t[n]))&&++n,n===t.length)throw G("Empty agent options",{b:r(t).e});const s=z(t,0,e),i=[];for(let e=n;e<t.length;++e)i.push(t[e].v);return{type:"agent options",agent:s,options:i}}],Kt=new Tt;class _t{getCodeMirrorMode(){return Kt.getCodeMirrorMode(Array.from(Wt.types.keys()))}parseLines(t,e){const n={meta:{title:"",theme:"",code:e,terminators:"none",headers:"box",textFormatter:E},stages:[]};return t.forEach(t=>(function(t,{meta:e,stages:n}){let s=null;for(let n=0;n<Zt.length&&!(s=Zt[n](t,e));++n);if(!s)throw G("Unrecognised command: "+I(t),t[0]);"object"==typeof s&&(s.ln=t[0].b.ln,n.push(s))})(t,n)),n}parse(t){const e=Kt.tokenise(t),n=Kt.splitLines(e);return this.parseLines(n,t)}}class $t{makeState(){}resetState(t){this.makeState(t)}prepareMeasurements(){}separationPre(){}separation(){}renderPre(){}render(){}renderHidden(){}shouldHide(){}}const te=new Map,ee={class:"outline",fill:"transparent"};class ne{getConfig(t,e){let n=null;return t.includes("database")&&(n=e.theme.agentCap.database),n||e.theme.agentCap.box}prepareMeasurements({formattedLabel:t,options:e},n){const s=this.getConfig(e,n);n.textSizer.expectMeasure(s.labelAttrs,t)}separation({formattedLabel:t,options:e},n){const s=this.getConfig(e,n),r=n.textSizer.measure(s.labelAttrs,t).width+s.padding.left+s.padding.right;return{left:r/2,radius:r/2,right:r/2}}topShift({formattedLabel:t,options:e},n){const s=this.getConfig(e,n),r=n.textSizer.measureHeight(s.labelAttrs,t)+s.padding.top+s.padding.bottom;return Math.max(0,r-s.arrowBottom)}render(t,{x:e,formattedLabel:n,options:s},r){const i=this.getConfig(s,r),a=r.svg.boxedText(i,n,{x:e,y:t});return r.makeRegion().add(a,r.svg.box(ee,{height:a.height,width:a.width,x:e-a.width/2,y:t})),{height:a.height,lineBottom:a.height,lineTop:0}}}class se{prepareMeasurements(){}separation(t,e){const n=e.theme.agentCap.cross;return{left:n.size/2,radius:0,right:n.size/2}}topShift(t,e){return e.theme.agentCap.cross.size/2}render(t,{x:e,options:n},s){const r=s.theme.agentCap.cross,i=r.size/2;return s.makeRegion().add(r.render({options:n,radius:i,x:e,y:t+i}),s.svg.box(ee,{height:2*i,width:2*i,x:e-i,y:t})),{height:2*i,lineBottom:i,lineTop:i}}}class re{prepareMeasurements({formattedLabel:t},e){const n=e.theme.agentCap.box;e.textSizer.expectMeasure(n.labelAttrs,t)}separation({formattedLabel:t},e){const n=e.theme.agentCap.box,s=e.textSizer.measure(n.labelAttrs,t).width+n.padding.left+n.padding.right;return{left:s/2,radius:s/2,right:s/2}}topShift(t,e){return e.theme.agentCap.bar.height/2}render(t,{x:e,formattedLabel:n,options:s},r){const i=r.theme.agentCap.box,a=r.theme.agentCap.bar,o=r.textSizer.measure(i.labelAttrs,n).width+i.padding.left+i.padding.right,{height:h}=a;return r.makeRegion().add(a.render({height:h,options:s,width:o,x:e-o/2,y:t}),r.svg.box(ee,{height:h,width:o,x:e-o/2,y:t})),{height:h,lineBottom:h,lineTop:0}}}class ie{prepareMeasurements(){}separation({currentRad:t}){return{left:t,radius:t,right:t}}topShift(t,e,n){const s=e.theme.agentCap.fade;return n?s.height:0}render(t,{x:e},n,s){const r=n.theme.agentCap.fade,i=r.height/(r.height+r.extend),a=n.addDef(s?"FadeIn":"FadeOut",()=>n.svg.linearGradient({x1:"0%",x2:"0%",y1:s?"100%":"0%",y2:s?"0%":"100%"},[{offset:"0%","stop-color":"#FFFFFF"},{offset:(100*i).toFixed(3)+"%","stop-color":"#000000"}]));return n.lineMaskLayer.add(n.svg.box({fill:"url(#"+a+")"},{height:r.height+r.extend,width:r.width,x:e-r.width/2,y:t-(s?r.extend:0)})),n.makeRegion().add(n.svg.box(ee,{height:r.height,width:r.width,x:e-r.width/2,y:t})),{height:r.height,lineBottom:0,lineTop:r.height}}}class ae{prepareMeasurements(){}separation({currentRad:t}){return{left:t,radius:t,right:t}}topShift(t,e){return e.theme.agentCap.none.height}render(t,{x:e},n){const s=n.theme.agentCap.none;return n.makeRegion().add(n.svg.box(ee,{height:s.height,width:10,x:e-5,y:t})),{height:s.height,lineBottom:0,lineTop:s.height}}}const oe={bar:new re,box:new ne,cross:new se,fade:new ie,none:new ae};class he extends $t{constructor(t){super(),this.begin=t}prepareMeasurements({mode:t,agentIDs:e},n){e.forEach(e=>{const s=n.agentInfos.get(e);oe[t].prepareMeasurements(s,n,this.begin)})}separationPre({mode:t,agentIDs:e},n){e.forEach(e=>{const s=n.agentInfos.get(e),r=oe[t].separation(s,n,this.begin);n.addSpacing(e,r),s.currentMaxRad=Math.max(s.currentMaxRad,r.radius)})}separation({agentIDs:t},s){this.begin?e(s.visibleAgentIDs,t):n(s.visibleAgentIDs,t)}renderPre({mode:t,agentIDs:e},n){let s=0;return e.forEach(e=>{const r=n.agentInfos.get(e),i=oe[t],a=i.topShift(r,n,this.begin);s=Math.max(s,a);const o=i.separation(r,n,this.begin).radius;r.currentMaxRad=Math.max(r.currentMaxRad,o)}),{agentIDs:e,topShift:s}}render({mode:t,agentIDs:e},n){let s=0;return e.forEach(e=>{const r=n.agentInfos.get(e),i=oe[t],a=i.topShift(r,n,this.begin),o=n.primaryY-a,h=i.render(o,r,n,this.begin);s=Math.max(s,o+h.height),this.begin?n.drawAgentLine(e,o+h.lineBottom):n.drawAgentLine(e,o+h.lineTop,!0)}),s+n.theme.actionMargin}renderHidden({agentIDs:t},e){t.forEach(t=>{e.drawAgentLine(t,e.topY,!this.begin)})}}V("agent begin",new he(!0)),V("agent end",new he(!1));class le extends $t{radius(t,e){return t?e.theme.agentLineHighlightRadius:0}separationPre({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);t.forEach(t=>{const e=n.agentInfos.get(t);e.currentRad=s,e.currentMaxRad=Math.max(e.currentMaxRad,s)})}renderPre({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);t.forEach(t=>{const e=n.agentInfos.get(t);e.currentMaxRad=Math.max(e.currentMaxRad,s)})}render({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);return t.forEach(t=>{n.drawAgentLine(t,n.primaryY),n.agentInfos.get(t).currentRad=s}),n.primaryY+n.theme.actionMargin}renderHidden(t,e){this.render(t,e)}}V("agent highlight",new le);const de={class:"outline",fill:"transparent"};class ge extends $t{prepareMeasurements({left:t,tag:e,label:n},s){const r=s.state.blocks.get(t),i=s.theme.getBlock(r.type).section;s.textSizer.expectMeasure(i.tag.labelAttrs,e),s.textSizer.expectMeasure(i.label.labelAttrs,n)}separation({left:t,right:e,tag:n,label:s},r){const i=r.state.blocks.get(t),a=r.theme.getBlock(i.type).section,o=r.textSizer.measure(a.tag.labelAttrs,n).width+a.tag.padding.left+a.tag.padding.right+r.textSizer.measure(a.label.labelAttrs,s).width+a.label.padding.left+a.label.padding.right;r.addSeparation(t,e,o)}renderPre({left:t,right:e}){return{agentIDs:[t,e]}}render({left:t,right:e,tag:n,label:s},r,i=!1){const a=r.state.blocks.get(t),o=r.theme.getBlock(a.type),h=r.agentInfos.get(t),l=r.agentInfos.get(e);let d=r.primaryY;i||(d+=o.section.padding.bottom);const g=r.makeRegion(),c=r.svg.boxedText({boxAttrs:o.section.tag.boxAttrs,boxRenderer:o.section.tag.boxRenderer,labelAttrs:o.section.tag.labelAttrs,padding:o.section.tag.padding},n,{x:h.x,y:d}),u=r.svg.boxedText({boxAttrs:{fill:"#000000"},labelAttrs:o.section.label.labelAttrs,padding:o.section.label.padding},s,{x:h.x+c.width,y:d}),p=Math.max(Math.max(c.height,u.height),o.section.label.minHeight);return a.hold.add(c.box),r.lineMaskLayer.add(u.box),g.add(r.svg.box(de,{height:p,width:l.x-h.x,x:h.x,y:d}),c.label,u.label),i?a.canHide&&g.addClass(a.hide?"collapsed":"expanded"):a.hold.add(o.sepRenderer({x1:h.x,x2:l.x,y1:d,y2:d})),d+p+o.section.padding.top}}class ce extends ge{makeState(t){t.blocks=new Map}resetState(t){t.blocks.clear()}storeBlockInfo(t,e){const{canHide:n}=t,s={canHide:n,hide:n&&e.renderer.isCollapsed(t.ln),hold:null,startY:null,type:t.blockType};return e.state.blocks.set(t.left,s),s}prepareMeasurements(t,e){this.storeBlockInfo(t,e),super.prepareMeasurements(t,e)}separationPre(t,e){this.storeBlockInfo(t,e),super.separationPre(t,e)}separation(t,n){e(n.visibleAgentIDs,[t.left,t.right]),super.separation(t,n)}renderPre(t,e){const n=this.storeBlockInfo(t,e),s=e.theme.getBlock(n.type);return{agentIDs:[t.left,t.right],topShift:s.margin.top}}render(t,e){const n=e.svg.el("g");e.blockLayer.add(n);const s=e.state.blocks.get(t.left);return s.hold=n,s.startY=e.primaryY,super.render(t,e,!0)}shouldHide({left:t},e){return{nest:e.state.blocks.get(t).hide?1:0,self:!1}}}class ue extends $t{separation({left:t,right:e},s){n(s.visibleAgentIDs,[t,e])}renderPre({left:t,right:e},n){const s=n.state.blocks.get(t);return{agentIDs:[t,e],topShift:n.theme.getBlock(s.type).section.padding.bottom}}render({left:t,right:e},n){const s=n.state.blocks.get(t),r=n.theme.getBlock(s.type),i=n.agentInfos.get(t),a=n.agentInfos.get(e);let o=r.boxRenderer;s.hide&&(o=r.collapsedBoxRenderer||o);let h=o({height:n.primaryY-s.startY,width:a.x-i.x,x:i.x,y:s.startY});return h.shape||(h={shape:h}),s.hold.add(h.shape),n.fillLayer.add(h.fill),n.lineMaskLayer.add(h.mask),n.primaryY+r.margin.bottom+n.theme.actionMargin}shouldHide({left:t},e){return{nest:e.state.blocks.get(t).hide?-1:0,self:!1}}}V("block begin",new ce),V("block split",new ge),V("block end",new ue);const pe={class:"outline",fill:"transparent"};class fe{constructor(t){this.propName=t}getConfig(t){return t.connect.arrow[this.propName]}short(t){const e=this.getConfig(t),n=e.attrs["stroke-linejoin"]||"miter",s=.5*e.attrs["stroke-width"],r=.5*t.agentLineAttrs[""]["stroke-width"];if("round"===n)return r+s;{const t=e.height/2,n=e.width;return r+s*Math.sqrt(n*n/(t*t)+1)}}render(t,e,n,s){const r=this.getConfig(e),i=this.short(e);t.add(r.render(r.attrs,{x:n.x+i*s.dx,y:n.y+i*s.dy,width:r.width,height:r.height,dir:s}))}width(t){return this.short(t)+this.getConfig(t).width}height(t){return this.getConfig(t).height}lineGap(t,e){const n=this.getConfig(t),s=this.short(t);if("none"===n.attrs.fill){const t=n.height/2,r=n.width;return(s+(s+e["stroke-width"]/2*(r/t)))/2}return s+n.width/2}}class me{getConfig(t){return t.connect.arrow.cross}render(t,e,n,s){const r=this.getConfig(e);t.add(r.render({x:n.x+r.short*s.dx,y:n.y+r.short*s.dy,radius:r.radius}))}width(t){const e=this.getConfig(t);return e.short+e.radius}height(t){return 2*this.getConfig(t).radius}lineGap(t){return this.getConfig(t).short}}const be=[{render:()=>null,width:()=>0,height:()=>0,lineGap:()=>0},new fe("single"),new fe("double"),new me];class ye extends $t{prepareMeasurements({agentIDs:t,label:e},n){const s=n.theme.connect,r=t[0]===t[1]?s.label.loopbackAttrs:s.label.attrs;n.textSizer.expectMeasure(r,e)}separationPre({agentIDs:t},e){const n=e.theme.connect.source.radius;t.forEach(t=>{const s=e.agentInfos.get(t);s.isVirtualSource&&(s.currentRad=n,s.currentMaxRad=Math.max(s.currentMaxRad,n))})}separation({label:t,agentIDs:n,options:s},r){const i=r.theme.connect,a=be[s.left],o=be[s.right],h=n[0]===n[1],l=h?i.label.loopbackAttrs:i.label.attrs;let d=r.textSizer.measure(l,t).width;d>0&&(d+=2*i.label.padding);const g=r.agentInfos.get(n[0]);if(h)r.addSpacing(n[0],{left:0,right:g.currentMaxRad+Math.max(d+a.width(r.theme),o.width(r.theme))+i.loopbackRadius});else{const t=r.agentInfos.get(n[1]);r.addSeparation(n[0],n[1],g.currentMaxRad+t.currentMaxRad+d+2*Math.max(a.width(r.theme),o.width(r.theme)))}e(r.momentaryAgentIDs,n)}renderRevArrowLine({x1:t,y1:e,x2:n,y2:s,xR:r},i,a,o){const h=a.theme.connect,l=h.line[i.line],d=be[i.left],g=be[i.right],c=d.lineGap(a.theme,l.attrs),u=g.lineGap(a.theme,l.attrs),p=l.renderRev(l.attrs,{x1:t+c,y1:e,x2:n+u,y2:s,xR:r,rad:h.loopbackRadius});o.add(p.shape),d.render(o,a.theme,{x:p.p1.x-c,y:p.p1.y},{dx:1,dy:0}),g.render(o,a.theme,{x:p.p2.x-u,y:p.p2.y},{dx:1,dy:0})}renderSelfConnect({label:t,agentIDs:e,options:n},s,r,i){const a=s.theme.connect,o=be[n.left],h=be[n.right],l=s.agentInfos.get(e[1]),d=t?s.textSizer.measureHeight(a.label.attrs,t)+a.label.margin.top+a.label.margin.bottom:0,g=r.x+r.currentMaxRad+o.width(s.theme)+(t?a.label.padding:0),c=s.svg.boxedText({padding:a.mask.padding,boxAttrs:{fill:"#000000"},labelAttrs:a.label.loopbackAttrs},t,{x:g-a.mask.padding.left,y:i-d+a.label.margin.top}),u=t?c.width+a.label.padding-a.mask.padding.left-a.mask.padding.right:0,p=Math.max(l.x+l.currentMaxRad+h.width(s.theme),g+u),f=Math.max(d,o.height(s.theme)/2),m=h.height(s.theme)/2;s.lineMaskLayer.add(c.box);const b=s.makeRegion().add(s.svg.box(pe,{x:r.x,y:i-f,width:p+a.loopbackRadius-r.x,height:f+s.primaryY-i+m}),c.label);return this.renderRevArrowLine({x1:r.x+r.currentMaxRad,y1:i,x2:l.x+l.currentMaxRad,y2:s.primaryY,xR:p},n,s,b),s.primaryY+Math.max(m,0)+s.theme.actionMargin}renderArrowLine({x1:t,y1:e,x2:n,y2:s},r,i,a){const o=i.theme.connect.line[r.line],h=be[r.left],l=be[r.right],d=Math.sqrt((n-t)*(n-t)+(s-e)*(s-e)),g=h.lineGap(i.theme,o.attrs),c=l.lineGap(i.theme,o.attrs),u=(n-t)/d,p=(s-e)/d,f=o.renderFlat(o.attrs,{x1:t+g*u,y1:e+g*p,x2:n-c*u,y2:s-c*p});a.add(f.shape);const m={x:f.p1.x-g*u,y:f.p1.y-g*p},b={x:f.p2.x+c*u,y:f.p2.y+c*p};return h.render(a,i.theme,m,{dx:u,dy:p}),l.render(a,i.theme,b,{dx:-u,dy:-p}),{p1:m,p2:b,lArrow:h,rArrow:l}}renderVirtualSources({from:t,to:e,rendered:n},s,r){const i=s.theme.connect.source;t.isVirtualSource&&r.add(i.render({x:n.p1.x-i.radius,y:n.p1.y,radius:i.radius})),e.isVirtualSource&&r.add(i.render({x:n.p2.x+i.radius,y:n.p2.y,radius:i.radius}))}renderSimpleLabel(t,{layer:e,x1:n,x2:s,y1:r,y2:i,height:a},o){const h=o.theme.connect,l=(n+s)/2,d=(r+i)/2;let g=e;const c={fill:"#000000"};if(r!==i){const t="rotate("+180*Math.atan((i-r)/(s-n))/Math.PI+" "+l+","+d+")";c.transform=t,g=o.svg.el("g").attr("transform",t),e.add(g)}const u=o.svg.boxedText({padding:h.mask.padding,boxAttrs:c,labelAttrs:h.label.attrs},t,{x:l,y:d+h.label.margin.top-a});o.lineMaskLayer.add(u.box),g.add(u.label)}renderSimpleConnect({label:t,agentIDs:e,options:n},s,r,i){const a=s.theme.connect,o=s.agentInfos.get(e[1]),h=r.x<o.x?1:-1,l=s.textSizer.measureHeight(a.label.attrs,t)+a.label.margin.top+a.label.margin.bottom,d=r.x+r.currentMaxRad*h,g=o.x-o.currentMaxRad*h,c=s.makeRegion(),u=this.renderArrowLine({x1:d,y1:i,x2:g,y2:s.primaryY},n,s,c),p=Math.max(u.lArrow.height(s.theme),u.rArrow.height(s.theme))/2,f=Math.max(l,p);return this.renderVirtualSources({from:r,to:o,rendered:u},s,c),c.add(s.svg.el("path").attrs(pe).attr("d","M"+d+","+(i-f)+"L"+g+","+(s.primaryY-f)+"L"+g+","+(s.primaryY+p)+"L"+d+","+(i+p)+"Z")),this.renderSimpleLabel(t,{layer:c,x1:d,y1:i,x2:g,y2:s.primaryY,height:l},s),s.primaryY+Math.max(p+s.theme.minActionMargin,s.theme.actionMargin)}renderPre({label:t,agentIDs:e,options:n},s){const r=s.theme.connect,i=be[n.left],a=be[n.right],o=s.textSizer.measureHeight(r.label.attrs,t)+r.label.margin.top+r.label.margin.bottom;let h=i.height(s.theme);return e[0]!==e[1]&&(h=Math.max(h,a.height(s.theme))),{agentIDs:e,topShift:Math.max(h/2,o)}}render(t,e,n=null,s=null){let r=s,i=n;return null===n&&(i=e.agentInfos.get(t.agentIDs[0]),r=e.primaryY),t.agentIDs[0]===t.agentIDs[1]?this.renderSelfConnect(t,e,i,r):this.renderSimpleConnect(t,e,i,r)}}class xe extends ye{makeState(t){t.delayedConnections=new Map}resetState(t){t.delayedConnections.clear()}separation(t,n){super.separation(t,n),e(n.momentaryAgentIDs,[t.agentIDs[0]])}renderPre(t,e){return Object.assign(super.renderPre(t,e),{agentIDs:[t.agentIDs[0]]})}render(t,e){return e.state.delayedConnections.set(t.tag,{stage:t,from:Object.assign({},e.agentInfos.get(t.agentIDs[0])),y:e.primaryY}),e.primaryY+e.theme.actionMargin}renderHidden(t,e){this.render(t,e)}}class ke extends ye{prepareMeasurements(){}separationPre(){}separation(){}renderPre({tag:t},e){const n=e.theme.connect,s=e.state.delayedConnections.get(t),r=s.stage,i=[r.agentIDs[1]];return r.agentIDs[0]===r.agentIDs[1]?{agentIDs:i,y:s.y+2*n.loopbackRadius}:Object.assign(super.renderPre(r,e),{agentIDs:i})}render({tag:t},e){const n=e.state.delayedConnections.get(t);return super.render(n.stage,e,n.from,n.y)}}V("connect",new ye),V("connect-delay-begin",new xe),V("connect-delay-end",new ke);const we={class:"outline",fill:"transparent"};class ve extends $t{prepareMeasurements({mode:t,formattedLabel:e},n){const s=n.theme.getDivider(t);n.textSizer.expectMeasure(s.labelAttrs,e)}separation({mode:t,formattedLabel:e},n){const s=n.theme.getDivider(t),r=n.textSizer.measure(s.labelAttrs,e).width+s.padding.left+s.padding.right;n.addSeparation("[","]",r),n.addSpacing("[",{left:s.extend,right:0}),n.addSpacing("]",{left:0,right:s.extend})}renderPre(){return{agentIDs:["[","]"]}}render({mode:t,height:e,formattedLabel:n},s){const r=s.theme.getDivider(t),i=s.agentInfos.get("["),a=s.agentInfos.get("]");let o=0,h=0;n&&(h=s.textSizer.measureHeight(r.labelAttrs,n));const l=Math.max(e,h)+r.margin;let d=null;if(n){const t=s.svg.boxedText({boxAttrs:{fill:"#000000"},labelAttrs:r.labelAttrs,padding:r.padding},n,{x:(i.x+a.x)/2,y:s.primaryY+(l-h)/2-r.padding.top});s.fullMaskLayer.add(t.box),d=t.label,o=t.width}const{shape:g,mask:c}=r.render({env:s,height:e,labelHeight:h,labelWidth:o,width:a.x-i.x+2*r.extend,x:i.x-r.extend,y:s.primaryY+(l-e)/2});return s.fullMaskLayer.add(c),s.makeRegion({unmasked:!0}).add(s.svg.box(we,{height:l,width:a.x-i.x+2*r.extend,x:i.x-r.extend,y:s.primaryY}),g,d),s.primaryY+l+s.theme.actionMargin}}V("divider",new ve);class Ae extends $t{makeState(t){t.marks=new Map}resetState(t){t.marks.clear()}render({name:t},{topY:e,state:n}){n.marks.set(t,e)}renderHidden(t,e){this.render(t,e)}}class Fe extends $t{renderPre({target:t},{state:e}){let n=0;return t&&e.marks&&(n=e.marks.get(t)||0),{asynchronousY:n}}}V("mark",new Ae),V("async",new Fe);const Me={class:"outline",fill:"transparent"};class Se extends $t{prepareMeasurements({mode:t,label:e},n){const s=n.theme.getNote(t);n.textSizer.expectMeasure(s.labelAttrs,e)}renderPre({agentIDs:t}){return{agentIDs:t}}renderNote({xMid:t=null,x0:e=null,x1:n=null,mode:s,label:r},i){const a=i.theme.getNote(s),o=i.topY+a.margin.top+a.padding.top,h=i.svg.formattedText(a.labelAttrs,r),l=i.textSizer.measure(h),d=l.width+a.padding.left+a.padding.right,g=a.padding.top+l.height+a.padding.bottom;switch(null===e&&null!==t&&(e=t-d/2),null===n&&null!==e?n=e+d:null===e&&(e=n-d),a.labelAttrs["text-anchor"]){case"middle":h.set({x:(e+a.padding.left+n-a.padding.right)/2,y:o});break;case"end":h.set({x:n-a.padding.right,y:o});break;default:h.set({x:e+a.padding.left,y:o})}return i.makeRegion().add(a.boxRenderer({height:g,width:n-e,x:e,y:i.topY+a.margin.top}),i.svg.box(Me,{height:g,width:n-e,x:e,y:i.topY+a.margin.top}),h),i.topY+a.margin.top+g+a.margin.bottom+i.theme.actionMargin}}class Re extends Se{separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),i=s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right,{left:a,right:o}=T(s.agentInfos,t),h=s.agentInfos.get(a),l=s.agentInfos.get(o);if(h===l)s.addSpacing(a,{left:i/2,right:i/2});else{const t=h.currentMaxRad+r.overlap.left,e=l.currentMaxRad+r.overlap.right;s.addSeparation(a,o,i-t-e),s.addSpacing(a,{left:t,right:0}),s.addSpacing(o,{left:0,right:e})}}render({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t),o=s.agentInfos.get(i),h=s.agentInfos.get(a);if(o===h){const t=o.x;return this.renderNote({label:n,mode:e,xMid:t},s)}return this.renderNote({label:n,mode:e,x0:o.x-o.currentMaxRad-r.overlap.left,x1:h.x+h.currentMaxRad+r.overlap.right},s)}}class Ce extends Se{constructor(t){super(),this.isRight=t}separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t),o=s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right+r.margin.left+r.margin.right;if(this.isRight){const t=s.agentInfos.get(a);s.addSpacing(a,{left:0,right:o+t.currentMaxRad})}else{const t=s.agentInfos.get(i);s.addSpacing(i,{left:o+t.currentMaxRad,right:0})}}render({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t);if(this.isRight){const t=s.agentInfos.get(a),i=t.x+t.currentMaxRad+r.margin.left;return this.renderNote({label:n,mode:e,x0:i},s)}{const t=s.agentInfos.get(i),a=t.x-t.currentMaxRad-r.margin.right;return this.renderNote({label:n,mode:e,x1:a},s)}}}class Ee extends Se{separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=T(s.agentInfos,t),o=s.agentInfos.get(i),h=s.agentInfos.get(a);s.addSeparation(i,a,s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right+r.margin.left+r.margin.right+o.currentMaxRad+h.currentMaxRad)}render({agentIDs:t,mode:e,label:n},s){const{left:r,right:i}=T(s.agentInfos,t),a=s.agentInfos.get(r),o=s.agentInfos.get(i),h=(a.x+a.currentMaxRad+o.x-o.currentMaxRad)/2;return this.renderNote({label:n,mode:e,xMid:h},s)}}V("note over",new Re),V("note left",new Ce(!1)),V("note right",new Ce(!0)),V("note between",new Ee);class Ge extends $t{invokeChildren(t,e,n){return t.stages.map(t=>{return e.components.get(t.type)[n](t,e)})}prepareMeasurements(t,e){this.invokeChildren(t,e,"prepareMeasurements")}separationPre(t,e){this.invokeChildren(t,e,"separationPre")}separation(t,e){this.invokeChildren(t,e,"separation")}renderPre(t,e){return this.invokeChildren(t,e,"renderPre").map(t=>B(t)).reduce(j,{agentIDs:[],asynchronousY:null,topShift:0})}render(t,e){const n=e.makeRegion;let s=0;return t.stages.forEach(t=>{e.makeRegion=((e={})=>n(Object.assign({stageOverride:t},e)));const r=e.components.get(t.type).render(t,e)||0;s=Math.max(s,r)}),e.makeRegion=n,s}renderHidden(t,e){this.invokeChildren(t,e,"renderHidden")}shouldHide(t,e){return this.invokeChildren(t,e,"shouldHide").reduce((t,{self:e=!1,nest:n=0}={})=>({nest:t.nest+n,self:t.self||Boolean(e)}),{nest:0,self:!1})}}V("parallel",new Ge);class Ie{constructor(t){this.element=t}addBefore(t=null,e=null){if(null===t)return this;if(Array.isArray(t))for(const n of t)this.addBefore(n,e);else{const n=function(t,e){return"string"==typeof t?e.createTextNode(t):"number"==typeof t?e.createTextNode(t.toString(10)):"object"==typeof t&&t.element?t.element:t}(t,this.element.ownerDocument);this.element.insertBefore(n,q(e))}return this}add(...t){return this.addBefore(t,null)}del(t=null){return null!==t&&this.element.removeChild(q(t)),this}attr(t,e){return this.element.setAttribute(t,e),this}attrs(t){for(const e in t)Object.prototype.hasOwnProperty.call(t,e)&&this.element.setAttribute(e,t[e]);return this}styles(t){for(const e in t)Object.prototype.hasOwnProperty.call(t,e)&&(this.element.style[e]=t[e]);return this}setClass(t){return this.attr("class",t)}addClass(t){const e=this.element.getAttribute("class");if(!e)return this.setClass(t);const n=e.split(" ");return n.includes(t)?this:(n.push(t),this.attr("class",n.join(" ")))}delClass(t){const e=this.element.getAttribute("class");if(!e)return this;const n=e.split(" "),s=n.indexOf(t);return-1!==s&&(n.splice(s,1),this.attr("class",n.join(" "))),this}text(t){return this.element.textContent=t,this}on(t,e,n={}){if(Array.isArray(t))for(const s of t)this.on(s,e,n);else this.element.addEventListener(t,e,n);return this}off(t,e,n={}){if(Array.isArray(t))for(const s of t)this.off(s,e,n);else this.element.removeEventListener(t,e,n);return this}val(t){return this.element.value=t,this}select(t,e=null){return this.element.selectionStart=t,this.element.selectionEnd=null===e?t:e,this}focus(){return this.element.focus(),this}focussed(){return this.element===this.element.ownerDocument.activeElement}empty(){for(;this.element.childNodes.length>0;)this.element.removeChild(this.element.lastChild);return this}attach(t){return q(t).appendChild(this.element),this}detach(){return this.element.parentNode.removeChild(this.element),this}}class De{constructor(t){if(!t)throw new Error("Missing document!");this.document=t,this.wrap=this.wrap.bind(this),this.el=this.el.bind(this),this.txt=this.txt.bind(this)}wrap(t){return t.element?t:new Ie(t)}el(t,e=null){let n=null;return n=null===e?this.document.createElement(t):this.document.createElementNS(e,t),new Ie(n)}txt(t=""){return this.document.createTextNode(t)}}const Le=[];class Ne{constructor(t,e,n={}){this.container=t,this.svg=e,this.state={attrs:{},formatted:Le,x:0,y:0},this.lines=[],this.set(n)}_rebuildLines(t){if(t>this.lines.length)for(;this.lines.length<t;)this.lines.push({latest:"",node:this.svg.el("text").attr("x",this.state.x).attrs(this.state.attrs).attach(this.container)});else for(;this.lines.length>t;)this.lines.pop().node.detach()}_reset(){this._rebuildLines(0)}_renderText(){const{formatted:t}=this.state;if(t&&t.length){if(!Array.isArray(t))throw new Error("Invalid formatted text: "+t);this._rebuildLines(t.length),this.lines.forEach((e,n)=>{const s=JSON.stringify(t[n]);s!==e.latest&&(e.node.empty(),Y(this.svg,e.node,t[n]),e.latest=s)})}else this._reset()}_updateX(){this.lines.forEach(({node:t})=>{t.attr("x",this.state.x)})}_updateY(){const t=this.svg.textSizer;let e=this.state.y;for(let n=0;n<this.lines.length;++n){const s=[this.state.formatted[n]],r=t.baseline(this.state.attrs,s);this.lines[n].node.attr("y",e+r),e+=t.measureHeight(this.state.attrs,s)}}set(t){const e=Object.assign({},this.state);!function(t,e){for(const n in t)Object.prototype.hasOwnProperty.call(t,n)&&null!==e[n]&&void 0!==e[n]&&(t[n]=e[n])}(this.state,t),this.state.attrs!==e.attrs&&(this._reset(),e.formatted=Le);const n=this.lines.length;this.state.formatted!==e.formatted&&this._renderText(),this.state.x!==e.x&&this._updateX(),this.state.y===e.y&&this.lines.length===n||this._updateY()}}class ze{constructor(t){this.svg=t,this.testers=this.svg.el("g").attrs({display:xt?"block":"none",visibility:"hidden"}),this.container=t.body}baseline({attrs:t}){return Number(t["font-size"])}measureHeight({attrs:t,formatted:e}){const n=this.baseline({attrs:t,formatted:e})*(Number(t["line-height"])||1);return e.length*n}prepMeasurement(t,e){const n=this.svg.el("text").attrs(t).attach(this.testers);return Y(this.svg,n,e),n}prepComplete(){this.container.add(this.testers)}performMeasurement(t){return t.element.getComputedTextLength()}teardown(){this.container.del(this.testers.empty())}}class Oe{constructor(t=null,e=0){this.pattern=t,this.dw=t&&t.partWidth,this.points=[],this.phase=e,this.x=null,this.y=null,this.disconnect=0}_nextDelta(){return this.pattern.getDelta(this.phase++)}_link(){2===this.disconnect&&(this.points.push(this.x+" "+this.y),this.disconnect=0)}cap(){return this.disconnect>0&&(this.points.push(this.x+" "+this.y),this.disconnect=0),this}move(t,e){return this.cap(),this.x=t,this.y=e,this.disconnect=2,this}line(t,e,{patterned:n=!0}={}){if(this.pattern&&n){const n=Math.sqrt((t-this.x)*(t-this.x)+(e-this.y)*(e-this.y)),s=(t-this.x)/n,r=(e-this.y)/n,i=-r,a=s;for(let t=0;t+this.dw<=n;t+=this.dw){const e=this._nextDelta();this.points.push(this.x+t*s+e*i+" "+(this.y+t*r+e*a))}this.disconnect=1}else this._link(),this.disconnect=2;return this.x=t,this.y=e,this}arc(t,e,n){const s=Math.sqrt((t-this.x)*(t-this.x)+(e-this.y)*(e-this.y)),r=Math.atan2(this.x-t,e-this.y),i=t+Math.sin(r+n)*s,a=e-Math.cos(r+n)*s;if(this.pattern){const i=n<0?1:-1,a=this.dw/s;for(let o=r;o+a<=r+n;o+=a){const n=this._nextDelta()*i;this.points.push(t+Math.sin(o)*(s+n)+" "+(e-Math.cos(o)*(s+n)))}this.disconnect=1}else this.points.push(this.x+" "+this.y+"A"+s+" "+s+" 0 "+(Math.abs(n)>=Math.PI?"1 ":"0 ")+(n<0?"0 ":"1 ")+i+" "+a),this.disconnect=0;return this.x=i,this.y=a,this}asPath(){return this._link(),"M"+this.points.join("L")}}const Be="http://www.w3.org/2000/svg";class Ve{constructor(t){this.sizer=t,this.cache=new Map,this.active=null}_expectMeasure({attrs:t,formatted:e}){if(!e.length)return null;const n=JSON.stringify(t);let s=this.cache.get(n);return s||(s={attrs:t,lines:new Map},this.cache.set(n,s)),e.forEach(t=>{if(!t.length)return;const e=JSON.stringify(t);s.lines.has(e)||s.lines.set(e,{formatted:t,width:null})}),s}_measureLine(t,e){if(!e.length)return 0;const n=JSON.stringify(e),s=t.lines.get(n);return null===s.width&&(window.console.warn("Performing unexpected measurement",e),this.performMeasurements()),s.width}_measureWidth(t){if(!t.formatted.length)return 0;const e=this._expectMeasure(t);return t.formatted.map(t=>this._measureLine(e,t)).reduce((t,e)=>Math.max(t,e),0)}_getMeasurementOpts(t,e){const n={attrs:t,formatted:e};if(e||(t.textBlock?(n.attrs=t.textBlock.state.attrs,n.formatted=t.textBlock.state.formatted):t.state&&(n.attrs=t.state.attrs,n.formatted=t.state.formatted),n.formatted=n.formatted||[]),!Array.isArray(n.formatted))throw new Error("Invalid formatted text: "+n.formatted);return n}expectMeasure(t,e){const n=this._getMeasurementOpts(t,e);this._expectMeasure(n)}performMeasurementsPre(){this.active=[],this.cache.forEach(({attrs:t,lines:e})=>{e.forEach(e=>{null===e.width&&this.active.push({cacheLine:e,data:this.sizer.prepMeasurement(t,e.formatted)})})}),this.active.length&&this.sizer.prepComplete()}performMeasurementsAct(){this.active.forEach(({data:t,cacheLine:e})=>{e.width=this.sizer.performMeasurement(t)})}performMeasurementsPost(){this.active.length&&this.sizer.teardown(),this.active=null}performMeasurements(){try{this.performMeasurementsPre(),this.performMeasurementsAct()}finally{this.performMeasurementsPost()}}measure(t,e){const n=this._getMeasurementOpts(t,e);return{height:this.sizer.measureHeight(n),width:this._measureWidth(n)}}baseline(t,e){const n=this._getMeasurementOpts(t,e);return this.sizer.baseline(n)}measureHeight(t,e){const n=this._getMeasurementOpts(t,e);return this.sizer.measureHeight(n)}resetCache(){this.cache.clear()}}class He{constructor(t,e=null){this.dom=t,this.body=this.el("svg").attr("xmlns",Be).attr("version","1.1");const n=e||(t=>new ze(t));this.textSizer=new Ve(n(this)),this.txt=this.txt.bind(this),this.el=this.el.bind(this)}linearGradient(t,e){return this.el("linearGradient").attrs(t).add(e.map(t=>this.el("stop").attrs(t)))}patternedLine(t=null,e=0){return new Oe(t,e)}txt(t){return this.dom.txt(t)}el(t,e=Be){return this.dom.el(t,e)}box(t,{height:e,width:n,x:s,y:r}){return this.el("rect").attrs(t).attrs({height:e,width:n,x:s,y:r})}boxFactory(t){return this.box.bind(this,t)}line(t,{x1:e,x2:n,y1:s,y2:r}){return this.el("line").attrs(t).attrs({x1:e,x2:n,y1:s,y2:r})}lineFactory(t){return this.line.bind(this,t)}circle(t,{x:e,y:n,radius:s}){return this.el("circle").attrs({cx:e,cy:n,r:s}).attrs(t)}circleFactory(t){return this.circle.bind(this,t)}cross(t,{x:e,y:n,radius:s}){return this.el("path").attr("d","M"+(e-s)+" "+(n-s)+"l"+2*s+" "+2*s+"m0 "+2*-s+"l"+2*-s+" "+2*s).attrs(t)}crossFactory(t){return this.cross.bind(this,t)}note(t,e,{height:n,width:s,x:r,y:i}){const a=r,o=r+s,h=i,l=i+n;return this.el("g").add(this.el("polygon").attr("points",a+" "+h+" "+(o-7)+" "+h+" "+o+" "+(h+7)+" "+o+" "+l+" "+a+" "+l).attrs(t),this.el("polyline").attr("points",o-7+" "+h+" "+(o-7)+" "+(h+7)+" "+o+" "+(h+7)).attrs(e))}noteFactory(t,e){return this.note.bind(this,t,e)}formattedText(t={},e=[],{x:n,y:s}={}){const r=this.el("g"),i=new Ne(r,this,{attrs:t,formatted:e,x:n,y:s});return Object.assign(r,{set:t=>i.set(t),textBlock:i})}formattedTextFactory(t){return this.formattedText.bind(this,t)}boxedText({padding:t,labelAttrs:e,boxAttrs:n={},boxRenderer:s=null},r,{x:i,y:a}){if(!r||!r.length)return Object.assign(this.el("g"),{box:null,height:0,label:null,width:0});const{shift:o,anchorX:h}=function(t,e,n){let s=0,r=t;switch(e["text-anchor"]){case"middle":s=.5,r+=(n.left-n.right)/2;break;case"end":s=1,r-=n.right;break;default:s=0,r+=n.left}return{anchorX:r,shift:s}}(i,e,t),l=this.formattedText(e,r,{x:h,y:a+t.top}),d=this.textSizer.measure(l),g=d.width+t.left+t.right,c=d.height+t.top+t.bottom,u=(s||this.boxFactory(n))({height:c,width:g,x:h-d.width*o-t.left,y:a});return Object.assign(this.el("g").add(u,l),{box:u,height:c,label:l,width:g})}boxedTextFactory(t){return this.boxedText.bind(this,t)}}let Te=0;class Pe extends mt{constructor({themes:t=[],namespace:e=null,components:n=null,document:s,textSizerFactory:r=null}={}){super(),this._bindMethods(),this.state={},this.width=0,this.height=0,this.themes=function(t){if(0===t.length)throw new Error("Cannot render without a theme");const e=new Map;return t.forEach(t=>{e.set(t.name,t)}),e.set("",t[0]),e}(t),this.themeBuilder=null,this.theme=null,this.namespace=function(t){return null===t?"R"+Te++:t}(e),this.components=n||H(),this.svg=new He(new De(s),r),this.knownThemeDefs=new Set,this.knownDefs=new Set,this.highlights=new Map,this.collapsed=new Set,this.currentHighlight=-1,this.buildStaticElements(),this.components.forEach(t=>{t.makeState(this.state)})}_bindMethods(){this.separationStage=this.separationStage.bind(this),this.prepareMeasurementsStage=this.prepareMeasurementsStage.bind(this),this.renderStage=this.renderStage.bind(this),this.addThemeDef=this.addThemeDef.bind(this),this.addDef=this.addDef.bind(this)}addTheme(t){this.themes.set(t.name,t)}buildStaticElements(){const{el:t}=this.svg;this.metaCode=this.svg.txt(),this.themeDefs=t("defs"),this.defs=t("defs"),this.fullMask=t("mask").attrs({id:this.namespace+"FullMask",maskUnits:"userSpaceOnUse"}),this.lineMask=t("mask").attrs({id:this.namespace+"LineMask",maskUnits:"userSpaceOnUse"}),this.fullMaskReveal=t("rect").attr("fill","#FFFFFF"),this.lineMaskReveal=t("rect").attr("fill","#FFFFFF"),this.backgroundFills=t("g"),this.agentLines=t("g").attr("mask","url(#"+this.namespace+"LineMask)"),this.blocks=t("g"),this.shapes=t("g"),this.unmaskedShapes=t("g"),this.title=this.svg.formattedText(),this.svg.body.add(this.svg.el("metadata").add(this.metaCode),this.themeDefs,this.defs,this.backgroundFills,t("g").attr("mask","url(#"+this.namespace+"FullMask)").add(this.agentLines,this.blocks,this.shapes),this.unmaskedShapes,this.title)}addThemeDef(t,e){const n=this.namespace+t;return this.knownThemeDefs.has(t)||(this.knownThemeDefs.add(t),this.themeDefs.add(e().attr("id",n))),n}addDef(t,e){let n=t,s=e;"function"!=typeof e&&(n="P"+this.knownDefs.size,s=(()=>t));const r=this.namespace+n;return this.knownDefs.has(n)||(this.knownDefs.add(n),this.defs.add(s().attr("id",r))),r}addSeparation(t,e,n){const s=this.agentInfos.get(t),r=this.agentInfos.get(e),i=s.separations.get(e)||0;s.separations.set(e,Math.max(i,n));const a=r.separations.get(t)||0;r.separations.set(t,Math.max(a,n))}checkHidden(t){const e=this.components.get(t.type),n={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},s=e.shouldHide(t,n)||{},r=this.hideNest>0;this.hideNest+=s.nest||0;const i=this.hideNest>0;if(this.hideNest<0)throw new Error("Unexpected nesting in "+t.type);return r===i?i:Boolean(s.self)}separationStage(t){const n=new Map,s=this.visibleAgentIDs.slice(),r=[];this.agentInfos.forEach(t=>{const e=t.currentRad;t.currentMaxRad=e,n.set(t.id,{left:e,right:e})});const i={addSeparation:(t,e,n)=>{r.push({agentID1:t,agentID2:e,dist:n})},addSpacing:(t,{left:e,right:s})=>{const r=n.get(t);r.left=Math.max(r.left,e),r.right=Math.max(r.right,s)},agentInfos:this.agentInfos,components:this.components,momentaryAgentIDs:s,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme,visibleAgentIDs:this.visibleAgentIDs},a=this.components.get(t.type);if(!a)throw new Error("Unknown component: "+t.type);a.separationPre(t,i),a.separation(t,i),this.checkHidden(t)||(e(s,this.visibleAgentIDs),r.forEach(({agentID1:t,agentID2:e,dist:n})=>{this.addSeparation(t,e,n)}),s.forEach(t=>{const e=this.agentInfos.get(t),r=n.get(t);e.maxRPad=Math.max(e.maxRPad,r.right),e.maxLPad=Math.max(e.maxLPad,r.left),s.forEach(s=>{if(this.agentInfos.get(s).index>=e.index)return;const i=n.get(s);this.addSeparation(t,s,r.left+i.right+this.theme.agentMargin)})}))}prepareMeasurementsStage(t){const e={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},n=this.components.get(t.type);if(!n)throw new Error("Unknown component: "+t.type);n.prepareMeasurements(t,e)}checkAgentRange(t,e=0){if(0===t.length)return e;const{left:n,right:s}=W(this.agentInfos,t),r=this.agentInfos.get(n).x,i=this.agentInfos.get(s).x;let a=e;return this.agentInfos.forEach(t=>{t.x>=r&&t.x<=i&&(a=Math.max(a,t.latestY))}),a}markAgentRange(t,e){if(0===t.length)return;const{left:n,right:s}=W(this.agentInfos,t),r=this.agentInfos.get(n).x,i=this.agentInfos.get(s).x;this.agentInfos.forEach(t=>{t.x>=r&&t.x<=i&&(t.latestY=e)})}drawAgentLine(t,e){null!==t.latestYStart&&e>t.latestYStart&&this.agentLines.add(this.theme.renderAgentLine({className:"agent-"+t.index+"-line",options:t.options,width:2*t.currentRad,x:t.x,y0:t.latestYStart,y1:e}))}addHighlightObject(t,e){let n=this.highlights.get(t);n||(n=[],this.highlights.set(t,n)),n.push(e)}forwardEvent(t,e,n,s){t.on(e,this.trigger.bind(this,n,s))}renderStage(t){this.agentInfos.forEach(t=>{const e=t.currentRad;t.currentMaxRad=e});const e={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},n=this.components.get(t.type),s=n.renderPre(t,e),{agentIDs:r,topShift:i,asynchronousY:a}=B(s,this.currentY),o=this.checkAgentRange(r,a),h={addDef:this.addDef,agentInfos:this.agentInfos,blockLayer:this.blocks,components:this.components,drawAgentLine:(t,e,n=!1)=>{const s=this.agentInfos.get(t);this.drawAgentLine(s,e),s.latestYStart=n?null:e},fillLayer:this.backgroundFills,fullMaskLayer:this.fullMask,lineMaskLayer:this.lineMask,makeRegion:({stageOverride:e=null,unmasked:n=!1}={})=>{const s=this.svg.el("g").setClass("region"),r=e||t;return this.addHighlightObject(r.ln,s),this.forwardEvent(s,"mouseenter","mouseover",[r]),this.forwardEvent(s,"mouseleave","mouseout",[r]),this.forwardEvent(s,"click","click",[r]),this.forwardEvent(s,"dblclick","dblclick",[r]),s.attach(n?this.unmaskedShapes:this.shapes)},primaryY:o+i,renderer:this,state:this.state,svg:this.svg,textSizer:this.svg.textSizer,theme:this.theme,topY:o};let l=o;this.checkHidden(t)?(h.primaryY=o,n.renderHidden(t,h)):l=Math.max(l,n.render(t,h)||0),this.markAgentRange(r,l),this.currentY=l}positionAgents(){const t=[];this.agentInfos.forEach(e=>{let n=0;e.separations.forEach((t,s)=>{const r=this.agentInfos.get(s);r.index<e.index&&(n=Math.max(n,r.x+t))}),e.x=n,t.push(e)});let e={x:0};t.reverse().forEach(t=>{let n=e.x;e=t,t.anchorRight&&(t.separations.forEach((e,s)=>{const r=this.agentInfos.get(s);r.index>t.index&&(n=Math.min(n,r.x-e))}),t.x=n)}),this.agentInfos.forEach(({x:t,maxRPad:e,maxLPad:n})=>{this.minX=Math.min(this.minX,t-n),this.maxX=Math.max(this.maxX,t+e)})}buildAgentInfos(t){this.agentInfos=new Map,t.forEach((t,e)=>{this.agentInfos.set(t.id,{anchorRight:t.anchorRight,currentMaxRad:0,currentRad:0,formattedLabel:t.formattedLabel,id:t.id,index:e,isVirtualSource:t.isVirtualSource,latestY:0,latestYStart:null,maxLPad:0,maxRPad:0,options:t.options,separations:new Map,x:null})})}updateBounds(t){const e=(this.minX+this.maxX)/2,n=this.svg.textSizer.measure(this.title),s=n.height>0?-this.theme.titleMargin-n.height:0;this.title.set({x:e,y:s});const r=n.width/2,i=this.theme.outerMargin,a=Math.min(this.minX,e-r)-i,o=Math.max(this.maxX,e+r)+i,h=s-i,l=t+i;this.width=o-a,this.height=l-h;const d={height:this.height,width:this.width,x:a,y:h};this.fullMaskReveal.attrs(d),this.lineMaskReveal.attrs(d),this.svg.body.attr("viewBox",a+" "+h+" "+this.width+" "+this.height)}_resetState(){this.components.forEach(t=>{t.resetState(this.state)}),this.currentY=0,this.hideNest=0}_reset(t){t&&(this.knownThemeDefs.clear(),this.themeDefs.empty()),this.knownDefs.clear(),this.highlights.clear(),this.defs.empty(),this.fullMask.empty(),this.lineMask.empty(),this.backgroundFills.empty(),this.agentLines.empty(),this.blocks.empty(),this.shapes.empty(),this.unmaskedShapes.empty(),this.defs.add(this.fullMask.add(this.fullMaskReveal),this.lineMask.add(this.lineMaskReveal)),this._resetState()}setHighlight(t=null){const e=null===t?-1:t;this.currentHighlight!==e&&(this.highlights.has(this.currentHighlight)&&this.highlights.get(this.currentHighlight).forEach(t=>{t.delClass("focus")}),this.highlights.has(e)&&this.highlights.get(e).forEach(t=>{t.addClass("focus")}),this.currentHighlight=e)}isCollapsed(t){return this.collapsed.has(t)}setCollapseAll(t){if(t)throw new Error("Cannot collapse all");return 0!==this.collapsed.size&&(this.collapsed.clear(),!0)}_setCollapsed(t,e){return"number"==typeof t&&(e!==this.isCollapsed(t)&&(e?this.collapsed.add(t):this.collapsed.delete(t),!0))}setCollapsed(t,e=!0){return null===t?this.setCollapseAll(e):Array.isArray(t)?t.map(t=>this._setCollapsed(t,e)).some(t=>t):this._setCollapsed(t,e)}_switchTheme(t){const e=this.themeBuilder;return this.themeBuilder=this.getThemeNamed(t),this.themeBuilder!==e&&(this.theme=this.themeBuilder.build(this.svg)),this.theme.reset(),this.themeBuilder!==e}optimisedRenderPreReflow(t){const e=this._switchTheme(t.meta.theme);this._reset(e),this.metaCode.nodeValue=t.meta.code,this.theme.addDefs(this.addThemeDef),this.title.set({attrs:this.theme.titleAttrs,formatted:t.meta.title}),this.svg.textSizer.expectMeasure(this.title),this.minX=0,this.maxX=0,this.buildAgentInfos(t.agents),t.stages.forEach(this.prepareMeasurementsStage),this._resetState(),this.svg.textSizer.performMeasurementsPre()}optimisedRenderReflow(){this.svg.textSizer.performMeasurementsAct()}optimisedRenderPostReflow(t){this.visibleAgentIDs=["[","]"],t.stages.forEach(this.separationStage),this._resetState(),this.positionAgents(),t.stages.forEach(this.renderStage);const e=this.checkAgentRange(["[","]"],this.currentY),n=Math.max(e-this.theme.actionMargin,0);this.updateBounds(n);const s=this.currentHighlight;this.currentHighlight=-1,this.setHighlight(s),this.svg.textSizer.performMeasurementsPost(),this.svg.textSizer.resetCache()}render(t){this.optimisedRenderPreReflow(t),this.optimisedRenderReflow(),this.optimisedRenderPostReflow(t)}getThemeNames(){return Array.from(this.themes.keys()).filter(t=>""!==t)}getThemes(){return this.getThemeNames().map(t=>this.themes.get(t))}getThemeNamed(t){const e=this.themes.get(t);return e||this.themes.get("")}getAgentX(t){return this.agentInfos.get(t).x}dom(){return this.svg.body.element}}var je={name:"Handlee",woff2:"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"};class qe{constructor(){this.s=new Uint32Array(4)}reset(){this.s[0]=394173556,this.s[1]=2926575054,this.s[2]=1022685995,this.s[3]=1178902408}nextFloat(){let t=this.s[0],e=this.s[1];const n=this.s[2],s=this.s[3];return this.s[0]=n,this.s[1]=s,t^=t<<23|e>>>9,e^=e<<23,this.s[2]=t^n^t>>>17^n>>>26,this.s[3]=e^s^(t<<15|e>>>17)^(n<<6|s>>>26),(this.s[3]+s>>>0)%4294967296/4294967296}}const Ye=je.name,We="'"+Ye+"',cursive",Ue={normal:{stroke:"rgba(0,0,0,0.7)","stroke-width":.8,"stroke-linejoin":"round","stroke-linecap":"round"},thick:{stroke:"rgba(0,0,0,0.8)","stroke-width":1.2,"stroke-linejoin":"round","stroke-linecap":"round"}},Xe={"font-family":We,"font-size":8,"line-height":1.5},Qe={"font-family":We,"font-size":8,"line-height":1.5,"text-anchor":"middle"},Je={};class Ze{constructor(t,e){this.deltas=[0,-.3,-.6,-.75,-.45,0,.45,.75,.6,.3],e!==Je&&this.deltas.reverse(),this.partWidth=6/this.deltas.length}getDelta(t){return this.deltas[t%this.deltas.length]+.5*Math.sin(.03*t)}}class Ke extends st{constructor(t,e=Je){super(t),this.handedness=e===Je?1:-1,this.random=new qe,this.wave=new Ze(4,e);const n={padding:{top:3,bottom:2},tag:{padding:{top:2,left:3,right:5,bottom:0},boxRenderer:this.renderTag.bind(this),labelAttrs:{"font-family":We,"font-weight":"bold","font-size":9,"line-height":1.5,"text-anchor":"left"}},label:{minHeight:6,padding:{top:2,left:5,right:3,bottom:1},labelAttrs:{"font-family":We,"font-size":8,"line-height":1.5,"text-anchor":"left"}}};Object.assign(this,{titleMargin:10,outerMargin:5,agentMargin:10,actionMargin:10,minActionMargin:3,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:5,left:10,right:10,bottom:5},arrowBottom:12.8,labelAttrs:{"font-family":We,"font-size":12,"line-height":1.5,"text-anchor":"middle"},boxRenderer:this.renderBox.bind(this)},database:{padding:{top:12,left:10,right:10,bottom:2},arrowBottom:12.8,boxRenderer:this.renderDB.bind(this,Object.assign({fill:"#FFFFFF","db-z":5},Ue.normal)),labelAttrs:{"font-family":Ye,"font-size":12,"line-height":1.5,"text-anchor":"middle"}},cross:{size:15,render:this.renderCross.bind(this)},bar:{height:6,render:this.renderBar.bind(this)},fade:{width:Math.ceil(12),height:6,extend:Math.ceil(2.5)},none:{height:10}},connect:{loopbackRadius:6,line:{solid:{attrs:Object.assign({fill:"none"},Ue.normal),renderFlat:this.renderFlatConnect.bind(this),renderRev:this.renderRevConnect.bind(this)},dash:{attrs:Object.assign({fill:"none","stroke-dasharray":"4, 2"},Ue.normal),renderFlat:this.renderFlatConnect.bind(this),renderRev:this.renderRevConnect.bind(this)},wave:{attrs:Object.assign({fill:"none","stroke-linejoin":"round","stroke-linecap":"round"},Ue.normal),renderFlat:this.renderFlatConnectWave.bind(this),renderRev:this.renderRevConnectWave.bind(this)}},arrow:{single:{width:5,height:6,attrs:Object.assign({fill:"rgba(0,0,0,0.9)"},Ue.normal),render:this.renderArrowHead.bind(this)},double:{width:4,height:8,attrs:Object.assign({fill:"none"},Ue.normal),render:this.renderArrowHead.bind(this)},cross:{short:5,radius:3,render:this.renderCross.bind(this)}},label:{padding:6,margin:{top:2,bottom:1},attrs:{"font-family":We,"font-size":8,"line-height":1.5,"text-anchor":"middle"},loopbackAttrs:{"font-family":We,"font-size":8,"line-height":1.5}},source:{radius:1,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":We,"font-size":20,"line-height":1.5,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":Object.assign({fill:"none"},Ue.normal),red:{stroke:"rgba(200,40,0,0.8)"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRefBlock.bind(this),section:n},"":{margin:{top:0,bottom:0},boxRenderer:this.renderBlock.bind(this),collapsedBoxRenderer:this.renderMinBlock.bind(this),section:n,sepRenderer:this.renderSeparator.bind(this)}},notes:{text:{margin:{top:0,left:6,right:6,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:Xe},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:5,right:10,bottom:5},overlap:{left:10,right:10},boxRenderer:this.renderNote.bind(this),labelAttrs:Xe},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:7,left:7,right:7,bottom:7},overlap:{left:10,right:10},boxRenderer:this.renderState.bind(this),labelAttrs:Xe}},dividers:{"":{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this)},delay:{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:1,gapSize:2})},tear:{labelAttrs:Qe,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,pattern:this.wave,lineAttrs:Ue.normal})}}})}reset(){this.random.reset()}addDefs(t){t("sketch_font",()=>{const t=this.svg.el("style",null);return t.text('@font-face{font-family:"'+je.name+'";src:url("data:font/woff2;base64,'+je.woff2+'");}'),t})}vary(t,e=0){if(!t)return e;const n=this.random.nextFloat();return e+2*Math.asin(2*n-1)*t/Math.PI}lineNodes(t,e,{var1:n=1,var2:s=1,varX:r=1,varY:i=1,move:a=!0}){const o=Math.sqrt((e.x-t.x)*(e.x-t.x)+(e.y-t.y)*(e.y-t.y)),h=Math.min(.2*Math.sqrt(o),5),l=this.vary(n*r*h,t.x),d=this.vary(n*i*h,t.y),g=this.vary(s*r*h,e.x),c=this.vary(s*i*h,e.y),u=function(t,e,n){return Math.max(e,Math.min(n,t))}((d-c)/(Math.abs(l-g)+.001),-1,1)/6+.5,p=this.vary(.5,.5)*h,f=this.vary(.5,.5)*h,m=l*(1-u)+g*u-p*this.handedness;return{nodes:(a?"M"+l+" "+d:"")+"C"+m+" "+(d*(1-u)+c*u-f)+","+g+" "+c+","+g+" "+c,p1:{x:l,y:d},p2:{x:g,y:c}}}renderLine(t,e,n){const s=this.lineNodes(t,e,n);return this.svg.el("path").attrs({d:s.nodes,fill:"none","stroke-dasharray":n.dash?"6, 5":"none"}).attrs(n.attrs||(n.thick?Ue.thick:Ue.normal))}boxNodes({x:t,y:e,width:n,height:s}){const r=this.lineNodes({x:t,y:e},{x:t+n,y:e},{}),i=this.lineNodes({x:t+n,y:e+s},{x:t,y:e+s},{move:!1}),a=this.lineNodes(r.p2,i.p1,{var1:0,var2:0,move:!1}),o=this.lineNodes(i.p2,r.p1,{var1:0,var2:.3,move:!1});return r.nodes+a.nodes+i.nodes+o.nodes}renderBox(t,{fill:e=null,thick:n=!1,attrs:s=null}={}){return this.svg.el("path").attrs({d:this.boxNodes(t),fill:e||"#FFFFFF"}).attrs(s||(n?Ue.thick:Ue.normal))}renderNote({x:t,y:e,width:n,height:s}){const r=this.lineNodes({x:t,y:e},{x:t+n-5,y:e},{}),i=this.lineNodes(r.p2,{x:t+n,y:e+5},{move:!1,var1:0}),a=this.lineNodes({x:t+n,y:e+s},{x:t,y:e+s},{move:!1}),o=this.lineNodes(i.p2,a.p1,{var1:0,var2:0,move:!1}),h=this.lineNodes(a.p2,r.p1,{var1:0,var2:.3,move:!1}),l=this.lineNodes(i.p1,{x:t+n-5,y:e+5},{var1:.3}),d=this.lineNodes(l.p2,i.p2,{var1:0,move:!1});return this.svg.el("g").add(this.svg.el("path").attrs({d:r.nodes+i.nodes+o.nodes+a.nodes+h.nodes,fill:"#FFFFFF"}).attrs(Ue.normal),this.svg.el("path").attrs({d:l.nodes+d.nodes,fill:"none"}).attrs(Ue.normal))}renderLineDivider({x:t,y:e,labelWidth:n,width:s,height:r}){let i=null;const a=e+r/2;return i=n>0?this.svg.el("g").add(this.renderLine({x:t,y:a},{x:t+(s-n)/2,y:a},{}),this.renderLine({x:t+(s+n)/2,y:a},{x:t+s,y:a},{})):this.renderLine({x:t,y:a},{x:t+s,y:a},{}),{shape:i}}renderFlatConnect(t,{x1:e,y1:n,x2:s,y2:r}){const i=this.lineNodes({x:e,y:n},{x:s,y:r},{varX:.3});return{shape:this.svg.el("path").attr("d",i.nodes).attrs(t),p1:i.p1,p2:i.p2}}renderRevConnect(t,{x1:e,y1:n,x2:s,y2:r,xR:i}){const a=Math.min(.06*(i-e),3),o=Math.min(.5*(i-e),6),h=e+this.vary(a,-1),l=n+this.vary(a,-1),d=i-o*this.vary(.2,1),g=n-this.vary(1,2),c=i,u=n+this.vary(1,1),p=i,f=r+this.vary(2),m=s+this.vary(a,-1),b=r+this.vary(a,-1);return{shape:this.svg.el("path").attr("d","M"+h+" "+l+"C"+h+" "+l+","+d+" "+g+","+c+" "+u+"S"+p+" "+f+","+m+" "+b).attrs(t),p1:{x:h,y:l},p2:{x:m,y:b}}}renderFlatConnectWave(t,{x1:e,y1:n,x2:s,y2:r}){const i=e+this.vary(.3),a=s+this.vary(.3),o=n+this.vary(1),h=r+this.vary(1);return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(this.wave).move(i,o).line(a,h).cap().asPath()).attrs(t),p1:{x:i,y:o},p2:{x:a,y:h}}}renderRevConnectWave(t,{x1:e,y1:n,x2:s,y2:r,xR:i}){const a=e+this.vary(.3),o=s+this.vary(.3),h=n+this.vary(1),l=r+this.vary(1);return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(this.wave).move(a,h).line(i,n).arc(i,(n+r)/2,Math.PI).line(o,l).cap().asPath()).attrs(t),p1:{x:a,y:h},p2:{x:o,y:l}}}renderArrowHead(t,{x:e,y:n,width:s,height:r,dir:i}){const a=s*this.vary(.2,1),o=r*this.vary(.3,1),h=a*i.dx,l=a*i.dy,d=.5*o*i.dx,g=.5*-o*i.dy,c=this.lineNodes({x:e+h-g,y:n+l-d},{x:e,y:n},{var1:2,var2:.2}),u=this.lineNodes(c.p2,{x:e+h+g,y:n+l+d},{var1:0,var2:2,move:!1}),p="none"===t.fill?{nodes:""}:this.lineNodes(u.p2,c.p1,{var1:0,var2:0,move:!1});return this.svg.el("path").attr("d",c.nodes+u.nodes+p.nodes).attrs(t)}renderState({x:t,y:e,width:n,height:s}){const r=Math.min(.06*n,3),i=Math.min(.06*s,3),a=t+r*this.vary(.6,1),o=e+i*this.vary(.6,1),h=t+n-r*this.vary(.6,1),l=e+i*this.vary(.6,1),d=t+r*this.vary(.6,1),g=e+s-i*this.vary(.6,1),c=t+n-r*this.vary(.6,1),u=e+s-i*this.vary(.6,1),p=t+n/2,f=e+s/2,m=r*this.vary(.2,1.2),b=i*this.vary(.2,1.2),y=e-Math.min(.005*n,1),x=e+s-Math.min(.01*n,2),k=t-Math.min(.01*s,2)*this.handedness,w=k+n;return this.svg.el("path").attr("d","M"+a+" "+o+"C"+(a+m)+" "+(o-b)+","+(p-n*this.vary(.03,.3))+" "+y+","+p+" "+y+"S"+(h-m)+" "+(l-b)+","+h+" "+l+"S"+w+" "+(f-s*this.vary(.03,.3))+","+w+" "+f+"S"+(c+m)+" "+(u-b)+","+c+" "+u+"S"+(p+n*this.vary(.03,.3))+" "+x+","+p+" "+x+"S"+(d+m)+" "+(g+b)+","+d+" "+g+"S"+k+" "+(f+s*this.vary(.03,.3))+","+k+" "+f+"S"+(a-m)+" "+(o+b)+","+a+" "+o+"Z").attr("fill","#FFFFFF").attrs(Ue.normal)}renderRefBlock(t){const e=this.boxNodes(t);return{shape:this.svg.el("path").attrs({d:e,fill:"none"}).attrs(Ue.thick),mask:this.svg.el("path").attrs({d:e,fill:"#000000"}),fill:this.svg.el("path").attrs({d:e,fill:"#FFFFFF"})}}renderBlock(t){return this.renderBox(t,{fill:"none",thick:!0})}renderMinBlock(t){return this.renderRefBlock(t)}renderTag({x:t,y:e,width:n,height:s}){const r=t+n,i=e+s,a=this.lineNodes({x:r+3,y:e},{x:r-2,y:i},{}),o=this.lineNodes(a.p2,{x:t,y:i+1},{var1:0,move:!1}),h=a.nodes+o.nodes;return this.svg.el("g").add(this.svg.el("path").attrs({d:h+"L"+t+" "+e,fill:"#FFFFFF"}),this.svg.el("path").attrs({d:h,fill:"#FFFFFF"}).attrs(Ue.normal))}renderSeparator({x1:t,y1:e,x2:n,y2:s}){return this.renderLine({x:t,y:e},{x:n,y:s},{thick:!0,dash:!0})}renderBar({x:t,y:e,width:n,height:s}){return this.renderBox({x:t,y:e,width:n,height:s},{fill:"#000000"})}renderCross({x:t,y:e,radius:n}){const s=this.vary(.2,1)*n,r=this.lineNodes({x:t-s,y:e-s},{x:t+s,y:e+s},{}),i=this.vary(.2,1)*n,a=this.lineNodes({x:t+i,y:e-i},{x:t-i,y:e+i},{});return this.svg.el("path").attrs({d:r.nodes+a.nodes,fill:"none"}).attrs(Ue.normal)}renderAgentLine({x:t,y0:e,y1:n,width:s,className:r,options:i}){const a=this.optionsAttributes(this.agentLineAttrs,i);return s>0?this.renderBox({x:t-s/2,y:e,width:s,height:n-e},{fill:"none",attrs:a}).setClass(r):this.renderLine({x:t,y:e},{x:t,y:n},{varY:.3,attrs:a}).setClass(r)}}class _e{constructor(t=Je){const e=t===Je;this.name=e?"sketch":"sketch left handed",this.handedness=t}build(t){return new Ke(t,this.handedness)}}Object.assign(_e,{RIGHT:Je,LEFT:{}});const $e=/^([ \t]*)(.*)$/,tn={after:".!+",end:/[ \t\r\n]$/,start:/^[ \t\r\n:,]/},en=/^"(\\.|[^"])*$/,nn=/[\r\n:,"<>\-~]/,sn=/["\\]/g,rn=[new lt,new Lt,new ft,new _e(_e.RIGHT),new _e(_e.LEFT)],an=new _t,on=new Rt,hn=an.getCodeMirrorMode();class ln extends mt{constructor(t=null,e={}){super();let n=null;t&&"object"==typeof t?(n=t,this.code=n.code):(n=e,this.code=t),Object.assign(this,{exporter:new kt,generator:on,isInteractive:!1,latestProcessed:null,parser:an,registerCodeMirrorMode:K,renderer:new Pe(Object.assign({document:function(t){return t?t.ownerDocument||null:"undefined"==typeof window?null:window.document}(n.container),themes:rn},n)),textSizerFactory:n.textSizerFactory||null}),this.renderer.addEventForwarding(this),n.container&&n.container.appendChild(this.dom()),n.interactive&&this.addInteractivity(),"string"==typeof this.code&&!1!==n.render&&this.render()}clone(t={}){const e=t.container||this.renderer.dom();return new ln(Object.assign({code:this.code,components:this.renderer.components,container:null,document:e.ownerDocument,interactive:this.isInteractive,namespace:null,textSizerFactory:this.textSizerFactory,themes:this.renderer.getThemes()},t))}set(t="",{render:e=!0}={}){this.code!==t&&(this.code=t,e&&this.render())}process(t){const e=this.parser.parse(t);return this.generator.generate(e)}addTheme(t){this.renderer.addTheme(t)}setHighlight(t){this.renderer.setHighlight(t)}isCollapsed(t){return this.renderer.isCollapsed(t)}setCollapsed(t,e=!0,{render:n=!0}={}){return!!this.renderer.setCollapsed(t,e)&&(n&&this.latestProcessed&&this.render(this.latestProcessed),!0)}collapse(t,e){return this.setCollapsed(t,!0,e)}expand(t,e){return this.setCollapsed(t,!1,e)}toggleCollapsed(t,e){return this.setCollapsed(t,!this.isCollapsed(t),e)}expandAll(t){return this.setCollapsed(null,!1,t)}getThemeNames(){return this.renderer.getThemeNames()}getThemes(){return this.renderer.getThemes()}getSVGSynchronous(){return this.exporter.getSVGURL(this.renderer)}getSVG(){return Promise.resolve({latest:!0,url:this.getSVGSynchronous()})}getCanvas({resolution:t=1,size:e=null}={}){return e&&(this.renderer.width=e.width,this.renderer.height=e.height),new Promise(e=>{this.exporter.getCanvas(this.renderer,t,e)})}getPNG({resolution:t=1,size:e=null}={}){return e&&(this.renderer.width=e.width,this.renderer.height=e.height),new Promise(e=>{this.exporter.getPNGURL(this.renderer,t,(t,n)=>{e({latest:n,url:t})})})}getSize(){return{height:this.renderer.height,width:this.renderer.width}}_revertParent(t){const e=this.renderer.dom();e.parentNode!==t.originalParent&&(e.parentNode.removeChild(e),t.originalParent&&t.originalParent.appendChild(e))}_sendRenderError(t){this._revertParent(this.renderState),this.renderState.error=!0,this.trigger("error",[this,t])}optimisedRenderPreReflow(t=null){const e=this.renderer.dom();this.renderState={error:!1,originalParent:e.parentNode,processed:t};const n=this.renderState;e.isConnected||(n.originalParent&&n.originalParent.removeChild(e),e.ownerDocument.body.appendChild(e));try{n.processed||(n.processed=this.process(this.code)),this.renderer.optimisedRenderPreReflow(n.processed)}catch(t){this._sendRenderError(t)}}optimisedRenderReflow(){try{this.renderState.error||this.renderer.optimisedRenderReflow()}catch(t){this._sendRenderError(t)}}optimisedRenderPostReflow(){const t=this.renderState;try{t.error||this.renderer.optimisedRenderPostReflow(t.processed)}catch(t){this._sendRenderError(t)}this.renderState=null,t.error||(this._revertParent(t),this.latestProcessed=t.processed,this.trigger("render",[this]))}render(t=null){function e(t,e){n=e}let n=null;if(this.addEventListener("error",e),this.optimisedRenderPreReflow(t),this.optimisedRenderReflow(),this.optimisedRenderPostReflow(),this.removeEventListener("error",e),n)throw n}setContainer(t=null){const e=this.dom();e.parentNode&&e.parentNode.removeChild(e),t&&t.appendChild(e)}addInteractivity(){this.isInteractive||(this.isInteractive=!0,this.addEventListener("click",t=>{this.toggleCollapsed(t.ln)}))}extractCodeFromSVG(t){return _(t)}renderAll(t){return $(t)}dom(){return this.renderer.dom()}}Object.assign(ln,{Exporter:kt,Generator:Rt,Parser:_t,Renderer:Pe,addTheme:function(t){rn.push(t)},convert:et,convertAll:function(t=null,e="sequence-diagram"){let n=null,s=null;"string"==typeof t?(n=null,s=t):(n=t,s=e);let r=null;r=n&&void 0!==n.length?n:(n||window.document).getElementsByClassName(s);const i=[];for(let t=0;t<r.length;++t)i.push(r[t]);et(i)},extractCodeFromSVG:_,getDefaultThemeNames:function(){return rn.map(t=>t.name)},registerCodeMirrorMode:K,renderAll:$,themes:rn});const dn=window.define;dn&&dn.amd?dn(()=>ln):(window.document.addEventListener("DOMContentLoaded",()=>{ln.convertAll()},{once:!0}),window.CodeMirror&&ln.registerCodeMirrorMode(window.CodeMirror),window.SequenceDiagram=ln)}();
\ No newline at end of file
+!function(){"use strict";function t(t,e,n=null){if(null===n)return t.indexOf(e);for(let s=0;s<t.length;++s)if(n(t[s],e))return s;return-1}function e(e,n=null,s=null){if(n)for(let r=0;r<n.length;++r)-1===t(e,n[r],s)&&e.push(n[r])}function n(e,n=null,s=null){if(n)for(let r=0;r<n.length;++r){const i=t(e,n[r],s);-1!==i&&e.splice(i,1)}}function s(e,n,s=null){const r=t(e,n,s);-1!==r&&e.splice(r,1)}function r(t){return t[t.length-1]}function i(t,e,n,s){if(e>=t.length)return void s.push(n.slice());const r=t[e];if(!Array.isArray(r))return n.push(r),i(t,e+1,n,s),void n.pop();for(let a=0;a<r.length;++a)n.push(r[a]),i(t,e+1,n,s),n.pop()}function a(t,e){const n=[];return t.forEach(t=>{n.push(...e(t))}),n}function o(t,e){const n=Ct[t.type];return!(!n||t.type!==e.type)&&!n.check.some(n=>t[n]!==e[n])}function h(t,n){Ct[t.type].merge.forEach(s=>{e(t[s],n[s])})}function l(t,e){for(let n=0;n<t.length;){e(t[n],n)?t.splice(n,1):++n}}function d(t){l(t,(e,n)=>{for(let s=0;s<n;++s)if(o(t[s],e))return h(t[s],e),!0;return!1})}function g(t){const e=new Set,n=t.map(({type:t})=>t);return n.forEach(t=>{const s=Ct[t];s&&n.every(e=>t===e||s.siblings.has(e))&&e.add(t)}),e}function c(t,e,n,s){l(s,s=>{if(!t.has(s.type)||!e.has(s.type))return!1;for(let t=0;t<n.length;++t)if(o(n[t],s))return h(n[t],s),!0;return!1})}function u(t,e){if("agent begin"===t.type)return t.mode=e,!0;if("parallel"===t.type){let n=!1;return t.stages.forEach(t=>{"agent begin"===t.type&&(t.mode=e,n=!0)}),n}return!1}function p(t,e,n,r=null){s(t,e,Mt.equals),s(t,n,Mt.equals);let i=0,a=t.length;if(r){const e=r.map(e=>Mt.indexOf(t,e)).filter(t=>-1!==t);i=e.reduce((t,e)=>Math.min(t,e),t.length),a=e.reduce((t,e)=>Math.max(t,e),i)+1}return t.splice(i,0,e),t.splice(a+1,0,n),{indexL:i,indexR:a+1}}function f(t,e=!1){return{type:"string",suggest:e,then:Object.assign({"":0},t)}}function m(t,e){return t.v===e.v&&t.prefix===e.prefix&&t.suffix===e.suffix&&t.q===e.q}function b(t,e,n){let s=n.suggest;return Array.isArray(s)||(s=[s]),a(s,s=>!1===s?[]:"object"==typeof s?s.known?t["known"+s.known]||[]:[s]:"string"==typeof s&&s?[{v:s,q:""===e}]:[function(t,e){return Object.keys(e.then).length>0?{v:t,suffix:" ",q:!1}:{v:t,suffix:"\n",q:!1}}(e,n)])}function y(t,n){const s=[],i=r(n);return Object.keys(i.then).forEach(r=>{let a=i.then[r];"number"==typeof a&&(a=n[n.length-a-1]),e(s,b(t,r,a),m)}),s}function x(t,n,s,{suggest:r,override:i}){let a=null;"object"==typeof r&&r.known&&(a=r.known),n.type&&a!==n.type&&(i&&(n.type=i),e(t["known"+n.type],[{v:n.value,suffix:" ",q:!0}],m),n.type="",n.value=""),a&&(n.type=a,n.value&&(n.value+=s.s),n.value+=s.v)}function w(t,e,n){const s={type:"",value:""};let i=n;const a=[i];return t.line.forEach((e,n)=>{n===t.line.length-1&&(t.completions=y(t,a));const o=e.q?"":e.v;let h=i.then[o];void 0===h?(h=i.then[""],t.isVar=!0):t.isVar=e.q,"number"==typeof h?a.length-=h:a.push(h||zt),i=r(a),x(t,s,e,i)}),e&&x(t,s,null,{}),t.nextCompletions=y(t,a),t.valid=Boolean(i.then["\n"])||0===Object.keys(i.then).length,i.type}function k(t){const e=t.baseToken||{};return{value:e.v||"",quoted:e.q||!1}}function v(t,e,n){return e.lastIndex=n,e.exec(t)}function A(t,e,n){return n?function(t,e,n){if(n.escape){const s=v(t,n.escape,e);if(s)return{appendSpace:"",appendValue:n.escapeWith(s),end:!1,newBlock:null,skip:s[0].length}}const s=v(t,n.end,e);return s?{appendSpace:"",appendValue:n.includeEnd?s[0]:"",end:!0,newBlock:null,skip:s[0].length}:{appendSpace:"",appendValue:t[e],end:!1,newBlock:null,skip:1}}(t,e,n):function(t,e){for(let n=0;n<Vt.length;++n){const s=Vt[n],r=v(t,s.start,e);if(r)return{appendSpace:"",appendValue:"",end:!s.end,newBlock:s,skip:r[0].length}}return{appendSpace:t[e],appendValue:"",end:!1,newBlock:null,skip:1}}(t,e)}function F(t){return{ch:t.ch,i:t.i,ln:t.ln}}function M(t){const e=Yt.exec(t);return e&&e[1]?e[1].length:0}function S(t){if("label"===t)return{token:"label"};const e=t.indexOf(" ");let n=null,s=null;-1===e?(n=t,s=[]):(n=t.substr(0,e),s=t.substr(e+1).split(","));let r=null;return"inc"===n&&(r=function(t){let e=1,n=1,s=0;return t[0]&&(e=Number(t[0]),s=Math.max(s,M(t[0]))),t[1]&&(n=Number(t[1]),s=Math.max(s,M(t[1]))),Number.isNaN(e)||Number.isNaN(n)?null:{dp:s,inc:n,start:e}}(s)),r||"<"+t+">"}function R(t,e,n){const s=" "+t+" ";let r=-1,i=s.length,a=0;return Wt.forEach(({begin:t,end:o},h)=>{const l=n[h]?o:t;l.lastIndex=e;const d=l.exec(s);d&&(d.index<i||d.index===i&&l.lastIndex>a)&&(r=h,i=d.index,a=l.lastIndex)}),{end:a-1,start:i,styleIndex:r}}function C(t,e){if(!t)return null;const n={};return e.forEach((t,e)=>{t&&Object.assign(n,Wt[e].attrs)}),n}function E(t){if(!t)return[];const e=Wt.map(()=>!1);let n=0,s=null;const r=[];return t.split("\n").forEach(t=>{const i=[];let a=0;for(;;){const{styleIndex:r,start:o,end:h}=R(t,a,e);if(-1===r)break;e[r]?(e[r]=!1,--n):(e[r]=!0,++n),o>a&&i.push({attrs:s,text:t.substring(a,o)}),s=C(n,e),a=h}a<t.length&&i.push({attrs:s,text:t.substr(a)}),r.push(i)}),r}function G(t,e=null){let n="";return e&&(n=" at line "+(e.b.ln+1)+", character "+e.b.ch),new Error(t+n)}function I(t,e=0,n=null){if(null===n&&(n=t.length),n<=e)return"";let s=t[e].v;for(let r=e+1;r<n;++r)s+=t[r].s+t[r].v;return s}function D(t){return!t||t.q?null:t.v}function L(t,e,n,s=null){for(let r=0;r<n.length;++r){const i=n[r],a=t[e+r];if(D(a)!==i){if(s)throw G(s+'; expected "'+i+'"',a);return e}}return e+n.length}function N(t,e,{start:n=0,limit:s=null,orEnd:r=!1}={}){null===s&&(s=t.length),Array.isArray(e)||(e=[e]);for(let r=n;r<=s-e.length;++r)if(L(t,r,e)!==r)return r;return r?s:-1}function O(t,e,n,{flagTypes:s={},aliases:i=!1}={}){const a=[],o=[];let h=e,l=!1;for(;h<n;++h){const e=t[h],n=D(e),r=s[n];if(!r)break;if(a.includes(r.flag))throw G("Duplicate agent flag: "+n,e);l=l||Boolean(r.allowBlankName),a.push(r.flag),o.push(r.blankNameFlag)}const{name:d,alias:g}=function(t,e,n,{enableAlias:s,allowBlankName:i}){let a=-1;if(s&&(a=N(t,"as",{start:e})),(-1===a||a>=n)&&(a=n),e>=a&&!i){let n=t[e];throw n||(n={b:r(t).e}),G("Missing agent name",n)}return{name:I(t,e,a),alias:I(t,a+1,n)}}(t,h,n,{enableAlias:i,allowBlankName:l});return{name:d,alias:g,flags:d?a:o}}function z(t,e,n,s){const r=[];let i=-1;for(let a=e;a<n;++a){","===D(t[a])?-1!==i&&(r.push(O(t,i,a,s)),i=-1):-1===i&&(i=a)}return-1!==i&&r.push(O(t,i,n,s)),r}function B({agentIDs:t=[],topShift:e=0,y:n=null,asynchronousY:s=null}={},r=null){let i=e;return null!==n&&null!==r&&(i=Math.max(i,n-r)),{agentIDs:t,asynchronousY:null===s?r:s,topShift:i,y:n}}function T(t,e){ne.set(t,e)}function H(){return ne}function V(t,e){let n=null,s=null;return e.forEach(e=>{const r=t.get(e);(null===n||r.index<n.index)&&(n=r),(null===s||r.index>s.index)&&(s=r)}),{left:n.id,right:s.id}}function P(t=null,e=null){return null===t?e:null===e?t:Math.max(t,e)}function j(t,n){return e(t.agentIDs,n.agentIDs),{agentIDs:t.agentIDs,asynchronousY:P(t.asynchronousY,n.asynchronousY),topShift:Math.max(t.topShift,n.topShift),y:P(t.y,n.y)}}function q(t){return null===t?null:t.element?t.element:t}function Y(t,e,n){if(!Array.isArray(n))throw new Error("Invalid formatted text line: "+n);n.forEach(({text:n,attrs:s})=>{s?e.add(t.el("tspan").attrs(s).add(n)):e.add(n)})}function W(t,e){let n=null,s=null;return e.forEach(e=>{const r=t.get(e);(null===n||r.index<n.index)&&(n=r),(null===s||r.index>s.index)&&(s=r)}),{left:n.id,right:s.id}}function U(t,e){return t.v===e.v&&t.prefix===e.prefix&&t.suffix===e.suffix&&t.q===e.q}function X(t,e,n){const s=t.getLine(e),r={squash:{ch:n,line:e},word:{ch:n,line:e}};return n>0&&" "===s[n-1]&&(nn.after.includes(s[n-2])&&r.word.ch--,r.squash.ch--),r}function Q(t,e,n){const s=function({v:t,q:e,prefix:n="",suffix:s=""},r){const i=r||!rn.test(t)?r:'"';return n+(i&&e?i+t.replace(an,"\\$&")+i:t)+s}(t,n),r=t.q?e.fromVar:e.fromKey;return"\n"===s?{className:"pick-virtual",displayFrom:null,displayText:"<END>",from:r.squash,text:"\n",to:e.to.squash}:{className:null,displayFrom:r.word,displayText:s.trim(),from:nn.start.test(s)?r.squash:r.word,text:s,to:nn.end.test(s)?e.to.squash:e.to.word}}function J({global:t,prefix:e="",suffix:n=""},s){const r=s[t];return r?r.map(t=>({prefix:e,q:!0,suffix:n,v:t})):[]}function Z(t,n){const s=t.getCursor(),i=function(t,e){const n=t.getLineTokens(e.line);for(let t=0;t<n.length;++t)if(n[t].end>=e.ch){n.length=t+1;break}return n}(t,s),a=r(i)||t.getTokenAt(s),o=function(t,e){let n="",s=0,r=0;t.forEach(t=>{t.state.isVar?(n+=t.string,r=t.end):(n="",s=t.end)}),r>e.ch&&(n=n.substr(0,e.ch-s));const i=en.exec(n);n=i[2];let a="";return sn.test(n)&&(a=n.charAt(0),n=n.substr(1)),{from:s+i[1].length,partial:n,quote:a,valid:r>=s}}(i,s),h=function(t,e){let n=t.string;t.end>e.ch&&(n=n.substr(0,e.ch-t.start));const s=en.exec(n);return{from:t.start+s[1].length,partial:s[2],valid:!0}}(a,s),l=s.ch>0&&a.state.line.length>0;let d=l?a.state.completions:a.state.beginCompletions;l||(d=d.concat(a.state.knownAgent)),function(t,n={}){for(let s=0;s<t.length;)t[s].global?(e(t,J(t[s],n),U),t.splice(s,1)):++s}(d,t.options.globals);const g={fromKey:X(t,s.line,h.from),fromVar:X(t,s.line,o.from),to:function(t,e,n){const s={squash:{ch:n,line:e},word:{ch:n,line:e}};return" "===t.getLine(e)[n]&&s.squash.ch++,s}(t,s.line,a.end)};let c=null;const u=d.filter(t=>(t.q||!o.quote)&&function(t,e){return e.valid&&t.startsWith(e.partial)}(t.v,t.q?o:h)).map(t=>n.completeSingle||t.v!==(t.q?o:h).partial?Q(t,g,o.quote):(c=t,null)).filter(t=>null!==t);return c&&u.length>0&&u.unshift(Q(c,g,o.quote)),{from:function(t,e){let n=null;return t.forEach(({displayFrom:t})=>{t&&(!n||t.line>n.line||t.line===n.line&&t.ch>n.ch)&&(n=t)}),n||e.word}(u,g.fromKey),list:u,to:g.to.word}}function K(t,e="sequence"){const n=t||window.CodeMirror;n.defineMode(e,()=>dn),n.registerHelper("hint",e,Z)}function _(t){const e=(new DOMParser).parseFromString(t,"image/svg+xml").querySelector("metadata");return e?e.textContent:""}function $(t){function e(t,e){n.push(e)}const n=[];if(t.forEach(t=>{t.addEventListener("error",e),t.optimisedRenderPreReflow()}),t.forEach(t=>{t.optimisedRenderReflow()}),t.forEach(t=>{t.optimisedRenderPostReflow(),t.removeEventListener("error",e)}),n.length>0)throw n}function tt(t,e=null,n={}){if("svg"===t.tagName)return null;const s=function(t){return{interactive:function(t){return void 0!==t&&"false"!==t}(t.dataset.sdInteractive),namespace:t.dataset.sdNamespace||null}}(t),r=new gn(null===e?t.textContent:e,Object.assign(s,n)),i=r.dom(),a=t.attributes;for(let t=0;t<a.length;++t)i.setAttribute(a[t].nodeName,a[t].nodeValue);return t.parentNode.replaceChild(i,t),r}function et(t,e=null,n={}){let s=null,r=null;if(e&&"object"==typeof e?s=(r=e).code:(r=n,s=e),Array.isArray(t)){const e=Object.assign({},r,{render:!1}),n=t.map(t=>tt(t,s,e));return!1!==r.render&&$(n),n}return tt(t,s,r)}function nt(t){return"&#"+t.charCodeAt(0).toString(10)+";"}function st(t){return t.replace(/[^\r\n\t !#$%(-;=?-~]/g,nt)}class rt{constructor(t,e){Array.isArray(e)?this.deltas=e:this.deltas=[0,2*-e/3,-e,2*-e/3,0,2*e/3,e,2*e/3],this.partWidth=t/this.deltas.length}getDelta(t){return this.deltas[t%this.deltas.length]}}class it{constructor(t){this.svg=t}reset(){}addDefs(){}getBlock(t){return this.blocks[t]||this.blocks[""]}getNote(t){return this.notes[t]||this.notes[""]}getDivider(t){return this.dividers[t]||this.dividers[""]}optionsAttributes(t,e){return function(t,e){const n=Object.assign({},t[""]);return e.forEach(e=>{Object.assign(n,t[e]||{})}),n}(t,e)}renderAgentLine({x:t,y0:e,y1:n,width:s,className:r,options:i}){const a=this.optionsAttributes(this.agentLineAttrs,i);return s>0?this.svg.box(a,{x:t-s/2,y:e,width:s,height:n-e}).addClass(r):this.svg.line(a,{x1:t,x2:t,y1:e,y2:n}).addClass(r)}renderArrowHead(t,{x:e,y:n,width:s,height:r,dir:i}){const a=s*i.dx,o=s*i.dy,h=.5*r*i.dx,l=.5*-r*i.dy;return this.svg.el("none"===t.fill?"polyline":"polygon").attr("points",e+a-l+" "+(n+o-h)+" "+e+" "+n+" "+(e+a+l)+" "+(n+o+h)).attrs(t)}renderTag(t,{x:e,y:n,width:s,height:r}){const{rx:i,ry:a}=t,o=e+s,h=n+r,l="M"+o+" "+n+"L"+o+" "+(h-a)+"L"+(o-i)+" "+h+"L"+e+" "+h,d=this.svg.el("g");return"none"!==t.fill&&d.add(this.svg.el("path").attr("d",l+"L"+e+" "+n).attrs(t).attr("stroke","none")),"none"!==t.stroke&&d.add(this.svg.el("path").attr("d",l).attrs(t).attr("fill","none")),d}renderDB(t,e){const n=t["db-z"];return this.svg.el("g").add(this.svg.box({rx:e.width/2,ry:n},e).attrs(t),this.svg.el("path").attr("d","M"+e.x+" "+(e.y+n)+"a"+e.width/2+" "+n+" 0 0 0 "+e.width+" 0").attrs(t).attr("fill","none"))}renderRef(t,e){return{shape:this.svg.box(t,e).attrs({fill:"none"}),mask:this.svg.box(t,e).attrs({fill:"#000000",stroke:"none"}),fill:this.svg.box(t,e).attrs({stroke:"none"})}}renderFlatConnect(t,e,{x1:n,y1:s,x2:r,y2:i}){return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(t).move(n,s).line(r,i).cap().asPath()).attrs(e),p1:{x:n,y:s},p2:{x:r,y:i}}}renderRevConnect(t,e,{x1:n,y1:s,x2:r,y2:i,xR:a,rad:o}){const h=(i-s)/2,l=this.svg.patternedLine(t).move(n,s).line(a,s);return o<h?l.arc(a,s+o,Math.PI/2).line(a+o,i-o).arc(a,i-o,Math.PI/2):l.arc(a,(s+i)/2,Math.PI),{shape:this.svg.el("path").attr("d",l.line(r,i).cap().asPath()).attrs(e),p1:{x:n,y:s},p2:{x:r,y:i}}}renderLineDivider({lineAttrs:t},{x:e,y:n,labelWidth:s,width:r,height:i}){let a=null;const o=n+i/2;return a=s>0?this.svg.el("g").add(this.svg.line({fill:"none"},{x1:e,x2:e+(r-s)/2,y1:o,y2:o}).attrs(t),this.svg.line({fill:"none"},{x1:e+(r+s)/2,x2:e+r,y1:o,y2:o}).attrs(t)):this.svg.line({fill:"none"},{x1:e,x2:e+r,y1:o,y2:o}).attrs(t),{shape:a}}renderDelayDivider({dotSize:t,gapSize:e},{x:n,y:s,width:r,height:i}){const a=this.svg.el("g");for(let o=0;o+e<=i;o+=t+e)a.add(this.svg.box({fill:"#000000"},{x:n,y:s+o,width:r,height:e}));return{mask:a}}renderTearDivider({fadeBegin:t,fadeSize:e,pattern:n,zigWidth:s,zigHeight:r,lineAttrs:i},{x:a,y:o,labelWidth:h,labelHeight:l,width:d,height:g,env:c}){const u=c.addDef("tear-grad",()=>{const n=100/d;return this.svg.linearGradient({},[{offset:t*n+"%","stop-color":"#000000"},{offset:(t+e)*n+"%","stop-color":"#FFFFFF"},{offset:100-(t+e)*n+"%","stop-color":"#FFFFFF"},{offset:100-t*n+"%","stop-color":"#000000"}])}),p=this.svg.el("mask").attr("maskUnits","userSpaceOnUse").add(this.svg.box({fill:"url(#"+u+")"},{x:a,y:o-5,width:d,height:g+10})),f=c.addDef(p);h>0&&p.add(this.svg.box({rx:2,ry:2,fill:"#000000"},{x:a+(d-h)/2,y:o+(g-l)/2-1,width:h,height:l+2}));const m=n||new rt(s,[r,-r]);let b=null;const y=this.svg.patternedLine(m).move(a,o).line(a+d,o),x=this.svg.el("g").attr("mask","url(#"+f+")").add(this.svg.el("path").attrs({d:y.asPath(),fill:"none"}).attrs(i));if(g>0){const t=this.svg.patternedLine(m).move(a,o+g).line(a+d,o+g);x.add(this.svg.el("path").attrs({d:t.asPath(),fill:"none"}).attrs(i)),y.line(t.x,t.y,{patterned:!1}).cap(),y.points.push(...t.points.reverse()),b=this.svg.el("path").attrs({d:y.asPath(),fill:"#000000"})}return{shape:x,mask:b}}}const at="sans-serif",ot=new rt(6,.5),ht={"font-family":at,"font-size":8,"line-height":1.3},lt={"font-family":at,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class dt extends it{constructor(t){super(t);const e={padding:{top:3,bottom:2},tag:{padding:{top:1,left:3,right:3,bottom:0},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:2,ry:2}),labelAttrs:{"font-family":at,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:4,padding:{top:1,left:5,right:3,bottom:1},labelAttrs:{"font-family":at,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:10,outerMargin:5,agentMargin:10,actionMargin:10,minActionMargin:3,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:5,left:10,right:10,bottom:5},arrowBottom:12.8,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":1},labelAttrs:{"font-family":at,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:12,left:10,right:10,bottom:3},arrowBottom:12.8,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,"db-z":5}),labelAttrs:{"font-family":at,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},cross:{size:20,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},fade:{width:5,height:6,extend:1},none:{height:10}},connect:{loopbackRadius:6,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-dasharray":"4, 2"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"round","stroke-linecap":"round"},renderFlat:this.renderFlatConnect.bind(this,ot),renderRev:this.renderRevConnect.bind(this,ot)}},arrow:{single:{width:5,height:10,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000","stroke-width":0,"stroke-linejoin":"miter"}},double:{width:4,height:6,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"miter"}},cross:{short:7,radius:3,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})}},label:{padding:6,margin:{top:2,bottom:1},attrs:{"font-family":at,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":at,"font-size":8,"line-height":1.3}},source:{radius:2,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":at,"font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":1},red:{stroke:"#CC0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1.5,rx:2,ry:2}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":1.5,"stroke-dasharray":"4, 2"})}},notes:{text:{margin:{top:0,left:2,right:2,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:ht},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:5,right:10,bottom:5},overlap:{left:10,right:10},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:ht},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:7,left:7,right:7,bottom:7},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:10,ry:10}),labelAttrs:ht}},dividers:{"":{labelAttrs:lt,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:lt,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000"}})},delay:{labelAttrs:lt,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:1,gapSize:2})},tear:{labelAttrs:lt,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,zigWidth:6,zigHeight:1,lineAttrs:{stroke:"#000000"}})}}})}}class gt{constructor(){this.name="basic"}build(t){return new dt(t)}}const ct="sans-serif",ut=new rt(10,1),pt={"font-family":ct,"font-size":8,"line-height":1.3},ft={"font-family":ct,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class mt extends it{constructor(t){super(t);const e={padding:{top:3,bottom:4},tag:{padding:{top:2,left:5,right:5,bottom:1},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2,rx:3,ry:3}),labelAttrs:{"font-family":ct,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:5,padding:{top:2,left:5,right:3,bottom:1},labelAttrs:{"font-family":ct,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:12,outerMargin:5,agentMargin:8,actionMargin:5,minActionMargin:5,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:1,left:3,right:3,bottom:1},arrowBottom:11.1,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":3,rx:4,ry:4},labelAttrs:{"font-family":ct,"font-weight":"bold","font-size":14,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:4,left:3,right:3,bottom:0},arrowBottom:11.1,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":3,"db-z":2}),labelAttrs:{"font-family":ct,"font-weight":"bold","font-size":14,"line-height":1.3,"text-anchor":"middle"}},cross:{size:20,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":3,"stroke-linecap":"round"})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":3,rx:2,ry:2})},fade:{width:5,height:10,extend:1},none:{height:10}},connect:{loopbackRadius:8,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":3},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-dasharray":"10, 4"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"},renderFlat:this.renderFlatConnect.bind(this,ut),renderRev:this.renderRevConnect.bind(this,ut)}},arrow:{single:{width:10,height:12,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round"}},double:{width:10,height:12,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"}},cross:{short:10,radius:5,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":3,"stroke-linejoin":"round","stroke-linecap":"round"})}},label:{padding:7,margin:{top:2,bottom:3},attrs:{"font-family":ct,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":ct,"font-size":8,"line-height":1.3}},source:{radius:5,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":3})},mask:{padding:{top:1,left:5,right:5,bottom:3}}},titleAttrs:{"font-family":ct,"font-weight":"bolder","font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":3},red:{stroke:"#DD0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":4,rx:5,ry:5}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":4,rx:5,ry:5}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":4,rx:5,ry:5}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":2,"stroke-dasharray":"5, 3"})}},notes:{text:{margin:{top:0,left:2,right:2,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:pt},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:3,left:3,right:10,bottom:3},overlap:{left:10,right:10},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":2,"stroke-linejoin":"round"},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:pt},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:7,right:7,bottom:5},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":3,rx:10,ry:10}),labelAttrs:pt}},dividers:{"":{labelAttrs:ft,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:ft,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000","stroke-width":2,"stroke-linecap":"round"}})},delay:{labelAttrs:ft,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:3,gapSize:3})},tear:{labelAttrs:ft,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,zigWidth:6,zigHeight:1,lineAttrs:{stroke:"#000000","stroke-width":2,"stroke-linejoin":"round"}})}}})}}class bt{constructor(){this.name="chunky"}build(t){return new mt(t)}}class yt{constructor(){this.listeners=new Map,this.forwards=new Set}addEventListener(t,e){const n=this.listeners.get(t);n?n.push(e):this.listeners.set(t,[e])}removeEventListener(t,e){const n=this.listeners.get(t);if(!n)return;const s=n.indexOf(e);-1!==s&&n.splice(s,1)}on(t,e){return this.addEventListener(t,e),this}off(t,e){return this.removeEventListener(t,e),this}countEventListeners(t){return(this.listeners.get(t)||[]).length}removeAllEventListeners(t){t?this.listeners.delete(t):this.listeners.clear()}addEventForwarding(t){this.forwards.add(t)}removeEventForwarding(t){this.forwards.delete(t)}removeAllEventForwardings(){this.forwards.clear()}trigger(t,e=[]){(this.listeners.get(t)||[]).forEach(t=>t(...e)),this.forwards.forEach(n=>n.trigger(t,e))}}const xt="undefined"==typeof window,wt=!xt&&/^((?!chrome|android).)*safari/i.test(window.navigator.userAgent),kt=!xt&&void 0!==window.InstallTrigger;class vt{constructor(){this.latestSVG=null,this.latestInternalSVG=null,this.canvas=null,this.context=null,this.indexPNG=0,this.latestPNGIndex=0,this.latestPNG=null}getSVGContent(t){let e=t.dom().outerHTML;return e=e.replace(/^<svg/,'<svg width="'+(t.width||1)+'" height="'+(t.height||1)+'" ')}getSVGBlob(t){return new Blob([this.getSVGContent(t)],{type:"image/svg+xml"})}getSVGURL(t){const e=this.getSVGBlob(t);return this.latestSVG&&URL.revokeObjectURL(this.latestSVG),this.latestSVG=URL.createObjectURL(e),this.latestSVG}getCanvas(t,e,n){this.canvas||(window.devicePixelRatio=1,this.canvas=document.createElement("canvas"),this.context=this.canvas.getContext("2d"));const s=(t.width||1)*e,r=(t.height||1)*e,i=new Image(s,r);let a=null;wt&&((a=document.createElement("div")).style.position="absolute",a.style.visibility="hidden",a.appendChild(i),document.body.appendChild(a));const o=()=>{this.canvas.width=s,this.canvas.height=r,this.context.drawImage(i,0,0,s,r),a&&document.body.removeChild(a),n(this.canvas)};i.addEventListener("load",()=>{a?setTimeout(o,50):o()},{once:!0}),i.src=this.getSVGURL(t)}getPNGBlob(t,e,n){this.getCanvas(t,e,t=>{t.toBlob(n,"image/png")})}getPNGURL(t,e,n){++this.indexPNG;const s=this.indexPNG;this.getPNGBlob(t,e,t=>{const e=URL.createObjectURL(t);s>=this.latestPNGIndex?(this.latestPNG&&URL.revokeObjectURL(this.latestPNG),this.latestPNG=e,this.latestPNGIndex=s,n(e,!0)):(n(e,!1),URL.revokeObjectURL(e))})}}class At{constructor({visible:t=!1,locked:e=!1,blocked:n=!1,highlighted:s=!1,group:r=null,covered:i=!1}={}){this.visible=t,this.locked=e,this.blocked=n,this.highlighted=s,this.group=r,this.covered=i}}At.LOCKED=new At({locked:!0}),At.DEFAULT=new At;const Ft={equals:(t,e)=>t.name===e.name,hasFlag:(t,e=!0)=>n=>n.flags.includes(t)===e},Mt={equals:(t,e)=>t.id===e.id,make:(t,{anchorRight:e=!1,isVirtualSource:n=!1}={})=>({anchorRight:e,id:t,isVirtualSource:n,options:[]}),indexOf:(e,n)=>t(e,n,Mt.equals),hasIntersection:(e,n)=>(function(e,n,s=null){for(let r=0;r<n.length;++r)if(-1!==t(e,n[r],s))return!0;return!1})(e,n,Mt.equals),addNearby:(e,n,s,r)=>{const i=t(e,n,Mt.equals);-1===i?e.push(s):e.splice(i+r,0,s)}},St={"note over":[Mt.make("["),Mt.make("]")],"note left":[Mt.make("[")],"note right":[Mt.make("]")]},Rt=["[","]"],Ct={"agent begin":{check:["mode"],merge:["agentIDs"],siblings:new Set(["agent highlight"])},"agent end":{check:["mode"],merge:["agentIDs"],siblings:new Set(["agent highlight"])},"agent highlight":{check:["highlighted"],merge:["agentIDs"],siblings:new Set(["agent begin","agent end"])}};class Et{constructor(){this.agentStates=new Map,this.agentAliases=new Map,this.activeGroups=new Map,this.gAgents=[],this.labelPattern=null,this.nextID=0,this.nesting=[],this.markers=new Set,this.currentSection=null,this.currentNest=null,this.stageHandlers={"block begin":this.handleBlockBegin.bind(this),"block split":this.handleBlockSplit.bind(this),"block end":this.handleBlockEnd.bind(this),"group begin":this.handleGroupBegin.bind(this),mark:this.handleMark.bind(this),async:this.handleAsync.bind(this),"agent define":this.handleAgentDefine.bind(this),"agent options":this.handleAgentOptions.bind(this),"agent begin":this.handleAgentBegin.bind(this),"agent end":this.handleAgentEnd.bind(this),divider:this.handleDivider.bind(this),"label pattern":this.handleLabelPattern.bind(this),connect:this.handleConnect.bind(this),"connect-delay-begin":this.handleConnectDelayBegin.bind(this),"connect-delay-end":this.handleConnectDelayEnd.bind(this),"note over":this.handleNote.bind(this),"note left":this.handleNote.bind(this),"note right":this.handleNote.bind(this),"note between":this.handleNote.bind(this)},this.expandGroupedGAgent=this.expandGroupedGAgent.bind(this),this.handleStage=this.handleStage.bind(this),this.toGAgent=this.toGAgent.bind(this),this.endGroup=this.endGroup.bind(this)}toGAgent({name:t,alias:e,flags:n}){if(e){if(this.agentAliases.has(t))throw new Error("Cannot alias "+t+"; it is already an alias");const n=this.agentAliases.get(e);if(n&&n!==e||this.gAgents.some(t=>t.id===e))throw new Error("Cannot use "+e+" as an alias; it is already in use");this.agentAliases.set(e,t)}return Mt.make(this.agentAliases.get(t)||t,{isVirtualSource:n.includes("source")})}addStage(t,e=!0){t&&(void 0===t.ln&&(t.ln=this.latestLine),this.currentSection.stages.push(t),e&&(this.currentNest.hasContent=!0))}addParallelStages(t){const e=t.filter(t=>Boolean(t));0!==e.length&&(1!==e.length?(e.forEach(t=>{void 0===t.ln&&(t.ln=this.latestLine)}),this.addStage({type:"parallel",stages:e})):this.addStage(e[0]))}defineGAgents(t){e(this.currentNest.gAgents,t.filter(t=>!Rt.includes(t.id)),Mt.equals),e(this.gAgents,t,Mt.equals)}getGAgentState(t){return this.agentStates.get(t.id)||At.DEFAULT}updateGAgentState(t,e){const n=this.agentStates.get(t.id);n?Object.assign(n,e):this.agentStates.set(t.id,new At(e))}replaceGAgentState(t,e){this.agentStates.set(t.id,e)}validateGAgents(t,{allowGrouped:e=!1,allowCovered:n=!1,allowVirtual:s=!1}={}){t.forEach(t=>{const r=this.getGAgentState(t);if(r.blocked&&null===r.group)throw new Error("Duplicate agent name: "+t.id);if(!n&&r.covered)throw new Error("Agent "+t.id+" is hidden behind group");if(!e&&null!==r.group)throw new Error("Agent "+t.id+" is in a group");if(!s&&t.isVirtualSource)throw new Error("cannot use message source here");if(t.id.startsWith("__"))throw new Error(t.id+" is a reserved name")})}setGAgentVis(t,e,n,s=!1){const r=new Set,i=t.filter(t=>{if(r.has(t.id))return!1;r.add(t.id);const n=this.getGAgentState(t);if(n.locked||n.blocked){if(s)throw new Error("Cannot begin/end agent: "+t.id);return!1}return n.visible!==e});return 0===i.length?null:(i.forEach(t=>{this.updateGAgentState(t,{visible:e})}),this.defineGAgents(i),{type:e?"agent begin":"agent end",agentIDs:i.map(t=>t.id),mode:n})}setGAgentHighlight(t,e,n=!1){const s=t.filter(t=>{const s=this.getGAgentState(t);if(s.locked||s.blocked){if(n)throw new Error("Cannot highlight agent: "+t.id);return!1}return s.visible&&s.highlighted!==e});return 0===s.length?null:(s.forEach(t=>{this.updateGAgentState(t,{highlighted:e})}),{type:"agent highlight",agentIDs:s.map(t=>t.id),highlighted:e})}_makeSection(t,e){return{header:t,delayedConnections:new Map,stages:e}}_checkSectionEnd(){const t=this.currentSection.delayedConnections;if(t.size>0){const e=t.values().next().value;throw new Error('Unused delayed connection "'+e.tag+'" at line '+(e.ln+1))}}beginNested(t,{tag:e,label:n,name:s,ln:r}){const i=Mt.make(s+"[",{anchorRight:!0}),a=Mt.make(s+"]"),o=[i,a],h=[];return this.currentSection=this._makeSection({type:"block begin",blockType:t,tag:this.textFormatter(e),label:this.textFormatter(n),canHide:!0,left:i.id,right:a.id,ln:r},h),this.currentNest={blockType:t,gAgents:o,leftGAgent:i,rightGAgent:a,hasContent:!1,sections:[this.currentSection]},this.replaceGAgentState(i,At.LOCKED),this.replaceGAgentState(a,At.LOCKED),this.nesting.push(this.currentNest),{stages:h}}nextBlockName(){const t="__BLOCK"+this.nextID;return++this.nextID,t}nextVirtualAgentName(){const t="__"+this.nextID;return++this.nextID,t}handleBlockBegin({ln:t,blockType:e,tag:n,label:s}){this.beginNested(e,{tag:n,label:s,name:this.nextBlockName(),ln:t})}handleBlockSplit({ln:t,blockType:e,tag:n,label:s}){if("if"!==this.currentNest.blockType)throw new Error('Invalid block nesting ("else" inside '+this.currentNest.blockType+")");this._checkSectionEnd(),this.currentSection=this._makeSection({type:"block split",blockType:e,tag:this.textFormatter(n),label:this.textFormatter(s),left:this.currentNest.leftGAgent.id,right:this.currentNest.rightGAgent.id,ln:t},[]),this.currentNest.sections.push(this.currentSection)}handleBlockEnd(){if(this.nesting.length<=1)throw new Error('Invalid block nesting (too many "end"s)');this._checkSectionEnd();const t=this.nesting.pop();if(this.currentNest=r(this.nesting),this.currentSection=r(this.currentNest.sections),!t.hasContent)throw new Error("Empty block");this.defineGAgents(t.gAgents),p(this.gAgents,t.leftGAgent,t.rightGAgent,t.gAgents),t.sections.forEach(t=>{this.currentSection.stages.push(t.header),this.currentSection.stages.push(...t.stages)}),this.addStage({type:"block end",left:t.leftGAgent.id,right:t.rightGAgent.id})}makeGroupDetails(t,e){const s=t.map(this.toGAgent);if(this.validateGAgents(s),this.agentStates.has(e))throw new Error("Duplicate agent name: "+e);const r=this.nextBlockName(),i=Mt.make(r+"[",{anchorRight:!0}),a=Mt.make(r+"]");this.replaceGAgentState(i,At.LOCKED),this.replaceGAgentState(a,At.LOCKED),this.updateGAgentState(Mt.make(e),{blocked:!0,group:e}),this.defineGAgents([...s,i,a]);const{indexL:o,indexR:h}=p(this.gAgents,i,a,s),l=[],d=s.slice();for(let t=o+1;t<h;++t)l.push(this.gAgents[t]);return n(l,d,Mt.equals),{gAgents:s,leftGAgent:i,rightGAgent:a,gAgentsContained:d,gAgentsCovered:l}}handleGroupBegin({agents:t,blockType:e,tag:n,label:s,alias:r}){const i=this.makeGroupDetails(t,r);i.gAgentsContained.forEach(t=>{this.updateGAgentState(t,{group:r})}),i.gAgentsCovered.forEach(t=>{this.updateGAgentState(t,{covered:!0})}),this.activeGroups.set(r,i),this.addStage(this.setGAgentVis(i.gAgents,!0,"box")),this.addStage({type:"block begin",blockType:e,tag:this.textFormatter(n),canHide:!1,label:this.textFormatter(s),left:i.leftGAgent.id,right:i.rightGAgent.id})}endGroup({name:t}){const e=this.activeGroups.get(t);return e?(this.activeGroups.delete(t),e.gAgentsContained.forEach(t=>{this.updateGAgentState(t,{group:null})}),e.gAgentsCovered.forEach(t=>{this.updateGAgentState(t,{covered:!1})}),this.updateGAgentState(Mt.make(t),{group:null}),{type:"block end",left:e.leftGAgent.id,right:e.rightGAgent.id}):null}handleMark({name:t}){this.markers.add(t),this.addStage({type:"mark",name:t},!1)}handleDivider({mode:t,height:e,label:n}){this.addStage({type:"divider",mode:t,height:e,formattedLabel:this.textFormatter(n)},!1)}handleAsync({target:t}){if(""!==t&&!this.markers.has(t))throw new Error("Unknown marker: "+t);this.addStage({type:"async",target:t},!1)}handleLabelPattern({pattern:t}){this.labelPattern=t.slice();for(let t=0;t<this.labelPattern.length;++t){const e=this.labelPattern[t];"object"==typeof e&&void 0!==e.start&&(this.labelPattern[t]=Object.assign({current:e.start},e))}}applyLabelPattern(t){let e="";const n={label:t};return this.labelPattern.forEach(t=>{"string"==typeof t?e+=t:void 0!==t.token?e+=n[t.token]:void 0!==t.current&&(e+=t.current.toFixed(t.dp),t.current+=t.inc)}),e}expandGroupedGAgent(t){const{group:e}=this.getGAgentState(t);if(!e)return[t];const n=this.activeGroups.get(e);return[n.leftGAgent,n.rightGAgent]}expandGroupedGAgentConnection(t){const e=this.expandGroupedGAgent(t[0]),n=this.expandGroupedGAgent(t[1]);let s=Mt.indexOf(this.gAgents,e[0]),i=Mt.indexOf(this.gAgents,n[0]);return-1===s&&(s=e[0].isVirtualSource?-1:this.gAgents.length),-1===i&&(i=this.gAgents.length),s===i?[r(e),r(n)]:s<i?[r(e),n[0]]:[e[0],r(n)]}filterConnectFlags(t){const n=t.filter(Ft.hasFlag("begin")).map(this.toGAgent),s=t.filter(Ft.hasFlag("end")).map(this.toGAgent);if(Mt.hasIntersection(n,s))throw new Error("Cannot set agent visibility multiple times");const r=t.filter(Ft.hasFlag("start")).map(this.toGAgent),i=t.filter(Ft.hasFlag("stop")).map(this.toGAgent);if(e(i,s),Mt.hasIntersection(r,i))throw new Error("Cannot set agent highlighting multiple times");return this.validateGAgents(n),this.validateGAgents(s),this.validateGAgents(r),this.validateGAgents(i),{beginGAgents:n,endGAgents:s,startGAgents:r,stopGAgents:i}}makeVirtualAgent(t){const e=Mt.make(this.nextVirtualAgentName(),{anchorRight:t,isVirtualSource:!0});return this.replaceGAgentState(e,At.LOCKED),e}addNearbyAgent(t,e,n){Mt.addNearby(this.currentNest.gAgents,t,e,n),Mt.addNearby(this.gAgents,t,e,n)}expandVirtualSourceAgents(t){if(t[0].isVirtualSource){if(t[1].isVirtualSource)throw new Error("Cannot connect found messages");if(Rt.includes(t[1].id))throw new Error("Cannot connect found messages to special agents");const e=this.makeVirtualAgent(!0);return this.addNearbyAgent(t[1],e,0),[e,t[1]]}if(t[1].isVirtualSource){if(Rt.includes(t[0].id))throw new Error("Cannot connect found messages to special agents");const e=this.makeVirtualAgent(!1);return this.addNearbyAgent(t[0],e,1),[t[0],e]}return t}_handlePartialConnect(t){const e=this.filterConnectFlags(t),n=t.map(this.toGAgent);this.validateGAgents(n,{allowGrouped:!0,allowVirtual:!0}),this.defineGAgents(a(n,this.expandGroupedGAgent).filter(t=>!t.isVirtualSource));const s=t.filter(Ft.hasFlag("begin",!1)).map(this.toGAgent).filter(t=>!t.isVirtualSource);return this.addStage(this.setGAgentVis(s,!0,"box")),{flags:e,gAgents:n}}_makeConnectParallelStages(t,e){return[this.setGAgentVis(t.beginGAgents,!0,"box",!0),this.setGAgentHighlight(t.startGAgents,!0,!0),e,this.setGAgentHighlight(t.stopGAgents,!1,!0),this.setGAgentVis(t.endGAgents,!1,"cross",!0)]}_isSelfConnect(t){const e=t.map(this.toGAgent),n=this.expandGroupedGAgentConnection(e);return n[0].id===n[1].id&&!n.some(t=>t.isVirtualSource)}handleConnect({agents:t,label:e,options:n}){if(this._isSelfConnect(t)){const s={};return this.handleConnectDelayBegin({agent:t[0],tag:s,options:n,ln:0}),void this.handleConnectDelayEnd({agent:t[1],tag:s,label:e,options:n})}let{flags:s,gAgents:r}=this._handlePartialConnect(t);r=this.expandGroupedGAgentConnection(r);const i={type:"connect",agentIDs:(r=this.expandVirtualSourceAgents(r)).map(t=>t.id),label:this.textFormatter(this.applyLabelPattern(e)),options:n};this.addParallelStages(this._makeConnectParallelStages(s,i))}handleConnectDelayBegin({agent:t,tag:e,options:n,ln:s}){const r=this.currentSection.delayedConnections;if(r.has(e))throw new Error('Duplicate delayed connection "'+e+'"');const{flags:i,gAgents:a}=this._handlePartialConnect([t]),o=this.nextVirtualAgentName(),h={type:"connect-delay-begin",tag:o,agentIDs:null,label:null,options:n};r.set(e,{tag:e,uniqueTag:o,ln:s,gAgents:a,connectStage:h}),this.addParallelStages(this._makeConnectParallelStages(i,h))}handleConnectDelayEnd({agent:t,tag:e,label:n,options:s}){const r=this.currentSection.delayedConnections,i=r.get(e);if(!i)throw new Error('Unknown delayed connection "'+e+'"');let{flags:a,gAgents:o}=this._handlePartialConnect([t]);o=this.expandGroupedGAgentConnection([...i.gAgents,...o]),o=this.expandVirtualSourceAgents(o);let h=i.connectStage.options;if(h.line!==s.line)throw new Error("Mismatched delayed connection arrows");s.right&&(h=Object.assign({},h,{right:s.right})),Object.assign(i.connectStage,{agentIDs:o.map(t=>t.id),label:this.textFormatter(this.applyLabelPattern(n)),options:h});const l={type:"connect-delay-end",tag:i.uniqueTag};this.addParallelStages(this._makeConnectParallelStages(a,l)),r.delete(e)}handleNote({type:t,agents:e,mode:n,label:s}){let r=null;r=0===e.length?St[t]||[]:e.map(this.toGAgent),this.validateGAgents(r,{allowGrouped:!0});const i=(r=a(r,this.expandGroupedGAgent)).map(t=>t.id),o=new Set(i).size;if("note between"===t&&o<2)throw new Error("note between requires at least 2 agents");this.addStage(this.setGAgentVis(r,!0,"box")),this.defineGAgents(r),this.addStage({type:t,agentIDs:i,mode:n,label:this.textFormatter(s)})}handleAgentDefine({agents:t}){const n=t.map(this.toGAgent);this.validateGAgents(n,{allowGrouped:!0,allowCovered:!0}),e(this.gAgents,n,Mt.equals)}handleAgentOptions({agent:t,options:n}){const s=this.toGAgent(t),r=[s];this.validateGAgents(r,{allowGrouped:!0,allowCovered:!0}),e(this.gAgents,r,Mt.equals),this.gAgents.filter(({id:t})=>t===s.id).forEach(t=>{e(t.options,n)})}handleAgentBegin({agents:t,mode:e}){const n=t.map(this.toGAgent);this.validateGAgents(n),this.addStage(this.setGAgentVis(n,!0,e,!0))}handleAgentEnd({agents:t,mode:e}){const n=t.filter(t=>this.activeGroups.has(t.name)),s=t.filter(t=>!this.activeGroups.has(t.name)).map(this.toGAgent);this.validateGAgents(s),this.addParallelStages([this.setGAgentHighlight(s,!1),this.setGAgentVis(s,!1,e,!0),...n.map(this.endGroup)])}handleStage(t){this.latestLine=t.ln;try{const e=this.stageHandlers[t.type];if(!e)throw new Error("Unknown command: "+t.type);e(t)}catch(e){if("object"==typeof e&&e.message)throw e.message+=" at line "+(t.ln+1),e}}_reset(){this.agentStates.clear(),this.markers.clear(),this.agentAliases.clear(),this.activeGroups.clear(),this.gAgents.length=0,this.nextID=0,this.nesting.length=0,this.labelPattern=[{token:"label"}]}_finalise(t){p(this.gAgents,this.currentNest.leftGAgent,this.currentNest.rightGAgent),function(t){let e=[],n=new Set;for(let s=0;s<t.length;){const r=t[s];let i=null;d(i="parallel"===r.type?r.stages:[r]);const a=g(i);c(n,a,e,i),0===i.length?t.splice(s,1):("parallel"===r.type&&1===i.length&&t.splice(s,1,i[0]),n=a,e=i,++s)}}(t.stages),this.gAgents.forEach(t=>{t.formattedLabel=this.textFormatter(t.id)})}generate({stages:t,meta:e={}}){this._reset(),this.textFormatter=e.textFormatter;const n=this.beginNested("global",{tag:"",label:"",name:"",ln:0});if(t.forEach(this.handleStage),1!==this.nesting.length)throw new Error("Unterminated section at line "+(this.currentSection.header.ln+1));if(this.activeGroups.size>0)throw new Error("Unterminated group");this._checkSectionEnd();const s=e.terminators||"none";return this.addParallelStages([this.setGAgentHighlight(this.gAgents,!1),this.setGAgentVis(this.gAgents,!1,s)]),this._finalise(n),function(t,e){for(let n=0;n<t.length&&!u(t[n],e);++n);}(n.stages,e.headers||"box"),{meta:{title:this.textFormatter(e.title),theme:e.theme,code:e.code},agents:this.gAgents.slice(),stages:n.stages}}}const Gt="monospace",It=new rt(6,[0,-.25,-.5,-.25,0,.25,.5,.25]),Dt={"font-family":Gt,"font-size":8,"line-height":1.3},Lt={"font-family":Gt,"font-size":8,"line-height":1.3,"text-anchor":"middle"};class Nt extends it{constructor(t){super(t);const e={padding:{top:3,bottom:2},tag:{padding:{top:2,left:4,right:4,bottom:2},boxRenderer:this.renderTag.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:3,ry:3}),labelAttrs:{"font-family":Gt,"font-weight":"bold","font-size":9,"line-height":1.3,"text-anchor":"left"}},label:{minHeight:8,padding:{top:2,left:8,right:8,bottom:2},labelAttrs:{"font-family":Gt,"font-size":8,"line-height":1.3,"text-anchor":"left"}}};Object.assign(this,{titleMargin:8,outerMargin:4,agentMargin:12,actionMargin:12,minActionMargin:4,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:4,left:8,right:8,bottom:4},arrowBottom:12,boxAttrs:{fill:"#FFFFFF",stroke:"#000000","stroke-width":1},labelAttrs:{"font-family":Gt,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},database:{padding:{top:9,left:8,right:8,bottom:3},arrowBottom:12,boxRenderer:this.renderDB.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":1,"db-z":4}),labelAttrs:{"font-family":Gt,"font-size":12,"line-height":1.3,"text-anchor":"middle"}},cross:{size:16,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})},bar:{height:4,render:t.boxFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},fade:{width:5,height:8,extend:1},none:{height:8}},connect:{loopbackRadius:4,line:{solid:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},dash:{attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-dasharray":"4, 4"},renderFlat:this.renderFlatConnect.bind(this,null),renderRev:this.renderRevConnect.bind(this,null)},wave:{attrs:{fill:"none",stroke:"#000000","stroke-width":1},renderFlat:this.renderFlatConnect.bind(this,It),renderRev:this.renderRevConnect.bind(this,It)}},arrow:{single:{width:4,height:8,render:this.renderArrowHead.bind(this),attrs:{fill:"#000000","stroke-width":0,"stroke-linejoin":"miter"}},double:{width:3,height:6,render:this.renderArrowHead.bind(this),attrs:{fill:"none",stroke:"#000000","stroke-width":1,"stroke-linejoin":"miter"}},cross:{short:8,radius:4,render:t.crossFactory({fill:"none",stroke:"#000000","stroke-width":1})}},label:{padding:4,margin:{top:2,bottom:1},attrs:{"font-family":Gt,"font-size":8,"line-height":1.3,"text-anchor":"middle"},loopbackAttrs:{"font-family":Gt,"font-size":8,"line-height":1.3}},source:{radius:2,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":Gt,"font-size":20,"line-height":1.3,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":{fill:"none",stroke:"#000000","stroke-width":1},red:{stroke:"#AA0000"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2}),section:e},"":{margin:{top:0,bottom:0},boxRenderer:t.boxFactory({fill:"none",stroke:"#000000","stroke-width":2}),collapsedBoxRenderer:this.renderRef.bind(this,{fill:"#FFFFFF",stroke:"#000000","stroke-width":2}),section:e,sepRenderer:t.lineFactory({stroke:"#000000","stroke-width":2,"stroke-dasharray":"8, 4"})}},notes:{text:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:4,left:4,right:4,bottom:4},overlap:{left:8,right:8},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:Dt},note:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:8,left:8,right:8,bottom:8},overlap:{left:8,right:8},boxRenderer:t.noteFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1},{fill:"none",stroke:"#000000","stroke-width":1}),labelAttrs:Dt},state:{margin:{top:0,left:8,right:8,bottom:0},padding:{top:8,left:8,right:8,bottom:8},overlap:{left:8,right:8},boxRenderer:t.boxFactory({fill:"#FFFFFF",stroke:"#000000","stroke-width":1,rx:8,ry:8}),labelAttrs:Dt}},dividers:{"":{labelAttrs:Lt,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:Lt,padding:{top:2,left:5,right:5,bottom:2},extend:8,margin:0,render:this.renderLineDivider.bind(this,{lineAttrs:{stroke:"#000000"}})},delay:{labelAttrs:Lt,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:2,gapSize:2})},tear:{labelAttrs:Lt,padding:{top:2,left:5,right:5,bottom:2},extend:8,margin:8,render:this.renderTearDivider.bind(this,{fadeBegin:4,fadeSize:4,zigWidth:4,zigHeight:1,lineAttrs:{stroke:"#000000"}})}}})}}class Ot{constructor(){this.name="monospace"}build(t){return new Nt(t)}}const zt={type:"error line-error",suggest:!1,then:{"":0}},Bt=["database","red"],Tt=(()=>{function t(t,e=1){return{type:"variable",suggest:{known:"Agent"},then:Object.assign({},t,{"":0,",":{type:"operator",then:{"":e}}})}}function e(t){return{type:"keyword",suggest:[t+" of ",t+": "],then:{of:{type:"keyword",then:{"":h}},":":{type:"operator",then:{"":i}},"":h}}}function n({exit:t,sourceExit:e,blankExit:n}){const s={type:"operator",then:{"+":zt,"-":zt,"*":zt,"!":zt,"":t}};return{"+":{type:"operator",then:{"+":zt,"-":zt,"*":s,"!":zt,"":t}},"-":{type:"operator",then:{"+":zt,"-":zt,"*":s,"!":{type:"operator",then:{"+":zt,"-":zt,"*":zt,"!":zt,"":t}},"":t}},"*":{type:"operator",then:Object.assign({"+":s,"-":s,"*":zt,"!":zt,"":t},e||t)},"!":s,"":n||t}}const s={type:"",suggest:"\n",then:{}},r={type:"",suggest:!1,then:{}},i=f({"\n":s}),a={type:"operator",then:{"":i,"\n":r}},o=t({"\n":s,as:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,",":{type:"operator",then:{"":3}},"\n":s}}}}}),h=t({":":a}),l={type:"variable",suggest:{known:"Agent"},then:{"":0,":":{type:"operator",then:{"":i,"\n":r}},"\n":s}},d={":":{type:"operator",then:{"":f({as:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,"\n":s}}}}})}}},g={type:"keyword",then:Object.assign({over:{type:"keyword",then:{"":t(d)}}},d)},c={"\n":s,":":{type:"operator",then:{"":i,"\n":r}},with:{type:"keyword",suggest:["with height "],then:{height:{type:"keyword",then:{"":{type:"number",suggest:["6 ","30 "],then:{"\n":s,":":{type:"operator",then:{"":i,"\n":r}}}}}}}}},u=function(t,e,n){const s=Object.assign({},n);return e.forEach(e=>{s[e]={type:t,then:n}}),s}("keyword",["a","an"],function(t,e,n){const s={},r=Object.assign({},n);return e.forEach(e=>{s[e]={type:t,then:r},r[e]=0}),s}("keyword",Bt,{"\n":s})),p={type:"keyword",then:{"":i,":":{type:"operator",then:{"":i}},"\n":s}},m={title:{type:"keyword",then:{"":i}},theme:{type:"keyword",then:{"":{type:"string",suggest:{global:"themes",suffix:"\n"},then:{"":0,"\n":s}}}},headers:{type:"keyword",then:{none:{type:"keyword",then:{}},cross:{type:"keyword",then:{}},box:{type:"keyword",then:{}},fade:{type:"keyword",then:{}},bar:{type:"keyword",then:{}}}},terminators:{type:"keyword",then:{none:{type:"keyword",then:{}},cross:{type:"keyword",then:{}},box:{type:"keyword",then:{}},fade:{type:"keyword",then:{}},bar:{type:"keyword",then:{}}}},divider:{type:"keyword",then:Object.assign({line:{type:"keyword",then:c},space:{type:"keyword",then:c},delay:{type:"keyword",then:c},tear:{type:"keyword",then:c}},c)},define:{type:"keyword",then:{"":o,as:zt}},begin:{type:"keyword",then:{"":o,reference:g,as:zt}},end:{type:"keyword",then:{"":o,as:zt,"\n":s}},if:p,else:{type:"keyword",suggest:["else\n","else if: "],then:{if:{type:"keyword",suggest:"if: ",then:{"":i,":":{type:"operator",then:{"":i}}}},"\n":s}},repeat:p,group:p,note:{type:"keyword",then:{over:{type:"keyword",then:{"":h}},left:e("left"),right:e("right"),between:{type:"keyword",then:{"":t({":":zt},h)}}}},state:{type:"keyword",suggest:"state over ",then:{over:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Agent"},then:{"":0,",":zt,":":a}}}}}},text:{type:"keyword",then:{left:e("left"),right:e("right")}},autolabel:{type:"keyword",then:{off:{type:"keyword",then:{}},"":f({"\n":s},[{v:"<label>",suffix:"\n",q:!0},{v:"[<inc>] <label>",suffix:"\n",q:!0},{v:"[<inc 1,0.01>] <label>",suffix:"\n",q:!0}])}},simultaneously:{type:"keyword",then:{":":{type:"operator",then:{}},with:{type:"keyword",then:{"":{type:"variable",suggest:{known:"Label"},then:{"":0,":":{type:"operator",then:{}}}}}}}}};return t=>({type:"error line-error",then:Object.assign({},m,function(t){const e={type:"keyword",then:Object.assign({},n({exit:l,sourceExit:{":":a,"\n":r}}),{"...":{type:"operator",then:{"":{type:"variable",suggest:{known:"DelayedAgent"},then:{"":0,":":zt,"\n":s}}}}})},i={};t.forEach(t=>i[t]=e);const o={type:"operator",suggest:!1,override:"Label",then:{}},h={type:"variable",suggest:{known:"Agent"},then:Object.assign({"":0},i,{":":{type:"operator",override:"Label",then:{}}})},d={type:"variable",suggest:{known:"DelayedAgent"},then:Object.assign({"":0,":":o},i)},g=Object.assign({},h,{then:Object.assign({},h.then,{is:{type:"keyword",then:u}})});return Object.assign({"...":{type:"operator",then:{"":d}}},n({exit:h,sourceExit:Object.assign({"":h,":":o},i),blankExit:g}))}(t))})})();class Ht{constructor(t,e){this.tokenDefinitions=t,this.commands=Tt(e),this.lineComment="#"}startState(){return{currentType:-1,current:"",currentSpace:"",currentQuoted:!1,knownAgent:[],knownDelayedAgent:[],knownLabel:[],beginCompletions:y({},[this.commands]),completions:[],nextCompletions:[],valid:!0,isVar:!0,line:[],indent:0}}_matchPattern(t,e,n){return e?(e.lastIndex=0,t.match(e,n)):null}_tokenBegin(t,e){e.currentSpace="";for(let n="";!t.eol();n=t.next()){e.currentSpace+=n;for(let n=0;n<this.tokenDefinitions.length;++n){const s=this.tokenDefinitions[n];if(this._matchPattern(t,s.start,!0)){e.currentType=n;const{value:t,quoted:r}=k(s);return e.current=t,e.currentQuoted=r,!0}}}return!1}_tokenCheckEscape(t,e,n){const s=this._matchPattern(t,n.escape,!0);s&&(e.current+=n.escapeWith(s))}_addToken(t){t.line.push({v:t.current,s:t.currentSpace,q:t.currentQuoted})}_tokenEndFound(t,e,n,s){return e.currentType=-1,n.includeEnd&&(e.current+=s[0]),n.omit?"comment":(this._addToken(e),w(e,t.eol(),this.commands))}_tokenEOLFound(t,e,n){if(e.current+="\n",n.omit)return"comment";this._addToken(e);const s=w(e,!1,this.commands);return e.line.pop(),s}_tokenEnd(t,e){for(;;){const n=this.tokenDefinitions[e.currentType];if(this._tokenCheckEscape(t,e,n),!n.end)return this._tokenEndFound(t,e,n,null);{const s=this._matchPattern(t,n.end,!0);if(s)return this._tokenEndFound(t,e,n,s)}if(t.eol())return this._tokenEOLFound(t,e,n);e.current+=t.next()}}token(t,e){e.completions=e.nextCompletions,e.isVar=!0,t.sol()&&-1===e.currentType&&(e.line.length=0);let n="";return(-1!==e.currentType||this._tokenBegin(t,e))&&(n=this._tokenEnd(t,e)),-1===e.currentType&&t.eol()&&!e.valid?"line-error "+n:n}indent(t){return t.indent}}const Vt=[{end:/(?=\n)|$/y,omit:!0,start:/#/y},{baseToken:{q:!0},end:/"/y,escape:/\\(.)/y,escapeWith:function(t){return"n"===t[1]?"\n":t[1]},start:/"/y},{baseToken:{v:"..."},start:/\.\.\./y},{end:/(?=[ \t\r\n:+~\-*!<>,])|$/y,start:/(?=[^ \t\r\n:+~\-*!<>,])/y},{end:/(?=[^~\-<>x])|[-~]x|[<>](?=x)|$/y,includeEnd:!0,start:/(?=[~\-<])/y},{baseToken:{v:","},start:/,/y},{baseToken:{v:":"},start:/:/y},{baseToken:{v:"!"},start:/!/y},{baseToken:{v:"+"},start:/\+/y},{baseToken:{v:"*"},start:/\*/y},{baseToken:{v:"\n"},start:/\n/y}];class Pt{constructor(t){this.src=t,this.block=null,this.token=null,this.pos={ch:0,i:0,ln:0},this.reset()}isOver(){return this.pos.i>this.src.length}reset(){this.token={b:null,e:null,q:!1,s:"",v:""},this.block=null}beginToken(t){this.block=t.newBlock,Object.assign(this.token,this.block.baseToken),this.token.b=F(this.pos)}endToken(){let t=null;return this.block.omit||(this.token.e=F(this.pos),t=this.token),this.reset(),t}advance(){const t=A(this.src,this.pos.i,this.block);return t.newBlock&&this.beginToken(t),this.token.s+=t.appendSpace,this.token.v+=t.appendValue,function(t,e,n){for(let s=0;s<n;++s)++t.ch,"\n"===e[t.i+s]&&(++t.ln,t.ch=0);t.i+=n}(this.pos,this.src,t.skip),t.end?this.endToken():null}}class jt{tokenise(t){const e=[],n=new Pt(t);for(;!n.isOver();){const t=n.advance();t&&e.push(t)}if(n.block)throw new Error("Unterminated literal (began at "+function(t){return"line "+(t.ln+1)+", character "+t.ch}(n.token.b)+")");return e}getCodeMirrorMode(t){return new Ht(Vt,t)}splitLines(t){const e=[];let n=[];return t.forEach(t=>{t.q||"\n"!==t.v?n.push(t):n.length>0&&(e.push(n),n=[])}),n.length>0&&e.push(n),e}}const qt=/(.*?)<([^<>]*)>/g,Yt=/\.([0-9]*)/,Wt=[{attrs:{"font-style":"italic"},begin:/[\s_~`]\*(?=\S)/g,end:/\S\*(?=[\s_~`])/g},{attrs:{"font-style":"italic"},begin:/[\s*~`]_(?=\S)/g,end:/\S_(?=[\s*~`])/g},{attrs:{"font-weight":"bolder"},begin:/[\s_~`]\*\*(?=\S)/g,end:/\S\*\*(?=[\s_~`])/g},{attrs:{"font-weight":"bolder"},begin:/[\s*~`]__(?=\S)/g,end:/\S__(?=[\s*~`])/g},{attrs:{"text-decoration":"line-through"},begin:/[\s_*`]~(?=\S)/g,end:/\S~(?=[\s_*`])/g},{attrs:{"font-family":"monospace"},begin:/[\s_*~.]`(?=\S)/g,end:/\S`(?=[\s_*~.])/g}],Ut={if:{type:"block begin",blockType:"if",tag:"if",skip:[]},else:{type:"block split",blockType:"else",tag:"else",skip:["if"]},repeat:{type:"block begin",blockType:"repeat",tag:"repeat",skip:[]},group:{type:"block begin",blockType:"group",tag:"",skip:[]}},Xt={types:(()=>{const t=function(t){const e=[];return i(t,0,[],e),e}([[{tok:"",type:0},{tok:"<",type:1},{tok:"<<",type:2}],[{tok:"-",type:"solid"},{tok:"--",type:"dash"},{tok:"~",type:"wave"}],[{tok:"",type:0},{tok:">",type:1},{tok:">>",type:2},{tok:"x",type:3}]]).filter(t=>0!==t[0].type||0!==t[2].type),e=new Map;return t.forEach(t=>{e.set(t.map(t=>t.tok).join(""),{line:t[1].type,left:t[0].type,right:t[2].type})}),e})(),agentFlags:{"*":{flag:"begin",allowBlankName:!0,blankNameFlag:"source"},"+":{flag:"start"},"-":{flag:"stop"},"!":{flag:"end"}}},Qt=["none","box","cross","fade","bar"],Jt={text:{mode:"text",types:{left:{type:"note left",skip:["of"],min:0,max:null},right:{type:"note right",skip:["of"],min:0,max:null}}},note:{mode:"note",types:{over:{type:"note over",skip:[],min:0,max:null},left:{type:"note left",skip:["of"],min:0,max:null},right:{type:"note right",skip:["of"],min:0,max:null},between:{type:"note between",skip:[],min:2,max:null}}},state:{mode:"state",types:{over:{type:"note over",skip:[],min:1,max:1}}}},Zt={line:{defaultHeight:6},space:{defaultHeight:6},delay:{defaultHeight:30},tear:{defaultHeight:6}},Kt={define:{type:"agent define"},begin:{type:"agent begin",mode:"box"},end:{type:"agent end",mode:"cross"}},_t=[(t,e)=>"title"!==D(t[0])?null:(e.title=I(t,1),!0),(t,e)=>"theme"!==D(t[0])?null:(e.theme=I(t,1),!0),(t,e)=>{if("terminators"!==D(t[0]))return null;const n=D(t[1]);if(!n)throw G("Unspecified termination",t[0]);if(-1===Qt.indexOf(n))throw G('Unknown termination "'+n+'"',t[1]);return e.terminators=n,!0},(t,e)=>{if("headers"!==D(t[0]))return null;const n=D(t[1]);if(!n)throw G("Unspecified header",t[0]);if(-1===Qt.indexOf(n))throw G('Unknown header "'+n+'"',t[1]);return e.headers=n,!0},t=>{if("divider"!==D(t[0]))return null;const e=N(t,":",{orEnd:!0}),n=N(t,["with","height"],{limit:e,orEnd:!0}),s=I(t,1,n)||"line";if(!Zt[s])throw G("Unknown divider type",t[1]);const r=function(t,e=0,n=null,s=Number.NAN){const r=I(t,e,n);return Number(r||s)}(t,n+2,e,Zt[s].defaultHeight);if(Number.isNaN(r)||r<0)throw G("Invalid divider height",t[n+2]);return{type:"divider",mode:s,height:r,label:I(t,e+1)}},t=>{if("autolabel"!==D(t[0]))return null;let e=null;return e="off"===D(t[1])?"<label>":I(t,1),{type:"label pattern",pattern:function(t){const e=[];let n=null,s=0;for(qt.lastIndex=0;n=qt.exec(t);)n[1]&&e.push(n[1]),n[2]&&e.push(S(n[2])),s=qt.lastIndex;const r=t.substr(s);return r&&e.push(r),e}(e)}},t=>{if("end"===D(t[0])&&1===t.length)return{type:"block end"};const e=Ut[D(t[0])];if(!e)return null;let n=1;return t.length>n&&(n=L(t,n,e.skip,"Invalid block command")),n=L(t,n,[":"]),{type:e.type,blockType:e.blockType,tag:e.tag,label:I(t,n)}},t=>{if("begin"!==D(t[0])||"reference"!==D(t[1]))return null;let e=[];const n=N(t,":");if("over"===D(t[2])&&n>3)e=z(t,3,n);else if(2!==n)throw G('Expected ":" or "over"',t[2]);const s=O(t,n+1,t.length,{aliases:!0});if(!s.alias)throw G("Reference must have an alias",t[n]);return{type:"group begin",agents:e,blockType:"ref",tag:"ref",label:s.name,alias:s.alias}},t=>{const e=Kt[D(t[0])];return!e||t.length<=1?null:Object.assign({agents:z(t,1,t.length,{aliases:!0})},e)},t=>{if("simultaneously"!==D(t[0]))return null;if(":"!==D(r(t)))return null;let e="";if(t.length>2){if("with"!==D(t[1]))return null;e=I(t,2,t.length-1)}return{type:"async",target:e}},t=>{const e=Jt[D(t[0])],n=N(t,":");if(!e||-1===n)return null;const s=e.types[D(t[1])];if(!s)return null;let r=2;const i=z(t,r=L(t,r,s.skip),n);if(i.length<s.min)throw G("Too few agents for "+e.mode,t[0]);if(null!==s.max&&i.length>s.max)throw G("Too many agents for "+e.mode,t[0]);return{type:s.type,agents:i,mode:e.mode,label:I(t,n+1)}},t=>{const e=N(t,":",{orEnd:!0}),n=function(t,e,{start:n=0,limit:s=null}={}){null===s&&(s=t.length);for(let r=n;r<s;++r){const n=e.get(D(t[r]));if(n)return{pos:r,value:n}}return null}(t,Xt.types,{start:0,limit:e-1});if(!n)return null;const s=n.pos,r={flagTypes:Xt.agentFlags};if("..."===D(t[0]))return{type:"connect-delay-end",tag:I(t,1,s),agent:O(t,s+1,e,r),label:I(t,e+1),options:n.value};if("..."===D(t[s+1])){if(e!==t.length)throw G("Cannot label beginning of delayed connection",t[e]);return{type:"connect-delay-begin",tag:I(t,s+2,e),agent:O(t,0,s,r),options:n.value}}return{type:"connect",agents:[O(t,0,s,r),O(t,s+1,e,r)],label:I(t,e+1),options:n.value}},t=>t.length<2||":"!==D(r(t))?null:{type:"mark",name:I(t,0,t.length-1)},t=>{const e=N(t,"is");if(e<1)return null;let n=e+1;if(["a","an"].includes(D(t[n]))&&++n,n===t.length)throw G("Empty agent options",{b:r(t).e});const s=O(t,0,e),i=[];for(let e=n;e<t.length;++e)i.push(t[e].v);return{type:"agent options",agent:s,options:i}}],$t=new jt;class te{getCodeMirrorMode(){return $t.getCodeMirrorMode(Array.from(Xt.types.keys()))}parseLines(t,e){const n={meta:{title:"",theme:"",code:e,terminators:"none",headers:"box",textFormatter:E},stages:[]};return t.forEach(t=>(function(t,{meta:e,stages:n}){let s=null;for(let n=0;n<_t.length&&!(s=_t[n](t,e));++n);if(!s)throw G("Unrecognised command: "+I(t),t[0]);"object"==typeof s&&(s.ln=t[0].b.ln,n.push(s))})(t,n)),n}parse(t){const e=$t.tokenise(t),n=$t.splitLines(e);return this.parseLines(n,t)}}class ee{makeState(){}resetState(t){this.makeState(t)}prepareMeasurements(){}separationPre(){}separation(){}renderPre(){}render(){}renderHidden(){}shouldHide(){}}const ne=new Map,se={class:"outline",fill:"transparent"};class re{getConfig(t,e){let n=null;return t.includes("database")&&(n=e.theme.agentCap.database),n||e.theme.agentCap.box}prepareMeasurements({formattedLabel:t,options:e},n){const s=this.getConfig(e,n);n.textSizer.expectMeasure(s.labelAttrs,t)}separation({formattedLabel:t,options:e},n){const s=this.getConfig(e,n),r=n.textSizer.measure(s.labelAttrs,t).width+s.padding.left+s.padding.right;return{left:r/2,radius:r/2,right:r/2}}topShift({formattedLabel:t,options:e},n){const s=this.getConfig(e,n),r=n.textSizer.measureHeight(s.labelAttrs,t)+s.padding.top+s.padding.bottom;return Math.max(0,r-s.arrowBottom)}render(t,{x:e,formattedLabel:n,options:s},r){const i=this.getConfig(s,r),a=r.svg.boxedText(i,n,{x:e,y:t});return r.makeRegion().add(a,r.svg.box(se,{height:a.height,width:a.width,x:e-a.width/2,y:t})),{height:a.height,lineBottom:a.height,lineTop:0}}}class ie{prepareMeasurements(){}separation(t,e){const n=e.theme.agentCap.cross;return{left:n.size/2,radius:0,right:n.size/2}}topShift(t,e){return e.theme.agentCap.cross.size/2}render(t,{x:e,options:n},s){const r=s.theme.agentCap.cross,i=r.size/2;return s.makeRegion().add(r.render({options:n,radius:i,x:e,y:t+i}),s.svg.box(se,{height:2*i,width:2*i,x:e-i,y:t})),{height:2*i,lineBottom:i,lineTop:i}}}class ae{prepareMeasurements({formattedLabel:t},e){const n=e.theme.agentCap.box;e.textSizer.expectMeasure(n.labelAttrs,t)}separation({formattedLabel:t},e){const n=e.theme.agentCap.box,s=e.textSizer.measure(n.labelAttrs,t).width+n.padding.left+n.padding.right;return{left:s/2,radius:s/2,right:s/2}}topShift(t,e){return e.theme.agentCap.bar.height/2}render(t,{x:e,formattedLabel:n,options:s},r){const i=r.theme.agentCap.box,a=r.theme.agentCap.bar,o=r.textSizer.measure(i.labelAttrs,n).width+i.padding.left+i.padding.right,{height:h}=a;return r.makeRegion().add(a.render({height:h,options:s,width:o,x:e-o/2,y:t}),r.svg.box(se,{height:h,width:o,x:e-o/2,y:t})),{height:h,lineBottom:h,lineTop:0}}}class oe{prepareMeasurements(){}separation({currentRad:t}){return{left:t,radius:t,right:t}}topShift(t,e,n){const s=e.theme.agentCap.fade;return n?s.height:0}render(t,{x:e},n,s){const r=n.theme.agentCap.fade,i=r.height/(r.height+r.extend),a=n.addDef(s?"FadeIn":"FadeOut",()=>n.svg.linearGradient({x1:"0%",x2:"0%",y1:s?"100%":"0%",y2:s?"0%":"100%"},[{offset:"0%","stop-color":"#FFFFFF"},{offset:(100*i).toFixed(3)+"%","stop-color":"#000000"}]));return n.lineMaskLayer.add(n.svg.box({fill:"url(#"+a+")"},{height:r.height+r.extend,width:r.width,x:e-r.width/2,y:t-(s?r.extend:0)})),n.makeRegion().add(n.svg.box(se,{height:r.height,width:r.width,x:e-r.width/2,y:t})),{height:r.height,lineBottom:0,lineTop:r.height}}}class he{prepareMeasurements(){}separation({currentRad:t}){return{left:t,radius:t,right:t}}topShift(t,e){return e.theme.agentCap.none.height}render(t,{x:e},n){const s=n.theme.agentCap.none;return n.makeRegion().add(n.svg.box(se,{height:s.height,width:10,x:e-5,y:t})),{height:s.height,lineBottom:0,lineTop:s.height}}}const le={bar:new ae,box:new re,cross:new ie,fade:new oe,none:new he};class de extends ee{constructor(t){super(),this.begin=t}prepareMeasurements({mode:t,agentIDs:e},n){e.forEach(e=>{const s=n.agentInfos.get(e);le[t].prepareMeasurements(s,n,this.begin)})}separationPre({mode:t,agentIDs:e},n){e.forEach(e=>{const s=n.agentInfos.get(e),r=le[t].separation(s,n,this.begin);n.addSpacing(e,r),s.currentMaxRad=Math.max(s.currentMaxRad,r.radius)})}separation({agentIDs:t},s){this.begin?e(s.visibleAgentIDs,t):n(s.visibleAgentIDs,t)}renderPre({mode:t,agentIDs:e},n){let s=0;return e.forEach(e=>{const r=n.agentInfos.get(e),i=le[t],a=i.topShift(r,n,this.begin);s=Math.max(s,a);const o=i.separation(r,n,this.begin).radius;r.currentMaxRad=Math.max(r.currentMaxRad,o)}),{agentIDs:e,topShift:s}}render({mode:t,agentIDs:e},n){let s=0;return e.forEach(e=>{const r=n.agentInfos.get(e),i=le[t],a=i.topShift(r,n,this.begin),o=n.primaryY-a,h=i.render(o,r,n,this.begin);s=Math.max(s,o+h.height),this.begin?n.drawAgentLine(e,o+h.lineBottom):n.drawAgentLine(e,o+h.lineTop,!0)}),s+n.theme.actionMargin}renderHidden({agentIDs:t},e){t.forEach(t=>{e.drawAgentLine(t,e.topY,!this.begin)})}}T("agent begin",new de(!0)),T("agent end",new de(!1));class ge extends ee{radius(t,e){return t?e.theme.agentLineHighlightRadius:0}separationPre({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);t.forEach(t=>{const e=n.agentInfos.get(t);e.currentRad=s,e.currentMaxRad=Math.max(e.currentMaxRad,s)})}renderPre({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);t.forEach(t=>{const e=n.agentInfos.get(t);e.currentMaxRad=Math.max(e.currentMaxRad,s)})}render({agentIDs:t,highlighted:e},n){const s=this.radius(e,n);return t.forEach(t=>{n.drawAgentLine(t,n.primaryY),n.agentInfos.get(t).currentRad=s}),n.primaryY+n.theme.actionMargin}renderHidden(t,e){this.render(t,e)}}T("agent highlight",new ge);const ce={class:"outline",fill:"transparent"};class ue extends ee{prepareMeasurements({left:t,tag:e,label:n},s){const r=s.state.blocks.get(t),i=s.theme.getBlock(r.type).section;s.textSizer.expectMeasure(i.tag.labelAttrs,e),s.textSizer.expectMeasure(i.label.labelAttrs,n)}separation({left:t,right:e,tag:n,label:s},r){const i=r.state.blocks.get(t),a=r.theme.getBlock(i.type).section,o=r.textSizer.measure(a.tag.labelAttrs,n).width+a.tag.padding.left+a.tag.padding.right+r.textSizer.measure(a.label.labelAttrs,s).width+a.label.padding.left+a.label.padding.right;r.addSeparation(t,e,o)}renderPre({left:t,right:e}){return{agentIDs:[t,e]}}render({left:t,right:e,tag:n,label:s},r,i=!1){const a=r.state.blocks.get(t),o=r.theme.getBlock(a.type),h=r.agentInfos.get(t),l=r.agentInfos.get(e);let d=r.primaryY;i||(d+=o.section.padding.bottom);const g=r.makeRegion(),c=r.svg.boxedText({boxAttrs:o.section.tag.boxAttrs,boxRenderer:o.section.tag.boxRenderer,labelAttrs:o.section.tag.labelAttrs,padding:o.section.tag.padding},n,{x:h.x,y:d}),u=r.svg.boxedText({boxAttrs:{fill:"#000000"},labelAttrs:o.section.label.labelAttrs,padding:o.section.label.padding},s,{x:h.x+c.width,y:d}),p=Math.max(Math.max(c.height,u.height),o.section.label.minHeight);return a.hold.add(c.box),r.lineMaskLayer.add(u.box),g.add(r.svg.box(ce,{height:p,width:l.x-h.x,x:h.x,y:d}),c.label,u.label),i?a.canHide&&g.addClass(a.hide?"collapsed":"expanded"):a.hold.add(o.sepRenderer({x1:h.x,x2:l.x,y1:d,y2:d})),d+p+o.section.padding.top}}class pe extends ue{makeState(t){t.blocks=new Map}resetState(t){t.blocks.clear()}storeBlockInfo(t,e){const{canHide:n}=t,s={canHide:n,hide:n&&e.renderer.isCollapsed(t.ln),hold:null,startY:null,type:t.blockType};return e.state.blocks.set(t.left,s),s}prepareMeasurements(t,e){this.storeBlockInfo(t,e),super.prepareMeasurements(t,e)}separationPre(t,e){this.storeBlockInfo(t,e),super.separationPre(t,e)}separation(t,n){e(n.visibleAgentIDs,[t.left,t.right]),super.separation(t,n)}renderPre(t,e){const n=this.storeBlockInfo(t,e),s=e.theme.getBlock(n.type);return{agentIDs:[t.left,t.right],topShift:s.margin.top}}render(t,e){const n=e.svg.el("g");e.blockLayer.add(n);const s=e.state.blocks.get(t.left);return s.hold=n,s.startY=e.primaryY,super.render(t,e,!0)}shouldHide({left:t},e){return{nest:e.state.blocks.get(t).hide?1:0,self:!1}}}class fe extends ee{separation({left:t,right:e},s){n(s.visibleAgentIDs,[t,e])}renderPre({left:t,right:e},n){const s=n.state.blocks.get(t);return{agentIDs:[t,e],topShift:n.theme.getBlock(s.type).section.padding.bottom}}render({left:t,right:e},n){const s=n.state.blocks.get(t),r=n.theme.getBlock(s.type),i=n.agentInfos.get(t),a=n.agentInfos.get(e);let o=r.boxRenderer;s.hide&&(o=r.collapsedBoxRenderer||o);let h=o({height:n.primaryY-s.startY,width:a.x-i.x,x:i.x,y:s.startY});return h.shape||(h={shape:h}),s.hold.add(h.shape),n.fillLayer.add(h.fill),n.lineMaskLayer.add(h.mask),n.primaryY+r.margin.bottom+n.theme.actionMargin}shouldHide({left:t},e){return{nest:e.state.blocks.get(t).hide?-1:0,self:!1}}}T("block begin",new pe),T("block split",new ue),T("block end",new fe);const me={class:"outline",fill:"transparent"};class be{constructor(t){this.propName=t}getConfig(t){return t.connect.arrow[this.propName]}short(t){const e=this.getConfig(t),n=e.attrs["stroke-linejoin"]||"miter",s=.5*e.attrs["stroke-width"],r=.5*t.agentLineAttrs[""]["stroke-width"];if("round"===n)return r+s;{const t=e.height/2,n=e.width;return r+s*Math.sqrt(n*n/(t*t)+1)}}render(t,e,n,s){const r=this.getConfig(e),i=this.short(e);t.add(r.render(r.attrs,{x:n.x+i*s.dx,y:n.y+i*s.dy,width:r.width,height:r.height,dir:s}))}width(t){return this.short(t)+this.getConfig(t).width}height(t){return this.getConfig(t).height}lineGap(t,e){const n=this.getConfig(t),s=this.short(t);if("none"===n.attrs.fill){const t=n.height/2,r=n.width;return(s+(s+e["stroke-width"]/2*(r/t)))/2}return s+n.width/2}}class ye{getConfig(t){return t.connect.arrow.cross}render(t,e,n,s){const r=this.getConfig(e);t.add(r.render({x:n.x+r.short*s.dx,y:n.y+r.short*s.dy,radius:r.radius}))}width(t){const e=this.getConfig(t);return e.short+e.radius}height(t){return 2*this.getConfig(t).radius}lineGap(t){return this.getConfig(t).short}}const xe=[{render:()=>null,width:()=>0,height:()=>0,lineGap:()=>0},new be("single"),new be("double"),new ye];class we extends ee{prepareMeasurements({agentIDs:t,label:e},n){const s=n.theme.connect,r=t[0]===t[1]?s.label.loopbackAttrs:s.label.attrs;n.textSizer.expectMeasure(r,e)}separationPre({agentIDs:t},e){const n=e.theme.connect.source.radius;t.forEach(t=>{const s=e.agentInfos.get(t);s.isVirtualSource&&(s.currentRad=n,s.currentMaxRad=Math.max(s.currentMaxRad,n))})}separation({label:t,agentIDs:n,options:s},r){const i=r.theme.connect,a=xe[s.left],o=xe[s.right],h=n[0]===n[1],l=h?i.label.loopbackAttrs:i.label.attrs;let d=r.textSizer.measure(l,t).width;d>0&&(d+=2*i.label.padding);const g=r.agentInfos.get(n[0]);if(h)r.addSpacing(n[0],{left:0,right:g.currentMaxRad+Math.max(d+a.width(r.theme),o.width(r.theme))+i.loopbackRadius});else{const t=r.agentInfos.get(n[1]);r.addSeparation(n[0],n[1],g.currentMaxRad+t.currentMaxRad+d+2*Math.max(a.width(r.theme),o.width(r.theme)))}e(r.momentaryAgentIDs,n)}renderRevArrowLine({x1:t,y1:e,x2:n,y2:s,xR:r},i,a,o){const h=a.theme.connect,l=h.line[i.line],d=xe[i.left],g=xe[i.right],c=d.lineGap(a.theme,l.attrs),u=g.lineGap(a.theme,l.attrs),p=l.renderRev(l.attrs,{x1:t+c,y1:e,x2:n+u,y2:s,xR:r,rad:h.loopbackRadius});o.add(p.shape),d.render(o,a.theme,{x:p.p1.x-c,y:p.p1.y},{dx:1,dy:0}),g.render(o,a.theme,{x:p.p2.x-u,y:p.p2.y},{dx:1,dy:0})}renderSelfConnect({label:t,agentIDs:e,options:n},s,r,i){const a=s.theme.connect,o=xe[n.left],h=xe[n.right],l=s.agentInfos.get(e[1]),d=t?s.textSizer.measureHeight(a.label.attrs,t)+a.label.margin.top+a.label.margin.bottom:0,g=r.x+r.currentMaxRad+o.width(s.theme)+(t?a.label.padding:0),c=s.svg.boxedText({padding:a.mask.padding,boxAttrs:{fill:"#000000"},labelAttrs:a.label.loopbackAttrs},t,{x:g-a.mask.padding.left,y:i-d+a.label.margin.top}),u=t?c.width+a.label.padding-a.mask.padding.left-a.mask.padding.right:0,p=Math.max(l.x+l.currentMaxRad+h.width(s.theme),g+u),f=Math.max(d,o.height(s.theme)/2),m=h.height(s.theme)/2;s.lineMaskLayer.add(c.box);const b=s.makeRegion().add(s.svg.box(me,{x:r.x,y:i-f,width:p+a.loopbackRadius-r.x,height:f+s.primaryY-i+m}),c.label);return this.renderRevArrowLine({x1:r.x+r.currentMaxRad,y1:i,x2:l.x+l.currentMaxRad,y2:s.primaryY,xR:p},n,s,b),s.primaryY+Math.max(m,0)+s.theme.actionMargin}renderArrowLine({x1:t,y1:e,x2:n,y2:s},r,i,a){const o=i.theme.connect.line[r.line],h=xe[r.left],l=xe[r.right],d=Math.sqrt((n-t)*(n-t)+(s-e)*(s-e)),g=h.lineGap(i.theme,o.attrs),c=l.lineGap(i.theme,o.attrs),u=(n-t)/d,p=(s-e)/d,f=o.renderFlat(o.attrs,{x1:t+g*u,y1:e+g*p,x2:n-c*u,y2:s-c*p});a.add(f.shape);const m={x:f.p1.x-g*u,y:f.p1.y-g*p},b={x:f.p2.x+c*u,y:f.p2.y+c*p};return h.render(a,i.theme,m,{dx:u,dy:p}),l.render(a,i.theme,b,{dx:-u,dy:-p}),{p1:m,p2:b,lArrow:h,rArrow:l}}renderVirtualSources({from:t,to:e,rendered:n},s,r){const i=s.theme.connect.source;t.isVirtualSource&&r.add(i.render({x:n.p1.x-i.radius,y:n.p1.y,radius:i.radius})),e.isVirtualSource&&r.add(i.render({x:n.p2.x+i.radius,y:n.p2.y,radius:i.radius}))}renderSimpleLabel(t,{layer:e,x1:n,x2:s,y1:r,y2:i,height:a},o){const h=o.theme.connect,l=(n+s)/2,d=(r+i)/2;let g=e;const c={fill:"#000000"};if(r!==i){const t="rotate("+180*Math.atan((i-r)/(s-n))/Math.PI+" "+l+","+d+")";c.transform=t,g=o.svg.el("g").attr("transform",t),e.add(g)}const u=o.svg.boxedText({padding:h.mask.padding,boxAttrs:c,labelAttrs:h.label.attrs},t,{x:l,y:d+h.label.margin.top-a});o.lineMaskLayer.add(u.box),g.add(u.label)}renderSimpleConnect({label:t,agentIDs:e,options:n},s,r,i){const a=s.theme.connect,o=s.agentInfos.get(e[1]),h=r.x<o.x?1:-1,l=s.textSizer.measureHeight(a.label.attrs,t)+a.label.margin.top+a.label.margin.bottom,d=r.x+r.currentMaxRad*h,g=o.x-o.currentMaxRad*h,c=s.makeRegion(),u=this.renderArrowLine({x1:d,y1:i,x2:g,y2:s.primaryY},n,s,c),p=Math.max(u.lArrow.height(s.theme),u.rArrow.height(s.theme))/2,f=Math.max(l,p);return this.renderVirtualSources({from:r,to:o,rendered:u},s,c),c.add(s.svg.el("path").attrs(me).attr("d","M"+d+","+(i-f)+"L"+g+","+(s.primaryY-f)+"L"+g+","+(s.primaryY+p)+"L"+d+","+(i+p)+"Z")),this.renderSimpleLabel(t,{layer:c,x1:d,y1:i,x2:g,y2:s.primaryY,height:l},s),s.primaryY+Math.max(p+s.theme.minActionMargin,s.theme.actionMargin)}renderPre({label:t,agentIDs:e,options:n},s){const r=s.theme.connect,i=xe[n.left],a=xe[n.right],o=s.textSizer.measureHeight(r.label.attrs,t)+r.label.margin.top+r.label.margin.bottom;let h=i.height(s.theme);return e[0]!==e[1]&&(h=Math.max(h,a.height(s.theme))),{agentIDs:e,topShift:Math.max(h/2,o)}}render(t,e,n=null,s=null){let r=s,i=n;return null===n&&(i=e.agentInfos.get(t.agentIDs[0]),r=e.primaryY),t.agentIDs[0]===t.agentIDs[1]?this.renderSelfConnect(t,e,i,r):this.renderSimpleConnect(t,e,i,r)}}class ke extends we{makeState(t){t.delayedConnections=new Map}resetState(t){t.delayedConnections.clear()}separation(t,n){super.separation(t,n),e(n.momentaryAgentIDs,[t.agentIDs[0]])}renderPre(t,e){return Object.assign(super.renderPre(t,e),{agentIDs:[t.agentIDs[0]]})}render(t,e){return e.state.delayedConnections.set(t.tag,{stage:t,from:Object.assign({},e.agentInfos.get(t.agentIDs[0])),y:e.primaryY}),e.primaryY+e.theme.actionMargin}renderHidden(t,e){this.render(t,e)}}class ve extends we{prepareMeasurements(){}separationPre(){}separation(){}renderPre({tag:t},e){const n=e.theme.connect,s=e.state.delayedConnections.get(t),r=s.stage,i=[r.agentIDs[1]];return r.agentIDs[0]===r.agentIDs[1]?{agentIDs:i,y:s.y+2*n.loopbackRadius}:Object.assign(super.renderPre(r,e),{agentIDs:i})}render({tag:t},e){const n=e.state.delayedConnections.get(t);return super.render(n.stage,e,n.from,n.y)}}T("connect",new we),T("connect-delay-begin",new ke),T("connect-delay-end",new ve);const Ae={class:"outline",fill:"transparent"};class Fe extends ee{prepareMeasurements({mode:t,formattedLabel:e},n){const s=n.theme.getDivider(t);n.textSizer.expectMeasure(s.labelAttrs,e)}separation({mode:t,formattedLabel:e},n){const s=n.theme.getDivider(t),r=n.textSizer.measure(s.labelAttrs,e).width+s.padding.left+s.padding.right;n.addSeparation("[","]",r),n.addSpacing("[",{left:s.extend,right:0}),n.addSpacing("]",{left:0,right:s.extend})}renderPre(){return{agentIDs:["[","]"]}}render({mode:t,height:e,formattedLabel:n},s){const r=s.theme.getDivider(t),i=s.agentInfos.get("["),a=s.agentInfos.get("]");let o=0,h=0;n&&(h=s.textSizer.measureHeight(r.labelAttrs,n));const l=Math.max(e,h)+r.margin;let d=null;if(n){const t=s.svg.boxedText({boxAttrs:{fill:"#000000"},labelAttrs:r.labelAttrs,padding:r.padding},n,{x:(i.x+a.x)/2,y:s.primaryY+(l-h)/2-r.padding.top});s.fullMaskLayer.add(t.box),d=t.label,o=t.width}const{shape:g,mask:c}=r.render({env:s,height:e,labelHeight:h,labelWidth:o,width:a.x-i.x+2*r.extend,x:i.x-r.extend,y:s.primaryY+(l-e)/2});return s.fullMaskLayer.add(c),s.makeRegion({unmasked:!0}).add(s.svg.box(Ae,{height:l,width:a.x-i.x+2*r.extend,x:i.x-r.extend,y:s.primaryY}),g,d),s.primaryY+l+s.theme.actionMargin}}T("divider",new Fe);class Me extends ee{makeState(t){t.marks=new Map}resetState(t){t.marks.clear()}render({name:t},{topY:e,state:n}){n.marks.set(t,e)}renderHidden(t,e){this.render(t,e)}}class Se extends ee{renderPre({target:t},{state:e}){let n=0;return t&&e.marks&&(n=e.marks.get(t)||0),{asynchronousY:n}}}T("mark",new Me),T("async",new Se);const Re={class:"outline",fill:"transparent"};class Ce extends ee{prepareMeasurements({mode:t,label:e},n){const s=n.theme.getNote(t);n.textSizer.expectMeasure(s.labelAttrs,e)}renderPre({agentIDs:t}){return{agentIDs:t}}renderNote({xMid:t=null,x0:e=null,x1:n=null,mode:s,label:r},i){const a=i.theme.getNote(s),o=i.topY+a.margin.top+a.padding.top,h=i.svg.formattedText(a.labelAttrs,r),l=i.textSizer.measure(h),d=l.width+a.padding.left+a.padding.right,g=a.padding.top+l.height+a.padding.bottom;switch(null===e&&null!==t&&(e=t-d/2),null===n&&null!==e?n=e+d:null===e&&(e=n-d),a.labelAttrs["text-anchor"]){case"middle":h.set({x:(e+a.padding.left+n-a.padding.right)/2,y:o});break;case"end":h.set({x:n-a.padding.right,y:o});break;default:h.set({x:e+a.padding.left,y:o})}return i.makeRegion().add(a.boxRenderer({height:g,width:n-e,x:e,y:i.topY+a.margin.top}),i.svg.box(Re,{height:g,width:n-e,x:e,y:i.topY+a.margin.top}),h),i.topY+a.margin.top+g+a.margin.bottom+i.theme.actionMargin}}class Ee extends Ce{separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),i=s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right,{left:a,right:o}=V(s.agentInfos,t),h=s.agentInfos.get(a),l=s.agentInfos.get(o);if(h===l)s.addSpacing(a,{left:i/2,right:i/2});else{const t=h.currentMaxRad+r.overlap.left,e=l.currentMaxRad+r.overlap.right;s.addSeparation(a,o,i-t-e),s.addSpacing(a,{left:t,right:0}),s.addSpacing(o,{left:0,right:e})}}render({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=V(s.agentInfos,t),o=s.agentInfos.get(i),h=s.agentInfos.get(a);if(o===h){const t=o.x;return this.renderNote({label:n,mode:e,xMid:t},s)}return this.renderNote({label:n,mode:e,x0:o.x-o.currentMaxRad-r.overlap.left,x1:h.x+h.currentMaxRad+r.overlap.right},s)}}class Ge extends Ce{constructor(t){super(),this.isRight=t}separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=V(s.agentInfos,t),o=s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right+r.margin.left+r.margin.right;if(this.isRight){const t=s.agentInfos.get(a);s.addSpacing(a,{left:0,right:o+t.currentMaxRad})}else{const t=s.agentInfos.get(i);s.addSpacing(i,{left:o+t.currentMaxRad,right:0})}}render({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=V(s.agentInfos,t);if(this.isRight){const t=s.agentInfos.get(a),i=t.x+t.currentMaxRad+r.margin.left;return this.renderNote({label:n,mode:e,x0:i},s)}{const t=s.agentInfos.get(i),a=t.x-t.currentMaxRad-r.margin.right;return this.renderNote({label:n,mode:e,x1:a},s)}}}class Ie extends Ce{separation({agentIDs:t,mode:e,label:n},s){const r=s.theme.getNote(e),{left:i,right:a}=V(s.agentInfos,t),o=s.agentInfos.get(i),h=s.agentInfos.get(a);s.addSeparation(i,a,s.textSizer.measure(r.labelAttrs,n).width+r.padding.left+r.padding.right+r.margin.left+r.margin.right+o.currentMaxRad+h.currentMaxRad)}render({agentIDs:t,mode:e,label:n},s){const{left:r,right:i}=V(s.agentInfos,t),a=s.agentInfos.get(r),o=s.agentInfos.get(i),h=(a.x+a.currentMaxRad+o.x-o.currentMaxRad)/2;return this.renderNote({label:n,mode:e,xMid:h},s)}}T("note over",new Ee),T("note left",new Ge(!1)),T("note right",new Ge(!0)),T("note between",new Ie);class De extends ee{invokeChildren(t,e,n){return t.stages.map(t=>{return e.components.get(t.type)[n](t,e)})}prepareMeasurements(t,e){this.invokeChildren(t,e,"prepareMeasurements")}separationPre(t,e){this.invokeChildren(t,e,"separationPre")}separation(t,e){this.invokeChildren(t,e,"separation")}renderPre(t,e){return this.invokeChildren(t,e,"renderPre").map(t=>B(t)).reduce(j,{agentIDs:[],asynchronousY:null,topShift:0})}render(t,e){const n=e.makeRegion;let s=0;return t.stages.forEach(t=>{e.makeRegion=((e={})=>n(Object.assign({stageOverride:t},e)));const r=e.components.get(t.type).render(t,e)||0;s=Math.max(s,r)}),e.makeRegion=n,s}renderHidden(t,e){this.invokeChildren(t,e,"renderHidden")}shouldHide(t,e){return this.invokeChildren(t,e,"shouldHide").reduce((t,{self:e=!1,nest:n=0}={})=>({nest:t.nest+n,self:t.self||Boolean(e)}),{nest:0,self:!1})}}T("parallel",new De);class Le{constructor(t){this.element=t}addBefore(t=null,e=null){if(null===t)return this;if(Array.isArray(t))for(const n of t)this.addBefore(n,e);else{const n=function(t,e){return"string"==typeof t?e.createTextNode(t):"number"==typeof t?e.createTextNode(t.toString(10)):"object"==typeof t&&t.element?t.element:t}(t,this.element.ownerDocument);this.element.insertBefore(n,q(e))}return this}add(...t){return this.addBefore(t,null)}del(t=null){return null!==t&&this.element.removeChild(q(t)),this}attr(t,e){return this.element.setAttribute(t,e),this}attrs(t){for(const e in t)Object.prototype.hasOwnProperty.call(t,e)&&this.element.setAttribute(e,t[e]);return this}styles(t){for(const e in t)Object.prototype.hasOwnProperty.call(t,e)&&(this.element.style[e]=t[e]);return this}setClass(t){return this.attr("class",t)}addClass(t){const e=this.element.getAttribute("class");if(!e)return this.setClass(t);const n=e.split(" ");return n.includes(t)?this:(n.push(t),this.attr("class",n.join(" ")))}delClass(t){const e=this.element.getAttribute("class");if(!e)return this;const n=e.split(" "),s=n.indexOf(t);return-1!==s&&(n.splice(s,1),this.attr("class",n.join(" "))),this}text(t){return this.element.textContent=t,this}on(t,e,n={}){if(Array.isArray(t))for(const s of t)this.on(s,e,n);else this.element.addEventListener(t,e,n);return this}off(t,e,n={}){if(Array.isArray(t))for(const s of t)this.off(s,e,n);else this.element.removeEventListener(t,e,n);return this}val(t){return this.element.value=t,this}select(t,e=null){return this.element.selectionStart=t,this.element.selectionEnd=null===e?t:e,this}focus(){return this.element.focus(),this}focussed(){return this.element===this.element.ownerDocument.activeElement}empty(){for(;this.element.childNodes.length>0;)this.element.removeChild(this.element.lastChild);return this}attach(t){return q(t).appendChild(this.element),this}detach(){return this.element.parentNode.removeChild(this.element),this}}class Ne{constructor(t){if(!t)throw new Error("Missing document!");this.document=t,this.wrap=this.wrap.bind(this),this.el=this.el.bind(this),this.txt=this.txt.bind(this)}wrap(t){return t.element?t:new Le(t)}el(t,e=null){let n=null;return n=null===e?this.document.createElement(t):this.document.createElementNS(e,t),new Le(n)}txt(t=""){return this.document.createTextNode(t)}}const Oe=[];class ze{constructor(t,e,n={}){this.container=t,this.svg=e,this.state={attrs:{},formatted:Oe,x:0,y:0},this.lines=[],this.set(n)}_rebuildLines(t){if(t>this.lines.length)for(;this.lines.length<t;)this.lines.push({latest:"",node:this.svg.el("text").attr("x",this.state.x).attrs(this.state.attrs).attach(this.container)});else for(;this.lines.length>t;)this.lines.pop().node.detach()}_reset(){this._rebuildLines(0)}_renderText(){const{formatted:t}=this.state;if(t&&t.length){if(!Array.isArray(t))throw new Error("Invalid formatted text: "+t);this._rebuildLines(t.length),this.lines.forEach((e,n)=>{const s=JSON.stringify(t[n]);s!==e.latest&&(e.node.empty(),Y(this.svg,e.node,t[n]),e.latest=s)})}else this._reset()}_updateX(){this.lines.forEach(({node:t})=>{t.attr("x",this.state.x)})}_updateY(){const t=this.svg.textSizer;let e=this.state.y;for(let n=0;n<this.lines.length;++n){const s=[this.state.formatted[n]],r=t.baseline(this.state.attrs,s);this.lines[n].node.attr("y",e+r),e+=t.measureHeight(this.state.attrs,s)}}set(t){const e=Object.assign({},this.state);!function(t,e){for(const n in t)Object.prototype.hasOwnProperty.call(t,n)&&null!==e[n]&&void 0!==e[n]&&(t[n]=e[n])}(this.state,t),this.state.attrs!==e.attrs&&(this._reset(),e.formatted=Oe);const n=this.lines.length;this.state.formatted!==e.formatted&&this._renderText(),this.state.x!==e.x&&this._updateX(),this.state.y===e.y&&this.lines.length===n||this._updateY()}}class Be{constructor(t){this.svg=t,this.testers=this.svg.el("g").attrs({display:kt?"block":"none",visibility:"hidden"}),this.container=t.body}baseline({attrs:t}){return Number(t["font-size"])}measureHeight({attrs:t,formatted:e}){const n=this.baseline({attrs:t,formatted:e})*(Number(t["line-height"])||1);return e.length*n}prepMeasurement(t,e){const n=this.svg.el("text").attrs(t).attach(this.testers);return Y(this.svg,n,e),n}prepComplete(){this.container.add(this.testers)}performMeasurement(t){return t.element.getComputedTextLength()}teardown(){this.container.del(this.testers.empty())}}class Te{constructor(t=null,e=0){this.pattern=t,this.dw=t&&t.partWidth,this.points=[],this.phase=e,this.x=null,this.y=null,this.disconnect=0}_nextDelta(){return this.pattern.getDelta(this.phase++)}_link(){2===this.disconnect&&(this.points.push(this.x+" "+this.y),this.disconnect=0)}cap(){return this.disconnect>0&&(this.points.push(this.x+" "+this.y),this.disconnect=0),this}move(t,e){return this.cap(),this.x=t,this.y=e,this.disconnect=2,this}line(t,e,{patterned:n=!0}={}){if(this.pattern&&n){const n=Math.sqrt((t-this.x)*(t-this.x)+(e-this.y)*(e-this.y)),s=(t-this.x)/n,r=(e-this.y)/n,i=-r,a=s;for(let t=0;t+this.dw<=n;t+=this.dw){const e=this._nextDelta();this.points.push(this.x+t*s+e*i+" "+(this.y+t*r+e*a))}this.disconnect=1}else this._link(),this.disconnect=2;return this.x=t,this.y=e,this}arc(t,e,n){const s=Math.sqrt((t-this.x)*(t-this.x)+(e-this.y)*(e-this.y)),r=Math.atan2(this.x-t,e-this.y),i=t+Math.sin(r+n)*s,a=e-Math.cos(r+n)*s;if(this.pattern){const i=n<0?1:-1,a=this.dw/s;for(let o=r;o+a<=r+n;o+=a){const n=this._nextDelta()*i;this.points.push(t+Math.sin(o)*(s+n)+" "+(e-Math.cos(o)*(s+n)))}this.disconnect=1}else this.points.push(this.x+" "+this.y+"A"+s+" "+s+" 0 "+(Math.abs(n)>=Math.PI?"1 ":"0 ")+(n<0?"0 ":"1 ")+i+" "+a),this.disconnect=0;return this.x=i,this.y=a,this}asPath(){return this._link(),"M"+this.points.join("L")}}const He="http://www.w3.org/2000/svg";class Ve{constructor(t){this.sizer=t,this.cache=new Map,this.active=null}_expectMeasure({attrs:t,formatted:e}){if(!e.length)return null;const n=JSON.stringify(t);let s=this.cache.get(n);return s||(s={attrs:t,lines:new Map},this.cache.set(n,s)),e.forEach(t=>{if(!t.length)return;const e=JSON.stringify(t);s.lines.has(e)||s.lines.set(e,{formatted:t,width:null})}),s}_measureLine(t,e){if(!e.length)return 0;const n=JSON.stringify(e),s=t.lines.get(n);return null===s.width&&(window.console.warn("Performing unexpected measurement",e),this.performMeasurements()),s.width}_measureWidth(t){if(!t.formatted.length)return 0;const e=this._expectMeasure(t);return t.formatted.map(t=>this._measureLine(e,t)).reduce((t,e)=>Math.max(t,e),0)}_getMeasurementOpts(t,e){const n={attrs:t,formatted:e};if(e||(t.textBlock?(n.attrs=t.textBlock.state.attrs,n.formatted=t.textBlock.state.formatted):t.state&&(n.attrs=t.state.attrs,n.formatted=t.state.formatted),n.formatted=n.formatted||[]),!Array.isArray(n.formatted))throw new Error("Invalid formatted text: "+n.formatted);return n}expectMeasure(t,e){const n=this._getMeasurementOpts(t,e);this._expectMeasure(n)}performMeasurementsPre(){this.active=[],this.cache.forEach(({attrs:t,lines:e})=>{e.forEach(e=>{null===e.width&&this.active.push({cacheLine:e,data:this.sizer.prepMeasurement(t,e.formatted)})})}),this.active.length&&this.sizer.prepComplete()}performMeasurementsAct(){this.active.forEach(({data:t,cacheLine:e})=>{e.width=this.sizer.performMeasurement(t)})}performMeasurementsPost(){this.active.length&&this.sizer.teardown(),this.active=null}performMeasurements(){try{this.performMeasurementsPre(),this.performMeasurementsAct()}finally{this.performMeasurementsPost()}}measure(t,e){const n=this._getMeasurementOpts(t,e);return{height:this.sizer.measureHeight(n),width:this._measureWidth(n)}}baseline(t,e){const n=this._getMeasurementOpts(t,e);return this.sizer.baseline(n)}measureHeight(t,e){const n=this._getMeasurementOpts(t,e);return this.sizer.measureHeight(n)}resetCache(){this.cache.clear()}}class Pe{constructor(t,e=null){this.dom=t,this.body=this.el("svg").attr("xmlns",He).attr("version","1.1");const n=e||(t=>new Be(t));this.textSizer=new Ve(n(this)),this.txt=this.txt.bind(this),this.el=this.el.bind(this)}linearGradient(t,e){return this.el("linearGradient").attrs(t).add(e.map(t=>this.el("stop").attrs(t)))}patternedLine(t=null,e=0){return new Te(t,e)}txt(t){return this.dom.txt(t)}el(t,e=He){return this.dom.el(t,e)}box(t,{height:e,width:n,x:s,y:r}){return this.el("rect").attrs(t).attrs({height:e,width:n,x:s,y:r})}boxFactory(t){return this.box.bind(this,t)}line(t,{x1:e,x2:n,y1:s,y2:r}){return this.el("line").attrs(t).attrs({x1:e,x2:n,y1:s,y2:r})}lineFactory(t){return this.line.bind(this,t)}circle(t,{x:e,y:n,radius:s}){return this.el("circle").attrs({cx:e,cy:n,r:s}).attrs(t)}circleFactory(t){return this.circle.bind(this,t)}cross(t,{x:e,y:n,radius:s}){return this.el("path").attr("d","M"+(e-s)+" "+(n-s)+"l"+2*s+" "+2*s+"m0 "+2*-s+"l"+2*-s+" "+2*s).attrs(t)}crossFactory(t){return this.cross.bind(this,t)}note(t,e,{height:n,width:s,x:r,y:i}){const a=r,o=r+s,h=i,l=i+n;return this.el("g").add(this.el("polygon").attr("points",a+" "+h+" "+(o-7)+" "+h+" "+o+" "+(h+7)+" "+o+" "+l+" "+a+" "+l).attrs(t),this.el("polyline").attr("points",o-7+" "+h+" "+(o-7)+" "+(h+7)+" "+o+" "+(h+7)).attrs(e))}noteFactory(t,e){return this.note.bind(this,t,e)}formattedText(t={},e=[],{x:n,y:s}={}){const r=this.el("g"),i=new ze(r,this,{attrs:t,formatted:e,x:n,y:s});return Object.assign(r,{set:t=>i.set(t),textBlock:i})}formattedTextFactory(t){return this.formattedText.bind(this,t)}boxedText({padding:t,labelAttrs:e,boxAttrs:n={},boxRenderer:s=null},r,{x:i,y:a}){if(!r||!r.length)return Object.assign(this.el("g"),{box:null,height:0,label:null,width:0});const{shift:o,anchorX:h}=function(t,e,n){let s=0,r=t;switch(e["text-anchor"]){case"middle":s=.5,r+=(n.left-n.right)/2;break;case"end":s=1,r-=n.right;break;default:s=0,r+=n.left}return{anchorX:r,shift:s}}(i,e,t),l=this.formattedText(e,r,{x:h,y:a+t.top}),d=this.textSizer.measure(l),g=d.width+t.left+t.right,c=d.height+t.top+t.bottom,u=(s||this.boxFactory(n))({height:c,width:g,x:h-d.width*o-t.left,y:a});return Object.assign(this.el("g").add(u,l),{box:u,height:c,label:l,width:g})}boxedTextFactory(t){return this.boxedText.bind(this,t)}}let je=0;class qe extends yt{constructor({themes:t=[],namespace:e=null,components:n=null,document:s,textSizerFactory:r=null}={}){super(),this._bindMethods(),this.state={},this.width=0,this.height=0,this.themes=function(t){if(0===t.length)throw new Error("Cannot render without a theme");const e=new Map;return t.forEach(t=>{e.set(t.name,t)}),e.set("",t[0]),e}(t),this.themeBuilder=null,this.theme=null,this.namespace=function(t){return null===t?"R"+je++:t}(e),this.components=n||H(),this.svg=new Pe(new Ne(s),r),this.knownThemeDefs=new Set,this.knownDefs=new Set,this.highlights=new Map,this.collapsed=new Set,this.currentHighlight=-1,this.buildStaticElements(),this.components.forEach(t=>{t.makeState(this.state)})}_bindMethods(){this.separationStage=this.separationStage.bind(this),this.prepareMeasurementsStage=this.prepareMeasurementsStage.bind(this),this.renderStage=this.renderStage.bind(this),this.addThemeDef=this.addThemeDef.bind(this),this.addDef=this.addDef.bind(this)}addTheme(t){this.themes.set(t.name,t)}buildStaticElements(){const{el:t}=this.svg;this.metaCode=this.svg.txt(),this.themeDefs=t("defs"),this.defs=t("defs"),this.fullMask=t("mask").attrs({id:this.namespace+"FullMask",maskUnits:"userSpaceOnUse"}),this.lineMask=t("mask").attrs({id:this.namespace+"LineMask",maskUnits:"userSpaceOnUse"}),this.fullMaskReveal=t("rect").attr("fill","#FFFFFF"),this.lineMaskReveal=t("rect").attr("fill","#FFFFFF"),this.backgroundFills=t("g"),this.agentLines=t("g").attr("mask","url(#"+this.namespace+"LineMask)"),this.blocks=t("g"),this.shapes=t("g"),this.unmaskedShapes=t("g"),this.title=this.svg.formattedText(),this.svg.body.add(this.svg.el("metadata").add(this.metaCode),this.themeDefs,this.defs,this.backgroundFills,t("g").attr("mask","url(#"+this.namespace+"FullMask)").add(this.agentLines,this.blocks,this.shapes),this.unmaskedShapes,this.title)}addThemeDef(t,e){const n=this.namespace+t;return this.knownThemeDefs.has(t)||(this.knownThemeDefs.add(t),this.themeDefs.add(e().attr("id",n))),n}addDef(t,e){let n=t,s=e;"function"!=typeof e&&(n="P"+this.knownDefs.size,s=(()=>t));const r=this.namespace+n;return this.knownDefs.has(n)||(this.knownDefs.add(n),this.defs.add(s().attr("id",r))),r}addSeparation(t,e,n){const s=this.agentInfos.get(t),r=this.agentInfos.get(e),i=s.separations.get(e)||0;s.separations.set(e,Math.max(i,n));const a=r.separations.get(t)||0;r.separations.set(t,Math.max(a,n))}checkHidden(t){const e=this.components.get(t.type),n={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},s=e.shouldHide(t,n)||{},r=this.hideNest>0;this.hideNest+=s.nest||0;const i=this.hideNest>0;if(this.hideNest<0)throw new Error("Unexpected nesting in "+t.type);return r===i?i:Boolean(s.self)}separationStage(t){const n=new Map,s=this.visibleAgentIDs.slice(),r=[];this.agentInfos.forEach(t=>{const e=t.currentRad;t.currentMaxRad=e,n.set(t.id,{left:e,right:e})});const i={addSeparation:(t,e,n)=>{r.push({agentID1:t,agentID2:e,dist:n})},addSpacing:(t,{left:e,right:s})=>{const r=n.get(t);r.left=Math.max(r.left,e),r.right=Math.max(r.right,s)},agentInfos:this.agentInfos,components:this.components,momentaryAgentIDs:s,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme,visibleAgentIDs:this.visibleAgentIDs},a=this.components.get(t.type);if(!a)throw new Error("Unknown component: "+t.type);a.separationPre(t,i),a.separation(t,i),this.checkHidden(t)||(e(s,this.visibleAgentIDs),r.forEach(({agentID1:t,agentID2:e,dist:n})=>{this.addSeparation(t,e,n)}),s.forEach(t=>{const e=this.agentInfos.get(t),r=n.get(t);e.maxRPad=Math.max(e.maxRPad,r.right),e.maxLPad=Math.max(e.maxLPad,r.left),s.forEach(s=>{if(this.agentInfos.get(s).index>=e.index)return;const i=n.get(s);this.addSeparation(t,s,r.left+i.right+this.theme.agentMargin)})}))}prepareMeasurementsStage(t){const e={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},n=this.components.get(t.type);if(!n)throw new Error("Unknown component: "+t.type);n.prepareMeasurements(t,e)}checkAgentRange(t,e=0){if(0===t.length)return e;const{left:n,right:s}=W(this.agentInfos,t),r=this.agentInfos.get(n).x,i=this.agentInfos.get(s).x;let a=e;return this.agentInfos.forEach(t=>{t.x>=r&&t.x<=i&&(a=Math.max(a,t.latestY))}),a}markAgentRange(t,e){if(0===t.length)return;const{left:n,right:s}=W(this.agentInfos,t),r=this.agentInfos.get(n).x,i=this.agentInfos.get(s).x;this.agentInfos.forEach(t=>{t.x>=r&&t.x<=i&&(t.latestY=e)})}drawAgentLine(t,e){null!==t.latestYStart&&e>t.latestYStart&&this.agentLines.add(this.theme.renderAgentLine({className:"agent-"+t.index+"-line",options:t.options,width:2*t.currentRad,x:t.x,y0:t.latestYStart,y1:e}))}addHighlightObject(t,e){let n=this.highlights.get(t);n||(n=[],this.highlights.set(t,n)),n.push(e)}forwardEvent(t,e,n,s){t.on(e,this.trigger.bind(this,n,s))}renderStage(t){this.agentInfos.forEach(t=>{const e=t.currentRad;t.currentMaxRad=e});const e={agentInfos:this.agentInfos,components:this.components,renderer:this,state:this.state,textSizer:this.svg.textSizer,theme:this.theme},n=this.components.get(t.type),s=n.renderPre(t,e),{agentIDs:r,topShift:i,asynchronousY:a}=B(s,this.currentY),o=this.checkAgentRange(r,a),h={addDef:this.addDef,agentInfos:this.agentInfos,blockLayer:this.blocks,components:this.components,drawAgentLine:(t,e,n=!1)=>{const s=this.agentInfos.get(t);this.drawAgentLine(s,e),s.latestYStart=n?null:e},fillLayer:this.backgroundFills,fullMaskLayer:this.fullMask,lineMaskLayer:this.lineMask,makeRegion:({stageOverride:e=null,unmasked:n=!1}={})=>{const s=this.svg.el("g").setClass("region"),r=e||t;return this.addHighlightObject(r.ln,s),this.forwardEvent(s,"mouseenter","mouseover",[r]),this.forwardEvent(s,"mouseleave","mouseout",[r]),this.forwardEvent(s,"click","click",[r]),this.forwardEvent(s,"dblclick","dblclick",[r]),s.attach(n?this.unmaskedShapes:this.shapes)},primaryY:o+i,renderer:this,state:this.state,svg:this.svg,textSizer:this.svg.textSizer,theme:this.theme,topY:o};let l=o;this.checkHidden(t)?(h.primaryY=o,n.renderHidden(t,h)):l=Math.max(l,n.render(t,h)||0),this.markAgentRange(r,l),this.currentY=l}positionAgents(){const t=[];this.agentInfos.forEach(e=>{let n=0;e.separations.forEach((t,s)=>{const r=this.agentInfos.get(s);r.index<e.index&&(n=Math.max(n,r.x+t))}),e.x=n,t.push(e)});let e={x:0};t.reverse().forEach(t=>{let n=e.x;e=t,t.anchorRight&&(t.separations.forEach((e,s)=>{const r=this.agentInfos.get(s);r.index>t.index&&(n=Math.min(n,r.x-e))}),t.x=n)}),this.agentInfos.forEach(({x:t,maxRPad:e,maxLPad:n})=>{this.minX=Math.min(this.minX,t-n),this.maxX=Math.max(this.maxX,t+e)})}buildAgentInfos(t){this.agentInfos=new Map,t.forEach((t,e)=>{this.agentInfos.set(t.id,{anchorRight:t.anchorRight,currentMaxRad:0,currentRad:0,formattedLabel:t.formattedLabel,id:t.id,index:e,isVirtualSource:t.isVirtualSource,latestY:0,latestYStart:null,maxLPad:0,maxRPad:0,options:t.options,separations:new Map,x:null})})}updateBounds(t){const e=(this.minX+this.maxX)/2,n=this.svg.textSizer.measure(this.title),s=n.height>0?-this.theme.titleMargin-n.height:0;this.title.set({x:e,y:s});const r=n.width/2,i=this.theme.outerMargin,a=Math.min(this.minX,e-r)-i,o=Math.max(this.maxX,e+r)+i,h=s-i,l=t+i;this.width=o-a,this.height=l-h;const d={height:this.height,width:this.width,x:a,y:h};this.fullMaskReveal.attrs(d),this.lineMaskReveal.attrs(d),this.svg.body.attr("viewBox",a+" "+h+" "+this.width+" "+this.height)}_resetState(){this.components.forEach(t=>{t.resetState(this.state)}),this.currentY=0,this.hideNest=0}_reset(t){t&&(this.knownThemeDefs.clear(),this.themeDefs.empty()),this.knownDefs.clear(),this.highlights.clear(),this.defs.empty(),this.fullMask.empty(),this.lineMask.empty(),this.backgroundFills.empty(),this.agentLines.empty(),this.blocks.empty(),this.shapes.empty(),this.unmaskedShapes.empty(),this.defs.add(this.fullMask.add(this.fullMaskReveal),this.lineMask.add(this.lineMaskReveal)),this._resetState()}setHighlight(t=null){const e=null===t?-1:t;this.currentHighlight!==e&&(this.highlights.has(this.currentHighlight)&&this.highlights.get(this.currentHighlight).forEach(t=>{t.delClass("focus")}),this.highlights.has(e)&&this.highlights.get(e).forEach(t=>{t.addClass("focus")}),this.currentHighlight=e)}isCollapsed(t){return this.collapsed.has(t)}setCollapseAll(t){if(t)throw new Error("Cannot collapse all");return 0!==this.collapsed.size&&(this.collapsed.clear(),!0)}_setCollapsed(t,e){return"number"==typeof t&&(e!==this.isCollapsed(t)&&(e?this.collapsed.add(t):this.collapsed.delete(t),!0))}setCollapsed(t,e=!0){return null===t?this.setCollapseAll(e):Array.isArray(t)?t.map(t=>this._setCollapsed(t,e)).some(t=>t):this._setCollapsed(t,e)}_switchTheme(t){const e=this.themeBuilder;return this.themeBuilder=this.getThemeNamed(t),this.themeBuilder!==e&&(this.theme=this.themeBuilder.build(this.svg)),this.theme.reset(),this.themeBuilder!==e}optimisedRenderPreReflow(t){const e=this._switchTheme(t.meta.theme);this._reset(e),this.metaCode.nodeValue=t.meta.code,this.theme.addDefs(this.addThemeDef),this.title.set({attrs:this.theme.titleAttrs,formatted:t.meta.title}),this.svg.textSizer.expectMeasure(this.title),this.minX=0,this.maxX=0,this.buildAgentInfos(t.agents),t.stages.forEach(this.prepareMeasurementsStage),this._resetState(),this.svg.textSizer.performMeasurementsPre()}optimisedRenderReflow(){this.svg.textSizer.performMeasurementsAct()}optimisedRenderPostReflow(t){this.visibleAgentIDs=["[","]"],t.stages.forEach(this.separationStage),this._resetState(),this.positionAgents(),t.stages.forEach(this.renderStage);const e=this.checkAgentRange(["[","]"],this.currentY),n=Math.max(e-this.theme.actionMargin,0);this.updateBounds(n);const s=this.currentHighlight;this.currentHighlight=-1,this.setHighlight(s),this.svg.textSizer.performMeasurementsPost(),this.svg.textSizer.resetCache()}render(t){this.optimisedRenderPreReflow(t),this.optimisedRenderReflow(),this.optimisedRenderPostReflow(t)}getThemeNames(){return Array.from(this.themes.keys()).filter(t=>""!==t)}getThemes(){return this.getThemeNames().map(t=>this.themes.get(t))}getThemeNamed(t){const e=this.themes.get(t);return e||this.themes.get("")}getAgentX(t){return this.agentInfos.get(t).x}dom(){return this.svg.body.element}}var Ye={name:"Handlee",woff2:"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"};class We{constructor(){this.s=new Uint32Array(4)}reset(){this.s[0]=394173556,this.s[1]=2926575054,this.s[2]=1022685995,this.s[3]=1178902408}nextFloat(){let t=this.s[0],e=this.s[1];const n=this.s[2],s=this.s[3];return this.s[0]=n,this.s[1]=s,t^=t<<23|e>>>9,e^=e<<23,this.s[2]=t^n^t>>>17^n>>>26,this.s[3]=e^s^(t<<15|e>>>17)^(n<<6|s>>>26),(this.s[3]+s>>>0)%4294967296/4294967296}}const Ue=Ye.name,Xe="'"+Ue+"',cursive",Qe={normal:{stroke:"rgba(0,0,0,0.7)","stroke-width":.8,"stroke-linejoin":"round","stroke-linecap":"round"},thick:{stroke:"rgba(0,0,0,0.8)","stroke-width":1.2,"stroke-linejoin":"round","stroke-linecap":"round"}},Je={"font-family":Xe,"font-size":8,"line-height":1.5},Ze={"font-family":Xe,"font-size":8,"line-height":1.5,"text-anchor":"middle"},Ke={};class _e{constructor(t,e){this.deltas=[0,-.3,-.6,-.75,-.45,0,.45,.75,.6,.3],e!==Ke&&this.deltas.reverse(),this.partWidth=6/this.deltas.length}getDelta(t){return this.deltas[t%this.deltas.length]+.5*Math.sin(.03*t)}}class $e extends it{constructor(t,e=Ke){super(t),this.handedness=e===Ke?1:-1,this.random=new We,this.wave=new _e(4,e);const n={padding:{top:3,bottom:2},tag:{padding:{top:2,left:3,right:5,bottom:0},boxRenderer:this.renderTag.bind(this),labelAttrs:{"font-family":Xe,"font-weight":"bold","font-size":9,"line-height":1.5,"text-anchor":"left"}},label:{minHeight:6,padding:{top:2,left:5,right:3,bottom:1},labelAttrs:{"font-family":Xe,"font-size":8,"line-height":1.5,"text-anchor":"left"}}};Object.assign(this,{titleMargin:10,outerMargin:5,agentMargin:10,actionMargin:10,minActionMargin:3,agentLineHighlightRadius:4,agentCap:{box:{padding:{top:5,left:10,right:10,bottom:5},arrowBottom:12.8,labelAttrs:{"font-family":Xe,"font-size":12,"line-height":1.5,"text-anchor":"middle"},boxRenderer:this.renderBox.bind(this)},database:{padding:{top:12,left:10,right:10,bottom:2},arrowBottom:12.8,boxRenderer:this.renderDB.bind(this,Object.assign({fill:"#FFFFFF","db-z":5},Qe.normal)),labelAttrs:{"font-family":Ue,"font-size":12,"line-height":1.5,"text-anchor":"middle"}},cross:{size:15,render:this.renderCross.bind(this)},bar:{height:6,render:this.renderBar.bind(this)},fade:{width:Math.ceil(12),height:6,extend:Math.ceil(2.5)},none:{height:10}},connect:{loopbackRadius:6,line:{solid:{attrs:Object.assign({fill:"none"},Qe.normal),renderFlat:this.renderFlatConnect.bind(this),renderRev:this.renderRevConnect.bind(this)},dash:{attrs:Object.assign({fill:"none","stroke-dasharray":"4, 2"},Qe.normal),renderFlat:this.renderFlatConnect.bind(this),renderRev:this.renderRevConnect.bind(this)},wave:{attrs:Object.assign({fill:"none","stroke-linejoin":"round","stroke-linecap":"round"},Qe.normal),renderFlat:this.renderFlatConnectWave.bind(this),renderRev:this.renderRevConnectWave.bind(this)}},arrow:{single:{width:5,height:6,attrs:Object.assign({fill:"rgba(0,0,0,0.9)"},Qe.normal),render:this.renderArrowHead.bind(this)},double:{width:4,height:8,attrs:Object.assign({fill:"none"},Qe.normal),render:this.renderArrowHead.bind(this)},cross:{short:5,radius:3,render:this.renderCross.bind(this)}},label:{padding:6,margin:{top:2,bottom:1},attrs:{"font-family":Xe,"font-size":8,"line-height":1.5,"text-anchor":"middle"},loopbackAttrs:{"font-family":Xe,"font-size":8,"line-height":1.5}},source:{radius:1,render:t.circleFactory({fill:"#000000",stroke:"#000000","stroke-width":1})},mask:{padding:{top:0,left:3,right:3,bottom:1}}},titleAttrs:{"font-family":Xe,"font-size":20,"line-height":1.5,"text-anchor":"middle",class:"title"},agentLineAttrs:{"":Object.assign({fill:"none"},Qe.normal),red:{stroke:"rgba(200,40,0,0.8)"}},blocks:{ref:{margin:{top:0,bottom:0},boxRenderer:this.renderRefBlock.bind(this),section:n},"":{margin:{top:0,bottom:0},boxRenderer:this.renderBlock.bind(this),collapsedBoxRenderer:this.renderMinBlock.bind(this),section:n,sepRenderer:this.renderSeparator.bind(this)}},notes:{text:{margin:{top:0,left:6,right:6,bottom:0},padding:{top:2,left:2,right:2,bottom:2},overlap:{left:10,right:10},boxRenderer:t.boxFactory({fill:"#FFFFFF"}),labelAttrs:Je},note:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:5,left:5,right:10,bottom:5},overlap:{left:10,right:10},boxRenderer:this.renderNote.bind(this),labelAttrs:Je},state:{margin:{top:0,left:5,right:5,bottom:0},padding:{top:7,left:7,right:7,bottom:7},overlap:{left:10,right:10},boxRenderer:this.renderState.bind(this),labelAttrs:Je}},dividers:{"":{labelAttrs:Ze,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:()=>({})},line:{labelAttrs:Ze,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:0,render:this.renderLineDivider.bind(this)},delay:{labelAttrs:Ze,padding:{top:2,left:5,right:5,bottom:2},extend:0,margin:0,render:this.renderDelayDivider.bind(this,{dotSize:1,gapSize:2})},tear:{labelAttrs:Ze,padding:{top:2,left:5,right:5,bottom:2},extend:10,margin:10,render:this.renderTearDivider.bind(this,{fadeBegin:5,fadeSize:10,pattern:this.wave,lineAttrs:Qe.normal})}}})}reset(){this.random.reset()}addDefs(t){t("sketch_font",()=>{const t=this.svg.el("style",null);return t.text('@font-face{font-family:"'+Ye.name+'";src:url("data:font/woff2;base64,'+Ye.woff2+'");}'),t})}vary(t,e=0){if(!t)return e;const n=this.random.nextFloat();return e+2*Math.asin(2*n-1)*t/Math.PI}lineNodes(t,e,{var1:n=1,var2:s=1,varX:r=1,varY:i=1,move:a=!0}){const o=Math.sqrt((e.x-t.x)*(e.x-t.x)+(e.y-t.y)*(e.y-t.y)),h=Math.min(.2*Math.sqrt(o),5),l=this.vary(n*r*h,t.x),d=this.vary(n*i*h,t.y),g=this.vary(s*r*h,e.x),c=this.vary(s*i*h,e.y),u=function(t,e,n){return Math.max(e,Math.min(n,t))}((d-c)/(Math.abs(l-g)+.001),-1,1)/6+.5,p=this.vary(.5,.5)*h,f=this.vary(.5,.5)*h,m=l*(1-u)+g*u-p*this.handedness;return{nodes:(a?"M"+l+" "+d:"")+"C"+m+" "+(d*(1-u)+c*u-f)+","+g+" "+c+","+g+" "+c,p1:{x:l,y:d},p2:{x:g,y:c}}}renderLine(t,e,n){const s=this.lineNodes(t,e,n);return this.svg.el("path").attrs({d:s.nodes,fill:"none","stroke-dasharray":n.dash?"6, 5":"none"}).attrs(n.attrs||(n.thick?Qe.thick:Qe.normal))}boxNodes({x:t,y:e,width:n,height:s}){const r=this.lineNodes({x:t,y:e},{x:t+n,y:e},{}),i=this.lineNodes({x:t+n,y:e+s},{x:t,y:e+s},{move:!1}),a=this.lineNodes(r.p2,i.p1,{var1:0,var2:0,move:!1}),o=this.lineNodes(i.p2,r.p1,{var1:0,var2:.3,move:!1});return r.nodes+a.nodes+i.nodes+o.nodes}renderBox(t,{fill:e=null,thick:n=!1,attrs:s=null}={}){return this.svg.el("path").attrs({d:this.boxNodes(t),fill:e||"#FFFFFF"}).attrs(s||(n?Qe.thick:Qe.normal))}renderNote({x:t,y:e,width:n,height:s}){const r=this.lineNodes({x:t,y:e},{x:t+n-5,y:e},{}),i=this.lineNodes(r.p2,{x:t+n,y:e+5},{move:!1,var1:0}),a=this.lineNodes({x:t+n,y:e+s},{x:t,y:e+s},{move:!1}),o=this.lineNodes(i.p2,a.p1,{var1:0,var2:0,move:!1}),h=this.lineNodes(a.p2,r.p1,{var1:0,var2:.3,move:!1}),l=this.lineNodes(i.p1,{x:t+n-5,y:e+5},{var1:.3}),d=this.lineNodes(l.p2,i.p2,{var1:0,move:!1});return this.svg.el("g").add(this.svg.el("path").attrs({d:r.nodes+i.nodes+o.nodes+a.nodes+h.nodes,fill:"#FFFFFF"}).attrs(Qe.normal),this.svg.el("path").attrs({d:l.nodes+d.nodes,fill:"none"}).attrs(Qe.normal))}renderLineDivider({x:t,y:e,labelWidth:n,width:s,height:r}){let i=null;const a=e+r/2;return i=n>0?this.svg.el("g").add(this.renderLine({x:t,y:a},{x:t+(s-n)/2,y:a},{}),this.renderLine({x:t+(s+n)/2,y:a},{x:t+s,y:a},{})):this.renderLine({x:t,y:a},{x:t+s,y:a},{}),{shape:i}}renderFlatConnect(t,{x1:e,y1:n,x2:s,y2:r}){const i=this.lineNodes({x:e,y:n},{x:s,y:r},{varX:.3});return{shape:this.svg.el("path").attr("d",i.nodes).attrs(t),p1:i.p1,p2:i.p2}}renderRevConnect(t,{x1:e,y1:n,x2:s,y2:r,xR:i}){const a=Math.min(.06*(i-e),3),o=Math.min(.5*(i-e),6),h=e+this.vary(a,-1),l=n+this.vary(a,-1),d=i-o*this.vary(.2,1),g=n-this.vary(1,2),c=i,u=n+this.vary(1,1),p=i,f=r+this.vary(2),m=s+this.vary(a,-1),b=r+this.vary(a,-1);return{shape:this.svg.el("path").attr("d","M"+h+" "+l+"C"+h+" "+l+","+d+" "+g+","+c+" "+u+"S"+p+" "+f+","+m+" "+b).attrs(t),p1:{x:h,y:l},p2:{x:m,y:b}}}renderFlatConnectWave(t,{x1:e,y1:n,x2:s,y2:r}){const i=e+this.vary(.3),a=s+this.vary(.3),o=n+this.vary(1),h=r+this.vary(1);return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(this.wave).move(i,o).line(a,h).cap().asPath()).attrs(t),p1:{x:i,y:o},p2:{x:a,y:h}}}renderRevConnectWave(t,{x1:e,y1:n,x2:s,y2:r,xR:i}){const a=e+this.vary(.3),o=s+this.vary(.3),h=n+this.vary(1),l=r+this.vary(1);return{shape:this.svg.el("path").attr("d",this.svg.patternedLine(this.wave).move(a,h).line(i,n).arc(i,(n+r)/2,Math.PI).line(o,l).cap().asPath()).attrs(t),p1:{x:a,y:h},p2:{x:o,y:l}}}renderArrowHead(t,{x:e,y:n,width:s,height:r,dir:i}){const a=s*this.vary(.2,1),o=r*this.vary(.3,1),h=a*i.dx,l=a*i.dy,d=.5*o*i.dx,g=.5*-o*i.dy,c=this.lineNodes({x:e+h-g,y:n+l-d},{x:e,y:n},{var1:2,var2:.2}),u=this.lineNodes(c.p2,{x:e+h+g,y:n+l+d},{var1:0,var2:2,move:!1}),p="none"===t.fill?{nodes:""}:this.lineNodes(u.p2,c.p1,{var1:0,var2:0,move:!1});return this.svg.el("path").attr("d",c.nodes+u.nodes+p.nodes).attrs(t)}renderState({x:t,y:e,width:n,height:s}){const r=Math.min(.06*n,3),i=Math.min(.06*s,3),a=t+r*this.vary(.6,1),o=e+i*this.vary(.6,1),h=t+n-r*this.vary(.6,1),l=e+i*this.vary(.6,1),d=t+r*this.vary(.6,1),g=e+s-i*this.vary(.6,1),c=t+n-r*this.vary(.6,1),u=e+s-i*this.vary(.6,1),p=t+n/2,f=e+s/2,m=r*this.vary(.2,1.2),b=i*this.vary(.2,1.2),y=e-Math.min(.005*n,1),x=e+s-Math.min(.01*n,2),w=t-Math.min(.01*s,2)*this.handedness,k=w+n;return this.svg.el("path").attr("d","M"+a+" "+o+"C"+(a+m)+" "+(o-b)+","+(p-n*this.vary(.03,.3))+" "+y+","+p+" "+y+"S"+(h-m)+" "+(l-b)+","+h+" "+l+"S"+k+" "+(f-s*this.vary(.03,.3))+","+k+" "+f+"S"+(c+m)+" "+(u-b)+","+c+" "+u+"S"+(p+n*this.vary(.03,.3))+" "+x+","+p+" "+x+"S"+(d+m)+" "+(g+b)+","+d+" "+g+"S"+w+" "+(f+s*this.vary(.03,.3))+","+w+" "+f+"S"+(a-m)+" "+(o+b)+","+a+" "+o+"Z").attr("fill","#FFFFFF").attrs(Qe.normal)}renderRefBlock(t){const e=this.boxNodes(t);return{shape:this.svg.el("path").attrs({d:e,fill:"none"}).attrs(Qe.thick),mask:this.svg.el("path").attrs({d:e,fill:"#000000"}),fill:this.svg.el("path").attrs({d:e,fill:"#FFFFFF"})}}renderBlock(t){return this.renderBox(t,{fill:"none",thick:!0})}renderMinBlock(t){return this.renderRefBlock(t)}renderTag({x:t,y:e,width:n,height:s}){const r=t+n,i=e+s,a=this.lineNodes({x:r+3,y:e},{x:r-2,y:i},{}),o=this.lineNodes(a.p2,{x:t,y:i+1},{var1:0,move:!1}),h=a.nodes+o.nodes;return this.svg.el("g").add(this.svg.el("path").attrs({d:h+"L"+t+" "+e,fill:"#FFFFFF"}),this.svg.el("path").attrs({d:h,fill:"#FFFFFF"}).attrs(Qe.normal))}renderSeparator({x1:t,y1:e,x2:n,y2:s}){return this.renderLine({x:t,y:e},{x:n,y:s},{thick:!0,dash:!0})}renderBar({x:t,y:e,width:n,height:s}){return this.renderBox({x:t,y:e,width:n,height:s},{fill:"#000000"})}renderCross({x:t,y:e,radius:n}){const s=this.vary(.2,1)*n,r=this.lineNodes({x:t-s,y:e-s},{x:t+s,y:e+s},{}),i=this.vary(.2,1)*n,a=this.lineNodes({x:t+i,y:e-i},{x:t-i,y:e+i},{});return this.svg.el("path").attrs({d:r.nodes+a.nodes,fill:"none"}).attrs(Qe.normal)}renderAgentLine({x:t,y0:e,y1:n,width:s,className:r,options:i}){const a=this.optionsAttributes(this.agentLineAttrs,i);return s>0?this.renderBox({x:t-s/2,y:e,width:s,height:n-e},{fill:"none",attrs:a}).setClass(r):this.renderLine({x:t,y:e},{x:t,y:n},{varY:.3,attrs:a}).setClass(r)}}class tn{constructor(t=Ke){const e=t===Ke;this.name=e?"sketch":"sketch left handed",this.handedness=t}build(t){return new $e(t,this.handedness)}}Object.assign(tn,{RIGHT:Ke,LEFT:{}});const en=/^([ \t]*)(.*)$/,nn={after:".!+",end:/[ \t\r\n]$/,start:/^[ \t\r\n:,]/},sn=/^"(\\.|[^"])*$/,rn=/[\r\n:,"<>\-~]/,an=/["\\]/g,on=[new gt,new Ot,new bt,new tn(tn.RIGHT),new tn(tn.LEFT)],hn=new te,ln=new Et,dn=hn.getCodeMirrorMode();class gn extends yt{constructor(t=null,e={}){super();let n=null;t&&"object"==typeof t?(n=t,this.code=n.code):(n=e,this.code=t),Object.assign(this,{exporter:new vt,generator:ln,isInteractive:!1,latestProcessed:null,parser:hn,registerCodeMirrorMode:K,renderer:new qe(Object.assign({document:function(t){return t?t.ownerDocument||null:"undefined"==typeof window?null:window.document}(n.container),themes:on},n)),textSizerFactory:n.textSizerFactory||null}),this.renderer.addEventForwarding(this),n.container&&n.container.appendChild(this.dom()),n.interactive&&this.addInteractivity(),"string"==typeof this.code&&!1!==n.render&&this.render()}clone(t={}){const e=t.container||this.renderer.dom();return new gn(Object.assign({code:this.code,components:this.renderer.components,container:null,document:e.ownerDocument,interactive:this.isInteractive,namespace:null,textSizerFactory:this.textSizerFactory,themes:this.renderer.getThemes()},t))}set(t="",{render:e=!0}={}){this.code!==t&&(this.code=t,e&&this.render())}process(t){const e=this.parser.parse(t);return this.generator.generate(e)}addTheme(t){this.renderer.addTheme(t)}setHighlight(t){this.renderer.setHighlight(t)}isCollapsed(t){return this.renderer.isCollapsed(t)}setCollapsed(t,e=!0,{render:n=!0}={}){return!!this.renderer.setCollapsed(t,e)&&(n&&this.latestProcessed&&this.render(this.latestProcessed),!0)}collapse(t,e){return this.setCollapsed(t,!0,e)}expand(t,e){return this.setCollapsed(t,!1,e)}toggleCollapsed(t,e){return this.setCollapsed(t,!this.isCollapsed(t),e)}expandAll(t){return this.setCollapsed(null,!1,t)}getThemeNames(){return this.renderer.getThemeNames()}getThemes(){return this.renderer.getThemes()}getSVGSynchronous(){return this.exporter.getSVGURL(this.renderer)}getSVG(){return Promise.resolve({latest:!0,url:this.getSVGSynchronous()})}getCanvas({resolution:t=1,size:e=null}={}){return e&&(this.renderer.width=e.width,this.renderer.height=e.height),new Promise(e=>{this.exporter.getCanvas(this.renderer,t,e)})}getPNG({resolution:t=1,size:e=null}={}){return e&&(this.renderer.width=e.width,this.renderer.height=e.height),new Promise(e=>{this.exporter.getPNGURL(this.renderer,t,(t,n)=>{e({latest:n,url:t})})})}getSize(){return{height:this.renderer.height,width:this.renderer.width}}_revertParent(t){const e=this.renderer.dom();e.parentNode!==t.originalParent&&(e.parentNode.removeChild(e),t.originalParent&&t.originalParent.appendChild(e))}_sendRenderError(t){this._revertParent(this.renderState),this.renderState.error=!0,this.trigger("error",[this,t])}optimisedRenderPreReflow(t=null){const e=this.renderer.dom();this.renderState={error:!1,originalParent:e.parentNode,processed:t};const n=this.renderState;e.isConnected||(n.originalParent&&n.originalParent.removeChild(e),e.ownerDocument.body.appendChild(e));try{n.processed||(n.processed=this.process(this.code)),this.renderer.optimisedRenderPreReflow(n.processed)}catch(t){this._sendRenderError(t)}}optimisedRenderReflow(){try{this.renderState.error||this.renderer.optimisedRenderReflow()}catch(t){this._sendRenderError(t)}}optimisedRenderPostReflow(){const t=this.renderState;try{t.error||this.renderer.optimisedRenderPostReflow(t.processed)}catch(t){this._sendRenderError(t)}this.renderState=null,t.error||(this._revertParent(t),this.latestProcessed=t.processed,this.trigger("render",[this]))}render(t=null){function e(t,e){n=e}let n=null;if(this.addEventListener("error",e),this.optimisedRenderPreReflow(t),this.optimisedRenderReflow(),this.optimisedRenderPostReflow(),this.removeEventListener("error",e),n)throw n}setContainer(t=null){const e=this.dom();e.parentNode&&e.parentNode.removeChild(e),t&&t.appendChild(e)}addInteractivity(){this.isInteractive||(this.isInteractive=!0,this.addEventListener("click",t=>{this.toggleCollapsed(t.ln)}))}extractCodeFromSVG(t){return _(t)}renderAll(t){return $(t)}dom(){return this.renderer.dom()}}Object.assign(gn,{Exporter:vt,Generator:Et,Parser:te,Renderer:qe,addTheme:function(t){on.push(t)},convert:et,convertAll:function(t=null,e="sequence-diagram"){let n=null,s=null;"string"==typeof t?(n=null,s=t):(n=t,s=e);let r=null;r=n&&void 0!==n.length?n:(n||window.document).getElementsByClassName(s);const i=[];for(let t=0;t<r.length;++t)i.push(r[t]);et(i)},extractCodeFromSVG:_,getDefaultThemeNames:function(){return on.map(t=>t.name)},registerCodeMirrorMode:K,renderAll:$,themes:on});class cn{constructor(t){this.parentNode=null,this.nodeValue=t}contains(){return!1}get textContent(){return this.nodeValue}set textContent(t){this.nodeValue=t}get isConnected(){return null!==this.parentNode&&this.parentNode.isConnected}get innerHTML(){return function(t){return t.replace(/[^\r\n\t -%'-;=?-~]/g,nt)}(this.nodeValue)}get outerHTML(){return this.innerHTML}}class un{constructor(t,e,n){this.ownerDocument=t,this.tagName=e,this.namespaceURI=n,this.parentNode=null,this.childNodes=[],this.attributes=new Map,this.listeners=new Map}setAttribute(t,e){let n=null;if("number"==typeof e)n=e.toString(10);else{if("string"!=typeof e)throw new Error("Bad value "+e+" for attribute "+t);n=e}this.attributes.set(t,n)}getAttribute(t){return this.attributes.get(t)}addEventListener(t,e){let n=this.listeners.get(t);n||(n=[],this.listeners.set(t,n)),n.push(e)}removeEventListener(t,e){const n=this.listeners.get(t)||[],s=n.indexOf(e);-1!==s&&n.splice(s,1)}dispatchEvent(t){(this.listeners.get(t.type)||[]).forEach(e=>e(t))}contains(t){let e=t;for(;e;){if(e===this)return!0;e=e.parentNode}return!1}getElementsByTagName(t){const e=[];return this.traverseDescendants(n=>{n.tagName===t&&e.push(n)}),e}getElementsByClassName(t){const e=[],n=" "+t+" ";return this.traverseDescendants(t=>{-1!==(" "+(t.getAttribute("class")||"")+" ").indexOf(n)&&e.push(t)}),e}traverseDescendants(t){if(!1!==t(this))for(const e of this.childNodes)e.traverseDescendants&&e.traverseDescendants(t)}get firstChild(){return this.childNodes[0]||null}get lastChild(){return this.childNodes[this.childNodes.length-1]||null}indexOf(t){const e=this.childNodes.indexOf(t);if(-1===e)throw new Error(t+" is not a child of "+this);return e}insertBefore(t,e){if(t.contains(this))throw new Error("Cyclic node structures are not permitted");return null!==t.parentNode&&t.parentNode.removeChild(t),null===e?this.childNodes.push(t):this.childNodes.splice(this.indexOf(e),0,t),t.parentNode=this,t}appendChild(t){return this.insertBefore(t,null)}removeChild(t){return this.childNodes.splice(this.indexOf(t),1),t.parentNode=null,t}replaceChild(t,e){return t===e?e:(this.insertBefore(t,e),this.removeChild(e))}get isConnected(){return!0}get textContent(){let t="";for(const e of this.childNodes)t+=e.textContent;return t}set textContent(t){for(const t of this.childNodes)t.parentNode=null;this.childNodes.length=0,this.appendChild(new cn(t))}get innerHTML(){let t="";for(const e of this.childNodes)t+=e.outerHTML;return t}get outerHTML(){let t="";for(const[e,n]of this.attributes)t+=" "+e+'="'+st(n)+'"';return"<"+this.tagName+t+">"+this.innerHTML+"</"+this.tagName+">"}}class pn{createElement(t){return new un(this,t,"")}createElementNS(t,e){return new un(this,e,t||"")}createTextNode(t){return new cn(t)}}class fn{baseline(){return 1}measureHeight({formatted:t}){return t.length}prepMeasurement(t,e){return e}prepComplete(){}performMeasurement(t){return t.reduce((t,e)=>t+e.text.length,0)}teardown(){}}"undefined"!=typeof exports?(exports.SequenceDiagram=gn,exports.VirtualDocument=pn,exports.headlessTextSizerFactory=(()=>new fn)):window.define&&window.define.amd?window.define(()=>gn):(window.document.addEventListener("DOMContentLoaded",()=>{gn.convertAll()},{once:!0}),window.CodeMirror&&gn.registerCodeMirrorMode(window.CodeMirror),window.SequenceDiagram=gn)}();
\ No newline at end of file
diff --git a/library.htm b/library.htm
index 662bdc1..5462178 100644
--- a/library.htm
+++ b/library.htm
@@ -57,7 +57,7 @@
 	crossorigin="anonymous"
 ></script>
 
-<script src="lib/sequence-diagram.min.js"></script>
+<script src="lib/sequence-diagram-web.min.js"></script>
 
 <script>document.addEventListener('DOMContentLoaded', () => {
 
@@ -125,13 +125,13 @@ This library renders sequence diagrams from code. It is
 (LGPL-3.0), and including it in a website is as simple as adding the script:</p>
 
 <pre data-lang="text/html">
-&lt;script src="lib/sequence-diagram.min.js"&gt;&lt;/script&gt;
+&lt;script src="lib/sequence-diagram-web.min.js"&gt;&lt;/script&gt;
 </pre>
 
 <p>Or if you are using requirejs:</p>
 
 <pre data-lang="javascript">
-requirejs(['lib/sequence-diagram.min'], (SequenceDiagram) => {
+requirejs(['lib/sequence-diagram-web.min'], (SequenceDiagram) => {
   SequenceDiagram.convertAll();
 });
 </pre>
diff --git a/package.json b/package.json
index 022e12f..c561425 100644
--- a/package.json
+++ b/package.json
@@ -12,15 +12,22 @@
   },
   "license": "LGPL-3.0",
   "files": [
-    "lib/sequence-diagram.js"
+    "lib/sequence-diagram-web.js",
+    "lib/sequence-diagram.js",
+    "scripts",
+    "bin"
   ],
   "main": "lib/sequence-diagram",
   "module": "scripts/standalone",
+  "bin": {
+    "sequence-diagram-svg": "./bin/sequence-diagram-svg.js"
+  },
   "scripts": {
     "lint": "eslint . --config spec/support/eslintrc.js --ignore-path spec/support/eslintignore --ext .js --ext .mjs",
-    "minify-lib": "rollup --config scripts/rollup.config.js && uglifyjs --compress --mangle --warn --output lib/sequence-diagram.min.js -- lib/sequence-diagram.js",
+    "minify-lib": "rollup --config scripts/rollup.config.js && uglifyjs --compress --mangle --warn --output lib/sequence-diagram-web.min.js -- lib/sequence-diagram-web.js && uglifyjs --compress --mangle --warn --output lib/sequence-diagram.min.js -- lib/sequence-diagram.js",
     "minify-web": "rollup --config web/rollup.config.js && uglifyjs --compress --mangle --warn --output weblib/editor.min.js -- weblib/editor.js",
     "minify": "npm run minify-lib && npm run minify-web",
+    "prepublishOnly": "npm run minify-lib",
     "start": "http-server",
     "test": "npm run unit-test && npm run web-test && npm run lint && echo 'PASSED :)'",
     "unit-test": "rollup --config spec/support/rollup.config.js && node -r source-map-support/register node_modules/.bin/jasmine --config=spec/support/jasmine.json",
diff --git a/scripts/rollup.config.js b/scripts/rollup.config.js
index f1c4cdd..5910508 100644
--- a/scripts/rollup.config.js
+++ b/scripts/rollup.config.js
@@ -1,4 +1,12 @@
 export default [
+	{
+		input: 'scripts/standalone-web.mjs',
+		output: {
+			file: 'lib/sequence-diagram-web.js',
+			format: 'iife',
+			name: 'SequenceDiagram',
+		},
+	},
 	{
 		input: 'scripts/standalone.mjs',
 		output: {
diff --git a/scripts/standalone-web.mjs b/scripts/standalone-web.mjs
new file mode 100644
index 0000000..ed5f090
--- /dev/null
+++ b/scripts/standalone-web.mjs
@@ -0,0 +1,17 @@
+import SequenceDiagram from './sequence/SequenceDiagram.mjs';
+
+if(typeof exports !== 'undefined') {
+	exports.SequenceDiagram = SequenceDiagram;
+} else if(window.define && window.define.amd) {
+	window.define(() => SequenceDiagram);
+} else {
+	window.document.addEventListener('DOMContentLoaded', () => {
+		SequenceDiagram.convertAll();
+	}, {once: true});
+
+	if(window.CodeMirror) {
+		SequenceDiagram.registerCodeMirrorMode(window.CodeMirror);
+	}
+
+	window.SequenceDiagram = SequenceDiagram;
+}
diff --git a/scripts/standalone.mjs b/scripts/standalone.mjs
index 3af24dd..cfb801d 100644
--- a/scripts/standalone.mjs
+++ b/scripts/standalone.mjs
@@ -1,8 +1,41 @@
 import SequenceDiagram from './sequence/SequenceDiagram.mjs';
+import {VirtualDocument} from './core/documents/VirtualDocument.mjs';
 
-const def = window.define;
-if(def && def.amd) {
-	def(() => SequenceDiagram);
+class UnitaryTextSizer {
+	// Simplified text sizer, which assumes all characters render as
+	// 1x1 px squares for repeatable renders in all browsers
+
+	baseline() {
+		return 1;
+	}
+
+	measureHeight({formatted}) {
+		return formatted.length;
+	}
+
+	prepMeasurement(attrs, formatted) {
+		return formatted;
+	}
+
+	prepComplete() {
+		// No-op
+	}
+
+	performMeasurement(data) {
+		return data.reduce((total, part) => total + part.text.length, 0);
+	}
+
+	teardown() {
+		// No-op
+	}
+}
+
+if(typeof exports !== 'undefined') {
+	exports.SequenceDiagram = SequenceDiagram;
+	exports.VirtualDocument = VirtualDocument;
+	exports.headlessTextSizerFactory = () => new UnitaryTextSizer();
+} else if(window.define && window.define.amd) {
+	window.define(() => SequenceDiagram);
 } else {
 	window.document.addEventListener('DOMContentLoaded', () => {
 		SequenceDiagram.convertAll();
diff --git a/spec/support/karma.conf.js b/spec/support/karma.conf.js
index 89535df..7e59adb 100644
--- a/spec/support/karma.conf.js
+++ b/spec/support/karma.conf.js
@@ -40,6 +40,7 @@ module.exports = (config) => {
 			{included: false, pattern: 'scripts/**/*'},
 			{included: false, pattern: 'spec/**/*'},
 			{included: false, pattern: 'web/**/*'},
+			{included: false, pattern: 'bin/**/*'},
 			{included: false, pattern: 'README.md'},
 		],
 		frameworks: ['detectBrowsers', 'jasmine'],
diff --git a/spec/support/rollup.config.js b/spec/support/rollup.config.js
index 390aa05..35cabef 100644
--- a/spec/support/rollup.config.js
+++ b/spec/support/rollup.config.js
@@ -7,6 +7,7 @@ export default [
 			'scripts/**/*_spec.mjs',
 			'spec/**/*_spec.mjs',
 			'web/**/*_spec.mjs',
+			'bin/**/*_spec.mjs',
 		],
 		output: {
 			file: 'ephemeral/spec_bundle.js',