reamkit 1.14.0 → 1.15.1

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

@@ -0,0 +1,1359 @@
+import { serialFromYmd, serialToParts } from "./dates.js";
+import { arrEach, bool, deref, err, isErr, num, refEach, refGet, str, toBool, toNumber, toText } from "./value.js";
+//#region src/excel/formula/functions.ts
+function callFn(name, args, ev, ctx, shift) {
+	switch (name) {
+		case "TRUE": return bool(true);
+		case "FALSE": return bool(false);
+		case "NOT": {
+			if (args.length !== 1) return err("#VALUE!");
+			const b = toBool(ev(args[0]), ctx);
+			return typeof b === "string" ? err(b) : bool(!b);
+		}
+		case "AND":
+		case "OR": return andOr(name, args, ev, ctx);
+		case "IF": {
+			if (args.length < 2 || args.length > 3) return err("#VALUE!");
+			const c = toBool(ev(args[0]), ctx);
+			if (typeof c === "string") return err(c);
+			if (c) return ev(args[1]);
+			return args.length === 3 ? ev(args[2]) : bool(false);
+		}
+		case "IFERROR": {
+			if (args.length !== 2) return err("#VALUE!");
+			const v = ev(args[0]);
+			return isErr(deref(v, ctx)) ? ev(args[1]) : v;
+		}
+		case "ISBLANK": return is1(args, ev, ctx, (s) => s.t === "blank");
+		case "ISNUMBER": return is1(args, ev, ctx, (s) => s.t === "num");
+		case "ISTEXT": return is1(args, ev, ctx, (s) => s.t === "str");
+		case "ISLOGICAL": return is1(args, ev, ctx, (s) => s.t === "bool");
+		case "ISERROR": return is1(args, ev, ctx, (s) => s.t === "err");
+		case "ISERR": return is1(args, ev, ctx, (s) => s.t === "err" && s.v !== "#N/A");
+		case "ISNA": return is1(args, ev, ctx, (s) => s.t === "err" && s.v === "#N/A");
+		case "N": {
+			if (args.length !== 1) return err("#VALUE!");
+			const s = deref(ev(args[0]), ctx);
+			if (s.t === "num") return s;
+			if (s.t === "bool") return num(s.v ? 1 : 0);
+			if (s.t === "err") return s;
+			return num(0);
+		}
+		case "ABS": return math1(args, ev, ctx, Math.abs);
+		case "SIGN": return math1(args, ev, ctx, Math.sign);
+		case "SQRT": return math1(args, ev, ctx, (x) => x < 0 ? NaN : Math.sqrt(x));
+		case "INT": return math1(args, ev, ctx, Math.floor);
+		case "MOD": return mod(args, ev, ctx);
+		case "POWER": return power(args, ev, ctx);
+		case "ROUND": return roundFn(args, ev, ctx, "round");
+		case "ROUNDUP": return roundFn(args, ev, ctx, "up");
+		case "ROUNDDOWN":
+		case "TRUNC": return roundFn(args, ev, ctx, "down");
+		case "SUM": return aggregate(args, ev, ctx, (ns) => ns.reduce((a, b) => a + b, 0));
+		case "AVERAGE": return aggregate(args, ev, ctx, (ns) => ns.length ? ns.reduce((a, b) => a + b, 0) / ns.length : NaN, true);
+		case "MIN": return aggregate(args, ev, ctx, (ns) => ns.length ? Math.min(...ns) : 0);
+		case "MAX": return aggregate(args, ev, ctx, (ns) => ns.length ? Math.max(...ns) : 0);
+		case "COUNT": return countFn(args, ev, ctx, false);
+		case "COUNTA": return countFn(args, ev, ctx, true);
+		case "COUNTIF": return countSumIf(args, ev, ctx, false);
+		case "SUMIF": return countSumIf(args, ev, ctx, true);
+		case "LEN": {
+			const t = textArg(args, ev, ctx, 0);
+			return typeof t === "string" ? num(t.length) : err(t.v);
+		}
+		case "LEFT": return leftRight(args, ev, ctx, true);
+		case "RIGHT": return leftRight(args, ev, ctx, false);
+		case "MID": return mid(args, ev, ctx);
+		case "LOWER": return text1(args, ev, ctx, (s) => s.toLowerCase());
+		case "UPPER": return text1(args, ev, ctx, (s) => s.toUpperCase());
+		case "TRIM": return text1(args, ev, ctx, (s) => s.replace(/\s+/g, " ").trim());
+		case "CONCATENATE": return concat(args, ev, ctx);
+		case "EXACT": return exact(args, ev, ctx);
+		case "SEARCH": return findSearch(args, ev, ctx, false);
+		case "FIND": return findSearch(args, ev, ctx, true);
+		case "VALUE": {
+			const t = textArg(args, ev, ctx, 0);
+			if (typeof t !== "string") return err(t.v);
+			const n = Number(t.trim());
+			return t.trim() !== "" && Number.isFinite(n) ? num(n) : err("#VALUE!");
+		}
+		case "TODAY":
+		case "NOW": return ctx.nowSerial === void 0 ? err("#VALUE!") : num(ctx.nowSerial);
+		case "YEAR": return datePart(args, ev, ctx, (p) => p.year);
+		case "MONTH": return datePart(args, ev, ctx, (p) => p.month);
+		case "DAY": return datePart(args, ev, ctx, (p) => p.day);
+		case "WEEKDAY": return weekday(args, ev, ctx);
+		case "DATE": return dateFn(args, ev, ctx);
+		case "EDATE": return edate(args, ev, ctx, false);
+		case "EOMONTH": return edate(args, ev, ctx, true);
+		case "DAYS": return daysFn(args, ev, ctx);
+		case "HOUR": return timePart(args, ev, ctx, "h");
+		case "MINUTE": return timePart(args, ev, ctx, "m");
+		case "SECOND": return timePart(args, ev, ctx, "s");
+		case "TIME": return timeFn(args, ev, ctx);
+		case "WEEKNUM": return weekNum(args, ev, ctx, false);
+		case "ISOWEEKNUM": return weekNum(args, ev, ctx, true);
+		case "ISNONTEXT": return is1(args, ev, ctx, (s) => s.t !== "str");
+		case "ISREF": return args.length === 1 ? bool(ev(args[0]).t === "ref") : err("#VALUE!");
+		case "ISEVEN": return isParity(args, ev, ctx, true);
+		case "ISODD": return isParity(args, ev, ctx, false);
+		case "NA": return err("#N/A");
+		case "IFNA": {
+			if (args.length !== 2) return err("#VALUE!");
+			const v = ev(args[0]);
+			const d = deref(v, ctx);
+			return d.t === "err" && d.v === "#N/A" ? ev(args[1]) : v;
+		}
+		case "XOR": return xorFn(args, ev, ctx);
+		case "IFS": return ifsFn(args, ev, ctx);
+		case "SWITCH": return switchFn(args, ev, ctx);
+		case "PRODUCT": return aggregate(args, ev, ctx, (ns) => ns.length ? ns.reduce((a, b) => a * b, 1) : 0);
+		case "MEDIAN": return medianFn(args, ev, ctx);
+		case "LARGE": return largeSmall(args, ev, ctx, true);
+		case "SMALL": return largeSmall(args, ev, ctx, false);
+		case "QUOTIENT": return quotient(args, ev, ctx);
+		case "CEILING": return ceilingFloor(args, ev, ctx, "ceil");
+		case "FLOOR": return ceilingFloor(args, ev, ctx, "floor");
+		case "MROUND": return mround(args, ev, ctx);
+		case "EVEN": return evenOdd(args, ev, ctx, true);
+		case "ODD": return evenOdd(args, ev, ctx, false);
+		case "GCD": return gcdLcm(args, ev, ctx, "gcd");
+		case "LCM": return gcdLcm(args, ev, ctx, "lcm");
+		case "SUMPRODUCT": return sumProduct(args, ev, ctx);
+		case "COUNTBLANK": return countBlank(args, ev, ctx);
+		case "COUNTIFS": return countSumAvgIfs(args, ev, ctx, "count");
+		case "SUMIFS": return countSumAvgIfs(args, ev, ctx, "sum");
+		case "AVERAGEIFS": return countSumAvgIfs(args, ev, ctx, "avg");
+		case "AVERAGEIF": return averageIf(args, ev, ctx);
+		case "CONCAT": return concatFlatten(args, ev, ctx);
+		case "TEXTJOIN": return textJoin(args, ev, ctx);
+		case "SUBSTITUTE": return substitute(args, ev, ctx);
+		case "REPLACE": return replaceFn(args, ev, ctx);
+		case "REPT": return rept(args, ev, ctx);
+		case "PROPER": return text1(args, ev, ctx, properCase);
+		case "CHAR": return charFn(args, ev, ctx);
+		case "CODE": return codeFn(args, ev, ctx);
+		case "CLEAN": return text1(args, ev, ctx, stripControl);
+		case "T": return tFn(args, ev, ctx);
+		case "CHOOSE": return chooseFn(args, ev, ctx);
+		case "MATCH": return matchFn(args, ev, ctx);
+		case "INDEX": return indexFn(args, ev, ctx);
+		case "VLOOKUP": return lookupFn(args, ev, ctx, "v");
+		case "HLOOKUP": return lookupFn(args, ev, ctx, "h");
+		case "PI": return args.length === 0 ? num(Math.PI) : err("#VALUE!");
+		case "EXP": return math1(args, ev, ctx, Math.exp);
+		case "LN": return math1(args, ev, ctx, (x) => x <= 0 ? NaN : Math.log(x));
+		case "LOG10": return math1(args, ev, ctx, (x) => x <= 0 ? NaN : Math.log10(x));
+		case "LOG": return logFn(args, ev, ctx);
+		case "SIN": return math1(args, ev, ctx, Math.sin);
+		case "COS": return math1(args, ev, ctx, Math.cos);
+		case "TAN": return math1(args, ev, ctx, Math.tan);
+		case "ASIN": return math1(args, ev, ctx, (x) => Math.abs(x) > 1 ? NaN : Math.asin(x));
+		case "ACOS": return math1(args, ev, ctx, (x) => Math.abs(x) > 1 ? NaN : Math.acos(x));
+		case "ATAN": return math1(args, ev, ctx, Math.atan);
+		case "ATAN2": return math2(args, ev, ctx, (x, y) => x === 0 && y === 0 ? NaN : Math.atan2(y, x));
+		case "SINH": return math1(args, ev, ctx, Math.sinh);
+		case "COSH": return math1(args, ev, ctx, Math.cosh);
+		case "TANH": return math1(args, ev, ctx, Math.tanh);
+		case "DEGREES": return math1(args, ev, ctx, (x) => x * 180 / Math.PI);
+		case "RADIANS": return math1(args, ev, ctx, (x) => x * Math.PI / 180);
+		case "SQRTPI": return math1(args, ev, ctx, (x) => x < 0 ? NaN : Math.sqrt(x * Math.PI));
+		case "FACT": return factFn(args, ev, ctx);
+		case "COMBIN": return combinPermut(args, ev, ctx, false);
+		case "PERMUT": return combinPermut(args, ev, ctx, true);
+		case "SUMSQ": return aggregate(args, ev, ctx, (ns) => ns.reduce((a, b) => a + b * b, 0));
+		case "STDEV":
+		case "STDEV.S": return statSpread(args, ev, ctx, "stdev", true);
+		case "STDEVP":
+		case "STDEV.P": return statSpread(args, ev, ctx, "stdev", false);
+		case "VAR":
+		case "VAR.S": return statSpread(args, ev, ctx, "var", true);
+		case "VARP":
+		case "VAR.P": return statSpread(args, ev, ctx, "var", false);
+		case "AVEDEV": return statSpread(args, ev, ctx, "avedev", false);
+		case "DEVSQ": return statSpread(args, ev, ctx, "devsq", false);
+		case "GEOMEAN": return geoHarMean(args, ev, ctx, true);
+		case "HARMEAN": return geoHarMean(args, ev, ctx, false);
+		case "AVERAGEA": return aggregateA(args, ev, ctx, "avg");
+		case "MAXA": return aggregateA(args, ev, ctx, "max");
+		case "MINA": return aggregateA(args, ev, ctx, "min");
+		case "MODE":
+		case "MODE.SNGL": return modeFn(args, ev, ctx);
+		case "RANK":
+		case "RANK.EQ": return rankFn(args, ev, ctx);
+		case "PERCENTILE":
+		case "PERCENTILE.INC": return percentileFn(args, ev, ctx);
+		case "QUARTILE":
+		case "QUARTILE.INC": return quartileFn(args, ev, ctx);
+		case "ROW": return rowColFn(args, ev, shift, true);
+		case "COLUMN": return rowColFn(args, ev, shift, false);
+		case "ROWS": return rowsColsFn(args, ev, true);
+		case "COLUMNS": return rowsColsFn(args, ev, false);
+		case "TYPE": return typeFn(args, ev, ctx);
+		case "ERROR.TYPE": return errorTypeFn(args, ev, ctx);
+		case "UNICHAR": return unicharFn(args, ev, ctx);
+		case "UNICODE": return unicodeFn(args, ev, ctx);
+		default: return err("#NAME?");
+	}
+}
+function is1(args, ev, ctx, test) {
+	if (args.length !== 1) return err("#VALUE!");
+	return bool(test(deref(ev(args[0]), ctx)));
+}
+function numArg(args, ev, ctx, i) {
+	const n = toNumber(ev(args[i]), ctx);
+	return typeof n === "string" ? { e: n } : n;
+}
+function textArg(args, ev, ctx, i) {
+	const t = toText(ev(args[i]), ctx);
+	return typeof t === "string" ? t : { v: t };
+}
+function math1(args, ev, ctx, f) {
+	if (args.length !== 1) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	const r = f(a);
+	return Number.isNaN(r) ? err("#NUM!") : num(r);
+}
+function text1(args, ev, ctx, f) {
+	if (args.length !== 1) return err("#VALUE!");
+	const t = textArg(args, ev, ctx, 0);
+	return typeof t === "string" ? str(f(t)) : err(t.v);
+}
+function mod(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	const b = numArg(args, ev, ctx, 1);
+	if (typeof b !== "number") return err(b.e);
+	if (b === 0) return err("#DIV/0!");
+	return num(a - b * Math.floor(a / b));
+}
+function power(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	const b = numArg(args, ev, ctx, 1);
+	if (typeof b !== "number") return err(b.e);
+	const r = Math.pow(a, b);
+	return Number.isNaN(r) ? err("#NUM!") : num(r);
+}
+function roundFn(args, ev, ctx, mode) {
+	if (args.length < 1 || args.length > 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	let digits = 0;
+	if (args.length === 2) {
+		const d = numArg(args, ev, ctx, 1);
+		if (typeof d !== "number") return err(d.e);
+		digits = Math.trunc(d);
+	}
+	const f = Math.pow(10, digits);
+	const x = Math.abs(a) * f;
+	return num(Math.sign(a) * (mode === "round" ? Math.round(x) : mode === "up" ? Math.ceil(x) : Math.floor(x)) / f);
+}
+function andOr(name, args, ev, ctx) {
+	let any = false;
+	let acc = name === "AND";
+	for (const a of args) {
+		const v = ev(a);
+		if (v.t === "ref") {
+			let e;
+			refEach(v, ctx, (_r, _c, s) => {
+				if (s.t === "err") e ??= s.v;
+				else if (s.t === "num" || s.t === "bool") {
+					const b = s.t === "bool" ? s.v : s.v !== 0;
+					any = true;
+					acc = name === "AND" ? acc && b : acc || b;
+				}
+			});
+			if (e) return err(e);
+		} else if (v.t === "arr") {
+			let e;
+			arrEach(v.rows, (s) => {
+				if (s.t === "err") e ??= s.v;
+				else if (s.t === "num" || s.t === "bool") {
+					const b = s.t === "bool" ? s.v : s.v !== 0;
+					any = true;
+					acc = name === "AND" ? acc && b : acc || b;
+				}
+			});
+			if (e) return err(e);
+		} else {
+			const b = toBool(v, ctx);
+			if (typeof b === "string") return err(b);
+			any = true;
+			acc = name === "AND" ? acc && b : acc || b;
+		}
+	}
+	return any ? bool(acc) : err("#VALUE!");
+}
+function gatherNumbers(args, ev, ctx) {
+	const out = [];
+	for (const a of args) {
+		const v = ev(a);
+		if (v.t === "ref") {
+			let e;
+			refEach(v, ctx, (_r, _c, s) => {
+				if (s.t === "num") out.push(s.v);
+				else if (s.t === "err") e ??= s.v;
+			});
+			if (e) return e;
+		} else if (v.t === "arr") {
+			let e;
+			arrEach(v.rows, (s) => {
+				if (s.t === "num") out.push(s.v);
+				else if (s.t === "bool") out.push(s.v ? 1 : 0);
+				else if (s.t === "err") e ??= s.v;
+			});
+			if (e) return e;
+		} else {
+			const s = deref(v, ctx);
+			if (s.t === "err") return s.v;
+			if (s.t === "num") out.push(s.v);
+			else if (s.t === "bool") out.push(s.v ? 1 : 0);
+		}
+	}
+	return out;
+}
+function aggregate(args, ev, ctx, reduce, requireSome = false) {
+	const ns = gatherNumbers(args, ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	if (requireSome && ns.length === 0) return err("#DIV/0!");
+	const r = reduce(ns);
+	return Number.isNaN(r) ? err("#DIV/0!") : num(r);
+}
+function countFn(args, ev, ctx, nonBlank) {
+	let count = 0;
+	for (const a of args) {
+		const v = ev(a);
+		if (v.t === "ref") refEach(v, ctx, (_r, _c, s) => {
+			if (nonBlank ? s.t !== "blank" : s.t === "num") count++;
+		});
+		else if (v.t === "arr") arrEach(v.rows, (s) => {
+			if (nonBlank ? s.t !== "blank" : s.t === "num") count++;
+		});
+		else {
+			const s = deref(v, ctx);
+			if (nonBlank ? s.t !== "blank" : s.t === "num") count++;
+		}
+	}
+	return num(count);
+}
+function leftRight(args, ev, ctx, left) {
+	if (args.length < 1 || args.length > 2) return err("#VALUE!");
+	const t = textArg(args, ev, ctx, 0);
+	if (typeof t !== "string") return err(t.v);
+	let n = 1;
+	if (args.length === 2) {
+		const d = numArg(args, ev, ctx, 1);
+		if (typeof d !== "number") return err(d.e);
+		n = Math.trunc(d);
+		if (n < 0) return err("#VALUE!");
+	}
+	return str(left ? t.slice(0, n) : n === 0 ? "" : t.slice(Math.max(0, t.length - n)));
+}
+function mid(args, ev, ctx) {
+	if (args.length !== 3) return err("#VALUE!");
+	const t = textArg(args, ev, ctx, 0);
+	if (typeof t !== "string") return err(t.v);
+	const start = numArg(args, ev, ctx, 1);
+	if (typeof start !== "number") return err(start.e);
+	const len = numArg(args, ev, ctx, 2);
+	if (typeof len !== "number") return err(len.e);
+	if (start < 1 || len < 0) return err("#VALUE!");
+	const s = Math.trunc(start) - 1;
+	return str(t.slice(s, s + Math.trunc(len)));
+}
+function concat(args, ev, ctx) {
+	let out = "";
+	for (let i = 0; i < args.length; i++) {
+		const t = textArg(args, ev, ctx, i);
+		if (typeof t !== "string") return err(t.v);
+		out += t;
+	}
+	return str(out);
+}
+function exact(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const a = textArg(args, ev, ctx, 0);
+	if (typeof a !== "string") return err(a.v);
+	const b = textArg(args, ev, ctx, 1);
+	if (typeof b !== "string") return err(b.v);
+	return bool(a === b);
+}
+function findSearch(args, ev, ctx, caseSensitive) {
+	if (args.length < 2 || args.length > 3) return err("#VALUE!");
+	let needle = textArg(args, ev, ctx, 0);
+	if (typeof needle !== "string") return err(needle.v);
+	let hay = textArg(args, ev, ctx, 1);
+	if (typeof hay !== "string") return err(hay.v);
+	let start = 1;
+	if (args.length === 3) {
+		const s = numArg(args, ev, ctx, 2);
+		if (typeof s !== "number") return err(s.e);
+		start = Math.trunc(s);
+		if (start < 1) return err("#VALUE!");
+	}
+	if (!caseSensitive) {
+		needle = needle.toLowerCase();
+		hay = hay.toLowerCase();
+	}
+	const idx = hay.indexOf(needle, start - 1);
+	return idx < 0 ? err("#VALUE!") : num(idx + 1);
+}
+function datePart(args, ev, ctx, pick) {
+	if (args.length !== 1) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	if (a < 0) return err("#NUM!");
+	return num(pick(serialToParts(a, ctx.date1904)));
+}
+function weekday(args, ev, ctx) {
+	if (args.length < 1 || args.length > 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	if (a < 0) return err("#NUM!");
+	let type = 1;
+	if (args.length === 2) {
+		const t = numArg(args, ev, ctx, 1);
+		if (typeof t !== "number") return err(t.e);
+		type = Math.trunc(t);
+	}
+	const dow = serialToParts(a, ctx.date1904).dow;
+	switch (type) {
+		case 1: return num(dow + 1);
+		case 2: return num((dow + 6) % 7 + 1);
+		case 3: return num((dow + 6) % 7);
+		default: return err("#NUM!");
+	}
+}
+function dateFn(args, ev, ctx) {
+	if (args.length !== 3) return err("#VALUE!");
+	const y = numArg(args, ev, ctx, 0);
+	if (typeof y !== "number") return err(y.e);
+	const m = numArg(args, ev, ctx, 1);
+	if (typeof m !== "number") return err(m.e);
+	const d = numArg(args, ev, ctx, 2);
+	if (typeof d !== "number") return err(d.e);
+	const serial = serialFromYmd(Math.trunc(y), Math.trunc(m), Math.trunc(d), ctx.date1904);
+	return serial < 0 ? err("#NUM!") : num(serial);
+}
+function edate(args, ev, ctx, endOfMonth) {
+	if (args.length !== 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	if (a < 0) return err("#NUM!");
+	const m = numArg(args, ev, ctx, 1);
+	if (typeof m !== "number") return err(m.e);
+	const p = serialToParts(a, ctx.date1904);
+	const idx = p.year * 12 + (p.month - 1) + Math.trunc(m);
+	const ty = Math.floor(idx / 12);
+	const tm = idx % 12 + 1;
+	const dim = daysInMonth(ty, tm);
+	const serial = serialFromYmd(ty, tm, endOfMonth ? dim : Math.min(p.day, dim), ctx.date1904);
+	return serial < 0 ? err("#NUM!") : num(serial);
+}
+function daysInMonth(year, month1) {
+	return new Date(Date.UTC(year, month1, 0)).getUTCDate();
+}
+function countSumIf(args, ev, ctx, sum) {
+	const minArgs = sum ? 2 : 2;
+	const maxArgs = sum ? 3 : 2;
+	if (args.length < minArgs || args.length > maxArgs) return err("#VALUE!");
+	const range = ev(args[0]);
+	if (range.t !== "ref") return err("#VALUE!");
+	const crit = parseCriteria(deref(ev(args[1]), ctx));
+	if ("e" in crit) return err(crit.e);
+	const sumRect = sum && args.length === 3 ? asRef(ev(args[2])) : void 0;
+	if (sum && args.length === 3 && !sumRect) return err("#VALUE!");
+	let count = 0;
+	let total = 0;
+	let e;
+	refEach(range, ctx, (r, c, s) => {
+		if (!matchCriteria(s, crit)) return;
+		count++;
+		if (!sum) return;
+		let target = s;
+		if (sumRect) {
+			const sr = sumRect.rect.r0 + (r - range.rect.r0);
+			const sc = sumRect.rect.c0 + (c - range.rect.c0);
+			target = refGet(sumRect.sheet, ctx, sr, sc);
+		}
+		if (target.t === "num") total += target.v;
+		else if (target.t === "err") e ??= target.v;
+	});
+	if (e) return err(e);
+	return num(sum ? total : count);
+}
+function asRef(v) {
+	return v.t === "ref" ? {
+		rect: v.rect,
+		...v.sheet !== void 0 ? { sheet: v.sheet } : {}
+	} : void 0;
+}
+function parseCriteria(s) {
+	if (s.t === "err") return { e: s.v };
+	if (s.t === "num") return {
+		kind: "num",
+		op: "=",
+		n: s.v
+	};
+	if (s.t === "bool") return {
+		kind: "num",
+		op: "=",
+		n: s.v ? 1 : 0
+	};
+	if (s.t === "blank") return {
+		kind: "num",
+		op: "=",
+		n: 0
+	};
+	let text = s.v;
+	let op = "=";
+	const m = /^(<>|>=|<=|>|<|=)/.exec(text);
+	if (m) {
+		op = m[1];
+		text = text.slice(m[1].length);
+	}
+	const n = Number(text.trim());
+	if (text.trim() !== "" && Number.isFinite(n)) return {
+		kind: "num",
+		op,
+		n
+	};
+	return {
+		kind: "text",
+		negate: op === "<>",
+		re: wildcardToRegExp(text)
+	};
+}
+function matchCriteria(cell, crit) {
+	if (crit.kind === "num") {
+		const v = cell.t === "num" ? cell.v : cell.t === "bool" ? cell.v ? 1 : 0 : void 0;
+		if (v === void 0) return false;
+		switch (crit.op) {
+			case "=": return v === crit.n;
+			case "<>": return v !== crit.n;
+			case ">": return v > crit.n;
+			case ">=": return v >= crit.n;
+			case "<": return v < crit.n;
+			case "<=": return v <= crit.n;
+		}
+	}
+	const text = cell.t === "str" ? cell.v : cell.t === "blank" ? "" : void 0;
+	if (text === void 0) return false;
+	const hit = crit.re.test(text);
+	return crit.negate ? !hit : hit;
+}
+function wildcardToRegExp(pattern) {
+	let out = "^";
+	for (let i = 0; i < pattern.length; i++) {
+		const ch = pattern[i];
+		if (ch === "~" && (pattern[i + 1] === "*" || pattern[i + 1] === "?" || pattern[i + 1] === "~")) {
+			out += escapeRe(pattern[i + 1]);
+			i++;
+		} else if (ch === "*") out += ".*";
+		else if (ch === "?") out += ".";
+		else out += escapeRe(ch);
+	}
+	out += "$";
+	return new RegExp(out, "is");
+}
+function escapeRe(ch) {
+	return /[.*+?^${}()|[\]\\]/.test(ch) ? `\\${ch}` : ch;
+}
+var MAX_SCAN = 2e5;
+function isParity(args, ev, ctx, even) {
+	if (args.length !== 1) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	const odd = Math.abs(Math.trunc(a)) % 2 === 1;
+	return bool(even ? !odd : odd);
+}
+function xorFn(args, ev, ctx) {
+	let trues = 0;
+	let any = false;
+	for (const a of args) {
+		const v = ev(a);
+		if (v.t === "ref") {
+			let e;
+			refEach(v, ctx, (_r, _c, s) => {
+				if (s.t === "err") e ??= s.v;
+				else if (s.t === "num" || s.t === "bool") {
+					any = true;
+					if (s.t === "bool" ? s.v : s.v !== 0) trues++;
+				}
+			});
+			if (e) return err(e);
+		} else {
+			const b = toBool(v, ctx);
+			if (typeof b === "string") return err(b);
+			any = true;
+			if (b) trues++;
+		}
+	}
+	return any ? bool(trues % 2 === 1) : err("#VALUE!");
+}
+function ifsFn(args, ev, ctx) {
+	if (args.length < 2 || args.length % 2 !== 0) return err("#VALUE!");
+	for (let i = 0; i < args.length; i += 2) {
+		const c = toBool(ev(args[i]), ctx);
+		if (typeof c === "string") return err(c);
+		if (c) return ev(args[i + 1]);
+	}
+	return err("#N/A");
+}
+function switchFn(args, ev, ctx) {
+	if (args.length < 3) return err("#VALUE!");
+	const target = deref(ev(args[0]), ctx);
+	if (target.t === "err") return target;
+	let i = 1;
+	for (; i + 1 < args.length; i += 2) {
+		const cand = deref(ev(args[i]), ctx);
+		if (cand.t === "err") return cand;
+		if (scalarEquals(target, cand)) return ev(args[i + 1]);
+	}
+	return i < args.length ? ev(args[i]) : err("#N/A");
+}
+function scalarEquals(a, b) {
+	if (a.t === "num" && b.t === "num") return a.v === b.v;
+	if (a.t === "str" && b.t === "str") return a.v.toLowerCase() === b.v.toLowerCase();
+	if (a.t === "bool" && b.t === "bool") return a.v === b.v;
+	return a.t === "blank" && b.t === "blank";
+}
+function cmpScalar(a, b) {
+	if (a.t === "num" && b.t === "num") return a.v < b.v ? -1 : a.v > b.v ? 1 : 0;
+	if (a.t === "str" && b.t === "str") {
+		const x = a.v.toLowerCase();
+		const y = b.v.toLowerCase();
+		return x < y ? -1 : x > y ? 1 : 0;
+	}
+	if (a.t === "bool" && b.t === "bool") return a.v === b.v ? 0 : a.v ? 1 : -1;
+}
+function quotient(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	const b = numArg(args, ev, ctx, 1);
+	if (typeof b !== "number") return err(b.e);
+	if (b === 0) return err("#DIV/0!");
+	return num(Math.trunc(a / b));
+}
+function ceilingFloor(args, ev, ctx, mode) {
+	if (args.length !== 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	const sig = numArg(args, ev, ctx, 1);
+	if (typeof sig !== "number") return err(sig.e);
+	if (sig === 0) return num(0);
+	if (a !== 0 && a > 0 !== sig > 0) return err("#NUM!");
+	const q = Math.abs(a) / Math.abs(sig);
+	const snapped = Math.abs(q - Math.round(q)) < 1e-9 ? Math.round(q) : q;
+	const mag = (mode === "ceil" ? Math.ceil(snapped) : Math.floor(snapped)) * Math.abs(sig);
+	return num(a < 0 ? -mag : mag);
+}
+function roundHalfAway(q) {
+	const f = Math.floor(q);
+	return Math.abs(q - f - .5) < 1e-9 ? f + 1 : Math.round(q);
+}
+function mround(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const n = numArg(args, ev, ctx, 0);
+	if (typeof n !== "number") return err(n.e);
+	const mult = numArg(args, ev, ctx, 1);
+	if (typeof mult !== "number") return err(mult.e);
+	if (mult === 0) return num(0);
+	if (n !== 0 && n > 0 !== mult > 0) return err("#NUM!");
+	const mag = roundHalfAway(Math.abs(n) / Math.abs(mult)) * Math.abs(mult);
+	return num(n < 0 ? -mag : mag);
+}
+function evenOdd(args, ev, ctx, even) {
+	if (args.length !== 1) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	let m = Math.ceil(Math.abs(a));
+	if (even) {
+		if (m % 2 !== 0) m++;
+	} else if (m % 2 === 0) m++;
+	return num(a < 0 ? -m : m);
+}
+function gcd2(a, b) {
+	a = Math.abs(a);
+	b = Math.abs(b);
+	while (b) {
+		const t = a % b;
+		a = b;
+		b = t;
+	}
+	return a;
+}
+function gcdLcm(args, ev, ctx, mode) {
+	const ns = gatherNumbers(args, ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	if (ns.length === 0) return err("#VALUE!");
+	const ints = [];
+	for (const n of ns) {
+		const t = Math.trunc(n);
+		if (t < 0) return err("#NUM!");
+		ints.push(t);
+	}
+	if (mode === "gcd") return num(ints.reduce((a, b) => gcd2(a, b)));
+	let l = ints[0];
+	for (let i = 1; i < ints.length; i++) {
+		const b = ints[i];
+		if (l === 0 || b === 0) {
+			l = 0;
+			continue;
+		}
+		l = l / gcd2(l, b) * b;
+		if (!Number.isSafeInteger(l)) return err("#NUM!");
+	}
+	return num(l);
+}
+function medianFn(args, ev, ctx) {
+	const ns = gatherNumbers(args, ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	if (ns.length === 0) return err("#NUM!");
+	const s = [...ns].sort((a, b) => a - b);
+	const midIdx = Math.floor(s.length / 2);
+	return num(s.length % 2 ? s[midIdx] : (s[midIdx - 1] + s[midIdx]) / 2);
+}
+function largeSmall(args, ev, ctx, large) {
+	if (args.length !== 2) return err("#VALUE!");
+	const ns = gatherNumbers([args[0]], ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	const k = numArg(args, ev, ctx, 1);
+	if (typeof k !== "number") return err(k.e);
+	const ki = Math.trunc(k);
+	if (ki < 1 || ki > ns.length) return err("#NUM!");
+	return num([...ns].sort((a, b) => large ? b - a : a - b)[ki - 1]);
+}
+function countBlank(args, ev, ctx) {
+	if (args.length !== 1) return err("#VALUE!");
+	const r = asRef(ev(args[0]));
+	if (!r) return err("#VALUE!");
+	const area = (r.rect.r1 - r.rect.r0 + 1) * (r.rect.c1 - r.rect.c0 + 1);
+	let filled = 0;
+	refEach(r, ctx, (_x, _y, s) => {
+		if (!(s.t === "blank" || s.t === "str" && s.v === "")) filled++;
+	});
+	return num(Math.max(0, area - filled));
+}
+function countSumAvgIfs(args, ev, ctx, mode) {
+	const isCount = mode === "count";
+	let valueRef;
+	let pairStart = 0;
+	if (!isCount) {
+		const vr = asRef(ev(args[0]));
+		if (!vr) return err("#VALUE!");
+		valueRef = vr;
+		pairStart = 1;
+	}
+	const pairs = args.length - pairStart;
+	if (pairs < 2 || pairs % 2 !== 0) return err("#VALUE!");
+	const ranges = [];
+	const crits = [];
+	for (let i = pairStart; i + 1 < args.length; i += 2) {
+		const rng = asRef(ev(args[i]));
+		if (!rng) return err("#VALUE!");
+		const crit = parseCriteria(deref(ev(args[i + 1]), ctx));
+		if ("e" in crit) return err(crit.e);
+		ranges.push(rng);
+		crits.push(crit);
+	}
+	const base = ranges[0].rect;
+	const h = base.r1 - base.r0;
+	const w = base.c1 - base.c0;
+	for (const r of ranges) if (r.rect.r1 - r.rect.r0 !== h || r.rect.c1 - r.rect.c0 !== w) return err("#VALUE!");
+	if (valueRef) {
+		const vr = valueRef.rect;
+		if (vr.r1 - vr.r0 !== h || vr.c1 - vr.c0 !== w) return err("#VALUE!");
+	}
+	let count = 0;
+	let total = 0;
+	let numCount = 0;
+	let e;
+	refEach(ranges[0], ctx, (r, c, s0) => {
+		if (!matchCriteria(s0, crits[0])) return;
+		for (let k = 1; k < ranges.length; k++) {
+			const rk = ranges[k];
+			if (!matchCriteria(refGet(rk.sheet, ctx, rk.rect.r0 + (r - base.r0), rk.rect.c0 + (c - base.c0)), crits[k])) return;
+		}
+		count++;
+		if (isCount) return;
+		const vref = valueRef;
+		const target = refGet(vref.sheet, ctx, vref.rect.r0 + (r - base.r0), vref.rect.c0 + (c - base.c0));
+		if (target.t === "num") {
+			total += target.v;
+			numCount++;
+		} else if (target.t === "err") e ??= target.v;
+	});
+	if (e) return err(e);
+	if (isCount) return num(count);
+	if (mode === "sum") return num(total);
+	return numCount === 0 ? err("#DIV/0!") : num(total / numCount);
+}
+function averageIf(args, ev, ctx) {
+	if (args.length < 2 || args.length > 3) return err("#VALUE!");
+	const range = asRef(ev(args[0]));
+	if (!range) return err("#VALUE!");
+	const crit = parseCriteria(deref(ev(args[1]), ctx));
+	if ("e" in crit) return err(crit.e);
+	const avgRef = args.length === 3 ? asRef(ev(args[2])) : range;
+	if (!avgRef) return err("#VALUE!");
+	const rr = range.rect;
+	const ar = avgRef.rect;
+	let total = 0;
+	let count = 0;
+	let e;
+	refEach(range, ctx, (r, c, s) => {
+		if (!matchCriteria(s, crit)) return;
+		const target = avgRef === range ? s : refGet(avgRef.sheet, ctx, ar.r0 + (r - rr.r0), ar.c0 + (c - rr.c0));
+		if (target.t === "num") {
+			total += target.v;
+			count++;
+		} else if (target.t === "err") e ??= target.v;
+	});
+	if (e) return err(e);
+	return count === 0 ? err("#DIV/0!") : num(total / count);
+}
+function sumProduct(args, ev, ctx) {
+	if (args.length === 0) return err("#VALUE!");
+	const vals = args.map((a) => ev(a));
+	const refs = vals.map((v) => asRef(v));
+	if (refs.every((r) => r === void 0)) {
+		let p = 1;
+		for (const v of vals) {
+			const n = toNumber(v, ctx);
+			if (typeof n === "string") return err(n);
+			p *= n;
+		}
+		return num(p);
+	}
+	if (refs.some((r) => r === void 0)) return err("#VALUE!");
+	const base = refs[0].rect;
+	const h = base.r1 - base.r0;
+	const w = base.c1 - base.c0;
+	for (const r of refs) if (r.rect.r1 - r.rect.r0 !== h || r.rect.c1 - r.rect.c0 !== w) return err("#VALUE!");
+	let total = 0;
+	let e;
+	refEach(refs[0], ctx, (r, c, s0) => {
+		if (s0.t === "err") {
+			e ??= s0.v;
+			return;
+		}
+		if (s0.t !== "num") return;
+		let term = s0.v;
+		for (let k = 1; k < refs.length && term !== 0; k++) {
+			const rk = refs[k];
+			const cell = refGet(rk.sheet, ctx, rk.rect.r0 + (r - base.r0), rk.rect.c0 + (c - base.c0));
+			if (cell.t === "num") term *= cell.v;
+			else if (cell.t === "err") {
+				e ??= cell.v;
+				term = 0;
+			} else term = 0;
+		}
+		total += term;
+	});
+	return e ? err(e) : num(total);
+}
+function concatFlatten(args, ev, ctx) {
+	let out = "";
+	for (const a of args) {
+		const v = ev(a);
+		if (v.t === "ref") {
+			const { r0, c0, r1, c1 } = v.rect;
+			if ((r1 - r0 + 1) * (c1 - c0 + 1) > MAX_SCAN) return err("#VALUE!");
+			for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) {
+				const t = toText(refGet(v.sheet, ctx, r, c), ctx);
+				if (typeof t !== "string") return err(t);
+				out += t;
+				if (out.length > 32767) return err("#VALUE!");
+			}
+		} else {
+			const t = toText(v, ctx);
+			if (typeof t !== "string") return err(t);
+			out += t;
+		}
+	}
+	return str(out);
+}
+function textJoin(args, ev, ctx) {
+	if (args.length < 3) return err("#VALUE!");
+	const delim = textArg(args, ev, ctx, 0);
+	if (typeof delim !== "string") return err(delim.v);
+	const ignore = toBool(ev(args[1]), ctx);
+	if (typeof ignore === "string") return err(ignore);
+	const parts = [];
+	for (let i = 2; i < args.length; i++) {
+		const v = ev(args[i]);
+		if (v.t === "ref") {
+			const { r0, c0, r1, c1 } = v.rect;
+			if ((r1 - r0 + 1) * (c1 - c0 + 1) > MAX_SCAN) return err("#VALUE!");
+			for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) {
+				const t = toText(refGet(v.sheet, ctx, r, c), ctx);
+				if (typeof t !== "string") return err(t);
+				if (!(ignore && t === "")) parts.push(t);
+			}
+		} else {
+			const t = toText(v, ctx);
+			if (typeof t !== "string") return err(t);
+			if (!(ignore && t === "")) parts.push(t);
+		}
+	}
+	return str(parts.join(delim));
+}
+function substitute(args, ev, ctx) {
+	if (args.length < 3 || args.length > 4) return err("#VALUE!");
+	const text = textArg(args, ev, ctx, 0);
+	if (typeof text !== "string") return err(text.v);
+	const oldT = textArg(args, ev, ctx, 1);
+	if (typeof oldT !== "string") return err(oldT.v);
+	const newT = textArg(args, ev, ctx, 2);
+	if (typeof newT !== "string") return err(newT.v);
+	if (oldT === "") return str(text);
+	if (args.length === 3) return str(text.split(oldT).join(newT));
+	const inst = numArg(args, ev, ctx, 3);
+	if (typeof inst !== "number") return err(inst.e);
+	const k = Math.trunc(inst);
+	if (k < 1) return err("#VALUE!");
+	let idx = -1;
+	let count = 0;
+	for (;;) {
+		idx = text.indexOf(oldT, idx + 1);
+		if (idx < 0) return str(text);
+		if (++count === k) return str(text.slice(0, idx) + newT + text.slice(idx + oldT.length));
+	}
+}
+function replaceFn(args, ev, ctx) {
+	if (args.length !== 4) return err("#VALUE!");
+	const text = textArg(args, ev, ctx, 0);
+	if (typeof text !== "string") return err(text.v);
+	const start = numArg(args, ev, ctx, 1);
+	if (typeof start !== "number") return err(start.e);
+	const len = numArg(args, ev, ctx, 2);
+	if (typeof len !== "number") return err(len.e);
+	const newT = textArg(args, ev, ctx, 3);
+	if (typeof newT !== "string") return err(newT.v);
+	const s = Math.trunc(start);
+	const l = Math.trunc(len);
+	if (s < 1 || l < 0) return err("#VALUE!");
+	return str(text.slice(0, s - 1) + newT + text.slice(s - 1 + l));
+}
+function rept(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const text = textArg(args, ev, ctx, 0);
+	if (typeof text !== "string") return err(text.v);
+	const n = numArg(args, ev, ctx, 1);
+	if (typeof n !== "number") return err(n.e);
+	const k = Math.trunc(n);
+	if (k < 0) return err("#VALUE!");
+	if (text.length * k > 32767) return err("#VALUE!");
+	return str(text.repeat(k));
+}
+function properCase(s) {
+	return s.replace(/[A-Za-z]+/g, (w) => w[0].toUpperCase() + w.slice(1).toLowerCase());
+}
+function charFn(args, ev, ctx) {
+	if (args.length !== 1) return err("#VALUE!");
+	const n = numArg(args, ev, ctx, 0);
+	if (typeof n !== "number") return err(n.e);
+	const code = Math.trunc(n);
+	if (code < 1 || code > 255) return err("#VALUE!");
+	return str(String.fromCharCode(code));
+}
+function codeFn(args, ev, ctx) {
+	const t = textArg(args, ev, ctx, 0);
+	if (typeof t !== "string") return err(t.v);
+	if (t.length === 0) return err("#VALUE!");
+	return num(t.charCodeAt(0));
+}
+function stripControl(s) {
+	let out = "";
+	for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) >= 32) out += s[i];
+	return out;
+}
+function tFn(args, ev, ctx) {
+	if (args.length !== 1) return err("#VALUE!");
+	const s = deref(ev(args[0]), ctx);
+	if (s.t === "err") return s;
+	return s.t === "str" ? s : str("");
+}
+function daysFn(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const end = numArg(args, ev, ctx, 0);
+	if (typeof end !== "number") return err(end.e);
+	const start = numArg(args, ev, ctx, 1);
+	if (typeof start !== "number") return err(start.e);
+	return num(Math.trunc(end) - Math.trunc(start));
+}
+function timePart(args, ev, ctx, part) {
+	if (args.length !== 1) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	if (a < 0) return err("#NUM!");
+	let secs = Math.round((a - Math.floor(a)) * 86400);
+	if (secs >= 86400) secs -= 86400;
+	if (part === "h") return num(Math.floor(secs / 3600));
+	if (part === "m") return num(Math.floor(secs / 60) % 60);
+	return num(secs % 60);
+}
+function timeFn(args, ev, ctx) {
+	if (args.length !== 3) return err("#VALUE!");
+	const h = numArg(args, ev, ctx, 0);
+	if (typeof h !== "number") return err(h.e);
+	const m = numArg(args, ev, ctx, 1);
+	if (typeof m !== "number") return err(m.e);
+	const s = numArg(args, ev, ctx, 2);
+	if (typeof s !== "number") return err(s.e);
+	return num(((Math.trunc(h) * 3600 + Math.trunc(m) * 60 + Math.trunc(s)) % 86400 + 86400) % 86400 / 86400);
+}
+function weekStartDow(type) {
+	switch (type) {
+		case 1:
+		case 17: return 0;
+		case 2:
+		case 11: return 1;
+		case 12: return 2;
+		case 13: return 3;
+		case 14: return 4;
+		case 15: return 5;
+		case 16: return 6;
+		default: return;
+	}
+}
+function weekNum(args, ev, ctx, iso) {
+	if (args.length < 1 || args.length > 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	if (a < 0) return err("#NUM!");
+	const serial = Math.floor(a);
+	if (iso) return num(isoWeek(serial, ctx.date1904));
+	let type = 1;
+	if (args.length === 2) {
+		const t = numArg(args, ev, ctx, 1);
+		if (typeof t !== "number") return err(t.e);
+		type = Math.trunc(t);
+	}
+	if (type === 21) return num(isoWeek(serial, ctx.date1904));
+	const firstDow = weekStartDow(type);
+	if (firstDow === void 0) return err("#NUM!");
+	const jan1 = serialFromYmd(serialToParts(serial, ctx.date1904).year, 1, 1, ctx.date1904);
+	const offset = (serialToParts(jan1, ctx.date1904).dow - firstDow + 7) % 7;
+	const dayOfYear = serial - jan1 + 1;
+	return num(Math.floor((dayOfYear + offset - 1) / 7) + 1);
+}
+function isoWeek(serial, date1904) {
+	const thursday = serial - (serialToParts(serial, date1904).dow + 6) % 7 + 3;
+	const ty = serialToParts(thursday, date1904).year;
+	const jan1 = serialFromYmd(ty, 1, 1, date1904);
+	return Math.floor((thursday - jan1) / 7) + 1;
+}
+function chooseFn(args, ev, ctx) {
+	if (args.length < 2) return err("#VALUE!");
+	const i = numArg(args, ev, ctx, 0);
+	if (typeof i !== "number") return err(i.e);
+	const k = Math.trunc(i);
+	if (k < 1 || k > args.length - 1) return err("#VALUE!");
+	return ev(args[k]);
+}
+function matchFn(args, ev, ctx) {
+	if (args.length < 2 || args.length > 3) return err("#VALUE!");
+	const target = deref(ev(args[0]), ctx);
+	if (target.t === "err") return target;
+	const range = asRef(ev(args[1]));
+	if (!range) return err("#VALUE!");
+	const rect = range.rect;
+	let type = 1;
+	if (args.length === 3) {
+		const t = numArg(args, ev, ctx, 2);
+		if (typeof t !== "number") return err(t.e);
+		type = Math.trunc(t);
+	}
+	const horizontal = rect.r0 === rect.r1;
+	const vertical = rect.c0 === rect.c1;
+	if (!horizontal && !vertical) return err("#N/A");
+	const len = horizontal ? rect.c1 - rect.c0 + 1 : rect.r1 - rect.r0 + 1;
+	if (len > MAX_SCAN) return err("#N/A");
+	const at = (i) => horizontal ? refGet(range.sheet, ctx, rect.r0, rect.c0 + i) : refGet(range.sheet, ctx, rect.r0 + i, rect.c0);
+	if (type === 0) {
+		const re = target.t === "str" ? wildcardToRegExp(target.v) : void 0;
+		for (let i = 0; i < len; i++) {
+			const cell = at(i);
+			if (re ? cell.t === "str" && re.test(cell.v) : scalarEquals(cell, target)) return num(i + 1);
+		}
+		return err("#N/A");
+	}
+	let best = -1;
+	for (let i = 0; i < len; i++) {
+		const cmp = cmpScalar(at(i), target);
+		if (cmp === void 0) continue;
+		if (type === 1 ? cmp <= 0 : cmp >= 0) best = i;
+		else break;
+	}
+	return best < 0 ? err("#N/A") : num(best + 1);
+}
+function indexFn(args, ev, ctx) {
+	if (args.length < 2 || args.length > 3) return err("#VALUE!");
+	const range = asRef(ev(args[0]));
+	if (!range) return err("#VALUE!");
+	const rect = range.rect;
+	const rn = numArg(args, ev, ctx, 1);
+	if (typeof rn !== "number") return err(rn.e);
+	let r = Math.trunc(rn);
+	let cn = 1;
+	if (args.length === 3) {
+		const c = numArg(args, ev, ctx, 2);
+		if (typeof c !== "number") return err(c.e);
+		cn = Math.trunc(c);
+	}
+	const rows = rect.r1 - rect.r0 + 1;
+	const cols = rect.c1 - rect.c0 + 1;
+	if (args.length === 2 && rows === 1 && cols > 1) {
+		cn = r;
+		r = 1;
+	}
+	if (r < 0 || cn < 0 || r > rows || cn > cols) return err("#REF!");
+	if (r === 0 || cn === 0) return err("#VALUE!");
+	return refGet(range.sheet, ctx, rect.r0 + r - 1, rect.c0 + cn - 1);
+}
+function lookupFn(args, ev, ctx, vh) {
+	if (args.length < 3 || args.length > 4) return err("#VALUE!");
+	const target = deref(ev(args[0]), ctx);
+	if (target.t === "err") return target;
+	const table = asRef(ev(args[1]));
+	if (!table) return err("#VALUE!");
+	const rect = table.rect;
+	const sh = table.sheet;
+	const idx = numArg(args, ev, ctx, 2);
+	if (typeof idx !== "number") return err(idx.e);
+	const line = Math.trunc(idx);
+	let approx = true;
+	if (args.length === 4) {
+		const b = toBool(ev(args[3]), ctx);
+		if (typeof b === "string") return err(b);
+		approx = b;
+	}
+	const rows = rect.r1 - rect.r0 + 1;
+	const cols = rect.c1 - rect.c0 + 1;
+	const vertical = vh === "v";
+	const vecLen = vertical ? rows : cols;
+	if (line < 1 || line > (vertical ? cols : rows)) return err("#REF!");
+	if (vecLen > MAX_SCAN) return err("#N/A");
+	const keyAt = (i) => vertical ? refGet(sh, ctx, rect.r0 + i, rect.c0) : refGet(sh, ctx, rect.r0, rect.c0 + i);
+	const resultAt = (i) => vertical ? refGet(sh, ctx, rect.r0 + i, rect.c0 + line - 1) : refGet(sh, ctx, rect.r0 + line - 1, rect.c0 + i);
+	if (!approx) {
+		const re = target.t === "str" ? wildcardToRegExp(target.v) : void 0;
+		for (let i = 0; i < vecLen; i++) {
+			const k = keyAt(i);
+			if (re ? k.t === "str" && re.test(k.v) : scalarEquals(k, target)) return resultAt(i);
+		}
+		return err("#N/A");
+	}
+	let best = -1;
+	for (let i = 0; i < vecLen; i++) {
+		const cmp = cmpScalar(keyAt(i), target);
+		if (cmp === void 0) continue;
+		if (cmp <= 0) best = i;
+		else break;
+	}
+	return best < 0 ? err("#N/A") : resultAt(best);
+}
+function math2(args, ev, ctx, f) {
+	if (args.length !== 2) return err("#VALUE!");
+	const a = numArg(args, ev, ctx, 0);
+	if (typeof a !== "number") return err(a.e);
+	const b = numArg(args, ev, ctx, 1);
+	if (typeof b !== "number") return err(b.e);
+	const r = f(a, b);
+	return Number.isNaN(r) ? err("#NUM!") : num(r);
+}
+function logFn(args, ev, ctx) {
+	if (args.length < 1 || args.length > 2) return err("#VALUE!");
+	const x = numArg(args, ev, ctx, 0);
+	if (typeof x !== "number") return err(x.e);
+	let base = 10;
+	if (args.length === 2) {
+		const b = numArg(args, ev, ctx, 1);
+		if (typeof b !== "number") return err(b.e);
+		base = b;
+	}
+	if (x <= 0 || base <= 0 || base === 1) return err("#NUM!");
+	return num(Math.log(x) / Math.log(base));
+}
+function factFn(args, ev, ctx) {
+	if (args.length !== 1) return err("#VALUE!");
+	const n = numArg(args, ev, ctx, 0);
+	if (typeof n !== "number") return err(n.e);
+	const k = Math.trunc(n);
+	if (k < 0 || k > 170) return err("#NUM!");
+	let r = 1;
+	for (let i = 2; i <= k; i++) r *= i;
+	return num(r);
+}
+function combinPermut(args, ev, ctx, perm) {
+	if (args.length !== 2) return err("#VALUE!");
+	const nN = numArg(args, ev, ctx, 0);
+	if (typeof nN !== "number") return err(nN.e);
+	const kN = numArg(args, ev, ctx, 1);
+	if (typeof kN !== "number") return err(kN.e);
+	const n = Math.trunc(nN);
+	const k = Math.trunc(kN);
+	if (n < 0 || k < 0 || k > n) return err("#NUM!");
+	let p = 1;
+	for (let i = 0; i < k; i++) p *= n - i;
+	if (perm) return num(p);
+	let kf = 1;
+	for (let i = 2; i <= k; i++) kf *= i;
+	return num(Math.round(p / kf));
+}
+function statSpread(args, ev, ctx, kind, sample) {
+	const ns = gatherNumbers(args, ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	const n = ns.length;
+	if (n === 0 || sample && n < 2) return err("#DIV/0!");
+	const mean = ns.reduce((a, b) => a + b, 0) / n;
+	if (kind === "avedev") return num(ns.reduce((a, b) => a + Math.abs(b - mean), 0) / n);
+	const ss = ns.reduce((a, b) => a + (b - mean) * (b - mean), 0);
+	if (kind === "devsq") return num(ss);
+	const variance = ss / (sample ? n - 1 : n);
+	return num(kind === "var" ? variance : Math.sqrt(variance));
+}
+function geoHarMean(args, ev, ctx, geo) {
+	const ns = gatherNumbers(args, ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	if (ns.length === 0 || ns.some((x) => x <= 0)) return err("#NUM!");
+	if (geo) return num(Math.exp(ns.reduce((a, b) => a + Math.log(b), 0) / ns.length));
+	return num(ns.length / ns.reduce((a, b) => a + 1 / b, 0));
+}
+function aggregateA(args, ev, ctx, kind) {
+	const ns = [];
+	let e;
+	const take = (s) => {
+		if (s.t === "num") ns.push(s.v);
+		else if (s.t === "bool") ns.push(s.v ? 1 : 0);
+		else if (s.t === "str") ns.push(0);
+		else if (s.t === "err") e ??= s.v;
+	};
+	for (const a of args) {
+		const v = ev(a);
+		if (v.t === "ref") refEach(v, ctx, (_r, _c, s) => take(s));
+		else take(deref(v, ctx));
+	}
+	if (e) return err(e);
+	if (ns.length === 0) return kind === "avg" ? err("#DIV/0!") : num(0);
+	if (kind === "avg") return num(ns.reduce((a, b) => a + b, 0) / ns.length);
+	return num(kind === "max" ? Math.max(...ns) : Math.min(...ns));
+}
+function modeFn(args, ev, ctx) {
+	const ns = gatherNumbers(args, ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	const counts = /* @__PURE__ */ new Map();
+	for (const x of ns) counts.set(x, (counts.get(x) ?? 0) + 1);
+	let maxCount = 1;
+	for (const c of counts.values()) if (c > maxCount) maxCount = c;
+	if (maxCount < 2) return err("#N/A");
+	for (const x of ns) if (counts.get(x) === maxCount) return num(x);
+	return err("#N/A");
+}
+function rankFn(args, ev, ctx) {
+	if (args.length < 2 || args.length > 3) return err("#VALUE!");
+	const x = numArg(args, ev, ctx, 0);
+	if (typeof x !== "number") return err(x.e);
+	const ns = gatherNumbers([args[1]], ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	let asc = false;
+	if (args.length === 3) {
+		const o = numArg(args, ev, ctx, 2);
+		if (typeof o !== "number") return err(o.e);
+		asc = o !== 0;
+	}
+	if (!ns.includes(x)) return err("#N/A");
+	let rank = 1;
+	for (const v of ns) if (asc ? v < x : v > x) rank++;
+	return num(rank);
+}
+function percentileFn(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const ns = gatherNumbers([args[0]], ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	const k = numArg(args, ev, ctx, 1);
+	if (typeof k !== "number") return err(k.e);
+	return percentile(ns, k);
+}
+function quartileFn(args, ev, ctx) {
+	if (args.length !== 2) return err("#VALUE!");
+	const ns = gatherNumbers([args[0]], ev, ctx);
+	if (!Array.isArray(ns)) return err(ns);
+	const q = numArg(args, ev, ctx, 1);
+	if (typeof q !== "number") return err(q.e);
+	const qi = Math.trunc(q);
+	if (qi < 0 || qi > 4) return err("#NUM!");
+	return percentile(ns, qi / 4);
+}
+function percentile(ns, k) {
+	if (ns.length === 0 || k < 0 || k > 1) return err("#NUM!");
+	const sorted = [...ns].sort((a, b) => a - b);
+	const pos = k * (sorted.length - 1);
+	const lo = Math.floor(pos);
+	const hi = Math.ceil(pos);
+	return num(sorted[lo] + (sorted[hi] - sorted[lo]) * (pos - lo));
+}
+function rectArg(arg, ev) {
+	const v = ev(arg);
+	return v.t === "ref" ? v.rect : void 0;
+}
+function rowColFn(args, ev, shift, isRow) {
+	if (args.length === 0) {
+		const cur = isRow ? shift.curRow : shift.curCol;
+		return cur === void 0 ? err("#VALUE!") : num(cur + 1);
+	}
+	if (args.length !== 1) return err("#VALUE!");
+	const rect = rectArg(args[0], ev);
+	return rect ? num((isRow ? rect.r0 : rect.c0) + 1) : err("#VALUE!");
+}
+function rowsColsFn(args, ev, isRows) {
+	if (args.length !== 1) return err("#VALUE!");
+	const rect = rectArg(args[0], ev);
+	if (!rect) return err("#VALUE!");
+	return num(isRows ? rect.r1 - rect.r0 + 1 : rect.c1 - rect.c0 + 1);
+}
+function typeFn(args, ev, ctx) {
+	if (args.length !== 1) return err("#VALUE!");
+	const s = deref(ev(args[0]), ctx);
+	if (s.t === "str") return num(2);
+	if (s.t === "bool") return num(4);
+	if (s.t === "err") return num(16);
+	return num(1);
+}
+var ERROR_TYPE_CODES = {
+	"#NULL!": 1,
+	"#DIV/0!": 2,
+	"#VALUE!": 3,
+	"#REF!": 4,
+	"#NAME?": 5,
+	"#NUM!": 6,
+	"#N/A": 7
+};
+function errorTypeFn(args, ev, ctx) {
+	if (args.length !== 1) return err("#VALUE!");
+	const s = deref(ev(args[0]), ctx);
+	return s.t === "err" ? num(ERROR_TYPE_CODES[s.v]) : err("#N/A");
+}
+function unicharFn(args, ev, ctx) {
+	if (args.length !== 1) return err("#VALUE!");
+	const n = numArg(args, ev, ctx, 0);
+	if (typeof n !== "number") return err(n.e);
+	const cp = Math.trunc(n);
+	if (cp < 1 || cp > 1114111) return err("#VALUE!");
+	return str(String.fromCodePoint(cp));
+}
+function unicodeFn(args, ev, ctx) {
+	const t = textArg(args, ev, ctx, 0);
+	if (typeof t !== "string") return err(t.v);
+	if (args.length !== 1 || t.length === 0) return err("#VALUE!");
+	return num(t.codePointAt(0));
+}
+//#endregion
+export { callFn };