All block readers ported

js/markdown.js

@@ -2644,7 +2644,7 @@ class MDParagraphReader extends MDReader {
 	readBlock(state) {
 		var paragraphLines = [];
 		var p = state.p;
-		while (p < state.lines.length) {
+		while (state.hasLines(1, $p)) {
 			let line = state.lines[p++];
 			if (line.trim().length == 0) {
 				break;

php/markdown.php

@@ -1459,37 +1459,921 @@ class MDTagModifier {
 // -- Readers ---------------------------------------------------------------
 
 
-class MDReader {}
+/**
+ * Base class for readers of various markdown syntax. A `Markdown` instance can
+ * be created with any combination of subclasses of these to customize the
+ * flavor of markdown parsed.
+ * 
+ * @see {@link custom.md} for details on subclassing
+ */
+class MDReader {
+	/**
+	 * Called before processing begins. `state.lines` is populated and the
+	 * line pointer `state.p` will be at `0`.
+	 *
+	 * Default implementation does nothing.
+	 */
+	public function preProcess(MDState $state) {}
 
-class MDUnderlinedHeadingReader extends MDReader {}
+	/**
+	 * Attempts to read an `MDBlockNode` subclass at the current line pointer
+	 * `state.p`. Only matches if the block pattern starts at the line pointer,
+	 * not elsewhere in the `state.lines` array. If a block is found, `state.p`
+	 * should be incremented to the next line _after_ the block structure and
+	 * a `MDBlockNode` subclass instance is returned. If no block is found,
+	 * returns `null`.
+	 *
+	 * Default implementation always returns `null`.
+	 */
+	public function readBlock(MDState $state): ?MDBlockNode { return null; }
 
-class MDHashHeadingReader extends MDReader {}
+	/**
+	 * Attempts to read an inline token from the beginning of `line`. Only the
+	 * start of the given `line` is considered. If a matching token is found, an
+	 * `MDToken` is returned. Otherwise `null` is returned.
+	 *
+	 * Default implementation always returns `null`.
+	 */
+	public function readToken(MDState $state, string $line): ?MDToken { return null; }
 
-class MDSubtextReader extends MDReader {}
+	/**
+	 * Attempts to find a pattern anywhere in `tokens` and perform a _single_
+	 * in-place substitution with one or more `MDNode` subclass instances.
+	 * If a substitution is performed, must return `true`, otherwise `false`.
+	 *
+	 * Default implementation always returns `false`.
+	 *
+	 * @param MDState $state
+	 * @param int $pass  what substitution pass this is, starting with 1
+	 * @param (MDToken|MDInlineNode)[] $tokens  mixed array of `MDToken` and `MDInlineNode` elements
+	 * @return bool  `true` if a substitution was performed, `false` if not
+	 */
+	public function substituteTokens(MDState $state, int $pass, array $tokens): bool { return false; }
 
-class MDBlockQuoteReader extends MDReader {}
+	/**
+	 * Called after all parsing has completed. An array `blocks` is passed of
+	 * all the top-level `MDBlockNode` elements in the document which this
+	 * method can traverse or alter in-place via `.splice` operations if
+	 * necessary.
+	 *
+	 * `MDNode.visitChildren` is useful for recursively looking for certain
+	 * `MDNode` instances. `MDNode.replaceNodes` is useful for swapping in
+	 * replacements.
+	 *
+	 * Default implementation does nothing.
+	 *
+	 * @param MDState $state
+	 * @param MDBlockNode[] $blocks
+	 */
+	public function postProcess(MDState $state, array $blocks) {}
 
-class _MDListReader extends MDReader {}
+	/**
+	 * Can be overridden to influence ordering of this reader with respect to
+	 * another during the block parsing phase. Return `-1` to be ordered before
+	 * the given reader, `1` to be ordered after it, or `0` for no preference.
+	 * Only return non-`0` values to resolve specific conflicts.
+	 *
+	 * Default implementation always returns `0` (no preference).
+	 *
+	 * @param MDReader $other
+	 * @return int  a negative, positive, or 0 value to be ordered before,
+	 *   after, or anwhere relative to `other`, respectively
+	 */
+	public function compareBlockOrdering(MDReader $other): int {
+		return 0;
+	}
 
-class MDUnorderedListReader extends _MDListReader {}
+	/**
+	 * Can be overridden to influence ordering of this reader with respect to
+	 * another during the tokenizing phase. Return `-1` to be ordered before
+	 * the given reader, `1` to be ordered after it, or `0` for no preference.
+	 * Only return non-`0` values to resolve specific conflicts.
+	 *
+	 * Default implementation always returns `0` (no preference).
+	 *
+	 * @param MDReader $other
+	 * @return int  a negative, positive, or 0 value to be ordered before,
+	 *   after, or anwhere relative to `other`, respectively
+	 */
+	public function compareTokenizeOrdering(MDReader $other): int {
+		return 0;
+	}
+
+	/**
+	 * Can be overridden to influence ordering of this reader with respect to
+	 * another during the substitution phase. Return `-1` to be ordered before
+	 * the given reader, `1` to be ordered after it, or `0` for no preference.
+	 * Only return non-`0` values to resolve specific conflicts.
+	 *
+	 * Readers are sorted within each substitution pass. All pass 1 readers are
+	 * processed first, then all pass 2 readers, etc. The number of passes this
+	 * reader participates in is dictated by `substitionPassCount`.
+	 *
+	 * Default implementation always returns `0` (no preference).
+	 *
+	 * @param MDReader $other
+	 * @param int $pass  substitution pass, with numbering starting at `1`
+	 * @return int  a negative, positive, or 0 value to be ordered before,
+	 *   after, or anwhere relative to `other`, respectively
+	 */
+	public function compareSubstituteOrdering(MDReader $other, int $pass): int {
+		return 0;
+	}
 
-class MDOrderedListReader extends _MDListReader {}
+	/**
+	 * How many substitution passes this reader requires. Substitution allows
+	 * all pass 1 readers to process first, then all pass 2 readers, etc.
+	 */
+	public function substitutionPassCount(): int { return 1; }
 
-class MDFencedCodeBlockReader extends MDReader {}
+	/**
+	 * For sorting readers with ordering preferences. The `compare` methods
+	 * don't have the properties of normal sorting compares so need to sort
+	 * differently.
+	 *
+	 * @param MDReader[] $arr  array to sort
+	 * @param callable $compareFn  comparison function, taking two array element
+	 *   arguments and returning -1, 0, or 1 for a < b, a == b, and a > b,
+	 *   respectively
+	 * @param callable $idFn  function for returning a unique hashable id for
+	 *   the array element
+	 * @return MDReader[]  sorted array
+	 */
+	private static function kahnTopologicalSort(array $arr, callable $compareFn, callable $idFn): array {
+		$graph = [];
+		$inDegrees = [];
+		$valuesById = [];
+
+		// Build the graph and compute in-degrees
+		foreach ($arr as $elem) {
+			$id = $idFn($elem);
+			$graph[$id] = [];
+			$inDegrees[$id] = 0;
+			$valuesById[$id] = $elem;
+		}
 
-class MDIndentedCodeBlockReader extends MDReader {}
+		for ($i = 0; $i < sizeof($arr); $i++) {
+			$elemA = $arr[$i];
+			$idA = $idFn($elemA);
+			for ($j = 0; $j < sizeof($arr); $j++) {
+				if ($i === $j) continue;
+				$elemB = $arr[$j];
+				$idB = $idFn($elemB);
+				$comparisonResult = $compareFn($elemA, $elemB);
+				if ($comparisonResult < 0) {
+					array_push($graph[$idA], push($idB));
+					$inDegrees[$idB]++;
+				} elseif ($comparisonResult > 0) {
+					array_push($graph[$idB], $idA);
+					$inDegrees[$idA]++;
+				}
+			}
+		}
 
-class MDHorizontalRuleReader extends MDReader {}
+		// Initialize the queue with zero-inDegree nodes
+		$queue = [];
+		foreach ($inDegrees as $elemId) {
+			if ($inDegrees[$elemId] === 0) {
+				array_push($queue, $elemId);
+			}
+		}
 
-class MDTableReader extends MDReader {}
+		// Process the queue and build the topological order list
+		$sorted = [];
+		while (sizeof($queue) > 0) {
+			$elemId = array_shift($queue);
+			array_push($sorted, $valuesById[$elemId]);
+			unset($valuesById[$elemId]);
+
+			foreach ($graph[$elemId] as $neighbor) {
+				$inDegrees[$neighbor]--;
+				if ($inDegrees[$neighbor] === 0) {
+					array_push($queue, $neighbor);
+				}
+			}
+		}
+		// Anything left over can go at the end. No ordering dependencies.
+		foreach ($valuesById as $elemId => $value) {
+			array_push($sorted, $value);
+		}
 
-class MDDefinitionListReader extends MDReader {}
+		return $sorted;
+	}
 
-class MDFootnoteReader extends MDReader {}
+	/**
+	 * Returns a sorted array of readers by their block priority preferences.
+	 *
+	 * @param MDReader[] $readers
+	 * @return MDReader[]  sorted readers
+	 */
+	public static function sortReaderForBlocks(array &$readers) {
+		$sorted = $readers;
+		return self::kahnTopologicalSort($sorted, function(MDReader $a, MDReader $b): int {
+			return $a->compareBlockOrdering($b);
+		}, fn($elem) => get_class($elem));
+	}
 
-class MDAbbreviationReader extends MDReader {}
+	/**
+	 * Returns a sorted array of readers by their tokenization priority preferences.
+	 *
+	 * @param MDReader[] $readers
+	 * @return MDReader[]  sorted readers
+	 */
+	public static function sortReadersForTokenizing(array $readers): array {
+		$sorted = $readers;
+		return self::kahnTopologicalSort($sorted, function(MDReader $a, MDReader $b): int {
+			return $a->compareTokenizeOrdering($b);
+		}, fn($elem) => get_class($elem));
+	}
 
-class MDParagraphReader extends MDReader {}
+	/**
+	 * Returns a sorted array of tuples (arrays) containing the substitution
+	 * pass number and reader instance, sorted by their substitution priority
+	 * preferences.
+	 *
+	 * For readers with `substitutionPassCount` > `1`, the same reader will
+	 * appear multiple times in the resulting array, one per pass.
+	 *
+	 * @param MDReader[] $readers
+	 * @return MDReader[]  sorted array of tuples with the pass number and
+	 *   reader instance in each
+	 */
+	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 ]);
+			}
+			$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 {
+				$aReader = $a[1];
+				$bReader = $b[1];
+				return $aReader->compareSubstituteOrdering($bReader, $pass);
+			}, fn($elem) => get_class($elem[1]));
+			$result = array_merge($result, $passResult);
+		}
+		return $result;
+	}
+}
+
+/**
+ * Reads markdown blocks for headings denoted with the underline syntax.
+ *
+ * Supports `MDTagModifier` suffixes.
+ */
+class MDUnderlinedHeadingReader extends MDReader {
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		if (!$state->hasLines(2)) return null;
+		$modifier;
+		$contentLine = trim($state->lines[$p++]);
+		[$contentLine, $modifier] = MDTagModifier.fromLine(contentLine, state);
+		$underLine = trim($state->lines[$p++]);
+		if ($contentLine == '') return null;
+		if (mb_eregi('^=+$', $underLine)) {
+			$state->p = $p;
+			$block = new MDHeadingNode(1, $state->inlineMarkdownToNodes($contentLine));
+			if ($modifier) $modifier->applyTo($block);
+			return $block;
+		}
+		if (mb_eregi('^\-+$', $underLine)) {
+			$state->p = $p;
+			$block = new MDHeadingNode(2, $state->inlineMarkdownToNodes($contentLine));
+			if ($modifier) $modifier->applyTo($block);
+			return $block;
+		}
+		return null;
+	}
+}
+
+/**
+ * Reads markdown blocks for headings denoted with hash marks. Heading levels 1
+ * to 6 are supported.
+ *
+ * Supports `MDTagModifier` suffixes.
+ */
+class MDHashHeadingReader extends MDReader {
+	private static $hashHeadingRegex = '^(#{1,6})\\s*([^#].*?)\\s*\\#*\\s*$';  // 1=hashes, 2=content
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		$line = $state->lines[$p++];
+		$modifier;
+		[$line, $modifier] = MDTagModifier::fromLine($line, $state);
+		if (!mb_eregi(self::hashHeadingRegex, $line, $groups)) return null;
+		$state->p = $p;
+		$level = mb_strlen($groups[1]);
+		$content = $groups[2];
+		$block = new MDHeadingNode($level, $state->inlineMarkdownToNodes($content));
+		if ($modifier) $modifier->applyTo($block);
+		return $block;
+	}
+}
+
+/**
+ * Reads subtext blocks. Subtext is smaller, fainter text for things like
+ * disclaimers or sources.
+ *
+ * Supports `MDTagModifier` suffixes.
+ */
+class MDSubtextReader extends MDReader {
+	private static $subtextRegex = '^\\-#\\s*(.*?)\\s*$';  // 1=content
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		$line = $state->lines[$p++];
+		$modifier;
+		[$line, $modifier] = MDTagModifier::fromLine($line, $state);
+		if (!mb_eregi(self::subtextRegex, $line, $groups)) return null;
+		$state->p = $p;
+		$content = $groups[1];
+		$block = new MDSubtextNode($state->inlineMarkdownToNodes($content));
+		if ($modifier) $modifier->applyTo($block);
+		return $block;
+	}
+
+	public function compareBlockOrdering(MDReader $other): int {
+		if ($other instanceof MDUnorderedListReader) {
+			return -1;
+		}
+		return 0;
+	}
+}
+
+/**
+ * Reads markdown blocks for blockquoted text.
+ */
+class MDBlockQuoteReader extends MDReader {
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$blockquoteLines = [];
+		$p = $state->p;
+		while ($p < sizeof($state->lines)) {
+			$line = $state->lines[$p++];
+			if (str_starts_with($line, ">")) {
+				array_push($blockquoteLines, $line);
+			} else {
+				break;
+			}
+		}
+		if (sizeof($blockquoteLines) == 0) return null;
+		$contentLines = array_map(fn($line) => mb_eregi_replace('^ {0,3}\\t?', '', mb_substr($line, 1)), $blockquoteLines);
+		$substate = $state->copy($contentLines);
+		$quotedBlocks = $substate->readBlocks();
+		$state->p = $p;
+		return new MDBlockquoteNode($quotedBlocks);
+	}
+}
+
+/**
+ * Internal abstract base class for ordered and unordered lists.
+ */
+class _MDListReader extends MDReader {
+	private static function readItemLines(MDState $state, int $firstLineStartPos): array {
+		$p = $state->p;
+		$lines = [];
+		$seenBlankLine = false;
+		$stripTrailingBlankLines = true;
+		while ($state->hasLines(1, $p)) {
+			$isFirstLine = ($p == $state->p);
+			$line = $state->lines[$p++];
+			if ($isFirstLine) {
+				$line = mb_substr($line, $firstLineStartPos);
+			}
+			if (mb_eregi('^(?:\\*|\\+|\\-|\\d+\\.)\\s+', $line)) {
+				// Found next list item
+				$stripTrailingBlankLines = false; // because this signals extra spacing intended
+				break;
+			}
+			$isBlankLine = trim($line) == '';
+			$isIndented = mb_eregi('^\\s+\\S', $line);
+			if ($isBlankLine) {
+				$seenBlankLine = true;
+			} elseif (!$isIndented && $seenBlankLine) {
+				// Post-list content
+				break;
+			}
+			array_push($lines, $line);
+		}
+		$lines = MDUtils::withoutTrailingBlankLines($lines);
+		return MDUtils::stripIndent($lines);
+	}
+
+	protected function readListItemContent(MDState $state, int $firstLineStartPos): MDBlockNode {
+		$itemLines = $this->readItemLines($state, $firstLineStartPos);
+		$state->p += max(sizeof($itemLines), 1);
+
+		if (sizeof($itemLines) == 1) {
+			return $state->inlineMarkdownToNode($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);
+		}
+
+		// 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];
+			if (mb_eregi('^(?:\\*|\\-|\\+|\\d+\\.)\\s+', $line)) {
+				// Nested list found
+				$firstBlock = $state->inlineMarkdownToNode(implode("\n", array_slice($itemLines, 0, $p)));
+				$substate = $state->copy(array_slice($itemLines, $p));
+				$blocks = $substate->readBlocks();
+				return array_merge([ $firstBlock, $blocks ]);
+			}
+		}
+
+		// Ok, give up and just do a standard block read
+		{
+			$substate = $state->copy($itemLines);
+			$blocks = $substate->readBlocks();
+			return (sizeof($blocks) == 1) ? $blocks[0] : new MDNode($blocks);
+		}
+	}
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		throw new Error(`Abstract readBlock must be overridden in ${this.constructor.name}`);
+	}
+}
+
+/**
+ * Block reader for unordered (bulleted) lists.
+ */
+class MDUnorderedListReader extends _MDListReader {
+	private static string $unorderedListRegex = '^([\\*\\+\\-]\\s+)(.*)$';  // 1=bullet, 2=content
+
+	private function readUnorderedListItem(MDState $state): ?MDListItemNode {
+		$p = $state->p;
+		$line = $state->lines[$p];
+		if (!mb_eregi(self::$unorderedListRegex, $line, $groups)) return null;
+		$firstLineOffset = mb_strlen($groups[1]);
+		return new MDListItemNode($this->readListItemContent($state, $firstLineOffset));
+	}
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$items = [];
+		$item = null;
+		do {
+			$item = $this->readUnorderedListItem($state);
+			if ($item) array_push($items, $item);
+		} while ($item);
+		if (sizeof($items) == 0) return null;
+		return new MDUnorderedListNode($items);
+	}
+}
+
+/**
+ * Block reader for ordered (numbered) lists. The number of the first item is
+ * used to begin counting. The subsequent items increase by 1, regardless of
+ * their value.
+ */
+class MDOrderedListReader extends _MDListReader {
+	private static string $orderedListRegex = '^(\\d+)(\\.\\s+)(.*)$';  // 1=number, 2=dot, 3=content
+
+	private function readOrderedListItem(MDState $state): ?MDListItemNode {
+		$p = $state->p;
+		$line = $state->lines[$p];
+		if (!mb_eregi(self::$orderedListRegex, $line, $groups)) return null;
+		$ordinal = intval($groups[1]);
+		$firstLineOffset = mb_strlen($groups[1]) + mb_strlen($groups[2]);
+		return new MDListItemNode($this->readListItemContent($state, $firstLineOffset), $ordinal);
+	}
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$items = [];
+		$item = null;
+		do {
+			$item = $this->readOrderedListItem($state);
+			if ($item) array_push($items, $item);
+		} while ($item);
+		if (sizeof($items)) return null;
+		return new MDOrderedListNode($items, $items[0]->ordinal);
+	}
+}
+
+/**
+ * Block reader for code blocks denoted by pairs of triple tickmarks. If
+ * a programming language name, _xyz_, immediately follows the backticks, a
+ * `language-xyz` CSS class will be added to the resulting `<code>`
+ * element.
+ *
+ * Supports `MDTagModifier` suffix.
+ */
+class MDFencedCodeBlockReader extends MDReader {
+	public function readBlock(MDState $state): ?MDBlockNode {
+		if (!$state->hasLines(2)) 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;
+		$language = mb_strlen($groups[1]) > 0 ? $groups[1] : null;
+		$codeLines = [];
+		while ($state->hasLines(1, $p)) {
+			$line = $state->lines[$p++];
+			if (trim($line) == '```') {
+				$state->p = $p;
+				$block = new MDCodeBlockNode(implode("\n", $codeLines), $language);
+				if ($modifier) $modifier->applyTo($block);
+				return $block;
+			}
+			array_push($codeLines, $line);
+		}
+		return null;
+	}
+}
+
+/**
+ * Block reader for code blocks denoted by indenting text.
+ */
+class MDIndentedCodeBlockReader extends MDReader {
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		$codeLines = [];
+		while ($state->hasLines(1, $p)) {
+			$line = $state->lines[$p++];
+			if (MDUtils::countIndents($line, true) < 1) {
+				$p--;
+				break;
+			}
+			array_push($codeLines, MDUtils::stripIndent($line));
+		}
+		if (sizeof($codeLines) == 0) return null;
+		$state->p = $p;
+		return new MDCodeBlockNode(implode("\n", $codeLines));
+	}
+}
+
+/**
+ * Block reader for horizontal rules. Composed of three or more hypens or
+ * asterisks on a line by themselves, with or without intermediate whitespace.
+ */
+class MDHorizontalRuleReader extends MDReader {
+	private static string $horizontalRuleRegex = '^\\s*(?:\\-(?:\\s*\\-){2,}|\\*(?:\\s*\\*){2,})\\s*$';
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		$line = $state->lines[$p++];
+		[$line, $modifier] = MDTagModifier::fromLine($line, $state);
+		if (mb_eregi(self::horizontalRuleRegex, $line)) {
+			$state->p = $p;
+			$block = new MDHorizontalRuleNode();
+			if ($modifier) $modifier->applyTo($block);
+			return $block;
+		}
+		return null;
+	}
+
+	public function compareBlockOrdering(MDReader $other): int {
+		if ($other instanceof MDUnorderedListReader) {
+			return -1;
+		}
+		return 0;
+	}
+}
+
+/**
+ * Block reader for tables.
+ *
+ * Supports `MDTagModifier` suffix.
+ */
+class MDTableReader extends MDReader {
+	private function readTableRow(MDState $state, bool $isHeader): ?MDTableRowNode {
+		if (!$state->hasLines(1)) return null;
+		$p = $state->p;
+		$line = MDTagModifier::strip(trim($state->lines[$p++]));
+		if (!mb_eregi('.*\\|.*', $line)) return null;
+		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) {
+			$content = $state->inlineMarkdownToNode(trim($token));
+			return $isHeader ? new MDTableHeaderCellNode($content) : new MDTableCellNode($content);
+		}, $cellTokens);
+		$state->p = $p;
+		return new MDTableRowNode($cells);
+	}
+
+	/**
+	 * @param string $line
+	 * @return string[]
+	 */
+	private function parseColumnAlignments(string $line): array {
+		$line = trim($line);
+		if (str_starts_with($line, '|')) $line = mb_substr($line, 1);
+		if (str_ends_with($line, '|')) $line = mb_substr($line, 0, mb_strlen($line) - 1);
+		return array_map(function($token) {
+			if (str_starts_with($token, ':')) {
+				if (str_ends_with($token, ':')) {
+					return 'center';
+				}
+				return 'left';
+			} elseif (str_ends_with($token, ':')) {
+				return 'right';
+			}
+			return null;
+		}, mb_split('\\s*\\|\\s*', $line));
+	}
+
+	private static string $tableDividerRegex = '^\\s*[|]?\\s*(?:[:]?-+[:]?)(?:\\s*\\|\\s*[:]?-+[:]?)*\\s*[|]?\\s*$';
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		if (!$state->hasLines(2)) return null;
+		$startP = $state->p;
+		$firstLine = $state->lines[$startP];
+		$modifier = MDTagModifier::fromLine($firstLine, $state)[1];
+		$headerRow = $this->readTableRow($state, true);
+		if ($headerRow === null) {
+			$state->p = $startP;
+			return null;
+		}
+		$dividerLine = $state->lines[$state->p++];
+		if (!mb_eregi(self::$tableDividerRegex, $dividerLine, $dividerGroups)) {
+			$state->p = $startP;
+			return null;
+		}
+		$columnAlignments = $this->parseColumnAlignments($dividerLine);
+		$bodyRows = [];
+		while ($state->hasLines(1)) {
+			$row = $this->readTableRow($state, false);
+			if ($row === null) break;
+			array_push($bodyRows, $row);
+		}
+		$table = new MDTableNode($headerRow, $bodyRows);
+		$table->columnAlignments = $columnAlignments;
+		if ($modifier) $modifier->applyTo($table);
+		return $table;
+	}
+}
+
+/**
+ * Block reader for definition lists. Definitions go directly under terms starting
+ * with a colon.
+ */
+class MDDefinitionListReader extends MDReader {
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		$groups;
+		$termCount = 0;
+		$definitionCount = 0;
+		$defLines = [];
+		while ($state->hasLines(1, $p)) {
+			$line = $state->lines[$p++];
+			if (trim($line) === '') {
+				break;
+			}
+			if (mb_eregi('^\\s+', $line)) {
+				if (sizeof($defLines) == 0) return null;
+				$defLines[sizeof($defLines) - 1] .= "\n" . $line;
+			} elseif (mb_eregi('^:\\s+', $line)) {
+				array_push($defLines, $line);
+				$definitionCount++;
+			} else {
+				array_push($defLines, $line);
+				$termCount++;
+			}
+		}
+		if ($termCount == 0 || $definitionCount == 0) return null;
+		$blocks = array_map(function($line) {
+			if (mb_eregi('^:\\s+(.*?)$', $line)) {
+				return new MDDefinitionListDefinitionNode($state->inlineMarkdownToNodes($groups[1]));
+			} else {
+				return new MDDefinitionListTermNode($state->inlineMarkdownToNodes($line));
+			}
+		}, $defLines);
+		$state->p = $p;
+		return new MDDefinitionListNode($blocks);
+	}
+}
+
+/**
+ * Block reader for defining footnote contents. Footnotes can be defined anywhere
+ * in the document but will always be rendered at the end of a page or end of
+ * the document.
+ */
+class MDFootnoteReader extends MDReader {
+	private static string $footnoteWithTitleRegex = '^\\[\\^([^\\s\\[\\]]+?)\\s+"(.*?)"\\]';  // 1=symbol, 2=title
+	private static string $footnoteRegex = '^\\[\\^([^\\s\\[\\]]+?)\\]';  // 1=symbol
+
+	/**
+	 * @param MDState $state
+	 * @param string $symbol
+	 * @param MDNode[] $footnote
+	 */
+	private function defineFootnote(MDState $state, string $symbol, array $footnote) {
+		$footnotes = $state->root()['footnotes'] ?? [];
+		$footnotes[$symbol] = $footnote;
+		$state->root()['footnotes'] = $footnotes;
+	}
+
+	private function registerUniqueInstance(MDState $state, string $symbol, int $unique) {
+		$footnoteInstances = $state->root()['footnoteInstances'];
+		$instances = $footnoteInstances[$symbol] ?? [];
+		array_push($instances, $unique);
+		$footnoteInstances[$symbol] = $instances;
+	}
+
+	private function idForFootnoteSymbol(MDState $state, string $symbol): int {
+		$footnoteIds = $state->root()['footnoteIds'];
+		$existing = $footnoteIds[$symbol];
+		if ($existing) return $existing;
+		$nextFootnoteId = $state->root()['nextFootnoteId'];
+		$id = $nextFootnoteId++;
+		$footnoteIds[$symbol] = $id;
+		$state->root()['nextFootnoteId'] = $nextFootnoteId;
+		return $id;
+	}
+
+	public function preProcess(MDState $state) {
+		$state->root()['footnoteInstances'] = [];
+		$state->root()['footnotes'] = [];
+		$state->root()['footnoteIds'] = [];
+		$state->root()['nextFootnoteId'] = 1;
+	}
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		if (!mb_eregi('^\\s*\\[\\^\\s*([^\\]]+)\\s*\\]:\\s+(.*)\\s*$', $state->lines[$p++], $groups)) return null;
+		$symbol = $groups[1];
+		$def = $groups[2];
+		while ($state->hasLines(1, $p)) {
+			$line = $state->lines[$p++];
+			if (mb_eregi('^\\s+', $line)) {
+				$def += "\n" . $line;
+			} else {
+				$p--;
+				break;
+			}
+		}
+		$content = $state->inlineMarkdownToNodes($def);
+		$this->defineFootnote($state, $symbol, $content);
+		$state->p = $p;
+		return new MDNode(); // empty
+	}
+
+	public function readToken(MDState $state, string $line): ?MDToken {
+		$groups;
+		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)) {
+			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 ])) {
+			$symbol = $match->tokens[0]->content;
+			array_splice($tokens, $match->index, 1, new MDFootnoteNode($symbol));
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @param {MDState} state
+	 * @param {MDBlockNode[]} blocks
+	 */
+	public function postProcess(MDState $state, array $blocks) {
+		$nextOccurrenceId = 1;
+		foreach ($blocks as $block) {
+			$block->visitChildren(function($node) use (&$nextOccurrenceId) {
+				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);
+			});
+		}
+		if (sizeof($state->footnotes) == 0) return;
+		array_push($blocks, new MDFootnoteListNode());
+	}
+
+	public function compareBlockOrdering(MDReader $other): int {
+		if ($other instanceof MDLinkReader || $other instanceof MDImageReader) {
+			return -1;
+		}
+		return 0;
+	}
+
+	public function compareTokenizeOrdering(MDReader $other): int {
+		if ($other instanceof MDLinkReader || $other instanceof MDImageReader) {
+			return -1;
+		}
+		return 0;
+	}
+
+	public function compareSubstituteOrdering(MDReader $other, int $pass): int {
+		if ($other instanceof MDLinkReader || $other instanceof MDImageReader) {
+			return -1;
+		}
+		return 0;
+	}
+}
+
+/**
+ * Block reader for abbreviation definitions. Anywhere the abbreviation appears
+ * in plain text will have its definition available when hovering over it.
+ * Definitions can appear anywhere in the document. Their content should only
+ * contain simple text, not markdown.
+ */
+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;
+	}
+
+	public function preProcess(MDState $state) {
+		$state->root()['abbreviations'] = [];
+		$state->root()['abbreviationRegexes'] = [];
+	}
+
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$p = $state->p;
+		$line = $state->lines[$p++];
+		if (!mb_eregi('^\\s*\\*\\[([^\\]]+?)\\]:\\s+(.*?)\\s*$', $line, $groups)) return null;
+		$abbrev = $groups[1];
+		$def = $groups[2];
+		$this->defineAbbreviation($state, $abbrev, $def);
+		$state->p = $p;
+		return new MDNode(); // empty
+	}
+
+	/**
+	 * @param MDState $state
+	 * @param MDNode[] $blocks
+	 */
+	public function postProcess(MDState $state, array $blocks) {
+		$abbreviations = $state->root()['abbreviations'];
+		$regexes = $state->root()['abbreviationRegexes'];
+		MDNode::replaceNodes($state, $blocks, function($original) {
+			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) {
+					$index = strpos($text, $abbreviation);
+					if ($index === false) break;
+					$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 ]);
+					$i = -1; // start over
+					$changed = true;
+					break;
+				}
+			}
+			if (!$changed) return null;
+			$nodes = array_map(fn($elem) => is_string($elem) ? new MDTextNode($elem) : $elem);
+			return new MDNode($nodes);
+		});
+	}
+}
+
+/**
+ * Block reader for simple paragraphs. Paragraphs are separated by a blank (or
+ * whitespace-only) line. This reader is prioritized after every other reader
+ * since there is no distinguishing syntax.
+ */
+class MDParagraphReader extends MDReader {
+	public function readBlock(MDState $state): ?MDBlockNode {
+		$paragraphLines = [];
+		$p = $state->p;
+		while ($state->hasLines(1, $p)) {
+			$line = $state->lines[$p++];
+			if (trim($line) === '') {
+				break;
+			}
+			array_push($paragraphLines, $line);
+		}
+		if ($state->p == 0 && $p >= sizeof($state->lines)) {
+			// If it's the entire document don't wrap it in a paragraph
+			return null;
+		}
+		if (sizeof($paragraphLines) > 0) {
+			$state->p = $p;
+			$content = implode("\n", $paragraphLines);
+			return new MDParagraphNode($state->inlineMarkdownToNodes($content));
+		}
+		return null;
+	}
+
+	public function compareBlockOrdering(MDReader $other): int {
+		return 1; // always dead last
+	}
+}
 
 class MDSimplePairInlineReader extends MDReader {}