@gui-chat-plugin/spreadsheet 4.1.0 → 4.2.1

package/dist/engine/functions/distribution-math.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The t and normal distributions and the t-test, as pure numerics. Tails are computed
+ * directly rather than as 1 − (the rest), so a small p-value keeps its relative precision.
+ * The spreadsheet rules (argument checks, #NUM!) live in distributions.ts.
+ */
+export declare const normalDensity: (z: number) => number;
+/** P(Z > z) for the standard normal. erfc(x) is Q(1/2, x²), so the upper tail is half of it. */
+export declare function normalUpperTail(z: number): number;
+/** P(Z ≤ z) for the standard normal. */
+export declare const normalCdf: (z: number) => number;
+/** The z with P(Z ≤ z) = p, for 0 < p < 1. */
+export declare function normalQuantile(p: number): number;
+/** The z with P(Z > z) = q, for 0 < q < 1. */
+export declare const normalUpperQuantile: (q: number) => number;
+/** The t density with `df` degrees of freedom: 1 / (√ν B(ν/2, 1/2)) · (1 + t²/ν)^(−(ν+1)/2). */
+export declare function studentDensity(t: number, df: number): number;
+/** P(T > t). For t ≥ 0 it is ½ · I_x(ν/2, ½) with x = ν / (ν + t²) = r / (1 + r), r = ν / t².
+ *  It goes through ln r, so t² never overflows and 1 − x keeps its digits for a small t. */
+export declare function studentUpperTail(t: number, df: number): number;
+/** P(T ≤ t). */
+export declare const studentCdf: (t: number, df: number) => number;
+/** The t with P(T > t) = q, for 0 < q < 1. */
+export declare function studentUpperQuantile(q: number, df: number): number;
+/** The t with P(T ≤ t) = p, for 0 < p < 1. */
+export declare const studentQuantile: (p: number, df: number) => number;
+export interface SampleSummary {
+    count: number;
+    mean: number;
+    /** The sample variance, divided by n − 1. */
+    variance: number;
+}
+export declare function summarize(values: number[]): SampleSummary;
+export interface TStatistic {
+    t: number;
+    df: number;
+}
+/** Paired: the one-sample t of the differences. */
+export declare function pairedT(differences: number[]): TStatistic;
+/** Two samples with a pooled (equal) variance. */
+export declare function pooledT(first: SampleSummary, second: SampleSummary): TStatistic;
+/** Two samples with unequal variances (Welch). The Welch–Satterthwaite df is not rounded. */
+export declare function welchT(first: SampleSummary, second: SampleSummary): TStatistic;
+/** The p-value of a t statistic: one tail, or both. */
+export declare const tTestProbability: ({ t, df }: TStatistic, tails: 1 | 2) => number;

package/dist/engine/functions/distributions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The t and normal distributions, the t-test and confidence intervals. The numerics live in
+ * distribution-math.ts; this file reads the arguments, applies Excel's argument rules —
+ * degrees of freedom, tails, type and size truncated to integers, anything out of range
+ * #NUM! — and registers the names.
+ */
+export {};

package/dist/engine/functions/index.d.ts

@@ -6,10 +6,15 @@
  */
 import "./statistical";
 import "./statistical-analysis";
+import "./regression";
+import "./distributions";
+import "./shape";
 import "./mathematical";
 import "./logical";
 import "./text";
 import "./financial";
 import "./lookup";
 import "./date";
+import "./calendar";
+import "./aliases";
 export { functionRegistry } from "../registry";

package/dist/engine/functions/regression-math.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure rules for the regression and covariance functions (FORECAST.LINEAR, TREND, STEYX,
+ * COVARIANCE.S/.P), separated from the range-reading handlers so they can be tested directly.
+ */
+import { type SpreadsheetError } from "../spreadsheet-errors";
+import type { CellValue } from "../types";
+import { type NumericPairs } from "./analysis-math";
+/** FORECAST.LINEAR: the least-squares line's value at `x`. Ranges with no pair of numbers are
+ *  #N/A, as Excel answers for empty ranges; an x that never varies has no line: #DIV/0!. */
+export declare function forecastLinear(pairs: NumericPairs, x: number): number | SpreadsheetError;
+/** STEYX: the standard error of the y predicted by the least-squares line. */
+export declare function standardErrorOfEstimate(pairs: NumericPairs): number | SpreadsheetError;
+/** COVARIANCE.P: the mean product of the deviations, divided by n. */
+export declare function populationCovariance(pairs: NumericPairs): number | SpreadsheetError;
+/** COVARIANCE.S: divided by n - 1, so it needs two pairs. */
+export declare function sampleCovariance(pairs: NumericPairs): number | SpreadsheetError;
+/** The positions 1..n, TREND's known_x when it is omitted. */
+export declare const defaultKnownXs: (count: number) => number[];
+/**
+ * TREND at one new x. Unlike FORECAST it reads the ranges whole, as LINEST does: ranges of
+ * different sizes are #REF!, an error cell is that error, and a blank or text cell is #VALUE!
+ * rather than a skipped row. With a constant, an x that never varies is collinear with it and is
+ * dropped, as LINEST drops it, leaving the mean of y; through the origin only an all-zero x is.
+ */
+export declare function trendAt(knownYs: CellValue[], knownXs: CellValue[], newX: number, withConstant: boolean): number | SpreadsheetError;

package/dist/engine/functions/regression.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Regression and covariance functions: FORECAST.LINEAR, TREND at one new x, STEYX,
+ * COVARIANCE.S/.P. The rules live in regression-math.ts; this file reads the arguments.
+ */
+export {};

package/dist/engine/functions/shape-math.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The shape of one sample — skewness, kurtosis, percent rank — and its geometric and harmonic
+ * means, as pure numerics with Excel's formulas and Excel's errors. Registered in shape.ts.
+ */
+import { type SpreadsheetError } from "../spreadsheet-errors";
+type Result = number | SpreadsheetError;
+/** SKEW: n / ((n − 1)(n − 2)) · Σ z³. Fewer than three values, or none that differ: #DIV/0!. */
+export declare function skewness(values: number[]): Result;
+/** KURT: n(n + 1) / ((n − 1)(n − 2)(n − 3)) · Σ z⁴ − 3(n − 1)² / ((n − 2)(n − 3)). Fewer than four
+ *  values, or none that differ: #DIV/0!. */
+export declare function kurtosis(values: number[]): Result;
+/** STANDARDIZE: (x − mean) / sd, for sd > 0. */
+export declare const standardize: (x: number, center: number, sd: number) => Result;
+/** GEOMEAN: the n-th root of the product, through logs. Any value at or below 0, or none: #NUM!. */
+export declare function geometricMean(values: number[]): Result;
+/** HARMEAN: n / Σ (1 / x). Any value at or below 0, or none: #NUM!. */
+export declare function harmonicMean(values: number[]): Result;
+/** PERCENTRANK.INC with `significance` digits, truncated as Excel truncates. No data, or fewer
+ *  than one significant digit: #NUM!. An x outside the data: #N/A. One value: 1 when it is x. */
+export declare function percentRank(values: number[], x: number, significance: number): Result;
+export {};

package/dist/engine/functions/shape.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SKEW, KURT, STANDARDIZE, PERCENTRANK.INC, GEOMEAN and HARMEAN: the numbers of their arguments
+ * read as SUM reads them, and the rules in shape-math.ts.
+ */
+export {};

package/dist/engine/functions/special-functions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The special functions the t and normal distributions are built from: log gamma,
+ * log beta, and the regularized incomplete beta and gamma functions. Pure numerics,
+ * no spreadsheet types; accurate to a relative error near 1e-15 in the ranges the
+ * distribution functions use, which tests/engine/test_distributions.ts checks
+ * against values computed at 50 digits.
+ */
+/** ln Γ(x) for x > 0. */
+export declare function logGamma(x: number): number;
+/** ln B(a, b) for a, b > 0. With one argument large (the t distribution's df / 2 beside ½) it is
+ *  split like R's lbeta: ln Γ(q) − ln Γ(p + q) cancels once both are large and alike. */
+export declare function logBeta(a: number, b: number): number;
+/** I_x(a, b) from ln x and ln(1 − x). Taking logs lets a caller pass an x, or a 1 − x, too small
+ *  for a double (t above 1e154 in the t distribution) without the front factor collapsing to 0. */
+export declare function regularizedBetaFromLogs(logX: number, logComplement: number, a: number, b: number): number;
+/** Q(a, x) = Γ(a, x) / Γ(a), the regularized upper incomplete gamma function. */
+export declare function regularizedGammaUpper(a: number, x: number): number;

package/dist/engine/functions/statistical-analysis.d.ts

@@ -3,4 +3,11 @@
  * population spread, and the multi-condition aggregates. The rules live in
  * analysis-math.ts; this file reads the ranges and registers the names.
  */
-export {};
+import { type FunctionContext, type FunctionHandler } from "../registry";
+import { type NumericPairs } from "./analysis-math";
+import { type SpreadsheetError } from "../spreadsheet-errors";
+/** A scalar argument as a number, or the error it evaluated to (`#VALUE!` for text). */
+export declare const scalarArg: (args: string[], context: FunctionContext, index: number) => number | SpreadsheetError;
+/** `(known_y, known_x)` from argument `first` on, read raw so the two ranges stay paired by position. */
+export declare const pairsFrom: (args: string[], context: FunctionContext, first?: number) => NumericPairs | SpreadsheetError;
+export declare const pairedHandler: (rule: (pairs: NumericPairs) => number | SpreadsheetError) => FunctionHandler;

package/dist/engine/functions/statistical.d.ts

@@ -1,5 +1,25 @@
 /**
  * Statistical Functions
  */
-import { type FunctionContext } from "../registry";
+import { type FunctionContext, type FunctionHandler, type RangeGetter } from "../registry";
+import { type SpreadsheetError } from "../spreadsheet-errors";
+import type { CellValue } from "../types";
+/** One value an argument contributed, tagged by where it came from. A range cell
+ *  was already filtered by the range getter; a scalar is whatever the argument
+ *  evaluated to and may hold no number at all. */
+interface ArgumentValue {
+    value: CellValue;
+    isScalar: boolean;
+}
+export declare const collectArgumentValues: (args: string[], context: FunctionContext, readRange: RangeGetter) => ArgumentValue[];
+/** The numbers an aggregate reads from its arguments, or the first error among them in argument
+ *  order — an error cell in a range, or an argument that evaluated to one — read in one pass, so
+ *  no argument is read or evaluated twice. A range keeps only the cells that hold a number, as the
+ *  numeric read does. */
+export declare const collectNumbersOrError: (args: string[], context: FunctionContext) => number[] | SpreadsheetError;
+/** The cells of a range read blank-aware that hold a number, as numbers — what the numeric read keeps. */
+export declare const rangeNumbers: (values: CellValue[]) => number[];
+/** The handler's rule over the numbers of its arguments, or the first error among them. */
+export declare const overNumbers: (rule: (values: number[]) => CellValue) => FunctionHandler;
 export declare const collectNumericValues: (args: string[], context: FunctionContext) => number[];
+export {};

package/dist/engine/jsonCellLocator.d.ts

@@ -1,19 +1,3 @@
-/**
- * Locate the start offset of a specific cell value inside a
- * pretty-printed JSON spreadsheet document. Extracted from
- * `handleTableClick` in `src/plugins/spreadsheet/View.vue` where the
- * inline scanner pushed cognitive complexity to 163.
- *
- * The scanner walks the raw editor text character-by-character,
- * tracking string boundaries, bracket depth, and object depth to
- * find the n-th cell of the m-th row within a named sheet's `data`
- * array. We deliberately do NOT parse the JSON — we need the
- * character offset inside the user's text buffer (which may not be
- * valid JSON mid-edit), so a positional scan is required.
- *
- * Pure — no refs, no DOM. Returns -1 if the cell can't be located.
- * Tested in `test/plugins/spreadsheet/engine/test_jsonCellLocator.ts`.
- */
 /**
  * Given the pretty-printed JSON editor text, a sheet name, and
  * (rowIndex, colIndex), return the character offset of that cell's

package/dist/engine/logicalLiterals.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The logical literals `TRUE` and `FALSE` written in a formula, in any case, as the boolean values
+ * a logical cell already renders as (`true` / `false`), so a written TRUE and a cell holding TRUE
+ * read alike. A function call (`TRUE()`), a sheet name (`TRUE!A1`) and text in quotes are left.
+ */
+export declare function logicalLiteralsAsBooleans(formula: string): string;
+/** The boolean an expression is when it is nothing but one, or null. */
+export declare function loneBoolean(expr: string): boolean | null;
+/** An expression with its booleans as the numbers arithmetic reads them (TRUE is 1), when it holds
+ *  no text that could contain the words. */
+export declare function booleansAsNumbers(expr: string): string;

package/dist/engine/math-ops.d.ts

@@ -12,7 +12,7 @@ import { type SpreadsheetError } from "./spreadsheet-errors";
  *  `ROUND(-2.5, 0)` came back -2 instead of -3). */
 export declare function roundTo(value: number, digits: number): number;
 /** Excel ROUNDUP: away from zero. */
-export declare function roundUpTo(value: number, digits: number): number;
+export declare function roundUpTo(value: number, digits: number): number | SpreadsheetError;
 /** Excel ROUNDDOWN: toward zero. */
 export declare function roundDownTo(value: number, digits: number): number;
 /** Excel FLOOR: nearest multiple of `significance` toward zero; opposite signs
@@ -27,7 +27,9 @@ export declare function ceilingToSignificance(value: number, significance: numbe
  *  zero is #DIV/0!, not a silent 0. */
 export declare function modulo(value: number, divisor: number): number | SpreadsheetError;
 /** Excel POWER: a negative base with a non-integer exponent has no real root, so
- *  it is #NUM! rather than JS's NaN. */
+ *  it is #NUM! rather than JS's NaN. 0 to a negative power divides by zero
+ *  (#DIV/0!), 0^0 is #NUM!, and a result too large for a number is #NUM! where
+ *  JS answers Infinity. */
 export declare function power(base: number, exponent: number): number | SpreadsheetError;
 /** Natural log guarded to its domain: `LN(x)` for `x <= 0` is #NUM!, not
  *  -∞ / NaN. Reused by LN and LOG. */

package/dist/engine/numericCoercion.d.ts

@@ -36,3 +36,9 @@ export declare function holdsNumber(value: CellValue): boolean;
  * leading number, matching the engine's other numeric reads.
  */
 export declare function toScalarNumber(value: CellValue): number | SpreadsheetError;
+/**
+ * Whether a calculated cell value counts as a number in a range read by SUM, AVERAGE or COUNT:
+ * a number, or text that is entirely a number. A logical value and an empty string — what a
+ * formula like `=IF(…,"",…)` leaves — are not, as in Excel.
+ */
+export declare function isRangeNumber(value: CellValue): boolean;

package/dist/engine/registry.d.ts

@@ -5,6 +5,7 @@
  * allowing modular organization and easy extension of formula capabilities.
  */
 import type { CellValue } from "./types";
+import { type SpreadsheetError } from "./spreadsheet-errors";
 export type { CellValue };
 export type CellGetter = (ref: string) => CellValue;
 export type RangeGetter = (range: string) => CellValue[];
@@ -16,7 +17,14 @@ export interface FunctionContext {
     getCellValue: CellGetter;
     getRangeValues: RangeGetter;
     getRangeValuesRaw?: RawRangeGetter | undefined;
+    getRangeValuesKeepingBlanks?: RawRangeGetter | undefined;
+    /** How many cells of a range hold something, a formula's "" included (COUNTA). */
+    countFilledCells?: ((range: string) => number) | undefined;
     evaluateFormula: (formula: string) => CellValue;
+    /** Whether an argument is nothing but a reference to a blank cell, which evaluating reads as 0. */
+    isBlankReference?: ((arg: string) => boolean) | undefined;
+    /** Read an ambiguous `01/02/2020` as day-first, as the sheet's own dates are. */
+    preferDDMMYYYY?: boolean | undefined;
 }
 /** The too-few-arguments error, raised by the evaluator from the registry's
  *  `minArgs` before any handler runs — and by `requiredArg` for the argument a
@@ -41,6 +49,11 @@ export declare const requiredArg: (context: FunctionContext, args: string[], ind
  *  `FunctionContext` — a host that predates it keeps its old behaviour rather
  *  than throwing. */
 export declare const rawRangeReader: (context: FunctionContext) => RangeGetter;
+/** The positional reader with a blank cell read as "" rather than 0, for the functions that
+ *  must tell a blank from a stored 0: a criteria (`"<2"` does not match a blank), a pairing
+ *  (CORREL drops a row with a blank side), COUNTA. Lookups keep `rawRangeReader`, where a
+ *  blank reads as 0 the way Excel's INDEX returns it. */
+export declare const blankAwareRangeReader: (context: FunctionContext) => RangeGetter;
 export type FunctionHandler = (args: string[], context: FunctionContext) => CellValue;
 export interface FunctionDefinition {
     name: string;
@@ -53,9 +66,15 @@ export interface FunctionDefinition {
 }
 declare class FunctionRegistry {
     private functions;
+    private overlay;
     register(def: FunctionDefinition): void;
     get(name: string): FunctionDefinition | undefined;
     hasFunction(name: string): boolean;
+    /** Whether `name` is one of the engine's own functions, which a workbook may not redefine. */
+    isBuiltIn(name: string): boolean;
+    /** Run `calculate` with `functions` (keyed by upper-case name) visible as well. Only for a
+     *  synchronous calculation: nothing else can run between setting the overlay and taking it off. */
+    withOverlay<T>(functions: ReadonlyMap<string, FunctionDefinition>, calculate: () => T): T;
     getAllFunctions(): FunctionDefinition[];
     getFunctionsByCategory(): Map<string, FunctionDefinition[]>;
 }
@@ -63,6 +82,11 @@ export declare const functionRegistry: FunctionRegistry;
 /** Whether `name` written before "(" is a function call. A letters-only name is,
  *  registered or not (an unknown one reports #NAME?). A name with digits is only
  *  when registered: LOG10 is also shaped like a cell reference, so `A1(2)` is not. */
+/** A function name as a formula spells it: letters and digits, with `.`-joined
+ *  parts for the names current Excel uses (`PERCENTILE.INC`, `STDEV.S`). A part may
+ *  start with a digit (`T.DIST.2T`). Used as a regex SOURCE by every place that
+ *  looks for a call. */
+export declare const FUNCTION_NAME_SOURCE = "[A-Z][A-Z0-9]*(?:\\.[A-Z0-9]+)*";
 export declare const isCallableName: (name: string) => boolean;
 /**
  * Lenient numeric coercion for range aggregation: anything unreadable is 0.
@@ -70,12 +94,16 @@ export declare const isCallableName: (name: string) => boolean;
  * in numericCoercion.parseNumericString, shared with the strict scalar read.
  */
 export declare function toNumber(value: CellValue): number;
-/**
- * Helper function to convert a value to a string
- */
+/** A value as text, as Excel writes it: a logical value is TRUE or FALSE. */
 export declare function toString(value: CellValue): string;
 /**
  * Helper to parse criteria for conditional functions like COUNTIF, SUMIF
  * Returns a comparison function that tests if a value matches the criteria
  */
-export declare function parseCriteria(criteria: string): (value: CellValue) => boolean;
+export declare function parseCriteria(criteria: string, preferDDMMYYYY?: boolean): (value: CellValue) => boolean;
+/** The matcher for the criteria argument at `index`, or the error it evaluated to.
+ *
+ *  A criteria is an expression like any other argument: `">=2"`, `C1`, `">="&C1`. Reading its
+ *  source text instead matched `C1` against the letters "C1", so a criteria held in a cell or
+ *  built with `&` matched nothing and the function answered a silent 0. */
+export declare function criteriaArg(context: FunctionContext, args: string[], index: number): ((value: CellValue) => boolean) | SpreadsheetError;

package/dist/engine/sheetReference.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Reading the sheet out of a sheet-qualified reference: `Data!A1`, `'My Sheet'!A1:B2`, and a
+ * quoted name holding an apostrophe written twice, as Excel writes it (`'It''s'!A1` names It's).
+ */
+/** A reference split from the sheet it names. */
+export interface SheetQualifiedReference {
+    sheetName: string;
+    ref: string;
+}
+/** The sheet a reference names and the reference within it, or null when it names no sheet. */
+export declare function splitSheetReference(fullRef: string): SheetQualifiedReference | null;
+/** The index just past the closing quote of the sheet name that opens at `start` (a `'`), a
+ *  doubled `''` inside it read as part of the name; -1 when the name never closes. */
+export declare function endOfQuotedSheetName(text: string, start: number): number;

package/dist/engine/textCollation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Comparing text the way Excel sorts it, without depending on the runtime's ICU: the browser
+ * and the server both calculate a sheet, and a collation that varies with the ICU build could
+ * answer one comparison two ways. Case is ignored and accents count, as in Intl.Collator("en",
+ * { sensitivity: "accent" }), whose order on ASCII this reproduces.
+ */
+/** Negative, zero or positive as `left` sorts before, with or after `right`. */
+export declare function compareText(left: string, right: string): number;

package/dist/engine/textComparison.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Excel comparison (`=` `<>` `<` `>` `<=` `>=`) over values of any type.
+ *
+ * Comparison binds looser than `&`, so `A1&B1="12"` compares the joined text.
+ * Excel orders numbers before text before booleans, compares text by language order
+ * without regard to case (accents count), and never finds a number equal to text
+ * (`"12"=12` is FALSE). A chain reads left to right: `1=1=TRUE` is `(1=1)=TRUE`.
+ */
+import type { CellValue } from "./types";
+export type ExcelComparisonOperator = "=" | "<>" | "<" | ">" | "<=" | ">=";
+export interface ComparisonChain {
+    operands: string[];
+    operators: ExcelComparisonOperator[];
+}
+/** The operands and operators of a top-level comparison chain; null when there is none, or when a
+ *  run is not one of Excel's six operators (`==`, `!=`) or an operand is empty. */
+export declare function splitTopLevelComparisons(expr: string): ComparisonChain | null;
+/** Negative, zero or positive as `left` sorts before, with or after `right` in Excel's order. */
+export declare function compareCellValues(left: CellValue, right: CellValue): number;
+export declare function applyComparison(operator: ExcelComparisonOperator, left: CellValue, right: CellValue): boolean;
+/** Fold a chain left to right; `values` holds one more entry than `operators`. */
+export declare function foldComparisons(values: CellValue[], operators: ExcelComparisonOperator[]): CellValue;

package/dist/engine/translateFormula.d.ts

@@ -7,17 +7,21 @@
  * allowlists that gate that evaluation. No engine or evaluator state is
  * captured — every function here is input → output only.
  */
-/** Excel `^` exponentiation → JS `**`.
+/** Excel `^` exponentiation → JS `**`, with Excel's precedence.
  *
- * Excel's `^` is left-associative (`2^3^2` = `(2^3)^2` = 64); JS `**` is
- * right-associative (`2**3**2` = `2**(3**2)` = 512). This transform does not
- * bridge that difference, so a chained `^` still evaluates the JS way — a known
- * limitation tracked separately (#2359), pinned by the tests. */
+ * JS rejects a unary minus directly before `**` (`-2**2` is a syntax error) and
+ * reads `**` right to left. Excel negates first (`-2^2` = 4) and reads `^` left
+ * to right (`2^3^2` = 64), so each chain is rebuilt as `((-2)**3)**2`. Text
+ * outside a chain, and any `^` inside a string literal, is left as it is. */
 export declare function caretToPow(expr: string): string;
 /** Excel `&` string concatenation → JS `+`, leaving any `&` inside a quoted
  *  string literal untouched. A quote toggles the "inside a literal" state only
  *  when it is not backslash-escaped. */
 export declare function replaceConcatOperator(expr: string): string;
+/** A space between two `+` or two `-` in a row, outside string literals. JS reads `--` and `++`
+ *  as decrement and increment, so `=1--2` and `=--2` failed to parse; Excel reads each sign on
+ *  its own (`1- -2` is 3). Applied to the expression handed to `new Function` only. */
+export declare function separateRepeatedSigns(expr: string): string;
 /** Excel `=` equality → JS `==`, without disturbing `<=`, `>=` or `!=`. A single
  *  `=` is rewritten only when flanked by a non-`<>!` char on the left and a
  *  non-`=` on the right.
@@ -35,3 +39,10 @@ export declare function isSafeArithmetic(expr: string): boolean;
 /** Whether an expression contains only the characters a comparison evaluation
  *  may see: the arithmetic set plus ` < > ! = `. Gates `new Function`. */
 export declare function isSafeComparison(expr: string): boolean;
+interface OperatorToken {
+    kind: "literal" | "number" | "word" | "open" | "close" | "caret" | "space" | "symbol";
+    text: string;
+}
+/** Split an expression into the tokens operator precedence needs; joining the texts gives the input back. */
+export declare function tokenizeOperators(expr: string): OperatorToken[];
+export {};

package/dist/engine/wholeReferences.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Whole-column (`A:A`, `B:D`) and whole-row (`1:1`, `2:5`) references, rewritten as the bounded
+ * range they cover in their sheet: `A:A` becomes `A1:A<last row>`, `1:1` becomes
+ * `A1:<last column>1`. Everything past a sheet's data is blank, so the answers are Excel's, and
+ * every reader downstream (ranges, lookups, argument checks) sees an ordinary `A1:B2` range.
+ */
+/** How far a sheet's data reaches: the number of rows, and the longest row's length. */
+export interface SheetExtent {
+    rows: number;
+    columns: number;
+}
+/** The extent of the sheet a reference names (`null` for the formula's own sheet), or null when there is no such sheet. */
+export type ExtentOf = (sheetName: string | null) => SheetExtent | null;
+/**
+ * The formula with every whole-column and whole-row reference bounded to its sheet's data. Text
+ * inside a string literal (`"A:A"`) is left as written. A reference to a sheet that does not
+ * exist is left as written too, so it fails as any reference to that sheet does.
+ */
+export declare function boundWholeReferences(formula: string, extentOf: ExtentOf): string;

package/dist/index.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./samples-B6CgK8O-.cjs"),t=require("./core-PwJLsuHs.cjs");exports.MAX_RANGE_CELLS=t.t,exports.SYSTEM_PROMPT=e.b,exports.TOOL_DEFINITION=e.x,exports.TOOL_NAME=e.S,exports.calculatedRange=t.n,exports.executeSpreadsheet=e.u,exports.executeSpreadsheetDispatch=e.f,exports.isSpreadsheetArtifactPath=e.h,exports.isSpreadsheetDispatchArgs=e.p,exports.pluginCore=e.d,exports.readCalculatedRange=t.r,exports.samples=e.t;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./samples-UnTPgkyq.cjs"),t=require("./core-Cf9Pxo_q.cjs");exports.MAX_RANGE_CELLS=t.t,exports.SYSTEM_PROMPT=e.w,exports.TOOL_DEFINITION=e.T,exports.TOOL_NAME=e.E,exports.calculatedRange=t.n,exports.executeSpreadsheet=e.n,exports.executeSpreadsheetDispatch=e.g,exports.isSpreadsheetArtifactPath=e.y,exports.isSpreadsheetDispatchArgs=e._,exports.pluginCore=e.r,exports.readCalculatedRange=t.r,exports.samples=e.t;

package/dist/index.js

@@ -1,3 +1,3 @@
-import { S as e, b as t, d as n, f as r, h as i, p as a, t as o, u as s, x as c } from "./samples-miYeCJeQ.js";
-import { n as l, r as u, t as d } from "./core-CaJMHb3p.js";
-export { d as MAX_RANGE_CELLS, t as SYSTEM_PROMPT, c as TOOL_DEFINITION, e as TOOL_NAME, l as calculatedRange, s as executeSpreadsheet, r as executeSpreadsheetDispatch, i as isSpreadsheetArtifactPath, a as isSpreadsheetDispatchArgs, n as pluginCore, u as readCalculatedRange, o as samples };
+import { E as e, T as t, _ as n, g as r, n as i, r as a, t as o, w as s, y as c } from "./samples-C5JjpxYJ.js";
+import { n as l, r as u, t as d } from "./core-CTRlKL9k.js";
+export { d as MAX_RANGE_CELLS, s as SYSTEM_PROMPT, t as TOOL_DEFINITION, e as TOOL_NAME, l as calculatedRange, i as executeSpreadsheet, r as executeSpreadsheetDispatch, c as isSpreadsheetArtifactPath, n as isSpreadsheetDispatchArgs, a as pluginCore, u as readCalculatedRange, o as samples };

package/dist/lang/messages.d.ts

@@ -12,6 +12,11 @@ export interface Messages {
     dataMustBeArray: string;
     loadFailed(error: string): string;
     saveFailed(error: string): string;
+    fileChangedElsewhere: string;
+    saveConflict: string;
+    useFileVersion: string;
+    overwriteWithMine: string;
+    cellEditorClosedByChange: string;
     invalidJsonAlert(error: string): string;
     unknownError: string;
     update: string;