reamkit 1.14.0 → 1.15.1

package/dist/esm/excel/activex-parser.js

@@ -0,0 +1,188 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/excel/activex-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	parseAttributeValue: false,
+	removeNSPrefix: true
+});
+function parseActiveX(data) {
+	const ocx = asObject(parser.parse(decoder.decode(data))["ocx"]);
+	if (!ocx) return {};
+	const props = /* @__PURE__ */ new Map();
+	for (const pr of toArray(ocx["ocxPr"])) {
+		const o = asObject(pr);
+		const name = o && strAttr(o, "name");
+		const value = o && strAttr(o, "value");
+		if (name) props.set(name.toLowerCase(), value ?? "");
+	}
+	const caption = props.get("caption");
+	const value = props.get("value");
+	const groupName = props.get("groupname");
+	return {
+		...caption !== void 0 ? { caption } : {},
+		...value !== void 0 ? { value } : {},
+		...groupName !== void 0 ? { groupName } : {}
+	};
+}
+function activeXType(progId) {
+	switch ((/Forms\.(\w+)\.\d+/i.exec(progId ?? "")?.[1] ?? "").toLowerCase()) {
+		case "checkbox": return "checkbox";
+		case "optionbutton": return "option";
+		case "commandbutton": return "button";
+		case "togglebutton": return "toggle";
+		case "textbox": return "textbox";
+		case "combobox": return "combo";
+		case "listbox": return "list";
+		case "label": return "label";
+		case "spinbutton": return "spin";
+		case "scrollbar": return "scroll";
+		case "frame": return "frame";
+		default: return "control";
+	}
+}
+function asObject(v) {
+	return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+}
+function toArray(v) {
+	return Array.isArray(v) ? v : v !== void 0 && v !== null ? [v] : [];
+}
+function strAttr(obj, key) {
+	const v = obj[`@_${key}`];
+	return typeof v === "string" ? v : void 0;
+}
+function activeXBinRelId(xmlData) {
+	const ocx = asObject(parser.parse(decoder.decode(xmlData))["ocx"]);
+	if (!ocx) return void 0;
+	const persistence = strAttr(ocx, "persistence");
+	if (persistence !== "persistStreamInit" && persistence !== "persistStream" && persistence !== "persistStorage") return;
+	return strAttr(ocx, "id");
+}
+var CFB_MAGIC = [
+	208,
+	207,
+	17,
+	224,
+	161,
+	177,
+	26,
+	225
+];
+var MORPH_DATA_BLOCK_1 = [
+	[0, 4],
+	[1, 4],
+	[2, 4],
+	[3, 4],
+	[4, 1],
+	[5, 1],
+	[6, 1],
+	[7, 1],
+	[9, 2],
+	[10, 4],
+	[11, 2],
+	[12, 2],
+	[13, 2],
+	[14, 2],
+	[15, 2],
+	[16, 1],
+	[17, 1],
+	[18, 1],
+	[20, 1],
+	[21, 1]
+];
+var MORPH_DATA_BLOCK_2 = [
+	[24, 4],
+	[25, 4],
+	[26, 4],
+	[27, 2],
+	[28, 2],
+	[29, 2]
+];
+var BIT_F_SIZE = 8;
+var BIT_F_VALUE = 22;
+var BIT_F_CAPTION = 23;
+var BIT_F_GROUP_NAME = 32;
+var MORPH_MAJOR_VERSION = 2;
+var ONE_8 = new TextDecoder("windows-1252");
+var UTF16 = new TextDecoder("utf-16le");
+function u16le(d, i) {
+	return d[i] | d[i + 1] << 8;
+}
+function u32le(d, i) {
+	return (d[i] | d[i + 1] << 8 | d[i + 2] << 16 | d[i + 3] << 24) >>> 0;
+}
+function parseActiveXBin(data) {
+	if (data.length >= 8 && CFB_MAGIC.every((b, i) => data[i] === b)) return {};
+	let off;
+	if (data.length >= 18 && data[16] === 0 && data[17] === MORPH_MAJOR_VERSION) off = 16;
+	else if (data.length >= 2 && data[0] === 0 && data[1] === MORPH_MAJOR_VERSION) off = 0;
+	if (off === void 0) return {};
+	let p = off + 2;
+	if (p + 10 > data.length) return {};
+	const cb = u16le(data, p);
+	p += 2;
+	const blockEnd = Math.min(data.length, p + cb);
+	const propLo = u32le(data, p);
+	const propHi = u32le(data, p + 4);
+	p += 8;
+	const dataStart = p;
+	const bit = (b) => (b < 32 ? propLo >>> b & 1 : propHi >>> b - 32 & 1) === 1;
+	const align = (n) => {
+		p += (n - (p - dataStart) % n) % n;
+	};
+	for (const [b, size] of MORPH_DATA_BLOCK_1) if (bit(b)) {
+		align(size);
+		p += size;
+	}
+	const readCount = () => {
+		align(4);
+		if (p + 4 > blockEnd) return void 0;
+		const v = u32le(data, p);
+		p += 4;
+		return v;
+	};
+	let valueCount;
+	let captionCount;
+	let groupCount;
+	if (bit(BIT_F_VALUE)) {
+		valueCount = readCount();
+		if (valueCount === void 0) return {};
+	}
+	if (bit(BIT_F_CAPTION)) {
+		captionCount = readCount();
+		if (captionCount === void 0) return {};
+	}
+	for (const [b, size] of MORPH_DATA_BLOCK_2) if (bit(b)) {
+		align(size);
+		p += size;
+	}
+	if (bit(BIT_F_GROUP_NAME)) {
+		groupCount = readCount();
+		if (groupCount === void 0) return {};
+	}
+	if (bit(BIT_F_SIZE)) {
+		align(4);
+		p += 8;
+	}
+	const readString = (count) => {
+		if (count === void 0) return void 0;
+		align(4);
+		const len = count & 2147483647;
+		if (len === 0) return "";
+		if (p + len > blockEnd) return void 0;
+		const slice = data.subarray(p, p + len);
+		p += len;
+		return (count & 2147483648) !== 0 ? ONE_8.decode(slice) : UTF16.decode(slice);
+	};
+	const value = readString(valueCount);
+	const caption = readString(captionCount);
+	const groupName = readString(groupCount);
+	return {
+		...caption !== void 0 && caption !== "" ? { caption } : {},
+		...value !== void 0 && value !== "" ? { value } : {},
+		...groupName !== void 0 && groupName !== "" ? { groupName } : {}
+	};
+}
+//#endregion
+export { activeXBinRelId, activeXType, parseActiveX, parseActiveXBin };

package/dist/esm/excel/conditional-format.d.ts

@@ -1,5 +1,5 @@
 import { CellIcon } from '../core/document-model/index.js';
-import { ConditionalFormat, WorksheetCell, XlsxStyles } from '../core/spreadsheet-model/index.js';
+import { ConditionalFormat, DefinedName, WorksheetCell, XlsxStyles } from '../core/spreadsheet-model/index.js';
 export interface CfOverride {
     readonly fillHex?: string;
     readonly fontColorHex?: string;
@@ -13,4 +13,6 @@ export interface CfOverride {
     readonly icon?: CellIcon;
 }
 export type CellConditionalFormatter = (row: number, col: number, numericValue: number | undefined, text: string | undefined) => CfOverride | undefined;
-export declare function buildConditionalFormatter(conditionalFormats: ReadonlyArray<ConditionalFormat> | undefined, styles: XlsxStyles, cells: ReadonlyArray<WorksheetCell>, resolveText?: (cell: WorksheetCell) => string): CellConditionalFormatter | undefined;
+export declare function buildConditionalFormatter(conditionalFormats: ReadonlyArray<ConditionalFormat> | undefined, styles: XlsxStyles, cells: ReadonlyArray<WorksheetCell>, resolveText?: (cell: WorksheetCell) => string, date1904?: boolean, now?: Date, sheetGrids?: ReadonlyMap<string, {
+    readonly cells: ReadonlyArray<WorksheetCell>;
+}>, currentSheet?: string, definedNames?: ReadonlyArray<DefinedName>): CellConditionalFormatter | undefined;

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, resolveText) {
+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 = [];
@@ -33,13 +37,35 @@ function buildConditionalFormatter(conditionalFormats, styles, cells, resolveTex
 		rule,
 		dupKeys: resolveDupUnique(rule, cf.ranges, cells, resolveText)
 	});
-	else flat.push({
+	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);
+	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 (value === void 0 && (text === void 0 || text.length === 0)) return void 0;
+		if (!hasExpr && value === void 0 && (text === void 0 || text.length === 0)) return;
 		const dupKey = dupKeyOf(value, text);
 		let textFmt;
 		let textClaimed = false;
@@ -49,7 +75,7 @@ function buildConditionalFormatter(conditionalFormats, styles, cells, resolveTex
 			textFmt = dxfToOverride(dxfs[dxfId]);
 			textClaimed = true;
 		};
-		for (const { ranges, rule, scale, bar: resolved, iconThresholds, threshold, dupKeys } of flat) {
+		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":
@@ -84,6 +110,19 @@ function buildConditionalFormatter(conditionalFormats, styles, cells, resolveTex
 				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;
@@ -94,6 +133,101 @@ function buildConditionalFormatter(conditionalFormats, styles, cells, resolveTex
 		};
 	};
 }
+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;

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 {};