@sheetxl/primitives 0.8.0-beta.12 → 0.8.0-beta.14

package/browser/esm/index.mjs

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/primitives - Primitives - Base types for SheetXL functions. - v0.8.0-beta.12
+* @license @sheetxl/primitives - Primitives - Base types for SheetXL functions. - v0.8.0-beta.14
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.
@@ -21,6 +21,39 @@ var e;
 		}
 		return i === null ? e : i.join("");
 	};
+	let n = e.MIN_NUMBER = 22250738585072014e-324;
+	e.flushSubnormal = function(e) {
+		return e > -n && e < n ? 0 : e;
+	}, e.isNumberTextInRange = function(e, t = ".") {
+		let n = e.length;
+		if (n < 309 && e.indexOf("E") < 0 && e.indexOf("e") < 0) return !0;
+		let r = t.charCodeAt(0), i = !1, a = !1, o = !1, s = 0, c = 0, l = 0, u = 0;
+		for (; u < n; u++) {
+			let t = e.charCodeAt(u);
+			if (t >= 48 && t <= 57) i = !0, a ? (l++, o || (t === 48 ? c++ : o = !0)) : (o || t !== 48) && (o = !0, s++);
+			else if (t === r) a = !0;
+			else if ((t === 69 || t === 101) && i) break;
+		}
+		let d = 0;
+		if (u < n) {
+			let t = u + 1, r = !1, i = e.charCodeAt(t);
+			i === 45 ? (r = !0, t++) : i === 43 && t++;
+			let a = 0;
+			for (; t < n; t++) {
+				let n = e.charCodeAt(t);
+				if (n < 48 || n > 57) break;
+				d = 10 * d + (n - 48), a++;
+			}
+			if (a === 0) return !0;
+			r && (d = -d);
+		}
+		if (o) {
+			let e = (s > 0 ? s - 1 : -(c + 1)) + d;
+			return e >= -309 && e <= 307;
+		}
+		let f = d - l;
+		return f >= -308 && f <= 308;
+	};
 })(e ||= {});
 var t, n, r, i, a = {
 	Number: "number",
@@ -370,34 +403,34 @@ var v = class {
 	}
 }, y = class {
 	createRange(e, t, n) {
-		throw new C();
+		throw x("createRange");
 	}
 	flattenAreas(e) {
-		throw new C();
+		throw x("flattenAreas");
 	}
 	getReference(e, t) {
-		throw new C();
+		throw x("getReference");
 	}
 	getResizedReference(e, t, n) {
-		throw new C();
+		throw x("getResizedReference");
 	}
 	getNumberFormat(e, t) {
-		throw new C();
+		throw x("getNumberFormat");
 	}
 	fromSerialDate(e, t) {
-		throw new C();
+		throw x("fromSerialDate");
 	}
 	toSerialDate(e, t) {
-		throw new C();
+		throw x("toSerialDate");
 	}
 	getDateParts(e, t) {
-		throw new C();
+		throw x("getDateParts");
 	}
 	getSerialDate(e, t, n, r, i, a, o) {
-		throw new C();
+		throw x("getSerialDate");
 	}
 	getNow() {
-		throw new C();
+		throw x("getNow");
 	}
 	getRandom() {
 		return Math.random();
@@ -406,10 +439,10 @@ var v = class {
 		return null;
 	}
 	getEntireCoords() {
-		return w;
+		return T;
 	}
 	isValidDate(e, t) {
-		return e instanceof Date || Object.prototype.toString.call(e) === "[object Date]" ? !isNaN(e.getTime()) : !t && typeof e == "number" && !(e < 0 || e > E);
+		return e instanceof Date || Object.prototype.toString.call(e) === "[object Date]" ? !isNaN(e.getTime()) : !t && typeof e == "number" && !(e < 0 || e > D);
 	}
 	getRow() {
 		return 0;
@@ -445,22 +478,22 @@ var v = class {
 		return null;
 	}
 	getAddress(e, t) {
-		throw new C();
+		throw x("getAddress");
 	}
 	parseAsSerialDate(e, t) {
-		throw new C();
+		throw x("parseAsSerialDate");
 	}
 	parseAsDate(e, t) {
-		throw new C();
+		throw x("parseAsDate");
 	}
 	parseAsNumber(e, t) {
-		throw new C();
+		throw x("parseAsNumber");
 	}
 	createCriteria(e, t) {
-		throw new C();
+		throw x("createCriteria");
 	}
 	createGrouping(e, t) {
-		throw new C();
+		throw x("createGrouping");
 	}
 	parseAsLiteral(e) {
 		let t = e.toUpperCase();
@@ -475,13 +508,13 @@ var v = class {
 		return r === i ? e < t ? -1 : +(e > t) : r < i ? -1 : 1;
 	}
 	getRuntime() {
-		return T;
+		return E;
 	}
 	getArgs() {
-		throw new C(x);
+		throw new w(S);
 	}
 	createRichData(e, t) {
-		throw new C(S);
+		throw new w(C);
 	}
 }, b = (e) => {
 	if (e == null) return 0;
@@ -491,19 +524,19 @@ var v = class {
 		case "boolean": return 3;
 		default: return 4;
 	}
-}, x = "FormulaContext.getArgs() is only valid while a function body is running", S = "FormulaContext.createRichData() needs a workbook being calculated", C = class extends Error {
+}, x = (e) => new w(`FormulaContext.${e}() is only valid while a function body is running. A deferred executor reads its workbook through ctx.getFormulaContext().`), S = "FormulaContext.getArgs() is only valid while a function body is running", C = "FormulaContext.createRichData() needs a workbook being calculated", w = class extends Error {
 	constructor(e = "Not implemented in StubbedFormulaContext") {
 		super(e), this.name = "NotImplementedError";
 	}
-}, w = Object.freeze({
+}, T = Object.freeze({
 	colStart: 0,
 	rowStart: 0,
 	colEnd: 2 ** 14 - 1,
 	rowEnd: 2 ** 20 - 1
-}), T = {
+}), E = {
 	isDate1904: () => !1,
-	getLocale: () => k.tag,
-	getLocaleProfile: () => k,
+	getLocale: () => A.tag,
+	getLocaleProfile: () => A,
 	isR1C1: () => !1,
 	getNow: () => 0,
 	getRandom: () => Math.random(),
@@ -512,12 +545,12 @@ var v = class {
 	getOS: () => "unknown",
 	getUser: () => "unidentified",
 	getDescription: () => "Stubbed Formula Context"
-}, E = 2958465, D = new y(), O = class {
+}, D = 2958465, O = new y(), k = class {
 	constructor() {
-		this._scope = D, this._argsFn = null;
+		this._scope = O, this._argsFn = null;
 	}
 	_setScope(e) {
-		this._scope = e ?? D;
+		this._scope = e ?? O;
 	}
 	_getScope() {
 		return this._scope;
@@ -529,7 +562,7 @@ var v = class {
 		return this._getScope().getNumberFormat(e, t);
 	}
 	getEntireCoords() {
-		return this._getScope().getEntireCoords() ?? w;
+		return this._getScope().getEntireCoords() ?? T;
 	}
 	parseAsSerialDate(e, t) {
 		return this._getScope().parseAsSerialDate(e, t);
@@ -548,7 +581,7 @@ var v = class {
 	}
 	parseAsLiteral(e) {
 		let t = this._getScope();
-		return t.parseAsLiteral ? t.parseAsLiteral(e) : D.parseAsLiteral(e);
+		return t.parseAsLiteral ? t.parseAsLiteral(e) : O.parseAsLiteral(e);
 	}
 	toText(e) {
 		return this._getScope().toText(e);
@@ -638,18 +671,18 @@ var v = class {
 		return this._getScope().getAddress(e, t);
 	}
 	compare(e, t, n) {
-		return this._getScope().compare?.(e, t, n) ?? D.compare(e, t, n);
+		return this._getScope().compare?.(e, t, n) ?? O.compare(e, t, n);
 	}
 	getRuntime() {
 		return this._getScope().getRuntime();
 	}
 	createRichData(e, t) {
 		let n = this._getScope();
-		return n.createRichData ? n.createRichData(e, t) : D.createRichData(e, t);
+		return n.createRichData ? n.createRichData(e, t) : O.createRichData(e, t);
 	}
 	getArgs() {
 		let e = this._argsFn, t = e ? e() : null;
-		if (!t) throw new C(x);
+		if (!t) throw new w(S);
 		return t;
 	}
 	get [Symbol.toStringTag]() {
@@ -658,7 +691,7 @@ var v = class {
 	toString() {
 		return this._getScope()?.toString?.() ?? "{STUB SCOPE}";
 	}
-}, k = Object.freeze({
+}, A = Object.freeze({
 	tag: "en-US",
 	numberingSystem: "latn",
 	decimal: ".",
@@ -738,5 +771,5 @@ var v = class {
 		sensitivity: "base",
 		numeric: !0
 	})
-}), A = new O();
-export { k as DEFAULT_LOCALE_PROFILE, A as FormulaContext, i as FormulaError, t as IRange, r as IRangeStats, o as InteropScalarType, v as Observable, e as Scalar, a as ScalarType, O as ScopedFormulaContext, y as StubbedFormulaContext, s as ValueKind, u as WildCard, d as isLazyValue };
+}), j = new k();
+export { A as DEFAULT_LOCALE_PROFILE, j as FormulaContext, i as FormulaError, t as IRange, r as IRangeStats, o as InteropScalarType, v as Observable, e as Scalar, a as ScalarType, k as ScopedFormulaContext, y as StubbedFormulaContext, s as ValueKind, u as WildCard, d as isLazyValue };

package/node/esm/index.mjs

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/primitives - Primitives - Base types for SheetXL functions. - v0.8.0-beta.12
+* @license @sheetxl/primitives - Primitives - Base types for SheetXL functions. - v0.8.0-beta.14
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.
@@ -21,6 +21,41 @@ var e;
 		}
 		return null === n ? e : n.join("");
 	};
+	const r = e.MIN_NUMBER = 22250738585072014e-324;
+	e.flushSubnormal = function(e) {
+		return e > -r && e < r ? 0 : e;
+	}, e.isNumberTextInRange = function(e, t = ".") {
+		const r = e.length;
+		if (r < 309 && e.indexOf("E") < 0 && e.indexOf("e") < 0) return !0;
+		const o = t.charCodeAt(0);
+		let n = !1, s = !1, a = !1, i = 0, c = 0, u = 0, l = 0;
+		for (; l < r; l++) {
+			const t = e.charCodeAt(l);
+			if (t >= 48 && t <= 57) n = !0, s ? (u++, a || (48 === t ? c++ : a = !0)) : (a || 48 !== t) && (a = !0, i++);
+			else if (t === o) s = !0;
+			else if ((69 === t || 101 === t) && n) break;
+		}
+		let d = 0;
+		if (l < r) {
+			let t = l + 1, o = !1;
+			const n = e.charCodeAt(t);
+			45 === n ? (o = !0, t++) : 43 === n && t++;
+			let s = 0;
+			for (; t < r; t++) {
+				const r = e.charCodeAt(t);
+				if (r < 48 || r > 57) break;
+				d = 10 * d + (r - 48), s++;
+			}
+			if (0 === s) return !0;
+			o && (d = -d);
+		}
+		if (a) {
+			const e = (i > 0 ? i - 1 : -(c + 1)) + d;
+			return e >= -309 && e <= 307;
+		}
+		const g = d - u;
+		return g >= -308 && g <= 308;
+	};
 })(e || (e = {}));
 var t, r, o, n, s = {
 	Number: "number",
@@ -270,7 +305,7 @@ var t, r, o, n, s = {
 		}
 	}
 	e.Unknown = C;
-	class w extends o {
+	class f extends o {
 		constructor(e, o) {
 			super(t.Field, r.Field, e, o);
 		}
@@ -278,8 +313,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Field;
 		}
 	}
-	e.Field = w;
-	class f extends o {
+	e.Field = f;
+	class b extends o {
 		constructor(e, o) {
 			super(t.Calc, r.Calc, e, o);
 		}
@@ -287,8 +322,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Calc;
 		}
 	}
-	e.Calc = f;
-	class y extends o {
+	e.Calc = b;
+	class A extends o {
 		constructor(e, o) {
 			super(t.Busy, r.Busy, e, o);
 		}
@@ -296,7 +331,7 @@ var t, r, o, n, s = {
 			this.code = n.Code.Busy;
 		}
 	}
-	e.Busy = y;
+	e.Busy = A;
 	class N extends o {
 		constructor(e, o) {
 			super(t.Python, r.Python, e, o);
@@ -306,7 +341,7 @@ var t, r, o, n, s = {
 		}
 	}
 	e.Python = N;
-	class b extends o {
+	class D extends o {
 		constructor(e, o) {
 			super(t.Timeout, r.Timeout, e, o);
 		}
@@ -314,7 +349,7 @@ var t, r, o, n, s = {
 			this.code = n.Code.Timeout;
 		}
 	}
-	e.Timeout = b;
+	e.Timeout = D;
 }(n || (n = {}));
 var g = {};
 g[n.Code.Parse] = n.Parse, g[n.Code.Null] = n.Null, g[n.Code.Div0] = n.Div0, g[n.Code.Value] = n.Value, g[n.Code.Ref] = n.Ref, g[n.Code.Name] = n.Name, g[n.Code.Num] = n.Num, g[n.Code.NA] = n.NA, g[n.Code.GettingData] = n.GettingData, g[n.Code.Spill] = n.Spill, g[n.Code.Connect] = n.Connect, g[n.Code.Blocked] = n.Blocked, g[n.Code.Unknown] = n.Unknown, g[n.Code.Field] = n.Field, g[n.Code.Calc] = n.Calc, g[n.Code.Busy] = n.Busy, g[n.Code.Python] = n.Python, g[n.Code.Timeout] = n.Timeout;
@@ -351,7 +386,7 @@ for (let e = 0; e < C.length; e++) {
 		return !!e && !0 === e.isFormulaError && (void 0 === t || e.getCode() === t);
 	};
 })(n || (n = {}));
-var w = class {
+var f = class {
 	constructor(e) {
 		this._subscribeFn = e;
 	}
@@ -371,36 +406,36 @@ var w = class {
 			"function" == typeof n && n();
 		}, o;
 	}
-}, f = class {
+}, b = class {
 	createRange(e, t, r) {
-		throw new D();
+		throw N("createRange");
 	}
 	flattenAreas(e) {
-		throw new D();
+		throw N("flattenAreas");
 	}
 	getReference(e, t) {
-		throw new D();
+		throw N("getReference");
 	}
 	getResizedReference(e, t, r) {
-		throw new D();
+		throw N("getResizedReference");
 	}
 	getNumberFormat(e, t) {
-		throw new D();
+		throw N("getNumberFormat");
 	}
 	fromSerialDate(e, t) {
-		throw new D();
+		throw N("fromSerialDate");
 	}
 	toSerialDate(e, t) {
-		throw new D();
+		throw N("toSerialDate");
 	}
 	getDateParts(e, t) {
-		throw new D();
+		throw N("getDateParts");
 	}
 	getSerialDate(e, t, r, o, n, s, a) {
-		throw new D();
+		throw N("getSerialDate");
 	}
 	getNow() {
-		throw new D();
+		throw N("getNow");
 	}
 	getRandom() {
 		return Math.random();
@@ -409,10 +444,10 @@ var w = class {
 		return null;
 	}
 	getEntireCoords() {
-		return A;
+		return _;
 	}
 	isValidDate(e, t) {
-		return e instanceof Date || "[object Date]" === Object.prototype.toString.call(e) ? !isNaN(e.getTime()) : !t && "number" == typeof e && !(e < 0 || e > R);
+		return e instanceof Date || "[object Date]" === Object.prototype.toString.call(e) ? !isNaN(e.getTime()) : !t && "number" == typeof e && !(e < 0 || e > x);
 	}
 	getRow() {
 		return 0;
@@ -448,22 +483,22 @@ var w = class {
 		return null;
 	}
 	getAddress(e, t) {
-		throw new D();
+		throw N("getAddress");
 	}
 	parseAsSerialDate(e, t) {
-		throw new D();
+		throw N("parseAsSerialDate");
 	}
 	parseAsDate(e, t) {
-		throw new D();
+		throw N("parseAsDate");
 	}
 	parseAsNumber(e, t) {
-		throw new D();
+		throw N("parseAsNumber");
 	}
 	createCriteria(e, t) {
-		throw new D();
+		throw N("createCriteria");
 	}
 	createGrouping(e, t) {
-		throw new D();
+		throw N("createGrouping");
 	}
 	parseAsLiteral(e) {
 		const t = e.toUpperCase();
@@ -474,19 +509,19 @@ var w = class {
 	}
 	compare(e, t, r) {
 		if (e === t) return 0;
-		const o = y(e), n = y(t);
+		const o = A(e), n = A(t);
 		return o !== n ? o < n ? -1 : 1 : e < t ? -1 : e > t ? 1 : 0;
 	}
 	getRuntime() {
-		return _;
+		return R;
 	}
 	getArgs() {
-		throw new D(N);
+		throw new w(D);
 	}
 	createRichData(e, t) {
-		throw new D(b);
+		throw new w(y);
 	}
-}, y = (e) => {
+}, A = (e) => {
 	if (null == e) return 0;
 	switch (typeof e) {
 		case "number": return 1;
@@ -494,19 +529,19 @@ var w = class {
 		case "boolean": return 3;
 		default: return 4;
 	}
-}, N = "FormulaContext.getArgs() is only valid while a function body is running", b = "FormulaContext.createRichData() needs a workbook being calculated", D = class extends Error {
+}, N = (e) => new w(`FormulaContext.${e}() is only valid while a function body is running. A deferred executor reads its workbook through ctx.getFormulaContext().`), D = "FormulaContext.getArgs() is only valid while a function body is running", y = "FormulaContext.createRichData() needs a workbook being calculated", w = class extends Error {
 	constructor(e = "Not implemented in StubbedFormulaContext") {
 		super(e), this.name = "NotImplementedError";
 	}
-}, A = Object.freeze({
+}, _ = Object.freeze({
 	colStart: 0,
 	rowStart: 0,
 	colEnd: Math.pow(2, 14) - 1,
 	rowEnd: Math.pow(2, 20) - 1
-}), _ = {
+}), R = {
 	isDate1904: () => !1,
-	getLocale: () => T.tag,
-	getLocaleProfile: () => T,
+	getLocale: () => k.tag,
+	getLocaleProfile: () => k,
 	isR1C1: () => !1,
 	getNow: () => 0,
 	getRandom: () => Math.random(),
@@ -515,12 +550,12 @@ var w = class {
 	getOS: () => "unknown",
 	getUser: () => "unidentified",
 	getDescription: () => "Stubbed Formula Context"
-}, R = 2958465, x = new f(), F = class {
+}, x = 2958465, F = new b(), T = class {
 	constructor() {
-		this._scope = x, this._argsFn = null;
+		this._scope = F, this._argsFn = null;
 	}
 	_setScope(e) {
-		this._scope = e ?? x;
+		this._scope = e ?? F;
 	}
 	_getScope() {
 		return this._scope;
@@ -532,7 +567,7 @@ var w = class {
 		return this._getScope().getNumberFormat(e, t);
 	}
 	getEntireCoords() {
-		return this._getScope().getEntireCoords() ?? A;
+		return this._getScope().getEntireCoords() ?? _;
 	}
 	parseAsSerialDate(e, t) {
 		return this._getScope().parseAsSerialDate(e, t);
@@ -551,7 +586,7 @@ var w = class {
 	}
 	parseAsLiteral(e) {
 		const t = this._getScope();
-		return t.parseAsLiteral ? t.parseAsLiteral(e) : x.parseAsLiteral(e);
+		return t.parseAsLiteral ? t.parseAsLiteral(e) : F.parseAsLiteral(e);
 	}
 	toText(e) {
 		return this._getScope().toText(e);
@@ -641,18 +676,18 @@ var w = class {
 		return this._getScope().getAddress(e, t);
 	}
 	compare(e, t, r) {
-		return this._getScope().compare?.(e, t, r) ?? x.compare(e, t, r);
+		return this._getScope().compare?.(e, t, r) ?? F.compare(e, t, r);
 	}
 	getRuntime() {
 		return this._getScope().getRuntime();
 	}
 	createRichData(e, t) {
 		const r = this._getScope();
-		return r.createRichData ? r.createRichData(e, t) : x.createRichData(e, t);
+		return r.createRichData ? r.createRichData(e, t) : F.createRichData(e, t);
 	}
 	getArgs() {
 		const e = this._argsFn, t = e ? e() : null;
-		if (!t) throw new D(N);
+		if (!t) throw new w(D);
 		return t;
 	}
 	get [Symbol.toStringTag]() {
@@ -661,7 +696,7 @@ var w = class {
 	toString() {
 		return this._getScope()?.toString?.() ?? "{STUB SCOPE}";
 	}
-}, T = Object.freeze({
+}, k = Object.freeze({
 	tag: "en-US",
 	numberingSystem: "latn",
 	decimal: ".",
@@ -741,5 +776,5 @@ var w = class {
 		sensitivity: "base",
 		numeric: !0
 	})
-}), P = new F();
-export { T as DEFAULT_LOCALE_PROFILE, P as FormulaContext, n as FormulaError, t as IRange, o as IRangeStats, a as InteropScalarType, w as Observable, e as Scalar, s as ScalarType, F as ScopedFormulaContext, f as StubbedFormulaContext, i as ValueKind, l as WildCard, d as isLazyValue };
+}), P = new T();
+export { k as DEFAULT_LOCALE_PROFILE, P as FormulaContext, n as FormulaError, t as IRange, o as IRangeStats, a as InteropScalarType, f as Observable, e as Scalar, s as ScalarType, T as ScopedFormulaContext, b as StubbedFormulaContext, i as ValueKind, l as WildCard, d as isLazyValue };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sheetxl/primitives",
   "description": "Primitives - Base types for SheetXL functions.",
-  "version": "0.8.0-beta.12",
+  "version": "0.8.0-beta.14",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {

package/types/src/ErrorPolicy.d.ts

@@ -24,11 +24,11 @@
  * if (range.hasError()) return range.firstError();
  * ```
  *
- * placed before its own validation where Excel's error outranks it (`LARGE(range-with-#N/A, 0)`
+ * placed before its own validation where the member's error outranks it (`LARGE(range-with-#N/A, 0)`
  * is `#N/A`, not `#NUM!`). Aggregators and consumers say it; reshapers and lookups, whose members
  * pass through or are never read, need no line at all. Where a function takes several ranges the
  * lines run in ARGUMENT order — the whole of argument N before N+1, row-major within — which is
- * Excel's which-error-wins order, and a function that pairs its ranges (the paired
+ * the which-error-wins order, and a function that pairs its ranges (the paired
  * statistics) orders its own scan the way it pairs.
  *
  * > *A bare error propagates unless your function opts in to seeing it; the members of a range

package/types/src/Flatten.d.ts

@@ -19,8 +19,8 @@
  * Both are the same mechanism at different granularity — the marshaller picks the unit from the
  * element type — and a blank drops out of either. The scalar case is the common one; the range case
  * exists because a reference UNION is a single argument holding several areas: a parameter that does
- * not declare `Flatten` refuses one outright (`#VALUE!` — `TRANSPOSE((A1:A3,C1:C3))` in Excel), and a
- * body that declares it answers for the union itself, in one line, the way Excel's own do:
+ * not declare `Flatten` refuses one outright (`#VALUE!` — `TRANSPOSE((A1:A3,C1:C3))`), and a
+ * body that declares it answers for the union itself, in one line, the way the built-ins do:
  * `AREAS` counts the areas, `SUM` adds them, `ROWS` answers `#REF!` to more than one, the lookups
  * `#N/A`.
  *

package/types/src/FormulaContext.d.ts

@@ -97,7 +97,7 @@ export declare class StubbedFormulaContext implements IFormulaContext {
      * Unimplemented. See {@link IFormulaContext.createGrouping}.
      *
      * @remarks
-     * Grouping needs Excel's key equality, which this stub does not have.
+     * Grouping needs the engine's key equality, which this stub does not have.
      */
     createGrouping(keys: IRange, options?: IFormulaContext.GroupingOptions): IFormulaContext.Grouping;
     /**
@@ -115,15 +115,15 @@ export declare class StubbedFormulaContext implements IFormulaContext {
      * Renders a scalar as text. See {@link IFormulaContext.toText}.
      *
      * @remarks
-     * A BASIC rendering, deliberately NOT Excel's. Excel's rule -- coercion General (15
+     * A BASIC rendering, deliberately NOT the engine's. The engine's rule -- coercion General (15
      * significant digits, plain decimal while the rendering fits 20 characters, else
      * scientific) written with the workbook LOCALE's decimal separator -- is
      * `formatNumberGeneral` in `@sheetxl/sdk`, and every evaluation path reaches it through
      * the calculation context rather than through this stub. Numbers here get the plain JS
-     * rendering, which diverges from Excel on both precision and separator.
+     * rendering, which diverges from the engine on both precision and separator.
      *
      * This exists so authoring, type defs and other non-runtime access get usable text
-     * instead of throwing. Anything that needs Excel parity is running in the engine, and
+     * instead of throwing. Anything that needs the full rule is running in the engine, and
      * the engine never lands here.
      */
     toText(value: Scalar | undefined): string;
@@ -131,14 +131,14 @@ export declare class StubbedFormulaContext implements IFormulaContext {
      * Orders two scalars. See {@link IFormulaContext.compare}.
      *
      * @remarks
-     * A BASIC total order, deliberately NOT Excel's. Excel's rule -- locale collation, the word
+     * A BASIC total order, deliberately NOT the engine's. The engine's rule -- locale collation, the word
      * sort, a blank taking the other operand's type, 11-decimal numeric normalization -- is
      * `ScalarCollation` in `@sheetxl/sdk`, and every evaluation path reaches it through the
      * calculation context rather than through this stub. `options` is ignored: strength is a
      * collation concept and nothing here collates.
      *
      * This exists so authoring, type defs and other non-runtime access get a usable ordering
-     * instead of throwing. Anything that needs Excel parity is running in the engine, and the
+     * instead of throwing. Anything that needs the full rule is running in the engine, and the
      * engine never lands here.
      */
     compare(a: Scalar, b: Scalar, options?: Intl.CollatorOptions): number;

package/types/src/FormulaError.d.ts

@@ -20,7 +20,7 @@ import { IReferenceRange } from './IReferenceRange';
  *
  *  SpillErrorScalarSubType | "Unknown" | "Collision" | "IndeterminateSize" | "WorksheetEdge" | "OutOfMemoryWhileCalc" | "Table" | "MergedCell"
  * # Office 2023
- * 10. #CONNECT! This occurs when a data type is used that is not currently supported in this version of Excel.
+ * 10. #CONNECT! This occurs when a data type is used that is not currently supported.
  * 11. #BLOCKED! Indicates that an action or feature is blocked, possibly due to security settings, protected view, or other restrictions. Often related to online features, external links, or macros.
  * 12. #UNKNOWN! May be returned in the case of a protected workbook.
  * 13. #FIELD! Invalid field name for a data type.

package/types/src/IFormulaContext.d.ts

@@ -67,8 +67,8 @@ export interface IFormulaContext {
      * A union `(A1:A5,B1:B2)` reaches a {@link IFunction.ParameterTypeJSON.reportType} slot as one
      * `IRange` per area. Functions that answer over it do so because they walk MEMBERS and a union
      * simply has more of them — `LARGE((DA1:DA5,DK1:DK2),2)` is the second largest of all seven
-     * cells. This is that walk, and it is a helper rather than a marshalling step on purpose: Excel
-     * flattens in exactly the same place, a shared reducer its bodies opt into, which is why the
+     * cells. This is that walk, and it is a helper rather than a marshalling step on purpose:
+     * flattening is a shared reducer the bodies opt into, which is why the
      * same union is flattened by `LARGE`, refused by `SUMPRODUCT` and answered `#REF!` by `ROWS`.
      *
      * The result is a single column in area order, row-major within each area. SHAPE IS NOT
@@ -117,7 +117,7 @@ export interface IFormulaContext {
      */
     getColumn(): number;
     /**
-     * Whether the call being evaluated is in Excel's VALUE mode, where a multi-cell reference at a
+     * Whether the call being evaluated is in VALUE mode, where a multi-cell reference at a
      * slot that reads ONE value is implicitly intersected with the formula's cell (the `@` rule);
      * `false` is ARRAY mode, where such a slot reads the reference's first cell.
      *
@@ -156,7 +156,7 @@ export interface IFormulaContext {
      * A few arguments honor only their top-left corner and are re-sized to the shape of the range
      * that drives them — `SUMIF`'s `sum_range`, `LOOKUP`'s `result_vector`. The window can therefore
      * run off the bottom or right of the grid: `SUMIF(A1:A5,">0",A1048574)` asks for five rows
-     * starting three from the end. Excel reads the part that fits and treats the rest as blank, which
+     * starting three from the end. The part that fits is read and the rest is blank, which
      * is what this returns; positions past the clamp read as `undefined` from `getValueAt`.
      *
      * @param anchor The coords of the argument as written; only its top-left corner is honored.
@@ -560,12 +560,11 @@ export interface IFormulaContext {
      *   want the raw carry above — `DATEDIF("2020-01-31","2020-03-01","md")` is `-1`
      *   because Jan 31 rolls into March. `EDATE`/`EOMONTH` want the opposite and CLAMP to
      *   the target month's length, so they pre-clamp before calling here. One conversion,
-     *   two opposite rules, both matching Excel. Baking either one in breaks the other.
+     *   two opposite rules. Baking either one in breaks the other.
      * * **Results may legitimately leave the calendar.** `YEARFRAC` basis 1 anchors a year
      *   length on January 1 of `laterYear + 1`, which at the top of the calendar is
-     *   `10000-01-01`; Excel answers `1.9972602739726026` for
-     *   `YEARFRAC(DATE(9998,1,1),DATE(9999,12,31),1)` rather than `#NUM!`. A range check
-     *   here would break it.
+     *   `10000-01-01`; `YEARFRAC(DATE(9998,1,1),DATE(9999,12,31),1)` is
+     *   `1.9972602739726026`, not `#NUM!`. A range check here would break it.
      * * **The 16-bit argument limits are per-function.** `DATE`'s month errors outside
      *   `[-32767, 32766]` while its day saturates to `32767`, and `TIME` errors outside
      *   `[0, 32767]` on every argument — same magic number, three different rules.
@@ -573,8 +572,8 @@ export interface IFormulaContext {
      * Note the asymmetry with {@link getDateParts}, which DOES throw `#NUM!` outside the
      * calendar because it answers a user-facing question. An internal intermediate that
      * steps one day past the end must therefore not be round-tripped through it; compute
-     * on the fields instead. That mistake made `YEARFRAC(DATE(9999,1,1),DATE(9999,12,31),0)`
-     * `#NUM!` where Excel says `1`.
+     * on the fields instead, or `YEARFRAC(DATE(9999,1,1),DATE(9999,12,31),0)` becomes `#NUM!`
+     * rather than `1`.
      */
     getSerialDate(year: number, month: number, day: number, hour?: number, minute?: number, second?: number, millis?: number): number;
     /**
@@ -590,8 +589,8 @@ export interface IFormulaContext {
      *
      * @remarks
      * Argument REFLECTION, for the one thing a declaration cannot say: what happened at *this* call.
-     * It exists to serve Excel's declared `any`, which means "no contract, the body decides" — every
-     * other Excel type maps onto a type we already have and the marshaller handles it.
+     * It exists to serve a declared `any`, which means "no contract, the body decides" — every
+     * other declared type maps onto a type we already have and the marshaller handles it.
      *
      * The returned view is valid ONLY while the body that asked for it is running. Views are pooled
      * by dispatch depth, so retaining one across an `await`, a callback, or a nested evaluation hands
@@ -610,7 +609,7 @@ export interface IFormulaContext {
      * recognizes it: while the call is still waiting, a recalculation with
      * an equal payload leaves it be rather than asking again. Once it has stopped, a recalculation
      * calls the function again; what it fetched is answered from the workbook's cache
-     * (`IBatchContext.fetch`).
+     * (`IDeferContext.fetch`).
      * @returns The last answer this call gave for the same question, when the function is being
      * called again (a recalculation); `undefined` on a first call or a changed question. Return it
      * to keep showing it until the new answer arrives, or return something else to show that the
@@ -622,14 +621,15 @@ export interface IFormulaContext {
      * from meanwhile: return `#BUSY!` when they should wait as an error, or text such as
      * `'Fetching…'` when that is what they should show.
      *
-     * The executor runs after the recalculation, outside any cell; read nothing from the formula
-     * context there. Whatever the body knows goes in the payload.
+     * The executor runs after the recalculation, outside any cell, so the ambient `FormulaContext`
+     * is not its own: it reads the workbook through `ctx.getFormulaContext()`. Whatever the body
+     * knows about its cell goes in the payload.
      *
      * @example
      * ```typescript
      * function fetchAll(
      *   calls: readonly IFormulaContext.DeferredCall<string>[],
-     *   ctx: IFormulaContext.IBatchContext
+     *   ctx: IFormulaContext.IDeferContext
      * ): void {
      *   for (const call of calls) {
      *     ctx.fetch(call.payload as string)
@@ -683,7 +683,7 @@ export declare namespace IFormulaContext {
          * then `range` is returned as it is, hidden rows included.
          *
          * @remarks
-         * This is `SUBTOTAL` 1-11 (Excel: they "include manually hidden rows", which is what an
+         * This is `SUBTOTAL` 1-11 (they include manually hidden rows, which is what an
          * unfiltered sheet reads as). `SUBTOTAL` 101-111 and `AGGREGATE` leave it off and skip
          * always.
          * @defaultValue false
@@ -812,7 +812,7 @@ export declare namespace IFormulaContext {
      * Answers the calls made by {@link IFormulaContext.defer} against it. Invoked once at the end of
      * a recalculation with every such call; how many requests that becomes is the executor's choice.
      */
-    type DeferExecutor<T = any> = (calls: readonly DeferredCall<T>[], ctx: IBatchContext) => void | Promise<void>;
+    type DeferExecutor<T = any> = (calls: readonly DeferredCall<T>[], ctx: IDeferContext) => void | Promise<void>;
     /**
      * One call made by {@link IFormulaContext.defer}, as its executor receives it.
      *
@@ -824,7 +824,7 @@ export declare namespace IFormulaContext {
         /** What the function passed to `defer`. */
         readonly payload: unknown;
         /** Settles the call with its result. */
-        resolve(value: T): void;
+        resolve(value: T, options?: DeferredCall.ResolveOptions): void;
         /** Settles the call with an error: a `FormulaError` as itself, anything else as `#VALUE!`. */
         reject(error: unknown): void;
         /** Runs `fn` when the result is no longer wanted. */
@@ -835,10 +835,29 @@ export declare namespace IFormulaContext {
          */
         readonly cancelled: boolean;
     }
+    namespace DeferredCall {
+        /**
+         * Options for {@link DeferredCall.resolve}.
+         */
+        interface ResolveOptions {
+            /**
+             * Whether the blanks of an array result stay blank when it spills. Omitted, they read as
+             * `0`, as any spilled array's blanks do.
+             *
+             * @remarks
+             * For data whose empty fields mean "nothing here", such as an imported file. The result
+             * keeps them while a formula passes it on as it is (`IF(c, result, …)`). A function that
+             * answers element by element builds a new array, whose blanks read as `0`
+             * (`IFERROR(result, …)`, `result & ""`).
+             * @defaultValue false
+             */
+            keepBlanks?: boolean;
+        }
+    }
     /**
      * What an executor is given beside its calls.
      */
-    interface IBatchContext {
+    interface IDeferContext {
         /** A random number in `[0, 1)` from the calculation's source, which a test can seed. */
         getRandom(): number;
         /**
@@ -846,6 +865,35 @@ export declare namespace IFormulaContext {
          * here (maps, numbers, strings, buffers), not connections or sockets.
          */
         getState<S>(init: () => S): S;
+        /**
+         * Groups `calls` by payload and runs `answer` once per distinct payload with every call that
+         * asked it: one request per question, however many cells asked.
+         *
+         * @param calls The calls to group, usually every call the executor was handed.
+         * @param answer Settles one group. When it throws, or the promise it returns rejects, the
+         * group's calls it has not settled fail with that error; the other groups are not affected.
+         * @returns Resolves once every group has been answered. It never rejects.
+         *
+         * @remarks
+         * Payloads are equal as `defer` compares them: the same primitive, or plain objects or arrays
+         * whose own values are the same one level deep. Groups are answered concurrently, in the
+         * order their first call appears.
+         *
+         * @example
+         * ```typescript
+         * async function fetchQuotes(
+         *   calls: readonly IFormulaContext.DeferredCall<number>[],
+         *   ctx: IFormulaContext.IDeferContext
+         * ): Promise<void> {
+         *   await ctx.byPayload(calls, async (ticker: string, group) => {
+         *     const response = await ctx.fetch(`https://api.example.com/quote/${ticker}`);
+         *     const price: number = (await response.json()).price;
+         *     for (const call of group) call.resolve(price);
+         *   });
+         * }
+         * ```
+         */
+        byPayload<T = any, P = unknown>(calls: readonly DeferredCall<T>[], answer: (payload: P, group: readonly DeferredCall<T>[]) => void | Promise<void>): Promise<void>;
         /**
          * A rich value of a registered type, for the workbook being calculated: what
          * {@link IFormulaContext.createRichData} makes inside a cell, made here for a call's result.
@@ -866,8 +914,44 @@ export declare namespace IFormulaContext {
          * answer the workbook already has for the URL (a picture it keeps, or anything fetched while
          * it is open) answers from the workbook, and two calls for one URL share one request. In an
          * external calculation (*Refresh All*) it goes to the source.
+         *
+         * Rejects when the URL cannot be reached, with a `FormulaError.Blocked` when the site responded
+         * but the browser would not let the page read it.
          */
         fetch(input: string, init?: RequestInit): Promise<Response>;
+        /**
+         * The formula context of the workbook being calculated, with no cell: its parsing, text,
+         * comparison and dates, read with the workbook's locale and date system.
+         *
+         * @remarks
+         * Valid for as long as the executor runs, across every `await`. The ambient `FormulaContext`
+         * is not: it belongs to the cell being evaluated, and an executor runs after that evaluation
+         * ends. What needs a cell (`getRow`, `getReference`, `getValueAt`, `defer`, `markVolatile`,
+         * `formatResults`, `getRandom`) throws here; {@link getRandom} is the executor's own.
+         */
+        getFormulaContext(): IFormulaContext;
+        /**
+         * Reads delimited text (CSV, TSV) into rows of values, each field read the way the workbook
+         * reads typed entry: numbers, dates, booleans and error labels become values, anything else
+         * stays text, and an empty field is blank.
+         *
+         * @param text The delimited text.
+         * @param options How the text is split.
+         * @returns The rows, padded with blanks to the widest row.
+         */
+        parseText(text: string, options?: IDeferContext.ParseTextOptions): Promise<Scalar[][]>;
+    }
+    namespace IDeferContext {
+        /**
+         * Options for {@link IDeferContext.parseText}.
+         */
+        interface ParseTextOptions {
+            /**
+             * The character between fields.
+             * @defaultValue `','`
+             */
+            delimiter?: string;
+        }
     }
 }
 //# sourceMappingURL=IFormulaContext.d.ts.map

package/types/src/IFunction.d.ts

@@ -304,7 +304,7 @@ export declare namespace IFunction {
          *
          * @remarks
          * STATIC, and read from the formula text at compile time: it is true of the call whether or
-         * not the call runs, which is what a lazy argument (and Excel) requires.
+         * not the call runs, which is what a lazy argument requires.
          *
          * @see {@link ReturnTypeJSON.volatile}
          */
@@ -343,7 +343,7 @@ export declare namespace IFunction {
          * @remarks
          * Only meaningful for a VARIADIC function; a fixed parameter list is already its own maximum.
          * The number is the whole CALL's argument count, prefix and optional suffix included, and it
-         * is refused where Excel refuses it — at entry, before evaluation.
+         * is refused at entry, before evaluation.
          *
          * @see {@link Repeating}
          */
@@ -645,8 +645,8 @@ export declare namespace IFunction {
          * Generated from the `NoLift<T>` marker.
          *
          * @remarks
-         * Per parameter, because Excel is: `NETWORKDAYS.INTL` refuses a reference at its date slots
-         * and lifts one at `weekend`. An ARRAY at the slot still lifts, a one-cell reference is an
+         * Per parameter, because Excel's built-ins differ by slot: `NETWORKDAYS.INTL` refuses a
+         * reference at its date slots and lifts one at `weekend`. An ARRAY at the slot still lifts, a one-cell reference is an
          * ordinary argument, and a repeating slot absorbs a container as members, so the marker only
          * ever applies to a non-repeating scalar parameter.
          */
@@ -686,7 +686,7 @@ export declare namespace IFunction {
          * union is the range arm, handed over whole. The slot never lifts.
          *
          * @remarks
-         * Excel reads a one-cell argument at some array slots as THE ARGUMENT rather than as a
+         * Some array slots read a one-cell argument as THE ARGUMENT rather than as a
          * one-cell container: `SORT(<#N/A cell>,1,1,<#DIV/0! cell>)` is `#N/A` where
          * `TAKE(<#N/A cell>,<#DIV/0! cell>)` is `#DIV/0!`. The engine's default
          * for a range slot is TAKE's; this flag is SORT's. {@link scalar} and {@link range} each carry
@@ -753,7 +753,7 @@ export declare namespace IFunction {
          *
          * @remarks
          * Collected at COMPILE time from the formula text (`CompiledFormula.hasVolatile`), because
-         * that is where Excel decides it: `=IF(TRUE,1,RAND())` recalculates on every idle pass though
+         * that is where volatility is decided: `=IF(TRUE,1,RAND())` recalculates on every idle pass though
          * no branch selects the arm, and with lazy arguments the call never happens for the engine to
          * observe.
          *
@@ -776,11 +776,10 @@ export declare namespace IFunction {
          * parameter. Omitted at the default of 255.
          *
          * @remarks
-         * Excel keeps one such number per NAME and compares it against the whole call's argument
-         * count in its front end, so a call past it is refused AT ENTRY rather than answered — which
-         * is why the cap lives on the declaration and not in a body. It is not derivable from the
-         * shape: `STDEV` takes 255 arguments and `STDEV.S`, the same function under its dotted name,
-         * takes 254.
+         * The cap is one number per NAME, compared against the whole call's argument count, so a call
+         * past it is refused AT ENTRY rather than answered — which is why the cap lives on the
+         * declaration and not in a body. It is not derivable from the shape: in Excel `STDEV` takes 255
+         * arguments and `STDEV.S`, the same function under its dotted name, takes 254.
          *
          * @defaultValue 255
          */

package/types/src/IFunctionArguments.d.ts

@@ -15,9 +15,8 @@ import { IFunction } from './IFunction';
  * - What was the value BEFORE the parameter's type coerced it?
  * - Was that empty slot an omission, or a blank cell the caller pointed at?
  *
- * Excel has behaviors that turn on exactly those questions, and they cluster at the
- * parameters Excel declares `any` — where there is nothing to express as a type, because Excel
- * declined to express one. `CUMIPMT` refuses a boolean at every slot while `FV` coerces one at
+ * Some functions have behaviors that turn on exactly those questions, and they cluster at
+ * parameters declared `any` — where there is nothing to express as a type. `CUMIPMT` refuses a boolean at every slot while `FV` coerces one at
  * every slot; the difference is not the values, it is that `CUMIPMT`'s slots are `any` and its
  * body decides.
  *
@@ -142,7 +141,7 @@ export interface IFunctionArguments {
      */
     getKindAt(index: number): ValueKind;
     /**
-     * True when the argument at `index` is DIRECT — Excel's "typed into the list of arguments":
+     * True when the argument at `index` is DIRECT — typed into the list of arguments:
      * the evaluated value IS a value, not a container or a callable.
      *
      * @param index The PARAMETER index — the position in the body's own signature.

package/types/src/IRange.d.ts

@@ -255,7 +255,7 @@ export interface IRange<T extends Scalar = Scalar> {
      * @remarks
      * Errors INSIDE a range are the body's to judge: the engine hands a valid range over whole and
      * never looks inside, so a function whose answer depends on every member says so with this
-     * line, placed before its own validation where Excel's error outranks it. A reshaper or a
+     * line, placed before its own validation where the member's error outranks it. A reshaper or a
      * lookup, whose members pass through or are never read, needs no line at all.
      */
     firstError(): FormulaError.Known | null;
@@ -268,7 +268,7 @@ export interface IRange<T extends Scalar = Scalar> {
      * @remarks
      * `options.axis` is the TRAVERSAL order feeding the ordinal, not the orientation of the result:
      * the result is always Nx1, and a row is `flatten().transpose()`. The default is row-major,
-     * which is the order Excel pairs two range operands in.
+     * which is the order two range operands pair in.
      *
      * `options.type` carries a read type onto the result, so a member the type filters out becomes
      * a HOLE at its ordinal rather than compacting the column. That is what lets two operands be
@@ -916,7 +916,7 @@ export declare namespace IRange {
          *
          * - By default, `broadcast()` follows strict alignment rules like NumPy and will
          *   throw an error if the input ranges cannot be broadcasted together.
-         * - When `misalignValue` is provided, `broadcast()` will instead mimic Excel behavior:
+         * - When `misalignValue` is provided, `broadcast()` will instead follow Excel's behavior:
          *   - It finds the **largest valid intersection** of the ranges.
          *   - It expands the result to the **union of both range sizes**.
          *   - Any cells that do not have valid corresponding values from the inputs
@@ -974,7 +974,7 @@ export declare namespace IRange {
          *
          * @remarks
          * Off, a dimension of 1 is a short dimension like any other and pads `misalignValue` past
-         * its one position: Excel's `MAP` rule, where a 1-row array is not stretched.
+         * its one position: the `MAP` rule, where a 1-row array is not stretched.
          */
         tile?: boolean;
         /**

package/types/src/IRangeStats.d.ts

@@ -71,7 +71,7 @@ export interface IRangeStats {
      */
     getAggregates(options?: IRange.IteratorOptions): Readonly<IRangeStats.Aggregates>;
     /**
-     * Returns the sum as Excel's `SUM` reports it — {@link getAggregates}'s `sum` with Excel's
+     * Returns the sum as `SUM` reports it — {@link getAggregates}'s `sum` with Excel's
      * cancellation-to-zero rule applied.
      *
      * @param total A total the caller accumulated across SEVERAL stats instances. Omit for a
@@ -82,7 +82,7 @@ export interface IRangeStats {
      * @remarks
      * Collapses a total to exactly zero when it lands at least 50 binary exponents below the
      * operands that produced it, so `SUM(0.1,0.2,-0.3)` is `0` rather than `5.55111512312578E-17`.
-     * Use this wherever you mean "the number Excel's SUM would show" — a status bar, a report
+     * Use this wherever you mean "the number SUM shows" — a status bar, a report
      * total, a formula. Use `getAggregates().sum` where you mean the true total of the data.
      *
      * The two genuinely differ, and neither is a rounding of the other:
@@ -92,12 +92,12 @@ export interface IRangeStats {
      *   and `PERCENTOF`, and to NOTHING else — `SUMIF`, `SUMPRODUCT`, `SERIESSUM`, `DSUM`, the
      *   `SUMX2MY2` family and every binary operator all keep the residue over the same values.
      *   That is why this is a method you call and not a change to `getAggregates`.
-     * - `AVERAGE` divides THIS, not the raw sum: snapping the mean instead is measurably wrong.
+     * - `AVERAGE` divides THIS, not the raw sum: snapping the mean instead is wrong.
      *
      * It is also cheap when it does not fire: a bound derived from `min`/`max` rejects any
      * ordinary total without re-reading the range.
      *
-     * **Multiple ranges.** Excel evaluates the rule on the *final* accumulation step, so a total
+     * **Multiple ranges.** The rule applies on the *final* accumulation step, so a total
      * spanning several ranges must be judged against the range holding the LAST value — pass the
      * running total as `total` and call this on that range. (Snapping each range separately gets
      * `SUM(A1:A3,0)` and `SUM(A1:A1,A2:A2,A3:A3)` wrong in opposite directions.) A composite
@@ -245,7 +245,7 @@ export declare namespace IRangeStats {
      * Sorting requires materializing the full numeric population (O(n log n), one allocation).
      * Unlike `Aggregates`, sorted views are **not composable across sub-ranges**.
      *
-     * Covers the following Excel functions (all share one sort per coords per calc cycle):
+     * Covers the following functions (all share one sort per coords per calc cycle):
      * - `LARGE`, `SMALL`
      * - `MEDIAN`, `PERCENTILE`, `PERCENTILE.INC`, `PERCENTILE.EXC`
      * - `QUARTILE`, `QUARTILE.INC`, `QUARTILE.EXC`  (q1 = k=0.25, q3 = k=0.75)
@@ -310,7 +310,7 @@ export declare namespace IRangeStats {
          * one outside the population is not found.
          * @param exclusive If true, uses exclusive formula (0 and 1 are excluded).
          * @param significance Number of DECIMAL PLACES to TRUNCATE the result to — despite what
-         * Excel's own help calls the argument, it is not significant digits and it does not round.
+         * Excel's help calls the argument, it is not significant digits and it does not round.
          * Truncated toward zero first (1.9 places means 1), and must be at least 1. Omit it for the
          * exact untruncated rank, which is also the only form that cannot fail.
          * @returns The percent rank of x; `null` if x is not found or there are no numbers in range.

package/types/src/Repeating.d.ts

@@ -46,12 +46,12 @@
  * omitted when there is a single repetition. `SORTBY`'s legal arities are 2 and 1+2n and nothing
  * else — `SORTBY(array, by1)` is legal, `SORTBY(array, by1, o1, by2)` is not. It is not a general
  * "the final element of the final group may be omitted" rule; that rule would accept a formula
- * Excel refuses. An optional slot anywhere else in the group is a compiler error.
+ * that must be refused. An optional slot anywhere else in the group is a compiler error.
  *
  * ### The maximum, `Max`
  *
- * The second type argument is the largest number of arguments the WHOLE CALL accepts, which is
- * how Excel states it: one number per NAME, compared against the call's total argument count and
+ * The second type argument is the largest number of arguments the WHOLE CALL accepts: one
+ * number per NAME, compared against the call's total argument count and
  * refused at entry (`Excess_function_arguments`), never a count of this parameter's own share.
  * `SWITCH`'s 254 therefore covers its `expression` and its trailing `default` as well as the
  * pairs, and `CHOOSEROWS`' covers its `array`.

package/types/src/ReportType.d.ts

@@ -27,8 +27,8 @@
  * what can arrive and {@link IFunctionArguments.getAreaCountAt} answers the union question the
  * kind cannot — a plain reference is one area, a union is more.
  *
- * Its use is meant to stay countable: a slot earns it with a rule Excel actually shows, never
- * with a guess.
+ * Its use is meant to stay countable: a slot earns it with a concrete behavior that needs it,
+ * never speculatively.
  *
  * @example
  * ```ts

package/types/src/Scalar.d.ts

@@ -31,8 +31,8 @@ export declare namespace Scalar {
      */
     const MAX_SIGNIFICANT_DIGITS = 15;
     /**
-     * Applies Excel's entry rule to numeric text: every significand digit past the
-     * 15th becomes `0`, so the text parses to the double Excel would store.
+     * Applies the 15-digit entry rule to numeric text: every significand digit past the
+     * 15th becomes `0`, so the text parses to the double a cell stores.
      *
      * @param text Numeric text in any accepted form — signed, grouped, percent,
      * currency-affixed, or scientific. The scan is locale-blind: only digit
@@ -46,6 +46,30 @@ export declare namespace Scalar {
      * truncation, not rounding: `1234567890.123456789` stores `…345`, never `…346`.
      */
     function truncateNumberText(text: string): string;
+    /**
+     * The smallest magnitude a stored number can have: the smallest normal double. A smaller one is
+     * stored as `0`.
+     */
+    const MIN_NUMBER = 2.2250738585072014e-308;
+    /**
+     * Applies the stored-number floor to a number entering a workbook — typed, parsed from text, written
+     * through the API or loaded from a file: a magnitude below {@link MIN_NUMBER} becomes `0`.
+     */
+    function flushSubnormal(value: number): number;
+    /**
+     * Whether numeric text is inside the range accepted as a number, judged from the text as
+     * written rather than the double it parses to.
+     *
+     * @param text Numeric text in any accepted form, as {@link truncateNumberText} takes it. Only
+     * digits, `decimal` and an exponent marker are read.
+     * @param decimal The decimal separator `text` is written with.
+     * @returns `false` when the leading significant digit sits outside `1E-309` … `1E+307`
+     * (`1E-310`, `0.00001E-305`, `1E+308`); for a zero mantissa, when its scale — exponent less
+     * fraction digits — is outside ±308 (`0E-309`, `0.0E-308` and `0E+309`, but not `0E-308`,
+     * `000E-308` or `0.0E+309`). Text out of range is not a number: a formula literal will not
+     * commit, `VALUE` is `#VALUE!` and typed entry stays text.
+     */
+    function isNumberTextInRange(text: string, decimal?: string): boolean;
     /**
      * Encodings of `ScalarType` for persistence.
      */

package/types/src/ValueKind.d.ts

@@ -4,7 +4,7 @@
  *
  * @remarks
  * A value's kind and its extent are different axes: `{10}`, `A1` and a bare `10` all reach a
- * range-typed parameter as a 1x1 container, yet Excel separates them:
+ * range-typed parameter as a 1x1 container, yet they are distinct:
  * `VLOOKUP(10,10,1,TRUE)` is `#N/A` while `VLOOKUP(10,{10},1,TRUE)` is 10, and `TYPE` answers
  * 1 vs 64. The kind is what the CALLER supplied; the extent is merely its size.
  *
@@ -13,7 +13,7 @@
  * argument can be: a reference, a non-reference array, a callable, and no argument at all. As an
  * argument kind, {@link ScalarType.Null} means a BLANK value.
  *
- * The names and values are ours. The numeric codes Excel's `TYPE` function answers are a
+ * The names and values are ours. The numeric codes the `TYPE` function answers are a
  * PROJECTION of this kind (see `TYPE`'s implementation), not the kind itself.
  *
  * @see {@link IFunctionArguments.getKindAt}

package/types/src/WildCard.d.ts

@@ -11,7 +11,7 @@ export declare const WildCard: {
      * Compiles Excel wildcard text into a regex.
      *
      * @param anchor Where the pattern has to line up: `true` for the WHOLE string, `'start'` for a
-     * PREFIX, `false` for anywhere in it. Excel matches a whole cell, so every lookup and criteria
+     * PREFIX, `false` for anywhere in it. A criterion matches a whole cell, so every lookup and criteria
      * caller anchors; `SEARCH`, which looks for a substring, does not; and a `D` function's criteria
      * table is the prefix form — `DSUM` with the criterion `appl` takes the row whose value is
      * `Apple`, where `COUNTIF` with the same criterion takes none.