@rowsncolumns/fast-formula-parser 6.2.36 → 6.2.37

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
@@ -3965,6 +3990,148 @@ 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 {
         let shortAmPm = shortAmPmPatternCache.get(pattern);
@@ -3972,7 +4139,7 @@ const ssfFormat = (pattern, value, locale) => {
             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 +4842,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 +4927,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 +4944,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 +6516,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 +6566,7 @@ const TextFunctions = {
     if (removeEmpty) {
       parts = parts.filter((part) => part !== "");
     }
+    if (parts.length === 0) return "";
 
     // Return as a single row array
     return [parts];
@@ -12353,15 +12542,48 @@ 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]);
@@ -12382,12 +12604,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 };
 };
@@ -13267,20 +13489,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
@@ -13293,7 +13513,7 @@ const DistributionFunctions = {
         return forecast[horizon - 1];
     },
 
-    '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,9 +13521,8 @@ 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));
@@ -13323,21 +13542,21 @@ const DistributionFunctions = {
         return z * rmse * Math.sqrt(horizon);
     },
 
-    '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);
         // Excel STAT codes:
@@ -14424,6 +14643,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 +15628,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 +16943,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 +16976,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 +16989,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 +17496,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}.
    */
@@ -19850,6 +20098,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 +20118,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 +20173,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 +20556,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 +20574,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 +21380,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 +21524,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 +25663,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 +25686,7 @@ const ExternalFunctions = {
   EUROCONVERT: unavailable,
   TRANSLATE: unavailable,
   DETECTLANGUAGE: unavailable,
+  QUERY: unavailable,
 };
 
 var api$3 = {};
@@ -44517,7 +44835,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 +44859,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 +45502,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 +45534,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 +45543,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 +45573,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 +45594,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 +45721,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 +45740,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 +45819,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 +45836,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 +45904,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 +45977,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 +45996,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 +46019,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 +46039,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 +46061,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 +46114,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 +46164,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 +46622,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 +46852,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 +46900,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 +46918,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 +47923,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 +49146,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;