Able to parse simple markdown with PHP

php/markdown.php

 	 * @param string[] $lines
 	 * @return string[]
 	 */
-	public static function withoutTrailingBlankLines(array &$lines): array {
+	public static function withoutTrailingBlankLines(array $lines): array {
 		$stripped = $lines;
 		while (sizeof($stripped) > 0 && mb_strlen(trim($stripped[sizeof($stripped) - 1])) == 0) {
 			array_pop($stripped);
 	 *
 	 * @param string[] $lines
 	 */
-	public static function containsBlankLine(array &$lines): bool {
+	public static function containsBlankLine(array $lines): bool {
 		foreach ($lines as $line) {
 			if (mb_strlen(trim($line)) == 0) return true;
 		}
 	 */
 	public int $p = 0;
 
+	/**
+	 * General storage for anything readers need to track during the parsing
+	 * process.
+	 */
+	public array $userInfo = [];
+
 	private ?MDState $parent = null;
 
 	/**
 	 */
 	public MDHTMLFilter $tagFilter;
 
-	private static string $textWhitespaceRegex = '^(\\s*)(?:(\\S|\\S.*\\S)(\\s*?))?$'; // 1=leading WS, 2=text, 3=trailing WS
-
 	/**
 	 * @param string[] $lines - lines of markdown text
 	 */
 		$lines = MDUtils::withoutTrailingBlankLines(array_slice($this->lines, $this->p));
 		if (sizeof($lines) == 0) return null;
 		$this->p = sizeof($this->lines);
-		return $this->inlineMarkdownToNode(implode("\n", $lines));
+		return new MDBlockNode($this->inlineMarkdownToNode(implode("\n", $lines)));
 	}
 
 	/**
 				if ($this->p == $startP) {
 					$readerClassName = get_class($reader);
 					$blockClassName = get_class($block);
-					throw new Error("{$readerClassName} returned an " +
-						"{$blockClassName} without incrementing MDState.p. " +
+					throw new Error("{$readerClassName} returned an " .
+						"{$blockClassName} without incrementing MDState.p. " .
 						"This could lead to an infinite loop.");
 				}
 				return $block;
 		/**
 		 * Flushes accumulated content in `text` to `tokens`.
 		 */
-		function endText() {
+		$endText = function() use (&$tokens, &$text) {
 			if (mb_strlen($text) == 0) return;
-			$textGroups = null;
-			if (mb_eregi(MDState::$textWhitespaceRegex, $text, $textGroups)) {
-				if (mb_strlen($textGroups[1]) > 0) {
-					array_push($tokens, new MDToken($textGroups[1], MDTokenType::Whitespace, $textGroups[1]));
-				}
-				if ($textGroups[2] && mb_strlen($textGroups[2]) > 0) {
-					$tokens.push(new MDToken($textGroups[2], MDTokenType::Text, $textGroups[2]));
-				}
-				if ($textGroups[3] && mb_strlen($textGroups[3]) > 0) {
-					$tokens.push(new MDToken($textGroups[3], MDTokenType::Whitespace, $textGroups[3]));
-				}
+			$textGroups = [];
+			if (mb_eregi('^(\s+)(.*?)$', $text, $textGroups)) {
+				array_push($tokens, new MDToken($textGroups[1], MDTokenType::Whitespace, $textGroups[1]));
+				$text = $textGroups[2];
+			}
+			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 {
 				array_push($tokens, new MDToken($text, MDTokenType::Text, $text));
 			}
 			$text = '';
-		}
+		};
 
-		for ($p = 0; $p < mb_strlen(line); $p++) {
-			$ch = mb_substr($line, p, 1);
+		for ($p = 0; $p < mb_strlen($line); $p++) {
+			$ch = mb_substr($line, $p, 1);
 			$remainder = mb_substr($line, $p);
 			if ($expectLiteral) {
 				$text .= $ch;
 			foreach ($this->root()->readersByTokenPriority as $reader) {
 				$token = $reader->readToken($this, $remainder);
 				if ($token === null) continue;
-				endText();
+				$endText();
 				array_push($tokens, $token);
 				if ($token->original == null || mb_strlen($token->original) == 0) {
 					$readerClassName = get_class($reader);
 				break;
 			}
 			if (!$found) {
-				$text += $ch;
+				$text .= $ch;
 			}
 		}
-		endText();
+		$endText();
 		return $tokens;
 	}
 
 		$anyChanges = false;
 		do {
 			$anyChanges = false;
-			foreach ($this->root->readersBySubstitutePriority as $readerTuple) {
+			foreach ($this->root()->readersBySubstitutePriority as $readerTuple) {
 				/** @var int */
 				$pass = $readerTuple[0];
 				/** @var MDReader */
 	 * Defines a URL by reference symbol.
 	 */
 	public function defineURL(string $reference, string $url, ?string $title=null) {
-		$this->root->referenceToURL[mb_strtolower($reference)] = $url;
+		$this->root()->referenceToURL[mb_strtolower($reference)] = $url;
 		if ($title !== null) $this->root()->referenceToTitle[mb_strtolower($reference)] = $title;
 	}
 
 				case '*':
 					return true;
 				case '{classlist}':
-					if (mb_eregi(self::classListRegex, $value)) return true;
+					if (mb_eregi(self::$classListRegex, $value)) return true;
 					break;
 				case '{int}':
-					if (mb_eregi(self::integerRegex, $value)) return true;
+					if (mb_eregi(self::$integerRegex, $value)) return true;
 					break;
 				case '{none}':
 					if ($value === true) return true;
 					if ($this->isValidStyleDeclaration($value)) return true;
 					break;
 				case '{url}':
-					if (mb_eregi(self::permissiveURLRegex, $value)) return true;
+					if (mb_eregi(self::$permissiveURLRegex, $value)) return true;
 					break;
 				default:
 					if ($value === $option) return true;
 			if ($value === true) {
 				$html .= " {$safeName}";
 			} else {
-				$escapedValue = MDUtils::escapeHTML("{$value}");
+				$escapedValue = htmlentities("{$value}");
 				$html .= " {$safeName}=\"{$escapedValue}\"";
 			}
 		}
 		$valuesById = [];
 
 		// Build the graph and compute in-degrees
-		foreach ($arr as $elem) {
+		foreach ($arr as $index => $elem) {
 			$id = $idFn($elem);
 			$graph[$id] = [];
 			$inDegrees[$id] = 0;
 				$idB = $idFn($elemB);
 				$comparisonResult = $compareFn($elemA, $elemB);
 				if ($comparisonResult < 0) {
-					array_push($graph[$idA], push($idB));
+					array_push($graph[$idA], $idB);
 					$inDegrees[$idB]++;
 				} elseif ($comparisonResult > 0) {
 					array_push($graph[$idB], $idA);
 
 		// Initialize the queue with zero-inDegree nodes
 		$queue = [];
-		foreach ($inDegrees as $elemId) {
-			if ($inDegrees[$elemId] === 0) {
+		foreach ($inDegrees as $elemId => $degree) {
+			if ($degree === 0) {
 				array_push($queue, $elemId);
 			}
 		}
 	 * @param MDReader[] $readers
 	 * @return MDReader[]  sorted readers
 	 */
-	public static function sortReaderForBlocks(array &$readers) {
+	public static function sortReaderForBlocks(array &$readers): array {
 		$sorted = $readers;
 		return self::kahnTopologicalSort($sorted, function(MDReader $a, MDReader $b): int {
 			return $a->compareBlockOrdering($b);
 	 * @param MDReader[] $readers
 	 * @return MDReader[]  sorted readers
 	 */
-	public static function sortReadersForTokenizing(array $readers): array {
+	public static function sortReadersForTokenizing(array &$readers): array {
 		$sorted = $readers;
 		return self::kahnTopologicalSort($sorted, function(MDReader $a, MDReader $b): int {
 			return $a->compareTokenizeOrdering($b);
 	 * @return MDReader[]  sorted array of tuples with the pass number and
 	 *   reader instance in each
 	 */
-	public static function sortReadersForSubstitution(array $readers): array {
+	public static function sortReadersForSubstitution(array &$readers): array {
 		$tuples = [];
 		$maxPass = 1;
 		foreach ($readers as $reader) {
 			$passCount = $reader->substitutionPassCount();
 			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);
-			$passResult = self::kahnTopologicalSort($readersThisPass, function(MDReader $a, MDReader $b): int {
+			$readersThisPass = 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);
 		if (!$state->hasLines(2)) return null;
 		$modifier;
 		$contentLine = trim($state->lines[$p++]);
-		[$contentLine, $modifier] = MDTagModifier.fromLine(contentLine, state);
+		[$contentLine, $modifier] = MDTagModifier::fromLine($contentLine, $state);
 		$underLine = trim($state->lines[$p++]);
 		if ($contentLine == '') return null;
 		if (mb_eregi('^=+$', $underLine)) {
 		$line = $state->lines[$p++];
 		$modifier;
 		[$line, $modifier] = MDTagModifier::fromLine($line, $state);
-		if (!mb_eregi(self::hashHeadingRegex, $line, $groups)) return null;
+		if (!mb_eregi(self::$hashHeadingRegex, $line, $groups)) return null;
 		$state->p = $p;
 		$level = mb_strlen($groups[1]);
 		$content = $groups[2];
 		$line = $state->lines[$p++];
 		$modifier;
 		[$line, $modifier] = MDTagModifier::fromLine($line, $state);
-		if (!mb_eregi(self::subtextRegex, $line, $groups)) return null;
+		if (!mb_eregi(self::$subtextRegex, $line, $groups)) return null;
 		$state->p = $p;
 		$content = $groups[1];
 		$block = new MDSubtextNode($state->inlineMarkdownToNodes($content));
 		// Multiline content with no blank lines. Search for new block
 		// boundaries without the benefit of a blank line to demarcate it.
 		for ($p = 1; $p < sizeof($itemLines); $p++) {
-			$line = $itemLines[p];
+			$line = $itemLines[$p];
 			if (mb_eregi('^(?:\\*|\\-|\\+|\\d+\\.)\\s+', $line)) {
 				// Nested list found
 				$firstBlock = $state->inlineMarkdownToNode(implode("\n", array_slice($itemLines, 0, $p)));
 	}
 
 	public function readBlock(MDState $state): ?MDBlockNode {
-		throw new Error(`Abstract readBlock must be overridden in ${this.constructor.name}`);
+		$className = get_class($this);
+		throw new Error("Abstract readBlock must be overridden in {$className}");
 	}
 }
 
 			$item = $this->readOrderedListItem($state);
 			if ($item) array_push($items, $item);
 		} while ($item);
-		if (sizeof($items)) return null;
+		if (sizeof($items) == 0) return null;
 		return new MDOrderedListNode($items, $items[0]->ordinal);
 	}
 }
 		if (!$state->hasLines(2)) return null;
 		$p = $state->p;
 		$openFenceLine = $state->lines[$p++];
-		[$openFenceLine, $modifier] = MDTagModifier->fromLine($openFenceLine, $state);
+		[$openFenceLine, $modifier] = MDTagModifier::fromLine($openFenceLine, $state);
 		if (!mb_eregi('```\s*([a-z0-9]*)\s*$', $openFenceLine, $groups)) return null;
 		$language = mb_strlen($groups[1]) > 0 ? $groups[1] : null;
 		$codeLines = [];
 		$p = $state->p;
 		$line = $state->lines[$p++];
 		[$line, $modifier] = MDTagModifier::fromLine($line, $state);
-		if (mb_eregi(self::horizontalRuleRegex, $line)) {
+		if (mb_eregi(self::$horizontalRuleRegex, $line)) {
 			$state->p = $p;
 			$block = new MDHorizontalRuleNode();
 			if ($modifier) $modifier->applyTo($block);
 	 * @param MDNode[] $footnote
 	 */
 	private function defineFootnote(MDState $state, string $symbol, array $footnote) {
-		$footnotes = $state->root()['footnotes'] ?? [];
+		$footnotes = $state->root()->userInfo['footnotes'] ?? [];
 		$footnotes[$symbol] = $footnote;
-		$state->root()['footnotes'] = $footnotes;
+		$state->root()->userInfo['footnotes'] = $footnotes;
 	}
 
 	private function registerUniqueInstance(MDState $state, string $symbol, int $unique) {
-		$footnoteInstances = $state->root()['footnoteInstances'];
+		$footnoteInstances = $state->root()->userInfo['footnoteInstances'];
 		$instances = $footnoteInstances[$symbol] ?? [];
 		array_push($instances, $unique);
 		$footnoteInstances[$symbol] = $instances;
 	}
 
 	private function idForFootnoteSymbol(MDState $state, string $symbol): int {
-		$footnoteIds = $state->root()['footnoteIds'];
+		$footnoteIds = $state->root()->userInfo['footnoteIds'];
 		$existing = $footnoteIds[$symbol];
 		if ($existing) return $existing;
-		$nextFootnoteId = $state->root()['nextFootnoteId'];
+		$nextFootnoteId = $state->root()->userInfo['nextFootnoteId'];
 		$id = $nextFootnoteId++;
 		$footnoteIds[$symbol] = $id;
-		$state->root()['nextFootnoteId'] = $nextFootnoteId;
+		$state->root()->userInfo['nextFootnoteId'] = $nextFootnoteId;
 		return $id;
 	}
 
 	public function preProcess(MDState $state) {
-		$state->root()['footnoteInstances'] = [];
-		$state->root()['footnotes'] = [];
-		$state->root()['footnoteIds'] = [];
-		$state->root()['nextFootnoteId'] = 1;
+		$state->root()->userInfo['footnoteInstances'] = [];
+		$state->root()->userInfo['footnotes'] = [];
+		$state->root()->userInfo['footnoteIds'] = [];
+		$state->root()->userInfo['nextFootnoteId'] = 1;
 	}
 
 	public function readBlock(MDState $state): ?MDBlockNode {
 		while ($state->hasLines(1, $p)) {
 			$line = $state->lines[$p++];
 			if (mb_eregi('^\\s+', $line)) {
-				$def += "\n" . $line;
+				$def .= "\n" . $line;
 			} else {
 				$p--;
 				break;
 		if (mb_eregi(self::$footnoteWithTitleRegex, $line, $groups)) {
 			return new MDToken($groups[0], MDTokenType::Footnote, $groups[1], $groups[2]);
 		}
-		if (mb_eregi(MDFootnoteReader::footnoteRegex, $line, $groups)) {
+		if (mb_eregi(self::$footnoteRegex, $line, $groups)) {
 			return new MDToken($groups[0], MDTokenType::Footnote, $groups[1]);
 		}
 		return null;
 	}
 
 	public function substituteTokens(MDState $state, int $pass, array &$tokens): bool {
-		if ($match = MDToken::findFirstTokens($tokens, [ MDTokenType::Footnote ])) {
+		if ($match = self::findFirstTokens($tokens, [ MDTokenType::Footnote ])) {
 			$symbol = $match->tokens[0]->content;
 			array_splice($tokens, $match->index, 1, new MDFootnoteNode($symbol));
 			return true;
 				$this->$registerUniqueInstance($state, $node->symbol, $node->occurrenceId);
 			});
 		}
-		if (sizeof($state->footnotes) == 0) return;
+		if (sizeof($state->userInfo['footnotes']) == 0) return;
 		array_push($blocks, new MDFootnoteListNode());
 	}
 
 	}
 
 	public function preProcess(MDState $state) {
-		$state->root()['abbreviations'] = [];
-		$state->root()['abbreviationRegexes'] = [];
+		$state->root()->userInfo['abbreviations'] = [];
+		$state->root()->userInfo['abbreviationRegexes'] = [];
 	}
 
 	public function readBlock(MDState $state): ?MDBlockNode {
 	 * @param MDNode[] $blocks
 	 */
 	public function postProcess(MDState $state, array &$blocks) {
-		$abbreviations = $state->root()['abbreviations'];
-		$regexes = $state->root()['abbreviationRegexes'];
-		MDNode::replaceNodes($state, $blocks, function($original) {
+		$abbreviations = $state->root()->userInfo['abbreviations'];
+		$regexes = $state->root()->userInfo['abbreviationRegexes'];
+		MDNode::replaceNodes($state, $blocks, function($original) use ($abbreviations, $regexes) {
 			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];
+				$text = $elems[$i];
 				if (!is_string($text)) continue;
 				foreach ($abbreviations as $abbreviation) {
 					$index = strpos($text, $abbreviation);
 class MDLinkReader extends MDReader {
 	public function readToken(MDState $state, string $line): ?MDToken {
 		$simpleEmailRegex = "^<(" . MDUtils::$baseEmailRegex . ")>";
-		$simpleURLRegex = "^<(" . MDUtils::$baseURLRegex + ")>";
+		$simpleURLRegex = "^<(" . MDUtils::$baseURLRegex . ")>";
 		if ($groups = MDToken::tokenizeLabel($line)) {
 			return new MDToken($groups[0], MDTokenType::Label, $groups[1]);
 		}
 				}
 			}
 			$this->children = $children;
-		} else if ($children instanceof MDNode) {
+		} elseif ($children instanceof MDNode) {
 			$this->children = [ $children ];
 		} else {
 			$thisClassName = get_class($this);
 			$html .= " class=\"{$classList}\"";
 		}
 		if ($this->cssId !== null && mb_strlen($this->cssId) > 0) {
-			$html += " id=\"{$this->cssId}\"";
+			$html .= " id=\"{$this->cssId}\"";
 		}
 		$styles = [];
 		foreach ($this->cssStyles as $key => $value) {
 	 * @return string HTML string
 	 */
 	public static function arrayToHTML(array $nodes, MDState $state): string {
-		return implode('', array_map(function($node) {
+		return implode('', array_map(function($node) use ($state) {
 			return $node->toHTML($state) . ($node instanceof MDBlockNode ? "\n" : '');
 		}, $nodes));
 	}
 
 	public function toHTML(MDState $state): string {
 		$languageModifier = ($this->language !== null) ? " class=\"language-{$this->language}\"" : '';
-		return "<pre" . $this->htmlAttributes() . "><code{$languageModifier}>" +
-			MDUtils.escapeHTML($this->text) . "</code></pre>\n";
+		return "<pre" . $this->htmlAttributes() . "><code{$languageModifier}>" .
+			htmlentities($this->text) . "</code></pre>\n";
 	}
 }
 
 		$html .= $this->headerRow->toHTML($state) . "\n";
 		$html .= "</thead>\n";
 		$html .= "<tbody>\n";
-		$html .= MDNode::toHTML($this->bodyRows, $state) + "\n";
+		$html .= MDNode::toHTML($this->bodyRows, $state) . "\n";
 		$html .= "</tbody>\n";
 		$html .= "</table>\n";
 		return $html;
  */
 class MDFootnoteListNode extends MDBlockNode {
 	private function footnoteId(MDState $state, string $symbol): int {
-		$lookup = $state->root()['footnoteIds'];
+		$lookup = $state->root()->userInfo['footnoteIds'];
 		if (!$lookup) return null;
 		return $lookup[$symbol] ?? null;
 	}
 
 	public function toHTML(MDState $state): string {
-		$footnotes = $state->footnotes;
+		$footnotes = $state->userInfo['footnotes'];
 		$symbolOrder = array_keys($footnotes);
 		if (sizeof($footnotes) == 0) return '';
 		$footnoteUniques = $state->root()->footnoteInstances;
 			$uniques = $footnoteUniques[$symbol];
 			if ($uniques) {
 				foreach ($uniques as $unique) {
-					$html .= " <a href=\"#{$state->root->elementIdPrefix}footnoteref_{$unique}\" class=\"footnote-backref\">↩︎</a>";
+					$html .= " <a href=\"#{$state->root()->elementIdPrefix}footnoteref_{$unique}\" class=\"footnote-backref\">↩︎</a>";
 				}
 			}
 			$html .= "</li>\n";
 	}
 
 	public function toPlaintext(MDState $state): string {
-		$footnotes = $state->footnotes;
+		$footnotes = $state->userInfo['footnotes'];
 		$symbolOrder = array_keys($footnotes);
 		if (sizeof($footnotes) == 0) return '';
 		$text = '';
 
 	public function __construct(string $text) {
 		parent::__construct([]);
+		if (!is_string($text) || mb_strlen($text) == 0) throw new Error("Meh!");
 		$this->text = $text;
 	}
 
 	 *
 	 * @param MDReader[] $readers
 	 */
-	public function __construct(?array $readers) {
+	public function __construct(?array $readers=null) {
 		$this->readers = $readers ?? self::allReaders();
-		$this->readersByBlockPriority = MDReader::sortReaderForBlocks($readers);
-		$this->readersByTokenPriority = MDReader::sortReadersForTokenizing($readers);
-		$this->readersBySubstitutePriority = MDReader::sortReadersForSubstitution($readers);
+		$this->readersByBlockPriority = MDReader::sortReaderForBlocks($this->readers);
+		$this->readersByTokenPriority = MDReader::sortReadersForTokenizing($this->readers);
+		$this->readersBySubstitutePriority = MDReader::sortReadersForSubstitution($this->readers);
 		$this->tagFilter = new MDHTMLFilter();
 	}
 
 		$state->readersBySubstitutePriority = $this->readersBySubstitutePriority;
 		$state->tagFilter = $this->tagFilter;
 		$state->elementIdPrefix = $elementIdPrefix;
-		foreach ($this.readers as $reader) {
+		foreach ($this->readers as $reader) {
 			$reader->preProcess($state);
 		}
 		$nodes = $state->readBlocks();