@sheetxl/formulas 0.8.0-beta.2 → 0.8.0-beta.21

package/{browser/esm/BUPw_w8LCTxzqyi2.mjs → node/esm/sEnzSvD52gctYJAN.mjs}

@@ -1,8 +1,8 @@
 /**
-* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.2
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.21
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
-* License: The license can be found at https://www.sheetxl.com/license.
+* License: MIT
 */
 var e = {
 	COMPLEX: {

package/{browser/esm/CcmByvKzgVja3yr6.mjs → node/esm/yDs0erVJTPEM7IFS.mjs}

@@ -1,8 +1,8 @@
 /**
-* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.2
+* @license @sheetxl/formulas - Formulas - TypeScript formulas compatible with Excel built-ins. - v0.8.0-beta.21
 *
 * (C) 2026-present SheetXL Inc. & Michael T. Ford
-* License: The license can be found at https://www.sheetxl.com/license.
+* License: MIT
 */
 var e = {
 	BESSELI: {

package/package.json

@@ -1,21 +1,26 @@
 {
   "name": "@sheetxl/formulas",
   "description": "Formulas - TypeScript formulas compatible with Excel built-ins.",
-  "version": "0.8.0-beta.2",
-  "license": "SEE LICENSE IN <LICENSE>",
+  "version": "0.8.0-beta.21",
+  "license": "MIT",
   "type": "module",
   "exports": {
     ".": {
       "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,8 +42,8 @@
     "formulas"
   ],
   "dependencies": {
-    "@sheetxl/primitives": "^0.8.0-beta.2",
-    "@sheetxl/scripting": "^0.8.0-beta.2",
+    "@sheetxl/primitives": "^0.8.0-beta.21",
+    "@sheetxl/scripting": "^0.8.0-beta.21",
     "bahttext": "^2.4.0",
     "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/{lookupReference/PivotBy.decl.d.ts → financial/MarketHistory.decl.d.ts}

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

package/types/src/.generated/decl/{lookupReference/GroupBy.decl.d.ts → web/ImportData.decl.d.ts}

@@ -1,4 +1,4 @@
 import { MinifiedDeclarations } from '@sheetxl/scripting';
 declare const declarations: MinifiedDeclarations;
 export default declarations;
-//# sourceMappingURL=GroupBy.decl.d.ts.map
+//# sourceMappingURL=ImportData.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/{lookupReference/PivotBy.desc.d.ts → financial/MarketHistory.desc.d.ts}

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

package/types/src/.generated/desc/{lookupReference/GroupBy.desc.d.ts → web/ImportData.desc.d.ts}

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

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

@@ -12,6 +12,22 @@
  * the arctangent.
  */
 export declare const flushSubnormal: (value: number) => number;
+/**
+ * The shift Excel adds to a count or position argument before truncating it.
+ *
+ * It is a small ABSOLUTE constant, so a value just under an integer counts as that integer at any
+ * magnitude: `LEFT("hello",0.9999999)` is "h" and `LEFT("hello",0.999999)` — one digit less — is
+ * the empty string.
+ *
+ * Which functions shift is a PER-FUNCTION fact, not an engine one, and the family is split down
+ * the middle: LEFT, RIGHT, FIND, SEARCH, REPLACE, SUBSTITUTE, CHAR, INDEX and ROUND shift, while
+ * MID, REPT and UNICHAR truncate the double as it stands (`MID("hello",0.9999999,1)` is #VALUE!
+ * and `UNICHAR(0.9999999)` is too). So this is applied per call site rather than in the
+ * declaration.
+ */
+export declare const COUNT_EPSILON: number;
+/** A count or position argument, shifted by {@link COUNT_EPSILON} and truncated. */
+export declare const excelCount: (count: 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`.

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

@@ -0,0 +1,23 @@
+/**
+ * Half-width and full-width conversion for `ASC` and `DBCS`.
+ *
+ * @remarks
+ * Follows Windows `LCMapStringEx` with `LCMAP_HALFWIDTH` / `LCMAP_FULLWIDTH`, which answers the same
+ * under every language with two widths — the only languages under which the conversion applies.
+ *
+ * The rules are the Unicode Halfwidth and Fullwidth Forms block. Two departures come from Windows:
+ * the backslash stays as it is in both directions, and the block's halfwidth arrows, box drawing and
+ * shapes (U+FFE8 to U+FFEE) are not converted. Windows also composes any base and combining mark
+ * going to full width (`e` and U+0301 become U+00E9); only kana and Hangul compose here.
+ */
+/**
+ * Converts every character that has a full-width form to it, then composes what the conversion left
+ * side by side: a kana and its voiced mark become one character, and Hangul letters one syllable.
+ */
+export declare const toFullWidth: (text: string) => string;
+/**
+ * Converts every character that has a half-width form to it. A voiced katakana becomes two
+ * characters, so the result can be longer than `text`.
+ */
+export declare const toHalfWidth: (text: string) => string;
+//# sourceMappingURL=CharWidth.d.ts.map

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

@@ -2,7 +2,7 @@ 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.
+ * where it should carry 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;
@@ -51,7 +51,7 @@ export declare function poissonPdf(k: number, l: number): number;
  * 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
+ * The ORDER is the one place this differs from the rest of the category, which 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.
@@ -62,8 +62,8 @@ 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 — it costs sixty
- * of BINOM.DIST's rows on its own — so it is not a cleanup to make.
+ * 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;
@@ -85,8 +85,7 @@ 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. Whether Excel rounds there too is not
- * established, so the round trip stays.
+ * 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. */

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

@@ -1,4 +1,4 @@
-import { Scalar } from '@sheetxl/primitives';
+import { FormulaError, IRange, 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.
@@ -11,4 +11,18 @@ import { Scalar } from '@sheetxl/primitives';
  * Count flavors do NOT wrap: `COUNTIF(A1:A3,">1")` counts a matched error member.
  */
 export declare function rejectMatchedError(fn: (accumulator: Scalar, value: Scalar) => Scalar): (accumulator: Scalar, value: Scalar) => Scalar;
+/**
+ * The member error a paired statistic answers with: `#NULL!` and `#GETTING_DATA` read as `#NUM!`.
+ *
+ * Shared by the two-array statistics (`CORREL`, `PEARSON`, `RSQ`, `STEYX`, `COVARIANCE.*`, `SLOPE`,
+ * `INTERCEPT`, `FORECAST`, `SUMX2MY2` and its siblings, `PROB`, `CHISQ.TEST`, `F.TEST`, `T.TEST`).
+ * Which member wins is each function's own scan order; only the kind is mapped. `SUMPRODUCT`,
+ * `SUM` and the one-array statistics keep the error as it is.
+ */
+export declare function pairedMemberError<E extends FormulaError.Known>(error: E): E;
+/**
+ * {@link pairedMemberError} of a range's first error, except at a single-cell REFERENCE: that one
+ * reads as a direct argument and keeps its error (`PROB(A2,C1,1)` is `#NULL!` where A2 is).
+ */
+export declare function pairedRangeError(range: IRange): FormulaError.Known;
 //# sourceMappingURL=Errors.d.ts.map

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

@@ -17,7 +17,7 @@ import { IRange, Scalar } from '@sheetxl/primitives';
  */
 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.
+ * The one cell a multi-cell REFERENCE reads as at a slot declared a plain VALUE.
  *
  * @remarks
  * The choice is the call's implicit-intersection MODE: in VALUE

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

@@ -9,13 +9,13 @@
  * 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, and in five spellings — lands
- * further from Excel on the same matrices.
+ * 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:
+ * The product is a multiplication, so it carries the two rules the 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.
  */

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

@@ -57,8 +57,8 @@ export declare const upRegGamma: (a: number, x: number) => number;
  *   -a (u - ln(1+u)) - ln(1+u) - ln(a)/2 - ln(2 pi)/2 - stirlerr(a),   u = x/a - 1
  * ```
  *
- * whose every term is the size of the answer. Excel's own `GAMMA.DIST(1E7,1E7,1,FALSE)` is bit
- * for bit the value this returns, so it is what Excel computes too.
+ * whose every term is the size of the answer. It is Excel's form: `GAMMA.DIST(1E7,1E7,1,FALSE)`
+ * is exactly the value this returns.
  */
 export declare function gammaLogPdf(a: number, x: number): number;
 /** The inverse of {@link lowRegGamma} in its second argument. */

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

@@ -187,9 +187,9 @@ export declare function TODAY(): Volatile<number>;
  * How WEEKDAY numbers the days of the week.
  *
  * @remarks
- * Declared `ReportType`, as every numeric built-in enum is: Excel TRUNCATES this argument (`2.9`
- * is 2) and answers #NUM! outside the set, which an enum's gate does not, so the body keeps the
- * verdict. Members that mean the same thing share Excel's label (2 and 11, 1 and 17), and so share
+ * Declared `ReportType`, as every numeric built-in enum is: the argument is TRUNCATED (`2.9`
+ * is 2) and is #NUM! outside the set, which an enum's gate does not do, so the body keeps
+ * the verdict. Members that mean the same thing share a label (2 and 11, 1 and 17), and so share
  * one descriptor entry.
  */
 declare enum WeekdayType {

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

@@ -0,0 +1,40 @@
+import { Scalar, Flatten, Omittable } from '@sheetxl/primitives';
+/**
+ * Returns an array of historical quote data for a symbol and date range you specify.
+ * @param stock the ticker symbol of the financial instrument (`"IBM"`).
+ * @param startDate the first date to return data from.
+ * @param endDate the last date to return data from. Default is the start date.
+ * @param interval the granularity of the data: `0` daily, `1` weekly, `2` monthly. Default is `0`.
+ * @param headers whether to add column headers: `0` none, `1` a header row, `2` the instrument identifier and a header row. Default is `1`.
+ * @param properties the columns to return, each a number: `0` Date, `1` Close, `2` Open, `3` High, `4` Low, `5` Volume. Default is Date and Close.
+ *
+ * @remarks
+ * * The cell shows `#BUSY!` until the quotes arrive, then spills one row per bar, ascending.
+ * * Quotes come from [Alpha Vantage](https://www.alphavantage.co), which needs an API key:
+ *   `ALPHAVANTAGE_API_KEY` on the global object or in the environment. Without one the service's
+ *   `demo` key is used, which answers for `IBM` only. A free key allows 25 requests a day.
+ * * An unknown symbol is `#N/A`. A spent request budget is `#VALUE!` carrying the service's notice.
+ * * A recalculation does not ask again; the quotes are kept with the cell. Reopening the file does.
+ * * Excel accepts a Stock data type for `stock`; here it is the ticker text.
+ */
+export declare function STOCKHISTORY(stock: string, startDate: number, endDate?: Omittable<number>, interval?: Omittable<number>, headers?: Omittable<number>, properties?: Flatten<Scalar>): Scalar[][];
+/**
+ * Returns the daily exchange rate of one currency in another over a period, from the European
+ * Central Bank's reference rates.
+ * @param from the currency to convert from, as an ISO code (`"USD"`).
+ * @param to the currency to convert to, as an ISO code (`"EUR"`).
+ * @param startDate the first date of the period.
+ * @param endDate the last date of the period. Default is the start date.
+ * @param headers whether to add column headers: `0` none, `1` a header row, `2` the pair and a header row. Default is `1`.
+ *
+ * @remarks
+ * * Spills one row per business day in the period, with the date and the rate. The cell shows
+ *   `#BUSY!` until the rates arrive.
+ * * Rates are the ECB's daily reference rates (about 16:00 CET), published on TARGET business
+ *   days; weekends and holidays have no row.
+ * * Both currencies must be among the roughly thirty the ECB publishes; another is `#N/A`.
+ * * A recalculation does not ask again; the rates are kept with the cell. Reopening the file does.
+ * * Data by [Frankfurter](https://frankfurter.dev), a free service with no key. Please do not abuse it.
+ */
+export declare function FXHISTORY(from: string, to: string, startDate: number, endDate?: Omittable<number>, headers?: Omittable<number>): Scalar[][];
+//# sourceMappingURL=MarketHistory.d.ts.map

package/types/src/logical/Logical.d.ts

@@ -55,7 +55,7 @@ export declare function IFNA(value: AcceptError<Scalar>, valueIfNA: Lazy<AcceptE
  * The search STOPS at the first TRUE condition, and a condition past it is never read: a
  * `#DIV/0!` or an uncoercible text there does not surface. A fault reached BEFORE the match is
  * fatal, which is why the test slot accepts errors and this body decides — the engine's own
- * left-to-right propagation would refuse the whole call for a condition Excel never evaluates.
+ * left-to-right propagation would refuse the whole call for a condition that is never evaluated.
  */
 export declare function IFS(condition: Repeating<[logicalTest: AcceptError<boolean>, logicalTrue: AcceptError<any>], 254>): any;
 /**

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

@@ -53,8 +53,9 @@ export declare function CHOOSEROWS(array: Flatten<IRange>, rowNum: Repeating<num
 /**
  * Returns the column number of a reference.
  * @param reference is the cell or range of contiguous cells for which you want the column number. If omitted, the cell containing the COLUMN function is used.
+ * @returnKind number
  */
-export declare function COLUMN(reference?: Flatten<IReferenceRange>): number[];
+export declare function COLUMN(reference?: Flatten<IReferenceRange>): number | number[];
 /**
  * Returns the number of columns in an array or reference.
  * @param array is an array or array formula, or a reference to a range of cells for which you want the number of columns.
@@ -70,11 +71,10 @@ export declare function DROP(array: IRange, row: number, columns?: Omittable<num
 export declare function EXPAND(array: IRange | Scalar, row: Omittable<number>, columns?: Omittable<number>, padWith?: NoLift<Omittable<AcceptError<Scalar>>>): IRange;
 /**
  * Extracts a value from a field of a given record.
- * @hidden Unimplemented RichData
  * @param value The record from which you want to extract the field.
  * @param fieldName The names of the field or fields that you want to extract.
  */
-export declare function FIELDVALUE(value: IRichData, fieldName: string): Scalar[][];
+export declare function FIELDVALUE(value: AcceptError<IRichData>, fieldName: string): Scalar | IRange;
 /**
  * Filter a range or array.
  * @param array the range or array to filter.
@@ -89,14 +89,13 @@ export declare function FILTER(array: Flatten<IRange>, include: Flatten<IRange<b
 export declare function FORMULATEXT(reference: Flatten<IReferenceRange>): string;
 /**
  * Extracts data stored in a PivotTable.
- * @hidden Unimplemented Pivot
  * @param dataField is the name of the data field to extract data from.
  * @param pivotTable is a reference to a cell or range of cells in the PivotTable that contains the data you want to retrieve.
  * @param fieldItem the field/item pairs to refer to.
  * @param fieldItem.field field to refer to.
  * @param fieldItem.item field item to refer to.
  */
-export declare function GETPIVOTDATA(dataField: string, pivotTable: string, fieldItem?: Repeating<[field: string, item?: IRange]>): string;
+export declare function GETPIVOTDATA(dataField: string, pivotTable: Flatten<IReferenceRange>, fieldItem?: Repeating<[field: string, item?: Scalar]>): Scalar;
 /**
  * Looks for a value in the top row of a table or array of values and returns the value in the same column from a row you specify.
  * @param lookupValue is the value to be found in the first row of the table and can be a value, a reference, or a text string.
@@ -112,21 +111,51 @@ export declare function HLOOKUP(lookupValue: Scalar, tableArray: Flatten<IRange>
 export declare function HSTACK(array: Repeating<IRange, 254>): IRange;
 /**
  * Creates a shortcut or jump that opens a document stored on your hard drive, a network server, or on the Internet.
- * @hidden Unimplemented RichData
  * @param linkLocation is the text giving the path and file name to the document to be opened, a hard drive location, UNC address, or URL path.
  * @param friendlyName is text or a number that is displayed in the cell. If omitted, the cell displays the linkLocation text.
+ * @returns A link that reads as its friendly name; a reference to it is a link too.
  */
-export declare function HYPERLINK(linkLocation: string, friendlyName?: string): Scalar;
+export declare function HYPERLINK(linkLocation: string, friendlyName?: Scalar): IRichData;
+/**
+ * How IMAGE sizes the picture in its cell.
+ *
+ * @remarks
+ * Declared `ReportType`: the body truncates the argument and refuses one outside 0-3.
+ */
+declare enum ImageSizing {
+    /**
+     * Fits the picture in the cell, keeping its aspect ratio.
+     * @name Fit to cell
+     */
+    Fit = 0,
+    /**
+     * Fills the cell, ignoring the picture's aspect ratio.
+     * @name Fill cell
+     */
+    Fill = 1,
+    /**
+     * Keeps the picture's own size, which may overflow the cell.
+     * @name Original size
+     */
+    Original = 2,
+    /**
+     * Uses the height and width given.
+     * @name Custom size
+     */
+    Custom = 3
+}
 /**
  * Returns an image from a given source.
- * @hidden Unimplemented RichData
  * @param source The path of the source that points to the image.
  * @param alternateText The alternative text that describes the image for accessibility.
  * @param sizing The setting that determines the dimensions in which the image will be rendered in the cell.
  * @param height The custom height of the image in pixels.
  * @param width The custom width of the image in pixels.
+ * @returns The image, once it has loaded; `#BUSY!` until then, or the image it showed when a
+ * recalculation loads it again. A source that cannot be loaded is
+ * `#VALUE!`, or `#CONNECT!` when the server answers with an error.
  */
-export declare function IMAGE(source: string, alternateText?: string, sizing?: number, height?: number, width?: number): IRichData;
+export declare function IMAGE(source: string, alternateText?: Omittable<string>, sizing?: Omittable<ReportType<ImageSizing>>, height?: Omittable<number>, width?: Omittable<number>): IRichData;
 /**
  * Returns a value or reference of the cell at the intersection of a particular row and column, in a given range.
  * @param array is a range of cells or an array constant.
@@ -135,7 +164,7 @@ export declare function IMAGE(source: string, alternateText?: string, sizing?: n
  * @param areaNum selects the area in Array or Reference from which to return a value. If omitted, the first area is used.
  *
  * @remarks
- * Combines both Excel INDEX functions using optional parameters.
+ * Combines the array and reference forms of INDEX using optional parameters.
  */
 export declare function INDEX(array: Flatten<IRange>, rowNum: Omittable<number>, colNum?: Omittable<number | undefined, 0>, areaNum?: Omittable<number, 0>): any;
 /**
@@ -156,7 +185,7 @@ export declare function LOOKUP(lookupValue: Scalar, lookupVector: Flatten<IRange
  *
  * @remarks
  * Declared `ReportType`, as every numeric built-in enum is: the body keeps the verdict. It reads the
- * argument by its SIGN; what Excel does with a value outside the set is not measured.
+ * argument by its SIGN.
  */
 declare enum MatchType {
     /**
@@ -196,7 +225,7 @@ export declare function OFFSET(reference: IReferenceRange, rows: number, cols: n
  * @param reference is the cell or a single range of cells for which you want the row number; if omitted, returns the cell containing the ROW function.
  * @returnKind number
  */
-export declare function ROW(reference?: Flatten<IReferenceRange>): number[] | number[][];
+export declare function ROW(reference?: Flatten<IReferenceRange>): number | number[] | number[][];
 /**
  * Returns the number of rows in a reference or array.
  * @param array is an array, an array formula, or a reference to a range of cells for which you want the number of rows.
@@ -222,7 +251,7 @@ export declare function SORT(array: IRange | Scalar, sortIndex?: Omittable<IRang
  * The direction SORT and SORTBY sort a key in.
  *
  * @remarks
- * Declared `ReportType`, as every numeric built-in enum is: Excel FLOORS this argument (`1.5` sorts
+ * Declared `ReportType`, as every numeric built-in enum is: this argument FLOORS (`1.5` sorts
  * ascending, `-1.5` is #VALUE!), which an enum's gate does not, so `_sortOrders` keeps the verdict.
  * SORT takes an array of orders, one per key, so its slot is `IRange<ReportType<SortOrder>>`.
  */
@@ -257,8 +286,8 @@ export declare function TAKE(array: IRange, rows: Omittable<number>, columns?: O
  * Which values to leave out.
  *
  * @remarks
- * Declared `ReportType`: Excel TRUNCATES this argument on the way in (`TOCOL(a,1.9)` reads 1 and
- * `3.9` reads 3, measured), which an enum's gate does not, so the body keeps the verdict.
+ * Declared `ReportType`: this argument TRUNCATES on the way in (`TOCOL(a,1.9)` reads 1 and
+ * `3.9` reads 3), which an enum's gate does not, so the body keeps the verdict.
  */
 declare enum IgnoreValues {
     /**
@@ -347,7 +376,7 @@ export declare function WRAPROWS(vector: IRange | Scalar, wrapCount: number, pad
  *
  * @remarks
  * Declared `ReportType`, as every numeric built-in enum is: the body keeps the verdict (anything
- * else is #VALUE!). Excel's out-of-set behavior is not measured.
+ * else is #VALUE!).
  */
 declare enum MatchMode {
     /**
@@ -376,7 +405,7 @@ declare enum MatchMode {
  *
  * @remarks
  * Declared `ReportType`, as every numeric built-in enum is: the body keeps the verdict (anything
- * else is #VALUE!). Excel's out-of-set behavior is not measured.
+ * else is #VALUE!).
  */
 declare enum SearchMode {
     /**

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

@@ -8,9 +8,9 @@ export declare function ABS(number: number): number;
  * The calculation AGGREGATE performs.
  *
  * @remarks
- * Declared `ReportType`, as every numeric built-in enum is: Excel TRUNCATES this argument (`9.9`
- * is SUM, measured), which an enum's gate does not, so the body keeps the verdict. Also the
- * overload discriminant of DESIGN-REPEATING §6: 14-19 take a trailing `k`.
+ * Declared `ReportType`, as every numeric built-in enum is: the argument is TRUNCATED (`9.9`
+ * is SUM), which an enum's gate does not do, so the body keeps the verdict. Also the
+ * overload discriminant: 14-19 take a trailing `k`.
  */
 declare enum AggregateFunction {
     /**
@@ -113,8 +113,8 @@ declare enum AggregateFunction {
  * What AGGREGATE leaves out.
  *
  * @remarks
- * Declared `ReportType`, as every numeric built-in enum is: Excel TRUNCATES this argument (`6.9`
- * is 6, measured), which an enum's gate does not, so the body keeps the verdict.
+ * Declared `ReportType`, as every numeric built-in enum is: the argument is TRUNCATED (`6.9`
+ * is 6), which an enum's gate does not do, so the body keeps the verdict.
  */
 declare enum AggregateOptions {
     /**
@@ -596,9 +596,9 @@ export declare function SQRTPI(number: NoLift<Omittable<AcceptError<Scalar>>>):
  * The calculation SUBTOTAL performs; 101-111 leave out hidden rows.
  *
  * @remarks
- * Declared `ReportType`, as every numeric built-in enum is: Excel TRUNCATES this argument (`9.9`
- * is SUM, measured), which an enum's gate does not, so the body keeps the verdict. Excel labels
- * 101-111 with the bare function name, as 1-11; a member name keys the descriptor and the
+ * Declared `ReportType`, as every numeric built-in enum is: the argument is TRUNCATED (`9.9`
+ * is SUM), which an enum's gate does not do, so the body keeps the verdict. 101-111 are
+ * labeled with the bare function name, as 1-11 are; a member name keys the descriptor and the
  * language packs, so each must be unique.
  */
 declare enum SubtotalFunction {

package/types/src/testing/Testing.d.ts

@@ -7,7 +7,7 @@ import { Scalar, IRange } from '@sheetxl/primitives';
  * @param label optional label for the delay function.
  * @category SheetXL
  */
-export declare function DELAY(time: number, input: Scalar, label?: string): Promise<Scalar>;
+export declare function DELAY(time: number, input: Scalar, label?: string): Scalar;
 declare global {
     var debugEventTarget: EventTarget | undefined;
 }
@@ -24,5 +24,5 @@ declare global {
  *   (e.g. globalThis.debugEventTarget.dispatchEvent(new CustomEvent('test', { detail: "ping" }));
  * @category SheetXL
  */
-export declare function WAIT(type: string, input?: IRange): Promise<string>;
+export declare function WAIT(type: string, input?: IRange): string;
 //# sourceMappingURL=Testing.d.ts.map

package/types/src/web/FilterXML.d.ts

@@ -4,5 +4,5 @@ import { Scalar } from '@sheetxl/primitives';
  * @param xml is a string in valid XML format.
  * @param xpath is a string in standard XPath format.
  */
-export declare function FILTERXML(xml: string, xpath: string): Promise<Scalar[][]>;
+export declare function FILTERXML(xml: string, xpath: string): Scalar[][];
 //# sourceMappingURL=FilterXML.d.ts.map

package/types/src/web/ImportData.d.ts

@@ -0,0 +1,26 @@
+import { Scalar, Omittable } from '@sheetxl/primitives';
+/**
+ * Imports data at a given url in .csv (comma-separated value) or .tsv (tab-separated value) format.
+ * @param url the url of the .csv or .tsv data, including protocol (e.g. `http://`).
+ * @param delimiter the single character between fields. It may not be a double quote, or whitespace other than a tab. Default is inferred from the file name: comma for CSV, tab for TSV.
+ * @param locale a language and region locale code to use when parsing the data (`"en_US"`). Default is the workbook's locale.
+ *
+ * @example
+ *  =IMPORTDATA("https://api.covidtracking.com/v1/us/daily.csv")
+ *
+ * @remarks
+ * * The cell shows `#BUSY!` until the data arrives, then spills one row per line.
+ * * Each field is read as if it were typed into a cell: numbers, dates and `TRUE`/`FALSE` become
+ *   values, anything else stays text, and an empty field is blank.
+ * * A url that cannot be fetched is `#N/A`.
+ * * In a browser the server must allow cross-origin requests (CORS), or the workbook's fetcher
+ *   must reach it another way. Otherwise the `#N/A` says the site is restricted.
+ * * A recalculation does not ask again; the data is kept while the workbook is open, and a
+ *   workbook opens with the data it was saved with.
+ *   *Refresh All* does.
+ * * `locale` is accepted for compatibility; fields are read with the workbook's locale.
+ *
+ * @category Sheets
+ */
+export declare function IMPORTDATA(url: string, delimiter?: Omittable<string>, locale?: Omittable<string>): Scalar[][];
+//# sourceMappingURL=ImportData.d.ts.map

package/types/src/web/Web.d.ts

@@ -7,5 +7,5 @@ export declare function ENCODEURL(text: string): string;
  * Retrieves data from a web service.
  * @param url is the URL of the web service.
  */
-export declare function WEBSERVICE(url: string): Promise<string>;
+export declare function WEBSERVICE(url: string): string;
 //# sourceMappingURL=Web.d.ts.map

package/browser/cjs/1XrWGMP3GmsQOMIX.cjs

@@ -1 +0,0 @@
-exports.default={ERF:{s:`Returns the error function.`,p:{lowerLimit:{d:`is the lower bound for integrating ERF.`},upperLimit:{d:`is the upper bound for integrating ERF.`}}},"ERF.PRECISE":{s:`Returns the error function.`,p:{x:{d:`is the lower bound for integrating ERF.PRECISE.`}}},ERFC:{s:`Returns the complementary error function.`,p:{x:{d:`is the lower bound for integrating ERF.`}}},"ERFC.PRECISE":{s:`Returns the complementary error function.`,p:{x:{d:`is the lower bound for integrating ERF.`}}}};

package/browser/cjs/4nReftSsKWmnRdtf.cjs

@@ -1 +0,0 @@
-exports.default={AND:{s:`Checks whether all arguments are TRUE, and returns TRUE if all arguments are TRUE.`,p:{logical:{d:`are 1 to 255 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references.`}}},BYCOL:{s:`Applies a LAMBDA function to each column and returns an array of the results.`,p:{array:{d:`is an array to be separated by column.`},fn:{d:`is a LAMBDA that takes a column as its single parameter and returns one result for it.`}}},BYROW:{s:`Applies a LAMBDA function to each row and returns an array of the results.`,p:{array:{d:`is an array to be separated by row.`},fn:{d:`is a LAMBDA that takes a row as its single parameter and returns one result for it.`}}},FALSE:{s:`Returns the logical value FALSE.`,p:{}},FLATTEN:{s:`Flattens all the values from one or more ranges into a single column.`,c:`Sheets`,p:{ranges:{d:`One or more ranges or scalar values to flatten.`}}},IF:{s:`Checks whether a condition is met, and returns one value if TRUE, and another value if FALSE.`,p:{logicalTest:{d:`is any value or expression that can be evaluated to TRUE or FALSE.`},valueIfTrue:{d:`is the value that is returned if logicalTest is TRUE. If omitted, TRUE is returned. You can nest up to seven IF functions.`},valueIfFalse:{d:`is the value that is returned if logicalTest is FALSE. If omitted, FALSE is returned.`}}},IFERROR:{s:`Returns valueIfError if expression is an error and the value of the expression itself otherwise.`,p:{value:{d:`is any value or expression or reference.`},valueIfError:{d:`is any value or expression or reference.`}}},IFNA:{s:`Returns the value you specify if the expression resolves to #N/A, otherwise returns the result of the expression.`,p:{value:{d:`is any value or expression or reference.`},valueIfNA:{d:`is any value or expression or reference.`}}},IFS:{s:`Checks whether one or more conditions are met and returns a value corresponding to the first TRUE condition.`,p:{condition:{d:`the conditions to test and the values to return for them.`},"condition.logicalTest":{d:`is any value or expression that can be evaluated to TRUE or FALSE.`},"condition.logicalTrue":{d:`is the value returned if logicalTest is TRUE.`}}},LAMBDA:{s:`Creates a function value which can be called within formulas.`,p:{parameterOrCalculation:{d:`a parameter or a calculation that returns a value. If a parameter, it must be the last argument.`}}},LET:{s:`Assigns calculation results to names. Useful for storing intermediate calculations and values by defining names inside a formula. These names only apply within the scope of the LET function.`,p:{name:{d:`the name, or a calculation which can make use of all names within the LET. Names must start with a letter, cannot be the output of a formula, or conflict with range syntax.`},nameOrValue:{d:`the value associated with the name.`},calculationOrName:{},rest:{}}},MAKEARRAY:{s:`Returns a calculated array of a specified row and column size, by applying a LAMBDA function.`,p:{rows:{d:`is the number of rows in the array. Must be greater than zero.`},columns:{d:`is the number of columns in the array. Must be greater than zero.`},fn:{d:`is a LAMBDA that is called to create the array. The LAMBDA takes two parameters, row index and column index.`}}},MAP:{s:`Returns an array formed by 'mapping' each value in the array(s) to a new value by applying a lambda to create a new value.`,p:{array:{d:`is an array to be mapped.`},lambdaOrArray:{d:`is a LAMBDA which must be the last argument and must have a parameter for each array passed, or another array to be mapped.`}}},NOT:{s:`Changes FALSE to TRUE, or TRUE to FALSE.`,p:{logical:{d:`is a value or expression that can be evaluated to TRUE or FALSE.`}}},OR:{s:`Checks whether any of the arguments are TRUE, and returns TRUE or FALSE. Returns FALSE only if all arguments are FALSE.`,p:{logical:{d:`are 1 to 255 conditions that you want to test that can be either TRUE or FALSE.`}}},REDUCE:{s:`Reduces an array to an accumulated value by applying a LAMBDA function to each value and returning the total value in the accumulator.`,p:{initialValue:{d:`is the starting value for the accumulator.`},array:{d:`is an array to be reduced.`},fn:{d:`is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value.`}}},REDUCEIF:{s:`Reduces the cells specified by a given condition or criteria.`,c:`SheetXL`,p:{range:{d:`is the range of cells you want evaluated.`},criteria:{d:`is the condition or criteria in the form of a number, expression, or text that defines which cells will be reduced.`},reduceRange:{d:`are the actual cells to reduce. If omitted, the cells in range are used. This can be blank.`},fn:{d:`is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value.`}}},SCAN:{s:`Scans an array by applying a LAMBDA function to each value and returns an array that has each intermediate value.`,p:{initialValue:{d:`is the starting value for the accumulator.`},array:{d:`is an array to be reduced.`},fn:{d:`is a LAMBDA that is called to reduce the array. The LAMBDA takes two parameters, accumulator and value.`}}},SWITCH:{s:`Evaluates an expression against a list of values and returns the result corresponding to the first matching value. If there is no match, an optional default value is returned.`,p:{expression:{d:`is an expression to be evaluated.`},match:{d:`the values to compare against expression and the results to return for them.`},"match.value":{d:`is a value to compare against expression.`},"match.result":{d:`is a result to be returned if the corresponding value matches expression.`},defaultResult:{d:`is the result to be returned when no value matches expression.`}}},TRUE:{s:`Returns the logical value TRUE.`,p:{}},XOR:{s:`Returns a logical 'Exclusive Or' of all arguments.`,p:{logical:{d:`are 1 to 254 conditions you want to test that can be either TRUE or FALSE and can be logical values, arrays, or references.`}}}};

package/browser/cjs/507hQYooKKjnRzsZ.cjs

@@ -1 +0,0 @@
-exports.default={CONVERT:{s:`Converts a number from one measurement system to another.`,p:{number:{d:`is the value in fromUnit to convert.`},fromUnit:{d:`is the units for number.`},toUnit:{d:`is the units for the result.`}}}};

package/browser/cjs/B6vy56yEA1I3B74O.cjs

@@ -1 +0,0 @@
-exports.default={CELL:{s:`Returns information about the cell.`,p:{infoType:{d:`The type of information to return.`},reference:{d:`The cell to report on. Defaults to the cell holding the formula.`}}},"ERROR.TYPE":{s:`Returns a number matching an error value.`,p:{errorVal:{d:`is the error value for which you want the identifying number, and can be an actual error value or a reference to a cell containing an error value.`}}},INFO:{s:`Returns information about the current operating system.`,p:{typeText:{d:`The type of information to return.`}}},ISBLANK:{s:`Checks whether a reference is to an empty cell, and returns TRUE or FALSE.`,p:{value:{d:`is the cell or a name that refers to the cell you want to test.`}}},ISDATE:{s:`Returns TRUE if the value is a date.`,c:`Sheets`,p:{value:{d:`The value to check.`}}},ISEMAIL:{s:`Returns TRUE if the value is a valid email address.`,c:`Sheets`,p:{value:{d:`The value to check.`}}},ISERR:{s:`Checks whether a value is an error other than #N/A, and returns TRUE or FALSE.`,p:{value:{d:`is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value.`}}},ISERROR:{s:`Checks whether a value is an error, and returns TRUE or FALSE`,p:{value:{d:`is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value`}}},ISEVEN:{s:`Returns TRUE if the number is even.`,p:{number:{d:`is the value to test.`}}},ISFORMULA:{s:`Checks whether a reference is to a cell containing a formula, and returns TRUE or FALSE.`,p:{reference:{d:`is a reference to the cell you want to test.  Reference can be a cell reference, a formula, or name that refers to a cell.`}}},ISLOGICAL:{s:`Checks whether a value is a logical value (TRUE or FALSE), and returns TRUE or FALSE.`,p:{value:{d:`is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value.`}}},ISNA:{s:`Checks whether a value is #N/A, and returns TRUE or FALSE.`,p:{value:{d:`is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value.`}}},ISNONTEXT:{s:`Checks whether a value is not text (blank cells are not text), and returns TRUE or FALSE.`,p:{value:{d:`is the value you want tested: a cell; a formula; or a name referring to a cell, formula, or value.`}}},ISNUMBER:{s:`Checks whether a value is not text (blank cells are not text), and returns TRUE or FALSE.`,p:{value:{d:`is the value you want tested: a cell; a formula; or a name referring to a cell, formula, or value.`}}},ISODD:{s:`Returns TRUE if the number is odd.`,p:{number:{d:`is the value to test.`}}},ISOMITTED:{s:`Checks whether the value is omitted, and returns TRUE or FALSE.`,p:{argument:{d:`is the value you want to test, such as a LAMBDA parameter.`}}},ISURL:{s:`Returns TRUE if the value is a valid HTTP or HTTPS URL.`,c:`Sheets`,p:{value:{d:`The value to check.`}}},ISREF:{s:`Checks whether a value is a reference, and returns TRUE or FALSE.`,p:{value:{d:`is the value you want to test. Value can refer to a cell, a formula, or a name that refers to a cell, formula, or value.`}}},ISTEXT:{s:`Converts a value to text in a specific number format.`,p:{value:{d:`is a number, a formula that evaluates to a numeric value, or a reference to a cell containing a numeric value.`}}},N:{s:`Converts non-number value to a number, dates to serial numbers, TRUE to 1, anything else to 0 (zero).`,p:{value:{d:`is the value to convert.`}}},NA:{s:`Returns the #N/A error value`,p:{}},SHEET:{s:`Returns the sheet number of the referenced sheet.`,p:{value:{d:`is the name of a sheet or a reference that you want the sheet number of. If omitted the number of the sheet containing the function is returned.`}}},SHEETS:{s:`Returns the number of sheets in a reference.`,p:{reference:{d:`is a reference for which you want to know the number of sheets it contains. If omitted the number of sheets in the workbook containing the function is returned.`}}},TYPE:{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.`}}}},exports.enums={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.`}}}};