Spreadsheet PHP mostly working

js/spreadsheet.js

 		if (!this.isResolved && resolveToRow) {
 			newRowIndex = relativeFrom.rowIndex;
 		}
-		if (newRowIndex != -1 && !this.isRowAbsolute) {
+		if (newRowIndex != -1 && !this.isRowFixed) {
 			const rowDelta = relativeTo.rowIndex - relativeFrom.rowIndex;
 			newRowIndex += rowDelta;
 		}

php/spreadsheet.php

  * `Function`.
  */
 enum CellExpressionOperation {
-	/** Arg is `number` */
+	/** Arg is `float` */
 	case Number;
 	/** Arg is `string` without quotes */
 	case String;
-	/** Arg is `boolean` */
+	/** Arg is `bool` */
 	case Boolean;
 	/** Arg is `CellAddress` */
 	case Reference;
 		/** @$CellAddress[] */
 		$expressionAddressQueue = [];
 		$range = new CellAddressRange(new CellAddress(0, 0), new CellAddress($colCount - 1, $rowCount - 1));
-		foreach ($range->cellsIn($this->grid) as $address) {
-			$cell = $this->grid->cellAt($address);
+		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) {
 				$cell->outputValue = $value;
 	 */
 	private function enqueueFilledBlanks(CellExpression $expression, array &$addresses) {
 		foreach ($expression->fillRanges ?? [] as $range) {
-			foreach ($range->cellsIn($this->grid) as $filledAddress) {
-				$filledCell = $this->grid->cellAt($filledAddress);
+			foreach ($range->cellsIn($this->grid) as $filledAddressStr => $filledCell) {
+				$filledAddress = CellAddress::fromString($filledAddressStr);
 				if ($filledCell->originalValue->type === CellValue::TYPE_BLANK &&
 						(!$filledCell->outputValue ||
 						$filledCell->outputValue->type === CellValue::TYPE_BLANK)) {
 			case CellExpressionOperation::Range: {
 				$range = $expr->arguments[0];
 				$values = [];
-				foreach ($range->cellsIn($this->grid) as $rAddress) {
-					$cell = $this->grid->cellAt($rAddress);
+				foreach ($range->cellsIn($this->grid) as $rAddressStr => $cell) {
+					$rAddress = CellAddress::fromString($rAddressStr);
 					if ($rAddress->equals($address)) continue;
 					$val = $this->grid->outputValueAt($rAddress);
 					if ($val === null) {
 		}
 		$evaled = array_map(fn($arg) => $this->evaluate($arg, $address), $args);
 		for ($i = 0; $i < sizeof($evaled) - 1; $i += 2) {
-			$test = $evaled[i].booleanValue();
+			$test = $evaled[$i].booleanValue();
 			if ($test === null) {
 				throw new CellEvaluationException("IFS expects a boolean for argument " . ($i + 1));
 			}
 	public ?string $qualifier;
 
 	/**
-	 * Optional format override. One of `number`, `currency`, `percent`.
+	 * Optional format override. One of `"number"`, `"currency"`, `"percent"`.
 	 */
 	public ?string $outputType = null;
 
 	 * @return ?CellExpression  parsed expression, or `null` if it failed
 	 */
 	public static function parse(string $expression, CellAddress $address): ?CellExpression {
-		$tokens = $this->expressionToTokens($expression);
+		$tokens = self::expressionToTokens($expression);
 		if (sizeof($tokens) == 0) return null;
-		$expr = $this->expressionFromTokens($tokens, $address);
+		$expr = self::expressionFromTokens($tokens, $address);
 		$expr->location = $address;
 		return $expr;
 	}
 	}
 
 	private function clone(): CellExpression {
-		$cp = new CellExpression();
-		$cp->op = $this->op;
-		$cp->arguments = array($this->arguments);
-		$cp->qualifier = $this->qualifier;
+		$cp = new CellExpression($this->op, array($this->arguments), $this->qualifier);
 		$cp->outputType = $this->outputType;
 		$cp->outputDecimals = $this->outputDecimals;
 		$cp->fillRanges = $this->fillRanges !== null ? array($this->fillRanges) : null;
 	 */
 	public static function expressionToTokens(string $text): array {
 		$tokens = [];
-		$pos = [0];
-		$this->skipWhitespace($text, $pos);
-		if (mb_substr($text, $pos[0], 1) == '=') {
+		$pos = 0;
+		self::skipWhitespace($text, $pos);
+		if (mb_substr($text, $pos, 1) === '=') {
 			// Ignore equals
-			$pos[0]++;
+			$pos++;
 		}
-		$this->skipWhitespace($text, $pos);
+		self::skipWhitespace($text, $pos);
 		$l = mb_strlen($text);
-		while ($pos[0] < $l) {
-			array_push($tokens, $this->readNextToken($text, $pos));
-			$this->skipWhitespace($text, $pos);
+		while ($pos < $l) {
+			array_push($tokens, self::readNextToken($text, $pos));
+			self::skipWhitespace($text, $pos);
 		}
 		return $tokens;
 	}
 	 */
 	private static function readNextToken(string $text, int &$pos): CellExpressionToken {
 		// Single char tokens
-		if ($token = $this->readNextSimpleToken($text, $pos, '==', CellExpressionTokenType::Equal)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '!=', CellExpressionTokenType::Unequal)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '<=', CellExpressionTokenType::LessThanEqual)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '>=', CellExpressionTokenType::GreaterThanEqual)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '<', CellExpressionTokenType::LessThan)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '>', CellExpressionTokenType::GreaterThan)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '!', CellExpressionTokenType::Not)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '+', CellExpressionTokenType::Plus)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '-', CellExpressionTokenType::Minus)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '*', CellExpressionTokenType::Multiply)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '/', CellExpressionTokenType::Divide)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, ',', CellExpressionTokenType::Comma)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '(', CellExpressionTokenType::OpenParen)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, ')', CellExpressionTokenType::CloseParen)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, ':', CellExpressionTokenType::Colon)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, ';', CellExpressionTokenType::Semicolon)) return $token;
-		if ($token = $this->readNextSimpleToken($text, $pos, '&', CellExpressionTokenType::Ampersand)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '==', CellExpressionTokenType::Equal)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '!=', CellExpressionTokenType::Unequal)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '<=', CellExpressionTokenType::LessThanEqual)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '>=', CellExpressionTokenType::GreaterThanEqual)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '<', CellExpressionTokenType::LessThan)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '>', CellExpressionTokenType::GreaterThan)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '!', CellExpressionTokenType::Not)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '+', CellExpressionTokenType::Plus)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '-', CellExpressionTokenType::Minus)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '*', CellExpressionTokenType::Multiply)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '/', CellExpressionTokenType::Divide)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, ',', CellExpressionTokenType::Comma)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '(', CellExpressionTokenType::OpenParen)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, ')', CellExpressionTokenType::CloseParen)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, ':', CellExpressionTokenType::Colon)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, ';', CellExpressionTokenType::Semicolon)) return $token;
+		if ($token = self::readNextSimpleToken($text, $pos, '&', CellExpressionTokenType::Ampersand)) return $token;
 		// Other tokens
-		if ($token = $this->readNextAddressToken($text, $pos)) return $token;
-		if ($token = $this->readNextNameToken($text, $pos)) return $token;
-		if ($token = $this->readNextNumberToken($text, $pos)) return $token;
-		if ($token = $this->readNextStringToken($text, $pos)) return $token;
+		if ($token = self::readNextAddressToken($text, $pos)) return $token;
+		if ($token = self::readNextNameToken($text, $pos)) return $token;
+		if ($token = self::readNextNumberToken($text, $pos)) return $token;
+		if ($token = self::readNextStringToken($text, $pos)) return $token;
 		$ch = mb_substr($text, $pos, 1);
 		throw new CellSyntaxException("Unexpected character \"{$ch}\" at {$pos}");
 	}
 		$address = '';
 		$isName = true;
 		if ($ch == '$') {
-			$address += $ch;
+			$address .= $ch;
 			$isName = false;
 			$p++;
 		}
-		$col = $this->readChars($text, $p, fn($s) => $this->isLetter($s), 1, 2);
+		$col = self::readChars($text, $p, fn($s) => self::isLetter($s), 1, 2);
 		if ($col === null) return null;
-		$address += $col;
+		$address .= $col;
 		$ch = mb_substr($text, $p, 1);
 		if ($ch == '$') {
-			$address += $ch;
+			$address .= $ch;
 			$isName = false;
 			$p++;
-			$row = $this->readChars($text, $p, $this->isDigit, 1);
+			$row = self::readChars($text, $p, fn($ch) => self::isDigit($ch), 1);
 			if ($row === null) return null;
-			$address += $row;
+			$address .= $row;
 		} else {
-			$row = $this->readChars($text, $p, $this->isDigit, 0);
+			$row = self::readChars($text, $p, fn($ch) => self::isDigit($ch), 0);
 			if ($row === null) return null;
-			$address += $row;
+			$address .= $row;
 		}
 		$pos = $p;
 		return new CellExpressionToken(
 
 	private static function readNextNameToken(string $text, int &$pos): ?CellExpressionToken {
 		$p = $pos;
-		$name = $this->readChars($text, $p, fn($s) => $this->isLetter($s), 1);
+		$name = self::readChars($text, $p, fn($s) => self::isLetter($s), 1);
 		if ($name === null) return null;
 		$pos = $p;
 		if (CellAddress::isAddress($name)) {
 
 	private static function readNextNumberToken(string $text, int &$pos): ?CellExpressionToken {
 		$ch = mb_substr($text, $pos, 1);
-		if (!$this->isDigit($ch)) return null;
+		if (!self::isDigit($ch)) return null;
 		$l = mb_strlen($text);
 		$numStr = $ch;
 		$pos++;
 		while ($pos < $l) {
 			$ch = mb_substr($text, $pos, 1);
-			if ($this->isDigit($ch)) {
+			if (self::isDigit($ch)) {
 				$pos++;
 				$numStr .= $ch;
 			} else {
 			$ch = mb_substr($text, $pos, 1);
 			if ($ch == '.') {
 				$numStr .= $ch;
-				$pos[0]++;
+				$pos++;
 				while ($pos < $l) {
-					$ch = mb_substr($text, $pos[0], 1);
-					if ($this->isDigit($ch)) {
+					$ch = mb_substr($text, $pos, 1);
+					if (self::isDigit($ch)) {
 						$pos++;
 						$numStr .= $ch;
 					} else {
 		$l = mb_strlen($text);
 		$inEscape = false;
 		while ($pos < $l) {
-			$ch = mb_substr($text, $pos[0], $pos[0] + 1);
+			$ch = mb_substr($text, $pos, 1);
 			$pos++;
 			if ($inEscape) {
 				$inEscape = false;
 			} elseif ($ch == '"') {
 				return new CellExpressionToken(CellExpressionTokenType::String, $str);
 			} else {
-				$str += $ch;
+				$str .= $ch;
 			}
 		}
 		throw new CellSyntaxException('Unterminated string');
 		while ($p < $l && ($maximumLength === null || $sl < $maximumLength)) {
 			$ch = mb_substr($text, $p, 1);
 			if (!$charTest($ch)) break;
-			$s += $ch;
+			$s .= $ch;
 			$sl++;
 			$p++;
 		}
-		if ($p < $l && $charTest(mb_substr($text, $p, $p + 1))) {
+		if ($p < $l && $charTest(mb_substr($text, $p, 1))) {
 			return null;
 		}
 		if ($minimumLength !== null && $sl < $minimumLength) {
 	 * @return ?CellExpression
 	 */
 	public static function expressionFromTokens(array $tokens, CellAddress $address): ?CellExpression {
-		if ($expr = $this->tryExpressionAndFormat($tokens, 0, sizeof($tokens) - 1, $address)) return $expr;
-		if ($expr = $this->tryExpressionAndFill($tokens, 0, sizeof($tokens) - 1, $address)) return $expr;
-		if ($expr = $this->tryExpression($tokens, 0, sizeof($tokens) - 1, $address)) return $expr;
+		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;
 		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) {
-				$expr = $this->tryExpressionAndFill($tokens, $start, $t - 1, $address) ??
-					$this->tryExpression($tokens, $start, $t - 1, $address);
+			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;
-				$format = $this->tryFormat($tokens, $t + 1, $end, $address);
+				$format = self::tryFormat($tokens, $t + 1, $end, $address);
 				if ($format === null) return null;
 				[ $expr->outputType, $expr->outputDecimals ] = $format;
 				return $expr;
 		if (!$tokens[$end]->type->isPotentialName()) return null;
 		$name = mb_strtoupper($tokens[$end]->content);
 		if ($name != 'FILL') return null;
-		$exp = $this->tryExpression($tokens, $start, $end - 1, $address);
+		$exp = self::tryExpression($tokens, $start, $end - 1, $address);
 		$columnIndex = $address->columnIndex;
 		$exp->fillRanges = [
 			new CellAddressRange(new CellAddress($columnIndex, -1), new CellAddress($columnIndex, -1)),
 	 */
 	private static function tryExpression(array $tokens, int $start, int $end,
 			CellAddress $address): CellExpression {
-		if ($expr = $this->tryParenExpression($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryNumber($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryString($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryBoolean($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryFunction($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryRange($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryReference($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryInfix($tokens, $start, $end, $address)) return $expr;
-		if ($expr = $this->tryUnary($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryParenExpression($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryNumber($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryString($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryBoolean($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryFunction($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryRange($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryReference($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryInfix($tokens, $start, $end, $address)) return $expr;
+		if ($expr = self::tryUnary($tokens, $start, $end, $address)) return $expr;
 		throw new CellSyntaxException("Invalid expression");
 	}
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 			if ($parenLevel < 0) return null;
 		}
 		if ($parenLevel != 0) return null;
-		return $this->tryExpression($tokens, $start + 1, $end - 1, $address);
+		return self::tryExpression($tokens, $start + 1, $end - 1, $address);
 	}
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 		$qualifier = $tokens[$start]->content;
 		if ($tokens[$start + 1]->type != CellExpressionTokenType::OpenParen) return null;
 		if ($tokens[$end]->type != CellExpressionTokenType::CloseParen) return null;
-		$argList = $this->tryArgumentList($tokens, $start + 2, $end - 1, $address);
+		$argList = self::tryArgumentList($tokens, $start + 2, $end - 1, $address);
 		if ($argList === null) return null;
 		return new CellExpression(CellExpressionOperation::Function, $argList, $qualifier);
 	}
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression[]|null
 	 */
 	private static function tryArgumentList(array $tokens, int $start, int $end,
-			CellAddress $address): ?CellExpression {
+			CellAddress $address): ?array {
 		$count = $end - $start + 1;
 		if ($count == 0) return [];
 		$parenDepth = 0;
 		// Convert token ranges to expressions
 		$args = [];
 		foreach ($argTokens as $argToken) {
-			$arg = $this->tryExpression($tokens, $argToken[0], $argToken[1], $address);
+			$arg = self::tryExpression($tokens, $argToken[0], $argToken[1], $address);
 			if ($arg === null) return null;
-			$args.push($arg);
+			array_push($args, $arg);
 		}
 		return $args;
 	}
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 				$parenLevel--;
 			} elseif ($parenLevel == 0 && $i > $start && $i < $end) {
 				$op = $tokens[$i]->type->name;
-				$priority = $this->infixPriority[$op] ?? false;
+				$priority = self::infixPriority[$op] ?? false;
 				if ($priority === false) continue;
-				array_push($candidates, [ 'priority' => priority, 'i' => $i ]);
+				array_push($candidates, [ 'priority' => $priority, 'i' => $i ]);
 			}
 		}
 		usort($candidates, fn($a, $b) => $a['priority'] - $b['priority']);
 		foreach ($candidates as $candidate) {
 			try {
 				$i = $candidate['i'];
-				$operand1 = $this->tryExpression($tokens, $start, $i - 1, $address);
+				$operand1 = self::tryExpression($tokens, $start, $i - 1, $address);
 				if ($operand1 === null) continue;
-				$operand2 = $this->tryExpression($tokens, $i + 1, $end, $address);
+				$operand2 = self::tryExpression($tokens, $i + 1, $end, $address);
 				if ($operand2 === null) continue;
 				$bestCandidate = $candidate;
 				break;
 		if ($bestCandidate === null) {
 			return null;
 		}
-		$i = $bestCandidate->i;
+		$i = $bestCandidate['i'];
 		switch ($tokens[$bestCandidate['i']]->type) {
 			case CellExpressionTokenType::Plus:
 				return new CellExpression(CellExpressionOperation::Add, [ $operand1, $operand2 ]);
 
 	/**
 	 * @param CellExpressionToken[] $tokens
-	 * @param number $start
-	 * @param number $end
+	 * @param int $start
+	 * @param int $end
 	 * @param CellAddress $address
 	 * @return CellExpression|null
 	 */
 		];
 		foreach ($ops as $op) {
 			if ($tokens[$start]->type != $op[0]) continue;
-			$operand = $this->tryExpression($tokens, $start + 1, $end, $address);
+			$operand = self::tryExpression($tokens, $start + 1, $end, $address);
 			if ($operand === null) return null;
 			return new CellExpression($op[1], [ $operand ]);
 		}
 	 * Whether the column should remain unchanged when transposed. This is
 	 * symbolized by prefixing the column name with a `$` (e.g. `$C3`).
 	 */
-	public bool $isColumnFixed = false;
+	public bool $isColumnFixed;
 
 	/**
 	 * Zero-based column index.
 	 */
-	public int $columnIndex = -1;
+	public int $columnIndex;
 
 	/**
 	 * Letter code for the column.
 	 * Whether the row should remain unchanged when transposed. This is
 	 * symbolized by prefixing the row number with a `$` (e.g. `C$3`).
 	 */
-	public bool $isRowFixed = false;
+	public bool $isRowFixed;
 
 	/**
 	 * Zero-based row index.
 	 */
-	public int $rowIndex = -1;
+	public int $rowIndex;
 
 	/**
 	 * One-based row number. This is the human-facing row number.
 	/**
 	 * Whether this address has both a definite column and row.
 	 */
-	public function isResolved(): bool { return $this->columnIndex >= 0 && $this->rowIndex >= 0; }
+	public bool $isResolved;
 
 	/**
 	 * @param int $columnIndex  0-based column index
 		$this->rowIndex = $rowIndex;
 		$this->isColumnFixed = $isColumnFixed;
 		$this->isRowFixed = $isRowFixed;
+		$this->isResolved = ($columnIndex >= 0 && $rowIndex >= 0);
 		$this->name = self::formatAddress($columnIndex, $rowIndex, $isColumnFixed, $isRowFixed);
 	}
 
 	 * @param CellAddress $relativeFrom  original address of the formula
 	 * @param CellAddress $relativeTo  address where the formula is being
 	 *   repeated
-	 * @param boolean $resolveToRow  whether to fill in a row number if this
+	 * @param bool $resolveToRow  whether to fill in a row number if this
 	 *   address doesn't have one
 	 * @return CellAddress|null   resolved address, or `null` if out of bounds
 	 */
 	public function transpose(CellAddress $relativeFrom, CellAddress $relativeTo,
 			bool $resolveToRow = true): ?CellAddress {
-		if (!$relativeFrom->isResolved() || !$relativeTo->isResolved()) {
+		if (!$relativeFrom->isResolved || !$relativeTo->isResolved) {
 			throw new CellEvaluationException("Can only transpose to and from resolved addresses");
 		}
 		$newColumnIndex = $this->columnIndex;
 		if (!$this->isResolved && $resolveToRow) {
 			$newRowIndex = $relativeFrom->rowIndex;
 		}
-		if ($newRowIndex != -1 && !$this->isRowAbsolute) {
+		if ($newRowIndex != -1 && !$this->isRowFixed) {
 			$rowDelta = $relativeTo->rowIndex - $relativeFrom->rowIndex;
 			$newRowIndex += $rowDelta;
 		}
 			$ACodepoint = ord('A');
 			$remaining = $columnIndex;
 			do {
-				$letters = chr(ACodepoint + (remaining % 26)) . $letters;
+				$letters = chr($ACodepoint + ($remaining % 26)) . $letters;
 				$remaining = floor($remaining / 26);
 			} while ($remaining > 0);
 		}
 		if ($isColumnFixed && $columnIndex >= 0) $addr .= '$';
 		if ($columnIndex >= 0) $addr .= self::columnIndexToLetters($columnIndex);
 		if ($isRowFixed && $rowIndex >= 0) $addr .= '$';
-		if ($rowIndex >= 0) $addr .= "${rowIndex + 1}";
+		if ($rowIndex >= 0) $addr .= ($rowIndex + 1);
 		return $addr;
 	}
 
 	 * @param string $address  cell address string
 	 * @param ?CellAddress $relativeTo  address to resolve relative
 	 *   addresses against
-	 * @param boolean $throwIfInvalid  whether to throw an error if address
+	 * @param bool $throwIfInvalid  whether to throw an error if address
 	 *   is invalid
 	 * @return ?CellAddress  address, if parsable
 	 * @throws CellEvaluationException  if the address is invalid and
 	 */
 	public static function fromString(string $address, ?CellAddress $relativeTo=null,
 			bool $throwIfInvalid=false): ?CellAddress {
-		if (!mb_eregi('^(\\$?)([A-Z]{1,2}?)((?:\\$(?=[0-9]))?)([0-9]*)$/', $address, $groups)) {
+		if (!mb_eregi('^(\\$?)([A-Z]{1,2}?)((?:\\$(?=[0-9]))?)([0-9]*)$', $address, $groups)) {
 			if ($throwIfInvalid) throw new CellEvaluationException("Bad address \"{$address}\"", '#REF');
 			return null;
 		}
 		$letters = mb_strtoupper($groups[2]);
 		$isRowFixed = ($groups[3] == '$');
 		$numbers = $groups[4];
-		$columnIndex = $this->lettersToColumnIndex($letters);
+		$columnIndex = self::lettersToColumnIndex($letters);
 		$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;
 	 * @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);
 	}
 
 	/**
-	 * Creates an iterator for every `CellAddress` in this range within the
+	 * Creates an iterator for every `CellAddress` string in this range within the
 	 * confines of the given grid's dimensions. Iterates each row in the first
 	 * column, then each row in the second, etc. Iteration range is inclusive
 	 * of the min and max extents.
 	 * 
 	 * Example:
 	 * ```
-	 * foreach (range.cellsIn(grid) as $address) {
+	 * foreach (range.cellsIn(grid) as $addressString => $cell) {
 	 *     ...
 	 * }
 	 * ```
 		$min_row = $this->minRowIndex;
 		$max_row = $this->maxRowIndex;
 		if ($min_row == -1) {
-			$min_row = $grid->getHeaderRowCount();
+			$min_row = 0;
 		}
 		if ($max_row == -1) {
-			$max_row = $grid->getRowCount() - 1;
+			$max_row = $grid->rowCount - 1;
 		}
-		$max_col = min($max_col, $grid->getColumnCount());
+		$max_col = min($max_col, $grid->columnCount);
 		return new class($grid, $min_col, $max_col, $min_row, $max_row) implements Iterator {
 			private SpreadsheetGrid $grid;
 			private int $min_col;
 				if ($this->col >= $this->min_col && $this->col <= $this->max_col &&
 						$this->row >= $this->min_row && $this->row <= $this->max_row) {
 					$this->address = new CellAddress($this->col, $this->row);
-					$this->cell = $this->grid->getCell($this->address);
+					$this->cell = $this->grid->cellAt($this->address);
 					if (!$this->cell) {
 						error_log("WARNING: Iterator found no cell at {$this->address->name}");
 					}
  */
 class CellValue {
 	/**
-	 * Blank cell. `value` is `null`.
+	 * Blank cell. `$value` is `null`.
 	 */
 	public const TYPE_BLANK = 'blank';
 	/**
-	 * Currency value. `value` is `number`.
+	 * Currency value. `$value` is `float`.
 	 */
 	public const TYPE_CURRENCY = 'currency';
 	/**
-	 * Regular number value. `value` is `number`.
+	 * Regular number value. `$value` is `float`.
 	 */
 	public const TYPE_NUMBER = 'number';
 	/**
-	 * Percentage. `value` is `number`, represented as a ratio (100% = 1.0).
+	 * Percentage. `$value` is `float`, represented as a ratio (100% = 1.0).
 	 */
 	public const TYPE_PERCENT = 'percent';
 	/**
-	 * Unaltered text value. `value` is `string`.
+	 * Unaltered text value. `$value` is `string`.
 	 */
 	public const TYPE_STRING = 'string';
 	/**
-	 * Boolean. `value` is `boolean`.
+	 * Boolean. `$value` is `bool`.
 	 */
 	public const TYPE_BOOLEAN = 'boolean';
 	/**
 	 * A formula that has resulted in an error during parsing or evaluation.
-	 * `value` is `string` error message.
+	 * `$value` is `string` error message.
 	 */
 	public const TYPE_ERROR = 'error';
 	/**
-	 * A formula expression. `value` is `string` and includes the leading `=`.
+	 * A formula expression. `$value` is `string` and includes the leading `=`.
 	 */
 	public const TYPE_FORMULA = 'formula';
 
 		string $type = CellValue::TYPE_STRING,
 		int $decimals = 0
 	) {
-		$this->formattedValue = formattedValue;
-		$this->value = value;
-		$this->type = type;
-		$this->decimals = decimals;
+		$this->formattedValue = $formattedValue;
+		$this->value = $value;
+		$this->type = $type;
+		$this->decimals = $decimals;
 	}
 
 	/**
 		}
 		if ($value instanceof Error) {
 			if ($value instanceof CellException) {
-				return new CellValue($value->errorSymbol, $value->message, CellValue::TYPE_ERROR);
+				return new CellValue($value->errorSymbol, $value->getMessage(), CellValue::TYPE_ERROR);
 			}
-			return new CellValue('#ERROR', $value->message, CellValue::TYPE_ERROR);
+			return new CellValue('#ERROR', $value->getMessage(), CellValue::TYPE_ERROR);
 		}
 		if (is_bool($value)) {
 			$formatted = CellValue::formatType($value, CellValue::TYPE_BOOLEAN, 0);
 			return new CellValue($formatted, $value, CellValue::TYPE_BOOLEAN);
 		}
 		if (is_numeric($value)) {
-			$resolvedType = $type || CellValue::TYPE_NUMBER;
+			$resolvedType = $type ?? CellValue::TYPE_NUMBER;
 			$resolvedDecimals = ($decimals !== null) ? $decimals :
 				($resolvedType == CellValue::TYPE_CURRENCY ? 2 :
 					CellValue::autodecimals($resolvedType == CellValue::TYPE_PERCENT ?
 			$wholes = mb_eregi_replace(',', '', $groups[1]);
 			$this->type = CellValue::TYPE_NUMBER;
 			$this->decimals = 0;
-			$this->value = parseFloat($wholes);
+			$this->value = floatval($wholes);
 			$this->formattedValue = CellValue::formatNumber($this->value, $this->decimals);
 			return;
 		}
 			case CellValue::TYPE_CURRENCY:
 			case CellValue::TYPE_NUMBER:
 			case CellValue::TYPE_PERCENT:
-				return $formatted ? $this->formattedValue : "${$this->value}";
+				return $formatted ? $this->formattedValue : "{$this->value}";
 			case CellValue::TYPE_STRING:
 				return $formatted ? $this->formattedValue : $this->value;
 			case CellValue::TYPE_ERROR:
 	 * @param CellValue $a  operand A
 	 * @param CellValue $b  operand B
 	 * @param string $op  operator symbol
-	 * @return array  3-element tuple array with A number value, B number value,
+	 * @return array  3-element tuple array with A float value, B float value,
 	 *   and result type string
 	 * @throws CellEvaluationException  if types are incompatible for numeric operations
 	 */
 	private static function resolveNumericOperands(CellValue $a, CellValue $b, string $op): array {
-		if ($a->type == $this->TYPE_ERROR) throw $a->value;
-		if ($b->type == $this->TYPE_ERROR) throw $b->value;
-		if ($a->type == $this->TYPE_STRING || $b->type == $this->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 == $this->TYPE_BLANK) {
-			if ($b->type == $this->TYPE_BLANK) {
-				return [ 0, 0, $this->TYPE_NUMBER, 0 ];
+		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 == $this->TYPE_BLANK) {
+		} elseif ($b->type == self::TYPE_BLANK) {
 			return [ $a->value, 0, $a->type ];
 		}
 
 		}
 
 		switch ($a->type . $b->type) {
-			case $this->TYPE_CURRENCY . $this->TYPE_NUMBER:
-			case $this->TYPE_CURRENCY . $this->TYPE_PERCENT:
-				return [ $a->value, $b->value, $this->TYPE_CURRENCY ];
-			case $this->TYPE_PERCENT . $this->TYPE_CURRENCY:
+			case self::TYPE_CURRENCY . self::TYPE_NUMBER:
+			case self::TYPE_CURRENCY . self::TYPE_PERCENT:
+				return [ $a->value, $b->value, self::TYPE_CURRENCY ];
+			case self::TYPE_PERCENT . self::TYPE_CURRENCY:
 				return [ $a->value, $b->value,
-						$isMultOrDiv ? $this->TYPE_CURRENCY : $this->TYPE_PERCENT ];
-			case $this->TYPE_PERCENT . $this->TYPE_NUMBER:
+						$isMultOrDiv ? self::TYPE_CURRENCY : self::TYPE_PERCENT ];
+			case self::TYPE_PERCENT . self::TYPE_NUMBER:
 				return [ $a->value, $b->value,
-						$isMultOrDiv ? $this->TYPE_NUMBER : $this->TYPE_PERCENT ];
-			case $this->TYPE_NUMBER . $this->TYPE_CURRENCY:
+						$isMultOrDiv ? self::TYPE_NUMBER : self::TYPE_PERCENT ];
+			case self::TYPE_NUMBER . self::TYPE_CURRENCY:
 				return [ $a->value, $b->value, $b->type ];
-			case $this->TYPE_NUMBER . $this->TYPE_PERCENT:
+			case self::TYPE_NUMBER . self::TYPE_PERCENT:
 				return [ $a->value, $b->value,
-						$isMultOrDiv ? $this->TYPE_NUMBER : $b->type ];
-			case $this->TYPE_BOOLEAN . $this->TYPE_CURRENCY:
-			case $this->TYPE_BOOLEAN . $this->TYPE_NUMBER:
-			case $this->TYPE_BOOLEAN . $this->TYPE_PERCENT:
+						$isMultOrDiv ? self::TYPE_NUMBER : $b->type ];
+			case self::TYPE_BOOLEAN . self::TYPE_CURRENCY:
+			case self::TYPE_BOOLEAN . self::TYPE_NUMBER:
+			case self::TYPE_BOOLEAN . self::TYPE_PERCENT:
 				return [ $a->value ? 1 : 0, $b->value, $b->type ];
-			case $this->TYPE_CURRENCY . $this->TYPE_BOOLEAN:
-			case $this->TYPE_NUMBER . $this->TYPE_BOOLEAN:
-			case $this->TYPE_PERCENT . $this->TYPE_BOOLEAN:
+			case self::TYPE_CURRENCY . self::TYPE_BOOLEAN:
+			case self::TYPE_NUMBER . self::TYPE_BOOLEAN:
+			case self::TYPE_PERCENT . self::TYPE_BOOLEAN:
 				return [ $a->value, $b->value ? 1 : 0, $a->type ];
 		}
-		throw new CellEvaluationException(`Unhandled operand types "${a.type}" and "${b.type}"`);
+		throw new CellEvaluationException("Unhandled operand types \"{$a->type}\" and \"{$b->type}\"");
 	}
 
 	/**
 			case CellValue::TYPE_BOOLEAN: return $value ? 'TRUE' : 'FALSE';
 			case CellValue::TYPE_STRING: return "{$value}";
 			case CellValue::TYPE_FORMULA: return "{$value}";
+			default: throw new CellException("Cannot format value of type {$type}");
 		}
 	}
 
 		if (str_starts_with($s, '-')) {
 			return '-$' . mb_substr($s, 1);
 		}
-		return '$' . s;
+		return '$' . $s;
 	}
 
 	private static function formatPercent(float|int $value, int $decimals): string {
 			$s = number_format($value, $maxDigits);
 			if (strpos($s, '.') === false) return 0;
 			$fraction = explode('.', $s)[1];
+			$fraction = rtrim($fraction, '0');
 			return min($maxDigits, mb_strlen($fraction));
 		}
 		return 0;
 		// Copy results back to table
 		for ($c = 0; $c < $columnCount; $c++) {
 			for ($r = 0; $r < $rowCount; $r++) {
-				$cellNode = $tableNode->bodyRows[$r]->children[$c];
+				$cellNode = $tableNode->bodyRows()[$r]->children[$c];
 				if ($cellNode === null) continue;
 				$gridCell = $grid->cells[$c][$r];
 				$gridValue = $gridCell->outputValue;

playgroundapi.php

 	'MDFootnoteReader' => true,
 	'MDAbbreviationReader' => true,
 	'MDParagraphReader' => true,
+	'MDSpreadsheetReader' => true,
 
 	'MDEmphasisReader' => true,
 	'MDStrongReader' => true,
 ];
 
 include 'php/markdown.php';
-$readers = [];
-foreach ($readerNames as $readerName) {
-	if ($permittedReaders[$readerName] ?? false) {
-		$ref = new ReflectionClass($readerName);
-		$reader = $ref->newInstanceArgs([]);
-		array_push($readers, $reader);
+include 'php/spreadsheet.php';
+try {
+	$readers = [];
+	foreach ($readerNames as $readerName) {
+		if ($permittedReaders[$readerName] ?? false) {
+			$ref = new ReflectionClass($readerName);
+			$reader = $ref->newInstanceArgs([]);
+			array_push($readers, $reader);
+		}
 	}
+	$parser = new Markdown($readers);
+	$html = $parser->toHTML($markdown);
+	header('Content-Type: text/html');
+	print($html);
+} catch (Error $e) {
+	header('Content-Type: text/html');
+	print('<pre><code>');
+	print($e->getMessage() . "\n");
+	print($e->getTraceAsString() . "\n");
+	print('</code></pre>');
+	flush();
+	throw $e;
 }
-$parser = new Markdown($readers);
-$html = $parser->toHTML($markdown);
-header('Content-Type: text/html');
-print($html);
 ?>