Sample playground markdown working in PHP

js/markdown.js

 		var maxPass = 1;
 		for (const reader of readers) {
 			const passCount = reader.substitutionPassCount;
+			maxPass = Math.max(maxPass, passCount);
 			for (var pass = 1; pass <= passCount; pass++) {
 				tuples.push([ pass, reader ]);
 			}
-			maxPass = Math.max(maxPass, pass);
 		}
 		var result = [];
 		for (var pass = 1; pass <= maxPass; pass++) {
 		state.abbreviations[abbreviation] = definition;
 		const regex = new RegExp("\\b(" + MDUtils.escapeRegex(abbreviation) + ")\\b", "ig");
 		state.abbreviationRegexes[abbreviation] = regex;
-}
+	}
 
 	preProcess(state) {
 		state.root['abbreviations'] = {};
 	readBlock(state) {
 		var paragraphLines = [];
 		var p = state.p;
-		while (state.hasLines(1, $p)) {
+		while (state.hasLines(1, p)) {
 			let line = state.lines[p++];
 			if (line.trim().length == 0) {
 				break;
 	substituteTokens(state, pass, tokens) {
 		if (this.attemptPair(state, pass, tokens, MDCodeNode, MDTokenType.Backtick, 2, true)) return true;
 		if (this.attemptPair(state, pass, tokens, MDCodeNode, MDTokenType.Backtick, 1, true)) return true;
+		return false;
 	}
 }
 
 /**
  * Node for a header cell in a header table row.
  */
-class MDTableHeaderCellNode extends MDBlockNode {
+class MDTableHeaderCellNode extends MDTableCellNode {
 	toHTML(state) {
 		return this._simplePairedTagHTML(state, 'th');
 	}

php/markdown.php

 		return false;
 	}
 
+	public static function typename($value): string {
+		$tn = gettype($value);
+		return ($tn === 'object') ? get_class($value) : $tn;
+	}
+
 	public static function equalAssocArrays(array &$a, array &$b) {
 		return empty(array_diff_assoc($a, $b));
 	}
 	}
 
 	public function __toString(): string {
-		$classname = get_class($this);
-		return "({$classname} type={$this->type} content={$this->content})";
+		$classname = MDUtils::typename($this);
+		return "<{$classname} type={$this->type->name} content=\"{$this->content}\">";
 	}
 
 	/**
 	 * @return ?MDTokenMatch match object, or `null` if not found
 	 */
 	public static function findFirstTokens(array $tokensToSearch, array $pattern, int $startIndex=0): ?MDTokenMatch {
+		if (sizeof($pattern) == 0) {
+			throw new Error("pattern empty");
+		}
 		$matched = [];
 		for ($t = $startIndex; $t < sizeof($tokensToSearch); $t++) {
 			$matchedAll = true;
 			$matched = [];
 			$patternOffset = 0;
-			for ($p = 0; $p < mb_strlen($pattern); $p++) {
+			for ($p = 0; $p < sizeof($pattern); $p++) {
 				$t0 = $t + $p + $patternOffset;
 				if ($t0 >= sizeof($tokensToSearch)) return null;
 				$token = $tokensToSearch[$t0];
 			array $startPattern, array $endPattern, ?callable $contentValidator=null,
 			int $startIndex=0): ?MDPairedTokenMatch {
 		for ($s = $startIndex; $s < sizeof($tokensToSearch); $s++) {
-			$startMatch = findFirstTokens($tokensToSearch, $startPattern, $s);
+			$startMatch = self::findFirstTokens($tokensToSearch, $startPattern, $s);
 			if ($startMatch === null) return null;
 			$endStart = $startMatch->index + sizeof($startMatch->tokens);
 			while ($endStart < sizeof($tokensToSearch)) {
-				$endMatch = findFirstTokens($tokensToSearch, $endPattern, $endStart);
+				$endMatch = self::findFirstTokens($tokensToSearch, $endPattern, $endStart);
 				if ($endMatch === null) break;
 				$contentStart = $startMatch->index + sizeof($startMatch->tokens);
 				$contentLength = $endMatch->index - $contentStart;
 	 */
 	public function __construct(array $lines) {
 		$this->lines = $lines;
+		$this->startTime = microtime(true);
 	}
 
 	/**
 			$block = $reader->readBlock($this);
 			if ($block) {
 				if ($this->p == $startP) {
-					$readerClassName = get_class($reader);
-					$blockClassName = get_class($block);
+					$readerClassName = MDUtils::typename($reader);
+					$blockClassName = MDUtils::typename($block);
 					throw new Error("{$readerClassName} returned an " .
 						"{$blockClassName} without incrementing MDState.p. " .
 						"This could lead to an infinite loop.");
 		$expectLiteral = false;
 
 		/**
-		 * Flushes accumulated content in `text` to `tokens`.
+		 * Flushes accumulated content in `$text` to `$tokens`.
 		 */
 		$endText = function() use (&$tokens, &$text) {
 			if (mb_strlen($text) == 0) return;
 			$textGroups = [];
-			if (mb_eregi('^(\s+)(.*?)$', $text, $textGroups)) {
+			if (mb_eregi('^(\\s+)(.*?)$', $text, $textGroups)) {
 				array_push($tokens, new MDToken($textGroups[1], MDTokenType::Whitespace, $textGroups[1]));
-				$text = $textGroups[2];
+				$text = is_string($textGroups[2]) ? $textGroups[2] : '';
 			}
-			if (mb_eregi('^(.*?)(\s+)$', $text, $textGroups)) {
+			if (mb_eregi('^(.*?)(\\s+)$', $text, $textGroups)) {
 				array_push($tokens, new MDToken($textGroups[1], MDTokenType::Text, $textGroups[1]));
 				array_push($tokens, new MDToken($textGroups[2], MDTokenType::Whitespace, $textGroups[2]));
 			} else {
 				$endText();
 				array_push($tokens, $token);
 				if ($token->original == null || mb_strlen($token->original) == 0) {
-					$readerClassName = get_class($reader);
+					$readerClassName = MDUtils::typename($reader);
 					throw new Error(`{$readerClassName} returned a token with an empty .original. This would cause an infinite loop.`);
 				}
 				$p += mb_strlen($token->original) - 1;
 		// CSS modifiers.
 		$lastNode = null;
 		$me = $this;
-		$nodes = array_map(function($node) use ($lastNode, $me) {
+		$nodes = array_map(function($node) use (&$lastNode, $me, $nodes) {
 			if ($node instanceof MDToken) {
 				/** @var MDToken */
 				$token = $node;
 				$lastNode = ($node instanceof MDTextNode) ? null : $node;
 				return $node;
 			} else {
-				$nodeClassName = get_class($node);
+				$nodeClassName = MDUtils::typename($node);
 				throw new Error("Unexpected node type {$nodeClassName}");
 			}
 		}, $nodes);
 		return $nodes;
 	}
 
+	public $startTime;
+
+	/**
+	 * Checks if parsing has taken an excessive length of time. Because I'm not
+	 * fully confident in my loops yet. :)
+	 */
+	public function checkExecutionTime(float $maxSeconds=1.0) {
+		$elapsed = microtime(true) - $this->root()->startTime;
+		if ($elapsed > $maxSeconds) {
+			throw new Error("Markdown parsing taking too long. Infinite loop?");
+		}
+	}
+
 	/**
 	 * Mapping of reference symbols to URLs. Used by `MDReferencedLinkReader`
 	 * and `MDReferencedImageReader`.
 		$sorted = $readers;
 		return self::kahnTopologicalSort($sorted, function(MDReader $a, MDReader $b): int {
 			return $a->compareBlockOrdering($b);
-		}, fn($elem) => get_class($elem));
+		}, fn($elem) => MDUtils::typename($elem));
 	}
 
 	/**
 		$sorted = $readers;
 		return self::kahnTopologicalSort($sorted, function(MDReader $a, MDReader $b): int {
 			return $a->compareTokenizeOrdering($b);
-		}, fn($elem) => get_class($elem));
+		}, fn($elem) => MDUtils::typename($elem));
 	}
 
 	/**
 		$maxPass = 1;
 		foreach ($readers as $reader) {
 			$passCount = $reader->substitutionPassCount();
+			$maxPass = max($paxPass, $passCount);
 			for ($pass = 1; $pass <= $passCount; $pass++) {
-				array_push($tuples, [[ $pass, $reader ]]);
+				array_push($tuples, [ $pass, $reader ]);
 			}
-			$maxPass = max($maxPass, $pass);
 		}
 		$result = [];
 		for ($pass = 1; $pass <= $maxPass; $pass++) {
-			$readersThisPass = array_filter($tuples, fn($tup) => $tup[0] == $pass);
+			$readersThisPass = array_values(array_filter($tuples, fn($tup) => $tup[0] === $pass));
 			$passResult = self::kahnTopologicalSort($readersThisPass, function(array $a, array $b) use ($pass): int {
 				$aReader = $a[1];
 				$bReader = $b[1];
 				return $aReader->compareSubstituteOrdering($bReader, $pass);
-			}, fn($elem) => get_class($elem[1]));
+			}, fn($elem) => MDUtils::typename($elem[1]));
 			$result = array_merge($result, $passResult);
 		}
 		return $result;
 		$state->p += max(sizeof($itemLines), 1);
 
 		if (sizeof($itemLines) == 1) {
-			return $state->inlineMarkdownToNode($itemLines[0]);
+			return new MDBlockNode($state->inlineMarkdownToNodes($itemLines[0]));
 		}
 
 		$hasBlankLines = sizeof(array_filter($itemLines, fn($line) => trim($line) == '')) > 0;
 		if ($hasBlankLines) {
 			$substate = $state->copy($itemLines);
 			$blocks = $substate->readBlocks();
-			return (sizeof($blocks) == 1) ? $blocks[0] : new MDNode($blocks);
+			return (sizeof($blocks) == 1) ? $blocks[0] : new MBlockDNode($blocks);
 		}
 
 		// Multiline content with no blank lines. Search for new block
 			$line = $itemLines[$p];
 			if (mb_eregi('^(?:\\*|\\-|\\+|\\d+\\.)\\s+', $line)) {
 				// Nested list found
-				$firstBlock = $state->inlineMarkdownToNode(implode("\n", array_slice($itemLines, 0, $p)));
+				$firstBlock = new MDBlockNode($state->inlineMarkdownToNodes(implode("\n", array_slice($itemLines, 0, $p))));
 				$substate = $state->copy(array_slice($itemLines, $p));
 				$blocks = $substate->readBlocks();
-				return array_merge([ $firstBlock, $blocks ]);
+				return new MDBlockNode(array_merge([ $firstBlock ], $blocks));
 			}
 		}
 
 		{
 			$substate = $state->copy($itemLines);
 			$blocks = $substate->readBlocks();
-			return (sizeof($blocks) == 1) ? $blocks[0] : new MDNode($blocks);
+			return (sizeof($blocks) == 1) ? $blocks[0] : new MDBlockNode($blocks);
 		}
 	}
 
 	public function readBlock(MDState $state): ?MDBlockNode {
-		$className = get_class($this);
+		$className = MDUtils::typename($this);
 		throw new Error("Abstract readBlock must be overridden in {$className}");
 	}
 }
 	private static string $unorderedListRegex = '^([\\*\\+\\-]\\s+)(.*)$';  // 1=bullet, 2=content
 
 	private function readUnorderedListItem(MDState $state): ?MDListItemNode {
+		if (!$state->hasLines(1)) return null;
 		$p = $state->p;
 		$line = $state->lines[$p];
 		if (!mb_eregi(self::$unorderedListRegex, $line, $groups)) return null;
 	private static string $orderedListRegex = '^(\\d+)(\\.\\s+)(.*)$';  // 1=number, 2=dot, 3=content
 
 	private function readOrderedListItem(MDState $state): ?MDListItemNode {
+		if (!$state->hasLines(1)) return null;
 		$p = $state->p;
 		$line = $state->lines[$p];
 		if (!mb_eregi(self::$orderedListRegex, $line, $groups)) return null;
 		$p = $state->p;
 		$openFenceLine = $state->lines[$p++];
 		[$openFenceLine, $modifier] = MDTagModifier::fromLine($openFenceLine, $state);
-		if (!mb_eregi('```\s*([a-z0-9]*)\s*$', $openFenceLine, $groups)) return null;
+		if (!mb_eregi('```\\s*([a-z0-9]*)\\s*$', $openFenceLine, $groups)) return null;
 		$language = mb_strlen($groups[1]) > 0 ? $groups[1] : null;
 		$codeLines = [];
 		while ($state->hasLines(1, $p)) {
 		if (str_starts_with($line, '|')) $line = mb_substr($line, 1);
 		if (str_ends_with($line, '|')) $line = mb_substr($line, 0, mb_strlen($line) - 1);
 		$cellTokens = explode('|', $line);
-		$cells = array_map(function($token) use ($isHeader) {
+		$cells = array_map(function($token) use ($isHeader, $state) {
 			$content = $state->inlineMarkdownToNode(trim($token));
 			return $isHeader ? new MDTableHeaderCellNode($content) : new MDTableCellNode($content);
 		}, $cellTokens);
 			}
 		}
 		if ($termCount == 0 || $definitionCount == 0) return null;
-		$blocks = array_map(function($line) {
-			if (mb_eregi('^:\\s+(.*?)$', $line)) {
+		$blocks = array_map(function($line) use ($state) {
+			if (mb_eregi('^:\\s+(.*?)$', $line, $groups)) {
 				return new MDDefinitionListDefinitionNode($state->inlineMarkdownToNodes($groups[1]));
 			} else {
 				return new MDDefinitionListTermNode($state->inlineMarkdownToNodes($line));
 		$instances = $footnoteInstances[$symbol] ?? [];
 		array_push($instances, $unique);
 		$footnoteInstances[$symbol] = $instances;
+		$state->root()->userInfo['footnoteInstances'] = $footnoteInstances;
 	}
 
 	private function idForFootnoteSymbol(MDState $state, string $symbol): int {
-		$footnoteIds = $state->root()->userInfo['footnoteIds'];
-		$existing = $footnoteIds[$symbol];
-		if ($existing) return $existing;
-		$nextFootnoteId = $state->root()->userInfo['nextFootnoteId'];
+		$footnoteIds = $state->root()->userInfo['footnoteIds'] ?? [];
+		$existing = $footnoteIds[$symbol] ?? null;
+		if ($existing !== null) return $existing;
+		$nextFootnoteId = $state->root()->userInfo['nextFootnoteId'] ?? 1;
 		$id = $nextFootnoteId++;
 		$footnoteIds[$symbol] = $id;
 		$state->root()->userInfo['nextFootnoteId'] = $nextFootnoteId;
+		$state->root()->userInfo['footnoteIds'] = $footnoteIds;
 		return $id;
 	}
 
 		$content = $state->inlineMarkdownToNodes($def);
 		$this->defineFootnote($state, $symbol, $content);
 		$state->p = $p;
-		return new MDNode(); // empty
+		return new MDBlockNode(); // empty
 	}
 
 	public function readToken(MDState $state, string $line): ?MDToken {
 	}
 
 	public function substituteTokens(MDState $state, int $pass, array &$tokens): bool {
-		if ($match = self::findFirstTokens($tokens, [ MDTokenType::Footnote ])) {
+		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::Footnote ])) {
 			$symbol = $match->tokens[0]->content;
-			array_splice($tokens, $match->index, 1, new MDFootnoteNode($symbol));
+			array_splice($tokens, $match->index, 1, [new MDFootnoteNode($symbol)]);
 			return true;
 		}
 		return false;
 	public function postProcess(MDState $state, array &$blocks) {
 		$nextOccurrenceId = 1;
 		foreach ($blocks as $block) {
-			$block->visitChildren(function($node) use (&$nextOccurrenceId) {
+			$block->visitChildren(function($node) use (&$nextOccurrenceId, $state) {
 				if (!($node instanceof MDFootnoteNode)) return;
 				$node->footnoteId = $this->idForFootnoteSymbol($state, $node->symbol);
 				$node->occurrenceId = $nextOccurrenceId++;
 				$node->displaySymbol = strval($node->footnoteId);
-				$this->$registerUniqueInstance($state, $node->symbol, $node->occurrenceId);
+				$this->registerUniqueInstance($state, $node->symbol, $node->occurrenceId);
 			});
 		}
 		if (sizeof($state->userInfo['footnotes']) == 0) return;
  */
 class MDAbbreviationReader extends MDReader {
 	private function defineAbbreviation(MDState $state, string $abbreviation, string $definition) {
-		$state->root()->abbreviations[$abbreviation] = $definition;
-		$regex = "\\b(" . preg_quote($abbreviation) . ")\\b";
-		$state->root()->abbreviationRegexes[$abbreviation] = $regex;
+		$abbrevs = $state->root()->userInfo['abbreviations'];
+		$abbrevs[$abbreviation] = $definition;
+		$state->root()->userInfo['abbreviations'] = $abbrevs;
 	}
 
 	public function preProcess(MDState $state) {
 		$state->root()->userInfo['abbreviations'] = [];
-		$state->root()->userInfo['abbreviationRegexes'] = [];
 	}
 
 	public function readBlock(MDState $state): ?MDBlockNode {
 		$def = $groups[2];
 		$this->defineAbbreviation($state, $abbrev, $def);
 		$state->p = $p;
-		return new MDNode(); // empty
+		return new MDBlockNode(); // empty
 	}
 
 	/**
 	 */
 	public function postProcess(MDState $state, array &$blocks) {
 		$abbreviations = $state->root()->userInfo['abbreviations'];
-		$regexes = $state->root()->userInfo['abbreviationRegexes'];
-		MDNode::replaceNodes($state, $blocks, function($original) use ($abbreviations, $regexes) {
+		MDNode::replaceNodes($state, $blocks, function($original) use ($abbreviations) {
 			if (!($original instanceof MDTextNode)) return null;
 			$changed = false;
 			$elems = [ $original->text ]; // mix of strings and MDNodes
 			for ($i = 0; $i < sizeof($elems); $i++) {
 				$text = $elems[$i];
 				if (!is_string($text)) continue;
-				foreach ($abbreviations as $abbreviation) {
+				foreach ($abbreviations as $abbreviation => $definition) {
 					$index = strpos($text, $abbreviation);
-					if ($index === false) break;
+					if ($index === false) continue;
 					$prefix = substr($text, 0, $index);
 					$suffix = substr($text, $index + strlen($abbreviation));
-					$definition = $abbreviations[$abbreviation];
-					array_splice($elems, $i, 1, [ $prefix, new MDAbbreviationNode($abbreviation, $definition), $suffix ]);
+					array_splice($elems, $i, 1, [$prefix, new MDAbbreviationNode($abbreviation, $definition), $suffix]);
 					$i = -1; // start over
 					$changed = true;
 					break;
 				}
 			}
 			if (!$changed) return null;
-			$nodes = array_map(fn($elem) => is_string($elem) ? new MDTextNode($elem) : $elem);
+			$nodes = array_map(fn($elem) => is_string($elem) ? new MDTextNode($elem) : $elem, $elems);
 			return new MDNode($nodes);
 		});
 	}
 		// #4: singles with paired inner tokens
 		if ($count == 1 && $pass != 2 && $pass != 4) return false;
 		if ($count > 1 && $pass != 1 && $pass != 3) return false;
-		$delimiters = [];
-		array_fill(0, $count, $delimiter);
+		$delimiters = array_fill(0, $count, $delimiter);
 		$isFirstOfMultiplePasses = $this->substitutionPassCount() > 1 && $pass == 1;
-		$match = MDToken::findPairedTokens($tokens, $delimiters, $delimiters, function($content) {
+		$match = MDToken::findPairedTokens($tokens, $delimiters, $delimiters, function($content) use ($nodeClass, $isFirstOfMultiplePasses, $delimiter) {
 			$firstType = $content[0] instanceof MDToken ? $content[0]->type : null;
 			$lastType = $content[sizeof($content) - 1] instanceof MDToken ? $content[sizeof($content) - 1]->type : null;
 			if ($firstType == MDTokenType::Whitespace) return false;
 			if ($lastType == MDTokenType::Whitespace) return false;
 			foreach ($content as $token) {
 				// Don't allow nesting
-				if (get_class($token) == $nodeClass) return false;
+				if (MDUtils::typename($token) == $nodeClass) return false;
 			}
 			if ($isFirstOfMultiplePasses) {
 				$innerCount = 0;
 			return true;
 		});
 		if ($match === null) return false;
-		$content = ($plaintext)
-			? implode('', array_map(fn($token) => $token->original, $match->contentTokens))
-			: $state->tokensToNodes($match->contentTokens);
+		$state->checkExecutionTime();
+		if ($plaintext) {
+			$content = implode('', array_map(fn($token) => $token instanceof MDToken ? $token->original : $token->toPlaintext($state), $match->contentTokens));
+		} else {
+			$content = $state->tokensToNodes($match->contentTokens);
+		}
 		$ref = new ReflectionClass($nodeClass);
 		$node = $ref->newInstanceArgs([ $content ]);
-		array_splice($tokens, $match->startIndex, $match->totalLength, [ $node ]);
+		array_splice($tokens, $match->startIndex, $match->totalLength, [$node]);
 		return true;
 	}
+
+	private static $firstTime = null;
 }
 
 /**
 	public function substituteTokens(MDState $state, int $pass, array &$tokens): bool {
 		if ($this->attemptPair($state, $pass, $tokens, 'MDCodeNode', MDTokenType::Backtick, 2, true)) return true;
 		if ($this->attemptPair($state, $pass, $tokens, 'MDCodeNode', MDTokenType::Backtick, 1, true)) return true;
+		return false;
 	}
 }
 
 			$text = $match->tokens[0]->content;
 			$url = $match->tokens[sizeof($match->tokens) - 1]->content;
 			$title = $match->tokens[sizeof($match->tokens) - 1]->extra;
-			array_splice($tokens, $match->index, sizeof($match->tokens), new MDLinkNode($url, $state->inlineMarkdownToNode($text), $title));
+			array_splice($tokens, $match->index, sizeof($match->tokens), [new MDLinkNode($url, $state->inlineMarkdownToNode($text), $title)]);
 			return true;
 		}
 		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::Label, MDTokenType::META_OptionalWhitespace, MDTokenType::Email ])) {
 			$email = $match->tokens[sizeof($match->tokens) - 1]->content;
 			$url = "mailto:{$email}";
 			$title = $match->tokens[sizeof($match->tokens) - 1]->extra;
-			array_splice($tokens, $match->index, sizeof($match->tokens), new MDLinkNode($url, $state->inlineMarkdownToNodes($text), $title));
+			array_splice($tokens, $match->index, sizeof($match->tokens), [new MDLinkNode($url, $state->inlineMarkdownToNodes($text), $title)]);
 			return true;
 		}
 		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::SimpleEmail ])) {
 			$token = $match->tokens[0];
 			$link = "mailto:{$token->content}";
 			$node = new MDLinkNode($link, new MDObfuscatedTextNode($token->content));
-			array_splice($tokens, $match->index, 1, $node);
+			array_splice($tokens, $match->index, 1, [$node]);
 			return true;
 		}
 		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::SimpleLink ])) {
 			$token = $match->tokens[0];
 			$link = $token->content;
 			$node = new MDLinkNode($link, new MDTextNode($link));
-			array_splice($tokens, $match->index, 1, $node);
+			array_splice($tokens, $match->index, 1, [$node]);
 			return true;
 		}
 		return false;
 			if (mb_eregi('^\\s*\\[(.+?)]:\\s*(\\S+)\\s*$', $line, $groups)) {
 				$symbol = $groups[1];
 				$url = $groups[2];
+				$title = null;
 			} else {
 				return null;
 			}
 		}
 		$state->defineURL($symbol, $url, $title);
 		$state->p = $p;
-		return new MDNode([]); // empty
+		return new MDBlockNode([]); // empty
 	}
 
 	public function substituteTokens(MDState $state, int $pass, array &$tokens): bool {
 		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::Label, MDTokenType::META_OptionalWhitespace, MDTokenType::Label ])) {
 			$text = $match->tokens[0]->content;
 			$ref = $match->tokens[sizeof($match->tokens) - 1]->content;
-			array_splice($tokens, $match->index, sizeof($match->tokens), new MDReferencedLinkNode($ref, $state->inlineMarkdownToNodes($text)));
+			array_splice($tokens, $match->index, sizeof($match->tokens), [new MDReferencedLinkNode($ref, $state->inlineMarkdownToNodes($text))]);
 			return true;
 		}
 		return false;
 			if ($title !== null) {
 				$node->attributes['title'] = $title;
 			}
-			array_splice($tokens, $match->index, sizeof($match->tokens), $node);
+			array_splice($tokens, $match->index, sizeof($match->tokens), [$node]);
 			return true;
 		}
 		return false;
 		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::Bang, MDTokenType::Label, MDTokenType::META_OptionalWhitespace, MDTokenType::Label ])) {
 			$alt = $match->tokens[1]->content;
 			$ref = $match->tokens[sizeof($match->tokens) - 1]->content;
-			array_splice($tokens, $match->index, sizeof($match->tokens), new MDReferencedImageNode($ref, $alt));
+			array_splice($tokens, $match->index, sizeof($match->tokens), [new MDReferencedImageNode($ref, $alt)]);
 			return true;
 		}
 		return false;
 	public function substituteTokens(MDState $state, int $pass, array &$tokens): bool {
 		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::HTMLTag ])) {
 			$tag = $match->tokens[0]->tag;
-			array_splice($tokens, $match->index, sizeof($match->tokens), new MDHTMLTagNode($tag));
+			array_splice($tokens, $match->index, 1, [new MDHTMLTagNode($tag)]);
 			return true;
 		}
 		return false;
 		if (is_array($children)) {
 			foreach ($children as $elem) {
 				if (!($elem instanceof MDNode)) {
-					$thisClassName = get_class($this);
-					$elemClassName = get_class($elem);
+					$thisClassName = MDUtils::typename($this);
+					$elemClassName = MDUtils::typename($elem);
 					throw new Error("{$thisClassName} expects children of type MDNode[] or MDNode, got array with {$elemClassName} element");
 				}
 			}
 		} elseif ($children instanceof MDNode) {
 			$this->children = [ $children ];
 		} else {
-			$thisClassName = get_class($this);
-			$elemClassName = gettype($children) == 'object' ? get_class($children) : gettype($children);
+			$thisClassName = MDUtils::typename($this);
+			$elemClassName = MDUtils::typename($children);
 			throw new Error("{$thisClassName} expects children of type MDNode[] or MDNode, got {$elemClassName}");
 		}
 	}
 
+	public function __toString(): string {
+		$s = "<" . get_class($this);
+		foreach ($this->children as $child) {
+			$s .= " {$child}";
+		}
+		$s .= ">";
+		return $s;
+	}
+
 	/**
 	 * Adds a CSS class. If already present it will not be duplicated.
 	 */
 	protected function htmlAttributes(): string {
 		$html = '';
 		if (sizeof($this->cssClasses) > 0) {
-			$classlist = implode(' ', $this->cssClasses);
-			$html .= " class=\"{$classList}\"";
+			$classlist = htmlentities(implode(' ', $this->cssClasses));
+			$html .= " class=\"{$classlist}\"";
 		}
 		if ($this->cssId !== null && mb_strlen($this->cssId) > 0) {
-			$html .= " id=\"{$this->cssId}\"";
+			$html .= " id=\"" . htmlentities($this->cssId) . "\"";
 		}
 		$styles = [];
 		foreach ($this->cssStyles as $key => $value) {
 			array_push($styles, "{$key}: {$value};");
 		}
 		if (sizeof($styles) > 0) {
-			$escaped = htmlspecialchars(implode(' ', $styles));
+			$escaped = htmlentities(implode(' ', $styles));
 			$html .= " style=\"{$escaped}\"";
 		}
 		foreach ($this->attributes as $key => $value) {
 			if ($key === 'class' || $key === 'id' || $key === 'style') continue;
 			$cleanKey = MDUtils::scrubAttributeName($key);
 			if (mb_strlen($cleanKey) == 0) continue;
-			$cleanValue = htmlspecialchars($value);
+			$cleanValue = htmlentities($value);
 			$html .= " {$cleanKey}=\"{$cleanValue}\"";
 		}
 		return $html;
 	public function __construct(int $level, array $children) {
 		parent::__construct($children);
 		if (!is_int($level) || ($level < 1 || $level > 6)) {
-			$thisClassName = get_class($this);
+			$thisClassName = MDUtils::typename($this);
 			throw new Error("{$thisClassName} requires heading level 1 to 6");
 		}
 		$this->level = $level;
 class MDOrderedListNode extends MDBlockNode {
 	/** @var MDListItemNode[] $children */
 
-	public int $startOrdinal;
+	public ?int $startOrdinal;
 
 	/**
 	 * @param MDListItemNode[] $children
  * An item in a bulleted or numbered list.
  */
 class MDListItemNode extends MDBlockNode {
-	public int $ordinal;
+	public ?int $ordinal;
 
 	/**
 	 * @param MDNode|MDNode[] $children
 	 * @param ?int $ordinal
 	 */
-	public function __construct(array $children, ?int $ordinal=null) {
+	public function __construct(array|MDNode $children, ?int $ordinal=null) {
 		parent::__construct($children);
 		$this->ordinal = $ordinal;
 	}
 	public ?string $language;
 
 	public function __construct(string $text, ?string $language=null) {
-		super([]);
+		parent::__construct([]);
 		$this->text = $text;
 		$this->language = $language;
 	}
 	 * @param MDTableRowNode $headerRow
 	 * @param MDTableRowNode[] $bodyRows
 	 */
-	public function __construct(MDTableRow $headerRow, array $bodyRows) {
+	public function __construct(MDTableRowNode $headerRow, array $bodyRows) {
 		parent::__construct(array_merge([ $headerRow ], $bodyRows));
 	}
 
 		$this->applyAlignments();
 		$html = '';
 		$html .= "<table" . $this->htmlAttributes() . ">\n";
-		$html .= '<thead>\n';
-		$html .= $this->headerRow->toHTML($state) . "\n";
+		$html .= "<thead>\n";
+		$html .= $this->headerRow()->toHTML($state) . "\n";
 		$html .= "</thead>\n";
 		$html .= "<tbody>\n";
-		$html .= MDNode::toHTML($this->bodyRows, $state) . "\n";
+		$html .= MDNode::arrayToHTML($this->bodyRows(), $state) . "\n";
 		$html .= "</tbody>\n";
 		$html .= "</table>\n";
 		return $html;
 /**
  * Node for a header cell in a header table row.
  */
-class MDTableHeaderCellNode extends MDBlockNode {
+class MDTableHeaderCellNode extends MDTableCellNode {
 	public function toHTML(MDState $state): string {
 		return $this->simplePairedTagHTML($state, 'th');
 	}
  * content.
  */
 class MDFootnoteListNode extends MDBlockNode {
-	private function footnoteId(MDState $state, string $symbol): int {
+	private function footnoteId(MDState $state, string $symbol): ?int {
 		$lookup = $state->root()->userInfo['footnoteIds'];
 		if (!$lookup) return null;
 		return $lookup[$symbol] ?? null;
 	}
 
 	public function toHTML(MDState $state): string {
-		$footnotes = $state->userInfo['footnotes'];
+		$footnotes = $state->root()->userInfo['footnotes'];
 		$symbolOrder = array_keys($footnotes);
 		if (sizeof($footnotes) == 0) return '';
-		$footnoteUniques = $state->root()->footnoteInstances;
+		$footnoteUniques = $state->root()->userInfo['footnoteInstances'];
 		$html = '';
 		$html .= '<div class="footnotes">';
 		$html .= '<ol>';
-		foreach ($symbolOrder as $symbol) {
+		foreach ($symbolOrder as $symbolRaw) {
+			$symbol = "{$symbolRaw}";
 			$content = $footnotes[$symbol];
 			if (!$content) continue;
 			$footnoteId = $this->footnoteId($state, $symbol);
-			$contentHTML = MDNode::toHTML($content, $state);
+			$contentHTML = MDNode::arrayToHTML($content, $state);
 			$html .= "<li value=\"{$footnoteId}\" id=\"{$state->root()->elementIdPrefix}footnote_{$footnoteId}\">{$contentHTML}";
-			$uniques = $footnoteUniques[$symbol];
+			$uniques = $footnoteUniques[$symbol] ?? null;
 			if ($uniques) {
 				foreach ($uniques as $unique) {
 					$html .= " <a href=\"#{$state->root()->elementIdPrefix}footnoteref_{$unique}\" class=\"footnote-backref\">↩︎</a>";
 		}
 		$html .= '</ol>';
 		$html .= '</div>';
-		return html;
+		return $html;
 	}
 
 	public function toPlaintext(MDState $state): string {
 		$symbolOrder = array_keys($footnotes);
 		if (sizeof($footnotes) == 0) return '';
 		$text = '';
-		foreach ($symbolOrder as $symbol) {
+		foreach ($symbolOrder as $symbolRaw) {
+			$symbol = "{$symbolRaw}";
 			$content = $footnotes[$symbol];
 			if (!$content) continue;
 			$text .= "{$symbol}. " . $this->childPlaintext(state) . "\n";
 
 	public function __construct(string $text) {
 		parent::__construct([]);
-		if (!is_string($text) || mb_strlen($text) == 0) throw new Error("Meh!");
 		$this->text = $text;
 	}
 
 	}
 
 	public function toHTML(MDState $state): string {
-		return "<code" . $this->htmlAttributes() . ">" . MDUtils::escapeHTML($this->text) . "</code>";
+		return "<code" . $this->htmlAttributes() . ">" . htmlentities($this->text) . "</code>";
 	}
 }
 
 	}
 
 	public function toHTML(MDState $state): string {
-		if ($this->differentiator !== null) {
+		if ($this->footnoteId !== null) {
 			return "<sup class=\"footnote\" id=\"{$state->root()->elementIdPrefix}footnoteref_{$this->occurrenceId}\"" . $this->htmlAttributes() . ">" .
 				"<a href=\"#{$state->root()->elementIdPrefix}footnote_{$this->footnoteId}\">" . htmlentities($this->displaySymbol ?? $this->symbol) . "</a></sup>";
 		}
 			$title = $state->urlTitleForReference($this->reference);
 			if ($title) $this->attributes['title'] = $title;
 		}
-		return $super->toHTML($state);
+		return parent::toHTML($state);
 	}
 }
 
 	public ?string $alt;
 
 	public function __construct(string $src, ?string $alt) {
-		super([]);
+		parent::__construct([]);
 		$this->src = $src;
 		$this->alt = $alt;
 	}
 			$title = $state->urlTitleForReference($this->reference);
 			if ($title !== null) $this->attributes['title'] = $title;
 		}
-		return super.toHTML(state);
+		return parent::toHTML($state);
 	}
 }
 
 	 * @param {string} definition
 	 */
 	public function __construct(string $abbreviation, string $definition) {
-		super([]);
+		parent::__construct([]);
 		$this->abbreviation = $abbreviation;
 		$this->attributes['title'] = $definition;
 	}
 	 * @param string $elementIdPrefix
 	 */
 	private function investigateException(array $lines, string $elementIdPrefix) {
+		print("Investigating error...\n");
 		$startIndex = 0;
 		$endIndex = sizeof($lines);
 		// Keep stripping away first line until an exception stops being thrown
 			}
 		}
 		$problematicMarkdown = implode("\n", array_slice($lines, $startIndex, $endIndex));
-		print("This portion of markdown caused an unexpected exception: {$problematicMarkdown}");
+		print("This portion of markdown caused an unexpected exception:\n{$problematicMarkdown}\n");
 	}
 }
 ?>