Readers now prioritized with compare methods instead of numbers

js/markdown.js

 	/** @type {MDState|null} */
 	#parent = null;
 
+	/** @type {MDConfig} */
+	config;
+
 	/**
-	 * Tuples of `priority:number` and `MDReader` sorted by `blockPriority`.
-	 * @type {Array}
+	 * Array of `MDReader`s sorted by block reading priority.
+	 * @type {MDReader[]}
 	 */
 	#readersByBlockPriority = [];
 
 	/**
-	 * Tuples of `priority:number` and `MDReader` sorted by `tokenizePriority`.
-	 * @type {Array}
+	 * Array of `MDReader`s sorted by tokenization priority.
+	 * @type {MDReader[]}
 	 */
 	#readersByTokenPriority = [];
 
 	/**
-	 * Tuples of `priority:number` and `MDReader` sorted by `substitutePriority`.
+	 * Tuples of `pass:number` and `MDReader` sorted substitution priority.
 	 * @type {Array}
 	 */
 	#readersBySubstitutePriority = [];
 
 	/**
 	 * @param {string[]} lines - lines of markdown text
-	 * @param {Array} readersByBlockPriority - tuple arrays of priority and MDReader
-	 * @param {Array} readersByTokenPriority - tuple arrays of priority and MDReader
+	 * @param {MDConfig} config
+	 * @param {MDReader[]} readersByBlockPriority
+	 * @param {MDReader[]} readersByTokenPriority
 	 * @param {Array} readersBySubstitutePriority - tuple arrays of priority and MDReader
 	 */
 	constructor(lines,
+		config=null,
 		readersByBlockPriority=null,
 		readersByTokenPriority=null,
 		readersBySubstitutePriority=null) {
 		this.#lines = lines;
+		this.config = config;
 		this.#readersByBlockPriority = readersByBlockPriority
 		this.#readersByTokenPriority = readersByTokenPriority
 		this.#readersBySubstitutePriority = readersBySubstitutePriority
 	copy(lines) {
 		let cp = new MDState(lines);
 		cp.#parent = this;
+		cp.config = this.config;
 		return cp;
 	}
 
 			this.p++;
 		}
 		if (!this.hasLines(1)) return null;
-		for (const tuple of this.root.#readersByBlockPriority) {
-			var reader = tuple[1];
+		for (const reader of this.root.#readersByBlockPriority) {
 			const startP = this.p;
 			const block = reader.readBlock(this);
 			if (block) {
 				continue;
 			}
 			var found = false;
-			for (const readerTuple of this.root.#readersByTokenPriority) {
-				/** @type {number} */
-				const priority = readerTuple[0];
-				/** @type {MDReader} */
-				const reader = readerTuple[1];
+			for (const reader of this.root.#readersByTokenPriority) {
 				const token = reader.readToken(this, remainder);
 				if (token === null) continue;
 				if (token === undefined) {
 			anyChanges = false;
 			for (const readerTuple of this.root.#readersBySubstitutePriority) {
 				/** @type {number} */
-				const priority = readerTuple[0];
+				const pass = readerTuple[0];
 				/** @type {MDReader} */
 				const reader = readerTuple[1];
-				const changed = reader.substituteTokens(this, priority, nodes);
+				const changed = reader.substituteTokens(this, pass, nodes);
 				if (!changed) continue;
 				anyChanges = true;
 				break;
  * any combination of these.
  * 1. **Blocks** - Processing an array of lines to find block-level structures,
  *    such as paragraphs, lists, tables, blockquotes, etc. and converting them
- *    into block-level `MDNode`s.
+ *    into block-level `MDNode`s. Override `readBlock`.
  * 2. **Inline tokens** - Carving up single lines of markdown into tokens for
  *    inline formatting, such as strong, emphasis, links, images, etc.
+ *    Override `readToken`.
  * 3. **Inline substitution** - Finding patterns of tokens and substituting them
- *    with `MDNode`s.
+ *    with `MDNode`s. Override `substituteTokens`. (`readToken` and
+ *   `substituteTokens` are usually overridden together.)
  * 
- * Each parsing phase consults each registered reader, checking if its
- * recognized syntax is located in a given place in the markdown. The order
- * the readers are tested is affected by priority values for each phase. This
- * allows syntactic ambiguities to be resolved in a consistent way (e.g.
- * `\*\*strong\*\*` and `\*emphasis\*` using similar syntax).
+ * Readers may have similar, ambiguous syntax (such as `**strong**` and
+ * `*emphasis*`) and need to process in a certain order. This can be done by
+ * overriding the `compare` methods to influence which readers to put before
+ * others in each phase. Furthermore, substitution can occur in multiple passes
+ * if necessary. These two mechanisms can be used to resolve ambiguities.
  */
 class MDReader {
 	/**
-	 * Block reading priority for this reader. Priority is a unitless relative
-	 * value used for sorting readers in the block reading process. Core readers
-	 * use a range of 0 to 100 but any value is permitted. Generally, more
-	 * distinctive, unambiguous block syntax should be prioritized first (low
-	 * priority number), while more general block syntax like paragraphs should
-	 * be prioritized last (high priority number). If the reader has no block-level
-	 * elements, can be set to `null` to skip during that phase.
-	 *
-	 * @type {number|null}
-	 */
-	get blockPriority() { return this.#blockPriority; };
-	#blockPriority;
-
-	/**
-	 * Inline tokenization priority for this reader. Priority is a unitless
-	 * relative value used for sorting readers in the tokenization process.
-	 * Core readers use a range of 0 to 100 but any value is permitted.
-	 * Generally, more distinctive, unambiguous token formats should be
-	 * prioritized first (low priority number), while more general, ambiguous
-	 * tokens should be prioritized last (high priority number). If the reader
-	 * has no inline-level elements, can be set to `null` to skip that phase.
-	 *
-	 * @type {number|null}
-	 */
-	get tokenizePriority() { return this.#tokenizePriority; };
-	#tokenizePriority;
-
-	/**
-	 * Inline token substitution priority/priorities for this reader. Priority
-	 * is a unitless relative value or values for sorting readers in the
-	 * tokenization process. Core readers use a range of 0 to 100 but any value
-	 * is permitted. Generally, more distinctive, unambiguous patterns should
-	 * be prioritized first (low priority number), while more general, ambiguous
-	 * patterns should be prioritized last (high priority number).
-	 * 
-	 * This property can be an array of numbers, in monotonically increasing
-	 * order. In that case, the same reader will occur 2 or more times in the
-	 * prioritization list. This can be useful when a reader handles multiple
-	 * patterns of differing priority. When `substituteTokens` is called, the
-	 * current priority is passed to differentiate which pass is being done.
-	 * 
-	 * If the reader has no inline-level elements, can be set to `null` to skip
-	 * that phase.
-	 *
-	 * @type {number|number[]|null}
-	 */
-	get substitutePriority() { return this.#substitutePriority; };
-	#substitutePriority;
-
-	constructor(blockPriority=100, tokenizePriority=100, substitutePriority=100) {
-		this.#blockPriority = blockPriority;
-		this.#tokenizePriority = tokenizePriority;
-		this.#substitutePriority = substitutePriority;
-	}
-
-	/**
 	 * Called before processing begins. `state.lines` is populated and the
 	 * line pointer `state.p` will be at `0`. Default implementation does nothing.
 	 *
 	 * with one or more `MDNode` subclass instances.
 	 * 
 	 * @param {MDState} state
-	 * @param {number} priority
+	 * @param {number} pass - what substitution pass this is, starting with 1
 	 * @param {Array} tokens - mixed array of `MDToken` and `MDInlineNode` elements
 	 * @returns {boolean} `true` if a substitution was performed, `false` if not
 	 */
-	substituteTokens(state, priority, tokens) { return false; }
+	substituteTokens(state, pass, tokens) { return false; }
 
 	/**
 	 * Called after all parsing has completed. An array `blocks` is passed of all
 	 * @param {MDBlockNode[]} blocks
 	 */
 	postProcess(state, blocks) {}
+
+	/**
+	 * @param {MDReader} other
+	 * @returns {number} -1 if this should be before other, 0 if the same or don't care, 1 if this should be after other
+	 */
+	compareBlockOrdering(other) {
+		return 0;
+	}
+
+	/**
+	 * @param {MDReader} other
+	 * @returns {number}
+	 */
+	compareTokenizeOrdering(other) {
+		return 0;
+	}
+
+	/**
+	 * @param {MDReader} other
+	 * @param {number} pass
+	 * @returns {number}
+	 */
+	compareSubstituteOrdering(other, pass) {
+		return 0;
+	}
+
+	get substitutionPassCount() { return 1; }
+
+	/**
+	 * 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 {function} compareFn - comparison function, taking two array element
+	 *   arguments and returning -1, 0, or 1 for a < b, a == b, and a > b,
+	 *   respectively
+	 * @param {function} idFn - function for returning a unique hashable id for
+	 *   the array element
+	 * @returns {MDReader[]} sorted array
+	 */
+	static #kahnTopologicalSort(arr, compareFn, idFn) {
+		const graph = {};
+		const inDegrees = {};
+		const valuesById = {};
+	
+		// Build the graph and compute in-degrees
+		for (const elem of arr) {
+			const id = idFn(elem);
+			graph[id] = [];
+			inDegrees[id] = 0;
+			valuesById[id] = elem;
+		}
+	
+		for (let i = 0; i < arr.length; i++) {
+			const elemA = arr[i];
+			const idA = idFn(elemA);
+			for (let j = 0; j < arr.length; j++) {
+				if (i === j) continue;
+				const elemB = arr[j];
+				const idB = idFn(elemB);
+				const comparisonResult = compareFn(elemA, elemB);
+				if (comparisonResult < 0) {
+					graph[idA].push(idB);
+					inDegrees[idB]++;
+				} else if (comparisonResult > 0) {
+					graph[idB].push(idA);
+					inDegrees[idA]++;
+				}
+			}
+		}
+	
+		// Initialize the queue with zero-inDegree nodes
+		const queue = [];
+		for (const elemId in inDegrees) {
+			if (inDegrees[elemId] === 0) {
+				queue.push(elemId);
+			}
+		}
+	
+		// Process the queue and build the topological order list
+		const sorted = [];
+		while (queue.length > 0) {
+			const elemId = queue.shift();
+			sorted.push(valuesById[elemId]);
+			delete valuesById[elemId];
+	
+			for (const neighbor of graph[elemId]) {
+				inDegrees[neighbor]--;
+				if (inDegrees[neighbor] === 0) {
+					queue.push(neighbor);
+				}
+			}
+		}
+		// Anything left over can go at the end. No ordering dependencies.
+		for (const elemId in valuesById) {
+			sorted.push(valuesById[elemId]);
+		}
+	
+		return sorted;
+	}
+
+	/**
+	 * @param {MDReader[]} readers
+	 * @returns {MDReader[]}
+	 */
+	static sortReaderForBlocks(readers) {
+		const sorted = readers.slice();
+		return MDReader.#kahnTopologicalSort(sorted, (a, b) => {
+			return a.compareBlockOrdering(b);
+			// if (ab != 0) return ab;
+			// return -b.compareBlockOrdering(a);
+		}, (elem) => elem.constructor.name);
+	}
+
+	/**
+	 * @param {MDReader[]} readers
+	 * @returns {MDReader[]}
+	 */
+	static sortReadersForTokenizing(readers) {
+		const sorted = readers.slice();
+		return MDReader.#kahnTopologicalSort(sorted, (a, b) => {
+			return a.compareTokenizeOrdering(b);
+			// if (ab != 0) return ab;
+			// return -b.compareTokenizeOrdering(a);
+		}, (elem) => elem.constructor.name);
+	}
+
+	/**
+	 * @param {MDReader[]} readers
+	 * @returns {MDReader[]}
+	 */
+	static sortReadersForSubstitution(readers) {
+		var tuples = [];
+		var maxPass = 1;
+		for (const reader of readers) {
+			const passCount = reader.substitutionPassCount;
+			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++) {
+			var readersThisPass = tuples.filter((tup) => tup[0] == pass);
+			const passResult = MDReader.#kahnTopologicalSort(readersThisPass, (a, b) => {
+				const aReader = a[1];
+				const bReader = b[1];
+				return aReader.compareSubstituteOrdering(bReader, pass);
+			}, (elem) => `${elem[1].constructor.name}:${elem[0]}`);
+			result = result.concat(passResult);
+		}
+		return result;
+	}
 }
 
 /**
 		if (modifier) modifier.applyTo(block);
 		return block;
 	}
+
+	compareBlockOrdering(other) {
+		if (other instanceof MDUnorderedListReader) {
+			return -1;
+		}
+		return 0;
+	}
 }
 
 /**
 		}
 		return null;
 	}
+
+	compareBlockOrdering(other) {
+		if (other instanceof MDUnorderedListReader) {
+			return -1;
+		}
+		return 0;
+	}
 }
 
 /**
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
+	substituteTokens(state, pass, tokens) {
 		var match;
 		if (match = MDToken.findFirstTokens(tokens, [ MDTokenType.Footnote ])) {
 			let symbol = match.tokens[0].content;
 		if (Object.keys(state.footnotes).length == 0) return;
 		blocks.push(new MDFootnoteListNode());
 	}
+
+	compareBlockOrdering(other) {
+		if (other instanceof MDLinkReader || other instanceof MDImageReader) {
+			return -1;
+		}
+		return 0;
+	}
+
+	compareTokenizeOrdering(other) {
+		if (other instanceof MDLinkReader || other instanceof MDImageReader) {
+			return -1;
+		}
+		return 0;
+	}
+
+	compareSubstituteOrdering(other, pass) {
+		if (other instanceof MDLinkReader || other instanceof MDImageReader) {
+			return -1;
+		}
+		return 0;
+	}
 }
 
 /**
 
 /**
  * Block reader for simple paragraphs. Paragraphs are separated by a blank (or
- * whitespace-only) line. This reader should be prioritized last since there
- * is no distinguishing syntax.
- * 
- * Example:
- * 
- * > ```markdown
- * > Lorem ipsum dolor
- * > sit amet. This is all one paragraph.
- * >
- * > Beginning of a new paragraph.
- * > ```
+ * whitespace-only) line. This reader is prioritized after every other reader
+ * since there is no distinguishing syntax.
  */
 class MDParagraphReader extends MDReader {
 	readBlock(state) {
 		}
 		return null;
 	}
+
+	compareBlockOrdering(other) {
+		return 1; // always dead last
+	}
 }
 
 /**
  * around some content.
  */
 class MDSimplePairInlineReader extends MDReader {
+	get substitutionPassCount() { return 4; }
+
 	/**
 	 * Attempts a substitution of a matched pair of delimiting token types.
 	 * If successful, the substitution is performed on `tokens` and `true` is
 	 * returned, otherwise `false` is returned and the array is untouched.
 	 * 
-	 * If multiple `substitutePriority` values are specified, the first pass
+	 * If `this.substitutionPassCount` is greater than 1, the first pass
 	 * will reject matches with the delimiting character inside the content
-	 * tokens. If a single `substitutePriority` is given or a subsequent pass
-	 * is performed with multiple values any contents will be accepted.
+	 * tokens. If the reader uses a single pass or a subsequent pass is performed
+	 * with multiple pass any contents will be accepted.
 	 * 
 	 * @param {MDState} state
-	 * @param {number} priority
+	 * @param {number} pass
 	 * @param {MDToken[]} tokens
 	 * @param {class} nodeClass
 	 * @param {MDTokenType} delimiter
 	 * @param {number} count - how many times the token is repeated to form the delimiter
 	 * @returns {boolean} `true` if substitution performed, `false` if not
 	 */
-	attemptPair(state, priority, tokens, nodeClass, delimiter, count=1, plaintext=false) {
+	attemptPair(state, pass, tokens, nodeClass, delimiter, count=1, plaintext=false) {
+		// We do four passes. #1: doubles without inner tokens, #2: singles
+		// without inner tokens, #3: doubles with paired inner tokens,
+		// #4: singles with paired inner tokens
+		if (count == 1 && pass != 2 && pass != 4) return;
+		if (count == 2 && pass != 1 && pass != 3) return;
 		let delimiters = Array(count).fill(delimiter);
-		let firstPassPriority = (this.substitutePriority instanceof Array) ? this.substitutePriority[0] : null;
+		const isFirstOfMultiplePasses = this.substitutionPassCount > 1 && pass == 1;
 		let match = MDToken.findPairedTokens(tokens, delimiters, delimiters, function(content) {
 			const firstType = content[0] instanceof MDToken ? content[0].type : null;
 			const lastType = content[content.length - 1] instanceof MDToken ? content[content.length - 1].type : null;
 			if (firstType == MDTokenType.Whitespace) return false;
 			if (lastType == MDTokenType.Whitespace) return false;
-			if (priority == firstPassPriority) {
+			for (const token of content) {
+				// Don't allow nesting
+				if (token.constructor == nodeClass) return false;
+			}
+			if (isFirstOfMultiplePasses) {
 				var innerCount = 0;
 				for (let token of content) {
 					if (token instanceof MDToken && token.type == delimiter) innerCount++;
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		if (this.attemptPair(state, priority, tokens, MDEmphasisNode, MDTokenType.Asterisk)) return true;
-		if (this.attemptPair(state, priority, tokens, MDEmphasisNode, MDTokenType.Underscore)) return true;
+	substituteTokens(state, pass, tokens) {
+		if (this.attemptPair(state, pass, tokens, MDEmphasisNode, MDTokenType.Asterisk)) return true;
+		if (this.attemptPair(state, pass, tokens, MDEmphasisNode, MDTokenType.Underscore)) return true;
 		return false;
 	}
+
+	compareSubstituteOrdering(other, pass) {
+		if (other instanceof MDStrongReader) {
+			return 1;
+		}
+		return 0;
+	}
 }
 
 class MDStrongReader extends MDSimplePairInlineReader {
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		if (this.attemptPair(state, priority, tokens, MDStrongNode, MDTokenType.Asterisk, 2)) return true;
-		if (this.attemptPair(state, priority, tokens, MDStrongNode, MDTokenType.Underscore, 2)) return true;
+	substituteTokens(state, pass, tokens) {
+		if (this.attemptPair(state, pass, tokens, MDStrongNode, MDTokenType.Asterisk, 2)) return true;
+		if (this.attemptPair(state, pass, tokens, MDStrongNode, MDTokenType.Underscore, 2)) return true;
 		return false;
 	}
+
+	compareSubstituteOrdering(other, pass) {
+		if (other instanceof MDEmphasisReader) {
+			return -1;
+		}
+		return 0;
+	}
 }
 
 class MDStrikethroughReader extends MDSimplePairInlineReader {
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		if (this.attemptPair(state, priority, tokens, MDStrikethroughNode, MDTokenType.Tilde, 2)) return true;
-		if (this.attemptPair(state, priority, tokens, MDStrikethroughNode, MDTokenType.Tilde)) return true;
+	substituteTokens(state, pass, tokens) {
+		if (this.attemptPair(state, pass, tokens, MDStrikethroughNode, MDTokenType.Tilde, 2)) return true;
+		if (state.config.strikethroughSingleTildeEnabled) {
+			if (this.attemptPair(state, pass, tokens, MDStrikethroughNode, MDTokenType.Tilde)) return true;
+		}
 		return false;
 	}
 }
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		return this.attemptPair(state, priority, tokens, MDUnderlineNode, MDTokenType.Underscore, 2);
+	substituteTokens(state, pass, tokens) {
+		return this.attemptPair(state, pass, tokens, MDUnderlineNode, MDTokenType.Underscore, 2);
+	}
+
+	compareSubstituteOrdering(other, pass) {
+		if (other instanceof MDStrongReader) {
+			return -1;
+		}
+		return 0;
 	}
 }
 
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		return this.attemptPair(state, priority, tokens, MDHighlightNode, MDTokenType.Equal, 2);
+	substituteTokens(state, pass, tokens) {
+		return this.attemptPair(state, pass, tokens, MDHighlightNode, MDTokenType.Equal, 2);
 	}
 }
 
 	static #simpleEmailRegex = new RegExp("^<(" + MDUtils.baseEmailRegex.source + ")>", "i");  // 1=email
 	static #simpleURLRegex = new RegExp("^<(" + MDUtils.baseURLRegex.source + ")>", "i");  // 1=URL
 
-	constructor(tokenizePriority=0.0, substitutePriority=0.0) {
-		super(tokenizePriority, substitutePriority);
-	}
-
 	readToken(state, line) {
 		var groups;
 		if (groups = MDUtils.tokenizeLabel(line)) {
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
+	substituteTokens(state, pass, tokens) {
 		var match;
 		if (match = MDToken.findFirstTokens(tokens, [ MDTokenType.Label, MDTokenType.META_OptionalWhitespace, MDTokenType.URL ])) {
 			let text = match.tokens[0].content;
 		return new MDNode([]); // empty
 	}
 
-	substituteTokens(state, priority, tokens) {
+	substituteTokens(state, pass, tokens) {
 		var match;
 		if (match = MDToken.findFirstTokens(tokens, [ MDTokenType.Label, MDTokenType.META_OptionalWhitespace, MDTokenType.Label ])) {
 			let text = match.tokens[0].content;
 }
 
 class MDImageReader extends MDLinkReader {
-	substituteTokens(state, priority, tokens) {}
-
 	readToken(state, line) {
 		const s = super.readToken(state, line);
 		if (s) return s;
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
+	substituteTokens(state, pass, tokens) {
 		var match;
 		if (match = MDToken.findFirstTokens(tokens, [ MDTokenType.Bang, MDTokenType.Label, MDTokenType.META_OptionalWhitespace, MDTokenType.URL ])) {
 			let alt = match.tokens[1].content;
 		}
 		return false;
 	}
+
+	compareSubstituteOrdering(other, pass) {
+		if (other instanceof MDLinkReader) {
+			return -1;
+		}
+		return 0;
+	}
 }
 
 class MDReferencedImageReader extends MDReferencedLinkReader {
 	readBlock(state) { return null; }
+
+	compareSubstituteOrdering(other, pass) {
+		if (other instanceof MDLinkReader) {
+			return -1;
+		}
+		return 0;
+	}
 }
 
 class MDCodeSpanReader extends MDSimplePairInlineReader {
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		if (this.attemptPair(state, priority, tokens, MDCodeNode, MDTokenType.Backtick, 2, true)) return true;
-		if (this.attemptPair(state, priority, tokens, MDCodeNode, MDTokenType.Backtick, 1, true)) return true;
+	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 null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		return this.attemptPair(state, priority, tokens, MDSubscriptNode, MDTokenType.Tilde);
+	preProcess(state) {
+		// Causes a conflict
+		state.config.strikethroughSingleTildeEnabled = false;
+	}
+
+	substituteTokens(state, pass, tokens) {
+		return this.attemptPair(state, pass, tokens, MDSubscriptNode, MDTokenType.Tilde);
+	}
+
+	compareSubstituteOrdering(other, pass) {
+		if (other instanceof MDStrikethroughReader) {
+			return -1;
+		}
+		return 0;
 	}
 }
 
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
-		return this.attemptPair(state, priority, tokens, MDSuperscriptNode, MDTokenType.Caret);
+	substituteTokens(state, pass, tokens) {
+		return this.attemptPair(state, pass, tokens, MDSuperscriptNode, MDTokenType.Caret);
 	}
 }
 
 		return new MDToken(tag.original, MDTokenType.HTMLTag, null, null, tag)
 	}
 
-	substituteTokens(state, priority, tokens) {
+	substituteTokens(state, pass, tokens) {
 		var match;
 		if (match = MDToken.findFirstTokens(tokens, [ MDTokenType.HTMLTag ])) {
 			const tag = match.tokens[0].tag
 		return null;
 	}
 
-	substituteTokens(state, priority, tokens) {
+	substituteTokens(state, pass, tokens) {
 		// Modifiers are applied elsewhere, and if they're not it's fine if they're
 		// rendered as the original syntax.
 		return false;
 }
 
 class MDConfig {
-
+	strikethroughSingleTildeEnabled = true;
 }
 
 class Markdown {
 	 * @type {MDReader[]}
 	 */
 	static standardReaders = [
-		new MDUnderlinedHeaderReader(0),
-		new MDHashHeaderReader(1),
-		new MDBlockQuoteReader(3),
-		new MDHorizontalRuleReader(9),  // prioritize before unordered list
-		new MDUnorderedListReader(10),
-		new MDOrderedListReader(11),
-		new MDFencedCodeBlockReader(20),
-		new MDIndentedCodeBlockReader(21),
-		new MDParagraphReader(100),
-
-		new MDStrongReader(101, 10, [ 0, 2 ]),  // prioritize before emphasis (both use * and _)
-		new MDEmphasisReader(101, 15, [ 5, 55 ]),
-		new MDCodeSpanReader(101, 20, [ 10, 60 ]),
-		new MDImageReader(101, 30, 15),  // prioritize before links
-		new MDLinkReader(101, 35, 20),
-		new MDHTMLTagReader(101, 80, 30),
+		new MDUnderlinedHeaderReader(),
+		new MDHashHeaderReader(),
+		new MDBlockQuoteReader(),
+		new MDHorizontalRuleReader(),
+		new MDUnorderedListReader(),
+		new MDOrderedListReader(),
+		new MDFencedCodeBlockReader(),
+		new MDIndentedCodeBlockReader(),
+		new MDParagraphReader(),
+
+		new MDStrongReader(),
+		new MDEmphasisReader(),
+		new MDCodeSpanReader(),
+		new MDImageReader(),
+		new MDLinkReader(),
+		new MDHTMLTagReader(),
 	];
 
 	/**
 	 */
 	static allReaders = [
 		...this.standardReaders,
-		new MDSubtextReader(2),
-		new MDTableReader(40),
-		new MDDefinitionListReader(50),
-		new MDFootnoteReader(60, 5, 40),  // prioritize before links and images
-		new MDAbbreviationReader(70),
-
-		new MDUnderlineReader(101, 5, [ 9, 11 ]),  // prioritize before emphasis and strong (both use _)
-		// new MDSubscriptReader(101, 20, [ 11, 51 ]),  // prioritize before strikethrough (both use ~)
-		new MDStrikethroughReader(101, 21, [ 12, 50 ]),
-		new MDHighlightReader(101, 23, [ 13, 51 ]),
-		new MDSuperscriptReader(101, 24, [ 14, 54 ]),
-		new MDReferencedImageReader(91, 31, 16),
-		new MDReferencedLinkReader(90, 36, 21),
-		new MDModifierReader(101, 90, 45),
+		new MDSubtextReader(),
+		new MDTableReader(),
+		new MDDefinitionListReader(),
+		new MDFootnoteReader(),
+		new MDAbbreviationReader(),
+
+		new MDUnderlineReader(),
+		new MDSubscriptReader(),
+		new MDStrikethroughReader(),
+		new MDHighlightReader(),
+		new MDSuperscriptReader(),
+		new MDReferencedImageReader(),
+		new MDReferencedLinkReader(),
+		new MDModifierReader(),
 	];
 
 	/**
 	 */
 	static completeParser = new Markdown(this.allReaders);
 
+	/**
+	 * @type {MDConfig}
+	 */
+	config;
+
 	#readers;
 
+	/** @type {MDReader[]} */
 	#readersByBlockPriority;
+	/** @type {MDReader[]} */
 	#readersByTokenPriority;
+	/** @type {Array} */
 	#readersBySubstitutePriority;
 
 	/**
 	 * Creates a Markdown parser with the given syntax readers.
 	 *
 	 * @param {MDReader[]} readers
+	 * @param {MDConfig} config
 	 */
-	constructor(readers=Markdown.allReaders) {
+	constructor(readers=Markdown.allReaders, config=new MDConfig()) {
 		this.#readers = readers;
-		const duplicateAndSort = function(priorityFn) {
-			var result = [];
-			for (const reader of readers) {
-				const p = priorityFn(reader);
-				const priorities = (p instanceof Array) ? p : [ p ];
-				for (const priority of priorities) {
-					result.push([priority, reader]);
-				}
-			}
-			result.sort((a, b) => a[0] - b[0]);
-			return result;
-		}
-		this.#readersByBlockPriority = duplicateAndSort((reader) => reader.blockPriority);
-		this.#readersByTokenPriority = duplicateAndSort((reader) => reader.tokenizePriority);
-		this.#readersBySubstitutePriority = duplicateAndSort((reader) => reader.substitutePriority);
+		this.config = config;
+		this.#readersByBlockPriority = MDReader.sortReaderForBlocks(readers);
+		this.#readersByTokenPriority = MDReader.sortReadersForTokenizing(readers);
+		this.#readersBySubstitutePriority = MDReader.sortReadersForSubstitution(readers);
 	}
 
 	/**
 	toHTML(markdown) {
 		const lines = markdown.split(/(?:\n|\r|\r\n)/);
 		const state = new MDState(lines,
+			this.config,
 			this.#readersByBlockPriority,
 			this.#readersByTokenPriority,
 			this.#readersBySubstitutePriority);

testjs.html

 					this.assertEqual(actual, expected);
 				}
 
-				test_strikethrough_single() {
-					let markdown = 'Lorem ~ipsum~ dolor';
+				test_strikethrough_double() {
+					let markdown = 'Lorem ~~ipsum~~ dolor';
 					let expected = 'Lorem <s>ipsum</s> dolor';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}
 
-				test_strikethrough_double() {
-					let markdown = 'Lorem ~~ipsum~~ dolor';
-					let expected = 'Lorem <s>ipsum</s> dolor';
+				test_subscript() {
+					let markdown = 'H~2~O';
+					let expected = 'H<sub>2</sub>O';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_superscript() {
+					let markdown = 'E=mc^2^';
+					let expected = 'E=mc<sup>2</sup>';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_highlight() {
+					let markdown = 'Lorem ==ipsum== dolor';
+					let expected = 'Lorem <mark>ipsum</mark> dolor';
+					let actual = this.md(markdown);
+					this.assertEqual(actual, expected);
+				}
+
+				test_underline() {
+					let markdown = 'Lorem __ipsum__ dolor';
+					let expected = 'Lorem <u>ipsum</u> dolor';
 					let actual = this.md(markdown);
 					this.assertEqual(actual, expected);
 				}