@sheetxl/primitives 0.7.28-beta.4 → 0.8.0-beta.2

package/node/esm/index.mjs

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/primitives - Primitives - Base types for SheetXL functions. - v0.7.28-beta.4
+* @license @sheetxl/primitives - Primitives - Base types for SheetXL functions. - v0.8.0-beta.2
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.
@@ -32,7 +32,13 @@ var t, r, o, n, s = {
 }, a = {
 	...s,
 	Date: "date"
-}, i = /[.*+?^${}()|[\]\\]/, c = (e) => i.test(e) ? "\\" + e : e, u = {
+}, i = {
+	...s,
+	Reference: "reference",
+	Array: "array",
+	Lambda: "lambda",
+	Omitted: "omitted"
+}, c = /[.*+?^${}()|[\]\\]/, u = (e) => c.test(e) ? "\\" + e : e, l = {
 	isWildCard: (e) => "string" == typeof e && /[*?]/.test(e),
 	toRegex: (e, t, r = !1) => {
 		let o = "";
@@ -41,14 +47,14 @@ var t, r, o, n, s = {
 			const r = e[t];
 			if ("~" === r) {
 				const r = e[t + 1];
-				"*" === r || "?" === r || "~" === r ? (o += c(r), t++) : o += "~";
+				"*" !== r && "?" !== r && "~" !== r || (o += u(r), t++);
 				continue;
 			}
-			"*" !== r ? o += "?" !== r ? c(r) : "." : o += ".*";
+			"*" !== r ? o += "?" !== r ? u(r) : "[\\s\\S]" : o += "[\\s\\S]*";
 		}
-		return RegExp(r ? `^${o}$` : o, t);
+		return "start" === r ? RegExp(`^${o}`, t) : RegExp(r ? `^${o}$` : o, t);
 	}
-};
+}, d = (e) => null !== e && "object" == typeof e && !0 === e.isLazy;
 (r = t || (t = {})).Axis = {
 	Column: "column",
 	Row: "row"
@@ -246,7 +252,7 @@ var t, r, o, n, s = {
 		}
 	}
 	e.Connect = m;
-	class C extends o {
+	class S extends o {
 		constructor(e, o) {
 			super(t.Blocked, r.Blocked, e, o);
 		}
@@ -254,8 +260,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Blocked;
 		}
 	}
-	e.Blocked = C;
-	class S extends o {
+	e.Blocked = S;
+	class C extends o {
 		constructor(e, o) {
 			super(t.Unknown, r.Unknown, e, o);
 		}
@@ -263,8 +269,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Unknown;
 		}
 	}
-	e.Unknown = S;
-	class N extends o {
+	e.Unknown = C;
+	class w extends o {
 		constructor(e, o) {
 			super(t.Field, r.Field, e, o);
 		}
@@ -272,8 +278,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Field;
 		}
 	}
-	e.Field = N;
-	class w extends o {
+	e.Field = w;
+	class f extends o {
 		constructor(e, o) {
 			super(t.Calc, r.Calc, e, o);
 		}
@@ -281,8 +287,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Calc;
 		}
 	}
-	e.Calc = w;
-	class f extends o {
+	e.Calc = f;
+	class y extends o {
 		constructor(e, o) {
 			super(t.Busy, r.Busy, e, o);
 		}
@@ -290,8 +296,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Busy;
 		}
 	}
-	e.Busy = f;
-	class b extends o {
+	e.Busy = y;
+	class N extends o {
 		constructor(e, o) {
 			super(t.Python, r.Python, e, o);
 		}
@@ -299,8 +305,8 @@ var t, r, o, n, s = {
 			this.code = n.Code.Python;
 		}
 	}
-	e.Python = b;
-	class y extends o {
+	e.Python = N;
+	class b extends o {
 		constructor(e, o) {
 			super(t.Timeout, r.Timeout, e, o);
 		}
@@ -308,17 +314,17 @@ var t, r, o, n, s = {
 			this.code = n.Code.Timeout;
 		}
 	}
-	e.Timeout = y;
+	e.Timeout = b;
 }(n || (n = {}));
-var l = {};
-l[n.Code.Parse] = n.Parse, l[n.Code.Null] = n.Null, l[n.Code.Div0] = n.Div0, l[n.Code.Value] = n.Value, l[n.Code.Ref] = n.Ref, l[n.Code.Name] = n.Name, l[n.Code.Num] = n.Num, l[n.Code.NA] = n.NA, l[n.Code.GettingData] = n.GettingData, l[n.Code.Spill] = n.Spill, l[n.Code.Connect] = n.Connect, l[n.Code.Blocked] = n.Blocked, l[n.Code.Unknown] = n.Unknown, l[n.Code.Field] = n.Field, l[n.Code.Calc] = n.Calc, l[n.Code.Busy] = n.Busy, l[n.Code.Python] = n.Python, l[n.Code.Timeout] = n.Timeout;
-var d = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map(), p = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), m = Object.keys(l);
-for (let e = 0; e < m.length; e++) {
-	const t = l[m[e]], r = new t();
-	p.set(r.getLabel(), t), h.set(r.getCode(), t), d.set(r.getLabel(), r), g.set(r.getCode(), r);
+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;
+var p = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map(), C = Object.keys(g);
+for (let e = 0; e < C.length; e++) {
+	const t = g[C[e]], r = new t();
+	m.set(r.getLabel(), t), S.set(r.getCode(), t), p.set(r.getLabel(), r), h.set(r.getCode(), r);
 }
 (function(e) {
-	const t = e.getBuiltInByCode = (e) => g.get(e);
+	const t = e.getBuiltInByCode = (e) => h.get(e);
 	e.BuiltIn = {
 		Parse: t(n.Code.Parse),
 		Null: t(n.Code.Null),
@@ -340,12 +346,12 @@ for (let e = 0; e < m.length; e++) {
 		Timeout: t(n.Code.Timeout)
 	}, e.newTypedError = (e, t, r) => {
 		let o;
-		return o = "string" == typeof e ? p.get(e) : h.get(e), o || (o = n.Unknown), new o(t, r);
-	}, e.getBuiltInByLabel = (e) => d.get(e), e.isError = function(e, t) {
+		return o = "string" == typeof e ? m.get(e) : S.get(e), o || (o = n.Unknown), new o(t, r);
+	}, e.getBuiltInByLabel = (e) => p.get(e), e.isError = function(e, t) {
 		return !!e && !0 === e.isFormulaError && (void 0 === t || e.getCode() === t);
 	};
 })(n || (n = {}));
-var C = class {
+var w = class {
 	constructor(e) {
 		this._subscribeFn = e;
 	}
@@ -365,42 +371,48 @@ var C = class {
 			"function" == typeof n && n();
 		}, o;
 	}
-}, S = class {
+}, f = class {
 	createRange(e, t, r) {
-		throw new w();
+		throw new b();
+	}
+	flattenAreas(e) {
+		throw new b();
 	}
 	getReference(e, t) {
-		throw new w();
+		throw new b();
 	}
 	getResizedReference(e, t, r) {
-		throw new w();
+		throw new b();
 	}
 	getNumberFormat(e, t) {
-		throw new w();
+		throw new b();
 	}
 	fromSerialDate(e, t) {
-		throw new w();
+		throw new b();
 	}
 	toSerialDate(e, t) {
-		throw new w();
+		throw new b();
 	}
 	getDateParts(e, t) {
-		throw new w();
+		throw new b();
 	}
 	getSerialDate(e, t, r, o, n, s, a) {
-		throw new w();
+		throw new b();
 	}
 	getNow() {
-		throw new w();
+		throw new b();
+	}
+	getRandom() {
+		return Math.random();
 	}
 	getValueAt(e, t, r, o) {
 		return null;
 	}
 	getEntireCoords() {
-		return f;
+		return A;
 	}
 	isValidDate(e, t) {
-		return e instanceof Date || "[object Date]" === Object.prototype.toString.call(e) ? !isNaN(e.getTime()) : !t && "number" == typeof e && !(e < 0 || e > y);
+		return e instanceof Date || "[object Date]" === Object.prototype.toString.call(e) ? !isNaN(e.getTime()) : !t && "number" == typeof e && !(e < 0 || e > _);
 	}
 	getRow() {
 		return 0;
@@ -408,6 +420,9 @@ var C = class {
 	getColumn() {
 		return 0;
 	}
+	isImplicitIntersect() {
+		return !1;
+	}
 	getFormulaAt(e, t, r) {
 		return null;
 	}
@@ -432,19 +447,19 @@ var C = class {
 		return null;
 	}
 	getAddress(e, t) {
-		throw new w();
+		throw new b();
 	}
 	parseAsSerialDate(e, t) {
-		throw new w();
+		throw new b();
 	}
 	parseAsDate(e, t) {
-		throw new w();
+		throw new b();
 	}
 	parseAsNumber(e, t) {
-		throw new w();
+		throw new b();
 	}
-	createCriteria(e) {
-		throw new w();
+	createCriteria(e, t) {
+		throw new b();
 	}
 	parseAsLiteral(e) {
 		const t = e.toUpperCase();
@@ -455,13 +470,16 @@ var C = class {
 	}
 	compare(e, t, r) {
 		if (e === t) return 0;
-		const o = N(e), n = N(t);
+		const o = y(e), n = y(t);
 		return o !== n ? o < n ? -1 : 1 : e < t ? -1 : e > t ? 1 : 0;
 	}
 	getRuntime() {
-		return b;
+		return D;
+	}
+	getArgs() {
+		throw new b(N);
 	}
-}, N = (e) => {
+}, y = (e) => {
 	if (null == e) return 0;
 	switch (typeof e) {
 		case "number": return 1;
@@ -469,41 +487,45 @@ var C = class {
 		case "boolean": return 3;
 		default: return 4;
 	}
-}, w = class extends Error {
+}, N = "FormulaContext.getArgs() is only valid while a function body is running", b = class extends Error {
 	constructor(e = "Not implemented in StubbedFormulaContext") {
 		super(e), this.name = "NotImplementedError";
 	}
-}, f = Object.freeze({
+}, A = Object.freeze({
 	colStart: 0,
 	rowStart: 0,
 	colEnd: Math.pow(2, 14) - 1,
 	rowEnd: Math.pow(2, 20) - 1
-}), b = {
+}), D = {
 	isDate1904: () => !1,
-	getLocale: () => _.tag,
-	getLocaleProfile: () => _,
+	getLocale: () => F.tag,
+	getLocaleProfile: () => F,
 	isR1C1: () => !1,
 	getNow: () => 0,
+	getRandom: () => Math.random(),
 	getLocation: () => "unknown",
 	getVersion: () => "1.0.0",
 	getOS: () => "unknown",
 	getUser: () => "unidentified",
 	getDescription: () => "Stubbed Formula Context"
-}, y = 2958465, D = new S(), A = class {
+}, _ = 2958465, R = new f(), x = class {
 	constructor() {
-		this._scope = D;
+		this._scope = R, this._argsFn = null;
 	}
 	_setScope(e) {
-		this._scope = e ?? D;
+		this._scope = e ?? R;
 	}
 	_getScope() {
 		return this._scope;
 	}
+	_setArgsProvider(e) {
+		this._argsFn = e;
+	}
 	getNumberFormat(e, t) {
 		return this._getScope().getNumberFormat(e, t);
 	}
 	getEntireCoords() {
-		return this._getScope().getEntireCoords() ?? f;
+		return this._getScope().getEntireCoords() ?? A;
 	}
 	parseAsSerialDate(e, t) {
 		return this._getScope().parseAsSerialDate(e, t);
@@ -514,12 +536,12 @@ var C = class {
 	parseAsNumber(e, t) {
 		return this._getScope().parseAsNumber(e, t);
 	}
-	createCriteria(e) {
-		return this._getScope().createCriteria(e);
+	createCriteria(e, t) {
+		return this._getScope().createCriteria(e, t);
 	}
 	parseAsLiteral(e) {
 		const t = this._getScope();
-		return t.parseAsLiteral ? t.parseAsLiteral(e) : D.parseAsLiteral(e);
+		return t.parseAsLiteral ? t.parseAsLiteral(e) : R.parseAsLiteral(e);
 	}
 	toText(e) {
 		return this._getScope().toText(e);
@@ -542,15 +564,30 @@ var C = class {
 	getNow() {
 		return this._getScope().getNow();
 	}
+	getRandom() {
+		return this._getScope().getRandom?.() ?? Math.random();
+	}
 	createRange(e, t, r) {
 		return this._getScope().createRange(e, t, r);
 	}
+	flattenAreas(e) {
+		if (!Array.isArray(e)) return e;
+		const t = [];
+		for (let r = 0; r < e.length; r++) {
+			const o = e[r], { rows: n, columns: s } = o.getShape();
+			for (let e = 0; e < n; e++) for (let r = 0; r < s; r++) t.push(o.getValueAt(e, r));
+		}
+		return this.createRange(t.length, 1, (e, r) => t[r.rowIndex]);
+	}
 	getRow() {
 		return this._getScope().getRow?.() ?? 0;
 	}
 	getColumn() {
 		return this._getScope().getColumn?.() ?? 0;
 	}
+	isImplicitIntersect() {
+		return this._getScope().isImplicitIntersect?.() ?? !1;
+	}
 	getReference(e, t) {
 		return this._getScope().getReference(e, t);
 	}
@@ -591,18 +628,23 @@ var C = class {
 		return this._getScope().getAddress(e, t);
 	}
 	compare(e, t, r) {
-		return this._getScope().compare?.(e, t, r) ?? D.compare(e, t, r);
+		return this._getScope().compare?.(e, t, r) ?? R.compare(e, t, r);
 	}
 	getRuntime() {
 		return this._getScope().getRuntime();
 	}
+	getArgs() {
+		const e = this._argsFn, t = e ? e() : null;
+		if (!t) throw new b(N);
+		return t;
+	}
 	get [Symbol.toStringTag]() {
 		return "[FormulaContext]";
 	}
 	toString() {
 		return this._getScope()?.toString?.() ?? "{STUB SCOPE}";
 	}
-}, _ = Object.freeze({
+}, F = Object.freeze({
 	tag: "en-US",
 	numberingSystem: "latn",
 	decimal: ".",
@@ -682,5 +724,5 @@ var C = class {
 		sensitivity: "base",
 		numeric: !0
 	})
-}), x = new A();
-export { _ as DEFAULT_LOCALE_PROFILE, x as FormulaContext, n as FormulaError, t as IRange, o as IRangeStats, a as InteropScalarType, C as Observable, e as Scalar, s as ScalarType, A as ScopedFormulaContext, S as StubbedFormulaContext, u as WildCard };
+}), T = new x();
+export { F as DEFAULT_LOCALE_PROFILE, T as FormulaContext, n as FormulaError, t as IRange, o as IRangeStats, a as InteropScalarType, w as Observable, e as Scalar, s as ScalarType, x as ScopedFormulaContext, f 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.7.28-beta.4",
+  "version": "0.8.0-beta.2",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {

package/types/src/ErrorPolicy.d.ts

@@ -1,78 +1,69 @@
 /**
- * Parameter markers that declare how the engine handles `FormulaError` values *before* a
- * function body runs. At the type level they are identity aliases — the body sees plain `T` —
- * but the declaration records the policy for the engine.
+ * The one parameter marker that speaks about errors — and it is a RULE, not quite a type. At the
+ * type level it is an identity alias (what arrives at any slot may already be an error — `Scalar`
+ * says so in its own definition); the marker says the ENGINE DOES NOT AUTO-REJECT a bare error at
+ * this slot: it is delivered raw, and the body decides.
  *
- * **ONE default, every position: errors reject.** Scalar arguments, lifted members,
- * flattened members, and range parameters alike propagate the first error — preserving its
- * identity (`#N/A` stays `#N/A`) — and the body never runs. Opt out with {@link AcceptError}.
- * The single exception needs no marker: a `FormulaError.Known`-typed parameter receives
- * errors because the type declares it.
+ * **There are two kinds of error, and the marker is about the first only:**
  *
- * > *Errors propagate unless your function opts in to seeing them.*
+ * 1. an error *instead of* a value or a range — `NA()`, an unresolvable name (`#NAME?`), a
+ *    union `(A1,C1)` where one rectangle is needed;
+ * 2. an error *inside* a range — a cell or member holding `#N/A`.
  *
- * | position | default | opt-out |
- * | --- | --- | --- |
- * | scalar argument | reject — propagate with identity, body never runs | `AcceptError<T>` — body receives raw |
- * | lifted member | reject — error becomes an error **member** of the output | `AcceptError<T>` |
- * | flattened member (`Scalar[]`, rest) | reject — first error wins, argument order, row-major | `AcceptError<T>` |
- * | range parameter | reject — first error (row-major) outranks everything | `AcceptError<IRange>` — members arrive raw |
- * | `FormulaError.Known` parameter | receive (the type declares it) | — |
+ * The engine never delivers the first unless the slot declares {@link AcceptError} — any `T`,
+ * one meaning. Without the marker the error propagates with its identity (`#N/A` stays `#N/A`)
+ * and the body never runs: as the call's answer for a scalar argument, as an error MEMBER of the
+ * output under a lift, as the first error in argument order for a flattened list. The single
+ * exception needs no marker: a `FormulaError.Known`-typed parameter receives errors because the
+ * type declares it.
  *
- * One parameter splits the two by ARGUMENT SHAPE rather than picking one:
- * {@link AcceptRefError} rejects a direct/computed error and accepts a reference-shaped one.
+ * The second is never the engine's business. A valid range is handed over whole, marker or no
+ * marker, and a body that cares asks:
  *
- * There is no marker for the default. A `RejectError<T>` alias existed and declared nothing the
- * engine did not already do, so it was removed rather than left as a second way to say nothing.
+ * ```ts
+ * if (range.hasError()) return range.firstError();
+ * ```
+ *
+ * placed before its own validation where Excel'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
+ * statistics) orders its own scan the way it pairs.
  *
- * Which-error-wins is ARGUMENT ORDER: the whole of argument N is scanned before argument
- * N+1, row-major within each. The engine's range scan rides `IRange.errors()` /
- * `IRange.hasError()` — raw stored members only, same definition as
- * `getStats().getTypedCounts([ScalarType.Error])`.
+ * > *A bare error propagates unless your function opts in to seeing it; the members of a range
+ * > are yours.*
  *
- * The tolerant set — parameters that declare `AcceptError` — is finite and documented
- * (RANGE-ERROR-PROP.md §6.3): operators (broadcast is per-member), reshapers / dynamic
- * arrays (error members pass through to the output), lookups (errors in never-consumed
- * cells are tolerated), shape-only reference params (ROWS, COLUMNS, INDEX, OFFSET…),
- * conditional consumers (SUMIF-family; the database family and SUBTOTAL/AGGREGATE keep
- * their in-body, data-dependent policy), counters (COUNT, COUNTA), and the error handlers
- * themselves (IS*, IFERROR…).
+ * There is no marker for the default. A `RejectError<T>` alias existed and declared nothing the
+ * engine did not already do, so it was removed rather than left as a second way to say nothing.
+ * `AcceptRefError<T>`, which split the policy by argument shape, retired with the engine's member
+ * scan: its range form is this default, and its scalar form (the database `field`) is a range
+ * slot whose body reads the one cell.
  */
 /**
- * Opts a parameter out of the reject default: the body receives `FormulaError` values raw.
- * Use this for functions whose job is to inspect, replace, or render errors (the IS*
- * family, IFERROR, ERROR.TYPE, VALUETOTEXT…), that remap errors rather than propagate
- * them, or that legitimately tolerate error members they may never consume (lookups,
- * reshapers, conditional consumers — the §6.3 tolerant set).
+ * The engine does not auto-reject a bare error at this parameter: it is delivered RAW — a
+ * `FormulaError.Known`, never boxed as a 1×1 range — and the body narrows with
+ * `FormulaError.isError` (if it cares). A raw error is therefore never confusable with a
+ * one-cell range holding an error MEMBER: the two kinds this file keeps apart stay apart in the
+ * value itself, and members are no engine concern at all. For the functions whose job is to
+ * inspect, replace, or count errors — the IS* family, IFERROR, ERROR.TYPE, TYPE, COUNT and
+ * COUNTA — for the binders (`LET`, `LAMBDA`), whose value slots carry an argument unevaluated,
+ * and for a body that owns a reading ORDER or a LIFT the engine cannot see (SERIESSUM's
+ * coefficients; CONCATENATE broadcasts the error over its lifted ranges, so the SHAPE of the
+ * answer is the marker's work).
  *
- * On a TYPED parameter (`IRange<number>`), `AcceptError` means errors and failed coercions
- * arrive as raw MEMBERS instead of propagating — COUNT ignores them, COUNTA counts them.
+ * On a TYPED range parameter (`IRange<number>`) the marker also lets error members and failed
+ * coercions ride through the typed read as raw members — COUNT ignores them, COUNTA counts them.
+ * On an untyped range it changes nothing about members: they arrive raw either way.
  *
  * @example
  * ```ts
  * export function ISERROR(value: AcceptError<Scalar>): Scalar { ... }
  * export function IFERROR(value: AcceptError<Scalar>, valueIfError: AcceptError<Scalar>): Scalar { ... }
  * // Both parameters: an unused error fallback must pass through untouched (IFERROR(5,NA()) → 5).
- * export function ROWS(array: AcceptError<IRange>): number { ... }
- * // Shape-only: ROWS(A1:A2) is 2 even if A1 is #REF!.
+ * export function COUNT(number: AcceptError<IRange<number>>[]): number { ... }
+ * // COUNT(NA()) is 0: the error is a value, and not a number.
  * ```
  */
 export type AcceptError<T> = T;
-/**
- * Splits the policy by the ARGUMENT'S SHAPE: a **direct or computed** error rejects (propagates
- * with its identity, exactly the default), while a **reference-shaped** one is accepted and the
- * body receives it raw. "Direct" is the same runtime-shape test the coercion uses — a scalar,
- * typed or computed; a reference or a computed array is not (`isDirectArg` in `TypedFunction`).
-*
- * ```
- * =DSUM(A1:B3,NA(),G1:G2)     #N/A       direct    — rejects, identity preserved
- * =DSUM(A1:B3,NA()+0,G1:G2)   #N/A       computed  — still direct
- * =DSUM(A1:B3,E1,G1:G2)       #VALUE!    E1=#N/A   — reference: body remaps
- * =DSUM(A1:B3,E2,G1:G2)       #VALUE!    E2=#DIV/0!
- * ```
- *
- * A body under this marker MUST handle the error it may now receive; a `FormulaError` reaching
- * an unguarded body is the item 18 hazard.
- */
-export type AcceptRefError<T> = T;
 //# sourceMappingURL=ErrorPolicy.d.ts.map

package/types/src/Flatten.d.ts

@@ -18,8 +18,11 @@
  *
  * 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, and a parameter that
- * does not declare `Flatten` refuses one outright (`#REF!` — `ROWS((A1:A3,C1:C5))` in Excel).
+ * 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:
+ * `AREAS` counts the areas, `SUM` adds them, `ROWS` answers `#REF!` to more than one, the lookups
+ * `#N/A`.
  *
  * At the type level it is `T[]`, so the body reads the list directly.
  *
@@ -27,7 +30,7 @@
  * ```ts
  * export function IRR(values: Flatten<number>, guess?: number): number { ... }
  * export function NETWORKDAYS(start: Date, end: Date, holidays?: Flatten<Scalar>): number { ... }
- * export function INDEX(array: Flatten<AcceptError<IRange>>, rowNum?: number, ...): any { ... }
+ * export function INDEX(array: Flatten<IRange>, rowNum?: number, ...): any { ... }
  * ```
  */
 export type Flatten<T> = T[];