Spreadsheet formulas can be styled with certain syntaxes

js/markdown.js

  */
 class MDTableReader extends MDReader {
 	/**
+	 * If cell contents begin with `=`, treat entire contents as plaintext.
+	 * Used by spreadsheet add-on to prevent equation operators from being
+	 * interpreted as markdown.
+	 * @type {boolean}
+	 */
+	preferFormulas = false;
+
+	/**
 	 * @param {MDState} state
 	 * @param {boolean} isHeader
 	 * @return {MDTableRowNode|null}
 		if (line.startsWith('|')) line = line.substring(1);
 		if (line.endsWith('|')) line = line.substring(0, line.length - 1);
 		let cellTokens = line.split('|');
+		const reader = this;
 		let cells = cellTokens.map(function(token) {
-			let content = state.inlineMarkdownToNode(token.trim());
+			const trimmedToken = token.trim();
+			let content;
+			if (reader.preferFormulas && trimmedToken.indexOf('=') >= 0) {
+				content = reader.#preserveFormula(state, trimmedToken);
+				if (content == null) {
+					content = state.inlineMarkdownToNode(trimmedToken);
+				}
+			} else {
+				content = state.inlineMarkdownToNode(token.trim());
+			}
 			return isHeader ? new MDTableHeaderCellNode(content) : new MDTableCellNode(content);
 		});
 		state.p = p;
 	}
 
 	/**
+	 * @param {MDState} state
+	 * @param {string} cellContents
+	 * @returns {MDNode|null}
+	 */
+	#preserveFormula(state, cellContents) {
+		// Up to three prefix punctuation patterns, formula, then three matching
+		// suffixes. Not guaranteed to catch every possible syntax but an awful lot.
+		const groups = /^([^a-z0-9\s]*)([^a-z0-9\s]*)([^a-z0-9\s]*)(=.*)\3\2\1$/i.exec(cellContents);
+		if (groups === null) return null;
+		const prefix = groups[1] + groups[2] + groups[3];
+		const formula = groups[4];
+		if (prefix.length == 0) {
+			return new MDTextNode(formula);
+		}
+		const suffix = groups[3] + groups[2] + groups[1];
+		// Parse substitute markdown with the same prefix and suffix but just
+		// an "x" as content. We'll swap in the unaltered formula into the
+		// parsed nodes.
+		const tempInline = prefix + 'x' + suffix;
+		const tempNodes = state.inlineMarkdownToNodes(tempInline);
+		if (tempNodes.length != 1) return null;
+		var foundText = false;
+		if (tempNodes[0] instanceof MDTextNode && tempNodes[0].text === 'x') {
+			tempNodes[0].text = formula;
+			foundText = true;
+		} else {
+			tempNodes[0].visitChildren(function(node) {
+				if (node instanceof MDTextNode && node.text === 'x') {
+					node.text = formula;
+					foundText = true;
+				}
+			});
+		}
+		if (!foundText) return null;
+		return tempNodes[0];
+	}
+
+	/**
 	 * @param {string} line
 	 * @returns {string[]}
 	 */
 		this.#bodyRows = bodyRows;
 	}
 
+	/**
+	 * Returns a given body cell.
+	 *
+	 * @param {number} column
+	 * @param {number} row
+	 * @returns {MDTableCellNode|null} cell or `null` if out of bounds
+	 */
+	bodyCellAt(column, row) {
+		const rowNode = this.bodyRows[row];
+		if (rowNode === undefined) return null;
+		const cellNode = rowNode.children[column];
+		return (cellNode === undefined) ? null : cellNode;
+	}
+
 	#recalculateChildren() {
 		this.children = [ this.#headerRow, ...this.#bodyRows ];
 	}

js/spreadsheet.js

  * `MDTableReader`. Tables without at least one formula will not be altered.
  */
 class MDSpreadsheetReader extends MDReader {
+	preProcess(state) {
+		for (const reader of state.readersByBlockPriority) {
+			if (reader instanceof MDTableReader) {
+				reader.preferFormulas = true;
+			}
+		}
+	}
+
 	postProcess(state, nodes) {
 		for (const node of nodes) {
 			if (node instanceof MDTableNode) {
 		const grid = new SpreadsheetGrid(columnCount, rowCount);
 		for (var c = 0; c < columnCount; c++) {
 			for (var r = 0; r < rowCount; r++) {
-				const cellNode = tableNode.bodyRows[r].children[c];
-				if (cellNode === undefined) continue;
+				const cellNode = tableNode.bodyCellAt(c, r);
+				if (cellNode === null) continue;
 				const cellText = cellNode.toPlaintext(state);
 				const gridCell = grid.cells[c][r];
 				gridCell.originalValue = CellValue.fromCellString(cellText);
 		var isCalculated = false;
 		for (var c = 0; c < columnCount && !isCalculated; c++) {
 			for (var r = 0; r < rowCount; r++) {
-				if (grid.cells[c][r].isCalculated) {
+				if (grid.cellAt(new CellAddress(c, r)).isCalculated) {
 					isCalculated = true;
 					break;
 				}
 		// Copy results back to table
 		for (var c = 0; c < columnCount; c++) {
 			for (var r = 0; r < rowCount; r++) {
-				const cellNode = tableNode.bodyRows[r].children[c];
-				if (cellNode === undefined) continue;
-				const gridCell = grid.cells[c][r];
-				const gridValue = gridCell.outputValue;
-				const cellText = gridValue.formattedValue;
+				const cellNode = tableNode.bodyCellAt(c, r);
+				const gridCell = grid.cellAt(new CellAddress(c, r));
+				if (cellNode === null || gridCell === null) continue;
+				this.#populateCell(cellNode, gridCell, state, c, r);
+			}
+		}
+	}
+
+	/**
+	 * @param {MDTableCellNode} cellNode
+	 * @param {SpreadsheetCell} gridCell
+	 * @param {MDState} state
+	 * @param {number} c - column index
+	 * @param {number} r - row index
+	 */
+	#populateCell(cellNode, gridCell, state, c, r) {
+		const gridValue = gridCell.outputValue;
+		if (gridValue === null) return;
+		const oldCellText = cellNode.toPlaintext(state).trim();
+		const cellText = gridValue.formattedValue;
+		if (cellText != oldCellText) {
+			// Try to insert the text into any nested whole-value formatting nodes
+			// if possible
+			if (!this.#findTextNode(cellNode, oldCellText, cellText)) {
+				// Contents contain mixed formatting. We'll have to just replace
+				// the whole thing.
 				cellNode.children = [ new MDTextNode(cellText) ];
-				if (gridCell.isCalculated) {
-					cellNode.cssClasses.push('calculated');
-				}
-				cellNode.cssClasses.push(`spreadsheet-type-${gridValue.type}`);
-				if (gridValue.type == CellValue.TYPE_ERROR) {
-					cellNode.attributes['title'] = gridValue.value;
-				}
-				const gridNumber = gridValue.numericValue();
-				if (gridNumber !== null) {
-					cellNode.attributes['data-numeric-value'] = `${gridNumber}`;
-				}
-				const gridString = gridValue.stringValue(false);
-				if (gridString !== null) {
-					cellNode.attributes['data-string-value'] = gridString;
-				}
 			}
 		}
+		if (gridCell.isCalculated) {
+			cellNode.cssClasses.push('calculated');
+		}
+		cellNode.cssClasses.push(`spreadsheet-type-${gridValue.type}`);
+		if (gridValue.type == CellValue.TYPE_ERROR) {
+			cellNode.attributes['title'] = gridValue.value;
+		}
+		const gridNumber = gridValue.numericValue();
+		if (gridNumber !== null) {
+			cellNode.attributes['data-numeric-value'] = `${gridNumber}`;
+		}
+		const gridString = gridValue.stringValue(false);
+		if (gridString !== null) {
+			cellNode.attributes['data-string-value'] = gridString;
+		}
+	}
+
+	#findTextNode(startNode, expectedText, newText) {
+		if (startNode instanceof MDTextNode) {
+			if (startNode.text.trim() === expectedText.trim()) {
+				startNode.text = newText;
+				return true;
+			}
+		}
+		for (const child of startNode.children) {
+			if (this.#findTextNode(child, expectedText, newText)) return true;
+		}
+		return false;
 	}
 }

php/markdown.php

  * Supports `MDTagModifier` suffix.
  */
 class MDTableReader extends MDReader {
+	/**
+	 * If cell contents begin with `=`, treat entire contents as plaintext.
+	 * Used by spreadsheet add-on to prevent equation operators from being
+	 * interpreted as markdown.
+	 * @type {boolean}
+	 */
+	public bool $preferFormulas = false;
+
 	private function readTableRow(MDState $state, bool $isHeader): ?MDTableRowNode {
 		if (!$state->hasLines(1)) return null;
 		$p = $state->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, $state) {
-			$content = $state->inlineMarkdownToNode(trim($token));
+		$cells = array_map(function($token) use ($state, $isHeader) {
+			$trimmedToken = trim($token);
+			if ($this->preferFormulas && strpos($trimmedToken, '=') !== false) {
+				$content = $this->preserveFormula($state, $trimmedToken);
+				if ($content === null) {
+					$content = $state->inlineMarkdownToNode($trimmedToken);
+				}
+			} else {
+				$content = $state->inlineMarkdownToNode($trimmedToken);
+			}
 			return $isHeader ? new MDTableHeaderCellNode($content) : new MDTableCellNode($content);
 		}, $cellTokens);
 		$state->p = $p;
 	}
 
 	/**
+	 * @param MDState $state
+	 * @param string $cellContents
+	 * @return ?MDNode
+	 */
+	private function preserveFormula(MDState $state, string $cellContents): ?MDNode {
+		// Up to three prefix punctuation patterns, formula, then three matching
+		// suffixes. Not guaranteed to catch every possible syntax but an awful lot.
+		// Using preg_match instead for... reasons.
+		$regex = '/^([^a-z0-9\\s]*)([^a-z0-9\\s]*)([^a-z0-9\\s]*)(=.*)\\3\\2\\1$/i';
+		if (!preg_match($regex, $cellContents, $groups)) {
+			return null;
+		}
+		$prefix = $groups[1] . $groups[2] . $groups[3];
+		$formula = $groups[4];
+		if ($prefix === '') {
+			return new MDTextNode($formula);
+		}
+		$suffix = $groups[3] . $groups[2] . $groups[1];
+		// Parse substitute markdown with the same prefix and suffix but just
+		// an "x" as content. We'll swap in the unaltered formula into the
+		// parsed nodes.
+		$tempInline = $prefix . 'x' . $suffix;
+		$tempNodes = $state->inlineMarkdownToNodes($tempInline);
+		if (count($tempNodes) != 1) return null;
+		$foundText = false;
+		if ($tempNodes[0] instanceof MDTextNode && $tempNodes[0]->text === 'x') {
+			$tempNodes[0]->text = $formula;
+			$foundText = true;
+		} else {
+			$tempNodes[0]->visitChildren(function($node) use ($formula, &$foundText) {
+				if ($node instanceof MDTextNode && $node->text === 'x') {
+					$node->text = $formula;
+					$foundText = true;
+				}
+			});
+		}
+		if (!$foundText) return null;
+		return $tempNodes[0];
+	}
+
+	/**
 	 * @param string $line
 	 * @return string[]
 	 */
 		parent::__construct(array_merge([ $headerRow ], $bodyRows));
 	}
 
+	/**
+	 * Returns a given body cell.
+	 *
+	 * @param {number} column
+	 * @param {number} row
+	 * @returns {MDTableCellNode|null} cell or `null` if out of bounds
+	 */
+	public function bodyCellAt(int $column, int $row): ?MDTableCellNode {
+		$rowNode = $this->bodyRows()[$row] ?? null;
+		if ($rowNode === null) return null;
+		$cellNode = $rowNode->children[$column] ?? null;
+		return ($cellNode === null) ? null : $cellNode;
+	}
+
 	public function applyAlignments() {
 		foreach ($this->children as $child) {
 			$this->applyAlignmentsToRow($child);
 	public function toPlaintext(MDState $state): string {
 		return $this->text;
 	}
+
+	public function __toString(): string {
+		return "<MDTextNode \"{$this->text}\">";
+	}
 }
 
 /**

php/spreadsheet.php

  * `MDTableReader`. Tables without at least one formula will not be altered.
  */
 class MDSpreadsheetReader extends MDReader {
+	public function preProcess(MDState $state) {
+		foreach ($state->readersByBlockPriority as $reader) {
+			if ($reader instanceof MDTableReader) {
+				$reader->preferFormulas = true;
+			}
+		}
+	}
+
 	public function postProcess(MDState $state, array &$nodes) {
 		foreach ($nodes as $node) {
 			if ($node instanceof MDTableNode) {
 		$grid = new SpreadsheetGrid($columnCount, $rowCount);
 		for ($c = 0; $c < $columnCount; $c++) {
 			for ($r = 0; $r < $rowCount; $r++) {
-				$row = $tableNode->bodyRows()[$r] ?? null;
-				if ($row === null) continue;
-				$cellNode = $row->children[$c] ?? null;
+				$cellNode = $tableNode->bodyCellAt($c, $r);
 				if ($cellNode === null) continue;
 				$cellText = $cellNode->toPlaintext($state);
 				$gridCell = $grid->cells[$c][$r];
 		$isCalculated = false;
 		for ($c = 0; $c < $columnCount && !$isCalculated; $c++) {
 			for ($r = 0; $r < $rowCount; $r++) {
-				if ($grid->cells[$c][$r]->isCalculated) {
+				if ($grid->cellAt(new CellAddress($c, $r))->isCalculated) {
 					$isCalculated = true;
 					break;
 				}
 		// Copy results back to table
 		for ($c = 0; $c < $columnCount; $c++) {
 			for ($r = 0; $r < $rowCount; $r++) {
-				$row = $tableNode->bodyRows()[$r] ?? null;
-				if ($row === null) continue;
-				$cellNode = $row->children[$c] ?? null;
-				if ($cellNode === null) continue;
-				$gridCell = $grid->cells[$c][$r];
-				$gridValue = $gridCell->outputValue;
-				$cellText = $gridValue->formattedValue;
+				$cellNode = $tableNode->bodyCellAt($c, $r);
+				$gridCell = $grid->cellAt(new CellAddress($c, $r));
+				if ($cellNode === null || $gridCell === null) continue;
+				$this->populateCell($cellNode, $gridCell, $state, $c, $r);
+			}
+		}
+	}
+
+	/**
+	 * @param MDTableCellNode $cellNode
+	 * @param SpreadsheetCell $gridCell
+	 * @param MDState $state
+	 * @param int $c  column index
+	 * @param int $r  row index
+	 */
+	private function populateCell(MDTableCellNode $cellNode,
+			SpreadsheetCell $gridCell, MDState $state, int $c, int $r) {
+		$gridValue = $gridCell->outputValue;
+		if ($gridValue === null) return;
+		$oldCellText = trim($cellNode->toPlaintext($state));
+		$cellText = $gridValue->formattedValue;
+		if ($cellText != $oldCellText) {
+			// Try to insert the text into any nested whole-value formatting nodes
+			// if possible
+			if (!$this->findTextNode($cellNode, $oldCellText, $cellText)) {
+				// Contents contain mixed formatting. We'll have to just replace
+				// the whole thing.
 				$cellNode->children = [ new MDTextNode($cellText) ];
-				if ($gridCell->isCalculated) {
-					$cellNode->addClass('calculated');
-				}
-				$cellNode->addClass("spreadsheet-type-{$gridValue->type}");
-				if ($gridValue->type === CellValue::TYPE_ERROR) {
-					$cellNode->attributes['title'] = $gridValue->value;
-				}
-				$gridNumber = $gridValue->numericValue();
-				if ($gridNumber !== null) {
-					$cellNode->attributes['data-numeric-value'] = "{$gridNumber}";
-				}
-				$gridString = $gridValue->stringValue(false);
-				if ($gridString !== null) {
-					$cellNode->attributes['data-string-value'] = $gridString;
-				}
 			}
 		}
+		if ($gridCell->isCalculated) {
+			$cellNode->addClass('calculated');
+		}
+		$cellNode->addClass("spreadsheet-type-{$gridValue->type}");
+		if ($gridValue->type == CellValue::TYPE_ERROR) {
+			$cellNode->attributes['title'] = $gridValue->value;
+		}
+		$gridNumber = $gridValue->numericValue();
+		if ($gridNumber !== null) {
+			$cellNode->attributes['data-numeric-value'] = "{$gridNumber}";
+		}
+		$gridString = $gridValue->stringValue(false);
+		if ($gridString !== null) {
+			$cellNode->attributes['data-string-value'] = $gridString;
+		}
+	}
+
+	private function findTextNode(MDNode $startNode, string $expectedText, string $newText): bool {
+		if ($startNode instanceof MDTextNode) {
+			if (trim($startNode->text) === trim($expectedText)) {
+				$startNode->text = $newText;
+				return true;
+			}
+		}
+		foreach ($startNode->children as $child) {
+			if ($this->findTextNode($child, $expectedText, $newText)) return true;
+		}
+		return false;
 	}
 }
 ?>

spreadsheet.md

 # Spreadsheet Expressions
 
-Spreadsheet expressions are an optional feature not enabled in the default parser configurations. To enable it, include `spreadsheet.js` and create a `Markdown` instance with a `MDSpreadsheetReader`.
+Spreadsheet expressions are an optional feature not enabled in the default parser configurations. To enable it, include `spreadsheet.js` / `spreadsheet.php` and create a `Markdown` instance with a `MDSpreadsheetReader`.
 
 ## Expressions
 
 ## Errors
 
 If an expression cannot be evaluated, the cell will show an error symbol, such as `#REF`, `#SYNTAX`, or `#ERROR`. A more detailed message is in the `title` attribute and can be seen in a tooltip by mousing over it.
+
+## Styling
+
+The parser tries to be smart about differentiating operators from markdown syntax,
+but if an operator character (such as `*`) is mistaken for formatting, escape
+it with `\\*`.
+
+A limited set of styling can be applied to formula results if it consists of
+matching punctuation before and after. For example, `**=SUM(A:A)**` will
+render a sum in bold. Up to three such formats can be combined, e.g.
+`==~~__=SUM(A:A)__~~==`. Blank cells that are autofilled by a formula in the
+column cannot currently be styled in this way.