From ddb4430ed2845a9bd826eefa2e39bf6b37720534 Mon Sep 17 00:00:00 2001
From: David Evans <davidje13@users.noreply.github.com>
Date: Sun, 5 Nov 2017 17:10:06 +0000
Subject: [PATCH] Add support for aliases, and fix various issues when using
 the same agent multiple times in a statement [#19]

---
 README.md                           |  13 ++
 screenshots/AgentAliases.png        | Bin 0 -> 22099 bytes
 scripts/sequence/CodeMirrorMode.js  | 316 +++++++++++++++-------------
 scripts/sequence/Generator.js       | 111 +++++++---
 scripts/sequence/Generator_spec.js  | 106 ++++++++--
 scripts/sequence/Parser.js          |  44 +++-
 scripts/sequence/Parser_spec.js     |  62 ++++--
 scripts/sequence/components/Note.js |  21 +-
 scripts/tester/jshintRunner.js      |   2 +-
 styles/main.css                     |   1 +
 10 files changed, 431 insertions(+), 245 deletions(-)
 create mode 100644 screenshots/AgentAliases.png

diff --git a/README.md b/README.md
index bbc6b43..4ef3f9a 100644
--- a/README.md
+++ b/README.md
@@ -150,6 +150,19 @@ terminators bar
 # (options are: box, bar, cross, none)
 ```
 
+### Agent Aliases
+
+<img src="screenshots/AgentAliases.png" alt="Agent Aliases preview" width="200" align="right" />
+
+```
+define My complicated agent name as A
+define "Another agent name,
+and this one's multi-line!" as B
+
+A -> B: this is much easier
+A <- B: than writing the whole name
+```
+
 ### Alternative Agent Ordering
 
 <img src="screenshots/AlternativeAgentOrdering.png" alt="Alternative Agent Ordering preview" width="150" align="right" />
diff --git a/screenshots/AgentAliases.png b/screenshots/AgentAliases.png
new file mode 100644
index 0000000000000000000000000000000000000000..0724670ebcd07cd05461102aa5089fc71292caa0
GIT binary patch
literal 22099
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

literal 0
HcmV?d00001

diff --git a/scripts/sequence/CodeMirrorMode.js b/scripts/sequence/CodeMirrorMode.js
index 1ed55d4..258fbb4 100644
--- a/scripts/sequence/CodeMirrorMode.js
+++ b/scripts/sequence/CodeMirrorMode.js
@@ -1,183 +1,195 @@
 define(['core/ArrayUtilities'], (array) => {
 	'use strict';
 
-	const CM_END = {type: '', suggest: '\n', then: {}};
-	const CM_HIDDEN_END = {type: '', then: {}};
 	const CM_ERROR = {type: 'error line-error', then: {'': 0}};
 
-	function makeCMCommaBlock(type, suggest, exits = {}) {
-		return {type, suggest, then: Object.assign({
+	const CM_COMMANDS = ((() => {
+		const end = {type: '', suggest: '\n', then: {}};
+		const hiddenEnd = {type: '', then: {}};
+
+		const ARROWS = [
+			'->', '-->',
+			'<-', '<--',
+			'<->', '<-->',
+		];
+
+		const textToEnd = {type: 'string', then: {'': 0, '\n': end}};
+		const aliasListToEnd = {type: 'variable', suggest: 'Agent', then: {
 			'': 0,
-			',': {type: 'operator', suggest: true, then: {
-				'': 1,
+			'as': {type: 'keyword', suggest: true, then: {
+				'': {type: 'variable', suggest: 'Agent', then: {
+					'': 0,
+					',': {type: 'operator', suggest: true, then: {'': 3}},
+					'\n': end,
+				}},
 			}},
-		}, exits)};
-	}
-
-	const CM_TEXT_TO_END = {type: 'string', then: {'': 0, '\n': CM_END}};
-	const CM_AGENT_LIST_TO_END = makeCMCommaBlock('variable', 'Agent', {
-		'\n': CM_END,
-	});
-	const CM_AGENT_LIST_TO_TEXT = makeCMCommaBlock('variable', 'Agent', {
-		':': {type: 'operator', suggest: true, then: {'': CM_TEXT_TO_END}},
-	});
-	const CM_AGENT_TO_OPTTEXT = {type: 'variable', suggest: 'Agent', then: {
-		'': 0,
-		':': {type: 'operator', suggest: true, then: {
-			'': CM_TEXT_TO_END,
-			'\n': CM_HIDDEN_END,
-		}},
-		'\n': CM_END,
-	}};
-
-	function makeCMSideNote(side) {
-		return {
-			type: 'keyword',
-			suggest: [side + ' of ', side + ': '],
-			then: {
-				'of': {type: 'keyword', suggest: true, then: {
-					'': CM_AGENT_LIST_TO_TEXT,
-				}},
-				':': {type: 'operator', suggest: true, then: {
-					'': CM_TEXT_TO_END,
-				}},
-				'': CM_AGENT_LIST_TO_TEXT,
-			},
-		};
-	}
-
-	function makeCMOperatorBlock(exit) {
-		const op = {type: 'operator', suggest: true, then: {
-			'+': CM_ERROR,
-			'-': CM_ERROR,
-			'*': CM_ERROR,
-			'!': CM_ERROR,
-			'': exit,
+			',': {type: 'operator', suggest: true, then: {'': 1}},
+			'\n': end,
 		}};
-		return {
-			'+': {type: 'operator', suggest: true, then: {
+		const agentListToEnd = {type: 'variable', suggest: 'Agent', then: {
+			'': 0,
+			',': {type: 'operator', suggest: true, then: {'': 1}},
+			':': {type: 'operator', suggest: true, then: {'': textToEnd}},
+		}};
+		const agentToOptText = {type: 'variable', suggest: 'Agent', then: {
+			'': 0,
+			':': {type: 'operator', suggest: true, then: {
+				'': textToEnd,
+				'\n': hiddenEnd,
+			}},
+			'\n': end,
+		}};
+
+		function makeSideNote(side) {
+			return {
+				type: 'keyword',
+				suggest: [side + ' of ', side + ': '],
+				then: {
+					'of': {type: 'keyword', suggest: true, then: {
+						'': agentListToEnd,
+					}},
+					':': {type: 'operator', suggest: true, then: {
+						'': textToEnd,
+					}},
+					'': agentListToEnd,
+				},
+			};
+		}
+
+		function makeOpBlock(exit) {
+			const op = {type: 'operator', suggest: true, then: {
 				'+': CM_ERROR,
 				'-': CM_ERROR,
-				'*': op,
+				'*': CM_ERROR,
 				'!': CM_ERROR,
 				'': exit,
-			}},
-			'-': {type: 'operator', suggest: true, then: {
-				'+': CM_ERROR,
-				'-': CM_ERROR,
-				'*': op,
-				'!': {type: 'operator', then: {
+			}};
+			return {
+				'+': {type: 'operator', suggest: true, then: {
 					'+': CM_ERROR,
 					'-': CM_ERROR,
+					'*': op,
+					'!': CM_ERROR,
+					'': exit,
+				}},
+				'-': {type: 'operator', suggest: true, then: {
+					'+': CM_ERROR,
+					'-': CM_ERROR,
+					'*': op,
+					'!': {type: 'operator', then: {
+						'+': CM_ERROR,
+						'-': CM_ERROR,
+						'*': CM_ERROR,
+						'!': CM_ERROR,
+						'': exit,
+					}},
+					'': exit,
+				}},
+				'*': {type: 'operator', suggest: true, then: {
+					'+': op,
+					'-': op,
 					'*': CM_ERROR,
 					'!': CM_ERROR,
 					'': exit,
 				}},
+				'!': op,
 				'': exit,
-			}},
-			'*': {type: 'operator', suggest: true, then: {
-				'+': op,
-				'-': op,
-				'*': CM_ERROR,
-				'!': CM_ERROR,
-				'': exit,
-			}},
-			'!': op,
-			'': exit,
-		};
-	}
+			};
+		}
 
-	function makeCMConnect() {
-		const connect = {
-			type: 'keyword',
-			suggest: true,
-			then: makeCMOperatorBlock(CM_AGENT_TO_OPTTEXT),
-		};
+		function makeCMConnect() {
+			const connect = {
+				type: 'keyword',
+				suggest: true,
+				then: makeOpBlock(agentToOptText),
+			};
 
-		return makeCMOperatorBlock({type: 'variable', suggest: 'Agent', then: {
-			'->': connect,
-			'-->': connect,
-			'<-': connect,
-			'<--': connect,
-			'<->': connect,
-			'<-->': connect,
-			':': {type: 'operator', suggest: true, override: 'Label', then: {}},
-			'': 0,
-		}});
-	}
+			const then = {
+				':': {
+					type: 'operator',
+					suggest: true,
+					override: 'Label',
+					then: {},
+				},
+				'': 0,
+			};
+			ARROWS.forEach((arrow) => (then[arrow] = connect));
+			return makeOpBlock({type: 'variable', suggest: 'Agent', then});
+		}
 
-	const CM_COMMANDS = {type: 'error line-error', then: Object.assign({
-		'title': {type: 'keyword', suggest: true, then: {
-			'': CM_TEXT_TO_END,
-		}},
-		'terminators': {type: 'keyword', suggest: true, then: {
-			'none': {type: 'keyword', suggest: true, then: {}},
-			'cross': {type: 'keyword', suggest: true, then: {}},
-			'box': {type: 'keyword', suggest: true, then: {}},
-			'bar': {type: 'keyword', suggest: true, then: {}},
-		}},
-		'define': {type: 'keyword', suggest: true, then: {
-			'': CM_AGENT_LIST_TO_END,
-		}},
-		'begin': {type: 'keyword', suggest: true, then: {
-			'': CM_AGENT_LIST_TO_END,
-		}},
-		'end': {type: 'keyword', suggest: true, then: {
-			'': CM_AGENT_LIST_TO_END,
-			'\n': CM_END,
-		}},
-		'if': {type: 'keyword', suggest: true, then: {
-			'': CM_TEXT_TO_END,
-			':': {type: 'operator', suggest: true, then: {
-				'': CM_TEXT_TO_END,
+		return {type: 'error line-error', then: Object.assign({
+			'title': {type: 'keyword', suggest: true, then: {
+				'': textToEnd,
 			}},
-			'\n': CM_END,
-		}},
-		'else': {type: 'keyword', suggest: ['else\n', 'else if: '], then: {
-			'if': {type: 'keyword', suggest: 'if: ', then: {
-				'': CM_TEXT_TO_END,
+			'terminators': {type: 'keyword', suggest: true, then: {
+				'none': {type: 'keyword', suggest: true, then: {}},
+				'cross': {type: 'keyword', suggest: true, then: {}},
+				'box': {type: 'keyword', suggest: true, then: {}},
+				'bar': {type: 'keyword', suggest: true, then: {}},
+			}},
+			'define': {type: 'keyword', suggest: true, then: {
+				'': aliasListToEnd,
+			}},
+			'begin': {type: 'keyword', suggest: true, then: {
+				'': aliasListToEnd,
+			}},
+			'end': {type: 'keyword', suggest: true, then: {
+				'': aliasListToEnd,
+				'\n': end,
+			}},
+			'if': {type: 'keyword', suggest: true, then: {
+				'': textToEnd,
 				':': {type: 'operator', suggest: true, then: {
-					'': CM_TEXT_TO_END,
+					'': textToEnd,
+				}},
+				'\n': end,
+			}},
+			'else': {type: 'keyword', suggest: ['else\n', 'else if: '], then: {
+				'if': {type: 'keyword', suggest: 'if: ', then: {
+					'': textToEnd,
+					':': {type: 'operator', suggest: true, then: {
+						'': textToEnd,
+					}},
+				}},
+				'\n': end,
+			}},
+			'repeat': {type: 'keyword', suggest: true, then: {
+				'': textToEnd,
+				':': {type: 'operator', suggest: true, then: {
+					'': textToEnd,
+				}},
+				'\n': end,
+			}},
+			'note': {type: 'keyword', suggest: true, then: {
+				'over': {type: 'keyword', suggest: true, then: {
+					'': agentListToEnd,
+				}},
+				'left': makeSideNote('left'),
+				'right': makeSideNote('right'),
+				'between': {type: 'keyword', suggest: true, then: {
+					'': agentListToEnd,
 				}},
 			}},
-			'\n': CM_END,
-		}},
-		'repeat': {type: 'keyword', suggest: true, then: {
-			'': CM_TEXT_TO_END,
-			':': {type: 'operator', suggest: true, then: {
-				'': CM_TEXT_TO_END,
-			}},
-			'\n': CM_END,
-		}},
-		'note': {type: 'keyword', suggest: true, then: {
-			'over': {type: 'keyword', suggest: true, then: {
-				'': CM_AGENT_LIST_TO_TEXT,
-			}},
-			'left': makeCMSideNote('left'),
-			'right': makeCMSideNote('right'),
-			'between': {type: 'keyword', suggest: true, then: {
-				'': CM_AGENT_LIST_TO_TEXT,
-			}},
-		}},
-		'state': {type: 'keyword', suggest: 'state over ', then: {
-			'over': {type: 'keyword', suggest: true, then: {
-				'': CM_AGENT_LIST_TO_TEXT,
-			}},
-		}},
-		'text': {type: 'keyword', suggest: true, then: {
-			'left': makeCMSideNote('left'),
-			'right': makeCMSideNote('right'),
-		}},
-		'simultaneously': {type: 'keyword', suggest: true, then: {
-			':': {type: 'operator', suggest: true, then: {}},
-			'with': {type: 'keyword', suggest: true, then: {
-				'': {type: 'variable', suggest: 'Label', then: {
-					'': 0,
-					':': {type: 'operator', suggest: true, then: {}},
+			'state': {type: 'keyword', suggest: 'state over ', then: {
+				'over': {type: 'keyword', suggest: true, then: {
+					'': agentListToEnd,
 				}},
 			}},
-		}},
-	}, makeCMConnect())};
+			'text': {type: 'keyword', suggest: true, then: {
+				'left': makeSideNote('left'),
+				'right': makeSideNote('right'),
+			}},
+			'simultaneously': {type: 'keyword', suggest: true, then: {
+				':': {type: 'operator', suggest: true, then: {}},
+				'with': {type: 'keyword', suggest: true, then: {
+					'': {type: 'variable', suggest: 'Label', then: {
+						'': 0,
+						':': {type: 'operator', suggest: true, then: {}},
+					}},
+				}},
+			}},
+		}, makeCMConnect())};
+	})());
 
 	function cmCappedToken(token, current) {
 		if(Object.keys(current.then).length > 0) {
diff --git a/scripts/sequence/Generator.js b/scripts/sequence/Generator.js
index 791c301..b1bea09 100644
--- a/scripts/sequence/Generator.js
+++ b/scripts/sequence/Generator.js
@@ -17,10 +17,6 @@ define(['core/ArrayUtilities'], (array) => {
 		return {name, anchorRight};
 	}
 
-	function convertAgent(agent) {
-		return makeAgent(agent.name);
-	}
-
 	function getAgentName(agent) {
 		return agent.name;
 	}
@@ -181,6 +177,7 @@ define(['core/ArrayUtilities'], (array) => {
 	return class Generator {
 		constructor() {
 			this.agentStates = new Map();
+			this.agentAliases = new Map();
 			this.agents = [];
 			this.blockCount = 0;
 			this.nesting = [];
@@ -204,6 +201,29 @@ define(['core/ArrayUtilities'], (array) => {
 				'block end': this.handleBlockEnd.bind(this),
 			};
 			this.handleStage = this.handleStage.bind(this);
+			this.convertAgent = this.convertAgent.bind(this);
+		}
+
+		convertAgent({alias, name}) {
+			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.agents.some((agent) => (agent.name === alias))
+				) {
+					throw new Error(
+						'Cannot use ' + alias +
+						' as an alias; it is already in use'
+					);
+				}
+				this.agentAliases.set(alias, name);
+			}
+			return makeAgent(this.agentAliases.get(name) || name);
 		}
 
 		addStage(stage, isVisible = true) {
@@ -230,13 +250,18 @@ define(['core/ArrayUtilities'], (array) => {
 			});
 		}
 
-		defineAgents(agents) {
-			array.mergeSets(this.currentNest.agents, agents, agentEqCheck);
-			array.mergeSets(this.agents, agents, agentEqCheck);
+		defineAgents(colAgents) {
+			array.mergeSets(this.currentNest.agents, colAgents, agentEqCheck);
+			array.mergeSets(this.agents, colAgents, agentEqCheck);
 		}
 
-		setAgentVisRaw(agents, visible, mode, checked = false) {
-			const filteredAgents = agents.filter((agent) => {
+		setAgentVis(colAgents, visible, mode, checked = false) {
+			const seen = new Set();
+			const filteredAgents = colAgents.filter((agent) => {
+				if(seen.has(agent.name)) {
+					return false;
+				}
+				seen.add(agent.name);
 				const state = this.agentStates.get(agent.name) || DEFAULT_AGENT;
 				if(state.locked) {
 					if(checked) {
@@ -269,17 +294,8 @@ define(['core/ArrayUtilities'], (array) => {
 			};
 		}
 
-		setAgentVis(agents, visible, mode, checked = false) {
-			return this.setAgentVisRaw(
-				agents.map(convertAgent),
-				visible,
-				mode,
-				checked
-			);
-		}
-
-		setAgentHighlight(agents, highlighted, checked = false) {
-			const filteredAgents = agents.filter((agent) => {
+		setAgentHighlight(colAgents, highlighted, checked = false) {
+			const filteredAgents = colAgents.filter((agent) => {
 				const state = this.agentStates.get(agent.name) || DEFAULT_AGENT;
 				if(state.locked) {
 					if(checked) {
@@ -349,27 +365,44 @@ define(['core/ArrayUtilities'], (array) => {
 		}
 
 		handleConnect({agents, label, options}) {
-			const beginAgents = agents.filter(agentHasFlag('begin'));
-			const endAgents = agents.filter(agentHasFlag('end'));
+			const beginAgents = (agents
+				.filter(agentHasFlag('begin'))
+				.map(this.convertAgent)
+			);
+			const endAgents = (agents
+				.filter(agentHasFlag('end'))
+				.map(this.convertAgent)
+			);
 			if(array.hasIntersection(beginAgents, endAgents, agentEqCheck)) {
 				throw new Error('Cannot set agent visibility multiple times');
 			}
 
-			const startAgents = agents.filter(agentHasFlag('start'));
-			const stopAgents = agents.filter(agentHasFlag('stop'));
+			const startAgents = (agents
+				.filter(agentHasFlag('start'))
+				.map(this.convertAgent)
+			);
+			const stopAgents = (agents
+				.filter(agentHasFlag('stop'))
+				.map(this.convertAgent)
+			);
 			array.mergeSets(stopAgents, endAgents);
 			if(array.hasIntersection(startAgents, stopAgents, agentEqCheck)) {
 				throw new Error('Cannot set agent highlighting multiple times');
 			}
 
-			this.defineAgents(agents.map(convertAgent));
+			const colAgents = agents.map(this.convertAgent);
+			const agentNames = colAgents.map(getAgentName);
+			this.defineAgents(colAgents);
 
-			const implicitBegin = agents.filter(agentHasFlag('begin', false));
+			const implicitBegin = (agents
+				.filter(agentHasFlag('begin', false))
+				.map(this.convertAgent)
+			);
 			this.addStage(this.setAgentVis(implicitBegin, true, 'box'));
 
 			const connectStage = {
 				type: 'connect',
-				agentNames: agents.map(getAgentName),
+				agentNames,
 				label,
 				options,
 			};
@@ -388,32 +421,39 @@ define(['core/ArrayUtilities'], (array) => {
 			if(agents.length === 0) {
 				colAgents = NOTE_DEFAULT_AGENTS[type] || [];
 			} else {
-				colAgents = agents.map(convertAgent);
+				colAgents = agents.map(this.convertAgent);
+			}
+			const agentNames = colAgents.map(getAgentName);
+			const uniqueAgents = new Set(agentNames).size;
+			if(type === 'note between' && uniqueAgents < 2) {
+				throw new Error('note between requires at least 2 agents');
 			}
 
-			this.addStage(this.setAgentVisRaw(colAgents, true, 'box'));
+			this.addStage(this.setAgentVis(colAgents, true, 'box'));
 			this.defineAgents(colAgents);
 
 			this.addStage({
 				type,
-				agentNames: colAgents.map(getAgentName),
+				agentNames,
 				mode,
 				label,
 			});
 		}
 
 		handleAgentDefine({agents}) {
-			this.defineAgents(agents.map(convertAgent));
+			this.defineAgents(agents.map(this.convertAgent));
 		}
 
 		handleAgentBegin({agents, mode}) {
-			this.addStage(this.setAgentVis(agents, true, mode, true));
+			const colAgents = agents.map(this.convertAgent);
+			this.addStage(this.setAgentVis(colAgents, true, mode, true));
 		}
 
 		handleAgentEnd({agents, mode}) {
+			const colAgents = agents.map(this.convertAgent);
 			this.addParallelStages([
-				this.setAgentHighlight(agents, false),
-				this.setAgentVis(agents, false, mode, true),
+				this.setAgentHighlight(colAgents, false),
+				this.setAgentVis(colAgents, false, mode, true),
 			]);
 		}
 
@@ -467,6 +507,7 @@ define(['core/ArrayUtilities'], (array) => {
 		generate({stages, meta = {}}) {
 			this.agentStates.clear();
 			this.markers.clear();
+			this.agentAliases.clear();
 			this.agents.length = 0;
 			this.blockCount = 0;
 			this.nesting.length = 0;
@@ -485,7 +526,7 @@ define(['core/ArrayUtilities'], (array) => {
 
 			this.addParallelStages([
 				this.setAgentHighlight(this.agents, false),
-				this.setAgentVisRaw(this.agents, false, terminators),
+				this.setAgentVis(this.agents, false, terminators),
 			]);
 
 			addBounds(
diff --git a/scripts/sequence/Generator_spec.js b/scripts/sequence/Generator_spec.js
index 4f4ed59..b5701f4 100644
--- a/scripts/sequence/Generator_spec.js
+++ b/scripts/sequence/Generator_spec.js
@@ -8,7 +8,7 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 			if(typeof item === 'object') {
 				return item;
 			} else {
-				return {name: item, flags: []};
+				return {name: item, alias: '', flags: []};
 			}
 		});
 	}
@@ -231,6 +231,33 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 			]);
 		});
 
+		it('converts aliases', () => {
+			const sequence = generator.generate({stages: [
+				PARSED.defineAgents([{name: 'Baz', alias: 'B', flags: []}]),
+				PARSED.connect(['A', 'B']),
+			]});
+			expect(sequence.agents).toEqual([
+				{name: '[', anchorRight: true},
+				{name: 'Baz', anchorRight: false},
+				{name: 'A', anchorRight: false},
+				{name: ']', anchorRight: false},
+			]);
+		});
+
+		it('rejects duplicate aliases', () => {
+			expect(() => generator.generate({stages: [
+				PARSED.defineAgents([{name: 'Foo', alias: 'B', flags: []}]),
+				PARSED.defineAgents([{name: 'Bar', alias: 'B', flags: []}]),
+			]})).toThrow();
+		});
+
+		it('rejects using agent names as aliases', () => {
+			expect(() => generator.generate({stages: [
+				PARSED.defineAgents([{name: 'Foo', alias: 'B', flags: []}]),
+				PARSED.defineAgents([{name: 'Bar', alias: 'Foo', flags: []}]),
+			]})).toThrow();
+		});
+
 		it('creates implicit begin stages for agents when used', () => {
 			const sequence = generator.generate({stages: [
 				PARSED.connect(['A', 'B']),
@@ -347,6 +374,16 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 			]);
 		});
 
+		it('removes duplicate begin agents', () => {
+			const sequence = generator.generate({stages: [
+				PARSED.beginAgents(['A', 'A']),
+			]});
+			expect(sequence.stages).toEqual([
+				GENERATED.beginAgents(['A']),
+				jasmine.anything(),
+			]);
+		});
+
 		it('collapses adjacent begin statements', () => {
 			const sequence = generator.generate({stages: [
 				PARSED.connect(['A', 'B']),
@@ -378,6 +415,17 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 			]);
 		});
 
+		it('removes duplicate end agents', () => {
+			const sequence = generator.generate({stages: [
+				PARSED.beginAgents(['A']),
+				PARSED.endAgents(['A', 'A']),
+			]});
+			expect(sequence.stages).toEqual([
+				jasmine.anything(),
+				GENERATED.endAgents(['A']),
+			]);
+		});
+
 		it('removes superfluous end statements', () => {
 			const sequence = generator.generate({stages: [
 				PARSED.defineAgents(['E']),
@@ -409,8 +457,8 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 
 		it('adds parallel highlighting stages', () => {
 			const sequence = generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['start']}]),
-				PARSED.connect(['A', {name: 'B', flags: ['stop']}]),
+				PARSED.connect(['A', {name: 'B', alias: '', flags: ['start']}]),
+				PARSED.connect(['A', {name: 'B', alias: '', flags: ['stop']}]),
 			]});
 			expect(sequence.stages).toEqual([
 				jasmine.anything(),
@@ -428,7 +476,7 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 
 		it('adds parallel begin stages', () => {
 			const sequence = generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['begin']}]),
+				PARSED.connect(['A', {name: 'B', alias: '', flags: ['begin']}]),
 			]});
 			expect(sequence.stages).toEqual([
 				GENERATED.beginAgents(['A']),
@@ -442,7 +490,7 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 
 		it('adds parallel end stages', () => {
 			const sequence = generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['end']}]),
+				PARSED.connect(['A', {name: 'B', alias: '', flags: ['end']}]),
 			]});
 			expect(sequence.stages).toEqual([
 				GENERATED.beginAgents(['A', 'B']),
@@ -456,8 +504,8 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 
 		it('implicitly ends highlighting when ending a stage', () => {
 			const sequence = generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['start']}]),
-				PARSED.connect(['A', {name: 'B', flags: ['end']}]),
+				PARSED.connect(['A', {name: 'B', alias: '', flags: ['start']}]),
+				PARSED.connect(['A', {name: 'B', alias: '', flags: ['end']}]),
 			]});
 			expect(sequence.stages).toEqual([
 				jasmine.anything(),
@@ -472,32 +520,41 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 		});
 
 		it('rejects conflicting flags', () => {
-			expect(() => generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['start', 'stop']}]),
-			]})).toThrow();
-
 			expect(() => generator.generate({stages: [
 				PARSED.connect([
-					{name: 'A', flags: ['start']},
-					{name: 'A', flags: ['stop']},
+					'A',
+					{name: 'B', alias: '', flags: ['start', 'stop']},
 				]),
 			]})).toThrow();
 
 			expect(() => generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['begin', 'end']}]),
+				PARSED.connect([
+					{name: 'A', alias: '', flags: ['start']},
+					{name: 'A', alias: '', flags: ['stop']},
+				]),
 			]})).toThrow();
 
 			expect(() => generator.generate({stages: [
 				PARSED.connect([
-					{name: 'A', flags: ['begin']},
-					{name: 'A', flags: ['end']},
+					'A',
+					{name: 'B', alias: '', flags: ['begin', 'end']},
+				]),
+			]})).toThrow();
+
+			expect(() => generator.generate({stages: [
+				PARSED.connect([
+					{name: 'A', alias: '', flags: ['begin']},
+					{name: 'A', alias: '', flags: ['end']},
 				]),
 			]})).toThrow();
 		});
 
 		it('adds implicit highlight end with implicit terminator', () => {
 			const sequence = generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['start']}]),
+				PARSED.connect([
+					'A',
+					{name: 'B', alias: '', flags: ['start']},
+				]),
 			]});
 			expect(sequence.stages).toEqual([
 				jasmine.anything(),
@@ -511,7 +568,7 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 
 		it('adds implicit highlight end with explicit terminator', () => {
 			const sequence = generator.generate({stages: [
-				PARSED.connect(['A', {name: 'B', flags: ['start']}]),
+				PARSED.connect(['A', {name: 'B', alias: '', flags: ['start']}]),
 				PARSED.endAgents(['A', 'B']),
 			]});
 			expect(sequence.stages).toEqual([
@@ -527,8 +584,8 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 		it('collapses adjacent end statements containing highlighting', () => {
 			const sequence = generator.generate({stages: [
 				PARSED.connect([
-					{name: 'A', flags: ['start']},
-					{name: 'B', flags: ['start']},
+					{name: 'A', alias: '', flags: ['start']},
+					{name: 'B', alias: '', flags: ['start']},
 				]),
 				PARSED.endAgents(['A']),
 				PARSED.endAgents(['B']),
@@ -849,6 +906,15 @@ defineDescribe('Sequence Generator', ['./Generator'], (Generator) => {
 			]);
 		});
 
+		it('rejects note between with a repeated agent', () => {
+			expect(() => generator.generate({stages: [
+				PARSED.note('note between', ['A', 'A'], {
+					mode: 'foo',
+					label: 'bar',
+				}),
+			]})).toThrow();
+		});
+
 		it('defaults to showing notes around the entire diagram', () => {
 			const sequence = generator.generate({stages: [
 				PARSED.note('note right', []),
diff --git a/scripts/sequence/Parser.js b/scripts/sequence/Parser.js
index 2aaaf69..1992ec9 100644
--- a/scripts/sequence/Parser.js
+++ b/scripts/sequence/Parser.js
@@ -114,7 +114,27 @@ define([
 		return -1;
 	}
 
-	function readAgent(line, start, end, flagTypes = {}) {
+	function readAgentAlias(line, start, end, enableAlias) {
+		let aliasSep = -1;
+		if(enableAlias) {
+			aliasSep = findToken(line, 'as', start);
+		}
+		if(aliasSep === -1 || aliasSep >= end) {
+			aliasSep = end;
+		}
+		if(start >= aliasSep) {
+			throw new Error('Missing agent name');
+		}
+		return {
+			name: joinLabel(line, start, aliasSep),
+			alias: joinLabel(line, aliasSep + 1, end),
+		};
+	}
+
+	function readAgent(line, start, end, {
+		flagTypes = {},
+		aliases = false,
+	} = {}) {
 		const flags = [];
 		let p = start;
 		for(; p < end; ++ p) {
@@ -129,23 +149,22 @@ define([
 				break;
 			}
 		}
-		if(p >= end) {
-			throw new Error('Missing agent name');
-		}
+		const {name, alias} = readAgentAlias(line, p, end, aliases);
 		return {
-			name: joinLabel(line, p, end),
+			name,
+			alias,
 			flags,
 		};
 	}
 
-	function readAgentList(line, start, end, flagTypes) {
+	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, flagTypes));
+					list.push(readAgent(line, currentStart, i, readAgentOpts));
 					currentStart = -1;
 				}
 			} else if(currentStart === -1) {
@@ -153,7 +172,7 @@ define([
 			}
 		}
 		if(currentStart !== -1) {
-			list.push(readAgent(line, currentStart, end, flagTypes));
+			list.push(readAgent(line, currentStart, end, readAgentOpts));
 		}
 		return list;
 	}
@@ -208,7 +227,7 @@ define([
 				return null;
 			}
 			return Object.assign({
-				agents: readAgentList(line, 1, line.length),
+				agents: readAgentList(line, 1, line.length, {aliases: true}),
 			}, type);
 		},
 
@@ -280,11 +299,14 @@ define([
 			if(typePos <= 0 || typePos >= labelSep - 1) {
 				return null;
 			}
+			const readAgentOpts = {
+				flagTypes: CONNECT_AGENT_FLAGS,
+			};
 			return {
 				type: 'connect',
 				agents: [
-					readAgent(line, 0, typePos, CONNECT_AGENT_FLAGS),
-					readAgent(line, typePos + 1, labelSep, CONNECT_AGENT_FLAGS),
+					readAgent(line, 0, typePos, readAgentOpts),
+					readAgent(line, typePos + 1, labelSep, readAgentOpts),
 				],
 				label: joinLabel(line, labelSep + 1),
 				options,
diff --git a/scripts/sequence/Parser_spec.js b/scripts/sequence/Parser_spec.js
index 503428d..fdc6171 100644
--- a/scripts/sequence/Parser_spec.js
+++ b/scripts/sequence/Parser_spec.js
@@ -12,7 +12,11 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 		} = {}) => {
 			return {
 				type: 'connect',
-				agents: agentNames.map((name) => ({name, flags: []})),
+				agents: agentNames.map((name) => ({
+					name,
+					alias: '',
+					flags: [],
+				})),
 				label,
 				options: {
 					line,
@@ -64,6 +68,15 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 			]);
 		});
 
+		it('propagates aliases', () => {
+			const parsed = parser.parse('define Foo Bar as A B');
+			expect(parsed.stages).toEqual([
+				{type: 'agent define', agents: [
+					{name: 'Foo Bar', alias: 'A B', flags: []},
+				]},
+			]);
+		});
+
 		it('respects spacing within agent names', () => {
 			const parsed = parser.parse('A+B -> C  D');
 			expect(parsed.stages).toEqual([
@@ -84,8 +97,12 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 				{
 					type: 'connect',
 					agents: [
-						{name: 'A', flags: ['start']},
-						{name: 'B', flags: ['stop', 'begin', 'end']},
+						{name: 'A', alias: '', flags: ['start']},
+						{name: 'B', alias: '', flags: [
+							'stop',
+							'begin',
+							'end',
+						]},
 					],
 					label: jasmine.anything(),
 					options: jasmine.anything(),
@@ -192,7 +209,7 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 			const parsed = parser.parse('note over A: hello there');
 			expect(parsed.stages).toEqual([{
 				type: 'note over',
-				agents: [{name: 'A', flags: []}],
+				agents: [{name: 'A', alias: '', flags: []}],
 				mode: 'note',
 				label: 'hello there',
 			}]);
@@ -209,31 +226,34 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 			expect(parsed.stages).toEqual([
 				{
 					type: 'note left',
-					agents: [{name: 'A', flags: []}],
+					agents: [{name: 'A', alias: '', flags: []}],
 					mode: 'note',
 					label: 'hello there',
 				},
 				{
 					type: 'note left',
-					agents: [{name: 'A', flags: []}],
+					agents: [{name: 'A', alias: '', flags: []}],
 					mode: 'note',
 					label: 'hello there',
 				},
 				{
 					type: 'note right',
-					agents: [{name: 'A', flags: []}],
+					agents: [{name: 'A', alias: '', flags: []}],
 					mode: 'note',
 					label: 'hello there',
 				},
 				{
 					type: 'note right',
-					agents: [{name: 'A', flags: []}],
+					agents: [{name: 'A', alias: '', flags: []}],
 					mode: 'note',
 					label: 'hello there',
 				},
 				{
 					type: 'note between',
-					agents: [{name: 'A', flags: []}, {name: 'B', flags: []}],
+					agents: [
+						{name: 'A', alias: '', flags: []},
+						{name: 'B', alias: '', flags: []},
+					],
 					mode: 'note',
 					label: 'hi',
 				},
@@ -244,7 +264,10 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 			const parsed = parser.parse('note over A B, C D: hi');
 			expect(parsed.stages).toEqual([{
 				type: 'note over',
-				agents: [{name: 'A B', flags: []}, {name: 'C D', flags: []}],
+				agents: [
+					{name: 'A B', alias: '', flags: []},
+					{name: 'C D', alias: '', flags: []},
+				],
 				mode: 'note',
 				label: 'hi',
 			}]);
@@ -258,7 +281,7 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 			const parsed = parser.parse('state over A: doing stuff');
 			expect(parsed.stages).toEqual([{
 				type: 'note over',
-				agents: [{name: 'A', flags: []}],
+				agents: [{name: 'A', alias: '', flags: []}],
 				mode: 'state',
 				label: 'doing stuff',
 			}]);
@@ -272,7 +295,7 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 			const parsed = parser.parse('text right of A: doing stuff');
 			expect(parsed.stages).toEqual([{
 				type: 'note right',
-				agents: [{name: 'A', flags: []}],
+				agents: [{name: 'A', alias: '', flags: []}],
 				mode: 'text',
 				label: 'doing stuff',
 			}]);
@@ -287,16 +310,25 @@ defineDescribe('Sequence Parser', ['./Parser'], (Parser) => {
 			expect(parsed.stages).toEqual([
 				{
 					type: 'agent define',
-					agents: [{name: 'A', flags: []}, {name: 'B', flags: []}],
+					agents: [
+						{name: 'A', alias: '', flags: []},
+						{name: 'B', alias: '', flags: []},
+					],
 				},
 				{
 					type: 'agent begin',
-					agents: [{name: 'A', flags: []}, {name: 'B', flags: []}],
+					agents: [
+						{name: 'A', alias: '', flags: []},
+						{name: 'B', alias: '', flags: []},
+					],
 					mode: 'box',
 				},
 				{
 					type: 'agent end',
-					agents: [{name: 'A', flags: []}, {name: 'B', flags: []}],
+					agents: [
+						{name: 'A', alias: '', flags: []},
+						{name: 'B', alias: '', flags: []},
+					],
 					mode: 'cross',
 				},
 			]);
diff --git a/scripts/sequence/components/Note.js b/scripts/sequence/components/Note.js
index bc705f9..742c8e1 100644
--- a/scripts/sequence/components/Note.js
+++ b/scripts/sequence/components/Note.js
@@ -103,11 +103,10 @@ define(['./BaseComponent'], (BaseComponent) => {
 				config.padding.right
 			);
 
-			if(agentNames.length > 1) {
-				const {left, right} = findExtremes(env.agentInfos, agentNames);
-				const infoL = env.agentInfos.get(left);
-				const infoR = env.agentInfos.get(right);
-
+			const {left, right} = findExtremes(env.agentInfos, agentNames);
+			const infoL = env.agentInfos.get(left);
+			const infoR = env.agentInfos.get(right);
+			if(infoL !== infoR) {
 				const hangL = infoL.currentMaxRad + config.overlap.left;
 				const hangR = infoR.currentMaxRad + config.overlap.right;
 
@@ -116,7 +115,7 @@ define(['./BaseComponent'], (BaseComponent) => {
 				env.addSpacing(left, {left: hangL, right: 0});
 				env.addSpacing(right, {left: 0, right: hangR});
 			} else {
-				env.addSpacing(agentNames[0], {
+				env.addSpacing(left, {
 					left: width / 2,
 					right: width / 2,
 				});
@@ -126,10 +125,10 @@ define(['./BaseComponent'], (BaseComponent) => {
 		render({agentNames, mode, label}, env) {
 			const config = env.theme.note[mode];
 
-			if(agentNames.length > 1) {
-				const {left, right} = findExtremes(env.agentInfos, agentNames);
-				const infoL = env.agentInfos.get(left);
-				const infoR = env.agentInfos.get(right);
+			const {left, right} = findExtremes(env.agentInfos, agentNames);
+			const infoL = env.agentInfos.get(left);
+			const infoR = env.agentInfos.get(right);
+			if(infoL !== infoR) {
 				return this.renderNote({
 					x0: infoL.x - infoL.currentMaxRad - config.overlap.left,
 					x1: infoR.x + infoR.currentMaxRad + config.overlap.right,
@@ -138,7 +137,7 @@ define(['./BaseComponent'], (BaseComponent) => {
 					label,
 				}, env);
 			} else {
-				const xMid = env.agentInfos.get(agentNames[0]).x;
+				const xMid = infoL.x;
 				return this.renderNote({
 					xMid,
 					anchor: 'middle',
diff --git a/scripts/tester/jshintRunner.js b/scripts/tester/jshintRunner.js
index 4306364..a3331ac 100644
--- a/scripts/tester/jshintRunner.js
+++ b/scripts/tester/jshintRunner.js
@@ -34,7 +34,7 @@ define(['jshintConfig', 'specs'], (jshintConfig) => {
 
 	const OPTS_TEST = Object.assign({}, jshintConfig, {
 		predef: PREDEF_TEST,
-		maxstatements: 50, // allow lots of tests
+		maxstatements: 100, // allow lots of tests
 	});
 
 	function formatError(error) {
diff --git a/styles/main.css b/styles/main.css
index 36e38a0..9f20cbb 100644
--- a/styles/main.css
+++ b/styles/main.css
@@ -88,6 +88,7 @@ html, body {
 	background: #FFFFFF;
 	font-family: sans-serif;
 	overflow: hidden;
+	user-select: none;
 }
 
 .options.links {