All blocks and spans covered by unit tests

js/markdown.js

 // FIXME: Nested blockquotes require blank line
 // TODO: HTML tags probably need better handling. Consider whether interior of matched tags should be interpreted as markdown.
 // TODO: Test broken/incomplete syntax thoroughly
-// TODO: Sanity checks on loops/recursion?
-// TODO: Tolerate whitespace between tokens (e.g. [click here] [urlref])
+// TODO: Sanity checks on loops/recursion
 // TODO: Spreadsheet functions in tables
-// TODO: Support document differentiators for CSS identifiers
+// TODO: Support document differentiators for CSS identifiers (using markdown to render 2+ documents in the same page, need ids to be unique within the page)
+// TODO: Support language marker in ``` to at least add a CSS class to the <pre>
+// TODO: Better way to detect start of new block inside of list item without line break
 
 class MDTokenType {
 	static Text = new MDTokenType('Text');
 	toString() {
 		return `${this.constructor.name}.${this.name}`;
 	}
+
+	equals(other) {
+		return (other instanceof MDTokenType) && other.name == this.name;
+	}
 }
 
 class MDToken {
 		this.tag = tag;
 	}
 
+	toString() {
+		return `(${this.constructor.name} type=${this.type.toString()} content=${this.content})`;
+	}
+
 	/**
 	 * Searches an array of MDToken for the given pattern of MDTokenTypes.
 	 * If found, returns an object with the given keys.
 		}
 		return null;
 	}
+
+	equals(other) {
+		if (!(other instanceof MDToken)) return false;
+		if (other.original !== this.original) return false;
+		if (!other.type.equals(this.type)) return false;
+		if (other.content !== this.content) return false;
+		if (other.extra !== this.extra) return false;
+		if (!MDUtils.equal(other.tag, this.tag)) return false;
+		if (!MDUtils.equals(other.modifier, this.modifier)) return false;
+		return true
+	}
 }
 
 class MDUtils {
 	static baseEmailRegex = /(?:(?:[^<>()\[\]\\.,;:\s@"]+(?:\.[^<>()\[\]\\.,;:\s@"]+)*)|(?:".+"))@(?:(?:\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(?:(?:[a-z\-0-9]+\.)+[a-z]{2,}))/i;
 
 	/**
-	 * @param {string} str
-	 * @returns {string}
+	 * Escapes special HTML characters.
+	 *
+	 * @param {string} str - string to escape
+	 * @param {boolean} encodeNewlinesAsBreaks - whether to convert newline characters to `<br>` tags
+	 * @returns {string} escaped HTML
 	 */
-	static escapeHTML(str) {
-		return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+	static escapeHTML(str, encodeNewlinesAsBreaks=false) {
+		var html = str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+		if (encodeNewlinesAsBreaks) {
+			html = html.replace(/\n/g, "<br>\n");
+		}
+		return html;
 	}
 
 	/**
-	 * @param {string} email
+	 * Encodes characters as HTML numeric entities to make it marginally more
+	 * difficult for web scrapers to grab sensitive info.
+	 *
+	 * @param {string} text - text to escape
+	 * @returns {string} escaped HTML
 	 */
 	static escapeObfuscated(text) {
 		var html = '';
 	}
 
 	/**
+	 * Tests if an array of lines contains at least one blank. A blank line
+	 * can contain whitespace.
+	 * 
+	 * @param {String[]} lines
+	 * @returns {boolean} whether `lines` contains any whitespace-only lines
+	 */
+	static containsBlankLine(lines) {
+		for (const line of lines) {
+			if (line.trim().length == 0) return true;
+		}
+		return false;
+	}
+
+	/**
 	 * Counts the number of indent levels in a line of text. Partial indents
 	 * (1 to 3 spaces) are counted as one indent level unless `fullIndentsOnly`
 	 * is `true`.
 		}
 		return typeof value;
 	}
+
+	static #equalArrays(a, b) {
+		if (a === b) return true;
+		if (!(a instanceof Array) || !(b instanceof Array)) return false;
+		if (a == null || b == null) return false;
+		if (a.length != b.length) return false;
+		for (var i = 0; i < a.length; i++) {
+			if (!this.equal(a[i], b[i])) return false;
+		}
+		return true;
+	}
+
+	static #equalObjects(a, b) {
+		if (a === b) return true;
+		if (!(a instanceof Object) || !(b instanceof Object)) return false;
+		if (a == null || b == null) return false;
+		if (a.equals !== undefined) {
+			return a.equals(b);
+		}
+		for (const key of Object.keys(a)) {
+			if (!this.equal(a[key], b[key])) return false;
+		}
+		for (const key of Object.keys(b)) {
+			if (!this.equal(a[key], b[key])) return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Tests for equality on lots of different kinds of values including objects
+	 * and arrays. Will use `.equals` on objects that implement it.
+	 * 
+	 * @param {any} a
+	 * @param {any} b
+	 * @returns {boolean}
+	 */
+	static equal(a, b) {
+		if (a instanceof Array && b instanceof Array) {
+			return this.#equalArrays(a, b);
+		}
+		if (a instanceof Object && b instanceof Object) {
+			return this.#equalObjects(a, b);
+		}
+		return a == b;
+	}
 }
 
 
 		state.p = p;
 		const level = groups[1].length;
 		const content = groups[2];
-		let block = new MDHeaderBlock(level, state.inlineMarkdownToSpan(content));
+		let block = new MDHeaderBlock(level, new MDInlineBlock(state.inlineMarkdownToSpan(content)));
 		if (modifier) modifier.applyTo(block);
 		return block;
 	}
 	}
 }
 
+/**
+ * Abstract base class for ordered and unordered lists.
+ */
 class MDBaseListBlockReader extends MDBlockReader {
 	constructor(priority) {
 		super(priority);
 		if (line.endsWith('|')) line = line.substring(0, line.length - 1);
 		let cellTokens = line.split('|');
 		let cells = cellTokens.map(function(token) {
-			let content = state.inlineMarkdownToSpan(token);
+			let content = state.inlineMarkdownToSpan(token.trim());
 			return isHeader ? new MDTableHeaderCellBlock(content) : new MDTableCellBlock(content);
 		});
 		state.p = p;
 		while (state.hasLines(1, p)) {
 			let line = state.lines[p++];
 			if (line.trim().length == 0) {
-				p--;
 				break;
 			}
 			if (/^\s+/.exec(line)) {
 		}
 		if (termCount == 0 || definitionCount == 0) return null;
 		let blocks = defLines.map(function(line) {
-			if (groups = /^:\s+(.*)$/.exec(line)) {
+			if (groups = /^:\s+(.*?)$/s.exec(line)) {
 				return new MDDefinitionDefinitionBlock(state.inlineMarkdownToSpans(groups[1]));
 			} else {
 				return new MDDefinitionTermBlock(state.inlineMarkdownToSpans(line));
 	readBlock(state) {
 		var paragraphLines = [];
 		var p = state.p;
+		var foundBlankLine = false;
 		while (p < state.lines.length) {
 			let line = state.lines[p++];
 			if (line.trim().length == 0) {
+				foundBlankLine = true;
 				break;
 			}
 			paragraphLines.push(line);
 		}
+		if (state.p == 0 && p >= state.lines.length) {
+			// If it's the entire document don't wrap it in a paragraph
+			return null;
+		}
 		if (paragraphLines.length > 0) {
 			state.p = p;
 			let content = paragraphLines.join("\n");
 class MDHeaderBlock extends MDBlock {
 	/** @type {number} */
 	#level;
-	/** @type {MDBlock} */
+	/** @type {MDBlock[]} */
 	#content;
 
 	/**
 	 * @param {number} level
-	 * @param {MDBlock} content
+	 * @param {MDBlock|MDBlock[]} content
 	 */
 	constructor(level, content) {
 		super();
 		this.#level = level;
-		this.#content = content;
+		this.#content = (content instanceof Array) ? content : [ content ];
 	}
 
 	toHTML(state) {
-		let contentHTML = this.#content.toHTML(state);
-		return `<h${this.#level}${this.htmlAttributes()}>${contentHTML}</h${this.level}>\n`;
+		let contentHTML = MDBlock.toHTML(this.#content, state);
+		return `<h${this.#level}${this.htmlAttributes()}>${contentHTML}</h${this.#level}>\n`;
 	}
 
 	visitChildren(fn) {
-		fn(this.content);
-		this.content.visitChildren(fn);
+		for (const child of this.#content) {
+			fn(child);
+			child.visitChildren(fn);
+		}
 	}
 }
 
 
 	htmlAttributes() {
 		var html = super.htmlAttributes();
-		if (this.startOrdinal !== null) {
+		if (this.startOrdinal !== null && this.startOrdinal != 1) {
 			html += ` start="${this.startOrdinal}"`;
 		}
 		return html;
 }
 
 class MDDefinitionTermBlock extends MDBlock {
-	/** @type {MDBlock} */
+	/** @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(`${this.constructor.name} expects MDBlock or MDBlock[], got ${typeof content}`);
+		}
 	}
 
 	toHTML(state) {
-		let contentHTML = this.#content.toHTML(state);
+		let contentHTML = MDBlock.toHTML(this.#content, state);
 		return `<dt${this.htmlAttributes()}>${contentHTML}</dt>`;
 	}
 
 	visitChildren(fn) {
-		fn(this.#content);
-		this.#content.visitChildren(fn);
+		for (const child of this.#content) {
+			fn(child);
+			child.visitChildren(fn);
+		}
 	}
 }
 
 class MDDefinitionDefinitionBlock extends MDBlock {
-	/** @type {MDBlock} */
+	/** @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(`${this.constructor.name} expects MDBlock or MDBlock[], got ${typeof content}`);
+		}
 	}
 
 	toHTML(state) {
-		let contentHTML = this.#content.toHTML(state);
+		let contentHTML = MDBlock.toHTML(this.#content, state);
 		return `<dd${this.htmlAttributes()}>${contentHTML}</dd>`;
 	}
 
 	visitChildren(fn) {
-		fn(this.#content);
-		this.#content.visitChildren(fn);
+		for (const child of this.#content) {
+			fn(child);
+			child.visitChildren(fn);
+		}
 	}
 }
 
 	#content;
 
 	/**
-	 * @param {MDSpan[]} content
+	 * @param {MDSpan|MDSpan[]} content
 	 */
 	constructor(content) {
 		super();
-		this.#content = content;
+		this.#content = (content instanceof Array) ? content : [ content ];
+		for (const span of this.#content) {
+			if (!(span instanceof MDSpan)) {
+				throw new Error(`${this.constructor.name} expects MDSpan or MDSpan[], got ${MDUtils.typename(span)}`);
+			}
+		}
 	}
 
 	toHTML(state) {
 		this.attributes = attributes;
 	}
 
+	toString() {
+		return this.fullTag;
+	}
+
+	equals(other) {
+		if (!(other instanceof MDHTMLTag)) return false;
+		return other.fullTag == this.fullTag;
+	}
+
 	static #htmlTagNameFirstRegex = /[a-z]/i;
 	static #htmlTagNameMedialRegex = /[a-z0-9]/i;
 	static #htmlAttributeNameFirstRegex = /[a-z]/i;
 	}
 }
 
+class MDTagModifier {
+	/** @type {string} */
+	original;
+	/** @type {string[]} */
+	cssClasses = [];
+	/** @type {string|null} */
+	cssId = null;
+	/** @type {object} */
+	attributes = {};
+
+	static #baseClassRegex = /\.([a-z_\-][a-z0-9_\-]*?)/i;
+	static #baseIdRegex = /#([a-z_\-][a-z0-9_\-]*?)/i;
+	static #baseAttributeRegex = /([a-z0-9]+?)=([^\s\}]+?)/i;
+	static #baseRegex = /\{([^}]+?)}/i;
+	static #leadingClassRegex = new RegExp('^' + this.#baseRegex.source, 'i');
+	static #trailingClassRegex = new RegExp('^(.*?)\\s*' + this.#baseRegex.source + '\\s*$', 'i');
+	static #classRegex = new RegExp('^' + this.#baseClassRegex.source + '$', 'i');  // 1=classname
+	static #idRegex = new RegExp('^' + this.#baseIdRegex.source + '$', 'i');  // 1=id
+	static #attributeRegex = new RegExp('^' + this.#baseAttributeRegex.source + '$', 'i');  // 1=attribute name, 2=attribute value
+
+	/**
+	 * @param {MDBlock|MDSpan} elem
+	 */
+	applyTo(elem) {
+		if (elem instanceof MDBlock || elem instanceof MDSpan) {
+			elem.cssClasses = elem.cssClasses.concat(this.cssClasses);
+			if (this.cssId) elem.cssId = this.cssId;
+			for (const name in this.attributes) {
+				elem.attributes[name] = this.attributes[name];
+			}
+		}
+	}
+
+	equals(other) {
+		if (!(other instanceof MDTagModifier)) return false;
+		if (!MDUtils.equal(other.cssClasses, this.cssClasses)) return false;
+		if (other.cssId !== this.cssId) return false;
+		if (!MDUtils.equal(other.attributes, this.attributes)) return false;
+		return true;
+	}
+
+	toString() {
+		return this.original;
+	}
+
+	static #fromContents(contents) {
+		let modifierTokens = contents.split(/\s+/);
+		let mod = new MDTagModifier();
+		mod.original = `{${contents}}`;
+		var groups;
+		for (const token of modifierTokens) {
+			if (token.trim() == '') continue;
+			if (groups = this.#classRegex.exec(token)) {
+				mod.cssClasses.push(groups[1]);
+			} else if (groups = this.#idRegex.exec(token)) {
+				mod.cssId = groups[1];
+			} else if (groups = this.#attributeRegex.exec(token)) {
+				mod.attributes[groups[1]] = groups[2];
+			} else {
+				return null;
+			}
+		}
+		return mod;
+	}
+
+	/**
+	 * Extracts modifier from line.
+	 * @param {string} line
+	 * @returns {Array} Tuple with remaining line and MDTagModifier.
+	 */
+	static fromLine(line) {
+		let groups = this.#trailingClassRegex.exec(line);
+		if (groups === null) return [ line, null ];
+		let bareLine = groups[1];
+		let mod = this.#fromContents(groups[2]);
+		return [ bareLine, mod ];
+	}
+
+	/**
+	 * Extracts modifier from head of string.
+	 * @param {string} line
+	 * @returns {MDTagModifier}
+	 */
+	static fromStart(line) {
+		let groups = this.#leadingClassRegex.exec(line);
+		if (groups === null) return null;
+		return this.#fromContents(groups[1]);
+	}
+
+	/**
+	 * @param {string} line
+	 * @returns {string}
+	 */
+	static strip(line) {
+		let groups = this.#trailingClassRegex.exec(line);
+		if (groups === null) return line;
+		return groups[1];
+	}
+}
+
 class MDState {
 	/** @type {string[]} */
 	#lines = [];
 	}
 
 	/**
+	 * Creates a simple `MDInlineBlock` if no other registered blocks match.
+	 * 
+	 * @returns {MDInlineBlock|null} fallback block
+	 */
+	#readFallbackBlock() {
+		if (this.p >= this.lines.length) return null;
+		const lines = MDUtils.withoutTrailingBlankLines(this.lines.slice(this.p));
+		if (lines.length == 0) return null;
+		this.p = this.lines.length;
+		return new MDInlineBlock(this.inlineMarkdownToSpans(lines.join("\n")));
+	}
+
+	/**
 	 * Attempts to read one block from the current line pointer. The pointer
 	 * will be positioned just after the end of the block.
 	 *
 			const block = reader.readBlock(this);
 			if (block) return block;
 		}
-		return null;
+		const fallback = this.#readFallbackBlock();
+		return fallback;
 	}
 
 	static #textWhitespaceRegex = /^(\s*)(?:(\S|\S.*\S)(\s*?))?$/; // 1=leading WS, 2=text, 3=trailing WS
 	}
 }
 
-class MDTagModifier {
-	/** @type {string} */
-	original;
-	/** @type {string[]} */
-	cssClasses = [];
-	/** @type {string|null} */
-	cssId = null;
-	/** @type {object} */
-	attributes = {};
-
-	static #baseClassRegex = /\.([a-z_\-][a-z0-9_\-]*?)/i;
-	static #baseIdRegex = /#([a-z_\-][a-z0-9_\-]*?)/i;
-	static #baseAttributeRegex = /([a-z0-9]+?)=([^\s\}]+?)/i;
-	static #baseRegex = /\{([^}]+?)}/i;
-	static #leadingClassRegex = new RegExp('^' + this.#baseRegex.source, 'i');
-	static #trailingClassRegex = new RegExp('^(.*?)\\s*' + this.#baseRegex.source + '\\s*$', 'i');
-	static #classRegex = new RegExp('^' + this.#baseClassRegex.source + '$', 'i');  // 1=classname
-	static #idRegex = new RegExp('^' + this.#baseIdRegex.source + '$', 'i');  // 1=id
-	static #attributeRegex = new RegExp('^' + this.#baseAttributeRegex.source + '$', 'i');  // 1=attribute name, 2=attribute value
-
-	/**
-	 * @param {MDBlock|MDSpan} elem
-	 */
-	applyTo(elem) {
-		if (elem instanceof MDBlock || elem instanceof MDSpan) {
-			elem.cssClasses = elem.cssClasses.concat(this.cssClasses);
-			if (this.cssId) elem.cssId = this.cssId;
-			for (const name in this.attributes) {
-				elem.attributes[name] = this.attributes[name];
-			}
-		}
-	}
-
-	static #fromContents(contents) {
-		let modifierTokens = contents.split(/\s+/);
-		let mod = new MDTagModifier();
-		mod.original = `{${contents}}`;
-		var groups;
-		for (const token of modifierTokens) {
-			if (token.trim() == '') continue;
-			if (groups = this.#classRegex.exec(token)) {
-				mod.cssClasses.push(groups[1]);
-			} else if (groups = this.#idRegex.exec(token)) {
-				mod.cssId = groups[1];
-			} else if (groups = this.#attributeRegex.exec(token)) {
-				mod.attributes[groups[1]] = groups[2];
-			} else {
-				return null;
-			}
-		}
-		return mod;
-	}
-
-	/**
-	 * Extracts modifier from line.
-	 * @param {string} line
-	 * @returns {Array} Tuple with remaining line and MDTagModifier.
-	 */
-	static fromLine(line) {
-		let groups = this.#trailingClassRegex.exec(line);
-		if (groups === null) return [ line, null ];
-		let bareLine = groups[1];
-		let mod = this.#fromContents(groups[2]);
-		return [ bareLine, mod ];
-	}
-
-	/**
-	 * Extracts modifier from head of string.
-	 * @param {string} line
-	 * @returns {MDTagModifier}
-	 */
-	static fromStart(line) {
-		let groups = this.#leadingClassRegex.exec(line);
-		if (groups === null) return null;
-		return this.#fromContents(groups[1]);
-	}
-
-	/**
-	 * @param {string} line
-	 * @returns {string}
-	 */
-	static strip(line) {
-		let groups = this.#trailingClassRegex.exec(line);
-		if (groups === null) return line;
-		return groups[1];
-	}
-}
-
 class Markdown {
 	/**
 	 * Set of standard block readers.

testjs.html

 		<style type="text/css">
 			:root {
 				font-family: sans-serif;
+				--color-passed: #090;
+				--color-failed: #a00;
+				--color-errored: #a80;
+				--color-untested: #888;
 			}
 			.testclass {
 				border: 1px solid black;
 				font-size: 1.25rem;
 				padding-bottom: 0.25em;
 			}
+			.testclassstatus {
+
+			}
+			.testclassstatus.passed { color: var(--color-passed); }
+			.testclassstatus.failed { color: var(--color-failed); }
+			.testclassstatus.errored { color: var(--color-errored); }
+			.testclassstatus.untested { color: var(--color-untested); }
 			.testcase {
+				clear: both;
 				padding: 0.2em 0;
 				margin-left: 2em;
 			}
 				border-top: 1px solid #888;
 			}
 			.testcasename {
-				font-size: 115%;
-				font-weight: bold;
+				font-family: monospace;
 			}
 			.testcasestatus {
 				font-weight: bold;
+				font-size: 80%;
+				float: left;
+			}
+			.testcasetiming {
+				float: right;
+				color: #888;
+				font-size: 80%;
+			}
+			.testcaseresult {
+				height: 1em;
+			}
+			.testcasemessage {
+				clear: both;
 			}
 			.result-untested {
 				color: #888;
 					if (test) this.fail(failMessage || `expected false, got ${test}`);
 				}
 				assertEqual(a, b, failMessage=null) {
-					if (a == b) return;
+					if (MDUtils.equal(a, b)) return;
 					const aVal = `${a}`;
 					const bVal = `${b}`;
 					if (aVal.length > 20 || bVal.length > 20) {
 				/** @var {String|null} */
 				message = null;
 				expectedError = null;
+				duration = null;
 				/** @var {String} */
 				get className() { return this.#objectUnderTest.constructor.name; }
 				/** @var {String} */
 					this.uniqueId = TestCaseRunner.#nextUniqueId++;
 				}
 				run() {
+					var start;
+					this.expectedError = null;
+					this.#objectUnderTest.currentRunner = this;
 					try {
-						this.expectedError = null;
-						this.#objectUnderTest.currentRunner = this;
 						this.#objectUnderTest.setUp();
+					} catch (e) {
+						console.error(`Failed to run ${this.className}.setUp() - ${e.message}`);
+						this.result = ResultType.errored;
+						this.message = e.message;
+						return;
+					}
+					try {
+						start = performance.now();
 						this.#method.bind(this.#objectUnderTest)();
+						this.duration = performance.now() - start;
 						this.result = ResultType.passed;
 						this.message = null;
 					} catch (e) {
+						this.duration = performance.now() - start;
 						if (e instanceof FailureError) {
 							this.result = ResultType.failed;
 							this.message = e.message;
 				toHTML() {
 					var html = `<div class="testcase" id="${this.#cssId}">`;
 					html += `<div class="testcasename"><span class="testcasemethod">${this.methodName}</span></div>`;
+					html += '<div class="testcaseresult">';
 					switch (this.result) {
 						case ResultType.untested:
 							html += '<div class="testcasestatus result-untested">Waiting to test</div>';
 							break;
 						case ResultType.testing:
-							html += '<div class="testcasestatus result-tesitng">Testing...</div>';
+							html += '<div class="testcasestatus result-testing">Testing...</div>';
 							break;
 						case ResultType.passed:
 							html += '<div class="testcasestatus result-passed">Passed</div>';
 							break;
 						case ResultType.failed:
 							html += '<div class="testcasestatus result-failed">Failed</div>';
-							html += `<div class="testcasemessage">${escapeHTML(this.message)}</div>`;
 							break;
 						case ResultType.errored:
 							html += '<div class="testcasestatus result-errored">Errored</div>';
-							html += `<div class="testcasemessage">${escapeHTML(this.message)}</div>`;
 							break;
 					}
+					if (this.duration !== null) {
+						html += `<div class="testcasetiming">${Number(this.duration / 1000.0).toFixed(3)}s</div>`;
+					}
+					html += '</div>';
+					if (this.message !== null) {
+						html += `<div class="testcasemessage">${escapeHTML(this.message)}</div>`;
+					}
 					html += `</div>`;
 					return html;
 				}
 					this.#uniqueId = TestClassRunner.#nextUniqueId++;
 				}
 				get #cssId() { return `testclass${this.#uniqueId}`; }
+				#summaryHTML() {
+					var anyTesting = false;
+					var anyFailed = false;
+					var anyErrored = false;
+					var anyUntested = false;
+					var anyPassed = false;
+					var allPassed = true;
+					for (const test of this.testCases) {
+						switch (test.result) {
+							case ResultType.untested:
+								anyUntested = true;
+								allPassed = false;
+								break;
+							case ResultType.testing:
+								anyTesting = true;
+								allPassed = false;
+								break;
+							case ResultType.passed:
+								anyPassed = true;
+								break;
+							case ResultType.failed:
+								anyFailed = true;
+								allPassed = false;
+								break;
+							case ResultType.errored:
+								anyErrored = true;
+								allPassed = false;
+								break;
+						}
+					}
+					var html = '';
+					html += `<summary class="testclasssummary" id="${this.#cssId}summary">`;
+					html += `<span class="testclassname">${this.#theClass.name}</span> `;
+					if (anyTesting || (anyUntested && (anyPassed || anyFailed || anyErrored))) {
+						html += '<span class="testclassstatus testing">Testing...</span>';
+					} else if (anyErrored) {
+						html += '<span class="testclassstatus errored">Errored</span>';
+					} else if (anyFailed) {
+						html += '<span class="testclassstatus failed">Failed</span>';
+					} else if (allPassed) {
+						html += '<span class="testclassstatus passed">Passed</span>';
+					}
+					html += '</summary>';
+					return html;
+				}
 				toHTML() {
 					var html = '';
 					html += `<div class="testclass" id="${this.#cssId}">`;
-					html += `<div class="testclassname">${this.#theClass.name}</div>`;
+					html += `<details id="${this.#cssId}details">`;
+					html += this.#summaryHTML();
 					for (const testCase of this.#testCases) {
 						html += testCase.toHTML();
 					}
+					html += '</details>';
 					html += '</div>';
 					return html;
 				}
 				updateHTML() {
-					var existing = document.getElementById(this.#cssId);
+					var existing = document.getElementById(`${this.#cssId}summary`);
 					if (!existing) {
 						document.getElementById('results').innerHTML += this.toHTML();
+					} else {
+						existing.outerHTML = this.#summaryHTML();
+						var allPassed = true;
+						for (const test of this.testCases) {
+							if (test.result != ResultType.passed) {
+								allPassed = false;
+								break;
+							}
+						}
+						document.getElementById(`${this.#cssId}details`).open = !allPassed;
 					}
 				}
 
 			function onLoad() {
 				let testClasses = [
 					TokenTests,
+					UtilsTests,
 					InlineTests,
 					BlockTests,
 				];
 						tokens: [ tokens[2] ],
 						index: 2,
 					};
-					this.assertEqual(JSON.stringify(result), JSON.stringify(expected));
+					this.assertEqual(result, expected);
+				}
+
+				test_findFirstTokens_optionalWhitespace1() {
+					const tokens = [
+						new MDToken('Lorem', MDTokenType.Text),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('[ipsum]', MDTokenType.Label, 'ipsum'),
+						new MDToken('(link.html)', MDTokenType.URL, 'link.html'),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('dolor', MDTokenType.Text),
+					];
+					const pattern = [
+						MDTokenType.Label,
+						MDTokenType.META_OptionalWhitespace,
+						MDTokenType.URL,
+					];
+					const result = MDToken.findFirstTokens(tokens, pattern);
+					const expected = {
+						tokens: [ tokens[2], tokens[3] ],
+						index: 2,
+					};
+					this.assertEqual(result, expected);
+				}
+
+				test_findFirstTokens_optionalWhitespace2() {
+					const tokens = [
+						new MDToken('Lorem', MDTokenType.Text),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('[ipsum]', MDTokenType.Label, 'ipsum'),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('(link.html)', MDTokenType.URL, 'link.html'),
+						new MDToken(' ', MDTokenType.Whitespace),
+						new MDToken('dolor', MDTokenType.Text),
+					];
+					const pattern = [
+						MDTokenType.Label,
+						MDTokenType.META_OptionalWhitespace,
+						MDTokenType.URL,
+					];
+					const result = MDToken.findFirstTokens(tokens, pattern);
+					const expected = {
+						tokens: [ tokens[2], tokens[3], tokens[4] ],
+						index: 2,
+					};
+					this.assertEqual(result, expected);
 				}
 
 				test_findPairedTokens() {
 						endIndex: 4,
 						totalLength: 3,
 					}
-					this.assertEqual(JSON.stringify(result), JSON.stringify(expected));
+					this.assertEqual(result, expected);
+				}
+			}
+
+			class UtilsTests extends BaseTest {
+				test_stripIndent() {
+					this.assertEqual(MDUtils.stripIndent(''), '');
+					this.assertEqual(MDUtils.stripIndent('  '), '');
+					this.assertEqual(MDUtils.stripIndent('foo'), 'foo');
+					this.assertEqual(MDUtils.stripIndent(' foo'), 'foo');
+					this.assertEqual(MDUtils.stripIndent('  foo'), 'foo');
+					this.assertEqual(MDUtils.stripIndent('   foo'), 'foo');
+					this.assertEqual(MDUtils.stripIndent('    foo'), 'foo');
+					this.assertEqual(MDUtils.stripIndent('     foo'), ' foo');
+					this.assertEqual(MDUtils.stripIndent('\tfoo'), 'foo');
+					this.assertEqual(MDUtils.stripIndent('\t\tfoo'), '\tfoo');
+					this.assertEqual(MDUtils.stripIndent('\t\tfoo', 2), 'foo');
+					this.assertEqual(MDUtils.stripIndent('      foo', 2), 'foo');
+				}
+
+				test_countIndents() {
+					this.assertEqual(MDUtils.countIndents(''), 0);
+					this.assertEqual(MDUtils.countIndents('  '), 1);
+					this.assertEqual(MDUtils.countIndents('    '), 1);
+					this.assertEqual(MDUtils.countIndents('foo'), 0);
+					this.assertEqual(MDUtils.countIndents('foo'), 0);
+					this.assertEqual(MDUtils.countIndents(' foo'), 1);
+					this.assertEqual(MDUtils.countIndents('  foo'), 1);
+					this.assertEqual(MDUtils.countIndents('   foo'), 1);
+					this.assertEqual(MDUtils.countIndents('    foo'), 1);
+					this.assertEqual(MDUtils.countIndents('     foo'), 2);
+					this.assertEqual(MDUtils.countIndents('\tfoo'), 1);
+					this.assertEqual(MDUtils.countIndents('\t\tfoo'), 2);
+
+					this.assertEqual(MDUtils.countIndents('', true), 0);
+					this.assertEqual(MDUtils.countIndents('  ', true), 0);
+					this.assertEqual(MDUtils.countIndents('    ', true), 1);
+					this.assertEqual(MDUtils.countIndents('foo', true), 0);
+					this.assertEqual(MDUtils.countIndents(' foo', true), 0);
+					this.assertEqual(MDUtils.countIndents('  foo', true), 0);
+					this.assertEqual(MDUtils.countIndents('   foo', true), 0);
+					this.assertEqual(MDUtils.countIndents('    foo', true), 1);
+					this.assertEqual(MDUtils.countIndents('     foo', true), 1);
+					this.assertEqual(MDUtils.countIndents('\tfoo', true), 1);
+					this.assertEqual(MDUtils.countIndents('\t\tfoo', true), 2);
+				}
+
+				test_tokenizeLabel() {
+					// Escapes are preserved
+					this.assertEqual(MDUtils.tokenizeLabel('[foo] bar'), [ '[foo]', 'foo' ]);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo\\[] bar'), [ '[foo\\[]', 'foo\\[' ]);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo\\]] bar'), [ '[foo\\]]', 'foo\\]' ]);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo[]] bar'), [ '[foo[]]', 'foo[]' ]);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo\\(] bar'), [ '[foo\\(]', 'foo\\(' ]);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo\\)] bar'), [ '[foo\\)]', 'foo\\)' ]);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo()] bar'), [ '[foo()]', 'foo()' ]);
+
+					this.assertEqual(MDUtils.tokenizeLabel('foo bar'), null);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo\\] bar'), null);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo bar'), null);
+					this.assertEqual(MDUtils.tokenizeLabel('[foo[] bar'), null);
+				}
+
+				test_tokenizeURL() {
+					this.assertEqual(MDUtils.tokenizeURL('(page.html) foo'), [ '(page.html)', 'page.html', null ]);
+					this.assertEqual(MDUtils.tokenizeURL('(page.html "link title") foo'), [ '(page.html "link title")', 'page.html', 'link title' ]);
+					this.assertEqual(MDUtils.tokenizeURL('(https://example.com/path/page.html?query=foo&bar=baz#fragment) foo'), [ '(https://example.com/path/page.html?query=foo&bar=baz#fragment)', 'https://example.com/path/page.html?query=foo&bar=baz#fragment', null ]);
+
+					this.assertEqual(MDUtils.tokenizeURL('page.html foo'), null);
+					this.assertEqual(MDUtils.tokenizeURL('(page.html foo'), null);
+					this.assertEqual(MDUtils.tokenizeURL('page.html) foo'), null);
+					this.assertEqual(MDUtils.tokenizeURL('(page.html "title) foo'), null);
+					this.assertEqual(MDUtils.tokenizeURL('(page .html) foo'), null);
+					this.assertEqual(MDUtils.tokenizeURL('(user@example.com) foo'), null);
+					this.assertEqual(MDUtils.tokenizeURL('(user@example.com "title") foo'), null);
+				}
+
+				test_tokenizeEmail() {
+					this.assertEqual(MDUtils.tokenizeEmail('(user@example.com)'), [ '(user@example.com)', 'user@example.com', null ]);
+					this.assertEqual(MDUtils.tokenizeEmail('(user@example.com "link title")'), [ '(user@example.com "link title")', 'user@example.com', 'link title' ]);
+
+					this.assertEqual(MDUtils.tokenizeEmail('(https://example.com) foo'), null);
+					this.assertEqual(MDUtils.tokenizeEmail('(https://example.com "link title") foo'), null);
+					this.assertEqual(MDUtils.tokenizeEmail('(user@example.com "link title) foo'), null);
+					this.assertEqual(MDUtils.tokenizeEmail('(user@example.com foo'), null);
+					this.assertEqual(MDUtils.tokenizeEmail('user@example.com) foo'), null);
 				}
 			}
 
 					this.parser = Markdown.completeParser;
 				}
 
-				test_simpleSingleParagraph() {
+				test_simpleText() {
 					let markdown = 'Lorem ipsum';
-					let expected = '<p>Lorem ipsum</p>';
+					let expected = 'Lorem ipsum';
 					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 expected = 'Lorem <strong>ipsum</strong> dolor <strong>sit</strong>';
 					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 expected = 'Lorem <em>ipsum</em> dolor <em>sit</em>';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_strongEmphasis_cleanNesting1() {
 					let markdown = 'Lorem **ipsum *dolor* sit** amet';
-					let expected = '<p>Lorem <strong>ipsum <em>dolor</em> sit</strong> amet</p>';
+					let expected = 'Lorem <strong>ipsum <em>dolor</em> sit</strong> amet';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_strongEmphasis_cleanNesting2() {
 					let markdown = 'Lorem *ipsum **dolor** sit* amet';
-					let expected = '<p>Lorem <em>ipsum <strong>dolor</strong> sit</em> amet</p>';
+					let expected = 'Lorem <em>ipsum <strong>dolor</strong> sit</em> amet';
 					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 expected1 = 'Lorem <strong><em>ipsum</em></strong> dolor';
+					let expected2 = 'Lorem <em><strong>ipsum</strong></em> dolor';
 					let actual = this.md(markdown);
 					this.assertTrue(actual == expected1 || actual == expected2);
 				}
 
 				test_strongEmphasis_lopsidedNesting1() {
 					let markdown = 'Lorem ***ipsum* dolor** sit';
-					let expected = '<p>Lorem <strong><em>ipsum</em> dolor</strong> sit</p>';
+					let expected = 'Lorem <strong><em>ipsum</em> dolor</strong> sit';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_strongEmphasis_lopsidedNesting2() {
 					let markdown = 'Lorem ***ipsum** dolor* sit';
-					let expected = '<p>Lorem <em><strong>ipsum</strong> dolor</em> sit</p>';
+					let expected = 'Lorem <em><strong>ipsum</strong> dolor</em> sit';
 					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 expected = 'Lorem <strong>ipsum <em>dolor</em></strong> sit';
 					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 expected = 'Lorem <em>ipsum <strong>dolor</strong></em> sit';
 					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 expected = 'Lorem <code>ipsum</code> dolor';
 					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 expected = 'Lorem <code>ip`su`m</code> dolor';
 					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 expected = 'Lorem <strike>ipsum</strike> dolor';
 					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 expected = 'Lorem <strike>ipsum</strike> dolor';
 					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 expected = 'Lorem <a href="https://example.com/path/page.html">ipsum</a> dolor';
 					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 expected = 'Lorem <a href="page.html">ipsum</a> dolor';
 					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 expected = 'Lorem <a href="page.html" title="link title">ipsum</a> dolor';
 					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 expected = 'Lorem <a href="https://example.com">https://example.com</a> dolor';
 					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 expected = 'Lorem <a href="mailto:&#117;&#115;&#101;&#114;&#64;&#101;&#120;&#97;&#109;&#112;&#108;&#101;&#46;&#99;&#111;&#109;">ipsum</a> dolor';
 					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 expected = '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';
 					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 expected = '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';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_image() {
+					let markdown = 'Lorem [![alt](image.jpg)](page.html) ipsum';
+					let expected = 'Lorem <a href="page.html"><img src="image.jpg" alt="alt"></a> ipsum';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_link_image_complex() {
+					let markdown = 'Lorem [![alt] (image.jpg "image title")] (page.html "link title") ipsum';
+					let expected = 'Lorem <a href="page.html" title="link title"><img src="image.jpg" alt="alt" title="image title"></a> ipsum';
 					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 expected = 'Lorem <img src="image.jpg" alt="alt text"> dolor';
 					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 expected = 'Lorem <img src="image.jpg"> dolor';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
 				test_image_withTitle() {
 					let markdown = 'Lorem ![alt text](image.jpg "image title") dolor';
+					let expected = 'Lorem <img src="image.jpg" alt="alt text" title="image title"> dolor';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_image_ref() {
+					let markdown = 'Lorem ![alt text][ref] dolor\n\n' +
+						'[ref]: image.jpg "image title"';
 					let expected = '<p>Lorem <img src="image.jpg" alt="alt text" title="image title"> dolor</p>';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
+
+				test_htmlTags() {
+					let markdown = 'Lorem <strong title="value" foo=\'with " quote\' bar="with \' apostrophe" attr=unquoted checked>ipsum</strong> dolor';
+					let expected = markdown;
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
 			}
 
 			class BlockTests extends BaseTest {
 
 				test_paragraph_lineGrouping() {
 					let markdown = "Lorem ipsum\ndolor sit amet";
-					let expected = "<p>Lorem ipsum dolor sit amet</p>";
+					let expected = "Lorem ipsum dolor sit amet";
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_header_underlineH1() {
+					let markdown = "Header 1\n===\n\nLorem ipsum";
+					let expected = "<h1>Header 1</h1> <p>Lorem ipsum</p>";
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_header_underlineH2() {
+					let markdown = "Header 2\n---\n\nLorem ipsum";
+					let expected = "<h2>Header 2</h2> <p>Lorem ipsum</p>";
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_header_hash() {
+					let markdown = "# Header 1\n## Header 2\n### Header 3\n#### Header 4\n##### Header 5\n###### Header 6\n";
+					let expected = '<h1>Header 1</h1> <h2>Header 2</h2> <h3>Header 3</h3> <h4>Header 4</h4> <h5>Header 5</h5> <h6>Header 6</h6>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_header_hash_trailing() {
+					let markdown = "# Header 1 #\n## Header 2 ##\n### Header 3 ######";
+					let expected = '<h1>Header 1</h1> <h2>Header 2</h2> <h3>Header 3</h3>';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 					this.assertEqual(actual, expected);
 				}
 
+				test_unorderedList_nested() {
+					let markdown = "* Lorem\n + Ipsum\n* Dolor";
+					let expected = '<ul> <li>Lorem <ul> <li>Ipsum</li> </ul></li> <li>Dolor</li> </ul>';
+					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 expected = '<ol> <li>Lorem</li> <li>Ipsum</li> <li>Dolor</li> </ol>';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 					this.assertEqual(actual, expected);
 				}
 
+				test_orderedList_nested1() {
+					let markdown = "1. Lorem\n 1. Ipsum\n1. Dolor";
+					let expected = '<ol> <li>Lorem <ol> <li>Ipsum</li> </ol></li> <li>Dolor</li> </ol>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_orderedList_nested2() {
+					let markdown = "1. Lorem\n 1. Ipsum\n      1. Dolor\n 1. Sit\n1. Amet";
+					let expected = '<ol> <li>Lorem <ol> <li>Ipsum <ol> <li>Dolor</li> </ol></li> <li>Sit</li> </ol></li> <li>Amet</li> </ol>';
+					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 expected = '<blockquote> Lorem ipsum dolor </blockquote>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_blockquote_paragraphs() {
+					let markdown = '> Lorem ipsum dolor\n>\n>Sit amet';
+					let expected = '<blockquote> <p>Lorem ipsum dolor</p> <p>Sit amet</p> </blockquote>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_blockquote_list() {
+					let markdown = '> 1. Lorem\n> 2. Ipsum';
+					let expected = '<blockquote> <ol> <li>Lorem</li> <li>Ipsum</li> </ol> </blockquote>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_codeBlock_indented() {
+					let markdown = "Code\n\n    function foo() {\n        return 'bar';\n    }\n\nend";
+					let expected = "<p>Code</p>\n\n<pre><code>function foo() {\n    return 'bar';\n}</code></pre>\n<p>end</p>\n";
+					let actual = this.parser.toHTML(markdown); // don't normalize whitespace
+					this.assertEqual(actual.replace(/ /g, '⎵'), expected.replace(/ /g, '⎵'));
+				}
+
+				test_codeBlock_fenced() {
+					let markdown = "Code\n\n```\nfunction foo() {\n    return 'bar';\n}\n```\n\nend";
+					let expected = "<p>Code</p>\n\n<pre><code>function foo() {\n    return 'bar';\n}</code></pre>\n<p>end</p>\n";
+					let actual = this.parser.toHTML(markdown); // don't normalize whitespace
+					this.assertEqual(actual.replace(/ /g, '⎵'), expected.replace(/ /g, '⎵'));
+				}
+
+				test_horizontalRule() {
+					let markdown = "Before\n\n---\n\n- - -\n\n***\n\n* * * * * * *\n\nafter";
+					let expected = "<p>Before</p> <hr> <hr> <hr> <hr> <p>after</p>";
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_table_unfenced() {
+					let markdown = "Column A | Column B | Column C\n--- | --- | ---\n1 | 2 | 3\n4 | 5 | 6";
+					let expected = "<table> <thead> <tr> <th>Column A</th> <th>Column B</th> <th>Column C</th> </tr> </thead> <tbody> <tr> <td>1</td> <td>2</td> <td>3</td> </tr> <tr> <td>4</td> <td>5</td> <td>6</td> </tr> </tbody> </table>";
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_table_fenced() {
+					let markdown = "| Column A | Column B | Column C |\n| --- | --- | --- |\n| 1 | 2 | 3\n4 | 5 | 6 |";
+					let expected = "<table> <thead> <tr> <th>Column A</th> <th>Column B</th> <th>Column C</th> </tr> </thead> <tbody> <tr> <td>1</td> <td>2</td> <td>3</td> </tr> <tr> <td>4</td> <td>5</td> <td>6</td> </tr> </tbody> </table>";
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_table_alignment() {
+					let markdown = 'Column A | Column B | Column C\n' +
+						':--- | :---: | ---:\n' +
+						'1 | 2 | 3\n' +
+						'4 | 5 | 6';
+					let expected = '<table> ' +
+						'<thead> ' +
+						'<tr> ' +
+						'<th align="left">Column A</th> ' +
+						'<th align="center">Column B</th> ' +
+						'<th align="right">Column C</th> ' +
+						'</tr> ' +
+						'</thead> ' +
+						'<tbody> ' +
+						'<tr> ' +
+						'<td align="left">1</td> ' +
+						'<td align="center">2</td> ' +
+						'<td align="right">3</td> ' +
+						'</tr> ' +
+						'<tr> ' +
+						'<td align="left">4</td> ' +
+						'<td align="center">5</td> ' +
+						'<td align="right">6</td> ' +
+						'</tr> ' +
+						'</tbody> ' +
+						'</table>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_table_holes() {
+					let markdown = 'Column A||Column C\n' +
+						'---|---|---\n' +
+						'|1|2||\n' +
+						'|4||6|\n' +
+						'||8|9|';
+					let expected = '<table> ' +
+						'<thead> ' +
+						'<tr> ' +
+						'<th>Column A</th> ' +
+						'<th></th> ' +
+						'<th>Column C</th> ' +
+						'</tr> ' +
+						'</thead> ' +
+						'<tbody> ' +
+						'<tr> ' +
+						'<td>1</td> ' +
+						'<td>2</td> ' +
+						'<td></td> ' +
+						'</tr> ' +
+						'<tr> ' +
+						'<td>4</td> ' +
+						'<td></td> ' +
+						'<td>6</td> ' +
+						'</tr> ' +
+						'<tr> ' +
+						'<td></td> ' +
+						'<td>8</td> ' +
+						'<td>9</td> ' +
+						'</tr> ' +
+						'</tbody> ' +
+						'</table>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_definitionList() {
+					let markdown = 'term\n' +
+						': definition\n' +
+						'another' +
+						' term\n' +
+						': def 1\n' +
+						' broken on next line\n' +
+						': def 2';
+					let expected = '<dl> ' +
+						'<dt>term</dt> ' +
+						'<dd>definition</dd> ' +
+						'<dt>another term</dt> ' +
+						'<dd>def 1 broken on next line</dd> ' +
+						'<dd>def 2</dd> ' +
+						'</dl>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_footnotes() {
+					let markdown = 'Lorem ipsum[^1] dolor[^2] sit[^1] amet\n\n[^1]: A footnote\n[^2]: Another footnote';
+					let expected = '<p>Lorem ipsum<sup id="footnoteref_1"><a href="#footnote_1">1</a></sup> ' +
+						'dolor<sup id="footnoteref_2"><a href="#footnote_2">2</a></sup> ' +
+						'sit<sup id="footnoteref_3"><a href="#footnote_1">1</a></sup> amet</p> ' +
+						'<div class="footnotes">' +
+						'<hr/>' +
+						'<ol>' +
+						'<li value="1" id="footnote_1">A footnote <a href="#footnoteref_1" class="footnote-backref">↩︎</a> <a href="#footnoteref_3" class="footnote-backref">↩︎</a></li> ' +
+						'<li value="2" id="footnote_2">Another footnote <a href="#footnoteref_2" class="footnote-backref">↩︎</a></li> ' +
+						'</ol>' +
+						'</div>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_abbreviations() {
+					let markdown = 'Lorem ipsum HTML dolor HTML sit\n' +
+						'\n' +
+						'*[HTML]: Hypertext Markup Language';
+					let expected = '<p>Lorem ipsum <abbr title="Hypertext Markup Language">HTML</abbr> dolor <abbr title="Hypertext Markup Language">HTML</abbr> sit</p>';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}