@rowsncolumns/fast-formula-parser 6.2.36 → 6.2.38

package/dist/cjs/index.js

@@ -3343,6 +3343,15 @@ function formatValue (value, parseData, opts) {
   return part ? runPart(value, part, opts, l10n) : opts.overflow;
 }
 
+function isDate (partitions) {
+  return !!(
+    (partitions[0] && partitions[0].date) ||
+    (partitions[1] && partitions[1].date) ||
+    (partitions[2] && partitions[2].date) ||
+    (partitions[3] && partitions[3].date)
+  );
+}
+
 const tokenHandlers = [
   [ TOKEN_GENERAL, /^General/i, 0 ],
   [ TOKEN_HASH, /^#/, 0 ],
@@ -3780,6 +3789,22 @@ function format (pattern, value, options = {}) {
   return formatValue(val, data, opts);
 }
 
+// FIXME: what is a a section?...
+/**
+ * Determine if a given format pattern is a date pattern.
+ *
+ * The pattern is considered a date pattern if any of its sections contain a
+ * date symbol (such as `Y` or `H`). Each section is restricted to be
+ * _either_ a number or date format.
+ *
+ * @param {string} pattern - A format pattern in the ECMA-376 number format.
+ * @returns {boolean} True if the specified pattern is date pattern, False otherwise.
+ */
+function isDateFormat (pattern) {
+  const data = prepareFormatterData(pattern, false);
+  return isDate(data.partitions);
+}
+
 // Excel indexed colors mapping used for legacy color references
 const IndexedColors = Object.freeze([
     // 0-7
@@ -3858,6 +3883,80 @@ const IndexedColors = Object.freeze([
 
 const isSingleSectionElapsedTimePattern = (pattern) => !pattern.includes(";") &&
     /\[(?:h+|m+|s+)\]/i.test(pattern.replace(/\[\$[^\]]+\]/g, ""));
+const intlMonthNames = (locale, options) => {
+    const formatter = new Intl.DateTimeFormat(locale, {
+        ...options,
+        timeZone: "UTC",
+    });
+    return Array.from({ length: 12 }, (_, month) => formatter
+        .formatToParts(new Date(Date.UTC(2020, month, 1)))
+        .find((part) => part.type === "month")?.value ?? "");
+};
+const intlRegisteredLocales = new Set();
+/**
+ * numfmt ships name tables for a fixed set of languages; a tag it does not know
+ * (et, ms, nn, …) silently renders English month/weekday names and en-US
+ * separators. Excel and `Intl.DateTimeFormat` localize every locale, so an
+ * unknown tag gets a numfmt locale built from Intl on first use: separators
+ * from `Intl.NumberFormat`, the in-date month names (numfmt's single table is
+ * the form used beside a day number — see `getStandaloneMonthLocale`), the
+ * in-date weekday names (the form `dateStyle: "full"` shows) and the AM/PM
+ * designators. Tags Intl itself does not know keep numfmt's fallback.
+ */
+const ensureNumfmtLocale = (locale) => {
+    if (intlRegisteredLocales.has(locale))
+        return;
+    intlRegisteredLocales.add(locale);
+    try {
+        if (getLocale(locale))
+            return;
+        const canonical = Intl.DateTimeFormat.supportedLocalesOf([locale])[0];
+        if (!canonical)
+            return;
+        const numberParts = new Intl.NumberFormat(locale).formatToParts(1234567.5);
+        const part = (type) => numberParts.find((p) => p.type === type)?.value;
+        const weekdayNames = (weekday) => {
+            // 2024-01-07 was a Sunday; numfmt indexes `dddd[0]` as Sunday.
+            const fmt = new Intl.DateTimeFormat(locale, {
+                weekday,
+                day: "numeric",
+                month: "long",
+                year: "numeric",
+                timeZone: "UTC",
+            });
+            return Array.from({ length: 7 }, (_, i) => fmt
+                .formatToParts(new Date(Date.UTC(2024, 0, 7 + i)))
+                .find((p) => p.type === "weekday")?.value ?? "");
+        };
+        const dayPeriod = (hour) => new Intl.DateTimeFormat(locale, {
+            hour: "numeric",
+            hour12: true,
+            timeZone: "UTC",
+        })
+            .formatToParts(new Date(Date.UTC(2024, 0, 7, hour)))
+            .find((p) => p.type === "dayPeriod")?.value;
+        const dateParts = new Intl.DateTimeFormat(locale, {
+            timeZone: "UTC",
+        }).formatToParts(new Date(Date.UTC(2024, 0, 7)));
+        const monthIndex = dateParts.findIndex((p) => p.type === "month");
+        const dayIndex = dateParts.findIndex((p) => p.type === "day");
+        const am = dayPeriod(9);
+        const pm = dayPeriod(21);
+        addLocale({
+            group: part("group") ?? "\u00a0",
+            decimal: part("decimal") ?? ".",
+            mmmm: intlMonthNames(locale, { day: "numeric", month: "long" }),
+            mmm: intlMonthNames(locale, { day: "numeric", month: "short" }),
+            dddd: weekdayNames("long"),
+            ddd: weekdayNames("short"),
+            ...(am && pm && am !== pm ? { ampm: [am, pm] } : {}),
+            preferMDY: monthIndex >= 0 && dayIndex >= 0 && monthIndex < dayIndex,
+        }, locale);
+    }
+    catch {
+        // Malformed tag: numfmt keeps its own fallback.
+    }
+};
 const localeForPattern = (pattern, locale) => {
     return locale;
 };
@@ -3965,14 +4064,158 @@ const DEFAULT_SEPARATORS = { decimal: ".", group: "," };
 const separatorsFor = (locale) => {
     return DEFAULT_SEPARATORS;
 };
+/**
+ * Rewrite the `[$symbol-LCID]` tokens of one section through `rewrite`,
+ * which receives the bracket content (`€-407`) and returns the new content,
+ * or an empty string to drop the token. Quoted literals, escapes and other
+ * bracket directives are left as written.
+ */
+const rewriteSectionLocaleTokens = (section, rewrite) => {
+    let out = "";
+    let inQuotes = false;
+    let inBrackets = false;
+    for (let i = 0; i < section.length; i++) {
+        const char = section[i];
+        if (inQuotes) {
+            inQuotes = char !== '"';
+        }
+        else if (inBrackets) {
+            inBrackets = char !== "]";
+        }
+        else if (char === '"') {
+            inQuotes = true;
+        }
+        else if (char === "[") {
+            const end = section[i + 1] === "$" ? section.indexOf("]", i) : -1;
+            if (end > 0) {
+                const token = rewrite(section.slice(i + 1, end));
+                if (token)
+                    out += `[${token}]`;
+                i = end;
+                continue;
+            }
+            inBrackets = true;
+        }
+        else if (char === "\\" || char === "_" || char === "*") {
+            out += char + (section[i + 1] ?? "");
+            i++;
+            continue;
+        }
+        out += char;
+    }
+    return out;
+};
+/** `[$€-407]` → `[$€]`; a bare `[$-407]` goes away. */
+const currencySymbolOnly = (token) => {
+    const dash = token.indexOf("-");
+    const symbol = dash < 0 ? token : token.slice(0, dash);
+    return symbol.length > 1 ? symbol : "";
+};
+const separatorLocales = new Map();
+/**
+ * Companion numfmt locale carrying `locale`'s calendar names and AM/PM with
+ * the workbook's decimal / group separators, so a date section pinned to
+ * `[$-407]` renders German names but a workbook decimal mark in `ss.00`.
+ * Returns `locale` itself when its separators already match.
+ */
+const getWorkbookSeparatorLocale = (locale, separators) => {
+    const key = `${locale}\u0000${separators.decimal}\u0000${separators.group}`;
+    const cached = separatorLocales.get(key);
+    if (cached !== undefined)
+        return cached;
+    let overlay = locale;
+    try {
+        const base = getLocale(locale);
+        if (base &&
+            (base.decimal !== separators.decimal || base.group !== separators.group)) {
+            // numfmt locale ids are `[a-z\d]+` with one optional `_` part.
+            const hex = (text) => [...text].map((c) => c.codePointAt(0).toString(16)).join("x");
+            overlay = `sep${hex(separators.decimal)}x${hex(separators.group)}_${locale.replace(/[^a-z\d]/gi, "")}`;
+            addLocale({ ...base, decimal: separators.decimal, group: separators.group }, overlay);
+        }
+    }
+    catch {
+        overlay = locale;
+    }
+    separatorLocales.set(key, overlay);
+    return overlay;
+};
+/**
+ * Re-point a date section's `[$symbol-LCID]` token at the companion locale
+ * with the workbook's separators (`$-407` → `$-sep2ex2c_407`). An LCID numfmt
+ * does not know or one carrying calendar bits stays as written.
+ */
+const workbookSeparatorLocaleToken = (separators) => (token) => {
+    const dash = token.indexOf("-");
+    if (dash < 0)
+        return token;
+    const code = token.slice(dash + 1);
+    const wincode = Number.parseInt(code, 16);
+    if (Number.isFinite(wincode) && wincode & 0xff0000)
+        return token;
+    if (!getLocale(code))
+        return token;
+    return `${token.slice(0, dash + 1)}${getWorkbookSeparatorLocale(code, separators)}`;
+};
+const isDateSection = (section) => {
+    try {
+        return isDateFormat(section);
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Excel's `[$symbol-LCID]` token selects the currency symbol and the
+ * language of day/month names and AM/PM; digit grouping and the decimal
+ * separator follow the workbook locale (`[$€-407] #,##0.00` is
+ * `€ 1,234.50` on a US host). numfmt applies the token's locale to the whole
+ * section, separators included, so the locale part is dropped from every
+ * section that is not a date (number, scientific, fraction, text, …); a
+ * date section keeps the token for its names, re-pointed at a companion
+ * locale that carries the workbook's separators for fractional seconds.
+ * Returns `undefined` when nothing had to change.
+ */
+const withWorkbookSeparators = (pattern, locale) => {
+    if (!pattern.includes("[$"))
+        return undefined;
+    const sections = splitFormatSections(pattern);
+    let changed = false;
+    let dateTokens;
+    const rewritten = sections.map((section) => {
+        if (!section.includes("[$"))
+            return section;
+        let rewrite = currencySymbolOnly;
+        if (isDateSection(section)) {
+            dateTokens ??= workbookSeparatorLocaleToken(separatorsFor());
+            rewrite = dateTokens;
+        }
+        const stripped = rewriteSectionLocaleTokens(section, rewrite);
+        changed ||= stripped !== section;
+        return stripped;
+    });
+    return changed ? rewritten.join(";") : undefined;
+};
+const workbookSeparatorPatternCache = new Map();
+const withWorkbookSeparatorsCached = (code, locale) => {
+    const key = `${""}\u0000${code}`;
+    let rewritten = workbookSeparatorPatternCache.get(key);
+    if (rewritten === undefined) {
+        rewritten = withWorkbookSeparators(code) ?? code;
+        workbookSeparatorPatternCache.set(key, rewritten);
+    }
+    return rewritten;
+};
 const ssfFormat = (pattern, value, locale) => {
     try {
+        if (locale)
+            ;
         let shortAmPm = shortAmPmPatternCache.get(pattern);
         if (shortAmPm === undefined && !shortAmPmPatternCache.has(pattern)) {
             shortAmPm = withShortAmPmMarker(pattern);
             shortAmPmPatternCache.set(pattern, shortAmPm);
         }
-        const code = shortAmPm ?? pattern;
+        const code = withWorkbookSeparatorsCached(shortAmPm ?? pattern, locale);
         let patternLocale = localeForPattern(pattern, locale);
         if (shortAmPm !== undefined && patternLocale) {
             patternLocale = getShortAmPmLocale(patternLocale);
@@ -4675,10 +4918,12 @@ class FormulaHelpersClass {
       !isRaw && Object.prototype.hasOwnProperty.call(param, "value");
     if (hasValueProp) {
       if (param.value == null) {
-        if (type === Types.STRING) {
-          // Blank cells should behave like empty strings in text formulas
-          return "";
-        }
+        // A blank cell is not an omitted argument (only omission takes
+        // `defValue`): Excel reads it as "" in a text slot, 0 in a number
+        // slot and FALSE in a logical slot.
+        if (type === Types.STRING) return "";
+        if (type === Types.NUMBER || type === Types.NUMBER_NO_BOOLEAN) return 0;
+        if (type === Types.BOOLEAN) return false;
         param = param.value;
       } else {
         param = param.value;
@@ -4758,6 +5003,7 @@ class FormulaHelpersClass {
    * @param range2
    */
   retrieveRanges(context, range1, range2) {
+    if (range1 === undefined) throw FormulaError.ARG_MISSING([Types.ARRAY]);
     // process args
     range2 = Address.extend(range1, range2);
 
@@ -4774,6 +5020,9 @@ class FormulaHelpersClass {
   }
 
   retrieveArg(context, arg) {
+    // `null` is an explicitly skipped argument (`SUMIF(A1:A5,,B1:B5)`);
+    // `undefined` is one the call never supplied — too few arguments.
+    if (arg === undefined) throw FormulaError.ARG_MISSING([Types.ARRAY]);
     if (arg === null) return { value: 0, isArray: false, omitted: true };
     const res = context.utils.extractRefValue(arg);
     return { value: res.val, isArray: res.isArray, ref: arg.ref };
@@ -6343,33 +6592,48 @@ const TextFunctions = {
     return text.slice(0, m.index) + expanded + text.slice(m.index + m[0].length);
   },
 
+  /**
+   * JOIN(delimiter, value_or_array1, [value_or_array2, …]) — Google Sheets.
+   * Ranges / arrays contribute every element; blanks and empty text are
+   * skipped; values spell as TEXTJOIN spells them (TRUE, 15-digit numbers) and
+   * an error among the values propagates. The rnc engine mirrors these rules.
+   */
   JOIN: (delimiter, ...values) => {
     delimiter = H$a.accept(delimiter, Types.STRING);
     const result = [];
 
-    H$a.flattenParams(values, null, true, (item) => {
-      if (item !== undefined && item !== null && item !== "") {
-        result.push(String(item));
-      }
+    H$a.flattenParams(values, Types.STRING, true, (item) => {
+      if (item === undefined || item === null) return;
+      const str = H$a.accept(item, Types.STRING);
+      if (str !== "") result.push(str);
     });
 
     return result.join(delimiter);
   },
 
+  /**
+   * SPLIT(text, delimiter, [split_by_each=TRUE], [remove_empty_text=TRUE]) —
+   * Google Sheets. Pieces stay text (no number coercion); an empty delimiter
+   * is #VALUE!; when every piece is removed the result is empty text. The
+   * rnc engine mirrors these rules.
+   */
   SPLIT: (text, delimiter, splitByEach, removeEmpty) => {
     text = H$a.accept(text, Types.STRING);
     delimiter = H$a.accept(delimiter, Types.STRING);
     splitByEach = H$a.accept(splitByEach, Types.BOOLEAN, true);
     removeEmpty = H$a.accept(removeEmpty, Types.BOOLEAN, true);
+    if (delimiter === "") throw FormulaError.VALUE;
 
     let parts;
     if (splitByEach) {
-      // Split by each character in delimiter
-      const delimiterChars = delimiter.split("");
-      const regex = new RegExp(
-        "[" + delimiterChars.map((c) => "\\" + c).join("") + "]"
-      );
-      parts = text.split(regex);
+      // Every character of the delimiter is a separator — a literal character,
+      // never a RegExp class ("d" must not become \d, "b" must not become \b).
+      const separators = new Set(delimiter);
+      parts = [""];
+      for (const ch of text) {
+        if (separators.has(ch)) parts.push("");
+        else parts[parts.length - 1] += ch;
+      }
     } else {
       // Split by the entire delimiter string
       parts = text.split(delimiter);
@@ -6378,6 +6642,7 @@ const TextFunctions = {
     if (removeEmpty) {
       parts = parts.filter((part) => part !== "");
     }
+    if (parts.length === 0) return "";
 
     // Return as a single row array
     return [parts];
@@ -12353,20 +12618,56 @@ const collectNumericValues = (array) => {
 // FORECAST.ETS helpers — Holt-Winters AAA implementation.
 // ---------------------------------------------------------------------
 
+// Excel's `seasonality` argument: 1 (the default) auto-detects the
+// period, 0 fits without a seasonal component, 2..8760 forces the
+// period; anything else is #NUM!. Fractions are truncated.
+const ETS_MAX_SEASONALITY = 8760;
+const forecastEtsSeasonality = (seasonalityArg) => {
+    if (seasonalityArg == null) return 1;
+    const value = H$8.accept(seasonalityArg, Types.NUMBER, 1);
+    if (value == null) return 1;
+    const seasonality = Math.floor(value);
+    if (seasonality < 0 || seasonality > ETS_MAX_SEASONALITY) throw FormulaError.NUM;
+    return seasonality;
+};
+
+// `data_completion` must be 0 or 1 and `aggregation` 1..7 (AVERAGE,
+// COUNT, COUNTA, MAX, MEDIAN, MIN, SUM), otherwise #NUM!. Neither
+// changes the fit: the timeline is used as given (no gap filling,
+// duplicates are not aggregated).
+const forecastEtsValidateOptions = (dataCompletionArg, aggregationArg) => {
+    if (dataCompletionArg != null) {
+        const completion = Math.floor(H$8.accept(dataCompletionArg, Types.NUMBER, 1));
+        if (completion !== 0 && completion !== 1) throw FormulaError.NUM;
+    }
+    if (aggregationArg != null) {
+        const aggregation = Math.floor(H$8.accept(aggregationArg, Types.NUMBER, 1));
+        if (aggregation < 1 || aggregation > 7) throw FormulaError.NUM;
+    }
+};
+
 // Pair up timeline + values, sort by timeline, infer the constant
 // step (Excel requires a uniformly-spaced timeline), and resolve
-// the seasonality parameter (auto-detect when 0/null/missing).
+// the seasonality parameter (Excel spelling: 1 auto-detects, 0 is no
+// seasonality, n > 1 is the period).
 const forecastEtsPrep = (ys, xs, seasonality) => {
     if (xs.length !== ys.length) throw FormulaError.NA;
     const pairs = [];
     for (let i = 0; i < xs.length; i++) {
         const x = xs[i];
         const yv = ys[i];
+        // An error anywhere in the series is the result (Excel and the Rust
+        // port's `series_number`); other non-numbers (text, blanks) are skipped.
+        if (x instanceof FormulaError) throw x;
+        if (yv instanceof FormulaError) throw yv;
         if (typeof x !== "number") continue;
         if (typeof yv !== "number") continue;
         pairs.push([x, yv]);
     }
-    if (pairs.length < 4) throw FormulaError.NA;
+    // Excel fits from two pairs (there is no four-pair floor); fewer is
+    // #N/A, and two pairs on the same timeline point have no step (#NUM!
+    // below). rowsncolumns/spreadsheet#642 B-01.
+    if (pairs.length < 2) throw FormulaError.NA;
     pairs.sort((a, b) => a[0] - b[0]);
     const sortedX = pairs.map(p => p[0]);
     const y = pairs.map(p => p[1]);
@@ -12382,12 +12683,12 @@ const forecastEtsPrep = (ys, xs, seasonality) => {
     diffs.sort((a, b) => a - b);
     const step = diffs[Math.floor(diffs.length / 2)];
     let period;
-    if (seasonality === 1) {
+    if (seasonality === 0) {
         period = 1; // No seasonality (linear Holt).
-    } else if (seasonality > 1) {
-        period = seasonality;
-    } else {
+    } else if (seasonality === 1) {
         period = detectSeasonality(y);
+    } else {
+        period = seasonality;
     }
     return { y, lastX: sortedX[sortedX.length - 1], step, period };
 };
@@ -12404,7 +12705,7 @@ const detectSeasonality = (y) => {
     const n = y.length;
     if (n < 4) return 1;
     const maxPeriod = Math.min(Math.floor(n / 2), 12);
-    const baseline = runHoltWinters(y, 1, 0.5, 0.1, 0, 0).sse;
+    const baseline = runHoltWinters(y, 1, 0.5, 0.1, 0).sse;
     let bestPeriod = 1;
     let bestSse = baseline;
     for (let m = 2; m <= maxPeriod; m++) {
@@ -12415,7 +12716,7 @@ const detectSeasonality = (y) => {
         for (const alpha of [0.3, 0.7]) {
             for (const beta of [0.1, 0.3]) {
                 for (const gamma of [0.3, 0.7]) {
-                    const sse = runHoltWinters(y, m, alpha, beta, gamma, 0).sse;
+                    const sse = runHoltWinters(y, m, alpha, beta, gamma).sse;
                     if (sse < mSse) mSse = sse;
                 }
             }
@@ -12431,11 +12732,10 @@ const detectSeasonality = (y) => {
 };
 
 // Fit Holt-Winters additive model with the supplied (or auto-fit) α,
-// β, γ smoothing parameters. Returns fitted in-sample values + the
-// `horizon`-step-ahead forecast. period=1 collapses to Holt linear
-// (no seasonal component).
-const fitHoltWinters = (y, period, horizon) => {
-    y.length;
+// β, γ smoothing parameters. Returns the fitted in-sample values and the
+// terminal state (`forecastAt(h)` extrapolates it to any horizon in O(1)).
+// period=1 collapses to Holt linear (no seasonal component).
+const fitHoltWinters = (y, period) => {
     // Grid search the smoothing params. The 5×5×5 grid is coarse but
     // close enough to the SSE-minimizing optimum that Excel's results
     // round-match within ~1% on the seasonal demo series.
@@ -12445,7 +12745,7 @@ const fitHoltWinters = (y, period, horizon) => {
     for (const alpha of grid) {
         for (const beta of grid) {
             for (const gamma of candidateGammas) {
-                const result = runHoltWinters(y, period, alpha, beta, gamma, horizon);
+                const result = runHoltWinters(y, period, alpha, beta, gamma);
                 if (best == null || result.sse < best.sse) {
                     best = { alpha, beta, gamma, ...result };
                 }
@@ -12455,7 +12755,25 @@ const fitHoltWinters = (y, period, horizon) => {
     return best;
 };
 
-const runHoltWinters = (y, period, alpha, beta, gamma, horizon) => {
+// The forecast `h` whole steps past the last observation from a run's
+// terminal state: level + h·trend + seasonal[(n + h - 1) mod m]. O(1) in
+// `h` — the old per-step forecast array made `FORECAST.ETS(1E15, …)`
+// hang the tab (and trapped the Rust engine's wasm with a capacity
+// overflow that poisoned the whole store). rowsncolumns/spreadsheet#642 B-06.
+const holtWintersForecastAt = ({ n, m, level, trend, seasonal }, h) => {
+    const seasonComp = m > 1 ? seasonal[(n + h - 1) % m] : 0;
+    return level + h * trend + seasonComp;
+};
+
+// One additive Holt-Winters pass with fixed smoothing parameters. The
+// initial level is the level one step *before* the series (first value
+// or first-cycle mean, minus the trend), so the one-step-ahead prediction
+// of the first observation is the observation itself and a perfectly
+// linear history has zero residual — an initial level *at* the first
+// value predicted y₀ + trend for y₀, and that spurious residual pulled
+// the grid search off the exact continuation (10,20,…,100 → 109.56
+// instead of Excel's 110). rowsncolumns/spreadsheet#642 B-01.
+const runHoltWinters = (y, period, alpha, beta, gamma) => {
     const n = y.length;
     const m = period;
     const fitted = new Array(n).fill(null);
@@ -12463,21 +12781,21 @@ const runHoltWinters = (y, period, alpha, beta, gamma, horizon) => {
     const seasonal = new Array(m).fill(0);
     if (m > 1 && n >= 2 * m) {
         // Initial seasonal indices = first-cycle deviations from the
-        // first-cycle mean. Initial level = mean of first cycle.
-        // Initial trend = average of per-step changes between first
-        // and second cycle, normalized by m.
+        // first-cycle mean. Initial trend = average of per-step changes
+        // between first and second cycle, normalized by m. Initial level
+        // = mean of first cycle, one trend step back.
         let sum1 = 0;
         for (let i = 0; i < m; i++) sum1 += y[i];
         const mean1 = sum1 / m;
-        level = mean1;
         let trendSum = 0;
         for (let i = 0; i < m; i++) trendSum += (y[i + m] - y[i]) / m;
         trend = trendSum / m;
+        level = mean1 - trend;
         for (let i = 0; i < m; i++) seasonal[i] = y[i] - mean1;
     } else {
-        // Holt linear initialization.
-        level = y[0];
+        // Holt linear initialization, one trend step back.
         trend = n > 1 ? y[1] - y[0] : 0;
+        level = y[0] - trend;
     }
     let sse = 0;
     let count = 0;
@@ -12496,12 +12814,12 @@ const runHoltWinters = (y, period, alpha, beta, gamma, horizon) => {
             seasonal[seasonIdx] = gamma * (y[t] - level) + (1 - gamma) * seasonComp;
         }
     }
-    const forecast = [];
-    for (let h = 1; h <= horizon; h++) {
-        const seasonComp = m > 1 ? seasonal[(n + h - 1) % m] : 0;
-        forecast.push(level + h * trend + seasonComp);
-    }
-    return { fitted, forecast, sse: count > 0 ? sse / count : Infinity };
+    const state = { n, m, level, trend, seasonal };
+    return {
+        fitted,
+        sse: count > 0 ? sse / count : Infinity,
+        forecastAt: (h) => holtWintersForecastAt(state, h),
+    };
 };
 
 const percentileInclusive = (values, k) => {
@@ -13267,20 +13585,18 @@ const DistributionFunctions = {
     // trend. We use the same idea — scan candidate periods 2..N/2,
     // capped at 12 (Excel's default cap for monthly data), and pick
     // the one with the lowest in-sample SSE for the fitted Holt-Winters
-    // model. Passing `seasonality = 1` forces "no seasonality" (Holt
-    // linear).
+    // model. `seasonality` follows Excel: 1 (default) auto-detects, 0
+    // forces "no seasonality" (Holt linear), n > 1 is the period. The
+    // Rust engine (formualizer `stats/forecast_ets.rs`) is a port of this
+    // code, so both engines agree to 1e-9 on the same inputs.
     // -------------------------------------------------------------------
 
     'FORECAST.ETS': (targetDate, values, timeline, seasonalityArg, dataCompletionArg, aggregationArg) => {
         const target = H$8.accept(targetDate, Types.NUMBER);
         const ys = H$8.accept(values, Types.ARRAY, undefined, true, true);
         const xs = H$8.accept(timeline, Types.ARRAY, undefined, true, true);
-        const seasonality = seasonalityArg == null
-            ? 1
-            : Math.floor(H$8.accept(seasonalityArg, Types.NUMBER, 1));
-        // dataCompletion + aggregation honored only at the prep step —
-        // gap-filling uses the previous value (matches Excel's
-        // dataCompletion=1 default).
+        const seasonality = forecastEtsSeasonality(seasonalityArg);
+        forecastEtsValidateOptions(dataCompletionArg, aggregationArg);
         const { y, lastX, step, period } = forecastEtsPrep(ys, xs, seasonality);
         if (target < lastX) {
             // Excel returns #NUM! for in-history targets in FORECAST.ETS
@@ -13288,12 +13604,14 @@ const DistributionFunctions = {
             throw FormulaError.NUM;
         }
         const horizon = Math.round((target - lastX) / step);
+        if (!Number.isFinite(horizon)) throw FormulaError.NUM;
         if (horizon < 1) return y[y.length - 1];
-        const { fitted: _f, forecast } = fitHoltWinters(y, period, horizon);
-        return forecast[horizon - 1];
+        const forecast = fitHoltWinters(y, period).forecastAt(horizon);
+        if (!Number.isFinite(forecast)) throw FormulaError.NUM;
+        return forecast;
     },
 
-    'FORECAST.ETS.CONFINT': (targetDate, values, timeline, confidenceArg, seasonalityArg) => {
+    'FORECAST.ETS.CONFINT': (targetDate, values, timeline, confidenceArg, seasonalityArg, dataCompletionArg, aggregationArg) => {
         const target = H$8.accept(targetDate, Types.NUMBER);
         const ys = H$8.accept(values, Types.ARRAY, undefined, true, true);
         const xs = H$8.accept(timeline, Types.ARRAY, undefined, true, true);
@@ -13301,13 +13619,13 @@ const DistributionFunctions = {
             ? 0.95
             : H$8.accept(confidenceArg, Types.NUMBER, 0.95);
         if (confidence <= 0 || confidence >= 1) throw FormulaError.NUM;
-        const seasonality = seasonalityArg == null
-            ? 1
-            : Math.floor(H$8.accept(seasonalityArg, Types.NUMBER, 1));
+        const seasonality = forecastEtsSeasonality(seasonalityArg);
+        forecastEtsValidateOptions(dataCompletionArg, aggregationArg);
         const { y, lastX, step, period } = forecastEtsPrep(ys, xs, seasonality);
         if (target < lastX) throw FormulaError.NUM;
         const horizon = Math.max(1, Math.round((target - lastX) / step));
-        const { fitted, forecast: _fc } = fitHoltWinters(y, period, horizon);
+        if (!Number.isFinite(horizon)) throw FormulaError.NUM;
+        const { fitted } = fitHoltWinters(y, period);
         // RMSE of in-sample residuals — z-scaled to the requested
         // confidence level. Excel uses √(horizon) scaling on the
         // forecast variance.
@@ -13320,26 +13638,28 @@ const DistributionFunctions = {
         }
         const rmse = n > 0 ? Math.sqrt(sse / n) : 0;
         const z = jStat.normal.inv(1 - (1 - confidence) / 2, 0, 1);
-        return z * rmse * Math.sqrt(horizon);
+        const halfWidth = z * rmse * Math.sqrt(horizon);
+        if (!Number.isFinite(halfWidth)) throw FormulaError.NUM;
+        return halfWidth;
     },
 
-    'FORECAST.ETS.SEASONALITY': (values, timeline) => {
+    'FORECAST.ETS.SEASONALITY': (values, timeline, dataCompletionArg, aggregationArg) => {
         const ys = H$8.accept(values, Types.ARRAY, undefined, true, true);
         const xs = H$8.accept(timeline, Types.ARRAY, undefined, true, true);
-        const { y } = forecastEtsPrep(ys, xs, 0);
-        return detectSeasonality(y);
+        forecastEtsValidateOptions(dataCompletionArg, aggregationArg);
+        const { period } = forecastEtsPrep(ys, xs, 1);
+        return period;
     },
 
-    'FORECAST.ETS.STAT': (values, timeline, statTypeArg, seasonalityArg) => {
+    'FORECAST.ETS.STAT': (values, timeline, statTypeArg, seasonalityArg, dataCompletionArg, aggregationArg) => {
         const ys = H$8.accept(values, Types.ARRAY, undefined, true, true);
         const xs = H$8.accept(timeline, Types.ARRAY, undefined, true, true);
         const statType = Math.floor(H$8.accept(statTypeArg, Types.NUMBER));
         if (statType < 1 || statType > 8) throw FormulaError.NUM;
-        const seasonality = seasonalityArg == null
-            ? 1
-            : Math.floor(H$8.accept(seasonalityArg, Types.NUMBER, 1));
+        const seasonality = forecastEtsSeasonality(seasonalityArg);
+        forecastEtsValidateOptions(dataCompletionArg, aggregationArg);
         const { y, period } = forecastEtsPrep(ys, xs, seasonality);
-        const { alpha, beta, gamma, fitted } = fitHoltWinters(y, period, 0);
+        const { alpha, beta, gamma, fitted } = fitHoltWinters(y, period);
         // Excel STAT codes:
         //   1: alpha   2: beta   3: gamma   4: MASE
         //   5: SMAPE   6: MAE    7: RMSE    8: detected step size
@@ -14424,6 +14744,9 @@ const DistributionFunctions = {
             const prediction = truncated.reduce((sum, value, idx) => sum + value * slopes[idx], 0) + intercept;
             return [prediction];
         });
+        // A single new_x is a plain number in Excel (and in the Rust
+        // engine); a 1x1 array would anchor an array formula on the cell.
+        if (result.length === 1) return result[0][0];
         return result;
     },
 
@@ -15406,7 +15729,7 @@ const StatisticalFunctions = {
   COUNTIF: (range, criteria) => {
     // do not flatten the array
     range = H$7.accept(range, Types.ARRAY, undefined, false, true);
-    const isCriteriaArray = criteria.isArray;
+    const isCriteriaArray = criteria?.isArray;
     criteria = H$7.accept(criteria);
 
     const countMatching = (parsed) => {
@@ -16721,7 +17044,15 @@ const MathFunctions = {
   FLOOR: (number, significance) => {
     number = H$6.accept(number, Types.NUMBER);
     significance = H$6.accept(significance, Types.NUMBER, 1);
-    if (significance === 0) return 0;
+    // Excel: a zero significance is #DIV/0! for FLOOR of a non-zero number
+    // (FLOOR(0,0) is 0; CEILING, FLOOR.MATH and FLOOR.PRECISE return 0); a
+    // positive number with a negative significance is #NUM!; a negative
+    // number rounds away from zero unless the significance is negative too
+    // (FLOOR(-2.5,2) = -4, FLOOR(-2.5,-2) = -2).
+    if (significance === 0) {
+      if (number === 0) return 0;
+      throw FormulaError.DIV0;
+    }
     if (number > 0 && significance < 0) throw FormulaError.NUM;
     const absSignificance = Math.abs(significance);
     const quotient = excelQuotient(Math.abs(number), absSignificance);
@@ -16746,6 +17077,7 @@ const MathFunctions = {
     // mode can be 0 or any other number, 0 means away from zero
     // the official documentation seems wrong
     mode = H$6.accept(mode, Types.NUMBER, 0);
+    if (significance === 0) return 0;
     // The Mode argument does not affect positive numbers.
     if (mode === 0 || number >= 0) {
       // away from zero
@@ -16758,7 +17090,8 @@ const MathFunctions = {
   "FLOOR.PRECISE": (number, significance) => {
     number = H$6.accept(number, Types.NUMBER);
     significance = H$6.accept(significance, Types.NUMBER, 1);
-    // always round up
+    // A zero significance is 0 (Excel); otherwise the mathematical floor.
+    if (significance === 0) return 0;
     return MathFunctions.FLOOR(number, Math.abs(significance));
   },
 
@@ -17264,6 +17597,22 @@ const MathFunctions = {
     return result;
   },
 
+  /**
+   * PERCENTOF(data_subset, data_all) — SUM(data_subset) / SUM(data_all) under
+   * SUM's rules (text / logical / blank cells inside ranges are skipped, error
+   * values propagate, a non-numeric scalar is #VALUE!); a zero whole is
+   * #DIV/0!. Excel 365's helper for GROUPBY / PIVOTBY percent-of-total.
+   */
+  PERCENTOF: (dataSubset, dataAll) => {
+    if (H$6.isOmitted(dataSubset) || H$6.isOmitted(dataAll)) {
+      throw FormulaError.ARG_MISSING([Types.NUMBER]);
+    }
+    const subset = MathFunctions.SUM(dataSubset);
+    const all = MathFunctions.SUM(dataAll);
+    if (all === 0) throw FormulaError.DIV0;
+    return subset / all;
+  },
+
   /**
    * This functions requires instance of {@link FormulaParser}.
    */
@@ -17771,6 +18120,11 @@ const applyToArray$1 = (value, checkFn) => {
  * Get the number of values that evaluate to true and false.
  * Cast Number and "TRUE", "FALSE" to boolean.
  * Ignore unrelated values.
+ * An error value — a direct argument (`AND(1/0, FALSE)`) or a cell inside a
+ * reference — is the result, whatever the other arguments decide: Excel never
+ * short-circuits AND/OR/XOR past an error, and the first one in argument order
+ * wins (rowsncolumns/spreadsheet#642 B-08). `flattenParams` only throws error
+ * values itself when a value type is requested.
  * @ignore
  * @param {any[]} params
  * @return {number[]}
@@ -17778,6 +18132,8 @@ const applyToArray$1 = (value, checkFn) => {
 function getNumLogicalValue(params) {
     let numTrue = 0, numFalse = 0;
     H$4.flattenParams(params, null, true, (val, info) => {
+        if (val instanceof FormulaError)
+            throw val;
         const type = typeof val;
         if (type === "string") {
             // Text inside a reference or array is ignored; a direct text
@@ -19850,6 +20206,10 @@ const ReferenceFunctions = {
         // Retrieve actual data to determine effective column count
         const { val: data } = context.utils.extractRefValue(obj, context.position);
         const colCount = Array.isArray(data) && Array.isArray(data[0]) ? data[0].length : 1;
+        // One column (`COLUMN(C:C)`, `COLUMN(B2:B5)`) is a plain number, as
+        // Excel shows it and as the Rust engine returns it; a 1x1 array would
+        // make the host anchor an array formula on the cell.
+        if (colCount <= 1) return fromCol;
         const result = [];
         for (let i = 0; i < colCount; i++) {
           result.push(fromCol + i);
@@ -19866,7 +20226,11 @@ const ReferenceFunctions = {
     if (obj == null) {
       throw Error("COLUMNS requires one argument");
     }
-    if (typeof obj != "object" || Array.isArray(obj)) throw FormulaError.VALUE;
+    if (obj instanceof FormulaError) throw obj;
+    // An array (`{1,2;3,4}`, `SEQUENCE(3,2)`, `RANDARRAY(3,2)`, a SORT/FILTER
+    // result) reports its width; a scalar is a 1×1 array (`COLUMNS(5)` = 1).
+    if (Array.isArray(obj)) return obj[0]?.length ?? 0;
+    if (typeof obj != "object") return 1;
     if (H$2.isCellRef(obj)) {
       return 1;
     } else if (H$2.isRangeRef(obj)) {
@@ -19917,6 +20281,7 @@ const ReferenceFunctions = {
 
   // Special
   INDEX: (context, ranges, rowNum, colNum, areaNum) => {
+    if (ranges === undefined) throw FormulaError.ARG_MISSING([Types.ARRAY]);
     // retrieve values
     const isColNumMissing = colNum == null;
     const isRowNumMissing = rowNum == null;
@@ -20299,6 +20664,8 @@ const ReferenceFunctions = {
         // Retrieve actual data to determine effective row count
         const { val: data } = context.utils.extractRefValue(obj, context.position);
         const rowCount = Array.isArray(data) ? data.length : 1;
+        // One row (`ROW(3:3)`, `ROW(B2:C2)`) is a plain number; see COLUMN.
+        if (rowCount <= 1) return fromRow;
         const result = [];
         for (let i = 0; i < rowCount; i++) {
           result.push([fromRow + i]); // Vertical array (column vector)
@@ -20315,7 +20682,11 @@ const ReferenceFunctions = {
     if (obj == null) {
       throw Error("ROWS requires one argument");
     }
-    if (typeof obj != "object" || Array.isArray(obj)) throw FormulaError.VALUE;
+    if (obj instanceof FormulaError) throw obj;
+    // An array (`{1,2;3,4}`, `SEQUENCE(3,2)`, `RANDARRAY(3,2)`, a SORT/FILTER
+    // result) reports its height; a scalar is a 1×1 array (`ROWS(5)` = 1).
+    if (Array.isArray(obj)) return obj.length;
+    if (typeof obj != "object") return 1;
     if (H$2.isCellRef(obj)) {
       return 1;
     } else if (H$2.isRangeRef(obj)) {
@@ -21117,6 +21488,44 @@ const ReferenceFunctions = {
     );
   },
 
+  /**
+   * TRIMRANGE(range, [trim_rows], [trim_cols]) — drops the blank rows /
+   * columns at the edges of a range or array: 0 keeps every row / column,
+   * 1 trims leading blanks, 2 trailing blanks, 3 (default) both. Only truly
+   * empty cells are blank (a "" text result or a 0 keeps its row); trimming
+   * everything away is `#REF!`, as in Excel. The function form of Excel's
+   * `A1.:.E10` / `A1:.E10` / `A1.:E10` trim-ref operators.
+   */
+  TRIMRANGE: (range, trim_rows, trim_cols) => {
+    if (H$2.isOmitted(range)) throw FormulaError.ARG_MISSING([Types.ARRAY]);
+    const mode = (arg) => {
+      if (H$2.isOmitted(arg)) return 3;
+      const n = Math.trunc(H$2.accept(arg, Types.NUMBER, 3));
+      if (n < 0 || n > 3) throw FormulaError.VALUE;
+      return n;
+    };
+    const trimRows = mode(trim_rows);
+    const trimCols = mode(trim_cols);
+    const m = toMatrix(range);
+    const height = m.length;
+    const width = m[0]?.length ?? 0;
+    const isBlank = (v) => v == null;
+    const blankRow = (r) => m[r].every(isBlank);
+    const blankCol = (c) => m.every((row) => isBlank(row[c]));
+    let rowStart = 0;
+    let rowEnd = height;
+    if (trimRows & 1) while (rowStart < rowEnd && blankRow(rowStart)) rowStart++;
+    if (trimRows & 2) while (rowEnd > rowStart && blankRow(rowEnd - 1)) rowEnd--;
+    let colStart = 0;
+    let colEnd = width;
+    if (trimCols & 1) while (colStart < colEnd && blankCol(colStart)) colStart++;
+    if (trimCols & 2) while (colEnd > colStart && blankCol(colEnd - 1)) colEnd--;
+    if (rowStart >= rowEnd || colStart >= colEnd) throw FormulaError.REF;
+    return m
+      .slice(rowStart, rowEnd)
+      .map((row) => row.slice(colStart, colEnd));
+  },
+
   /**
    * EXPAND(array, rows, [columns], [pad_with]) — grows an array to
    * `rows`×`columns`, filling new cells with `pad_with` (default `#N/A`).
@@ -21223,21 +21632,33 @@ const ReferenceFunctions = {
     return result;
   },
 
+  /**
+   * SORTN(range, [n], [display_ties_mode], [sort_column], [is_ascending]) —
+   * Google Sheets. SORT on one key column followed by the first n rows;
+   * display_ties_mode is accepted and ignored. A negative n is #VALUE!. The
+   * rnc engine mirrors these rules.
+   */
   SORTN: (context, range, n, displayTies, sortColumn, isAscending) => {
-    range = H$2.accept(range, Types.ARRAY);
+    range = H$2.accept(range, Types.ARRAY, undefined, false, true);
     n = H$2.accept(n, Types.NUMBER, range.length);
     displayTies = H$2.accept(displayTies, Types.NUMBER, 0);
     sortColumn = H$2.accept(sortColumn, Types.NUMBER, 1);
     isAscending = H$2.accept(isAscending, Types.BOOLEAN, true);
-
-    const sorted = ReferenceFunctions.SORT(
-      context,
-      range,
-      sortColumn,
-      isAscending,
-      false
-    );
-    return sorted.slice(0, n);
+    if (n < 0) throw FormulaError.VALUE;
+    if (!Array.isArray(range) || range.length === 0) return range;
+    // Same stable row sort as SORT's row path (SORT itself re-parses its
+    // arguments as parser params, so it cannot be called with the already
+    // accepted values — doing so made every SORTN call #VALUE!).
+    const width = range[0]?.length ?? 0;
+    if (sortColumn < 1 || sortColumn > width) throw FormulaError.VALUE;
+    const key = sortColumn - 1;
+    const compareValues = makeComparator(context?.locale);
+    const indexed = range.map((row, idx) => ({ row, idx }));
+    indexed.sort((a, b) => {
+      const comparison = compareValues(a.row[key], b.row[key]);
+      return (isAscending ? comparison : -comparison) || a.idx - b.idx;
+    });
+    return indexed.slice(0, n).map((entry) => entry.row);
   },
 
   /**
@@ -25350,6 +25771,10 @@ const FinancialFunctions = {
 // identifiers. Importers keep the cached result Excel wrote and exporters write
 // the formula back unchanged, so a workbook round-trips intact; only a
 // recalculation on this engine surfaces the #N/A.
+//
+// QUERY is the Google Sheets counterpart: it needs a query-language interpreter
+// neither engine has, and degrades the same way (the rnc engine registers the
+// same stub) so a Sheets-authored workbook evaluates identically on both.
 const unavailable = () => {
   throw FormulaError.NA;
 };
@@ -25369,6 +25794,7 @@ const ExternalFunctions = {
   EUROCONVERT: unavailable,
   TRANSLATE: unavailable,
   DETECTLANGUAGE: unavailable,
+  QUERY: unavailable,
 };
 
 var api$3 = {};
@@ -44517,7 +44943,10 @@ class Parser extends EmbeddedActionsParser {
         ) {
           return arr[0][0];
         }
-        return this.utils.toArray(arr);
+        const array = this.utils.toArray(arr);
+        return context.async
+          ? this.utils.settleArrayItems(array, $.position)
+          : array;
       });
     });
 
@@ -44538,9 +44967,13 @@ class Parser extends EmbeddedActionsParser {
             const prefix = $.OPTION(() => $.SUBRULE($.plusMinusOp));
             const image = $.CONSUME(Number$1).image;
             const number = $.ACTION(() => this.utils.toNumber(image));
+            // A signed literal is a plain number: apply the sign directly
+            // rather than through `applyPrefix`, whose async branch would
+            // hand the array a pending Promise (`{-100,60,60}` summed to 120
+            // under `parseAsync`).
             if (prefix)
               return $.ACTION(() =>
-                this.utils.applyPrefix([prefix], number, $.position)
+                this.utils.applyLiteralPrefix(prefix, number)
               );
             return number;
           },
@@ -45177,18 +45610,21 @@ const expandLet = (source) => {
 
 
 const LAMBDA_INTERNAL = "__RNC_LAMBDA__";
-/** Source spliced in for an optional parameter the caller left out. */
+/** Source spliced in for a parameter the caller left out. */
 const OMITTED_INTERNAL = "__RNC_OMITTED__";
 const OMITTED_CALL = `${OMITTED_INTERNAL}()`;
 /**
  * Runtime call of a lambda value: `__RNC_CALL__(lambda, arg1, …)`. Used
- * when `LAMBDA(...)(...)` cannot be inlined (arity mismatch) so the
- * evaluator reports `#VALUE!` like Excel instead of a parse error.
+ * when `LAMBDA(...)(...)` cannot be inlined (more arguments than
+ * parameters) so the evaluator reports `#VALUE!` like Excel instead of a
+ * parse error.
  */
 const CALL_INTERNAL = "__RNC_CALL__";
 
-// `[name]` — Excel's optional-parameter syntax. The lexer sees it as a
+// `[name]` — Excel's optional-parameter spelling. The lexer sees it as a
 // table-column token; only a bare identifier inside the brackets counts.
+// The brackets are documentation only: Excel lets a call leave out any
+// trailing parameter, bracketed or not (ISOMITTED reports it either way).
 const OPTIONAL_PARAM = /^\[\s*([A-Za-z_][A-Za-z0-9_.]*)\s*\]$/;
 
 /**
@@ -45206,8 +45642,6 @@ const paramFromSpan = (tokens, span) => {
   return null;
 };
 
-const requiredCount = (params) => params.filter((p) => !p.optional).length;
-
 /** Excel writes optional params back as `[name]`; keep that in the value form. */
 const paramsToSource = (params) =>
   params.map((p) => (p.optional ? `[${p.name}]` : p.name)).join(",");
@@ -45217,7 +45651,9 @@ const paramsToSource = (params) =>
  * IIFE inlining: when `LAMBDA(...)(...)` appears, substitute the
  * params with the call's arg sources and return the substituted body.
  * Returns null if the structure doesn't match (e.g. LAMBDA without
- * immediate invocation, or arity mismatch).
+ * immediate invocation). A call with more arguments than parameters is
+ * handed to the runtime, which reports `#VALUE!`; a call with fewer binds
+ * the missing parameters to the omitted marker.
  */
 const inlineIIFE = (source, tokens, lambdaOpenIdx, lambdaCloseIdx) => {
   // Next token after the lambda's close paren must be a bare OpenParen
@@ -45245,13 +45681,10 @@ const inlineIIFE = (source, tokens, lambdaOpenIdx, lambdaCloseIdx) => {
     callCloseIdx === callOpenIdx + 1
       ? []
       : splitArgs(tokens, callOpenIdx + 1, callCloseIdx);
-  if (
-    callArgSpans.length < requiredCount(params) ||
-    callArgSpans.length > params.length
-  ) {
-    // Arity mismatch — hand the call to the runtime, which applies the
-    // lambda value and reports #VALUE! (Excel's answer) instead of the
-    // parser choking on `(...)(...)`.
+  if (callArgSpans.length > params.length) {
+    // Too many arguments — hand the call to the runtime, which applies
+    // the lambda value and reports #VALUE! (Excel's answer) instead of
+    // the parser choking on `(...)(...)`.
     const lambdaValue = transformLambdaToValue(
       source,
       tokens,
@@ -45269,9 +45702,9 @@ const inlineIIFE = (source, tokens, lambdaOpenIdx, lambdaCloseIdx) => {
     };
   }
   const bindings = params.map(({ name }, i) => {
-    // Raw value — substituteNamesInBody decides the wrap. An omitted
-    // optional parameter binds to the omitted marker so ISOMITTED can
-    // see it.
+    // Raw value — substituteNamesInBody decides the wrap. A parameter the
+    // call left out binds to the omitted marker so ISOMITTED can see it
+    // (and any other use of it is #VALUE!).
     const value =
       i < callArgSpans.length
         ? sourceSlice(source, tokens, callArgSpans[i]).trim()
@@ -45396,14 +45829,15 @@ const isLambdaValue = (v) =>
   v != null && typeof v === "object" && v.__isLambda === true;
 
 /**
- * Marker bound to an optional `[param]` the caller left out. Only
+ * Marker bound to a parameter the caller left out (Excel allows a call
+ * with fewer arguments than parameters, `[param]` or not). Only
  * `ISOMITTED` looks at it; anywhere else it is an invalid operand.
  */
 const OMITTED = Object.freeze({ __isOmitted: true });
 const isOmittedValue = (v) =>
   v != null && typeof v === "object" && v.__isOmitted === true;
 
-/** `[name]` → optional parameter, `name` → required. */
+/** `[name]` → parameter documented as optional, `name` → plain parameter. */
 const parseLambdaParams = (paramsStr) =>
   paramsStr
     .split(",")
@@ -45414,9 +45848,43 @@ const parseLambdaParams = (paramsStr) =>
       return { name: optional ? raw.slice(1, -1).trim() : raw, optional };
     });
 
+/**
+ * An omitted marker that escapes `ISOMITTED` — a body that returns the
+ * omitted parameter itself, or spreads it into an array — is `#VALUE!`
+ * in the result, per cell inside an array. Arrays are only copied when
+ * one of their cells actually holds the marker.
+ */
+const rejectOmittedResult = (result) => {
+  if (isOmittedValue(result)) return FormulaError.VALUE;
+  if (!Array.isArray(result)) return result;
+  let out = null;
+  for (let i = 0; i < result.length; i++) {
+    const cell = rejectOmittedResult(result[i]);
+    if (cell !== result[i]) {
+      if (out === null) out = result.slice();
+      out[i] = cell;
+    }
+  }
+  return out ?? result;
+};
+
 const requiredParamCount = (lambda) =>
   lambda.params.filter((_, i) => !(lambda.optional?.[i] ?? false)).length;
 
+/**
+ * Excel's "Incorrect Parameters" `#VALUE!` for MAP / REDUCE / SCAN / BYROW /
+ * BYCOL / MAKEARRAY / GROUPBY / PIVOTBY: the helper drives the lambda with
+ * a fixed number of arguments and the lambda must declare a parameter for
+ * each of them. Only a `[name]` parameter may stay unsupplied — the
+ * "fewer arguments than parameters" allowance is for direct calls, not
+ * helpers. Returns the error for the whole helper call, or null when the
+ * counts fit.
+ */
+const hofArityError = (lambda, supplied) =>
+  supplied < requiredParamCount(lambda) || supplied > lambda.params.length
+    ? FormulaError.VALUE
+    : null;
+
 const formatLiteral = (value) => {
   if (value === null || value === undefined) return "0";
   if (value instanceof FormulaError) {
@@ -45459,12 +45927,11 @@ const formatLiteral = (value) => {
  */
 const applyLambda = async (context, lambda, args) => {
   if (!isLambdaValue(lambda)) return FormulaError.VALUE;
-  if (
-    args.length < requiredParamCount(lambda) ||
-    args.length > lambda.params.length
-  ) {
-    return FormulaError.VALUE;
-  }
+  // Excel rejects surplus arguments but accepts fewer than declared: the
+  // missing parameters are omitted (ISOMITTED → TRUE, any other use →
+  // #VALUE!). Helpers check their own parameter count with
+  // `hofArityError` before getting here.
+  if (args.length > lambda.params.length) return FormulaError.VALUE;
 
   context.__lambdaDepth = (context.__lambdaDepth ?? 0) + 1;
   if (context.__lambdaDepth > MAX_LAMBDA_DEPTH) {
@@ -45477,14 +45944,14 @@ const applyLambda = async (context, lambda, args) => {
   try {
     const bindings = lambda.params.map((name, i) => ({
       name,
-      // An omitted optional parameter binds to the omitted marker so
+      // A parameter the call left out binds to the omitted marker so
       // ISOMITTED inside the body can report it.
       value:
         i < args.length ? `(${formatLiteral(args[i])})` : `(${OMITTED_CALL})`,
     }));
     const substituted = substituteNamesInBody(lambda.body, bindings);
     const result = await context.parseAsync(substituted, context.position, true);
-    return result;
+    return rejectOmittedResult(result);
   } catch (e) {
     if (e instanceof FormulaError) return e;
     throw e;
@@ -45545,35 +46012,58 @@ const LambdaFunctions = {
   },
 
   /**
-   * Internal: the value spliced in for an optional `[param]` the caller
-   * left out (see the LAMBDA preprocessor / applyLambda).
+   * Internal: the value spliced in for a parameter the caller left out
+   * (see the LAMBDA preprocessor / applyLambda).
    */
   __RNC_OMITTED__: () => OMITTED,
 
   /**
    * Internal: `__RNC_CALL__(lambda, arg1, …)` — the preprocessor emits
-   * this for an inline `LAMBDA(...)(...)` whose argument count does not
-   * match the parameter list, so the arity error surfaces as #VALUE!.
+   * this for an inline `LAMBDA(...)(...)` with more arguments than
+   * parameters, so the arity error surfaces as #VALUE!.
    */
   __RNC_CALL__: async (context, lambdaArg, ...args) =>
     applyLambda(context, unwrap(lambdaArg), args.map(unwrap)),
 
   /**
-   * ISOMITTED(argument) — TRUE when `argument` is an optional LAMBDA
-   * parameter the caller did not supply, FALSE otherwise.
+   * ISOMITTED(argument) — TRUE when `argument` is a LAMBDA parameter the
+   * caller did not supply (bracketed `[p]` or not), FALSE otherwise.
    */
   ISOMITTED: (arg) => isOmittedValue(unwrap(arg)),
 
+  /**
+   * A well-formed `LET(name, value, ..., body)` never reaches the function
+   * table — the LET preprocessor inlines it. One that does is malformed:
+   * too few arguments is `#N/A` (the too-few-arguments contract shared with
+   * the Rust engine), an even count or a non-name binding is `#VALUE!`.
+   */
+  LET: (...args) => {
+    if (args.length < 3) return FormulaError.NA;
+    return FormulaError.VALUE;
+  },
+
+  /**
+   * Same for `LAMBDA(...)`: the preprocessor rewrites every LAMBDA with a
+   * body, so only `LAMBDA()` (too few arguments, `#N/A`) and a body-less
+   * `LAMBDA(x)` (a lambda value as the cell result, `#CALC!`) get here.
+   */
+  LAMBDA: (...args) => {
+    if (args.length === 0) return FormulaError.NA;
+    return FormulaError.CALC;
+  },
+
   /**
    * MAP(array1, [array2, ...], lambda) — applies lambda to each set
    * of corresponding elements. Returns a same-shape 2D array.
    */
   MAP: async (context, ...args) => {
-    if (args.length < 2) return FormulaError.VALUE;
+    if (args.length < 2) return FormulaError.NA;
     const lambda = unwrap(args[args.length - 1]);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
     const arrays = args.slice(0, -1).map((a) => as2D(unwrap(a)));
     if (arrays.length === 0) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, arrays.length);
+    if (arity) return arity;
     const rows = arrays[0].length;
     const cols = arrays[0][0]?.length ?? 0;
     const out = [];
@@ -45595,6 +46085,8 @@ const LambdaFunctions = {
   REDUCE: async (context, initialArg, arrayArg, lambdaArg) => {
     const lambda = unwrap(lambdaArg);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, 2);
+    if (arity) return arity;
     let acc = unwrap(initialArg);
     const values = flatten2D(as2D(unwrap(arrayArg)));
     for (const v of values) {
@@ -45612,6 +46104,8 @@ const LambdaFunctions = {
   SCAN: async (context, initialArg, arrayArg, lambdaArg) => {
     const lambda = unwrap(lambdaArg);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, 2);
+    if (arity) return arity;
     let acc = unwrap(initialArg);
     const arr = as2D(unwrap(arrayArg));
     const out = [];
@@ -45633,8 +46127,11 @@ const LambdaFunctions = {
    * array), returns a column vector of results.
    */
   BYROW: async (context, arrayArg, lambdaArg) => {
+    if (lambdaArg === undefined) return FormulaError.NA;
     const lambda = unwrap(lambdaArg);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, 1);
+    if (arity) return arity;
     const arr = as2D(unwrap(arrayArg));
     const out = [];
     for (const row of arr) {
@@ -45650,8 +46147,11 @@ const LambdaFunctions = {
    * 1D array), returns a row vector of results.
    */
   BYCOL: async (context, arrayArg, lambdaArg) => {
+    if (lambdaArg === undefined) return FormulaError.NA;
     const lambda = unwrap(lambdaArg);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, 1);
+    if (arity) return arity;
     const arr = as2D(unwrap(arrayArg));
     const cols = arr[0]?.length ?? 0;
     const out = [];
@@ -45669,8 +46169,11 @@ const LambdaFunctions = {
    * lambda(r, c) for each cell. r, c are 1-indexed per Excel.
    */
   MAKEARRAY: async (context, rowsArg, colsArg, lambdaArg) => {
+    if (lambdaArg === undefined) return FormulaError.NA;
     const lambda = unwrap(lambdaArg);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, 2);
+    if (arity) return arity;
     const rows = Math.floor(
       FormulaHelpers.accept(rowsArg, Types.NUMBER, 0),
     );
@@ -45719,6 +46222,8 @@ const LambdaFunctions = {
     const valueFields = as2D(unwrap(args[1]));
     const lambda = unwrap(args[2]);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, 1);
+    if (arity) return arity;
     const fieldHeaders = args[3] != null
       ? Math.floor(FormulaHelpers.accept(args[3], Types.NUMBER, 0))
       : 0;
@@ -45767,6 +46272,8 @@ const LambdaFunctions = {
     const valueFields = as2D(unwrap(args[2]));
     const lambda = unwrap(args[3]);
     if (!isLambdaValue(lambda)) return FormulaError.VALUE;
+    const arity = hofArityError(lambda, 1);
+    if (arity) return arity;
 
     const numOpt = (i, d) =>
       args[i] != null
@@ -46223,6 +46730,42 @@ let Utils$1 = class Utils {
     return Prefix.unaryOp(prefixes, val, isArray);
   }
 
+  /**
+   * Sign a numeric literal (`-1`, `+2` inside an array constant). Nothing
+   * to dereference or await here, so this stays synchronous in both parse
+   * modes.
+   * @param {string} prefix - `+` or `-`
+   * @param {number} number
+   * @return {number}
+   */
+  applyLiteralPrefix(prefix, number) {
+    return this._applyPrefix([prefix], number, false);
+  }
+
+  /**
+   * Under `parseAsync` an array-constant item built from a sub-expression
+   * (`{SUM(1,-2),3}`) is a pending Promise; an array must only ever carry
+   * values, so settle them. A settled item may itself be a reference
+   * (`{INDEX(A1:C5,1,1),2}`), which the sync arm of `constantArray`
+   * dereferences before the Promise ever existed — do the same here so both
+   * parse modes agree. Returns the array itself when nothing is pending.
+   * @param {Array.<Array>} array
+   * @param {{row: number, col: number, sheet: string}} position
+   * @return {Array.<Array>|Promise.<Array.<Array>>}
+   */
+  settleArrayItems(array, position) {
+    const isPending = (item) =>
+      item != null && typeof item.then === "function";
+    if (!array.some((row) => row.some(isPending))) return array;
+    const deref = (item) =>
+      item && item.ref ? this.extractRefValue(item, position).val : item;
+    return Promise.all(
+      array.map((row) =>
+        Promise.all(row).then((items) => items.map(deref))
+      )
+    );
+  }
+
   async applyPrefixAsync(prefixes, value, position) {
     const { val, isArray } = this.extractRefValue(await value, position);
     return this._applyPrefix(prefixes, val, isArray);
@@ -46417,15 +46960,21 @@ let Utils$1 = class Utils {
     }
   }
 
-  applyIntersect(refs) {
+  applyIntersect(refs, position) {
     // console.log('applyIntersect', refs);
     if (this.isFormulaError(refs[0])) return refs[0];
     if (!refs[0].ref) throw Error(`Expecting a reference, but got ${refs[0]}.`);
     // a intersection will keep track of references, value won't be retrieved here.
     let maxRow, maxCol, minRow, minCol, sheet, res; // index start from 1
+    // An unqualified operand (`B:B`, sheet undefined) lives on the formula's sheet: it must
+    // intersect an operand that names that sheet explicitly (`Sheet1!A1:C3`, or a defined name
+    // — the host resolves names WITH their sheet). Only a genuinely different sheet is #NULL!.
+    const currentSheet = (position ?? this.context.position)?.sheet;
+    const sheetOf = (ref) => ref.sheet ?? currentSheet;
     // first time setup
     const ref = refs.shift().ref;
     sheet = ref.sheet;
+    const sheetKey = sheetOf(ref);
     if (!ref.from) {
       // check whole row/col reference
       if (ref.row === undefined || ref.col === undefined) {
@@ -46459,10 +47008,11 @@ let Utils$1 = class Utils {
           ref.row < minRow ||
           ref.col > maxCol ||
           ref.col < minCol ||
-          sheet !== ref.sheet
+          sheetKey !== sheetOf(ref)
         ) {
           err = FormulaError.NULL;
         }
+        sheet ??= ref.sheet;
         maxRow = minRow = ref.row;
         maxCol = minCol = ref.col;
       } else {
@@ -46476,10 +47026,11 @@ let Utils$1 = class Utils {
           refMaxRow < minRow ||
           refMinCol > maxCol ||
           refMaxCol < minCol ||
-          sheet !== ref.sheet
+          sheetKey !== sheetOf(ref)
         ) {
           err = FormulaError.NULL;
         }
+        sheet ??= ref.sheet;
         // update
         maxRow = Math.min(maxRow, refMaxRow);
         minRow = Math.max(minRow, refMinRow);
@@ -47480,6 +48031,9 @@ class FormulaParser {
     if (!this.keepLambdaResult && unwrapLambdaValue(result)) {
       return FormulaError.CALC;
     }
+    // An inlined `LAMBDA(x,y,y)(1)` evaluates straight to the omitted
+    // marker; only ISOMITTED may consume it, so as a result it is #VALUE!.
+    result = rejectOmittedResult(result);
     const type = typeof result;
     // number
     if (type === "number") {
@@ -48700,6 +49254,7 @@ exports.WildCard = WildCard;
 exports.allTokens = allTokens;
 exports.default = FormulaParser;
 exports.implementedFunctionNames = implementedFunctionNames;
+exports.isNestedAggregateFormula = isNestedAggregateFormula;
 exports.lex = lex;
 exports.noop = noop;
 exports.numberToText = numberToText;