Cleanup, minor spreadsheet bugs

js/spreadsheet.js

 		if (args.length == 0) {
 			throw new CellEvaluationException("AND requires one or more arguments");
 		}
-		const values = args.map((arg) => this.#evaluate(arg, address));
+		const values = this.#flattenedNumericArguments('AND', args, address, false);
 		for (const value of values) {
 			const result = value.booleanValue();
 			if (result === null) {
 		if (args.length == 0) {
 			throw new CellEvaluationException("OR requires one or more arguments");
 		}
-		const values = args.map((arg) => this.#evaluate(arg, address));
+		const values = this.#flattenedNumericArguments('OR', args, address, false);
 		for (const value of values) {
 			const result = value.booleanValue();
 			if (result === null) {
 		if (args.length == 0) {
 			throw new CellEvaluationException("XOR requires one or more arguments");
 		}
-		const values = args.map((arg) => this.#evaluate(arg, address));
+		const values = this.#flattenedNumericArguments('XOR', args, address, false);
 		var result = null;
 		for (const value of values) {
 			const b = value.booleanValue();

php/spreadsheet.php

 	/**
 	 * Brief symbol to show in the cell to signify an error occurred during
 	 * evaluation.
-	 *
-	 * @$string
 	 */
 	public string $errorSymbol;
 
 		$colCount = $this->grid->columnCount;
 
 		// Make queue of cell addresses with expressions in them
-		/** @$CellAddress[] */
+		/** @var CellAddress[] */
 		$expressionAddressQueue = [];
-		$range = new CellAddressRange(new CellAddress(0, 0), new CellAddress($colCount - 1, $rowCount - 1));
+		$range = new CellAddressRange(new CellAddress(0, 0),
+			new CellAddress($colCount - 1, $rowCount - 1));
 		foreach ($range->cellsIn($this->grid) as $addressStr => $cell) {
 			$address = CellAddress::fromString($addressStr);
 			if ($address === null) {
 				error_log("Couldn't parse address string {$addressStr}!");
 			}
 			$value = $cell->originalValue;
-			if ($value->type != CellValue::TYPE_FORMULA) {
+			if ($value->type !== CellValue::TYPE_FORMULA) {
 				$cell->outputValue = $value;
 				$cell->isCalculated = false;
 				continue;
 	}
 
 	/**
-	 * Attempts to evaluate expressions at the given `addresses`. If an
+	 * Attempts to evaluate expressions at the given `$addresses`. If an
 	 * expression has unevaluated references, the expression is moved to the
 	 * end of the queue and tried again later. When this method returns, any
-	 * elements left in `addresses` can be considered circular references.
+	 * elements left in `$addresses` can be considered circular references.
 	 * 
 	 * @param CellAddress[] $addresses  mutable queue of formula addresses
 	 */
 	private function processExpressionQueue(array &$addresses) {
 		$requeueCount = 0;
-		while (sizeof($addresses) > 0 && $requeueCount < sizeof($addresses)) {
+		while (count($addresses) > 0 && $requeueCount < count($addresses)) {
 			$address = $addresses[0];
 			array_splice($addresses, 0, 1);
 			$cell = $this->grid->cellAt($address);
 					$cell->outputValue = $result;
 					$requeueCount = 0;
 				} elseif (is_array($result)) {
-					if (sizeof($result) == 1) {
+					if (count($result) === 1) {
 						$cell->outputValue = $result[0];
 						$requeueCount = 0;
 					} else {
-						throw new CellEvaluationException("Expression resolved to " . sizeof($result) . " values, single value expected");
+						throw new CellEvaluationException("Expression resolved to " .
+							count($result) . " values, single value expected");
 					}
 				} else {
-					$typename = gettype($result) == 'object' ? get_class($result) : gettype($result);
-					throw new CellEvaluationException("Expression resolved to {$typename}, expected CellValue");
+					$typename = gettype($result) === 'object' ? get_class($result)
+						: gettype($result);
+					throw new CellEvaluationException(
+						"Expression resolved to {$typename}, expected CellValue");
 				}
 			} catch (CellDependencyException $e) {
 				// Depends on a value that hasn't been calculated yet
 
 	/**
 	 * Autofills a formula, transposing the formula to each affected cell and
-	 * stored in `parsedExpression`, and each address is queued in `addresses`
+	 * stored in `$parsedExpression`, and each address is queued in `$addresses`
 	 * for evaluation.
 	 *
 	 * @param CellExpression $expression  autofilled formula
 	 * @param CellAddress $address  location of expression
 	 * @return CellValue|CellValue[]  results
 	 */
-	private function evaluate(CellExpression $expr, CellAddress $address) {
+	private function evaluate(CellExpression $expr, CellAddress $address): CellValue|array {
 		$result = $this->preevaluate($expr, $address);
 		if ($result instanceof CellValue) {
 			// Expression included formatting override. Apply it to value.
 	 * @param CellExpression $expr  expression to evaluate
 	 * @param CellAddress $address  location of expression
 	 * @return CellValue|CellValue[]  results
-	 * @throws CellException if evaluation fails for any reason
+	 * @throws CellException  if evaluation fails for any reason
 	 */
-	private function preevaluate(CellExpression $expr, CellAddress $address) {
+	private function preevaluate(CellExpression $expr, CellAddress $address): CellValue|array {
 		switch ($expr->op) {
 			case CellExpressionOperation::Number:
 			case CellExpressionOperation::String:
 	 * @param array $args  raw arguments
 	 * @param CellAddress $address  location of the expression
 	 * @return CellValue  result
-	 * @throws CellException if evaluation fails for any reason
+	 * @throws CellException  if evaluation fails for any reason
 	 */
 	private function callFunction(string $functionName, array $args, CellAddress $address): CellValue {
 		switch (mb_strtoupper($functionName)) {
 	 * @param array $args  raw arguments
 	 * @param CellAddress $address  address of the formula
 	 * @return CellValue[]  numeric arguments
-	 * @throws CellSyntaxException if wrong number of arguments is passed
-	 * @throws CellEvaluationException if an argument does not resolve to a numeric value
+	 * @throws CellSyntaxException  if wrong number of arguments is passed
+	 * @throws CellEvaluationException  if an argument does not resolve to a numeric value
 	 */
 	private function assertNumericArguments(string $functionName, int $minArgs,
 			int $maxArgs, array $args, CellAddress $address): array {
-		$argCount = sizeof($args);
+		$argCount = count($args);
 		if ($argCount < $minArgs || $argCount > $maxArgs) {
-			if ($minArgs == $maxArgs) {
-				throw new CellSyntaxException("{$functionName}() expects {$minArgs} arguments, got {$argCount}");
+			if ($minArgs === $maxArgs) {
+				throw new CellSyntaxException("{$functionName}() expects {$minArgs} " +
+					"arguments, got {$argCount}");
 			}
-			throw new CellSyntaxException("{$functionName}() expects between {$minArgs} and {$maxArgs} arguments, got {$argCount}");
+			throw new CellSyntaxException("{$functionName}() expects between " +
+				"{$minArgs} and {$maxArgs} arguments, got {$argCount}");
 		}
 		$out = [];
 		foreach ($args as $argument) {
 	 * @return CellValue  result
 	 */
 	private function funcAnd(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) == 0) {
+		if (count($args) === 0) {
 			throw new CellEvaluationException("AND requires one or more arguments");
 		}
-		$values = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
+		$values = $this->flattenedNumericArguments('AND', $args, $address, false);
 		foreach ($values as $value) {
 			$result = $value->booleanValue();
 			if ($result === null) {
 	 * @return CellValue  result
 	 */
 	private function funcIf(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) != 3) {
+		if (count($args) !== 3) {
 			throw new CellEvaluationException("IF expects three arguments");
 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 	 * @return CellValue  result
 	 */
 	private function funcIfs(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) < 3) {
+		if (count($args) < 3) {
 			throw new CellEvaluationException("IFS expects at least 3 arguments");
 		}
-		if ((sizeof($args) % 2) != 1) {
+		if ((count($args) % 2) !== 1) {
 			throw new CellEvaluationException("IFS expects an odd number of arguments");
 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
-		for ($i = 0; $i < sizeof($evaled) - 1; $i += 2) {
+		for ($i = 0; $i < count($evaled) - 1; $i += 2) {
 			$test = $evaled[$i].booleanValue();
 			if ($test === null) {
 				throw new CellEvaluationException("IFS expects a boolean for argument " . ($i + 1));
 				return $evaled[$i + 1];
 			}
 		}
-		return $evaled[sizeof($evaled) - 1];
+		return $evaled[count($evaled) - 1];
 	}
 
 	/**
 	private function funcLog(array $args, CellAddress $address): CellValue {
 		$evaled = $this->assertNumericArguments('LOG', 1, 2, $args, $address);
 		$exponent = $evaled[0];
-		$base = (sizeof($evaled) > 1) ? $evaled[1]->value : 10.0;
+		$base = (count($evaled) > 1) ? $evaled[1]->value : 10.0;
 		$newValue = log($exponent->value) / log($base);
 		return CellValue::fromValue($newValue, $exponent->type);
 	}
 	 * @return CellValue  result
 	 */
 	private function funcLower(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) != 1) {
+		if (count($args) !== 1) {
 			throw new CellEvaluationException("LOWER requires one argument");
 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 	private function funcMax(array $args, CellAddress $address): CellValue {
 		$maxValue = null;
 		$flattened = $this->flattenedNumericArguments('MAX', $args, $address);
-		if (sizeof($flattened) == 0) {
+		if (count($flattened) === 0) {
 			throw new CellEvaluationException("MAX requires at least one numeric argument");
 		}
 		foreach ($flattened as $argument) {
 	private function funcMin(array $args, CellAddress $address): CellValue {
 		$minValue = null;
 		$flattened = $this->flattenedNumericArguments('MIN', $args, $address);
-		if (sizeof($flattened) == 0) {
+		if (count($flattened) === 0) {
 			throw new CellEvaluationException("MIN requires at least one numeric argument");
 		}
 		foreach ($flattened as $argument) {
 	 * @return CellValue  result
 	 */
 	private function funcMod(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) != 2) {
+		if (count($args) !== 2) {
 			throw new CellEvaluationException("MOD requires two numeric arguments");
 		}
 		$values = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 	 * @return CellValue  result
 	 */
 	private function funcNot(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) != 1) {
+		if (count($args) !== 1) {
 			throw new CellEvaluationException("NOT expects one argument");
 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 	 * @return CellValue  result
 	 */
 	private function funcOr(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) == 0) {
+		if (count($args) === 0) {
 			throw new CellEvaluationException("OR requires one or more arguments");
 		}
-		$values = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
+		$values = $this->flattenedNumericArguments('OR', $args, $address, false);
 		foreach ($values as $value) {
 			$result = $value->booleanValue();
 			if ($result === null) {
 	private function funcRound(array $args, CellAddress $address): CellValue {
 		$evaled = $this->assertNumericArguments('ROUND', 1, 2, $args, $address);
 		$val = $evaled[0];
-		$places = sizeof($evaled) > 1 ? $evaled[1]->value : 0;
+		$places = count($evaled) > 1 ? $evaled[1]->value : 0;
 		$divider = pow(10.0, $places);
 		$newValue = round($val->value * $divider) / $divider;
 		return CellValue::fromValue($newValue, $val->type);
 	 * @return CellValue  result
 	 */
 	private function funcSubstitute(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) != 3) {
+		if (count($args) !== 3) {
 			throw new CellEvaluationException("SUBSTITUTE expects 3 string arguments");
 		}
 		$values = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 	 * @return CellValue  result
 	 */
 	private function funcUpper(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) != 1) {
+		if (count($args) !== 1) {
 			throw new CellEvaluationException("UPPER requires one argument");
 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 	 * @return CellValue  result
 	 */
 	private function funcXor(array $args, CellAddress $address): CellValue {
-		if (sizeof($args) == 0) {
+		if (count($args) === 0) {
 			throw new CellEvaluationException("XOR requires one or more arguments");
 		}
-		$values = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
+		$values = $this->flattenedNumericArguments('XOR', $args, $address, false);
 		$result = null;
 		foreach ($values as $value) {
 			$b = $value->booleanValue();
 			}
 			$result = ($result === null) ? $b : ($result ^ $b);
 		}
-		return CellValue::fromValue($result != 0);
+		return CellValue::fromValue($result !== 0);
 	}
 }
 
 	 */
 	public static function parse(string $expression, CellAddress $address): ?CellExpression {
 		$tokens = self::expressionToTokens($expression);
-		if (sizeof($tokens) == 0) return null;
+		if (count($tokens) === 0) return null;
 		$expr = self::expressionFromTokens($tokens, $address);
 		$expr->location = $address;
 		return $expr;
 	 * @param string $indent
 	 */
 	public static function dumpExpression(CellExpression $expression, string $indent = '') {
-		if (sizeof($expression->arguments) == 0) {
+		if (count($expression->arguments) === 0) {
 			error_log($indent . "expr " . $expression->op->name . "()");
 		} else {
 			error_log($indent . $expression->op->name . '(');
 		$l = mb_strlen($text);
 		while ($pos < $l) {
 			$ch = mb_substr($text, $pos, 1);
-			if ($ch == ' ' || $ch == "\t" || $ch == "\n" || $ch == "\r") {
+			if ($ch === ' ' || $ch === "\t" || $ch === "\n" || $ch === "\r") {
 				$pos++;
 			} else {
 				return;
 		$l = mb_strlen($target);
 		if ($l > $remaining) return null;
 		$test = mb_substr($text, $pos, $l);
-		if (mb_strtoupper($test) != mb_strtoupper($target)) return null;
+		if (mb_strtoupper($test) !== mb_strtoupper($target)) return null;
 		$pos += $l;
 		return new CellExpressionToken($type, $test);
 	}
 		$ch = mb_substr($text, $p, 1);
 		$address = '';
 		$isName = true;
-		if ($ch == '$') {
+		if ($ch === '$') {
 			$address .= $ch;
 			$isName = false;
 			$p++;
 		if ($col === null) return null;
 		$address .= $col;
 		$ch = mb_substr($text, $p, 1);
-		if ($ch == '$') {
+		if ($ch === '$') {
 			$address .= $ch;
 			$isName = false;
 			$p++;
-			$row = self::readChars($text, $p, fn($ch) => self::isDigit($ch), 1);
+			$row = self::readChars($text, $p, fn($s) => self::isDigit($s), 1);
 			if ($row === null) return null;
 			$address .= $row;
 		} else {
-			$row = self::readChars($text, $p, fn($ch) => self::isDigit($ch), 0);
+			$row = self::readChars($text, $p, fn($s) => self::isDigit($s), 0);
 			if ($row === null) return null;
 			$address .= $row;
 		}
 		}
 		if ($pos < $l) {
 			$ch = mb_substr($text, $pos, 1);
-			if ($ch == '.') {
+			if ($ch === '.') {
 				$numStr .= $ch;
 				$pos++;
 				while ($pos < $l) {
 			$pos++;
 			if ($inEscape) {
 				$inEscape = false;
-				if ($ch == '\\' || $ch == '"') {
+				if ($ch === '\\' || $ch === '"') {
 					$str .= $ch;
 				} else {
 					throw new CellSyntaxException("Bad string escape sequence \"\\{$ch}\"");
 				}
-			} elseif ($ch == '\\') {
+			} elseif ($ch === '\\') {
 				$inEscape = true;
-			} elseif ($ch == '"') {
+			} elseif ($ch === '"') {
 				return new CellExpressionToken(CellExpressionTokenType::String, $str);
 			} else {
 				$str .= $ch;
 	 * @return ?CellExpression
 	 */
 	public static function expressionFromTokens(array $tokens, CellAddress $address): ?CellExpression {
-		if ($expr = self::tryExpressionAndFormat($tokens, 0, sizeof($tokens) - 1, $address)) return $expr;
-		if ($expr = self::tryExpressionAndFill($tokens, 0, sizeof($tokens) - 1, $address)) return $expr;
-		if ($expr = self::tryExpression($tokens, 0, sizeof($tokens) - 1, $address)) return $expr;
+		if ($expr = self::tryExpressionAndFormat($tokens, 0, count($tokens) - 1, $address)) return $expr;
+		if ($expr = self::tryExpressionAndFill($tokens, 0, count($tokens) - 1, $address)) return $expr;
+		if ($expr = self::tryExpression($tokens, 0, count($tokens) - 1, $address)) return $expr;
 		return null;
 	}
 
 	private static function tryExpressionAndFormat(array $tokens, int $start,
 			int $end, CellAddress $address): ?CellExpression {
 		for ($t = $start + 1; $t < $end; $t++) {
-			if ($tokens[$t]->type == CellExpressionTokenType::Semicolon) {
+			if ($tokens[$t]->type === CellExpressionTokenType::Semicolon) {
 				$expr = self::tryExpressionAndFill($tokens, $start, $t - 1, $address) ??
 					self::tryExpression($tokens, $start, $t - 1, $address);
 				if ($expr === null) return null;
 		if ($count < 2) return null;
 		if (!$tokens[$end]->type->isPotentialName()) return null;
 		$name = mb_strtoupper($tokens[$end]->content);
-		if ($name != 'FILL') return null;
+		if ($name !== 'FILL') return null;
 		$exp = self::tryExpression($tokens, $start, $end - 1, $address);
 		$columnIndex = $address->columnIndex;
 		$exp->fillRanges = [
 		$count = $end - $start + 1;
 		if ($count < 0 || $count > 2) return null;
 		if (!$tokens[$start]->type->isPotentialName()) return null;
-		$type = mb_strtolower($tokens[$start]);
+		$type = mb_strtolower($tokens[$start]->content);
 		if (!CellValue::isTypeNumeric($type)) return null;
 		if ($count > 1) {
-			if ($tokens[$start + 1]->type != CellExpressionTokenType::Number) return null;
+			if ($tokens[$start + 1]->type !== CellExpressionTokenType::Number) return null;
 			$decimals = intval($tokens[$start + 1]->content);
 		} else {
 			$decimals = null;
 	 */
 	private static function tryParenExpression(array $tokens, int $start,
 			int $end, CellAddress $address): ?CellExpression {
-		if ($tokens[$start]->type != CellExpressionTokenType::OpenParen) return null;
-		if ($tokens[$end]->type != CellExpressionTokenType::CloseParen) return null;
+		if ($tokens[$start]->type !== CellExpressionTokenType::OpenParen) return null;
+		if ($tokens[$end]->type !== CellExpressionTokenType::CloseParen) return null;
 		$parenLevel = 0;
 		for ($t = $start + 1; $t < $end; $t++) {
-			if ($tokens[$t]->type == CellExpressionTokenType::OpenParen) {
+			if ($tokens[$t]->type === CellExpressionTokenType::OpenParen) {
 				$parenLevel++;
-			} elseif ($tokens[$t]->type == CellExpressionTokenType::CloseParen) {
+			} elseif ($tokens[$t]->type === CellExpressionTokenType::CloseParen) {
 				$parenLevel--;
 			}
 			if ($parenLevel < 0) return null;
 		}
-		if ($parenLevel != 0) return null;
+		if ($parenLevel !== 0) return null;
 		return self::tryExpression($tokens, $start + 1, $end - 1, $address);
 	}
 
 	 */
 	private static function tryNumber(array $tokens, int $start, int $end,
 			CellAddress $address): ?CellExpression {
-		if ($tokens[$end]->type != CellExpressionTokenType::Number) return null;
+		if ($tokens[$end]->type !== CellExpressionTokenType::Number) return null;
 		if ($end > $start + 1) return null;
 		$val = CellValue::fromCellString($tokens[$end]->content);
 		if ($end > $start) {
-			if ($tokens[$start]->type != CellExpressionTokenType::Minus) return null;
+			if ($tokens[$start]->type !== CellExpressionTokenType::Minus) return null;
 			$val->value = -$val->value;
 		}
 		return new CellExpression(CellExpressionOperation::Number, [ $val ]);
 	 */
 	private static function tryString(array $tokens, int $start, int $end,
 			CellAddress $address): ?CellExpression {
-		if ($start != $end) return null;
-		if ($tokens[$start]->type != CellExpressionTokenType::String) return null;
+		if ($start !== $end) return null;
+		if ($tokens[$start]->type !== CellExpressionTokenType::String) return null;
 		$str = $tokens[$start]->content;
 		return new CellExpression(CellExpressionOperation::String,
 			[ new CellValue($str, $str, CellValue::TYPE_STRING, 0) ]);
 	 */
 	private static function tryBoolean(array $tokens, int $start, int $end,
 			CellAddress $address): ?CellExpression {
-		if ($start != $end) return null;
+		if ($start !== $end) return null;
 		if (!$tokens[$start]->type->isPotentialName()) return null;
 		$str = mb_strtoupper($tokens[$start]->content);
-		if ($str != 'TRUE' && $str != 'FALSE') return null;
+		if ($str !== 'TRUE' && $str !== 'FALSE') return null;
 		return new CellExpression(CellExpressionOperation::Boolean,
-			[ new CellValue($str, $str == 'TRUE', CellValue::TYPE_BOOLEAN) ]);
+			[ new CellValue($str, $str === 'TRUE', CellValue::TYPE_BOOLEAN) ]);
 	}
 
 	/**
 		if ($count < 3) return null;
 		if (!$tokens[$start]->type->isPotentialName()) return null;
 		$qualifier = $tokens[$start]->content;
-		if ($tokens[$start + 1]->type != CellExpressionTokenType::OpenParen) return null;
-		if ($tokens[$end]->type != CellExpressionTokenType::CloseParen) return null;
+		if ($tokens[$start + 1]->type !== CellExpressionTokenType::OpenParen) return null;
+		if ($tokens[$end]->type !== CellExpressionTokenType::CloseParen) return null;
 		$argList = self::tryArgumentList($tokens, $start + 2, $end - 1, $address);
 		if ($argList === null) return null;
 		return new CellExpression(CellExpressionOperation::Function, $argList, $qualifier);
 	private static function tryArgumentList(array $tokens, int $start, int $end,
 			CellAddress $address): ?array {
 		$count = $end - $start + 1;
-		if ($count == 0) return [];
+		if ($count === 0) return [];
 		$parenDepth = 0;
 		$argCount = 1;
 
 		$argTokens = []; // argindex -> [ start, end ]
 		$exprStartToken = $start;
 		for ($i = $start; $i <= $end; $i++) {
-			if ($tokens[$i]->type == CellExpressionTokenType::OpenParen) {
+			if ($tokens[$i]->type === CellExpressionTokenType::OpenParen) {
 				$parenDepth++;
-			} elseif ($tokens[$i]->type == CellExpressionTokenType::CloseParen) {
+			} elseif ($tokens[$i]->type === CellExpressionTokenType::CloseParen) {
 				$parenDepth--;
-			} elseif ($tokens[$i]->type == CellExpressionTokenType::Comma && $parenDepth == 0) {
+			} elseif ($tokens[$i]->type === CellExpressionTokenType::Comma && $parenDepth === 0) {
 				$exprEndToken = $i - 1;
 				array_push($argTokens, [ $exprStartToken, $exprEndToken ]);
 				$exprStartToken = $i + 1;
 	private static function tryRange(array $tokens, int $start, int $end,
 			CellAddress $address): ?CellExpression {
 		$count = $end - $start + 1;
-		if ($count != 3) return null;
+		if ($count !== 3) return null;
 		if (!$tokens[$start]->type->isPotentialAddress()) return null;
 		$first = mb_strtoupper($tokens[$start]->content);
-		if ($tokens[$start + 1]->type != CellExpressionTokenType::Colon) return null;
+		if ($tokens[$start + 1]->type !== CellExpressionTokenType::Colon) return null;
 		if (!$tokens[$end]->type->isPotentialAddress()) return null;
 		$last = mb_strtoupper($tokens[$end]->content);
 		$firstAddress = CellAddress::fromString($first);
 	 */
 	private static function tryReference(array $tokens, int $start, int $end,
 			CellAddress $address): ?CellExpression {
-		if ($start != $end) return null;
+		if ($start !== $end) return null;
 		if (!$tokens[$start]->type->isPotentialAddress()) return null;
 		$ref = mb_strtoupper($tokens[$start]->content);
 		$refAddress = CellAddress::fromString($ref, $address, true);
 		$candidates = [];
 		$parenLevel = 0;
 		for ($i = $start; $i <= $end; $i++) {
-			if ($tokens[$i]->type == CellExpressionTokenType::OpenParen) {
+			if ($tokens[$i]->type === CellExpressionTokenType::OpenParen) {
 				$parenLevel++;
-			} elseif ($tokens[$i]->type == CellExpressionTokenType::CloseParen) {
+			} elseif ($tokens[$i]->type === CellExpressionTokenType::CloseParen) {
 				$parenLevel--;
-			} elseif ($parenLevel == 0 && $i > $start && $i < $end) {
+			} elseif ($parenLevel === 0 && $i > $start && $i < $end) {
 				$op = $tokens[$i]->type->name;
 				$priority = self::infixPriority[$op] ?? false;
 				if ($priority === false) continue;
 			[ CellExpressionTokenType::Not, CellExpressionOperation::UnaryNot ],
 		];
 		foreach ($ops as $op) {
-			if ($tokens[$start]->type != $op[0]) continue;
+			if ($tokens[$start]->type !== $op[0]) continue;
 			$operand = self::tryExpression($tokens, $start + 1, $end, $address);
 			if ($operand === null) return null;
 			return new CellExpression($op[1], [ $operand ]);
 	 * Tests if a string is formatted like an address.
 	 */
 	public static function isAddress(string $text): bool {
-		return self::fromString($text) != null;
+		return self::fromString($text) !== null;
 	}
 
 	/**
 		if (!$this->isResolved && $resolveToRow) {
 			$newRowIndex = $relativeFrom->rowIndex;
 		}
-		if ($newRowIndex != -1 && !$this->isRowFixed) {
+		if ($newRowIndex !== -1 && !$this->isRowFixed) {
 			$rowDelta = $relativeTo->rowIndex - $relativeFrom->rowIndex;
 			$newRowIndex += $rowDelta;
 		}
 
 	public function equals($other): bool {
 		if (!($other instanceof CellAddress)) return false;
-		return $other->columnIndex == $this->columnIndex && $other->rowIndex == $this->rowIndex;
+		return $other->columnIndex === $this->columnIndex && $other->rowIndex === $this->rowIndex;
 	}
 
 	public function exactlyEquals($other): bool {
 		if (!($other instanceof CellAddress)) return false;
-		return $other->name == $this->name;
+		return $other->name === $this->name;
 	}
 
 	public function __toString(): string {
 			if ($throwIfInvalid) throw new CellEvaluationException("Bad address \"{$address}\"", '#REF');
 			return null;
 		}
-		$isColumnFixed = ($groups[1] == '$');
+		$isColumnFixed = ($groups[1] === '$');
 		$letters = mb_strtoupper($groups[2]);
-		$isRowFixed = ($groups[3] == '$');
+		$isRowFixed = ($groups[3] === '$');
 		$numbers = $groups[4];
 		$columnIndex = self::lettersToColumnIndex($letters);
-		$rowIndex = (mb_strlen($numbers) == 0) ? -1 : intval($numbers) - 1;
+		$rowIndex = (mb_strlen($numbers) === 0) ? -1 : intval($numbers) - 1;
 		if ($columnIndex < 0 && $relativeTo !== null) $columnIndex = $relativeTo->columnIndex;
 		if ($rowIndex < 0 && $relativeTo !== null) $rowIndex = $relativeTo->rowIndex;
 		return new CellAddress($columnIndex, $rowIndex, $isColumnFixed, $isRowFixed);
 	 * @param CellAddress $toCell
 	 */
 	public function __construct(CellAddress $fromCell, CellAddress $toCell) {
-		if ($fromCell->isResolved != $toCell->isResolved) {
+		if ($fromCell->isResolved !== $toCell->isResolved) {
 			throw new CellEvaluationException("Cannot mix resolved and unresolved cell addresses in range: {$fromCell->name} and {$toCell->name}");
 		}
 		$this->minColumnIndex = min($fromCell->columnIndex, $toCell->columnIndex);
 	 * @return object iterable object
 	 */
 	public function cellsIn(SpreadsheetGrid $grid): Iterator {
-		$min_col = $this->minColumnIndex;
-		$max_col = $this->maxColumnIndex;
-		$min_row = $this->minRowIndex;
-		$max_row = $this->maxRowIndex;
-		if ($min_row == -1) {
-			$min_row = 0;
-		}
-		if ($max_row == -1) {
-			$max_row = $grid->rowCount - 1;
-		}
-		$max_col = min($max_col, $grid->columnCount);
-		return new class($grid, $min_col, $max_col, $min_row, $max_row) implements Iterator {
+		$minCol = $this->minColumnIndex;
+		$maxCol = $this->maxColumnIndex;
+		$minRow = $this->minRowIndex;
+		$maxRow = $this->maxRowIndex;
+		if ($minRow === -1) {
+			$minRow = 0;
+		}
+		if ($maxRow === -1) {
+			$maxRow = $grid->rowCount - 1;
+		}
+		$maxCol = min($maxCol, $grid->columnCount);
+		return new class($grid, $minCol, $maxCol, $minRow, $maxRow) implements Iterator {
 			private SpreadsheetGrid $grid;
-			private int $min_col;
-			private int $max_col;
-			private int $min_row;
-			private int $max_row;
+			private int $minCol;
+			private int $maxCol;
+			private int $minRow;
+			private int $maxRow;
 			private int $col;
 			private int $row;
 			private ?CellAddress $address = null;
 			private ?SpreadsheetCell $cell = null;
-			function __construct($grid, $min_col, $max_col, $min_row, $max_row) {
+			function __construct($grid, $minCol, $maxCol, $minRow, $maxRow) {
 				$this->grid = $grid;
-				$this->min_col = $min_col;
-				$this->max_col = $max_col;
-				$this->min_row = $min_row;
-				$this->max_row = $max_row;
-				$this->col = $min_col;
-				$this->row = $min_row;
+				$this->minCol = $minCol;
+				$this->maxCol = $maxCol;
+				$this->minRow = $minRow;
+				$this->maxRow = $maxRow;
+				$this->col = $minCol;
+				$this->row = $minRow;
 				$this->setValues();
 			}
 
 			private function setValues() {
-				if ($this->col >= $this->min_col && $this->col <= $this->max_col &&
-						$this->row >= $this->min_row && $this->row <= $this->max_row) {
+				if ($this->col >= $this->minCol && $this->col <= $this->maxCol &&
+						$this->row >= $this->minRow && $this->row <= $this->maxRow) {
 					$this->address = new CellAddress($this->col, $this->row);
 					$this->cell = $this->grid->cellAt($this->address);
 					if (!$this->cell) {
 
 			private function increment(): void {
 				$this->row++;
-				if ($this->row > $this->max_row) {
-					$this->row = $this->min_row;
+				if ($this->row > $this->maxRow) {
+					$this->row = $this->minRow;
 					$this->col++;
 				}
 				$this->setValues();
 			}
 
 			function rewind(): void {
-				$this->row = $this->min_row;
-				$this->col = $this->min_col;
+				$this->row = $this->minRow;
+				$this->col = $this->minCol;
 				$this->setValues();
 			}
 
 			function valid(): bool {
-				return $this->address != null;
+				return $this->address !== null;
 			}
 		};
 	}
 		if (is_numeric($value)) {
 			$resolvedType = $type ?? CellValue::TYPE_NUMBER;
 			$resolvedDecimals = ($decimals !== null) ? $decimals :
-				($resolvedType == CellValue::TYPE_CURRENCY ? 2 :
-					CellValue::autodecimals($resolvedType == CellValue::TYPE_PERCENT ?
+				($resolvedType === CellValue::TYPE_CURRENCY ? 2 :
+					CellValue::autodecimals($resolvedType === CellValue::TYPE_PERCENT ?
 						$value * 100.0 : $value));
 			$formatted = CellValue::formatType($value, $resolvedType, $resolvedDecimals);
 			return new CellValue($formatted, $value, $resolvedType, $resolvedDecimals);
 		$cellString = ($cellString !== null) ? trim($cellString) : null;
 		$this->formattedValue = $cellString;
 		// blank
-		if ($cellString === null || $cellString == '') {
+		if ($cellString === null || $cellString === '') {
 			$this->type = CellValue::TYPE_BLANK;
 			$this->value = null;
 			return;
 		}
 		// =TRUE
 		$caps = mb_strtoupper($cellString);
-		if ($caps == 'TRUE') {
+		if ($caps === 'TRUE') {
 			$this->type = CellValue::TYPE_BOOLEAN;
 			$this->formattedValue = $caps;
 			$this->value = true;
 			return;
 		}
 		// =FALSE
-		if ($caps == 'FALSE') {
+		if ($caps === 'FALSE') {
 			$this->type = CellValue::TYPE_BOOLEAN;
 			$this->formattedValue = $caps;
 			$this->value = false;
 			case CellValue::TYPE_CURRENCY:
 			case CellValue::TYPE_NUMBER:
 			case CellValue::TYPE_PERCENT:
-				return $this->value != 0;
+				return $this->value !== 0;
 			case CellValue::TYPE_ERROR:
 			case CellValue::TYPE_FORMULA:
 			case CellValue::TYPE_STRING:
 	 */
 	public function divide(CellValue $b): CellValue {
 		return self::binaryNumericOperation($this, $b, '/', function($aVal, $bVal) {
-			if ($bVal == 0) throw new CellEvaluationException("Division by zero", '#NAN');
+			if ($bVal === 0) throw new CellEvaluationException("Division by zero", '#NAN');
 			return $aVal / $bVal;
 		});
 	}
 	 */
 	public function modulo($b) {
 		return self::binaryNumericOperation($this, $b, '%', function($aVal, $bVal) {
-			if ($bVal == 0) throw new CellEvaluationException("Division by zero", '#NAN');
+			if ($bVal === 0) throw new CellEvaluationException("Division by zero", '#NAN');
 			return $aVal % $bVal;
 		});
 	}
 	 * Returns the result of whether this value is equal to `$b`.
 	 */
 	public function eq(CellValue $b): CellValue {
-		return self::fromValue(CellValue::compare($this, $b) == 0);
+		return self::fromValue(CellValue::compare($this, $b) === 0);
 	}
 
 	/**
 	 * Returns the result of whether this value is unequal to `$b`.
 	 */
 	public function neq(CellValue $b): CellValue {
-		return self::fromValue(CellValue::compare($this, $b) != 0);
+		return self::fromValue(CellValue::compare($this, $b) !== 0);
 	}
 
 	/**
 			case CellValue::TYPE_CURRENCY:
 			case CellValue::TYPE_NUMBER:
 			case CellValue::TYPE_PERCENT:
-				return self::fromValue($this->value == 0);
+				return self::fromValue($this->value === 0);
 			case CellValue::TYPE_STRING:
 				throw new CellEvaluationException("Cannot perform NOT on string");
 			case CellValue::TYPE_BOOLEAN:
 	 * @throws CellEvaluationException  if types are incompatible for numeric operations
 	 */
 	private static function resolveNumericOperands(CellValue $a, CellValue $b, string $op): array {
-		if ($a->type == self::TYPE_ERROR) throw $a->value;
-		if ($b->type == self::TYPE_ERROR) throw $b->value;
-		if ($a->type == self::TYPE_STRING || $b->type == self::TYPE_STRING) {
+		if ($a->type === self::TYPE_ERROR) throw $a->value;
+		if ($b->type === self::TYPE_ERROR) throw $b->value;
+		if ($a->type === self::TYPE_STRING || $b->type === self::TYPE_STRING) {
 			throw new CellEvaluationException("Cannot perform math on text values");
 		}
 
-		if ($a->type == self::TYPE_BLANK) {
-			if ($b->type == self::TYPE_BLANK) {
+		if ($a->type === self::TYPE_BLANK) {
+			if ($b->type === self::TYPE_BLANK) {
 				return [ 0, 0, self::TYPE_NUMBER, 0 ];
 			}
 			return [ 0, $b->value, $b->type ];
-		} elseif ($b->type == self::TYPE_BLANK) {
+		} elseif ($b->type === self::TYPE_BLANK) {
 			return [ $a->value, 0, $a->type ];
 		}
 
-		$isMultOrDiv = ($op == '*' || $op == '/' || $op == '%');
+		$isMultOrDiv = ($op === '*' || $op === '/' || $op === '%');
 
-		if ($a->type == $b->type) {
+		if ($a->type === $b->type) {
 			return [ $a->value, $b->value, $a->type ];
 		}
 
 	 * @throws CellException  if `$a` or `$b` is of type `TYPE_ERROR`
 	 */
 	private static function resolveComparableArguments(CellValue $a, CellValue $b): array {
-		if ($a->type == CellValue::TYPE_ERROR) throw $a->value;
-		if ($b->type == CellValue::TYPE_ERROR) throw $b->value;
-		if ($a->type == CellValue::TYPE_FORMULA) throw new CellEvaluationException("Can't compare formula values");
-		if ($b->type == CellValue::TYPE_FORMULA) throw new CellEvaluationException("Can't compare formula values");
+		if ($a->type === CellValue::TYPE_ERROR) throw $a->value;
+		if ($b->type === CellValue::TYPE_ERROR) throw $b->value;
+		if ($a->type === CellValue::TYPE_FORMULA) throw new CellEvaluationException("Can't compare formula values");
+		if ($b->type === CellValue::TYPE_FORMULA) throw new CellEvaluationException("Can't compare formula values");
 		$aNumValue = $a->value;
 		$bNumValue = $b->value;
 		$aStrValue = "{$a->value}";
 				$bNumValue = ($bNumValue) ? 1 : 0;
 				break;
 		}
-		if ($a->type == CellValue::TYPE_STRING || $b->type == CellValue::TYPE_STRING) {
+		if ($a->type === CellValue::TYPE_STRING || $b->type === CellValue::TYPE_STRING) {
 			return [ $aStrValue, $bStrValue ];
 		}
 		return [ $aNumValue, $bNumValue ];
 	 * Tests if a type is numeric.
 	 */
 	public static function isTypeNumeric(string $type): bool {
-		return $type == CellValue::TYPE_NUMBER ||
-			$type == CellValue::TYPE_PERCENT ||
-			$type == CellValue::TYPE_CURRENCY ||
-			$type == CellValue::TYPE_BOOLEAN;
+		return $type === CellValue::TYPE_NUMBER ||
+			$type === CellValue::TYPE_PERCENT ||
+			$type === CellValue::TYPE_CURRENCY ||
+			$type === CellValue::TYPE_BOOLEAN;
 	}
 
 	public function __toString(): string {
 	 */
 	public function cellAt(CellAddress $address): SpreadsheetCell {
 		$c = $address->columnIndex; $r = $address->rowIndex;
-		if ($c < 0 || $c >= sizeof($this->cells)) throw new CellEvaluationException("Unresolved cell address {$address->name}", '#REF');
+		if ($c < 0 || $c >= count($this->cells)) throw new CellEvaluationException("Unresolved cell address {$address->name}", '#REF');
 		$col = $this->cells[$c];
-		if ($r < 0 || $r >= sizeof($col)) throw new CellEvaluationException("Unresolved cell address {$address->name}", '#REF');
+		if ($r < 0 || $r >= count($col)) throw new CellEvaluationException("Unresolved cell address {$address->name}", '#REF');
 		return $col[$r];
 	}
 
 
 	private function processTable(MDTableNode $tableNode, MDState $state) {
 		// Measure table
-		$rowCount = sizeof($tableNode->bodyRows());
+		$rowCount = count($tableNode->bodyRows());
 		$columnCount = 0;
 		foreach ($tableNode->bodyRows() as $row) {
-			$columnCount = max($columnCount, sizeof($row->children));
+			$columnCount = max($columnCount, count($row->children));
 		}
 
 		// Create and populate grid
 		$grid = new SpreadsheetGrid($columnCount, $rowCount);
 		for ($c = 0; $c < $columnCount; $c++) {
 			for ($r = 0; $r < $rowCount; $r++) {
-				$cellNode = $tableNode->bodyRows()[$r]->children[$c];
+				$row = $tableNode->bodyRows()[$r] ?? null;
+				if ($row === null) continue;
+				$cellNode = $row->children[$c] ?? null;
 				if ($cellNode === null) continue;
 				$cellText = $cellNode->toPlaintext($state);
 				$gridCell = $grid->cells[$c][$r];
 		// Copy results back to table
 		for ($c = 0; $c < $columnCount; $c++) {
 			for ($r = 0; $r < $rowCount; $r++) {
-				$cellNode = $tableNode->bodyRows()[$r]->children[$c];
+				$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;
 					$cellNode->addClass('calculated');
 				}
 				$cellNode->addClass("spreadsheet-type-{$gridValue->type}");
-				if ($gridValue->type == CellValue::TYPE_ERROR) {
+				if ($gridValue->type === CellValue::TYPE_ERROR) {
 					$cellNode->attributes['title'] = $gridValue->value;
 				}
 				$gridNumber = $gridValue->numericValue();

playground.html

 
 ### Modified Heading {style=color:red;}
 
-| Unit Price | Qty | Subtotal |
-| ---: | ---: | ---: |
-| $1.23 | 2 | =A*B FILL |
-| $4.99 | 6 | |
-| Total | | =SUM(C:C) |
+| Unit Price | Qty | Discount | Subtotal |
+| ---: | ---: | ---: | ---: |
+| $1.23 | 2 | 10% | =A\\*B*(1-C) FILL |
+| $4.99 | 6 | | |
+| $0.99 | 1 | 25% | |
+| Total | | | =SUM(D:D) |
 
 ---