Initial port of spreadsheet code. Exposing members of MDBlocks and MDSpans. Adding toPlaintext method to blocks and spans.

js/markdown.js

 	 * @param {any} b
 	 * @returns {boolean}
 	 */
-	static equal(a, b) {
+	static equal(a, b, floatDifferencePercent=0.0) {
 		if (a instanceof Array && b instanceof Array) {
 			return this.#equalArrays(a, b);
 		}
 		if (a instanceof Object && b instanceof Object) {
 			return this.#equalObjects(a, b);
 		}
+		if (typeof a == 'number' && typeof b == 'number') {
+			if (a === b) return true;
+			const delta = b - a;
+			const ratio = delta / a;
+			return Math.abs(ratio) <= floatDifferencePercent;
+		}
 		return a == b;
 	}
 }
 		/** @type {MDToken} */
 		const token = result.tokens[0];
 		const tag = token.tag;
-		const span = new MDHTMLSpan(tag.fullTag);
+		const span = new MDHTMLSpan(tag);
 		tokens.splice(result.index, 1, span);
 		return true;
 	}
 
 	/**
 	 * @param {MDState} state
+	 * @returns {string}
 	 */
 	toHTML(state) {
-		throw new Error(`Abstract toHTML must be overridden in ${self.constructor.name}`);
+		throw new Error(`Abstract ${this.constructor.name}.toHTML must be implemented`);
+	}
+
+	/**
+	 * @param {MDState} state
+	 * @returns {string}
+	 */
+	toPlaintext(state) {
+		throw new Error(`Abstract ${this.constructor.name}.toPlaintext must be implemented`);
 	}
 
 	htmlAttributes() {
 	}
 
 	/**
+	 * @param {MDBlock[]} blocks
+	 * @param {MDState} state
+	 * @returns {string}
+	 */
+	static toPlaintext(blocks, state) {
+		return blocks.map((block) => block.toPlaintext(state)).join("\n");
+	}
+
+	/**
 	 * Visits all block and inline children of this block, calling the given
 	 * function with each. Should be implemented for any block with child nodes.
 	 *
 
 class MDMultiBlock extends MDBlock {
 	/** @type {MDBlock[]} */
-	#blocks;
+	blocks;
 
 	/**
 	 * @param {MDBlock[]} blocks
 	constructor(blocks) {
 		super();
 		if (blocks instanceof Array) {
-			this.#blocks = blocks;
+			this.blocks = blocks;
 		} else {
 			throw new Error(`${MDUtils.typename(this)} expects MDBlock[], got ${MDUtils.typename(blocks)}`);
 		}
 	}
 
 	toHTML(state) {
-		return MDBlock.toHTML(this.#blocks, state);
+		return MDBlock.toHTML(this.blocks, state);
+	}
+
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.blocks, state);
 	}
 
 	visitChildren(fn) {
-		for (const block of this.#blocks) {
+		for (const block of this.blocks) {
 			fn(block);
 			block.visitChildren(fn);
 		}
 
 class MDParagraphBlock extends MDBlock {
 	/** @type {MDBlock[]} */
-	#content;
+	content;
 
 	/**
 	 * @param {MDBlock|MDBlock[]} content
 	constructor(content) {
 		super();
 		if (content instanceof Array) {
-			this.#content = content;
+			this.content = content;
 		} else if (content instanceof MDBlock) {
-			this.#content = [ content ];
+			this.content = [ content ];
 		} else {
 			throw new Error(`${MDUtils.typename(this)} expects MDBlock[] or MDBlock, got ${MDUtils.typename(content)}`);
 		}
 	}
 
 	toHTML(state) {
-		const contentHTML = MDBlock.toHTML(this.#content, state);
+		const contentHTML = MDBlock.toHTML(this.content, state);
 		return `<p${this.htmlAttributes()}>${contentHTML}</p>\n`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		for (const child of this.#content) {
+		for (const child of this.content) {
 			fn(child);
 			child.visitChildren(fn);
 		}
 
 class MDHeaderBlock extends MDBlock {
 	/** @type {number} */
-	#level;
+	level;
 	/** @type {MDBlock[]} */
-	#content;
+	content;
 
 	/**
 	 * @param {number} level
 	 */
 	constructor(level, content) {
 		super();
-		this.#level = level;
-		this.#content = (content instanceof Array) ? content : [ content ];
+		this.level = level;
+		this.content = (content instanceof Array) ? content : [ content ];
 	}
 
 	toHTML(state) {
-		let contentHTML = MDBlock.toHTML(this.#content, state);
-		return `<h${this.#level}${this.htmlAttributes()}>${contentHTML}</h${this.#level}>\n`;
+		let contentHTML = MDBlock.toHTML(this.content, state);
+		return `<h${this.level}${this.htmlAttributes()}>${contentHTML}</h${this.level}>\n`;
+	}
+
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.content, state);
 	}
 
 	visitChildren(fn) {
-		for (const child of this.#content) {
+		for (const child of this.content) {
 			fn(child);
 			child.visitChildren(fn);
 		}
 		return `<blockquote${this.htmlAttributes()}>\n${contentHTML}\n</blockquote>`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
 		for (const block of this.content) {
 			fn(block);
 		return `<ul${this.htmlAttributes()}>\n${contentHTML}\n</ul>`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.items, state);
+	}
+
 	visitChildren(fn) {
 		for (const item of this.items) {
 			fn(item);
 		return `<ol${this.htmlAttributes()}>\n${contentHTML}\n</ol>`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.items, state);
+	}
+
 	visitChildren(fn) {
 		for (const item of this.items) {
 			fn(item);
 }
 
 class MDListItemBlock extends MDBlock {
-	/** @type {MDBlock} */
+	/** @type {MDBlock[]} */
 	content;
 	/** @type {number|null} */
 	ordinal;
 
 	/**
-	 * @param {MDBlock} content
+	 * @param {MDBlock|MDBlock[]} content
+	 * @param {number|null} ordinal
 	 */
 	constructor(content, ordinal=null) {
 		super();
-		this.content = content;
+		if (content instanceof Array) {
+			this.content = content;
+		} else {
+			this.content = [ content ];
+		}
 		this.ordinal = ordinal;
 	}
 
 	toHTML(state) {
-		let contentHTML = this.content.toHTML(state);
+		let contentHTML = MDBlock.toHTML(this.content, state);
 		return `<li${this.htmlAttributes()}>${contentHTML}</li>`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		fn(this.content);
-		this.content.visitChildren(fn);
+		for (const child of this.content) {
+			fn(child);
+			child.visitChildren(fn);
+		}
 	}
 }
 
 class MDCodeBlock extends MDBlock {
 	/** @type {string} */
-	#code;
+	code;
 
 	/**
 	 * @param {string} code
 	 */
 	constructor(code) {
 		super();
-		this.#code = code;
+		this.code = code;
 	}
 
 	toHTML(state) {
-		return `<pre${this.htmlAttributes()}><code>${MDUtils.escapeHTML(this.#code)}</code></pre>`;
+		return `<pre${this.htmlAttributes()}><code>${MDUtils.escapeHTML(this.code)}</code></pre>`;
+	}
+
+	toPlaintext(state) {
+		return this.code;
 	}
 }
 
 	toHTML(state) {
 		return `<hr${this.htmlAttributes()}>\n`;
 	}
+
+	toPlaintext(state) {
+		return '';
+	}
 }
 
 class MDTableCellBlock extends MDBlock {
 	static AlignRight = 'right';
 
 	/** @type {MDBlock} */
-	#content;
+	content;
 	/** @type {string|null} */
 	align = null;
 
 	 */
 	constructor(content) {
 		super();
-		this.#content = content;
+		this.content = content;
 	}
 
 	#alignAttribute() {
 	}
 
 	toHTML(state) {
-		let contentHTML = this.#content.toHTML(state);
+		let contentHTML = this.content.toHTML(state);
 		return `<td${this.htmlAttributes()}>${contentHTML}</td>`;
 	}
 
+	toPlaintext(state) {
+		return this.content.toPlaintext(state);
+	}
+
 	visitChildren(fn) {
-		fn(this.#content);
-		this.#content.visitChildren(fn);
+		fn(this.content);
+		this.content.visitChildren(fn);
 	}
 }
 
 
 class MDTableRowBlock extends MDBlock {
 	/** @type {MDTableCellBlock[]|MDTableHeaderCellBlock[]} */
-	#cells;
+	cells;
 
 	/**
 	 * @param {MDTableCellBlock[]|MDTableHeaderCellBlock[]} cells
 	 */
 	constructor(cells) {
 		super();
-		this.#cells = cells;
+		this.cells = cells;
 	}
 
 	/**
 	 * @param {string[]} alignments
 	 */
 	applyAlignments(alignments) {
-		for (var i = 0; i < this.#cells.length; i++) {
-			let cell = this.#cells[i];
+		for (var i = 0; i < this.cells.length; i++) {
+			let cell = this.cells[i];
 			let align = i < alignments.length ? alignments[i] : null;
 			cell.align = align;
 		}
 	}
 
 	toHTML(state) {
-		let cellsHTML = MDBlock.toHTML(this.#cells, state);
+		let cellsHTML = MDBlock.toHTML(this.cells, state);
 		return `<tr${this.htmlAttributes()}>\n${cellsHTML}\n</tr>`;
 	}
 
+	toPlaintext(state) {
+		return this.cells.map((cell) => cell.toPlaintext(state)).join(' ');
+	}
+
 	visitChildren(fn) {
-		for (const cell of this.#cells) {
+		for (const cell of this.cells) {
 			fn(cell);
 			cell.visitChildren(fn);
 		}
 
 class MDTableBlock extends MDBlock {
 	/** @type {MDTableRowBlock} */
-	#headerRow;
+	headerRow;
 	/** @type {MDTableRowBlock[]} */
-	#bodyRows;
+	bodyRows;
 
 	/**
 	 * @param {MDTableRowBlock} headerRow
 	 */
 	constructor(headerRow, bodyRows) {
 		super();
-		this.#headerRow = headerRow;
-		this.#bodyRows = bodyRows;
+		this.headerRow = headerRow;
+		this.bodyRows = bodyRows;
 	}
 
 	toHTML(state) {
-		let headerRowHTML = this.#headerRow.toHTML(state);
-		let bodyRowsHTML = MDBlock.toHTML(this.#bodyRows, state);
+		let headerRowHTML = this.headerRow.toHTML(state);
+		let bodyRowsHTML = MDBlock.toHTML(this.bodyRows, state);
 		return `<table${this.htmlAttributes()}>\n<thead>\n${headerRowHTML}\n</thead>\n<tbody>\n${bodyRowsHTML}\n</tbody>\n</table>`;
 	}
 
+	toPlaintext(state) {
+		return this.headerRow.toPlaintext(state) + "\n" + this.bodyRows.map((row) => row.toPlaintext(state)).join("\n");
+	}
+
 	visitChildren(fn) {
-		fn(this.#headerRow);
-		this.#headerRow.visitChildren(fn);
-		for (const row of this.#bodyRows) {
+		fn(this.headerRow);
+		this.headerRow.visitChildren(fn);
+		for (const row of this.bodyRows) {
 			fn(row);
 			row.visitChildren(fn);
 		}
 
 class MDDefinitionListBlock extends MDBlock {
 	/** @type {MDBlock[]} */
-	#content;
+	content;
 
 	/**
 	 * @param {MDBlock[]} content
 	 */
 	constructor(content) {
 		super();
-		this.#content = content;
+		this.content = content;
 	}
 
 	toHTML(state) {
-		let contentHTML = MDBlock.toHTML(this.#content, state);
+		let contentHTML = MDBlock.toHTML(this.content, state);
 		return `<dl${this.htmlAttributes()}>\n${contentHTML}\n</dl>`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		for (const block of this.#content) {
+		for (const block of this.content) {
 			fn(block);
 			block.visitChildren(fn);
 		}
 
 class MDDefinitionTermBlock extends MDBlock {
 	/** @type {MDBlock[]} */
-	#content;
+	content;
 
 	/**
 	 * @param {MDBlock|MDBlock[]} content
 	constructor(content) {
 		super();
 		if (content instanceof Array) {
-			this.#content = content;
+			this.content = content;
 		} else if (content instanceof MDBlock) {
-			this.#content = [ content ];
+			this.content = [ content ];
 		} else {
 			throw new Error(`${this.constructor.name} expects MDBlock or MDBlock[], got ${typeof content}`);
 		}
 	}
 
 	toHTML(state) {
-		let contentHTML = MDBlock.toHTML(this.#content, state);
+		let contentHTML = MDBlock.toHTML(this.content, state);
 		return `<dt${this.htmlAttributes()}>${contentHTML}</dt>`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		for (const child of this.#content) {
+		for (const child of this.content) {
 			fn(child);
 			child.visitChildren(fn);
 		}
 
 class MDDefinitionDefinitionBlock extends MDBlock {
 	/** @type {MDBlock[]} */
-	#content;
+	content;
 
 	/**
 	 * @param {MDBlock|MDBlock[]} content
 	constructor(content) {
 		super();
 		if (content instanceof Array) {
-			this.#content = content;
+			this.content = content;
 		} else if (content instanceof MDBlock) {
-			this.#content = [ content ];
+			this.content = [ content ];
 		} else {
 			throw new Error(`${this.constructor.name} expects MDBlock or MDBlock[], got ${typeof content}`);
 		}
 	}
 
 	toHTML(state) {
-		let contentHTML = MDBlock.toHTML(this.#content, state);
+		let contentHTML = MDBlock.toHTML(this.content, state);
 		return `<dd${this.htmlAttributes()}>${contentHTML}</dd>`;
 	}
 
+	toPlaintext(state) {
+		return MDBlock.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		for (const child of this.#content) {
+		for (const child of this.content) {
 			fn(child);
 			child.visitChildren(fn);
 		}
 		html += '</div>';
 		return html;
 	}
+
+	toPlaintext(state) {
+		const footnotes = state.footnotes;
+		var symbolOrder = Object.keys(footnotes);
+		if (Object.keys(footnotes).length == 0) return '';
+		var text = '';
+		for (const symbol of symbolOrder) {
+			let content = footnotes[symbol];
+			if (!content) continue;
+			text += `${symbol}. ${content.toPlaintext(state)}\n`;
+		}
+		return text.trim();
+	}
 }
 
 class MDInlineBlock extends MDBlock {
 	/** @type {MDSpan[]} */
-	#content;
+	content;
 
 	/**
 	 * @param {MDSpan|MDSpan[]} content
 	 */
 	constructor(content) {
 		super();
-		this.#content = (content instanceof Array) ? content : [ content ];
-		for (const span of this.#content) {
+		this.content = (content instanceof Array) ? content : [ content ];
+		for (const span of this.content) {
 			if (!(span instanceof MDSpan)) {
 				throw new Error(`${this.constructor.name} expects MDSpan or MDSpan[], got ${MDUtils.typename(span)}`);
 			}
 	}
 
 	toHTML(state) {
-		return MDSpan.toHTML(this.#content, state);
+		return MDSpan.toHTML(this.content, state);
+	}
+
+	toPlaintext(state) {
+		return MDSpan.toPlaintext(this.content, state);
 	}
 
 	visitChildren(fn) {
-		for (const span of this.#content) {
+		for (const span of this.content) {
 			fn(span);
 			span.visitChildren(fn);
 		}
 	 * @returns {string} HTML
 	 */
 	toHTML(state) {
-		throw new Error(`Abstract toHTML must be overridden in ${self.constructor.name}`);
+		throw new Error(`Abstract ${this.constructor.name}.toHTML must be implemented`);
+	}
+
+	toPlaintext(state) {
+		throw new Error(`Abstract ${this.constructor.name}.toPlaintext must be implemented`);
 	}
 
 	htmlAttributes() {
 	/**
 	 * @param {MDSpan[]} spans
 	 * @param {MDState} state
+	 * @returns {string}
 	 */
 	static toHTML(spans, state) {
-		return spans.map((span) => span.toHTML(state)).join("");
+		return spans.map((span) => span.toHTML(state)).join('');
+	}
+
+	/**
+	 * @param {MDSpan[]} spans
+	 * @param {MDState} state
+	 * @returns {string}
+	 */
+	static toPlaintext(spans, state) {
+		return spans.map((span) => span.toPlaintext(state)).join('');
 	}
 
 	/**
 		return MDSpan.toHTML(this.content, state);
 	}
 
+	toPlaintext(state) {
+		return MDSpan.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
 		for (const span of this.content) {
 			fn(span);
 		}
 		return html;
 	}
+
+	toPlaintext(state) {
+		return this.text;
+	}
 }
 
 class MDHTMLSpan extends MDSpan {
-	/** @param {string} html */
-	html;
+	/** @param {string} */
+	tag;
 
 	/**
-	 * @param {string} html
+	 * @param {MDHTMLTag} tag
 	 */
-	constructor(html) {
+	constructor(tag) {
 		super();
-		this.html = html;
+		this.tag = tag;
 	}
 
 	toHTML(state) {
-		return this.html;
+		return this.tag.fullTag;
+	}
+
+	toPlaintext(state) {
+		return '';
 	}
 }
 
 	toHTML(state) {
 		return MDUtils.escapeObfuscated(this.text);
 	}
+
+	toPlaintext(state) {
+		return this.text;
+	}
 }
 
 class MDLinkSpan extends MDSpan {
 		return html;
 	}
 
+	toPlaintext(state) {
+		return this.content.toPlaintext(state);
+	}
+
 	visitChildren(fn) {
 		fn(this.content);
 		this.content.visitChildren(fn);
 	ref;
 
 	constructor(ref, content) {
-		super(null, content);
+		super(null, content, null);
 		this.ref = ref;
 	}
 
 
 class MDEmphasisSpan extends MDSpan {
 	/** @type {MDSpan[]} */
-	#content;
+	content;
 
 	/**
 	 * @param {MDSpan|MDSpan[]} content
 	 */
 	constructor(content) {
 		super();
-		this.#content = (content instanceof MDSpan) ? [ content ] : content;
+		this.content = (content instanceof MDSpan) ? [ content ] : content;
 	}
 
 	toHTML(state) {
-		let contentHTML = MDSpan.toHTML(this.#content, state);
+		let contentHTML = MDSpan.toHTML(this.content, state);
 		return `<em${this.htmlAttributes()}>${contentHTML}</em>`;
 	}
 
+	toPlaintext(state) {
+		return MDSpan.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		for (const span of this.#content) {
+		for (const span of this.content) {
 			fn(span);
 			span.visitChildren(fn);
 		}
 
 class MDStrongSpan extends MDSpan {
 	/** @type {MDSpan[]} content */
-	#content;
+	content;
 
 	/**
 	 * @param {MDSpan|MDSpan[]} content
 	 */
 	constructor(content) {
 		super();
-		this.#content = (content instanceof MDSpan) ? [content] : content;
+		this.content = (content instanceof MDSpan) ? [content] : content;
 	}
 
 	toHTML(state) {
-		let contentHTML = MDSpan.toHTML(this.#content, state);
+		let contentHTML = MDSpan.toHTML(this.content, state);
 		return `<strong${this.htmlAttributes()}>${contentHTML}</strong>`;
 	}
 
+	toPlaintext(state) {
+		return MDSpan.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		for (const span of this.#content) {
+		for (const span of this.content) {
 			fn(span);
 			span.visitChildren(fn);
 		}
 
 class MDStrikethroughSpan extends MDSpan {
 	/** @type {MDSpan[]} content */
-	#content;
+	content;
 
 	/**
 	 * @param {MDSpan|MDSpan[]} content
 	 */
 	constructor(content) {
 		super();
-		this.#content = (content instanceof MDSpan) ? [content] : content;
+		this.content = (content instanceof MDSpan) ? [content] : content;
 	}
 
 	toHTML(state) {
-		let contentHTML = MDSpan.toHTML(this.#content, state);
+		let contentHTML = MDSpan.toHTML(this.content, state);
 		return `<strike${this.htmlAttributes()}>${contentHTML}</strike>`;
 	}
 
+	toPlaintext(state) {
+		return MDSpan.toPlaintext(this.content, state);
+	}
+
 	visitChildren(fn) {
-		for (const span of this.#content) {
+		for (const span of this.content) {
 			fn(span);
 			span.visitChildren(fn);
 		}
 
 class MDCodeSpan extends MDSpan {
 	/** @type {String} content */
-	#content;
+	content;
 
 	/**
 	 * @param {String} content
 	constructor(content) {
 		super();
 		if (typeof content == 'string') {
-			this.#content = content;
+			this.content = content;
 		} else {
 			throw new Error(`${this.constructor.name} content must be String, got ${typeof content}`);
 		}
 	}
 
 	toHTML(state) {
-		return `<code${this.htmlAttributes()}>${MDUtils.escapeHTML(this.#content)}</code>`;
+		return `<code${this.htmlAttributes()}>${MDUtils.escapeHTML(this.content)}</code>`;
+	}
+
+	toPlaintext(state) {
+		return this.content;
 	}
 }
 
 		html += '>';
 		return html;
 	}
+
+	toPlaintext(state) {
+		return this.alt || '';
+	}
 }
 
 class MDReferencedImageSpan extends MDImageSpan {
 		}
 		return `<!--FNREF:{${this.symbol}}-->`;
 	}
+
+	toPlaintext(state) {
+		return this.symbol;
+	}
 }
 
 
 	/** @type {string[]} */
 	#lines = [];
 
-	/** @type {object} */
+	/**
+	 * Abbreviation string (case sensitive) -> definition string
+	 * @type {object}
+	 */
 	#abbreviations = {};
 
-	/** @type {object} */
+	/**
+	 * Abbreviation string (case sensitive) -> RegExp
+	 * @type {object}
+	 */
 	#abbreviationRegexes = {};
 
 	/**
-	 * symbol:string -> content:MDBlock
+	 * Footnote symbol string -> content MDBlock
 	 * @type {object}
 	 */
 	#footnotes = {};
 
 	/**
-	 * symbol:string -> number[]
+	 * Footnote symbol string -> unique number[]
 	 * @type {object}
 	 */
 	#footnoteInstances = {};
 
-	/** @type {object} */
+	/**
+	 * Reference symbol -> URL string
+	 * @type {object}
+	 */
 	#urlDefinitions = {};
 
-	/** @type {object} */
+	/**
+	 * Reference symbol -> title string
+	 * @type {object}
+	 */
 	#urlTitles = {};
 
 	/** @type {number} */

testjs.html

 			}
 		</style>
 		<script src="js/markdown.js"></script>
+		<script src="js/spreadsheet.js"></script>
 		<!-- Testing infrastructure -->
 		<script>
 			/**
 				assertFalse(test, failMessage=null) {
 					if (test) this.fail(failMessage || `expected false, got ${test}`);
 				}
-				assertEqual(a, b, failMessage=null) {
-					if (MDUtils.equal(a, b)) return;
-					const aVal = `${a}`;
-					const bVal = `${b}`;
+				assertEqual(a, b, floatDifferenceRatio=0.0, failMessage=null) {
+					if (MDUtils.equal(a, b, floatDifferenceRatio)) return;
+					const aVal = (typeof a == 'string') ? `"${a}"` : `${a}`;
+					const bVal = (typeof b == 'string') ? `"${b}"` : `${b}`;
 					if (aVal.length > 20 || bVal.length > 20) {
 						this.fail(failMessage || `equality failed:\n${aVal}\n!=\n${bVal}`);
 					} else {
 		<script>
 			function onLoad() {
 				let testClasses = [
-					TokenTests,
-					UtilsTests,
-					InlineTests,
-					BlockTests,
+					// FIXME: Reenable these! Disabled temporarily to test spreadsheets faster.
+					// TokenTests,
+					// UtilsTests,
+					// InlineTests,
+					// BlockTests,
+					CellValueTests,
 				];
 				TestClassRunner.runAll(testClasses);
 			}
 					this.assertEqual(actual, expected);
 				}
 			}
+
+			class CellValueTests extends BaseTest {
+				test_fromCellString_blank() {
+					var value;
+					value = CellValue.fromCellString('');
+					this.assertEqual(value.type, CellValue.TYPE_BLANK);
+					this.assertEqual(value.formattedValue, '');
+					this.assertEqual(value.value, null);
+					value = CellValue.fromCellString(' ');
+					this.assertEqual(value.type, CellValue.TYPE_BLANK);
+					this.assertEqual(value.formattedValue, '');
+					this.assertEqual(value.value, null);
+				}
+
+				test_fromCellString_number() {
+					var value;
+					value = CellValue.fromCellString('123');
+					this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+					this.assertEqual(value.formattedValue, '123');
+					this.assertEqual(value.value, 123);
+					this.assertEqual(value.decimals, 0);
+					value = CellValue.fromCellString('-0');
+					this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+					this.assertEqual(value.formattedValue, '-0');
+					this.assertEqual(value.value, 0);
+					this.assertEqual(value.decimals, 0);
+					value = CellValue.fromCellString('1,234');
+					this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+					this.assertEqual(value.formattedValue, '1,234');
+					this.assertEqual(value.value, 1234);
+					this.assertEqual(value.decimals, 0);
+					value = CellValue.fromCellString('-1,234,567.89');
+					this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+					this.assertEqual(value.formattedValue, '-1,234,567.89');
+					this.assertEqual(value.value, -1234567.89);
+					this.assertEqual(value.decimals, 2);
+				}
+
+				test_fromCellString_percent() {
+					var value;
+					value = CellValue.fromCellString('123%');
+					this.assertEqual(value.type, CellValue.TYPE_PERCENT);
+					this.assertEqual(value.formattedValue, '123%');
+					this.assertEqual(value.value, 1.23, 0.0001);
+					this.assertEqual(value.decimals, 0);
+					value = CellValue.fromCellString('-12.3%');
+					this.assertEqual(value.type, CellValue.TYPE_PERCENT);
+					this.assertEqual(value.formattedValue, '-12.3%');
+					this.assertEqual(value.value, -0.123, 0.0001);
+					this.assertEqual(value.decimals, 1);
+				}
+
+				test_fromCellString_currency() {
+					var value;
+					value = CellValue.fromCellString('$123');
+					this.assertEqual(value.type, CellValue.TYPE_CURRENCY);
+					this.assertEqual(value.formattedValue, '$123');
+					this.assertEqual(value.value, 123);
+					this.assertEqual(value.decimals, 0);
+					value = CellValue.fromCellString('-$12.34');
+					this.assertEqual(value.type, CellValue.TYPE_CURRENCY);
+					this.assertEqual(value.formattedValue, '-$12.34');
+					this.assertEqual(value.value, -12.34, 0.0001);
+					this.assertEqual(value.decimals, 2);
+				}
+
+				test_fromCellString_boolean() {
+					var value;
+					value = CellValue.fromCellString('true');
+					this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
+					this.assertEqual(value.formattedValue, 'TRUE');
+					this.assertEqual(value.value, true);
+					value = CellValue.fromCellString('false');
+					this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
+					this.assertEqual(value.formattedValue, 'FALSE');
+					this.assertEqual(value.value, false);
+				}
+
+				test_fromCellString_string() {
+					var value;
+					value = CellValue.fromCellString('some text');
+					this.assertEqual(value.type, CellValue.TYPE_STRING);
+					this.assertEqual(value.formattedValue, 'some text');
+					this.assertEqual(value.value, 'some text');
+					value = CellValue.fromCellString("'123");
+					this.assertEqual(value.type, CellValue.TYPE_STRING);
+					this.assertEqual(value.formattedValue, '123');
+					this.assertEqual(value.value, '123');
+				}
+
+				test_fromCellString_formula() {
+					var value;
+					value = CellValue.fromCellString('=A*B');
+					this.assertEqual(value.type, CellValue.TYPE_FORMULA);
+					this.assertEqual(value.formattedValue, '=A*B');
+					this.assertEqual(value.value, '=A*B');
+					value = CellValue.fromCellString('=MAX(A, 3)');
+					this.assertEqual(value.type, CellValue.TYPE_FORMULA);
+					this.assertEqual(value.formattedValue, '=MAX(A, 3)');
+					this.assertEqual(value.value, '=MAX(A, 3)');
+				}
+
+				test_fromValue_null() {
+					var value;
+					value = CellValue.fromValue(null);
+					this.assertEqual(value.type, CellValue.TYPE_BLANK);
+				}
+
+				test_fromValue_number() {
+					var value;
+					value = CellValue.fromValue(123);
+					this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+					this.assertEqual(value.formattedValue, '123');
+					value = CellValue.fromValue(3.141592);
+					this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+					this.assertEqual(value.formattedValue, '3.141592');
+					value = CellValue.fromValue(123456789);
+					this.assertEqual(value.type, CellValue.TYPE_NUMBER);
+					this.assertEqual(value.formattedValue, '123,456,789');
+				}
+
+				test_fromValue_boolean() {
+					var value;
+					value = CellValue.fromValue(true);
+					this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
+					this.assertEqual(value.formattedValue, 'TRUE');
+					value = CellValue.fromValue(false);
+					this.assertEqual(value.type, CellValue.TYPE_BOOLEAN);
+					this.assertEqual(value.formattedValue, 'FALSE');
+				}
+
+				test_fromValue_string() {
+					var value;
+					value = CellValue.fromValue('foo');
+					this.assertEqual(value.type, CellValue.TYPE_STRING);
+					this.assertEqual(value.formattedValue, 'foo');
+					value = CellValue.fromValue('123');
+					this.assertEqual(value.type, CellValue.TYPE_STRING);
+					this.assertEqual(value.formattedValue, '123');
+				}
+
+				test_fromValue_formula() {
+					var value;
+					value = CellValue.fromValue('=A*B');
+					this.assertEqual(value.type, CellValue.TYPE_FORMULA);
+					this.assertEqual(value.formattedValue, '=A*B');
+				}
+
+				test_operation_add() {
+					var a, b, result, expected;
+					a = CellValue.fromValue(3);
+					b = CellValue.fromValue(4);
+					result = a.add(b)
+					expected = new CellValue('7', 7, CellValue.TYPE_NUMBER, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('100%');
+					b = CellValue.fromCellString('50%');
+					result = a.add(b);
+					expected = new CellValue('150%', 1.5, CellValue.TYPE_PERCENT, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('$123');
+					b = CellValue.fromCellString('$321');
+					result = a.add(b);
+					expected = new CellValue('$444.00', 444, CellValue.TYPE_CURRENCY, 2);
+					this.assertEqual(result, expected);
+				}
+
+				test_operation_subtract() {
+					var a, b, result, expected;
+					a = CellValue.fromValue(9);
+					b = CellValue.fromValue(4);
+					result = a.subtract(b)
+					expected = new CellValue('5', 5, CellValue.TYPE_NUMBER, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('100%');
+					b = CellValue.fromCellString('50%');
+					result = a.subtract(b);
+					expected = new CellValue('50%', 0.5, CellValue.TYPE_PERCENT, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('$321');
+					b = CellValue.fromCellString('$123');
+					result = a.subtract(b);
+					expected = new CellValue('$198.00', 198, CellValue.TYPE_CURRENCY, 2);
+					this.assertEqual(result, expected);
+				}
+
+				test_operation_multiply() {
+					var a, b, result, expected;
+					a = CellValue.fromValue(3);
+					b = CellValue.fromValue(4);
+					result = a.multiply(b)
+					expected = new CellValue('12', 12, CellValue.TYPE_NUMBER, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('150%');
+					b = CellValue.fromCellString('50%');
+					result = a.multiply(b);
+					expected = new CellValue('75%', 0.75, CellValue.TYPE_PERCENT, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('$321');
+					b = CellValue.fromCellString('50%');
+					result = a.multiply(b);
+					expected = new CellValue('$160.50', 160.50, CellValue.TYPE_CURRENCY, 2);
+					this.assertEqual(result, expected);
+				}
+
+				test_operation_divide() {
+					var a, b, result, expected;
+					a = CellValue.fromValue(12);
+					b = CellValue.fromValue(4);
+					result = a.divide(b)
+					expected = new CellValue('3', 3, CellValue.TYPE_NUMBER, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('150%');
+					b = CellValue.fromCellString('50%');
+					result = a.divide(b);
+					expected = new CellValue('300%', 3.0, CellValue.TYPE_PERCENT, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('$321');
+					b = CellValue.fromCellString('200%');
+					result = a.divide(b);
+					expected = new CellValue('$160.50', 160.50, CellValue.TYPE_CURRENCY, 2);
+					this.assertEqual(result, expected);
+				}
+
+				test_operation_modulo() {
+					var a, b, result, expected;
+					a = CellValue.fromValue(7);
+					b = CellValue.fromValue(4);
+					result = a.modulo(b)
+					expected = new CellValue('3', 3, CellValue.TYPE_NUMBER, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('175%');
+					b = CellValue.fromCellString('50%');
+					result = a.modulo(b);
+					expected = new CellValue('25%', 0.25, CellValue.TYPE_PERCENT, 0);
+					this.assertEqual(result, expected);
+
+					a = CellValue.fromCellString('$327');
+					b = CellValue.fromCellString('$20');
+					result = a.modulo(b);
+					expected = new CellValue('$7.00', 7.00, CellValue.TYPE_CURRENCY, 2);
+					this.assertEqual(result, expected);
+				}
+
+				test_operation_comparators() {
+					const a = CellValue.fromValue(3);
+					const b = CellValue.fromValue(4);
+					const t = CellValue.fromValue(true);
+					const f = CellValue.fromValue(false);
+
+					this.assertEqual(a.lt(b), t);
+					this.assertEqual(a.lte(b), t);
+					this.assertEqual(a.gt(b), f);
+					this.assertEqual(a.gte(b), f);
+					this.assertEqual(a.eq(b), f);
+					this.assertEqual(a.neq(b), t);
+
+					this.assertEqual(b.lt(a), f);
+					this.assertEqual(b.lte(a), f);
+					this.assertEqual(b.gt(a), t);
+					this.assertEqual(b.gte(a), t);
+					this.assertEqual(b.eq(a), f);
+					this.assertEqual(b.neq(a), t);
+
+					this.assertEqual(a.lt(a), f);
+					this.assertEqual(a.lte(a), t);
+					this.assertEqual(a.gt(a), f);
+					this.assertEqual(a.gte(a), t);
+					this.assertEqual(a.eq(a), t);
+					this.assertEqual(a.neq(a), f);
+				}
+
+				test_operation_concatenate() {
+					const a = CellValue.fromValue('abc');
+					const b = CellValue.fromValue('xyz');
+					const result = a.concatenate(b);
+					const expected = CellValue.fromValue('abcxyz');
+					this.assertEqual(result, expected);
+				}
+			}
 		</script>
 	</head>
 	<body>