@sheetxl/formulas 0.8.0-beta.1 → 0.8.0-beta.11

package/node/esm/{D2miaIrotHbpdWei.mjs → nW1VYp24XfapwOYa.mjs}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.1
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.11
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.

package/{browser/esm/-f-RKKojiLg94hp9.mjs → node/esm/qFHh9pVgQa0ZMumi.mjs}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.1
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.11
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.
@@ -70,15 +70,12 @@ var e = {
 			columns: { d: "The number of columns to drop. A negative value drops from the end of the array." }
 		}
 	},
-	EXPAND: {
-		s: "Expands an array to the specified dimensions.",
-		p: {
-			array: { d: "The array to expand." },
-			row: { d: "The number of rows in the expanded array. If missing, rows will not be expanded." },
-			columns: { d: "The number of columns in the expanded array. If missing, columns will not be expanded." },
-			padWidth: { d: "The value with which to pad. The default is #N/A." }
-		}
-	},
+	EXPAND: { p: {
+		array: {},
+		row: {},
+		columns: {},
+		padWith: {}
+	} },
 	FIELDVALUE: {
 		s: "Extracts a value from a field of a given record.",
 		p: {
@@ -312,5 +309,48 @@ var e = {
 			searchMode: { d: "1=first→last (default), -1=last→first, 2=binary asc, -2=binary desc" }
 		}
 	}
+}, r = {
+	MatchType: {
+		s: "How MATCH compares the lookup value with the values in the array.",
+		m: {
+			"Less than": { d: "The largest value that is less than or equal to the lookup value. The array must be sorted in ascending order." },
+			"Exact match": { d: "The first value that is exactly equal to the lookup value. The array can be in any order." },
+			"Greater than": { d: "The smallest value that is greater than or equal to the lookup value. The array must be sorted in descending order." }
+		}
+	},
+	SortOrder: {
+		s: "The direction SORT and SORTBY sort a key in.",
+		m: {
+			Ascending: { d: "Smallest to largest." },
+			Descending: { d: "Largest to smallest." }
+		}
+	},
+	IgnoreValues: {
+		s: "Which values to leave out.",
+		m: {
+			"Keep all values": { d: "Keep every value, blanks and errors included." },
+			"Ignore blanks": { d: "Leave out blank cells." },
+			"Ignore errors": { d: "Leave out error values." },
+			"Ignore blanks and errors": { d: "Leave out blank cells and error values." }
+		}
+	},
+	MatchMode: {
+		s: "How XLOOKUP and XMATCH match the lookup value.",
+		m: {
+			"Exact match": { d: "Only an item equal to the lookup value." },
+			"Exact match or next smaller item": { d: "An item equal to the lookup value, or else the next smaller item." },
+			"Exact match or next larger item": { d: "An item equal to the lookup value, or else the next larger item." },
+			"Wildcard character match": { d: "The lookup value may use *, ? and ~ as wildcards." }
+		}
+	},
+	SearchMode: {
+		s: "The order in which XLOOKUP and XMATCH search.",
+		m: {
+			"Search first-to-last": { d: "Search from the first item to the last." },
+			"Search last-to-first": { d: "Search from the last item to the first." },
+			"Binary search (sorted ascending order)": { d: "A binary search of items sorted in ascending order." },
+			"Binary search (sorted descending order)": { d: "A binary search of items sorted in descending order." }
+		}
+	}
 };
-export { e as default };
+export { e as default, r as enums };

package/node/esm/{B7750ljsJF3qA9kU.mjs → qzngIvn0BfOU7J6v.mjs}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.1
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.11
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.
@@ -9,7 +9,7 @@ var e = {
 		s: "Returns information about the cell.",
 		p: {
 			infoType: { d: "The type of information to return." },
-			reference: {}
+			reference: { d: "The cell to report on. Defaults to the cell holding the formula." }
 		}
 	},
 	"ERROR.TYPE": {
@@ -107,5 +107,39 @@ var e = {
 		s: "Returns an integer representing the data type of a value: number = 1; text = 2; logical value = 4; error value = 16; array = 64; compound data = 128.",
 		p: { value: { d: "is the value to check." } }
 	}
+}, t = {
+	CellInfoType: {
+		s: "The information to return about the cell.",
+		m: {
+			Address: { d: "Reference of the first cell in the reference, as text." },
+			Col: { d: "Column number of the cell in the reference." },
+			Color: { d: "1 if the cell is formatted in color for negative values; otherwise 0." },
+			Contents: { d: "Value of the upper-left cell in the reference; not a formula." },
+			Filename: { d: "Full path of the file that contains the reference, as text." },
+			Format: { d: "Text value corresponding to the number format of the cell." },
+			Parentheses: { d: "1 if the cell is formatted with parentheses for positive or all values; otherwise 0." },
+			Prefix: { d: "Text value corresponding to the label prefix of the cell." },
+			Protect: { d: "0 if the cell is not locked; otherwise 1." },
+			Row: { d: "Row number of the cell in the reference." },
+			Type: { d: "\"b\" for a blank cell, \"l\" for a text constant, \"v\" for anything else." },
+			Width: { d: "Column width of the cell, rounded to an integer." }
+		}
+	},
+	InfoType: {
+		s: "The information to return about the operating environment.",
+		m: {
+			Directory: { d: "Path of the current directory or folder." },
+			"Mem Avail": { d: "Amount of memory available. Legacy: answers #N/A." },
+			"Mem Used": { d: "Amount of memory being used for data. Legacy: answers #N/A." },
+			"Num File": { d: "Number of active worksheets in the open workbooks." },
+			Origin: { d: "Absolute reference of the top and leftmost visible cell." },
+			"OS Version": { d: "Current operating system version, as text." },
+			Recalc: { d: "Current recalculation mode; \"Automatic\" or \"Manual\"." },
+			Release: { d: "Version of the application, as text." },
+			System: { d: "Name of the operating environment; \"pcdos\" or \"mac\"." },
+			"Tot Mem": { d: "Total memory available. Legacy: answers #N/A." },
+			User: { d: "The licensed user. Not part of Excel." }
+		}
+	}
 };
-export { e as default };
+export { e as default, t as enums };

package/{browser/esm/CCGjvL3YYwY09qF-.mjs → node/esm/zNQMTF4Mftkd8m3i.mjs}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.1
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.11
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
 * License: The license can be found at https://www.sheetxl.com/license.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sheetxl/formulas",
   "description": "Formulas - TypeScript formulas compatible with Excel built-ins.",
-  "version": "0.8.0-beta.1",
+  "version": "0.8.0-beta.11",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {
@@ -9,13 +9,18 @@
       "types": "./types/index.d.ts",
       "browser": "./browser/esm/index.mjs",
       "node": "./node/esm/index.mjs",
-      "import": "./browser/esm/index.mjs",
-      "require": "./browser/cjs/index.cjs"
+      "default": "./browser/esm/index.mjs"
+    },
+    "./declarations": {
+      "types": "./types/declarations.d.ts",
+      "browser": "./browser/esm/declarations.mjs",
+      "node": "./node/esm/declarations.mjs",
+      "default": "./browser/esm/declarations.mjs"
     }
   },
   "types": "./types/index.d.ts",
   "module": "./browser/esm/index.mjs",
-  "main": "./browser/cjs/index.cjs",
+  "main": "./browser/esm/index.mjs",
   "sideEffects": false,
   "engineStrict": true,
   "homepage": "https://sheetxl.com",
@@ -37,10 +42,9 @@
     "formulas"
   ],
   "dependencies": {
-    "@sheetxl/primitives": "^0.8.0-beta.1",
-    "@sheetxl/scripting": "^0.8.0-beta.1",
+    "@sheetxl/primitives": "^0.8.0-beta.11",
+    "@sheetxl/scripting": "^0.8.0-beta.11",
     "bahttext": "^2.4.0",
-    "bessel": "^1.0.2",
-    "jstat": "^1.9.6"
+    "bessel": "^1.0.2"
   }
 }

package/types/declarations.d.ts

@@ -0,0 +1,4 @@
+export {}
+import Formulas from './src/.generated/declarations'
+export default Formulas
+export {}

package/types/src/.generated/decl/dateTime/Date.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Date.decl.d.ts.map

package/types/src/.generated/decl/information/Information.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Information.decl.d.ts.map

package/types/src/.generated/decl/lookupReference/Reference.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Reference.decl.d.ts.map

package/types/src/.generated/decl/mathTrig/Math.decl.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDeclarations } from '@sheetxl/scripting';
+import { MinifiedDeclarations, MinifiedEnums } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
+export declare const enums: MinifiedEnums;
 export default declarations;
 //# sourceMappingURL=Math.decl.d.ts.map

package/types/src/.generated/declarations.d.ts

@@ -0,0 +1,7 @@
+import { FunctionDeclarationModule } from '@sheetxl/scripting';
+/**
+ * This package's declarations, one entry per source module, in binding order.
+ */
+declare const declarations: readonly FunctionDeclarationModule[];
+export default declarations;
+//# sourceMappingURL=declarations.d.ts.map

package/types/src/.generated/desc/dateTime/Date.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Date.desc.d.ts.map

package/types/src/.generated/desc/information/Information.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Information.desc.d.ts.map

package/types/src/.generated/desc/lookupReference/Reference.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Reference.desc.d.ts.map

package/types/src/.generated/desc/mathTrig/Math.desc.d.ts

@@ -1,4 +1,5 @@
-import { MinifiedDescriptors } from '@sheetxl/scripting';
+import { MinifiedDescriptors, MinifiedEnumDescriptors } from '@sheetxl/scripting';
 declare const descriptors: MinifiedDescriptors;
+export declare const enums: MinifiedEnumDescriptors;
 export default descriptors;
 //# sourceMappingURL=Math.desc.d.ts.map

package/types/src/_utils/AValues.d.ts

@@ -0,0 +1,30 @@
+import { IRange, Scalar } from '@sheetxl/primitives';
+/**
+ * The reading the A functions apply to a member their plain twin skips — AVERAGEA, MAXA, MINA,
+ * STDEVA, STDEVPA, VARA and VARPA.
+ *
+ * Text and FALSE are 0, TRUE is 1, and a NUMERIC text is 0 rather than its number. All of it
+ * applies to a member of a REFERENCE; inside an ARRAY the A functions are their plain twins —
+ * `MAXA({-1,-2,"x"})` is -1 where MAXA over the same three CELLS is 0 — with one exception:
+ * AVERAGEA carries the text rule into an array as well, so `AVERAGEA({-1,-2,"x"})` is -1. A
+ * BOOLEAN in an array is skipped by every one of them, AVERAGEA included, typed or computed
+ * alike: `AVERAGEA({TRUE})` and `AVERAGEA(TRANSPOSE({TRUE}))` are both #DIV/0! while a TRUE CELL
+ * averages 1. The split is the reference-vs-array KIND, not literalness.
+ *
+ * A DIRECT argument never reaches any of this — those slots are typed `number`, so a boolean
+ * coerced to 1 and a text failed to #VALUE! before it was boxed.
+ *
+ * It lives here rather than beside the functions because an exported helper in a category
+ * directory registers a formula function, and both category files need it.
+ */
+export declare const isReferenceRange: (range: IRange) => boolean;
+/** MAXA, MINA, STDEVA, STDEVPA, VARA and VARPA. */
+export declare const ValueOptionsAFunctions: IRange.ValueOptions;
+/** AVERAGEA's, which differs in one place: a text member of an ARRAY is 0 rather than skipped. */
+export declare const ValueOptionsAverageA: IRange.ValueOptions;
+/**
+ * The same reading applied to a RAW member, for the bodies that need each deviation rather than
+ * an aggregate. `reference` is `isReferenceRange` of the range the value came out of.
+ */
+export declare const coerceAValue: (v: Scalar, reference: boolean) => number | null;
+//# sourceMappingURL=AValues.d.ts.map

package/types/src/_utils/AggregateIFS.d.ts

@@ -6,7 +6,9 @@ import { IRange, IFormulaContext, IReferenceRange, Scalar } from '@sheetxl/primi
  * @param context - The formula context.
  * @param pairs - The `[criteriaRange, criteria]` groups to evaluate. Each criteria is a single
  *   VALUE: the slot is declared `AcceptError<Scalar>`, so a range in that position is lifted by
- *   the engine and this helper is called once per element.
+ *   the engine and this helper is called once per element. `AcceptError` because an error is a
+ *   MATCHABLE criterion, not a fault — `COUNTIF(J1:J3,1/0)` over a `#DIV/0!` cell is 1 and
+ *   `SUMIF(J1:J3,NA(),J1:J3)` sums the matched `#N/A` cell.
  * @param aggregateFn - Called for each matching cell position with
  *   `(accumulator, value)`. `accumulator` is `null` on the first matching call.
  *   Return `accumulator` unchanged to skip a value (e.g. non-numeric).

package/types/src/_utils/Arithmetic.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Excel's arithmetic rules, for the bodies that have to reproduce them INSIDE a computation
+ * rather than at the boundary.
+ */
+/**
+ * Zeroes a subnormal, and folds -0 to 0 with it.
+ *
+ * Excel flushes a subnormal at its MULTIPLYING operators and nowhere else — a function's result
+ * keeps one (`EXP(-745)` is 5E-324) and so do `+` and `-`. A body whose answer comes out of a
+ * DIVISION inherits the rule and has to say so here, because JavaScript's `/` does not:
+ * `ACOTH(1E307*17)` is 0 in Excel, where `1/1.7E308` is a subnormal that would otherwise survive
+ * the arctangent.
+ */
+export declare const flushSubnormal: (value: number) => number;
+/**
+ * The inverse hyperbolic tangent, decomposed the way a C library does it — the log form above
+ * half and `log1p` below — rather than through the platform's `Math.atanh`.
+ *
+ * It is the spelling Excel agrees with: `ATANH(0.5)` is 0.5493061443340549,
+ * which is `ln(3)/2`, where `Math.atanh(0.5)` is one ulp below; and ACOTH reaches it with
+ * `y = 1/x`, where the log form keeps precision the rounded reciprocal has already lost
+ * (`ACOTH(1.0000001)` is 8.405621440467199, and `Math.atanh(1/1.0000001)` is 8.40562144042724 —
+ * a difference of eleven digits, not of a bit).
+ */
+export declare const atanhExcel: (y: number) => number;
+/**
+ * A double read at 15 SIGNIFICANT DECIMAL DIGITS — the precision at which Excel reads one before
+ * deciding which side of a boundary it falls on.
+ *
+ * `INT(4.35*100)` is 435 where the double is 434.99999999999994, and `ROUND(50*0.57,0)` is 29
+ * because 28.4999999999999964 reads as 28.5. It is a PER-SLOT rule and not a global one — MOD,
+ * QUOTIENT, EVEN and ODD read the raw double at the same position their siblings read this — so a
+ * body applies it at the slots that read this way and nowhere else.
+ */
+export declare const round15: (value: number) => number;
+//# sourceMappingURL=Arithmetic.d.ts.map

package/types/src/_utils/Combinatorics.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `n!` the way Excel accumulates it: a DESCENDING double product, `n · (n-1) · … · 2`.
+ *
+ * The order is the whole of the rule. Ascending gives a different double on twenty-two of the
+ * integers in range, and the correctly rounded value is a third answer again.
+ */
+export declare const factorialKernel: (n: number) => number;
+/** The largest `number` COMBIN accepts: `2^31 - 2`, one short of INT_MAX. */
+export declare const CombinMax = 2147483646;
+/**
+ * `C(n,k)` as a multiplicative product rather than a ratio of factorials.
+ *
+ * That is why `COMBIN(171,85)` answers where `FACT(171)` is `#NUM!`, and why the refusal is on
+ * the ANSWER rather than the arguments: `COMBIN(1029,514)` is 1.43E308 and `COMBIN(1030,514)` is
+ * `#NUM!`. Dividing before multiplying keeps the running value in range, and the smaller of
+ * `k` and `n-k` decides the step count — `COMBIN(170,84)` and `COMBIN(170,86)` are the same
+ * double, not merely the same number.
+ */
+export declare const binomialKernel: (n: number, k: number) => number;
+//# sourceMappingURL=Combinatorics.d.ts.map

package/types/src/_utils/Distributions.d.ts

@@ -0,0 +1,93 @@
+export declare const normalPdf: (x: number, mean: number, std: number) => number;
+/**
+ * Taken through `erfc` rather than `1 + erf`: below about `-6` standard deviations the latter is
+ * one plus a value one ulp short of minus one, so the whole lower tail cancels away to zero
+ * where Excel carries it out to 1E-300.
+ */
+export declare const normalCdf: (x: number, mean: number, std: number) => number;
+export declare const normalInv: (p: number, mean: number, std: number) => number;
+export declare function lognormalPdf(x: number, mu: number, sigma: number): number;
+export declare function lognormalCdf(x: number, mu: number, sigma: number): number;
+export declare const lognormalInv: (p: number, mu: number, sigma: number) => number;
+export declare function gammaPdf(x: number, shape: number, scale: number): number;
+export declare function gammaCdf(x: number, shape: number, scale: number): number;
+export declare const gammaInv: (p: number, shape: number, scale: number) => number;
+export declare function chisquarePdf(x: number, dof: number): number;
+export declare function chisquareCdf(x: number, dof: number): number;
+/** `1 - chisquareCdf`, taken from the tail itself rather than by subtracting it from one. */
+export declare function chisquareCdfUpper(x: number, dof: number): number;
+export declare const chisquareInv: (p: number, dof: number) => number;
+export declare function centralFPdf(x: number, df1: number, df2: number): number;
+export declare function centralFCdf(x: number, df1: number, df2: number): number;
+/**
+ * `1 - centralFCdf`, as the incomplete beta's OTHER tail — argument and parameters both swapped,
+ * so the small quantity is the one computed. Subtracting the lower tail from one instead loses
+ * the whole answer once the tail is under an ulp of one.
+ */
+export declare function centralFCdfUpper(x: number, df1: number, df2: number): number;
+export declare const centralFInv: (p: number, df1: number, df2: number) => number;
+export declare function studenttPdf(x: number, dof: number): number;
+/**
+ * The argument is `dof/(dof + x^2)` rather than `(x + sqrt(x^2+dof))/(2 sqrt(x^2+dof))`: the
+ * latter is one minus a value the size of the ANSWER, so at `x = 1E7` it arrives as `1 - 2.5E-15`
+ * and the tail is gone before the kernel is called. Both spell the same function.
+ */
+export declare function studenttCdf(x: number, dof: number): number;
+/**
+ * `1 - studenttCdf`, from the tail itself — see {@link studenttCdf} for the argument.
+ *
+ * An `x` whose square overflows is refused rather than read as the limit. Excel refuses it too
+ * (`T.DIST(1E307,5,TRUE)` is `#NUM!` while `T.DIST(2^31,5,TRUE)` is 1), and the boundary is the
+ * same one: `x^2` past a double.
+ */
+export declare function studenttCdfUpper(x: number, dof: number): number;
+export declare function studenttInv(p: number, dof: number): number;
+export declare function poissonPdf(k: number, l: number): number;
+/**
+ * The CDF sums the mass function term by term, and adds the terms BACK TO FRONT.
+ *
+ * `x` is the caller's argument and the mass function divides by `k!`, so the walk answers only
+ * while every term is finite: past 170 the factorial overflows and a term is `Infinity`, `NaN`
+ * or a silently truncated tail. Where the walk cannot answer, the complementary regularized
+ * gamma is the same function in closed form.
+ *
+ * The ORDER is the one place this differs from the rest of the category, where Excel accumulates
+ * forward. It is kept because nothing separates the two orders: only nine of the family's rows
+ * move at all and they split between them, and a summation order should not be changed on a
+ * coin toss.
+ */
+export declare function poissonCdf(x: number, l: number): number;
+export declare const binomialPdf: (k: number, n: number, p: number) => number;
+/**
+ * The CDF is the complement of a `1e-10` incomplete beta, ROUNDED to that same tolerance.
+ *
+ * The rounding is EXCEL'S, not a leftover: it is why a cumulative binomial in the bulk carries
+ * ten decimal places and no more. Taking it out moves answers AWAY from Excel, so it is not a
+ * cleanup to make.
+ */
+export declare function binomialCdf(x: number, n: number, p: number): number;
+export declare function negbinPdf(k: number, r: number, p: number): number;
+/**
+ * `x` is the caller's argument, so the walk needs both an exit and a fallback: it stops once the
+ * tail has underflowed — the mass is unimodal, so a zero term is followed only by zero terms and
+ * the sum can no longer move — and hands over to the regularized incomplete beta, the same
+ * function in closed form, when a term overflows or the tail has not arrived by `NegbinMaxSteps`.
+ * A walk that never saw a NONZERO term hands over too: `p^r` underflows well before the answer
+ * does, so an all-zero walk measures the mass function's range and not the distribution.
+ */
+export declare function negbinCdf(x: number, r: number, p: number): number;
+export declare const exponentialPdf: (x: number, rate: number) => number;
+export declare const exponentialCdf: (x: number, rate: number) => number;
+export declare function betaPdf(x: number, alpha: number, beta: number): number;
+export declare const betaCdf: (x: number, alpha: number, beta: number) => number;
+export declare const betaInv: (p: number, alpha: number, beta: number) => number;
+/**
+ * Half-width of the confidence interval around a mean, from the normal quantile.
+ *
+ * The `(1 + h) - 1` round trip is not redundant: it rounds the half-width against a unit
+ * magnitude, which moves the answer on most shapes.
+ */
+export declare function normalConfidence(alpha: number, standardDev: number, size: number): number;
+/** The same half-width from Student's t on `size - 1` degrees of freedom. */
+export declare function studenttConfidence(alpha: number, standardDev: number, size: number): number;
+//# sourceMappingURL=Distributions.d.ts.map

package/types/src/_utils/Errors.d.ts

@@ -1,23 +1,4 @@
-import { IRange, Scalar } from '@sheetxl/primitives';
-/**
- * Throws the first error member (row-major) — the in-body form of the engine's reject scan,
- * for functions that cannot use the engine's reject default. Call it once per range, in
- * ARGUMENT order, where a function takes several.
- *
- * Three reasons a function ends up here:
- * * its policy depends on a runtime argument (SUBTOTAL/AGGREGATE options),
- * * or on which rows matched (the database family),
- * * or one of its own verdicts OUTRANKS a member error, so the scan has to run after that check
- *   rather than before the body. The count mismatch is the one that does this
- *   (`CHISQ.TEST(<3 cells with an error>, <2 cells>)` is `#N/A`, not the error — the same rule
- *   the SUMX2MY2 family and `PROB` follow); every other validation loses to the error and needs
- *   no in-body scan at all.
- *
- * Those parameters declare `AcceptError` to keep the engine's reject default off; everything
- * with a static reject policy needs no marker at all. Callers hand UNTYPED ranges, so the read
- * is already raw.
- */
-export declare function throwFirstErrorMember(range: IRange): void;
+import { Scalar } from '@sheetxl/primitives';
 /**
  * Wraps a value-aggregating reduce callback (SUMIF / AVERAGEIF / MAXIFS / …) so an error in a
  * MATCHED member becomes the whole result, while a non-matched one stays invisible.

package/types/src/_utils/FirstCell.d.ts

@@ -0,0 +1,32 @@
+import { IRange, Scalar } from '@sheetxl/primitives';
+/**
+ * The answer for a CONTAINER at a slot that reads a multi-cell REFERENCE by its FIRST CELL while
+ * an array constant still answers per member — `N` and `T`.
+ *
+ * @remarks
+ * `T(AF1:AF3)` is `"alpha"` and stays a scalar —
+ * `ROWS` of it is 1 and `INDEX(…,2,1)` is `#REF!` — while `T({"alpha";"bravo"})` spills 2x1. Both
+ * names declare `IRange | Scalar`, so a value and a ONE-CELL reference never reach here (the
+ * marshaller dereferences them at the scalar arm, errors included); what arrives is a container,
+ * and only its KIND separates the two readings.
+ *
+ * `paramIndex` is the slot the kind is asked about — 0 for both of today's callers.
+ *
+ * An error at the first cell of a multi-cell reference propagates here, which is what a one-cell
+ * reference does (`T(<#N/A cell>)` is `#N/A`).
+ */
+export declare const readFirstOrMembers: <T extends Scalar>(container: IRange, read: (value: Scalar) => T, paramIndex?: number) => T;
+/**
+ * The one cell a multi-cell REFERENCE reads as at a slot Excel declares a plain VALUE.
+ *
+ * @remarks
+ * The choice is the call's implicit-intersection MODE: in VALUE
+ * mode the cell the formula's own row and column select — the `@` rule on both axes, `#VALUE!`
+ * when the formula cell lies outside the range — and in ARRAY mode the first cell. A one-cell
+ * reference is its own cell in either mode.
+ *
+ * `LeastSquares.readOneCell` in `@sheetxl/formulas-extended` is the same rule; the two packages
+ * share only `@sheetxl/primitives`, which is why there are two copies rather than one import.
+ */
+export declare const readIntersectedCell: (range: IRange) => Scalar;
+//# sourceMappingURL=FirstCell.d.ts.map

package/types/src/_utils/Matrix.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The elimination behind MDETERM and MINVERSE — LU with partial pivoting, and no tolerance
+ * anywhere in it.
+ *
+ * The determinant of a SINGULAR matrix is what makes the algorithm visible rather than a matter
+ * of taste: Excel answers 6.661338147750939E-16 for `MDETERM({1,2,3;4,5,6;7,8,9})`, exactly 0 for
+ * its transpose, and the same residue negated when its first two rows are swapped. Those are the
+ * numbers the elimination leaves; a body that cuts a small pivot to zero can produce none of
+ * them, and one without pivoting produces a different residue again.
+ *
+ * The inverse is this same decomposition followed by a forward and back SUBSTITUTION per unit
+ * column. Gauss-Jordan over `[A | I]` — the textbook alternative — gives different answers on
+ * the same matrices.
+ */
+/**
+ * The determinant, as the signed product of the pivots.
+ *
+ * The product is a multiplication, so it carries the two rules Excel's multiplying operators do:
+ * a subnormal flushes to zero (`MDETERM({1E-160,2E-160;3E-160,4E-160})` is 0, not 2E-320) and an
+ * overflow is `#NUM!` rather than an infinity, which is what `NaN` means to the caller.
+ */
+export declare const determinant: (m: readonly (readonly number[])[]) => number;
+/**
+ * The inverse, one unit column at a time. `null` when a pivot was zero — the caller's `#NUM!`.
+ *
+ * The substitution subtracts term by term rather than accumulating a sum and subtracting once;
+ * the two differ in the last bit wherever the terms cancel, and only the first reproduces
+ * Excel's `MINVERSE({1,2;3,4})`, which is not the exact `[[-2,1],[1.5,-0.5]]`.
+ */
+export declare const invert: (m: readonly (readonly number[])[]) => number[][] | null;
+//# sourceMappingURL=Matrix.d.ts.map