Numerous bug fixes. Unit tests working again.

js/markdown.js

 		for (var s = startIndex; s < tokensToSearch.length; s++) {
 			var startMatch = this.findFirstTokens(tokensToSearch, startPattern, s);
 			if (startMatch === null) return null;
-			var endMatch = this.findFirstTokens(tokensToSearch, endPattern, startMatch.index + startMatch.tokens.length);
-			if (endMatch === null) return null;
-			var contents = tokensToSearch.slice(startMatch.index + startMatch.tokens.length, endMatch.index);
-			if (contents.length > 0 && (contentValidator === null || contentValidator(contents))) {
-				return {
-					'startTokens': startMatch.tokens,
-					'contentTokens': contents,
-					'endTokens': endMatch.tokens,
-					'startIndex': startMatch.index,
-					'contentIndex': startMatch.index + startMatch.tokens.length,
-					'endIndex': endMatch.index,
-					'totalLength': endMatch.index + endMatch.tokens.length - startMatch.index,
-				};
-			} else {
-				// No match. Try again right after this start index.
-				s = startMatch.index;
+			var endStart = startMatch.index + startMatch.tokens.length;
+			while (endStart < tokensToSearch.length) {
+				var endMatch = this.findFirstTokens(tokensToSearch, endPattern, endStart);
+				if (endMatch === null) break;
+				var contents = tokensToSearch.slice(startMatch.index + startMatch.tokens.length, endMatch.index);
+				if (contents.length > 0 && (contentValidator === null || contentValidator(contents))) {
+					return {
+						'startTokens': startMatch.tokens,
+						'contentTokens': contents,
+						'endTokens': endMatch.tokens,
+						'startIndex': startMatch.index,
+						'contentIndex': startMatch.index + startMatch.tokens.length,
+						'endIndex': endMatch.index,
+						'totalLength': endMatch.index + endMatch.tokens.length - startMatch.index,
+					};
+				} else {
+					// Contents rejected. Try next end match.
+					endStart = endMatch.index + 1;
+				}
 			}
+			// No end matches. Increment start match.
+			s = startMatch.index;
 		}
 		return null;
 	}
 	static tokenizeURL(line) {
 		var groups;
 		if (groups = this.#urlWithTitleRegex.exec(line)) {
+			if (this.tokenizeEmail(line)) return null; // make sure it's not better described as an email address
 			return groups;
 		}
 		if (groups = this.#urlRegex.exec(line)) {
+			if (this.tokenizeEmail(line)) return null;
 			return [...groups, null];
 		}
 		return null;
 		}
 		return null;
 	}
+
+	/**
+	 * Describes the type of a variable for debugging.
+	 *
+	 * @param {any} value - value
+	 * @returns {String} description of type
+	 */
+	static typename(value) {
+		if (value === null) return 'null';
+		if (value instanceof Object) {
+			return value.constructor.name;
+		}
+		return typeof value;
+	}
 }
 
 
 		line = line.trim();
 		if (line.startsWith('|')) line = line.substring(1);
 		if (line.endsWith('|')) line = line.substring(0, line.length - 1);
-		return line.split('|').map(function(token) {
-			token = token.trim();
+		return line.split(/\s*\|\s*/).map(function(token) {
 			if (token.startsWith(':')) {
 				if (token.endsWith(':')) {
 					return MDTableCellBlock.AlignCenter;
 		});
 	}
 
-	static #tableDividerRegex = /^\s*[|]?(?:\s*[:]?-+[:]?\s*\|)(?:\s*[:]?-+[:]?\s*)[|]?\s*$/;
+	static #tableDividerRegex = /^\s*[|]?\s*(?:[:]?-+[:]?)(?:\s*\|\s*[:]?-+[:]?)*\s*[|]?\s*$/;
 
 	readBlock(state) {
 		if (!state.hasLines(2)) return null;
 		let startP = state.p;
 		let firstLine = state.lines[startP];
-		var ignore, modifier;
-		[ignore, modifier] = MDTagModifier.fromLine(firstLine);
+		var modifier = MDTagModifier.fromLine(firstLine)[1];
 		let headerRow = this.#readTableRow(state, true);
 		if (headerRow === null) {
 			state.p = startP;
 		if (paragraphLines.length > 0) {
 			state.p = p;
 			let content = paragraphLines.join("\n");
-			return new MDParagraphBlock(state.inlineMarkdownToSpan(content));
+			return new MDParagraphBlock(new MDInlineBlock(state.inlineMarkdownToSpans(content)));
 		}
 		return null;
 	}
 	 * @param {number} count - how many times the token is repeated to form the delimiter
 	 * @returns {boolean} `true` if substitution performed, `false` if not
 	 */
-	attemptPair(state, priority, tokens, spanClass, delimiter, count=1) {
+	attemptPair(state, priority, tokens, spanClass, delimiter, count=1, plaintext=false) {
 		let delimiters = Array(count).fill(delimiter);
 		let firstPassPriority = (this.substitutePriority instanceof Array) ? this.substitutePriority[0] : null;
 		let match = MDToken.findPairedTokens(tokens, delimiters, delimiters, function(content) {
+			const firstType = content[0] instanceof MDToken ? content[0].type : null;
+			const lastType = content[content.length - 1] instanceof MDToken ? content[content.length - 1].type : null;
+			if (firstType == MDTokenType.Whitespace) return false;
+			if (lastType == MDTokenType.Whitespace) return false;
 			if (priority == firstPassPriority) {
+				var innerCount = 0;
 				for (let token of content) {
-					if (token instanceof MDToken && token.type == delimiter) return false;
+					if (token instanceof MDToken && token.type == delimiter) innerCount++;
 				}
+				if ((innerCount % 2) != 0) return false;
 			}
 			return true;
 		});
 		if (match === null) return false;
-		tokens.splice(match.startIndex, match.totalLength, new spanClass(state.tokensToSpans(match.contentTokens)));
+		let content = (plaintext)
+			? match.contentTokens.map((token) => token.original).join('')
+			: state.tokensToSpans(match.contentTokens);
+		tokens.splice(match.startIndex, match.totalLength, new spanClass(content));
 		return true;
 	}
 }
 }
 
 class MDCodeInlineReader extends MDSimplePairInlineReader {
-	constructor(tokenizePriority=0.0, substitutePriority=[0.0, 50.0]) {
+	constructor(tokenizePriority=0.0, substitutePriority=0.0) {
 		super(tokenizePriority, substitutePriority);
 	}
 
 	}
 
 	substituteTokens(state, priority, tokens) {
-		if (this.attemptPair(state, priority, tokens, MDCodeSpan, MDTokenType.Backtick, 2)) return true;
-		if (this.attemptPair(state, priority, tokens, MDCodeSpan, MDTokenType.Backtick)) return true;
+		// ignore priority
+		if (this.attemptPair(state, -1, tokens, MDCodeSpan, MDTokenType.Backtick, 2, true)) return true;
+		if (this.attemptPair(state, -1, tokens, MDCodeSpan, MDTokenType.Backtick, 1, true)) return true;
 		return false;
 	}
 }
 }
 
 class MDSimpleLinkInlineReader extends MDInlineReader {
-	static #simpleURLRegex = new RegExp("^<(" + MDUtils.baseURLRegex.source + ")>", "i");  // 1=URL
 	static #simpleEmailRegex = new RegExp("^<(" + MDUtils.baseEmailRegex.source + ")>", "i");  // 1=email
+	static #simpleURLRegex = new RegExp("^<(" + MDUtils.baseURLRegex.source + ")>", "i");  // 1=URL
 
 	constructor(tokenizePriority=0.0, substitutePriority=0.0) {
 		super(tokenizePriority, substitutePriority);
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
+	#substituteEmail(state, tokens) {
+		const result = MDToken.findFirstTokens(tokens, [ MDTokenType.SimpleEmail ]);
+		if (result === null) return false;
+		/** @type {MDToken} */
+		const token = result.tokens[0];
+		const link = `mailto:${token.content}`;
+		const span = new MDLinkSpan(link, new MDObfuscatedTextSpan(token.content));
+		tokens.splice(result.index, 1, span);
+		return true;
+	}
+
+	#substituteURL(state, tokens) {
 		const result = MDToken.findFirstTokens(tokens, [ MDTokenType.SimpleLink ]);
 		if (result === null) return false;
 		/** @type {MDToken} */
 		tokens.splice(result.index, 1, span);
 		return true;
 	}
+
+	substituteTokens(state, priority, tokens) {
+		if (this.#substituteEmail(state, tokens)) return true;
+		if (this.#substituteURL(state, tokens)) return true;
+		return false;
+	}
 }
 
 class MDHTMLTagInlineReader extends MDInlineReader {
 	 */
 	constructor(blocks) {
 		super();
-		this.#blocks = blocks;
+		if (blocks instanceof Array) {
+			this.#blocks = blocks;
+		} else {
+			throw new Error(`${MDUtils.typename(this)} expects MDBlock[], got ${MDUtils.typename(blocks)}`);
+		}
 	}
 
 	toHTML(state) {
 }
 
 class MDParagraphBlock extends MDBlock {
-	/** @type {MDBlock} */
-	content;
+	/** @type {MDBlock[]} */
+	#content;
 
 	/**
-	 * @param {MDBlock} content
+	 * @param {MDBlock|MDBlock[]} content
 	 */
 	constructor(content) {
 		super();
-		this.content = content;
+		if (content instanceof Array) {
+			this.#content = content;
+		} else if (content instanceof MDBlock) {
+			this.#content = [ content ];
+		} else {
+			throw new Error(`${MDUtils.typename(this)} expects MDBlock[] or MDBlock, got ${MDUtils.typename(content)}`);
+		}
 	}
 
 	toHTML(state) {
-		let contentHTML = this.content.toHTML(state);
+		const contentHTML = MDBlock.toHTML(this.#content, state);
 		return `<p${this.htmlAttributes()}>${contentHTML}</p>\n`;
 	}
 
 	visitChildren(fn) {
-		fn(this.content);
-		this.content.visitChildren(fn);
+		for (const child of this.#content) {
+			fn(child);
+			child.visitChildren(fn);
+		}
 	}
 }
 
 class MDHeaderBlock extends MDBlock {
 	/** @type {number} */
-	level;
+	#level;
 	/** @type {MDBlock} */
-	content;
+	#content;
 
 	/**
 	 * @param {number} level
 	 */
 	constructor(level, content) {
 		super();
-		this.level = level;
-		this.content = content;
+		this.#level = level;
+		this.#content = content;
 	}
 
 	toHTML(state) {
-		let contentHTML = this.content.toHTML(state);
-		return `<h${this.level}${this.htmlAttributes()}>${contentHTML}</h${this.level}>\n`;
+		let contentHTML = this.#content.toHTML(state);
+		return `<h${this.#level}${this.htmlAttributes()}>${contentHTML}</h${this.level}>\n`;
 	}
 
 	visitChildren(fn) {
 }
 
 class MDCodeSpan extends MDSpan {
-	/** @type {string} content */
+	/** @type {String} content */
 	#content;
 
 	/**
-	 * @param {string} content
+	 * @param {String} content
 	 */
 	constructor(content) {
 		super();
-		this.#content = content;
+		if (typeof content == 'string') {
+			this.#content = content;
+		} else {
+			throw new Error(`${this.constructor.name} content must be String, got ${typeof content}`);
+		}
 	}
 
 	toHTML(state) {
 				const changed = reader.substituteTokens(this, priority, spans);
 				if (!changed) continue;
 				anyChanges = true;
+				break;
 			}
 		} while (anyChanges);
 
 	 * @type {MDInlineReader[]}
 	 */
 	static standardInlineReaders = [
-		new MDStrongInlineReader(10.0, [ 0.0, 50.0 ]),
-		new MDEmphasisInlineReader(15.0, [ 0.0, 50.0 ]),
-		new MDCodeInlineReader(20.0, [ 0.0, 50.0 ]),
-		new MDImageInlineReader(25.0, 10.0),
-		new MDLinkInlineReader(30.0, 15.0),
-		new MDSimpleLinkInlineReader(35.0, 20.0),
-		new MDHTMLTagInlineReader(80.0, 25.0),
+		new MDStrongInlineReader(10.0, [ 0.0, 2.0 ]),
+		new MDEmphasisInlineReader(15.0, [ 5.0, 55.0 ]),
+		new MDCodeInlineReader(20.0, [ 10.0, 60.0 ]),
+		new MDImageInlineReader(25.0, 15.0),
+		new MDLinkInlineReader(30.0, 20.0),
+		new MDSimpleLinkInlineReader(35.0, 25.0),
+		new MDHTMLTagInlineReader(80.0, 30.0),
 	];
 
 	/**
 	 */
 	static allInlineReaders = [
 		...this.standardInlineReaders,
-		new MDStrikethroughInlineReader(21.0, [ 0.0, 50.0 ]),
-		new MDFootnoteInlineReader(5.0, 30.0),
-		new MDModifierInlineReader(90.0, 35.0),
+		new MDStrikethroughInlineReader(21.0, [ 12.0, 50.0 ]),
+		new MDFootnoteInlineReader(5.0, 40.0),
+		new MDModifierInlineReader(90.0, 45.0),
 	];
 
 	/**

testjs.html

 			}
 		</style>
 		<script src="js/markdown.js"></script>
+		<!-- Testing infrastructure -->
 		<script>
-			function onLoad() {
-				let testClasses = [
-					InlineTests,
-					BlockTests,
-				];
-				TestClassRunner.runAll(testClasses);
-			}
-
 			/**
 			 * @param {String} text
 			 * @returns {String}
 			 */
 			function escapeHTML(text) {
-				return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+				return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\n/g, '<br/>\n');
 			}
 
 			class ResultType {
 					if (test) this.fail(failMessage || `expected false, got ${test}`);
 				}
 				assertEqual(a, b, failMessage=null) {
-					if (a != b) this.fail(failMessage || `equality failed: ${a} != ${b}`);
+					if (a == b) return;
+					const aVal = `${a}`;
+					const bVal = `${b}`;
+					if (aVal.length > 20 || bVal.length > 20) {
+						this.fail(failMessage || `equality failed:\n${aVal}\n!=\n${bVal}`);
+					} else {
+						this.fail(failMessage || `equality failed: ${aVal} != ${bVal}`);
+					}
 				}
 				expectError(e=true) {
 					if (this.currentRunner) this.currentRunner.expectedError = e;
 						} else {
 							this.result = ResultType.errored;
 							this.message = e.message;
+							if (e.stack !== undefined) {
+								this.message += "\n" + e.stack;
+							}
 						}
 					} finally {
 						this.expectedError = null;
 					}, 1);
 				}
 			}
-
-			// ---------------------------------------------------------------
+		</script>
+		<!-- Tests -->
+		<script>
+			function onLoad() {
+				let testClasses = [
+					TokenTests,
+					InlineTests,
+					BlockTests,
+				];
+				TestClassRunner.runAll(testClasses);
+			}
+			document.addEventListener('DOMContentLoaded', onLoad);
 
 			function normalizeWhitespace(str) {
 				return str.replace(/\s+/g, ' ').replace(/(?:^\s+|\s+$)/g, '');
 			}
 
+			class TokenTests extends BaseTest {
+				test_findFirstTokens() {
+					const tokens = [
+						new MDToken('Lorem', MDTokenType.Text),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('_', MDTokenType.Underscore),
+						new MDToken('ipsum', MDTokenType.Text),
+						new MDToken('_', MDTokenType.Underscore),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('dolor', MDTokenType.Text),
+						new MDToken('_', MDTokenType.Underscore),
+						new MDToken('sit', MDTokenType.Text),
+						new MDToken('_', MDTokenType.Underscore),
+					];
+					const pattern = [
+						MDTokenType.Underscore,
+					];
+					const result = MDToken.findFirstTokens(tokens, pattern);
+					const expected = {
+						tokens: [ tokens[2] ],
+						index: 2,
+					};
+					this.assertEqual(JSON.stringify(result), JSON.stringify(expected));
+				}
+
+				test_findPairedTokens() {
+					const tokens = [
+						new MDToken('Lorem', MDTokenType.Text),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('_', MDTokenType.Underscore),
+						new MDToken('ipsum', MDTokenType.Text),
+						new MDToken('_', MDTokenType.Underscore),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('dolor', MDTokenType.Text),
+						new MDToken('_', MDTokenType.Underscore),
+						new MDToken('sit', MDTokenType.Text),
+						new MDToken('_', MDTokenType.Underscore),
+					];
+					const pattern = [
+						MDTokenType.Underscore,
+					];
+					const result = MDToken.findPairedTokens(tokens, pattern, pattern);
+					const expected = {
+						startTokens: [ tokens[2] ],
+						contentTokens: [ tokens[3] ],
+						endTokens: [ tokens[4] ],
+						startIndex: 2,
+						contentIndex: 3,
+						endIndex: 4,
+						totalLength: 3,
+					}
+					this.assertEqual(JSON.stringify(result), JSON.stringify(expected));
+				}
+			}
+
 			class InlineTests extends BaseTest {
+				/** @type {Markdown} */
+				parser;
+				md(markdown) {
+					return normalizeWhitespace(this.parser.toHTML(markdown));
+				}
+			
+				setUp() {
+					this.parser = Markdown.completeParser;
+				}
+
 				test_simpleSingleParagraph() {
 					let markdown = 'Lorem ipsum';
 					let expected = '<p>Lorem ipsum</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_strong() {
 					let markdown = 'Lorem **ipsum** dolor **sit**';
 					let expected = '<p>Lorem <strong>ipsum</strong> dolor <strong>sit</strong></p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_emphasis() {
 					let markdown = 'Lorem _ipsum_ dolor _sit_';
 					let expected = '<p>Lorem <em>ipsum</em> dolor <em>sit</em></p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
-				test_strongEmphasis_easy() {
+				test_strongEmphasis_cleanNesting1() {
 					let markdown = 'Lorem **ipsum *dolor* sit** amet';
 					let expected = '<p>Lorem <strong>ipsum <em>dolor</em> sit</strong> amet</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
-				test_strongEmphasis_medium() {
+				test_strongEmphasis_cleanNesting2() {
+					let markdown = 'Lorem *ipsum **dolor** sit* amet';
+					let expected = '<p>Lorem <em>ipsum <strong>dolor</strong> sit</em> amet</p>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_strongEmphasis_tightNesting() {
 					let markdown = 'Lorem ***ipsum*** dolor';
 					let expected1 = '<p>Lorem <strong><em>ipsum</em></strong> dolor</p>';
 					let expected2 = '<p>Lorem <em><strong>ipsum</strong></em> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertTrue(actual == expected1 || actual == expected2);
 				}
 
-				test_strongEmphasis_hard1() {
+				test_strongEmphasis_lopsidedNesting1() {
 					let markdown = 'Lorem ***ipsum* dolor** sit';
 					let expected = '<p>Lorem <strong><em>ipsum</em> dolor</strong> sit</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
-				test_strongEmphasis_hard2() {
+				test_strongEmphasis_lopsidedNesting2() {
 					let markdown = 'Lorem ***ipsum** dolor* sit';
 					let expected = '<p>Lorem <em><strong>ipsum</strong> dolor</em> sit</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_strongEmphasis_lopsidedNesting3() {
+					let markdown = 'Lorem **ipsum *dolor*** sit';
+					let expected = '<p>Lorem <strong>ipsum <em>dolor</em></strong> sit</p>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_strongEmphasis_lopsidedNesting4() {
+					let markdown = 'Lorem *ipsum **dolor*** sit';
+					let expected = '<p>Lorem <em>ipsum <strong>dolor</strong></em> sit</p>';
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_inlineCode() {
 					let markdown = 'Lorem `ipsum` dolor';
 					let expected = '<p>Lorem <code>ipsum</code> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_inlineCode_withInnerBacktick() {
 					let markdown = 'Lorem ``ip`su`m`` dolor';
 					let expected = '<p>Lorem <code>ip`su`m</code> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_strikethrough_single() {
 					let markdown = 'Lorem ~ipsum~ dolor';
 					let expected = '<p>Lorem <strike>ipsum</strike> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_strikethrough_double() {
 					let markdown = 'Lorem ~~ipsum~~ dolor';
 					let expected = '<p>Lorem <strike>ipsum</strike> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_fullyQualified() {
 					let markdown = 'Lorem [ipsum](https://example.com/path/page.html) dolor';
 					let expected = '<p>Lorem <a href="https://example.com/path/page.html">ipsum</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_relative() {
 					let markdown = 'Lorem [ipsum](page.html) dolor';
 					let expected = '<p>Lorem <a href="page.html">ipsum</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_title() {
 					let markdown = 'Lorem [ipsum](page.html "link title") dolor';
 					let expected = '<p>Lorem <a href="page.html" title="link title">ipsum</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_literal() {
 					let markdown = 'Lorem <https://example.com> dolor';
 					let expected = '<p>Lorem <a href="https://example.com">https://example.com</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_ref() {
 					let markdown = "Lorem [ipsum][ref] dolor\n\n[ref]: https://example.com";
 					let expected = '<p>Lorem <a href="https://example.com">ipsum</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_email() {
 					let markdown = 'Lorem [ipsum](user@example.com) dolor';
 					let expected = '<p>Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;">ipsum</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_email_withTitle() {
 					let markdown = 'Lorem [ipsum](user@example.com "title") dolor';
 					let expected = '<p>Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;" title="title">ipsum</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_link_literalEmail() {
 					let markdown = 'Lorem <user@example.com> dolor';
 					let expected = '<p>Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;">&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;</a> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_image() {
 					let markdown = 'Lorem ![alt text](image.jpg) dolor';
 					let expected = '<p>Lorem <img src="image.jpg" alt="alt text"> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_image_noAlt() {
 					let markdown = 'Lorem ![](image.jpg) dolor';
 					let expected = '<p>Lorem <img src="image.jpg"> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_image_withTitle() {
 					let markdown = 'Lorem ![alt text](image.jpg "image title") dolor';
 					let expected = '<p>Lorem <img src="image.jpg" alt="alt text" title="image title"> dolor</p>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 			}
 
 			class BlockTests extends BaseTest {
+				/** @type {Markdown} */
+				parser;
+				md(markdown) {
+					return normalizeWhitespace(this.parser.toHTML(markdown));
+				}
+			
+				setUp() {
+					this.parser = Markdown.completeParser;
+				}
+
 				test_paragraphs() {
 					let markdown = "Lorem ipsum\n\nDolor sit amet";
 					let expected = "<p>Lorem ipsum</p> <p>Dolor sit amet</p>";
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_paragraph_lineGrouping() {
 					let markdown = "Lorem ipsum\ndolor sit amet";
 					let expected = "<p>Lorem ipsum dolor sit amet</p>";
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_unorderedList() {
 					let markdown = "* Lorem\n* Ipsum\n* Dolor";
 					let expected = '<ul> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ul>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_orderedList() {
 					let markdown = "1. Lorem\n1. Ipsum\n5. Dolor";
 					let expected = '<ol start="1"> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ol>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_orderedList_numbering() {
 					let markdown = "4. Lorem\n1. Ipsum\n9. Dolor";
 					let expected = '<ol start="4"> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ol>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_blockquote() {
 					let markdown = '> Lorem ipsum dolor';
 					let expected = '<blockquote> <p>Lorem ipsum dolor</p> </blockquote>';
-					let actual = normalizeWhitespace(Markdown.toHTML(markdown));
+					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 			}
-
-			document.addEventListener('DOMContentLoaded', onLoad);
 		</script>
 	</head>
 	<body>