@sheetxl/formulas-extended 0.8.0-beta.1 → 0.8.0-beta.10

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

@@ -23,4 +23,28 @@ export declare function isMoreThanOneYearAfter(startSerial: number, endSerial: n
  * `setMonth` which truncates automatically.
  */
 export declare function dateAddMonths(date: Date, months: number): Date;
+/**
+ * Calendar fields of a serial date. `m` is 1-based.
+ */
+export interface DateFields {
+    y: number;
+    m: number;
+    d: number;
+}
+/** Days in month `m` (1-based), on the real Gregorian calendar. */
+export declare const daysInMonth: (y: number, m: number) => number;
+/** True when `x` is the last day of its month. */
+export declare const isMonthEnd: (x: DateFields) => boolean;
+/** The workbook calendar's fields for a serial. */
+export declare function getDateFields(serial: number): DateFields;
+/**
+ * The serial of calendar fields, extended linearly BELOW the calendar (1899-12-31 is 0, and on
+ * down) and with a day past the month's end OVERFLOWING into the next month — a "Feb 30" is
+ * Mar 1. The coupon chains that walk off either end of the calendar are measured against Excel
+ * on those extended values, so they need an arithmetic that keeps producing them
+ * (fn-battery financial/ACCRINT and /ODDLPRICE).
+ */
+export declare function getSerialOfFields(y: number, m: number, d: number): number;
+/** The fields `months` months on from `x`, the day clamped to the destination month. */
+export declare function addMonthsClamped(x: DateFields, months: number): DateFields;
 //# sourceMappingURL=FinanceDate.d.ts.map

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

@@ -77,4 +77,50 @@ export declare function getDayCount(startSerial: number, endSerial: number, basi
  *
  */
 export declare function getDays360US(startSerial: number, endSerial: number): number;
+/** The last serial of the 1900 calendar (9999-12-31). */
+export declare const MAX_SERIAL_DATE = 2958465;
+/**
+ * Excel's date-slot domain for the day-count family, measured on DAYS360, YEARFRAC, DATEDIF
+ * and the six coupon functions (fn-battery financial/*, 2026-08-28): the RAW value must not be
+ * negative (`-1E-9` is #NUM!) and the truncated serial must not pass 9999-12-31 (`2958465.9` is
+ * a legal 9999-12-31). The fraction is otherwise discarded by every function in the family.
+ */
+export declare function isSerialDateInRange(serial: number): boolean;
+/**
+ * `YEARFRAC` — measured against Excel 16.0 (fn-battery financial/YEARFRAC, 2026-08-28). Both
+ * serials are truncated first, the earlier date becomes the start, and basis 0 is then the
+ * SIGNED NASD count: Excel orders the dates but never takes a magnitude, so
+ * `YEARFRAC(59,60,0)` — 1900-02-28, a real month end, against the phantom 1900-02-29 that is
+ * not — is `-1/360`. The other bases cannot go negative once ordered. The caller has validated
+ * the serials and the basis.
+ */
+export declare function getYearFrac(startSerial: number, endSerial: number, basis: number): number;
+/**
+ * The years to maturity a bond-yield ITERATION starts from — not `YEARFRAC`, and not the coupon
+ * count over the frequency. Whole years are stepped off the settlement (the day clamped to each
+ * destination month) and the remainder is the basis's own day count over the basis's year: the
+ * 30/360 counts over 360 at bases 0 and 4, real days over 360 at basis 2 and over 365 at basis 3,
+ * and real days over the MATURITY'S OWN year at basis 1 — 366 out of a leap year, whatever the
+ * remainder itself covers. Basis 0's February here is the LEGACY calendar's: a Feb 29 start is a
+ * month end and a Feb 28 is not, which is neither `getDayCount`'s rule (the real calendar's month
+ * end, so Feb 28 counts too) nor `getDays360US`'s (which also lets the conversion steer the end).
+ *
+ * Measured on 1,154 rows where the answer depends on nothing else (fn-battery
+ * financial/adhoc-yield-n, -n2, -n3), 2026-09-09.
+ *
+ * Used by: YIELD, ODDFYIELD.
+ */
+export declare function getYearsToMaturity(settlement: number, maturity: number, basis: number): number;
+/**
+ * The stub-period day count of AMORLINC/AMORDEGRC (the year fraction is `days / yearDays`, and
+ * the caller groups that as Excel does) — measured against Excel 16.0 (fn-battery
+ * financial/AMORLINC, /AMORDEGRC, 2026-08-28), and NOT YEARFRAC's: serials are truncated, the
+ * 30/360 bases count days as `getDayCount` does over 360, basis 3 is actual days over 365, and
+ * basis 1 is actual days over the length of the PURCHASE year (366 only when that year is a
+ * Gregorian leap year — 1900 is not — whatever the span crosses; 2007-12-31 → 2008-12-31 is
+ * 366/365), and in both actual bases a real Feb 29 counts as the 28th (`_feb29AsFeb28`). A zero-day stub is a whole period (`purchase = first period`, or Dec 30 → Dec 31
+ * at basis 0), and a stub longer than a year is not capped. Basis 2 is not accepted by either
+ * function; the caller has refused it before this is called.
+ */
+export declare function getAmorDayCount(purchased: number, firstPeriod: number, basis: number): DayCount;
 //# sourceMappingURL=FinanceDayCount.d.ts.map

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

@@ -0,0 +1,93 @@
+import { Omittable, Scalar } from '@sheetxl/primitives';
+/**
+ * The odd-coupon securities' shared machinery — the quasi-coupon chain of an irregular period
+ * and the day-count sums the price and yield forms are built from, measured against Excel 16.0
+ * (fn-battery financial/ODDLPRICE + /ODDLYIELD + /ODDFPRICE and the `adhoc-oddl-*` /
+ * `adhoc-oddf-*` probes, 2026-08-28/29).
+ */
+/**
+ * `(settlement, maturity, …dates, …numbers, frequency, [basis])` as the four ODD functions read
+ * it: every slot is Excel-declared `any` (a boolean is #VALUE!, an empty argument #N/A, a blank
+ * cell 0, a multi-cell reference does not broadcast — `NoLift<>` on every slot), and the order is
+ * coupon six's, not PRICE's. Each DATE is coerced and range-checked as it is read, so a negative
+ * `last_interest` is #NUM! over a text frequency; then the numbers are coerced; then the
+ * frequency is validated (1, 2 or 4 after truncation); then the BASIS, last. Only after all of
+ * that do the date ORDER and the signs decide — a text frequency beats a settlement that is
+ * after its maturity. Serials come back truncated.
+ */
+export declare function readOddArgs(dates: Omittable<Scalar>[], numbers: Omittable<Scalar>[], frequency: Omittable<Scalar>, basis: Omittable<Scalar>): {
+    dates: number[];
+    numbers: number[];
+    frequency: number;
+    basis: number;
+};
+/**
+ * The three day-count sums of the odd LAST period `[lastInterest, maturity]`, in coupon-period
+ * units — the numbers ODDLPRICE and ODDLYIELD are built from. Measured on 1,780
+ * (shape, frequency, basis) triples, each sum exact (`fn-battery/financial/fit-oddl.mjs`).
+ *
+ * It takes TWO chains, as COUPDAYS' basis 1 did (batch 3): the DECAYING chain anchored at
+ * `lastInterest` gives the period ends and their lengths, while the STICKY chain decides only
+ * which period the maturity lands in — so an Aug 31 maturity against a decayed Aug 28 boundary
+ * is still inside the period that ENDS there and overhangs it by three days.
+ *
+ * Over the periods `[B₀ = lastInterest, B₁] … [B_{J−1}, B_J]`:
+ *
+ * - `A` and `DSC` walk their span (`lastInterest → settlement`, `settlement → maturity`) period
+ *   by period, no period contributing more than itself — a 31st period end counted raw runs one
+ *   day past its own length.
+ * - `DC` counts every period 1 except the last, which is measured BACKWARD from its end,
+ *   `(NL − count(maturity, B_J)) / NL`. That is what makes `DC ≠ A + DSC` at basis 0.
+ *
+ * A chain that leaves the calendar is #NUM!: past its end going forward, and — stepping BACK
+ * from the MATURITY to the first date at or below `lastInterest` — below serial 1 going back
+ * (measured: a ladder landing on serial 1 computes, one landing on serial 0 is #NUM!).
+ */
+export declare function oddLastSums(settlement: number, maturity: number, lastInterest: number, frequency: number, basis: number): {
+    A: number;
+    DC: number;
+    DSC: number;
+};
+/**
+ * The numbers ODDFPRICE's form is built from — `N` regular coupons after `firstCoupon`, the
+ * accrued sum `A` and the first coupon's sum `DC` (both in coupon-period units), and `u`, the
+ * fractional exponent every cash flow after the settlement is discounted by. Measured on 1,125
+ * (shape, frequency, basis) triples, the four sums solved out of Excel by linearity
+ * (`fn-battery/financial/oddf-model.mjs`, `verify-oddf.mjs`, `adhoc-oddf-*`, 2026-08-29).
+ *
+ * The maturity must sit on `firstCoupon`'s grid — `COUPPCD(firstCoupon, maturity) = firstCoupon`
+ * — and the doc's two branches are real, on DIFFERENT date machinery. `E` is the regular period
+ * around the settlement on that grid, PRICE's {@link couponPeriod} (`COUPDAYBS + COUPDAYSNC` at
+ * basis 1); `DFC` the basis's count issue → firstCoupon:
+ *
+ * - `DFC = E` is #NUM! — an odd period that is exactly a regular one.
+ * - SHORT (`DFC < E`): one period, every count over `E` — `A = issue→settlement`, `DC = DFC`,
+ *   `u = settlement→firstCoupon`, the last straight from the settlement (the NASD advance
+ *   included). `N` is `COUPNUM(settlement, maturity) − 1`, which counts a grid date between the
+ *   settlement and the first coupon when there is one (a settlement in the gap between a
+ *   decayed boundary and its sticky twin).
+ * - LONG (`DFC > E`): `COUPNUM(issue, firstCoupon)` quasi periods on the STICKY grid, their
+ *   boundaries walked DECAYED back from `firstCoupon` (each step subtracts `12/f` months from
+ *   the previous date and clamps: an Aug 31 anchor semiannual is Feb 28, then Aug 28) — so the
+ *   earliest period can end at or before the issue and count nothing. `NL` is each period's
+ *   own actual span at basis 1, `360/f` or `365/f` elsewhere; `A` walks issue → settlement as
+ *   days over `NL`; `DC` is the issue's period as days over `NL` and every later period exactly
+ *   1 (the doc's DCᵢ — visible at bases 2 and 3). The exponent `u = Nq + DSC/E` is on the
+ *   sticky grid instead: `DSC = E − COUPDAYBS` at bases 0/1/4 and the actual days to the next
+ *   grid date at 2/3, and `Nq` is `COUPNUM(settlement, firstCoupon) − 1` PLUS ONE on a
+ *   month-end first coupon — Excel discounts every cash flow one period too far — unless the
+ *   settlement is itself a month end or its month holds an earlier quasi-coupon date
+ *   (`adhoc-oddf-nq`, 957 settlements swept day by day).
+ *
+ * A chain that walks below the calendar is #NUM! in either branch (a settlement in the first
+ * days of 1900 has quasi dates in 1899).
+ */
+export declare function oddFirstSums(settlement: number, maturity: number, issue: number, firstCoupon: number, frequency: number, basis: number): {
+    N: number;
+    A: number;
+    DC: number;
+    u: number;
+};
+/** The ATP arithmetic of the family: a product that overflowed is 0 (batch 4's `overflowIsZero`). */
+export declare const zeroIfOverflow: (value: number) => number;
+//# sourceMappingURL=FinanceOdd.d.ts.map

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

@@ -0,0 +1,84 @@
+import { Omittable, Scalar } from '@sheetxl/primitives';
+/**
+ * Argument readers for the securities functions — every slot Excel-declared `any`, read in the
+ * order Excel reads them (measured against Excel 16.0, fn-battery financial/*, 2026-08-28).
+ *
+ * Two orders exist in the family. The discount securities (DISC PRICEDISC YIELDDISC INTRATE
+ * RECEIVED) CONVERT from the last slot to the first and only then look for errors in slot
+ * order; ACCRINTM, ACCRINT and the coupon functions convert and validate each slot from the
+ * first. Each function names its own.
+ */
+/** The basis slot: omitted or blank is 0, text parses, a boolean is #VALUE!, out of 0–4 after truncation is #NUM!. */
+export declare function readBasis(basis: Omittable<Scalar>): number;
+/** The two dates of a security, truncated, both in the calendar and the settlement strictly first — else #NUM!. */
+export declare function checkDateOrder(settlement: number, maturity: number): {
+    settlement: number;
+    maturity: number;
+};
+/**
+ * `(settlement, maturity, x, y, [basis])` as DISC, PRICEDISC, YIELDDISC, INTRATE and RECEIVED
+ * read it: the basis FIRST — coerced and range-checked, so a text basis is #VALUE!, a basis of 5
+ * is #NUM! and an error there is the answer whatever an earlier slot holds — then the four
+ * slots from the first, each coerced (its error or a text answered) before the next is read;
+ * then the domain: serials in the calendar, `settlement < maturity` once truncated, `x > 0`,
+ * `y > 0`. An omitted required slot is #N/A, a blank cell 0.
+ */
+export declare function readDiscountArgs(settlement: Omittable<Scalar>, maturity: Omittable<Scalar>, x: Omittable<Scalar>, y: Omittable<Scalar>, basis: Omittable<Scalar>): {
+    settlement: number;
+    maturity: number;
+    x: number;
+    y: number;
+    basis: number;
+};
+/**
+ * `(settlement, maturity, x)` as TBILLEQ, TBILLPRICE and TBILLYIELD read it: each slot coerced
+ * from the first (an error or a text is answered before the next slot is read, so a text `x`
+ * beats swapped dates), then the domain: both serials in the calendar, `settlement < maturity`
+ * once truncated, the maturity at most one calendar year out ({@link _anniversary}), `x > 0`.
+ * `days` is the actual span of the truncated serials.
+ */
+export declare function readTbillArgs(settlement: Omittable<Scalar>, maturity: Omittable<Scalar>, x: Omittable<Scalar>): {
+    settlement: number;
+    maturity: number;
+    x: number;
+    days: number;
+};
+/**
+ * `(settlement, maturity, issue, rate, x, [basis])` as PRICEMAT and YIELDMAT read it: the basis
+ * first (coerced and range-checked, so a text basis is #VALUE! and a basis of 5 #NUM! whatever
+ * the other slots hold, and an error there wins), then the five slots from the first, each
+ * coerced before the next is read; then the domain — every serial in the calendar,
+ * `issue < settlement < maturity` once truncated, and the signs the caller checks. The three
+ * day counts come back with `DSM` as `DIM − A`, which is how Excel has it: at basis 0 a Feb 28
+ * settlement against a Mar 31 maturity counts 32 days inside a Jan 31 issue (60 − 28), where
+ * the NASD count of the pair alone is 31. `B` is the year length of the issue→settlement pair.
+ */
+export declare function readMatArgs(settlement: Omittable<Scalar>, maturity: Omittable<Scalar>, issue: Omittable<Scalar>, rate: Omittable<Scalar>, x: Omittable<Scalar>, basis: Omittable<Scalar>): {
+    rate: number;
+    x: number;
+    DIM: number;
+    DSM: number;
+    A: number;
+    B: number;
+};
+/**
+ * `(settlement, maturity, …numbers, frequency, [basis])` as PRICE, YIELD, DURATION and
+ * MDURATION read it (measured on all four, fn-battery 2026-08-28). PRICE and YIELD read the
+ * basis FIRST — coerced and range-checked, so a text basis is #VALUE! and a 5 is #NUM! whatever
+ * else is wrong, and an error there wins over an error in the settlement; DURATION and
+ * MDURATION read it LAST (`basisLast`), the coupon functions' way. In between, the settlement
+ * and the maturity are each coerced and checked against the calendar before the next slot is
+ * read (a negative settlement is #NUM! over a text frequency), then the numeric slots are
+ * coerced, then the frequency is coerced and validated (1, 2 or 4 after truncation); the date
+ * order (`settlement < maturity` once truncated) and the signs of the numbers come last.
+ */
+export declare function readBondArgs(settlement: Omittable<Scalar>, maturity: Omittable<Scalar>, numbers: Omittable<Scalar>[], frequency: Omittable<Scalar>, basis: Omittable<Scalar>, basisLast?: boolean): {
+    settlement: number;
+    maturity: number;
+    numbers: number[];
+    frequency: number;
+    basis: number;
+};
+/** Excel's Analysis-ToolPak arithmetic answers 0 for a product that overflowed (measured on ACCRINTM, TBILLEQ, TBILLPRICE, PRICEMAT). */
+export declare const overflowIsZero: (value: number) => number;
+//# sourceMappingURL=FinanceSecurity.d.ts.map

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

@@ -1,4 +1,25 @@
 import { IRuntime } from '@sheetxl/primitives';
+/**
+ * The secant step cap shared by RATE and IRR — Excel gives up after 200, not the documented 20
+ * (measured on one 24-period loan: a path of 200 steps converges, one of 203 is #NUM!). IRR runs
+ * the same iteration on the discount factor rather than the rate, so the cap is one fact.
+ */
+export declare const RATE_MAX_ITERATIONS = 200;
+/**
+ * The currency format Excel gives a financial result cell, in the runtime's locale.
+ *
+ * @remarks
+ * Which functions auto-format is a per-function fact and was MEASURED across the category
+ * (2026-08-29, `Range.NumberFormat` read after a `Formula2` entry into a General cell): the
+ * legacy core formats by result kind — money through this helper (NPV PMT IPMT PPMT FV PV SLN
+ * SYD DB DDB VDB) and a rate as `0%` (IRR MIRR RATE) — while everything ATP-era or added later
+ * sets nothing at all (XIRR XNPV NPER ISPMT RRI PDURATION EFFECT NOMINAL FVSCHEDULE CUMIPMT
+ * CUMPRINC and every security, COUPNCD and COUPPCD included).
+ *
+ * Excel applies it at ENTRY, before it knows the answer, so a `#NUM!`, `#VALUE!` or `#DIV/0!`
+ * cell carries the format too. That is why every `formatResults` call in this category LEADS its
+ * body instead of following the domain guards.
+ */
 export declare const defaultCurrencyFormat: (runtime: IRuntime) => string;
 /**
  * `base ^ exponent` as Excel evaluates it (the `^` operator, POWER, and the powers inside the
@@ -14,7 +35,22 @@ export declare const defaultCurrencyFormat: (runtime: IRuntime) => string;
  * on the sensitive rows (`FV(1E-15,12.5,…)` is 2 digits on `Math.pow`, exact here), and equal to
  * it everywhere else measured.
  *
- * A zero base follows the `^` operator: `0^0` is #NUM! and `0^negative` is #DIV/0!.
+ * A zero base follows the `^` operator: `0^0` is #NUM! and `0^negative` is #DIV/0!. So does a
+ * negative base under a fractional exponent: real only when the exponent's reciprocal, read at 15
+ * significant digits, is an odd integer — `FV(-3,1/3,1)` is -0.7533 — and #NUM! otherwise.
  */
 export declare const excelPow: (base: number, exponent: number) => number;
+/**
+ * Excel's C `(int)` cast of an argument: truncation toward zero, and INT_MIN for anything out of
+ * the 32-bit range (the x64 `cvttsd2si` convention), NaN included. Measured on DB (fn-battery,
+ * 2026-08-28): `DB(…,3E9,2E9)` is #NUM! because only `life` overflows to INT_MIN while
+ * `DB(…,1E10,5E9)` is 0 because both do.
+ */
+export declare const excelInt32: (value: number) => number;
+/**
+ * Round to `digits` decimals as Excel's ROUND does: ties away from zero, decided on the value's
+ * 15-significant-digit decimal form rather than its binary one — `550 · 0.45` is
+ * 247.49999999999997 in double and Excel rounds it to 248 (AMORDEGRC, measured 2026-08-28).
+ */
+export declare const excelRound: (value: number, digits?: number) => number;
 //# sourceMappingURL=FinanceUtils.d.ts.map

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

@@ -1,4 +1,4 @@
-import { FormulaError, IRange } from '@sheetxl/primitives';
+import { FormulaError, IRange, IReferenceRange, Scalar } from '@sheetxl/primitives';
 /**
  * How Excel reads `known_y` / `known_x` into (observations x predictors).
  *
@@ -33,15 +33,22 @@ export interface RegressionData {
 /**
  * Reads `known_y` / `known_x` the way the whole LINEST family does.
  *
- * STRICT membership: any non-numeric member of either range — text, boolean, or BLANK — is
- * `#VALUE!`. There is no skipping and no coercion here (`LINEST({2;TRUE;5;4}, …)` and
- * `LINEST({2;"3";5;4}, …)` are both `#VALUE!`), which is the opposite of the paired statistics
- * (CORREL/SLOPE/…) where a non-numeric member drops its pair. Dropping a member here would shift
- * every later observation against its x and silently return a different fit.
+ * The SHAPES are judged first — a mismatch is #REF! whatever the members hold — and then the
+ * members, in order. Membership is STRICT: any non-numeric member of either range — text,
+ * boolean, or BLANK — is `#VALUE!`. There is no skipping and no coercion here
+ * (`LINEST({2;TRUE;5;4}, …)` and `LINEST({2;"3";5;4}, …)` are both `#VALUE!`), which is the
+ * opposite of the paired statistics (CORREL/SLOPE/…) where a non-numeric member drops its pair.
+ * Dropping a member here would shift every later observation against its x and silently return a
+ * different fit.
  *
- * @throws #VALUE! on a non-numeric member, #REF! on a dimension mismatch.
+ * `log` is the LOGEST/GROWTH read: each y is checked as it is met, so a y at or below zero is
+ * #NUM! even when a text member sits later in the range, and the ys come back as their logarithms.
+ *
+ * @throws #VALUE! on a non-numeric member, #REF! on a dimension mismatch, #NUM! on a y without a
+ * logarithm.
  */
-export declare const readRegressionData: (knownYs: IRange, knownXs: IRange | undefined) => RegressionData;
+export declare const readRegressionData: (knownYs: IRange, knownXs: IRange | undefined, log?: boolean) => RegressionData;
+export declare const overLogical: (value: boolean | IReferenceRange | IReferenceRange[] | null | undefined, absent: boolean, compute: (value: boolean) => Scalar[][]) => Scalar[][];
 /**
  * Reads a `new_x` range into (observations x k), and reports the shape its predictions spill into.
  *
@@ -57,15 +64,6 @@ export declare const readNewX: (newXs: IRange, data: RegressionData) => {
     rows: number;
     cols: number;
 };
-/**
- * `ln(y)` for the log-space members of the family (LOGEST / GROWTH).
- *
- * A y at or below zero has no logarithm, and Excel reports that as #NUM! — a distinct outcome from
- * the #VALUE! a non-numeric member gets, so the two checks stay separate.
- *
- * @throws #NUM! when any y is <= 0.
- */
-export declare const toLogYs: (ys: number[]) => number[];
 /**
  * Evaluates a fit over `new_x`, in the shape Excel spills.
  *
@@ -73,7 +71,7 @@ export declare const toLogYs: (ys: number[]) => number[];
  * the fitted values, so a 6x2 `known_y` spills 6x2. Otherwise the shape comes from `new_x`
  * ({@link readNewX} decides whether that is element-wise or one row/column per observation).
  */
-export declare const predictInShape: (data: RegressionData, newXs: IRange | undefined, predict: (x: number[]) => number) => number[][];
+export declare const predictInShape: (data: RegressionData, newXs: IRange | undefined, predict: (x: number[]) => Scalar) => Scalar[][];
 /** A fitted model — coefficients in Excel's slot order plus everything the stats grid needs. */
 export interface RegressionFit {
     /**
@@ -81,11 +79,11 @@ export interface RegressionFit {
      * belongs to the LAST column of `known_x`.
      */
     coefficients: number[];
-    /** Standard errors in the same slot order. `se[k]` is meaningless when `!useConst` (Excel: #N/A). */
+    /** Standard errors in the same slot order. `se[k]` is meaningless when `!constant` (Excel: #N/A). */
     standardErrors: number[];
     /** Number of predictors actually used — a column dropped for rank deficiency does not count. */
     kEffective: number;
-    /** `n - kEffective - (useConst ? 1 : 0)`. */
+    /** `n - kEffective - (constant ? 1 : 0)`. */
     df: number;
     /** Standard error of the y estimate. 0 when `df <= 0`, which is what Excel returns. */
     sey: number;
@@ -111,7 +109,7 @@ export interface RegressionFit {
  * The same path covers "not enough observations": with n = 2 and 2 predictors the second column
  * has no residual left and is dropped, which is exactly what Excel returns.
  */
-export declare const fitLeastSquares: (ys: number[], xs: number[][], useConst: boolean) => RegressionFit;
+export declare const fitLeastSquares: (ys: number[], xs: number[][], constant: boolean) => RegressionFit;
 /**
  * The `stats = TRUE` grid: 5 rows x (k + 1) columns.
  *
@@ -127,5 +125,5 @@ export declare const fitLeastSquares: (ys: number[], xs: number[][], useConst: b
  * `se(b)` when the intercept was not fitted — the b slot itself still carries a value (0 for
  * LINEST, 1 for LOGEST), it is only its error that is #N/A.
  */
-export declare const buildStatsGrid: (fit: RegressionFit, coefficients: number[], useConst: boolean) => (number | FormulaError.Known)[][];
+export declare const buildStatsGrid: (fit: RegressionFit, coefficients: (number | FormulaError.Known)[], constant: boolean) => (number | FormulaError.Known)[][];
 //# sourceMappingURL=LeastSquares.d.ts.map

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

@@ -0,0 +1,205 @@
+import { FormulaError, IFormulaContext, IFunction, IRange, Scalar } from '@sheetxl/primitives';
+/**
+ * One aggregate column: a function applied to one value column.
+ */
+export interface Measure {
+    readonly fn: IFunction;
+    /** The value column it reads. */
+    readonly column: number;
+    /** Called with `(x, y)` rather than `(x)` — see {@link aggregate}. */
+    readonly twoArgs: boolean;
+    /** What the function-name row shows. */
+    readonly label: string;
+}
+/**
+ * The function argument, resolved.
+ */
+export interface Functions {
+    /** One per output column (or, when `vertical`, one per output row of each group). */
+    readonly measures: Measure[];
+    /** The functions were a column (`VSTACK(SUM,COUNT)`): each group gets one row per function. */
+    readonly vertical: boolean;
+    /** More than one function — a row or column names them. */
+    readonly named: boolean;
+}
+/**
+ * Resolves the function argument against the value columns, or answers the whole call's error.
+ *
+ * @remarks
+ * A row of functions is one column per function, a column of them one row per function (a13, a14),
+ * and a 2-D block is refused (a15). Functions pair with value columns one to many, many to one, or
+ * one to one (a37, a38, a42). A function that cannot take one argument, or needs more than two, is
+ * refused up front (a23, a24, a43) — the call shape is decided before any group runs.
+ */
+export declare const resolveFunctions: (fn: any, valueColumns: number) => Functions | FormulaError.Known;
+/**
+ * Applies a measure to a group's members.
+ *
+ * @remarks
+ * `y` is every kept value of the column, and only a function that REQUIRES two arguments gets it
+ * (`PERCENTOF`, `LAMBDA(x,y,…)`; a20–a22). An array result, a 1×1 included, is `#VALUE!` for that
+ * cell (a25, r05, r06); a single-cell reference reads as its value, and an error — returned or
+ * thrown — is just the cell's value.
+ */
+export declare const aggregate: (measure: Measure, x: IRange, y: () => IRange) => Scalar;
+/**
+ * How the first row is read — see {@link resolveHeaders}.
+ */
+export interface Headers {
+    /** The first row is a header, not data. */
+    readonly hasHeader: boolean;
+    /** A header row is output (the data's own, or generated). */
+    readonly show: boolean;
+}
+/**
+ * The `field_headers` argument, resolved; omitted, it is guessed from the values.
+ *
+ * @remarks
+ * 0: data; 1: header, hidden; 2: no header, generate one; 3: header, shown. Anything else is
+ * `#VALUE!` (b10, b11, b16).
+ *
+ * The guess is the one sort uses: a header when the first two rows hold values of different types
+ * in some value column (b01 has `"Sales"` over `10`, b08 has `"Product"` over `"Apple"`). Excel's
+ * own rule is not fully measured yet.
+ */
+export declare const resolveHeaders: (fieldHeaders: number | undefined, values: IRange) => Headers | FormulaError.Known;
+/**
+ * Validates a `total_depth` against the number of key fields.
+ *
+ * @remarks
+ * An integer no deeper than the fields (c04, c16, c20, c21); the sign puts totals first.
+ */
+export declare const isValidDepth: (depth: number, fieldCount: number) => boolean;
+/**
+ * One axis's sort: a direction per key level, or a sort by an aggregate.
+ */
+export interface SortSpec {
+    /** Per key level, 1 ascending or -1 descending. */
+    readonly keyDirections: number[];
+    /** Sort by an aggregate column: the measure's index and its direction. */
+    readonly byValue: {
+        readonly measure: number;
+        readonly direction: number;
+    } | null;
+}
+/**
+ * Parses a `sort_order` argument.
+ *
+ * @param valueColumns How many aggregate columns follow the keys; an index past the keys picks one.
+ *
+ * @remarks
+ * `±k` sorts key level `k`, or, past the keys, an aggregate column (d02, d05). Several indices must
+ * be distinct key levels, no more than there are (d09, d11, r12–r15). Zero, out of range, text, a
+ * fraction and a logical are `#VALUE!` (d07, d08, d16, d17, r24).
+ */
+export declare const resolveSort: (sortOrder: IRange | undefined, fieldCount: number, valueColumns: number) => SortSpec | FormulaError.Known;
+/**
+ * Whether `values` is one blank CELL — refused for the whole call (g16, g19).
+ *
+ * @remarks
+ * The rule `ARRAYTOTEXT` has for a lone blank: a reference to one empty cell is `#VALUE!`, while a
+ * blank KEY (g21), two blank cells (g18) or a blank array member are ordinary values.
+ */
+export declare const isLoneBlankCell: (values: IRange) => boolean;
+/**
+ * Validates a `filter_array` against the record count.
+ *
+ * @remarks
+ * One column as tall as the data, holding logicals and numbers only: an error or text anywhere is
+ * `#VALUE!` for the whole call (f06, f08), as is a shape mismatch (f03, f09, f11).
+ */
+export declare const isValidFilter: (filter: IRange, recordCount: number) => boolean;
+/**
+ * A group at one key level of an axis.
+ */
+export interface AxisNode {
+    /** The key level, 0 for the outermost field. */
+    readonly level: number;
+    /** The group within that level's grouping. */
+    readonly group: number;
+    /** The keys down to this level, as spelled by the group's first record. */
+    readonly keys: readonly Scalar[];
+    /** The group one level up, `null` at the outermost level. */
+    readonly parent: AxisNode | null;
+    readonly children: AxisNode[];
+}
+/**
+ * One output line of an axis: a group at the innermost level, a subtotal, or the grand total.
+ */
+export interface AxisLine {
+    readonly kind: 'group' | 'subtotal' | 'total';
+    /** `null` for the grand total. */
+    readonly node: AxisNode | null;
+}
+/**
+ * One axis of groups — `GROUPBY`'s rows, or either side of `PIVOTBY`.
+ *
+ * @remarks
+ * Each key level has its own grouping, over the key columns down to it, so a subtotal's members are
+ * one group of that grouping rather than a union of its children's. A level's parent is read
+ * through its first record (`getFirstRecord`/`getGroup`).
+ */
+export declare class PivotAxis {
+    readonly fieldCount: number;
+    /** Per key level, the grouping over the key columns down to it. */
+    readonly groupings: IFormulaContext.Grouping[];
+    /** Per key level, the key columns down to it. */
+    readonly prefixes: IRange[];
+    readonly roots: AxisNode[];
+    constructor(keys: IRange, filter: IRange | undefined);
+    /** The number of records kept. */
+    getRecordCount(): number;
+    /** A node's members of one value column. */
+    getMembers(values: IRange, node: AxisNode | null): IRange;
+    /**
+     * Orders the groups at every level.
+     *
+     * @param valueOf A node's aggregate, for a sort by value.
+     * @param table Field relationship 1: one flat order over the innermost groups (d18).
+     *
+     * @remarks
+     * Keys sort by the comparison operators' order — numbers, text, `FALSE`, `TRUE`, errors — with
+     * a blank key last in either direction (e01, e02). A sort by value orders each level by its own
+     * aggregate, parents by their subtotal (d05); ties keep key order (e06), and an error aggregate
+     * sorts last.
+     */
+    sort(spec: SortSpec, valueOf: (node: AxisNode) => Scalar, table: boolean): AxisNode[];
+    /**
+     * The output lines in order, with subtotals and the grand total placed per `depth`.
+     *
+     * @remarks
+     * `|depth|` 1 is the grand total alone; each step deeper adds subtotals for one more level from
+     * the top (c03, c13, c14). A negative depth puts every total before what it totals (c06, c15).
+     */
+    lines(roots: AxisNode[], depth: number): AxisLine[];
+    /**
+     * The key cells of a line: its keys, `""` past its level, and the total's label.
+     *
+     * @remarks
+     * A blank key shows as `0`, as Excel spills it (a01); padding is `""` (b09, c03). The grand total
+     * is `Grand Total` once subtotals show, `Total` otherwise (c02, c03).
+     */
+    keyCells(line: AxisLine, depth: number): Scalar[];
+}
+/**
+ * The generated header of key field `index` (0-based), for `field_headers` 2 (b04).
+ */
+export declare const generatedFieldLabel: (index: number) => string;
+/**
+ * The generated header of `PIVOTBY` column field `index` (0-based), for `field_headers` 2 (p43).
+ */
+export declare const generatedColumnFieldLabel: (index: number) => string;
+/**
+ * The generated header of value column `index` (0-based), for `field_headers` 2 (b04).
+ */
+export declare const generatedValueLabel: (index: number) => string;
+/**
+ * The columns of a range, one slice each — the same object every time it is asked for, which is
+ * what lets a grouping reuse its work on a value column.
+ */
+export declare const columnsOf: (range: IRange) => IRange[];
+/**
+ * A range without its first row — the data under a header.
+ */
+export declare const withoutFirstRow: (range: IRange) => IRange;
+//# sourceMappingURL=Pivot.d.ts.map

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

@@ -0,0 +1,33 @@
+import { FormulaError } from '@sheetxl/primitives';
+/** A compiled Excel pattern: the regex, and how many capture groups it has. */
+export interface CompiledPattern {
+    regex: RegExp;
+    groups: number;
+}
+/**
+ * Compiles one of Excel's patterns, or `#VALUE!` when neither reading of it will compile.
+ *
+ * The translated form is tried first, under `u`. A pattern that will not compile that way is
+ * retried EXACTLY AS WRITTEN and without `u` — that is the pre-translation reading, and it keeps
+ * the patterns that only `u`'s stricter escaping would have broken (`\-` outside a class) working.
+ */
+export declare const compilePattern: (pattern: string, caseInsensitive: boolean, extraFlags?: string) => CompiledPattern | FormulaError.Known;
+/**
+ * Excel's replacement text, as JavaScript's.
+ *
+ * The two languages nearly agree — `$1`, `$&`, `` $` `` and `$'` mean the same in both — and
+ * differ in three places: Excel's `$0` is the whole match (JavaScript spells that `$&`), its
+ * `${1}` and `${name}` are references where JavaScript reads them literally, and a reference to a
+ * group that does not exist is `#VALUE!` rather than literal text. That last one is why this
+ * returns an error instead of a string: `REGEXREPLACE("ab","(a)(b)","$3")` is refused by Excel,
+ * and so is a lone `$`.
+ */
+export declare const translateReplacement: (replacement: string, groups: number) => string | FormulaError.Known;
+/**
+ * Excel's 0-or-1 enum slots (`caseSensitivity`, and `returnMode`'s three values).
+ *
+ * Truncated first — 1.5 is 1 — and anything outside the list is `#VALUE!`, including a huge value
+ * and non-numeric text.
+ */
+export declare const readMode: (value: number, max: number) => number | FormulaError.Known;
+//# sourceMappingURL=RegexCompile.d.ts.map