reamkit 1.13.0 → 1.15.0

package/dist/esm/excel/conditional-format.js

@@ -1,5 +1,9 @@
+import { serialFromDate, timePeriodMatches } from "./formula/dates.js";
+import { BLANK, bool, err, num, str } from "./formula/value.js";
+import { NO_SHIFT, evaluate } from "./formula/eval.js";
+import { compileFormula, evaluateToBool } from "./formula/index.js";
 //#region src/excel/conditional-format.ts
-function buildConditionalFormatter(conditionalFormats, styles, cells) {
+function buildConditionalFormatter(conditionalFormats, styles, cells, resolveText, date1904 = false, now, sheetGrids, currentSheet, definedNames) {
 	if (!conditionalFormats || conditionalFormats.length === 0) return void 0;
 	const dxfs = styles.dxfs ?? [];
 	const flat = [];
@@ -18,41 +22,107 @@ function buildConditionalFormatter(conditionalFormats, styles, cells) {
 		rule,
 		iconThresholds: resolveIconThresholds(rule, cf.ranges, cells)
 	});
-	else flat.push({
+	else if (rule.type === "top10") flat.push({
+		ranges: cf.ranges,
+		rule,
+		threshold: resolveTop10(rule, cf.ranges, cells)
+	});
+	else if (rule.type === "aboveAverage") flat.push({
+		ranges: cf.ranges,
+		rule,
+		threshold: resolveAboveAverage(rule, cf.ranges, cells)
+	});
+	else if (rule.type === "duplicateValues" || rule.type === "uniqueValues") flat.push({
+		ranges: cf.ranges,
+		rule,
+		dupKeys: resolveDupUnique(rule, cf.ranges, cells, resolveText)
+	});
+	else if (rule.type === "expression") {
+		const first = cf.ranges[0];
+		flat.push({
+			ranges: cf.ranges,
+			rule,
+			compiled: compileFormula(rule.formula),
+			...first ? { origin: {
+				row: first.startRow,
+				col: first.startColumn
+			} } : {}
+		});
+	} else flat.push({
 		ranges: cf.ranges,
 		rule
 	});
 	flat.sort((a, b) => a.rule.priority - b.rule.priority);
-	return (row, col, value) => {
-		if (value === void 0) return void 0;
+	const hasExpr = flat.some((f) => f.rule.type === "expression");
+	const nowSerial = now !== void 0 ? serialFromDate(now, date1904) : void 0;
+	const cross = hasExpr && sheetGrids ? {
+		sheets: [...sheetGrids].map(([name, ws]) => ({
+			name,
+			cells: ws.cells
+		})),
+		...currentSheet !== void 0 ? { currentSheet } : {},
+		definedNames: definedNames ?? []
+	} : void 0;
+	const ctx = hasExpr ? buildEvalContext(cells, resolveText, nowSerial, date1904, cross) : void 0;
+	return (row, col, value, text) => {
+		if (!hasExpr && value === void 0 && (text === void 0 || text.length === 0)) return;
+		const dupKey = dupKeyOf(value, text);
 		let textFmt;
 		let textClaimed = false;
 		let bar;
 		let icon;
-		for (const { ranges, rule, scale, bar: resolved, iconThresholds } of flat) {
+		const claim = (dxfId) => {
+			textFmt = dxfToOverride(dxfs[dxfId]);
+			textClaimed = true;
+		};
+		for (const { ranges, rule, scale, bar: resolved, iconThresholds, threshold, dupKeys, compiled, origin } of flat) {
 			if (!coversCell(ranges, row, col)) continue;
 			switch (rule.type) {
 				case "cellIs":
-					if (!textClaimed && cellIsMatches(rule.operator, value, rule.formulas)) {
-						textFmt = dxfToOverride(dxfs[rule.dxfId]);
-						textClaimed = true;
-					}
+					if (!textClaimed && value !== void 0 && cellIsMatches(rule.operator, value, rule.formulas)) claim(rule.dxfId);
 					break;
 				case "colorScale":
-					if (!textClaimed && scale) {
+					if (!textClaimed && value !== void 0 && scale) {
 						textFmt = { fillHex: rgbHex(colorScaleColor(scale, value)) };
 						textClaimed = true;
 					}
 					break;
 				case "dataBar":
-					if (!bar && resolved) bar = dataBarBar(resolved, value);
+					if (!bar && value !== void 0 && resolved) bar = dataBarBar(resolved, value);
 					break;
 				case "iconSet":
-					if (!icon && iconThresholds) {
+					if (!icon && value !== void 0 && iconThresholds) {
 						const bucket = iconBucket(iconThresholds, value);
 						icon = iconToCell(rule.iconSet, iconThresholds.length, bucket, rule.reverse ?? false);
 					}
 					break;
+				case "top10":
+				case "aboveAverage":
+					if (!textClaimed && value !== void 0 && threshold && thresholdMatches(threshold, value)) claim(rule.dxfId);
+					break;
+				case "duplicateValues":
+				case "uniqueValues":
+					if (!textClaimed && dupKey !== void 0 && dupKeys?.has(dupKey)) claim(rule.dxfId);
+					break;
+				case "containsText":
+				case "notContainsText":
+				case "beginsWith":
+				case "endsWith":
+					if (!textClaimed && text !== void 0 && textRuleMatches(rule, text)) claim(rule.dxfId);
+					break;
+				case "expression":
+					if (!textClaimed && compiled && ctx && origin) {
+						if (evaluateToBool(compiled, ctx, {
+							dRow: row - origin.row,
+							dCol: col - origin.col,
+							curRow: row,
+							curCol: col
+						})) claim(rule.dxfId);
+					}
+					break;
+				case "timePeriod":
+					if (!textClaimed && value !== void 0 && nowSerial !== void 0 && timePeriodMatches(rule.timePeriod, value, nowSerial, date1904)) claim(rule.dxfId);
+					break;
 			}
 		}
 		if (!bar && !icon) return textFmt;
@@ -63,6 +133,121 @@ function buildConditionalFormatter(conditionalFormats, styles, cells) {
 		};
 	};
 }
+var COLS = 16384;
+function indexCells(cells, resolveText) {
+	const byKey = /* @__PURE__ */ new Map();
+	const populated = [];
+	for (const cell of cells) {
+		const s = cellToScalar(cell, resolveText);
+		if (s.t === "blank") continue;
+		byKey.set(cell.row * COLS + cell.column, s);
+		populated.push({
+			row: cell.row,
+			col: cell.column,
+			value: s
+		});
+	}
+	return {
+		byKey,
+		populated
+	};
+}
+function eachInMap(map, rect, visit) {
+	for (const c of map.populated) if (c.row >= rect.r0 && c.row <= rect.r1 && c.col >= rect.c0 && c.col <= rect.c1) visit(c.row, c.col, c.value);
+}
+function buildEvalContext(cells, resolveText, nowSerial, date1904, cross) {
+	const self = indexCells(cells, resolveText);
+	const base = {
+		nowSerial,
+		date1904,
+		getCell: (row, col) => self.byKey.get(row * COLS + col) ?? BLANK,
+		eachCell: (rect, visit) => eachInMap(self, rect, visit)
+	};
+	if (!cross) return base;
+	const sheetByName = /* @__PURE__ */ new Map();
+	cross.sheets.forEach((s, i) => sheetByName.set(s.name.toLowerCase(), i));
+	const maps = new Array(cross.sheets.length);
+	const sheetData = (idx) => maps[idx] ??= indexCells(cross.sheets[idx].cells, resolveText);
+	const currentIdx = cross.currentSheet !== void 0 ? sheetByName.get(cross.currentSheet.toLowerCase()) : void 0;
+	const nameMap = /* @__PURE__ */ new Map();
+	for (const dn of cross.definedNames) {
+		if (dn.localSheetId !== void 0 && dn.localSheetId !== currentIdx) continue;
+		const key = dn.name.toLowerCase();
+		if (dn.localSheetId !== void 0 || !nameMap.has(key)) nameMap.set(key, dn);
+	}
+	const resolving = /* @__PURE__ */ new Set();
+	const ctx = {
+		...base,
+		sheetIndex: (name) => sheetByName.get(name.toLowerCase()),
+		getCellOn: (sheet, row, col) => sheetData(sheet).byKey.get(row * COLS + col) ?? BLANK,
+		eachCellOn: (sheet, rect, visit) => eachInMap(sheetData(sheet), rect, visit),
+		resolveName: (rawName) => {
+			const key = rawName.toLowerCase();
+			const dn = nameMap.get(key);
+			if (!dn || resolving.has(key)) return void 0;
+			const compiled = compileFormula(dn.value.startsWith("=") ? dn.value.slice(1) : dn.value);
+			if (!compiled) return void 0;
+			const ast = compiled.ast;
+			if (ast.k === "num") return num(ast.v);
+			if (ast.k === "str") return str(ast.v);
+			if (ast.k === "bool") return bool(ast.v);
+			if (ast.k !== "cell" && ast.k !== "range") return void 0;
+			resolving.add(key);
+			try {
+				return evaluate(ast, ctx, NO_SHIFT);
+			} finally {
+				resolving.delete(key);
+			}
+		}
+	};
+	return ctx;
+}
+function cellToScalar(cell, resolveText) {
+	switch (cell.type) {
+		case "n": {
+			const n = Number(cell.rawValue);
+			return Number.isFinite(n) ? num(n) : BLANK;
+		}
+		case "b": return bool(cell.rawValue === "1" || cell.rawValue.toUpperCase() === "TRUE");
+		case "e": return err(toFErr(cell.rawValue));
+		case "s":
+		case "str":
+		case "inlineStr": return str(resolveText ? resolveText(cell) : cell.inlineText ?? cell.rawValue);
+		default: return cell.rawValue.length > 0 ? str(cell.rawValue) : BLANK;
+	}
+}
+var FERRS = new Set([
+	"#NULL!",
+	"#DIV/0!",
+	"#VALUE!",
+	"#REF!",
+	"#NAME?",
+	"#NUM!",
+	"#N/A"
+]);
+function toFErr(raw) {
+	return FERRS.has(raw) ? raw : "#VALUE!";
+}
+function dupKeyOf(value, text) {
+	if (value !== void 0) return `n:${value}`;
+	if (text === void 0) return void 0;
+	const k = text.trim().toLowerCase();
+	return k.length > 0 ? `s:${k}` : void 0;
+}
+function textRuleMatches(rule, text) {
+	const hay = text.toLowerCase();
+	const needle = rule.text.toLowerCase();
+	switch (rule.type) {
+		case "containsText": return hay.includes(needle);
+		case "notContainsText": return !hay.includes(needle);
+		case "beginsWith": return hay.startsWith(needle);
+		case "endsWith": return hay.endsWith(needle);
+	}
+}
+function thresholdMatches(t, value) {
+	if (t.below) return t.orEqual ? value <= t.threshold : value < t.threshold;
+	return t.orEqual ? value >= t.threshold : value > t.threshold;
+}
 function coversCell(ranges, row, col) {
 	for (const r of ranges) if (row >= r.startRow && row <= r.endRow && col >= r.startColumn && col <= r.endColumn) return true;
 	return false;
@@ -323,5 +508,56 @@ function iconColor(count, e) {
 	const ramp = ICON_RAMPS[count] ?? ICON_RAMPS[3];
 	return ramp[Math.max(0, Math.min(ramp.length - 1, e))];
 }
+function resolveTop10(rule, ranges, cells) {
+	const vals = collectRangeValues(cells, ranges);
+	if (vals.length === 0) return void 0;
+	const n = vals.length;
+	const raw = rule.percent ? Math.floor(n * rule.rank / 100) : rule.rank;
+	const count = Math.max(1, Math.min(n, raw));
+	return {
+		threshold: [...vals].sort((a, b) => rule.bottom ? a - b : b - a)[count - 1],
+		below: rule.bottom,
+		orEqual: true
+	};
+}
+function resolveAboveAverage(rule, ranges, cells) {
+	const vals = collectRangeValues(cells, ranges);
+	if (vals.length === 0) return void 0;
+	const mean = vals.reduce((s, v) => s + v, 0) / vals.length;
+	let threshold = mean;
+	if (rule.stdDev !== void 0 && rule.stdDev > 0) {
+		const variance = vals.reduce((s, v) => s + (v - mean) * (v - mean), 0) / vals.length;
+		const sd = Math.sqrt(variance);
+		threshold = rule.aboveAverage ? mean + rule.stdDev * sd : mean - rule.stdDev * sd;
+	}
+	return {
+		threshold,
+		below: !rule.aboveAverage,
+		orEqual: rule.equalAverage
+	};
+}
+function resolveDupUnique(rule, ranges, cells, resolveText) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const cell of cells) {
+		if (!coversCell(ranges, cell.row, cell.column)) continue;
+		const key = cellDupKey(cell, resolveText);
+		if (key === void 0) continue;
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	if (counts.size === 0) return void 0;
+	const qualifies = rule.type === "duplicateValues" ? (c) => c >= 2 : (c) => c === 1;
+	const out = /* @__PURE__ */ new Set();
+	for (const [k, c] of counts) if (qualifies(c)) out.add(k);
+	return out;
+}
+function cellDupKey(cell, resolveText) {
+	if (cell.type === "n") {
+		const n = Number(cell.rawValue);
+		return Number.isFinite(n) ? `n:${n}` : void 0;
+	}
+	if (!resolveText) return void 0;
+	const k = resolveText(cell).trim().toLowerCase();
+	return k.length > 0 ? `s:${k}` : void 0;
+}
 //#endregion
 export { buildConditionalFormatter };

package/dist/esm/excel/form-control-parser.d.ts

@@ -0,0 +1,6 @@
+export interface FormControlProps {
+    readonly objectType?: string;
+    readonly checked?: boolean;
+    readonly value?: number;
+}
+export declare function parseFormControlProps(data: Uint8Array): FormControlProps;

package/dist/esm/excel/form-control-parser.js

@@ -0,0 +1,29 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/form-control-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	removeNSPrefix: true
+});
+function parseFormControlProps(data) {
+	const pr = parser.parse(decoder.decode(data))["formControlPr"];
+	const obj = pr && typeof pr === "object" ? pr : void 0;
+	if (!obj) return {};
+	const objectType = strAttr(obj, "objectType");
+	const checkedRaw = strAttr(obj, "checked");
+	const valRaw = strAttr(obj, "val");
+	const value = valRaw !== void 0 && /^-?\d+$/.test(valRaw) ? Number(valRaw) : void 0;
+	return {
+		...objectType ? { objectType } : {},
+		...checkedRaw !== void 0 ? { checked: checkedRaw === "Checked" || checkedRaw === "1" } : {},
+		...value !== void 0 ? { value } : {}
+	};
+}
+function strAttr(obj, key) {
+	const v = obj[`@_${key}`];
+	return typeof v === "string" ? v : void 0;
+}
+//#endregion
+export { parseFormControlProps };

package/dist/esm/excel/formula/context.d.ts

@@ -0,0 +1,11 @@
+import { FValue, Rect, Scalar } from './value.js';
+export interface EvalContext {
+    readonly getCell: (row: number, col: number) => Scalar;
+    readonly eachCell: (rect: Rect, visit: (row: number, col: number, value: Scalar) => void) => void;
+    readonly nowSerial: number | undefined;
+    readonly date1904: boolean;
+    readonly sheetIndex?: (name: string) => number | undefined;
+    readonly getCellOn?: (sheet: number, row: number, col: number) => Scalar;
+    readonly eachCellOn?: (sheet: number, rect: Rect, visit: (row: number, col: number, value: Scalar) => void) => void;
+    readonly resolveName?: (name: string) => FValue | undefined;
+}

package/dist/esm/excel/formula/dates.d.ts

@@ -0,0 +1,11 @@
+import { TimePeriodKind } from '../../core/spreadsheet-model/index.js';
+export interface DateParts {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+    readonly dow: number;
+}
+export declare function serialToParts(serial: number, date1904: boolean): DateParts;
+export declare function serialFromDate(d: Date, date1904: boolean): number;
+export declare function serialFromYmd(year: number, month1: number, day: number, date1904: boolean): number;
+export declare function timePeriodMatches(period: TimePeriodKind, cellSerial: number, nowSerial: number, date1904: boolean): boolean;

package/dist/esm/excel/formula/dates.js

@@ -0,0 +1,46 @@
+import { excelSerialFromUtcParts, excelSerialToDate } from "../number-format.js";
+//#region src/excel/formula/dates.ts
+function serialToParts(serial, date1904) {
+	const d = excelSerialToDate(Math.floor(serial), date1904);
+	return {
+		year: d.getUTCFullYear(),
+		month: d.getUTCMonth() + 1,
+		day: d.getUTCDate(),
+		dow: d.getUTCDay()
+	};
+}
+function serialFromDate(d, date1904) {
+	return excelSerialFromUtcParts(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), date1904);
+}
+function serialFromYmd(year, month1, day, date1904) {
+	return excelSerialFromUtcParts(year, month1 - 1, day, date1904);
+}
+function timePeriodMatches(period, cellSerial, nowSerial, date1904) {
+	const cell = Math.floor(cellSerial);
+	const today = Math.floor(nowSerial);
+	switch (period) {
+		case "today": return cell === today;
+		case "yesterday": return cell === today - 1;
+		case "tomorrow": return cell === today + 1;
+		case "last7Days": return today - cell >= 0 && today - cell <= 6;
+		case "thisWeek":
+		case "lastWeek":
+		case "nextWeek": {
+			const lo = today - serialToParts(today, date1904).dow + (period === "lastWeek" ? -7 : period === "nextWeek" ? 7 : 0);
+			return cell >= lo && cell <= lo + 6;
+		}
+		case "thisMonth":
+		case "lastMonth":
+		case "nextMonth": {
+			const t = serialToParts(today, date1904);
+			const delta = period === "lastMonth" ? -1 : period === "nextMonth" ? 1 : 0;
+			const idx = t.year * 12 + (t.month - 1) + delta;
+			const targetYear = Math.floor(idx / 12);
+			const targetMonth = idx % 12 + 1;
+			const c = serialToParts(cell, date1904);
+			return c.year === targetYear && c.month === targetMonth;
+		}
+	}
+}
+//#endregion
+export { serialFromDate, serialFromYmd, serialToParts, timePeriodMatches };

package/dist/esm/excel/formula/eval.d.ts

@@ -0,0 +1,11 @@
+import { Ast } from './parser.js';
+import { EvalContext } from './context.js';
+import { FValue } from './value.js';
+export interface Shift {
+    readonly dRow: number;
+    readonly dCol: number;
+    readonly curRow?: number;
+    readonly curCol?: number;
+}
+export declare const NO_SHIFT: Shift;
+export declare function evaluate(ast: Ast, ctx: EvalContext, shift: Shift): FValue;

package/dist/esm/excel/formula/eval.js

@@ -0,0 +1,196 @@
+import { bool, deref, err, num, str, toNumber, toText } from "./value.js";
+import { callFn } from "./functions.js";
+//#region src/excel/formula/eval.ts
+var NO_SHIFT = {
+	dRow: 0,
+	dCol: 0
+};
+function evaluate(ast, ctx, shift) {
+	switch (ast.k) {
+		case "num": return num(ast.v);
+		case "str": return str(ast.v);
+		case "bool": return bool(ast.v);
+		case "err": return err(ast.v);
+		case "cell": {
+			const sheet = sheetIdx(ast.sheet, ctx);
+			if (sheet === false) return err("#REF!");
+			const r = resolveRef(ast.ref, shift);
+			if (!r) return err("#REF!");
+			return {
+				t: "ref",
+				rect: {
+					r0: r.row,
+					c0: r.col,
+					r1: r.row,
+					c1: r.col
+				},
+				...sheet !== void 0 ? { sheet } : {}
+			};
+		}
+		case "range": {
+			const sheet = sheetIdx(ast.sheet, ctx);
+			if (sheet === false) return err("#REF!");
+			const a = resolveRef(ast.a, shift);
+			const b = resolveRef(ast.b, shift);
+			if (!a || !b) return err("#REF!");
+			return {
+				t: "ref",
+				rect: {
+					r0: Math.min(a.row, b.row),
+					c0: Math.min(a.col, b.col),
+					r1: Math.max(a.row, b.row),
+					c1: Math.max(a.col, b.col)
+				},
+				...sheet !== void 0 ? { sheet } : {}
+			};
+		}
+		case "name": return ctx.resolveName?.(ast.name) ?? err("#NAME?");
+		case "array": return {
+			t: "arr",
+			rows: ast.rows.map((row) => row.map((el) => deref(evaluate(el, ctx, shift), ctx)))
+		};
+		case "unary": return evalUnary(ast.op, evaluate(ast.x, ctx, shift), ctx);
+		case "pct": {
+			const n = toNumber(evaluate(ast.x, ctx, shift), ctx);
+			return typeof n === "string" ? err(n) : num(n / 100);
+		}
+		case "bin": return evalBin(ast.op, ast.a, ast.b, ctx, shift);
+		case "call": return callFn(ast.name, ast.args, (a) => evaluate(a, ctx, shift), ctx, shift);
+	}
+}
+function resolveRef(ref, shift) {
+	const row = ref.row.abs ? ref.row.index : ref.row.index + shift.dRow;
+	const col = ref.col.abs ? ref.col.index : ref.col.index + shift.dCol;
+	if (row < 0 || col < 0) return void 0;
+	return {
+		row,
+		col
+	};
+}
+function sheetIdx(name, ctx) {
+	if (name === void 0) return void 0;
+	const idx = ctx.sheetIndex?.(name);
+	return idx === void 0 ? false : idx;
+}
+function evalUnary(op, x, ctx) {
+	const n = toNumber(x, ctx);
+	if (typeof n === "string") return err(n);
+	return num(op === "-" ? -n : n);
+}
+function evalBin(op, aAst, bAst, ctx, shift) {
+	const a = evaluate(aAst, ctx, shift);
+	const b = evaluate(bAst, ctx, shift);
+	if (a.t === "arr" || b.t === "arr") return broadcastBin(op, a, b, ctx);
+	return applyBin(op, a, b, ctx);
+}
+function applyBin(op, a, b, ctx) {
+	if (op === "&") {
+		const ta = toText(a, ctx);
+		if (typeof ta !== "string") return err(ta);
+		const tb = toText(b, ctx);
+		if (typeof tb !== "string") return err(tb);
+		return str(ta + tb);
+	}
+	if (op === "=" || op === "<>" || op === "<" || op === ">" || op === "<=" || op === ">=") return compareOp(op, deref(a, ctx), deref(b, ctx));
+	const na = toNumber(a, ctx);
+	if (typeof na === "string") return err(na);
+	const nb = toNumber(b, ctx);
+	if (typeof nb === "string") return err(nb);
+	switch (op) {
+		case "+": return num(na + nb);
+		case "-": return num(na - nb);
+		case "*": return num(na * nb);
+		case "/": return nb === 0 ? err("#DIV/0!") : num(na / nb);
+		case "^": {
+			const r = Math.pow(na, nb);
+			return Number.isNaN(r) ? err("#NUM!") : num(r);
+		}
+	}
+}
+function broadcastBin(op, a, b, ctx) {
+	const ar = a.t === "arr" ? a.rows : [[deref(a, ctx)]];
+	const br = b.t === "arr" ? b.rows : [[deref(b, ctx)]];
+	const nRows = Math.max(ar.length, br.length);
+	const out = [];
+	for (let r = 0; r < nRows; r++) {
+		const arow = ar[ar.length === 1 ? 0 : r];
+		const brow = br[br.length === 1 ? 0 : r];
+		if (!arow || !brow) return err("#VALUE!");
+		const nCols = Math.max(arow.length, brow.length);
+		const row = [];
+		for (let c = 0; c < nCols; c++) {
+			const ea = arow[arow.length === 1 ? 0 : c];
+			const eb = brow[brow.length === 1 ? 0 : c];
+			if (ea === void 0 || eb === void 0) return err("#VALUE!");
+			const res = applyBin(op, ea, eb, ctx);
+			row.push(res.t === "ref" || res.t === "arr" ? err("#VALUE!") : res);
+		}
+		out.push(row);
+	}
+	return {
+		t: "arr",
+		rows: out
+	};
+}
+function compareOp(op, a, b) {
+	const c = compare(a, b);
+	if (typeof c === "string") return err(c);
+	switch (op) {
+		case "=": return bool(c === 0);
+		case "<>": return bool(c !== 0);
+		case "<": return bool(c < 0);
+		case ">": return bool(c > 0);
+		case "<=": return bool(c <= 0);
+		case ">=": return bool(c >= 0);
+		default: return err("#VALUE!");
+	}
+}
+function compare(a, b) {
+	if (a.t === "err") return a.v;
+	if (b.t === "err") return b.v;
+	const na = normalizeBlank(a, b);
+	const nb = normalizeBlank(b, a);
+	const ca = category(na);
+	const cb = category(nb);
+	if (ca !== cb) return ca < cb ? -1 : 1;
+	if (na.t === "str" && nb.t === "str") {
+		const la = na.v.toLowerCase();
+		const lb = nb.v.toLowerCase();
+		return la < lb ? -1 : la > lb ? 1 : 0;
+	}
+	const va = scalarNumber(na);
+	const vb = scalarNumber(nb);
+	return va < vb ? -1 : va > vb ? 1 : 0;
+}
+function normalizeBlank(s, other) {
+	if (s.t !== "blank") return s;
+	switch (other.t) {
+		case "str": return {
+			t: "str",
+			v: ""
+		};
+		case "bool": return {
+			t: "bool",
+			v: false
+		};
+		default: return {
+			t: "num",
+			v: 0
+		};
+	}
+}
+function category(s) {
+	switch (s.t) {
+		case "num": return 0;
+		case "str": return 1;
+		case "bool": return 2;
+		default: return 0;
+	}
+}
+function scalarNumber(s) {
+	if (s.t === "num") return s.v;
+	if (s.t === "bool") return s.v ? 1 : 0;
+	return 0;
+}
+//#endregion
+export { NO_SHIFT, evaluate };

package/dist/esm/excel/formula/functions.d.ts

@@ -0,0 +1,7 @@
+import { Ast } from './parser.js';
+import { EvalContext } from './context.js';
+import { Shift } from './eval.js';
+import { FValue } from './value.js';
+type Ev = (a: Ast) => FValue;
+export declare function callFn(name: string, args: ReadonlyArray<Ast>, ev: Ev, ctx: EvalContext, shift: Shift): FValue;
+export {};