@sheetxl/formulas-extended 0.8.0-beta.12 → 0.8.0-beta.14

package/{browser/esm/QPgwxV6CKVRfiMgU.mjs → node/esm/lPwbrKEbLIYzRLFP.mjs}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/formulas-extended - Formulas Enterprise - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.12
+* @license @sheetxl/formulas-extended - Formulas Enterprise - TypeScript formulas compatible with Excel built-ins. - 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.

package/node/esm/{CoiYUgAPry1qUyhB.mjs → shH8FSZ-wXbrxVx7.mjs}

@@ -1,5 +1,5 @@
 /**
-* @license @sheetxl/formulas-extended - Formulas Enterprise - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.12
+* @license @sheetxl/formulas-extended - Formulas Enterprise - TypeScript formulas compatible with Excel built-ins. - 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.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sheetxl/formulas-extended",
   "description": "Formulas Enterprise - TypeScript formulas compatible with Excel built-ins.",
-  "version": "0.8.0-beta.12",
+  "version": "0.8.0-beta.14",
   "license": "SEE LICENSE IN <LICENSE>",
   "type": "module",
   "exports": {
@@ -42,7 +42,7 @@
     "formulas"
   ],
   "dependencies": {
-    "@sheetxl/primitives": "^0.8.0-beta.12",
-    "@sheetxl/scripting": "^0.8.0-beta.12"
+    "@sheetxl/primitives": "^0.8.0-beta.14",
+    "@sheetxl/scripting": "^0.8.0-beta.14"
   }
 }

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

@@ -15,18 +15,6 @@ import { Scalar, Omittable } from '@sheetxl/primitives';
  * This package does not depend on that one, so the rule is duplicated rather than imported;
  * change both together.
  */
-/**
- * Reads a DATE argument declared `any`.
- *
- * Text is accepted in two steps, as `WEEKNUM` does it: numeric text is a SERIAL
- * (`EOMONTH("36556",0)` = 36556) and only non-numeric text goes to the date parser.
- * `parseAsSerialDate` supplies the refusal — `#VALUE!` for a boolean, whether it arrived as a
- * literal or as a cell, and an incoming error rethrown with its own identity.
- *
- * A blank CELL is serial 0. A genuinely empty SLOT is `#N/A` in Excel (`EOMONTH(,0)`,
- * `YEARFRAC(,39814)` — fn-battery financial/YEARFRAC, 2026-08-28); a parameter declared
- * `Omittable<Scalar>` sees that slot as `undefined` and reads it through {@link anyDateRequired}.
- */
 export declare function anyDate(value: Scalar): number;
 /**
  * A REQUIRED date parameter Excel declares `any` (`Omittable<Scalar>` on the declaration): an

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

@@ -1,32 +1,5 @@
 type IterFn = (x: number) => number;
-/**
- * The approximate yield a bond-yield iteration starts from: the annual coupon plus the pull to par
- * spread over `years`, against a denominator that is the mid-point of par and the price less a
- * `years`-scaled share of the same pull. At par it returns the coupon rate exactly, which is why
- * a bond priced at 100 answers in one step.
- *
- * `years` is {@link getYearsToMaturity}, never the coupon count over the frequency. Measured on
- * 1,154 rows of fn-battery financial/adhoc-yield-start, -n, -n2 and -n3 — bonds whose redemption
- * dwarfs the price, where a hundred Newton steps carry the start out to a number that inverts.
- *
- * Used by: YIELD, ODDFYIELD.
- */
 export declare function approximateYield(rate: number, pr: number, years: number): number;
-/**
- * Excel's bond-yield iteration: Newton on the price with its ANALYTIC slope, at most a hundred
- * steps from {@link approximateYield}, stopping the first time a step moves the yield by less than
- * `1e-5` and answering the iterate the step just produced — so the answer is a PARTIALLY converged
- * one, ~1e-10 from the root on an ordinary bond, and on a bond that cannot converge it is simply
- * where the walk stood after a hundred steps.
- *
- * A slope that overflows to infinity, or a step that lands where the price cannot be evaluated
- * (a `1 + y/f` at or below zero), is `NaN` — the caller's #NUM!.
- *
- * Measured on YIELD's 1,134-row battery and fn-battery financial/adhoc-yield-fingerprint,
- * -start, -n, -n2, -n3, -domain (2026-09-09).
- *
- * Used by: YIELD, ODDFYIELD.
- */
 export declare function solveYieldByNewton(start: number, priceFn: IterFn, slopeFn: IterFn): number;
 export {};
 /**

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

@@ -10,14 +10,5 @@ export interface AmorArgs {
     days: number;
     yearDays: number;
 }
-/**
- * The seven arguments of AMORLINC/AMORDEGRC — measured against Excel 16.0 (fn-battery
- * financial/AMORLINC, /AMORDEGRC, 2026-08-28). Every one is Excel-declared `any`, so they are
- * read here in declaration order, with the basis read AFTER the dates are validated (a reversed
- * date pair beats a text basis: `…, DATE(2008,12,31), DATE(2008,8,19), …, "x")` is #NUM!). The
- * serials truncate; the shared domain is `cost > 0`, `0 ≤ salvage ≤ cost`, `period ≥ 0`,
- * `rate > 0`, both dates in the calendar and in order, and a truncated basis of 0, 1, 3 or 4.
- * Returns `null` for #NUM!.
- */
 export declare function amorArgs(cost: Omittable<Scalar>, datePurchased: Omittable<Scalar>, firstPeriod: Omittable<Scalar>, salvage: Omittable<Scalar>, period: Omittable<Scalar>, rate: Omittable<Scalar>, basis: Omittable<Scalar>): AmorArgs | null;
 //# sourceMappingURL=FinanceAmor.d.ts.map

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

@@ -1,21 +1,4 @@
 import { IRange } from '@sheetxl/primitives';
-/**
- * The dated cash-flow operands of XNPV and XIRR, read the way Excel reads them (measured against
- * Excel 16.0, fn-battery financial/XNPV, 2026-08-29).
- *
- * @remarks
- * Both functions take two operands that are read TOGETHER, member by member, by flattened
- * row-major ordinal — a 3x1 pairs fully with a 1x3 and a 2x2 pairs with a 4x1
- * (DESIGN-RANGE-PAIRING). That makes the reading order a pair scan rather than a slot order, and
- * it is one pass that stops at the first fault: a bad ordinal 2 is answered before ordinal 3's
- * error is looked at.
- *
- * Ordinal 0 is not like the rest. Its DATE is read before its value (an error there wins over an
- * error in the first flow) and range-checked before either, and a member of EITHER operand that
- * is not a number is `#VALUE!` there where the same member at any later ordinal is `#NUM!` —
- * so a whole operand of numeric text, or of blanks, answers `#VALUE!` while one number among
- * them answers `#NUM!`.
- */
 export interface DatedFlows {
     /** The flow at each ordinal. */
     values: number[];

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

@@ -32,35 +32,7 @@ export declare function calculateCoupnum(settlementSerial: number, maturitySeria
  * basis 0, actual days for 1–3, the European 30/360 for 4.
  */
 export declare function calculateCoupdaybs(settlementSerial: number, maturitySerial: number, frequency: number, basis: number): number;
-/**
- * Days from settlement to the next coupon date (COUPDAYSNC). Actual days for bases 1–3. The
- * 30/360 bases are NOT `getDayCount`'s (measured, 556 of 556 rows): the count runs from the
- * settlement's own day — a 31 is 30, and a February month end is NOT 30 unless the
- * settlement IS the previous coupon date, in which case the coupon date's unclamped day is
- * read instead (`COUPDAYSNC(DATE(2011,2,28),DATE(2011,5,31),2,0)` is 92, from day 28;
- * `COUPDAYSNC(DATE(2011,2,28),DATE(2011,8,29),2,0)` is 179, from the chain's `Feb 29`) — to
- * the next coupon date carrying the maturity's day unclamped: at basis 0 a February day at or
- * past the month's end is 30 and a 31 is 30 with no advance into the next month; basis 4
- * caps both ends at 30.
- */
 export declare function calculateCoupdaysnc(settlementSerial: number, maturitySerial: number, frequency: number, basis: number): number;
-/**
- * Days in the coupon period that contains settlement (COUPDAYS). Basis 3 is `365/frequency`
- * and the 30/360 bases `360/frequency`. Basis 1 is Excel's own construction, measured on
- * 2,302 rows (fn-battery financial/COUPDAYS + adhoc-coupdays-b1 + adhoc-coupdays-sweep) and
- * NOT the next coupon minus the previous one (LibreOffice's reading; wrong on 30 of the
- * battery's 225 rows). Excel walks TWO chains back from maturity: one whose day of month
- * decays as it is clamped (`Aug 30 → Feb 29 → Aug 29 → Feb 28 → Aug 28`) and one that stays
- * on the month's last day once a clamp lands there (`Aug 30 → Feb 29 → Aug 31 → Feb 28 →
- * Aug 31`). The decaying chain is walked to the first date on or before the settlement; if
- * the coupon after that date is not the same date in both chains, the period is the decaying
- * chain's, otherwise it is the month-end chain's period around the settlement. So for a Nov 30
- * maturity paid twice a year a settlement of Dec 15 sits in `Nov 30 → May 30` (181) while a
- * settlement of May 30 sits in `Nov 30 → May 31` (182) and one of May 31 in `May 31 → Nov 30`
- * (183). A period that begins below serial 1 is counted in real days (`_periodDays`).
- *
- * Used by: COUPDAYS and {@link couponPeriod}.
- */
 export declare function calculateCoupdays(settlementSerial: number, maturitySerial: number, frequency: number, basis: number): number;
 /**
  * The four arguments of the six coupon functions, read in Excel's order — every one is
@@ -79,48 +51,13 @@ export declare function readCouponArgs(settlement: Omittable<Scalar>, maturity:
     frequency: number;
     basis: number;
 };
-/**
- * The coupon-period numbers PRICE, YIELD, DURATION and MDURATION are built on, as Excel
- * composes them (measured against Excel's own COUPNUM/COUPDAYBS/COUPDAYS/COUPDAYSNC answers on
- * 572 shapes, fn-battery financial/PRICE + /DURATION, 2026-08-28): `N` is COUPNUM (NaN, the
- * caller's #NUM!, when the previous coupon is below the calendar), `A` is COUPDAYBS, and the
- * period length `E` is COUPDAYS — EXCEPT at basis 1, where it is the real span from the
- * previous coupon to the next (`COUPDAYBS + COUPDAYSNC`), not COUPDAYS' two-chain value; the
- * two differ on the month-end and February maturities (22 of the 225 basis-1 shapes). `DSC` is
- * `E − A`, never COUPDAYSNC.
- */
 export declare function couponPeriod(settlementSerial: number, maturitySerial: number, frequency: number, basis: number): {
     N: number;
     A: number;
     E: number;
     DSC: number;
 };
-/**
- * Standard coupon bond price per $100 face value — the doc's closed form over
- * {@link couponPeriod}'s numbers: with one coupon left `(coupon + redemption) / (1 + DSC/E ·
- * yld/f) − coupon · A/E` (linear, not the power form), otherwise the redemption and each coupon
- * discounted by `(1 + yld/f)^(k − 1 + DSC/E)` less the accrued coupon. Measured bit-for-bit on
- * PRICE's battery (fn-battery financial/PRICE, 2026-08-28).
- *
- * The grouping is measured too, as ODDFPRICE's is: the coupon sum is accumulated on its own,
- * forward, then the redemption term is added to it and the accrued coupon subtracted. Starting
- * the accumulator at the redemption instead costs 146 of PRICE's 779 census rows and 74 of
- * YIELD's 785 (SXL_CENSUS over the financial suite, 2026-09-09) — the terms and the divisions
- * are identical either way, only the order the additions round in differs. It is visible in
- * YIELD because that answer is a PARTIAL iterate.
- *
- * Used by: PRICE, YIELD.
- */
 export declare function calculatePrice(settlementSerial: number, maturitySerial: number, rate: number, yld: number, redemption: number, frequency: number, basis: number): number;
-/**
- * `d/dy` of {@link calculatePrice}, term by term — the slope YIELD's Newton divides by. Analytic,
- * not a difference quotient: a finite difference of any step reproduces neither the hundred-step
- * answers of a redemption that dwarfs the price nor the partially-converged ones (fn-battery
- * financial/adhoc-yield-fingerprint, 2026-09-09). A term that overflows makes the slope infinite,
- * which the caller answers as #NUM!.
- *
- * Used by: YIELD.
- */
 export declare function calculatePriceSlope(settlementSerial: number, maturitySerial: number, rate: number, yld: number, redemption: number, frequency: number, basis: number): number;
 /**
  * Macaulay duration of a coupon bond.

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

@@ -37,13 +37,6 @@ export declare const daysInMonth: (y: number, m: number) => number;
 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;

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

@@ -42,85 +42,11 @@ export interface DayCount {
  *
  */
 export declare function getDayCount(startSerial: number, endSerial: number, basis: number): DayCount;
-/**
- * Calculates the DAYS360 US method — signed integer day count.
- *
- * @see {@link getDayCount} (specifically `_getNasd30_360`) for the correct basis 0
- * implementation used by financial formulas.
- *
- * @param startSerial The Excel serial date representing the start date.
- * @param endSerial The Excel serial date representing the end date.
- * @returns The signed number of days between the dates (negative if endSerial < startSerial).
- *
- * @remarks
- * **Implementation Note:** This function is strictly for the `DAYS360` formula.
- * It must NOT be used for standard financial functions like `YEARFRAC`, `ACCRINT`, or `PRICE`.
- *
- * It deliberately differs from the standard NASD 30/360 convention (basis 0) on two points,
- * both measured against Excel:
- *
- * 1. The February End-of-Month conversion (startDay → 30) CASCADES into the end-day rule.
- *    Feb 28 to Mar 31 in 2011 is 30 days here and 31 days under basis 0.
- * 2. End-of-February is decided on the LEGACY calendar — the day after the start falls in
- *    March — where basis 0 asks the REAL calendar. The two disagree only across the phantom
- *    `1900-02-29`: `DAYS360(59,91)` is 33 and `DAYS360(60,91)` is 30, while the same pairs
- *    under basis 0 are 31/360 and 32/360.
- *
- * The arguments are NOT swapped into order first. `DAYS360` is not antisymmetric — the rules
- * apply to (start, end) as given, so `DAYS360(3/15, 3/31)` is 16 but `DAYS360(3/31, 3/15)`
- * is −15, and `DAYS360(43496, 0)` is −42870 against `DAYS360(0, 43496)` = 42871.
- *
- * We replicate Excel's exact behavior, which utilizes different 30/360 rulesets
- * for DAYS360 vs. NASD-based functions.
- *
- * https://en.wikipedia.org/wiki/Day_count_convention
- *
- */
 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

@@ -1,10 +1,4 @@
 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
@@ -21,67 +15,11 @@ export declare function readOddArgs(dates: Omittable<Scalar>[], numbers: Omittab
     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;

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

@@ -1,13 +1,4 @@
 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!. */
@@ -61,17 +52,6 @@ export declare function readMatArgs(settlement: Omittable<Scalar>, maturity: Omi
     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;
@@ -79,6 +59,5 @@ export declare function readBondArgs(settlement: Omittable<Scalar>, maturity: Om
     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,9 +1,4 @@
 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.
@@ -21,36 +16,7 @@ export declare const RATE_MAX_ITERATIONS = 200;
  * 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
- * time-value-of-money functions all agree — measured 2026-08-26, Excel 16.0 build 20326).
- *
- * For an INTEGER exponent of magnitude up to 4294967294 (2^32 − 2) Excel does not call a
- * correctly rounded pow: it multiplies — right-to-left binary exponentiation, a negative exponent
- * as the reciprocal of the positive power — and the rounding of every intermediate product is
- * carried into the result. That is invisible at the 15th digit of `(1+r)^n` itself, but a caller
- * that divides `(1+r)^n − 1` by a small `r` amplifies the last bits: `FV(1E-9,360,-100,-1000)`
- * agrees with Excel to 8 digits on `Math.pow` and is bit-exact on this form. From 2^32 − 1 up, and
- * for every non-integer exponent, Excel is `exp(y · ln x)` in double — closer to it than libm pow
- * 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!. 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/financial/ACCRINT.d.ts

@@ -9,19 +9,6 @@ import { AcceptError, Omittable, Scalar, NoLift } from '@sheetxl/primitives';
  * @param frequency is the number of coupon payments per year.
  * @param basis is the type of day count basis to use.
  * @param calcMethod is a logical value: to accrued interest from issue date = TRUE; to calculate from last coupon payment date = FALSE.
- *
- * @remarks
- * `par · rate/frequency · Σ(Aᵢ/NLᵢ)` over the quasi-coupon periods anchored at `first_interest`,
- * as Excel 16.0 composes it (fn-battery financial/ACCRINT and adhoc-accrint-clamped, 1,796 rows,
- * 2026-08-28 / 2026-09-09) — see {@link accruedPeriods}.
- * The seven leading slots are Excel-declared `any` (a boolean is #VALUE!, an empty slot #N/A —
- * except `par`, which is 1000 when omitted — a blank cell 0); `calc_method` is a logical read
- * FIRST: any number is accepted (nonzero is TRUE), text — `"TRUE"` included — is #VALUE!. Then
- * the slots are read from the first, each coerced and validated before the next (a negative
- * issue is #NUM! over a text frequency, a frequency of 3 over a text basis): every date in the
- * calendar, the frequency 1/2/4 and the basis 0–4 after truncation; then `issue < settlement`,
- * `rate > 0`, `par > 0`, and a quasi-coupon date the walk needs below serial 1 or past the
- * calendar's end is #NUM!. A product that overflows is 0.
  */
 export declare function ACCRINT(issue: NoLift<Omittable<AcceptError<Scalar>>>, firstInterest: NoLift<Omittable<AcceptError<Scalar>>>, settlement: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, par: NoLift<Omittable<AcceptError<Scalar>>>, frequency: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>, calcMethod?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 /**
@@ -31,16 +18,6 @@ export declare function ACCRINT(issue: NoLift<Omittable<AcceptError<Scalar>>>, f
  * @param rate is the security's annual coupon rate.
  * @param par is the security's par value.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * `par · rate · yearfrac(issue, settlement)` with YEARFRAC's year fraction (the signed NASD
- * count at basis 0), measured against Excel 16.0 (fn-battery financial/ACCRINTM, 2026-08-28).
- * There is no quasi-coupon walk here — a security paying at maturity has one period — so the
- * two share their reading and nothing else. The slots read from the first: each date is coerced
- * and checked against the calendar before the next slot is looked at, then the rate, the par and
- * the basis are coerced, and only then the date order (`issue ≤ settlement` once truncated —
- * equal is 0) and the signs of the rate and the par. An OMITTED par is 1000 (a blank cell is 0,
- * and #NUM!). A product that overflows is 0.
  */
 export declare function ACCRINTM(issue: NoLift<Omittable<AcceptError<Scalar>>>, settlement: NoLift<Omittable<AcceptError<Scalar>>>, rate: NoLift<Omittable<AcceptError<Scalar>>>, par: NoLift<Omittable<AcceptError<Scalar>>>, basis?: NoLift<Omittable<AcceptError<Scalar>>>): number;
 //# sourceMappingURL=ACCRINT.d.ts.map

package/types/src/financial/AMORDEGRC.d.ts

@@ -8,28 +8,6 @@ import { Scalar, Omittable, NoLift } from '@sheetxl/primitives';
  * @param period is the period.
  * @param rate is the depreciation rate.
  * @param basis is the type of day count basis to use.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/AMORDEGRC, 2026-08-28), where it differs from
- * the documentation in most places:
- *
- * - The life is `1/rate`. A life of 2 or less is #NUM!; the coefficient is 1.5 up to a life of 4,
- *   2 up to 6, 2.5 beyond (the documented "1 to 2 years" and "4 to 5 years" bands do not exist).
- * - Period 0 is `cost · rate · coefficient · stub fraction` (the AMORLINC stub, see
- *   `getAmorDayCount`), capped at `cost − salvage`, ROUNDED — half away from zero, not
- *   floored — and carried into the balance rounded.
- * - Each later period is the declining charge `balance · rate · coefficient`, except the LAST
- *   TWO periods of `ceil(life)`, which split the balance in two and then take the rest. There is
- *   no other straight-line switch (a 10-year asset stays on the declining charge in period 7
- *   although straight line is larger). Every returned charge is rounded, but the balance carries
- *   the UNROUNDED charge.
- * - A balance already below salvage at the start of a period returns 0; one equal to salvage is
- *   still depreciated (`AMORDEGRC(2400,…,2399,1,0.15,1)` is 900).
- * - A period under 1 is period 1 and above 1 truncates — except that Excel answers other
- *   periods' values for some fractions below 1 (0.1 and 1E-300 answer period 5, 0.5 answers 0);
- *   those rows are accepted differences.
- * - Every argument is Excel-declared `any`: a boolean is refused, an empty argument is missing, a
- *   multi-cell reference does not broadcast. Basis truncates and 2 is refused; 4 is accepted.
  */
 export declare function AMORDEGRC(cost: NoLift<Omittable<Scalar>>, datePurchased: NoLift<Omittable<Scalar>>, firstPeriod: NoLift<Omittable<Scalar>>, salvage: NoLift<Omittable<Scalar>>, period: NoLift<Omittable<Scalar>>, rate: NoLift<Omittable<Scalar>>, basis?: NoLift<Omittable<Scalar>>): number;
 //# sourceMappingURL=AMORDEGRC.d.ts.map

package/types/src/financial/Cashflow.d.ts

@@ -9,17 +9,6 @@ export declare function NPV(rate: number, value: IRange<number>[]): number;
  * Returns the internal rate of return for a series of cash flows.
  * @param values is an array or a reference to cells that contain numbers for which you want to calculate the internal rate of return.
  * @param guess is a number that you guess is close to the result of IRR.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/IRR plus `adhoc-irr-iterates` and
- * `adhoc-irr-guess`, 2026-08-29). The member rule is NPV's — a text, boolean, blank or
- * empty-string member is SKIPPED and the periods close up behind it, so `{-100,TRUE,110}` is the
- * two-flow 10% — while an error member is `#VALUE!` whatever its own identity was. An error handed
- * as the whole argument is not a member and keeps its identity (`IRR(NA())` is `#N/A`). `guess` is
- * declared `number` (a boolean coerces, a text is `#VALUE!`), an ABSENT argument is 0.1 where an
- * EMPTY slot and a blank cell are 0, and the domain is the one RATE has at both ends:
- * `guess <= -1` is `#VALUE!`, and so is a guess so large that `1 + guess` is `guess` again
- * (the turn is at 2^53 — `IRR(…,9.007E15)` answers and `IRR(…,9.008E15)` does not).
  */
 export declare function IRR(values: Omittable<Flatten<AcceptError<Scalar>>>, guess?: number): number;
 /**
@@ -27,19 +16,6 @@ export declare function IRR(values: Omittable<Flatten<AcceptError<Scalar>>>, gue
  * @param values An array of cash flows; must contain at least one positive and one negative value.
  * @param financeRate The interest rate paid on negative cash flows (cost of capital).
  * @param reinvestRate The interest rate received on positive cash flows (reinvestment rate).
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/MIRR, 2026-08-29). The member rule is IRR's —
- * a text, boolean, blank or empty-string member is SKIPPED and the periods close up, so it also
- * shortens the `n` the exponent counts — but an error member keeps its own identity here where
- * IRR flattens every one to `#VALUE!`. The two rates are declared `number` (a boolean coerces, an
- * empty slot and a blank cell are 0) and are read before the members, so a text rate beats an
- * `#N/A` in the schedule.
- *
- * The form is the documented one, and each side DIVIDES by its own compounding — which is where
- * `#DIV/0!` comes from at a rate of −1 (a flow at period 0 divides by `(1+r)^0` and survives one:
- * `MIRR({-100,110},-1,0)` is 10% while `MIRR({-100,110},0,-1)` is not). Fewer than two flows, or
- * no outflow at all, divides by zero as well.
  */
 export declare function MIRR(values: Omittable<Flatten<AcceptError<Scalar>>>, financeRate: number, reinvestRate: number): number;
 /**
@@ -47,14 +23,6 @@ export declare function MIRR(values: Omittable<Flatten<AcceptError<Scalar>>>, fi
  * @param rate is the discount rate to apply to the cash flows.
  * @param values is a series of cash flows that correspond to a schedule of payments in dates.
  * @param dates is a schedule of payment dates that corresponds to the cash flow payments.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/XNPV, 2026-08-29). Each flow is discounted
- * over ACTUAL days from the FIRST date on a 365-day year — `(trunc(dᵢ) − trunc(d₀))/365`, each
- * serial truncated on its own, so a fractional date changes nothing. The dates need not be
- * sorted; they need only fall at or after `d₀`, and a date before it is #NUM!. The rate is
- * strictly positive (0 and below are #NUM!, 1E-300 is an answer), and a discount factor or a
- * sum that overflows is #NUM!. The operands read as {@link readDatedFlows} describes.
  */
 export declare function XNPV(rate: NoLift<Omittable<Scalar>>, values: Omittable<IRange>, dates: Omittable<IRange>): number;
 /**
@@ -62,23 +30,6 @@ export declare function XNPV(rate: NoLift<Omittable<Scalar>>, values: Omittable<
  * @param values is a series of cash flows that correspond to a schedule of payments in dates.
  * @param dates is a schedule of payment dates that corresponds to the cash flow payments.
  * @param guess is a number that you guess is close to the result of XIRR.
- *
- * @remarks
- * Measured against Excel 16.0 (fn-battery financial/XIRR, 2026-08-29). XIRR is XNPV's equation
- * solved for the rate — the same `(trunc(dᵢ) − trunc(d₀))/365` day count — but neither its
- * operands nor its answer are XNPV's. The members are COERCED rather than refused (numeric text
- * and date text parse; a boolean or a true text is `#VALUE!`), a pair whose VALUE is blank is
- * DROPPED, serial 0 is legal, and the dates need not be ordered at all: a flow before `d₀` is
- * discounted by a negative exponent. Fewer than two surviving pairs is `#N/A`; two of the same
- * sign is `#NUM!`. `guess` is ATP `any` — a boolean is `#VALUE!`, an EMPTY slot is the 0.1
- * default where a blank cell is 0, and a reference does not lift.
- *
- * Excel's own answer is only accurate to about eight digits and moves with the guess in the
- * ninth, so the fixture's numeric rows carry a `precision` (CALC-ISSUES 26): its
- * iteration is unidentified, as YIELD's and ODDFYIELD's are. What IS reproduced is the search's
- * one directional rule — from a NEGATIVE guess Excel never reaches a positive root
- * (`XIRR({-100,110},…,-0.5)` is `#NUM!` while the same call at guess 0 answers 10%), though a
- * non-negative guess reaches a negative root freely.
  */
 export declare function XIRR(values: Omittable<IRange>, dates: Omittable<IRange>, guess?: NoLift<Omittable<Scalar>>): number;
 //# sourceMappingURL=Cashflow.d.ts.map