@cj-tech-master/excelts 9.3.1 → 9.4.0

package/dist/browser/modules/formula/functions/lookup.js

@@ -10,26 +10,9 @@ import { excelWildcardToRegex, getCell, hasUnescapedWildcard, unescapeExcelWildc
 function sameType(a, b) {
     return a.kind === b.kind;
 }
-function scalarIsNumber(v) {
-    return v.kind === RVKind.Number;
-}
 function scalarIsString(v) {
     return v.kind === RVKind.String;
 }
-function scalarStringEquals(a, b) {
-    return scalarIsString(a) && scalarIsString(b) && a.value.toLowerCase() === b.value.toLowerCase();
-}
-/**
- * Ordered comparison of two scalars. Numbers compared by value; strings by
- * case-insensitive lexical order. Returns NaN when the two operands have
- * incompatible types (e.g. number vs string) so callers can skip them.
- */
-/**
- * @deprecated Use `compareScalarsSameKind` from `runtime/values` directly —
- * the two are identical. Retained only as a local alias to keep the diff
- * small; callers inside this file are free to migrate.
- */
-const compareScalar = compareScalarsSameKind;
 // ============================================================================
 // Functions
 // ============================================================================
@@ -62,7 +45,7 @@ export function fnINDEX(args) {
         return topLeft(args[0]);
     }
     const arr = args[0];
-    const rowNumV = args.length > 1 ? toNumberRV(args[1]) : rvNumber(0);
+    const rowNumV = args.length > 1 ? toNumberRV(topLeft(args[1])) : rvNumber(0);
     if (isError(rowNumV)) {
         return rowNumV;
     }
@@ -70,7 +53,7 @@ export function fnINDEX(args) {
     // Without this, `INDEX(a, 1.5, 1)` would index into `arr.rows[0.5]`, which
     // in V8 silently returns `undefined` and corrupts downstream values.
     const rowNum = Math.trunc(rowNumV.value);
-    const colNumV = args.length > 2 ? toNumberRV(args[2]) : rvNumber(0);
+    const colNumV = args.length > 2 ? toNumberRV(topLeft(args[2])) : rvNumber(0);
     if (isError(colNumV)) {
         return colNumV;
     }
@@ -87,6 +70,10 @@ export function fnINDEX(args) {
         if (c < 0 || c >= arr.width) {
             return ERRORS.REF;
         }
+        // Single-row source: a whole-column extract collapses to the one cell.
+        if (arr.height === 1) {
+            return arr.rows[0][c];
+        }
         const rows = [];
         for (let r = 0; r < arr.height; r++) {
             rows.push([getCell(arr, r, c)]);
@@ -99,6 +86,12 @@ export function fnINDEX(args) {
         if (r < 0 || r >= arr.height) {
             return ERRORS.REF;
         }
+        // Single-column source: a whole-row extract collapses to the one cell.
+        // Matches Excel's convention — `INDEX(A1:A5, 2)` yields the scalar A2,
+        // not a 1×1 array that downstream arithmetic has to implicit-intersect.
+        if (arr.width === 1) {
+            return arr.rows[r][0];
+        }
         return rvArray([[...arr.rows[r]]]);
     }
     // Single cell
@@ -118,7 +111,11 @@ export function fnMATCH(args) {
         return ERRORS.NA;
     }
     const lookupArr = args[1];
-    const matchTypeV = args.length > 2 ? toNumberRV(args[2]) : rvNumber(1);
+    // Blank `match_type` → Excel default 1 (largest value ≤ lookup, ascending sort).
+    // Previously a blank coerced to 0 via toNumberRV and silently flipped the
+    // function to exact-match mode — a behaviour gap vs. Excel's documented
+    // default.
+    const matchTypeV = args.length > 2 && args[2].kind !== RVKind.Blank ? toNumberRV(topLeft(args[2])) : rvNumber(1);
     if (isError(matchTypeV)) {
         return matchTypeV;
     }
@@ -146,6 +143,12 @@ export function fnMATCH(args) {
                 wildcardRe = null;
             }
         }
+        // Pre-compute the literal (unescaped + lowercased) lookup string
+        // once. The old code called `unescapeExcelWildcard(lookupValue.value).toLowerCase()`
+        // inside the hot per-cell loop, paying O(n) per cell for what is
+        // a constant expression. (For ranges without strings the literal
+        // is never consulted — `scalarIsString(fi)` short-circuits first.)
+        const lookupLiteralLc = lookupStr !== null && !hasWildcard ? unescapeExcelWildcard(lookupStr).toLowerCase() : null;
         for (let i = 0; i < flat.length; i++) {
             if (scalarEquals(flat[i], lookupValue)) {
                 return rvNumber(i + 1);
@@ -157,7 +160,7 @@ export function fnMATCH(args) {
                         return rvNumber(i + 1);
                     }
                 }
-                else {
+                else if (lookupLiteralLc !== null) {
                     // No unescaped wildcard — but the pattern may still contain
                     // `~*` / `~?` / `~~` escape sequences that should reduce to
                     // their literal character before comparison. Calling
@@ -165,8 +168,7 @@ export function fnMATCH(args) {
                     // SEARCH and the criteria predicate use; without it,
                     // `MATCH("a~*b", ...)` would literally look for `"a~*b"`
                     // instead of `"a*b"`.
-                    const literal = unescapeExcelWildcard(lookupValue.value).toLowerCase();
-                    if (fi.value.toLowerCase() === literal) {
+                    if (fi.value.toLowerCase() === lookupLiteralLc) {
                         return rvNumber(i + 1);
                     }
                 }
@@ -179,23 +181,18 @@ export function fnMATCH(args) {
         let bestIdx = -1;
         for (let i = 0; i < flat.length; i++) {
             const v = flat[i];
-            if (sameType(v, lookupValue)) {
-                if (scalarIsNumber(v) && scalarIsNumber(lookupValue)) {
-                    if (v.value <= lookupValue.value) {
-                        bestIdx = i;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                else if (scalarIsString(v) && scalarIsString(lookupValue)) {
-                    if (v.value.toLowerCase() <= lookupValue.value.toLowerCase()) {
-                        bestIdx = i;
-                    }
-                    else {
-                        break;
-                    }
-                }
+            if (v.kind !== lookupValue.kind) {
+                continue;
+            }
+            const cmp = compareScalarsSameKind(v, lookupValue);
+            if (!Number.isFinite(cmp)) {
+                continue;
+            }
+            if (cmp <= 0) {
+                bestIdx = i;
+            }
+            else {
+                break;
             }
         }
         return bestIdx >= 0 ? rvNumber(bestIdx + 1) : ERRORS.NA;
@@ -204,23 +201,18 @@ export function fnMATCH(args) {
     let bestIdx = -1;
     for (let i = 0; i < flat.length; i++) {
         const v = flat[i];
-        if (sameType(v, lookupValue)) {
-            if (scalarIsNumber(v) && scalarIsNumber(lookupValue)) {
-                if (v.value >= lookupValue.value) {
-                    bestIdx = i;
-                }
-                else {
-                    break;
-                }
-            }
-            else if (scalarIsString(v) && scalarIsString(lookupValue)) {
-                if (v.value.toLowerCase() >= lookupValue.value.toLowerCase()) {
-                    bestIdx = i;
-                }
-                else {
-                    break;
-                }
-            }
+        if (v.kind !== lookupValue.kind) {
+            continue;
+        }
+        const cmp = compareScalarsSameKind(v, lookupValue);
+        if (!Number.isFinite(cmp)) {
+            continue;
+        }
+        if (cmp >= 0) {
+            bestIdx = i;
+        }
+        else {
+            break;
         }
     }
     return bestIdx >= 0 ? rvNumber(bestIdx + 1) : ERRORS.NA;
@@ -234,13 +226,18 @@ export function fnVLOOKUP(args) {
         return ERRORS.NA;
     }
     const table = args[1];
-    const colIndexV = toNumberRV(args[2]);
+    const colIndexV = toNumberRV(topLeft(args[2]));
     if (isError(colIndexV)) {
         return colIndexV;
     }
     // VLOOKUP truncates the column index toward zero before bounds checks.
     const colIndex = Math.trunc(colIndexV.value);
-    const rangeLookupV = args.length > 3 ? toBooleanRV(args[3]) : { kind: RVKind.Boolean, value: true };
+    // Blank `range_lookup` → Excel default TRUE. A blank coerces through
+    // `toBooleanRV` to FALSE which silently flips to exact match —
+    // opposite of Excel's documented default.
+    const rangeLookupV = args.length > 3 && args[3].kind !== RVKind.Blank
+        ? toBooleanRV(topLeft(args[3]))
+        : { kind: RVKind.Boolean, value: true };
     if (isError(rangeLookupV)) {
         return rangeLookupV;
     }
@@ -249,39 +246,65 @@ export function fnVLOOKUP(args) {
         return ERRORS.REF;
     }
     if (!rangeLookup) {
-        // Exact match
+        // Exact match — `scalarEquals` already handles case-insensitive string
+        // comparison (see runtime/values.ts), so the earlier `scalarStringEquals`
+        // fallback was dead code.
+        //
+        // Excel's VLOOKUP supports wildcards (`*`, `?`, `~*`, `~?`, `~~`) in
+        // the exact-match mode (range_lookup=FALSE). Three paths, chosen by
+        // what the lookup string contains:
+        //   - unescaped wildcard (`*` or `?`) → regex match
+        //   - only escape sequences (`~*`, `~?`, `~~`) → unescape then
+        //     literal case-insensitive compare (so `"a~*b"` matches `"a*b"`)
+        //   - neither → plain `scalarEquals`
+        const lookupStr = lookupValue.kind === RVKind.String ? lookupValue.value : null;
+        let wildcardRe = null;
+        let literalLc = null;
+        if (lookupStr !== null && hasUnescapedWildcard(lookupStr)) {
+            try {
+                wildcardRe = new RegExp("^" + excelWildcardToRegex(lookupStr) + "$", "i");
+            }
+            catch {
+                wildcardRe = null;
+            }
+        }
+        else if (lookupStr !== null && /~[*?~]/.test(lookupStr)) {
+            literalLc = unescapeExcelWildcard(lookupStr).toLowerCase();
+        }
         for (let r = 0; r < table.height; r++) {
             const cell = getCell(table, r, 0);
             if (scalarEquals(cell, lookupValue)) {
                 return getCell(table, r, colIndex - 1);
             }
-            if (scalarStringEquals(cell, lookupValue)) {
+            if (wildcardRe && cell.kind === RVKind.String && wildcardRe.test(cell.value)) {
+                return getCell(table, r, colIndex - 1);
+            }
+            if (literalLc !== null &&
+                cell.kind === RVKind.String &&
+                cell.value.toLowerCase() === literalLc) {
                 return getCell(table, r, colIndex - 1);
             }
         }
         return ERRORS.NA;
     }
-    // Approximate match: sorted ascending by first column.
+    // Approximate match: sorted ascending by first column. Binary-search
+    // style isn't safe here (Excel allows mixed-type entries which break
+    // monotonicity), so walk until we overshoot.
     let bestRow = -1;
     for (let r = 0; r < table.height; r++) {
         const v = getCell(table, r, 0);
-        if (sameType(v, lookupValue)) {
-            if (scalarIsNumber(v) && scalarIsNumber(lookupValue)) {
-                if (v.value <= lookupValue.value) {
-                    bestRow = r;
-                }
-                else {
-                    break;
-                }
-            }
-            else if (scalarIsString(v) && scalarIsString(lookupValue)) {
-                if (v.value.toLowerCase() <= lookupValue.value.toLowerCase()) {
-                    bestRow = r;
-                }
-                else {
-                    break;
-                }
-            }
+        if (v.kind !== lookupValue.kind) {
+            continue;
+        }
+        const cmp = compareScalarsSameKind(v, lookupValue);
+        if (!Number.isFinite(cmp)) {
+            continue;
+        }
+        if (cmp <= 0) {
+            bestRow = r;
+        }
+        else {
+            break;
         }
     }
     return bestRow >= 0 ? getCell(table, bestRow, colIndex - 1) : ERRORS.NA;
@@ -295,13 +318,16 @@ export function fnHLOOKUP(args) {
         return ERRORS.NA;
     }
     const table = args[1];
-    const rowIndexV = toNumberRV(args[2]);
+    const rowIndexV = toNumberRV(topLeft(args[2]));
     if (isError(rowIndexV)) {
         return rowIndexV;
     }
     // HLOOKUP truncates the row index toward zero before bounds checks.
     const rowIndex = Math.trunc(rowIndexV.value);
-    const rangeLookupV = args.length > 3 ? toBooleanRV(args[3]) : { kind: RVKind.Boolean, value: true };
+    // Blank `range_lookup` → Excel default TRUE (see VLOOKUP rationale).
+    const rangeLookupV = args.length > 3 && args[3].kind !== RVKind.Blank
+        ? toBooleanRV(topLeft(args[3]))
+        : { kind: RVKind.Boolean, value: true };
     if (isError(rangeLookupV)) {
         return rangeLookupV;
     }
@@ -310,8 +336,33 @@ export function fnHLOOKUP(args) {
         return ERRORS.REF;
     }
     if (!rangeLookup) {
+        // Exact match — supports wildcards on string lookups (see VLOOKUP
+        // for full rationale; the paths mirror one another).
+        const lookupStr = lookupValue.kind === RVKind.String ? lookupValue.value : null;
+        let wildcardRe = null;
+        let literalLc = null;
+        if (lookupStr !== null && hasUnescapedWildcard(lookupStr)) {
+            try {
+                wildcardRe = new RegExp("^" + excelWildcardToRegex(lookupStr) + "$", "i");
+            }
+            catch {
+                wildcardRe = null;
+            }
+        }
+        else if (lookupStr !== null && /~[*?~]/.test(lookupStr)) {
+            literalLc = unescapeExcelWildcard(lookupStr).toLowerCase();
+        }
         for (let c = 0; c < table.width; c++) {
-            if (scalarEquals(getCell(table, 0, c), lookupValue)) {
+            const cell = getCell(table, 0, c);
+            if (scalarEquals(cell, lookupValue)) {
+                return getCell(table, rowIndex - 1, c);
+            }
+            if (wildcardRe && cell.kind === RVKind.String && wildcardRe.test(cell.value)) {
+                return getCell(table, rowIndex - 1, c);
+            }
+            if (literalLc !== null &&
+                cell.kind === RVKind.String &&
+                cell.value.toLowerCase() === literalLc) {
                 return getCell(table, rowIndex - 1, c);
             }
         }
@@ -320,18 +371,18 @@ export function fnHLOOKUP(args) {
     let bestCol = -1;
     for (let c = 0; c < table.width; c++) {
         const hv = getCell(table, 0, c);
-        if (sameType(hv, lookupValue)) {
-            // For approximate match, find largest <= lookupValue
-            if (scalarIsNumber(hv) && scalarIsNumber(lookupValue)) {
-                if (hv.value <= lookupValue.value) {
-                    bestCol = c;
-                }
-            }
-            else if (scalarIsString(hv) && scalarIsString(lookupValue)) {
-                if (hv.value.toLowerCase() <= lookupValue.value.toLowerCase()) {
-                    bestCol = c;
-                }
-            }
+        if (hv.kind !== lookupValue.kind) {
+            continue;
+        }
+        const cmp = compareScalarsSameKind(hv, lookupValue);
+        if (!Number.isFinite(cmp)) {
+            continue;
+        }
+        // Approximate match: pick the largest value <= lookupValue. We don't
+        // break early when we overshoot because HLOOKUP's legacy behaviour
+        // scans the whole row even for unsorted data.
+        if (cmp <= 0) {
+            bestCol = c;
         }
     }
     return bestCol >= 0 ? getCell(table, rowIndex - 1, bestCol) : ERRORS.NA;
@@ -349,17 +400,30 @@ export function fnXLOOKUP(args) {
         return ERRORS.VALUE;
     }
     const returnArr = args[2];
-    const ifNotFound = args.length > 3 ? topLeft(args[3]) : null;
-    const matchModeV = args.length > 4 ? toNumberRV(args[4]) : rvNumber(0);
+    // Blank `if_not_found` → treat as omitted (default #N/A). Without
+    // this guard, an explicitly-blank fourth slot would produce BLANK as
+    // the fallback, which differs from Excel's "omitted → #N/A" default
+    // and from what a user intuitively expects.
+    const ifNotFound = args.length > 3 && args[3].kind !== RVKind.Blank ? topLeft(args[3]) : null;
+    // Blank `match_mode` → 0 (exact); any non-{-1, 0, 1, 2} is rejected.
+    const matchModeV = args.length > 4 && args[4].kind !== RVKind.Blank ? toNumberRV(topLeft(args[4])) : rvNumber(0);
     if (isError(matchModeV)) {
         return matchModeV;
     }
     const matchMode = matchModeV.value;
-    const searchModeV = args.length > 5 ? toNumberRV(args[5]) : rvNumber(1);
+    if (matchMode !== 0 && matchMode !== -1 && matchMode !== 1 && matchMode !== 2) {
+        return ERRORS.VALUE;
+    }
+    // Blank `search_mode` → 1 (first-to-last). Previously a blank coerced
+    // to 0 which silently passed through but is not a valid search mode.
+    const searchModeV = args.length > 5 && args[5].kind !== RVKind.Blank ? toNumberRV(topLeft(args[5])) : rvNumber(1);
     if (isError(searchModeV)) {
         return searchModeV;
     }
     const searchMode = searchModeV.value;
+    if (searchMode !== 1 && searchMode !== -1 && searchMode !== 2 && searchMode !== -2) {
+        return ERRORS.VALUE;
+    }
     // Flatten lookup array to 1D
     const flat = [];
     const isRow = lookupArr.height === 1;
@@ -464,10 +528,6 @@ export function fnXLOOKUP(args) {
                 foundIdx = i;
                 break;
             }
-            if (scalarStringEquals(flat[i], lookupValue)) {
-                foundIdx = i;
-                break;
-            }
         }
     }
     else if (matchMode === -1) {
@@ -570,16 +630,23 @@ export function fnXMATCH(args) {
         return ERRORS.VALUE;
     }
     const lookupArr = args[1];
-    const matchModeV = args.length > 2 ? toNumberRV(args[2]) : rvNumber(0);
+    // Blank `match_mode` → 0 (exact). Same validation as XLOOKUP.
+    const matchModeV = args.length > 2 && args[2].kind !== RVKind.Blank ? toNumberRV(topLeft(args[2])) : rvNumber(0);
     if (isError(matchModeV)) {
         return matchModeV;
     }
     const matchMode = matchModeV.value;
-    const searchModeV = args.length > 3 ? toNumberRV(args[3]) : rvNumber(1);
+    if (matchMode !== 0 && matchMode !== -1 && matchMode !== 1 && matchMode !== 2) {
+        return ERRORS.VALUE;
+    }
+    const searchModeV = args.length > 3 && args[3].kind !== RVKind.Blank ? toNumberRV(topLeft(args[3])) : rvNumber(1);
     if (isError(searchModeV)) {
         return searchModeV;
     }
     const searchMode = searchModeV.value;
+    if (searchMode !== 1 && searchMode !== -1 && searchMode !== 2 && searchMode !== -2) {
+        return ERRORS.VALUE;
+    }
     const flat = [];
     if (lookupArr.height === 1) {
         for (let c = 0; c < lookupArr.width; c++) {
@@ -599,9 +666,6 @@ export function fnXMATCH(args) {
             if (scalarEquals(flat[i], lookupValue)) {
                 return rvNumber(i + 1);
             }
-            if (scalarStringEquals(flat[i], lookupValue)) {
-                return rvNumber(i + 1);
-            }
         }
         return ERRORS.NA;
     }
@@ -649,11 +713,11 @@ export function fnXMATCH(args) {
         // Next-smaller-or-equal: largest item <= lookupValue.
         let best = -1;
         for (let i = 0; i < flat.length; i++) {
-            const cmp = compareScalar(flat[i], lookupValue);
+            const cmp = compareScalarsSameKind(flat[i], lookupValue);
             if (Number.isNaN(cmp)) {
                 continue;
             }
-            if (cmp <= 0 && (best === -1 || compareScalar(flat[i], flat[best]) > 0)) {
+            if (cmp <= 0 && (best === -1 || compareScalarsSameKind(flat[i], flat[best]) > 0)) {
                 best = i;
             }
         }
@@ -663,11 +727,11 @@ export function fnXMATCH(args) {
         // Next-larger-or-equal: smallest item >= lookupValue.
         let best = -1;
         for (let i = 0; i < flat.length; i++) {
-            const cmp = compareScalar(flat[i], lookupValue);
+            const cmp = compareScalarsSameKind(flat[i], lookupValue);
             if (Number.isNaN(cmp)) {
                 continue;
             }
-            if (cmp >= 0 && (best === -1 || compareScalar(flat[i], flat[best]) < 0)) {
+            if (cmp >= 0 && (best === -1 || compareScalarsSameKind(flat[i], flat[best]) < 0)) {
                 best = i;
             }
         }
@@ -676,12 +740,12 @@ export function fnXMATCH(args) {
     return ERRORS.NA;
 }
 export function fnADDRESS(args) {
-    const rowNumV = toNumberRV(args[0]);
+    const rowNumV = toNumberRV(topLeft(args[0]));
     if (isError(rowNumV)) {
         return rowNumV;
     }
     const rowNum = Math.trunc(rowNumV.value);
-    const colNumV = toNumberRV(args[1]);
+    const colNumV = toNumberRV(topLeft(args[1]));
     if (isError(colNumV)) {
         return colNumV;
     }
@@ -692,7 +756,10 @@ export function fnADDRESS(args) {
     if (!Number.isFinite(rowNum) || !Number.isFinite(colNum) || rowNum < 1 || colNum < 1) {
         return ERRORS.VALUE;
     }
-    const absNumV = args.length > 2 ? toNumberRV(args[2]) : rvNumber(1);
+    // Blank `abs_num` → Excel default 1 (fully absolute). Without the
+    // blank guard, `toNumberRV(BLANK)` coerces to 0 which falls outside
+    // the 1..4 range and surfaces a spurious #VALUE!.
+    const absNumV = args.length > 2 && args[2].kind !== RVKind.Blank ? toNumberRV(topLeft(args[2])) : rvNumber(1);
     if (isError(absNumV)) {
         return absNumV;
     }
@@ -704,7 +771,7 @@ export function fnADDRESS(args) {
     // a1 style (true/default) vs r1c1 (false)
     const a1Arg = args.length > 3 ? topLeft(args[3]) : { kind: RVKind.Boolean, value: true };
     const a1 = a1Arg.kind === RVKind.Boolean ? a1Arg.value : true;
-    const sheetText = args.length > 4 ? toStringRV(args[4]) : "";
+    const sheetText = args.length > 4 ? toStringRV(topLeft(args[4])) : "";
     if (!a1) {
         // R1C1 style
         const rPart = absNum === 1 || absNum === 2 ? `R${rowNum}` : `R[${rowNum}]`;
@@ -777,20 +844,7 @@ export function fnLOOKUP(args) {
                 flat.push(getCell(lookupArr, r, 0));
             }
         }
-        let bestIdx = -1;
-        for (let i = 0; i < flat.length; i++) {
-            const v = flat[i];
-            if (sameType(v, lookupValue)) {
-                if (scalarIsNumber(v) && scalarIsNumber(lookupValue) && v.value <= lookupValue.value) {
-                    bestIdx = i;
-                }
-                else if (scalarIsString(v) &&
-                    scalarIsString(lookupValue) &&
-                    v.value.toLowerCase() <= lookupValue.value.toLowerCase()) {
-                    bestIdx = i;
-                }
-            }
-        }
+        const bestIdx = findLastLessEqual(flat, lookupValue);
         if (bestIdx === -1) {
             return ERRORS.NA;
         }
@@ -811,38 +865,48 @@ export function fnLOOKUP(args) {
         return ERRORS.NA;
     }
     if (cols >= rows) {
-        let bestIdx = -1;
+        // Array-form LOOKUP, horizontal orientation: lookup runs along first
+        // row; result is pulled from the last row of the same column.
+        const firstRow = [];
         for (let c = 0; c < cols; c++) {
-            const v = getCell(lookupArr, 0, c);
-            if (sameType(v, lookupValue)) {
-                if (scalarIsNumber(v) && scalarIsNumber(lookupValue) && v.value <= lookupValue.value) {
-                    bestIdx = c;
-                }
-                else if (scalarIsString(v) &&
-                    scalarIsString(lookupValue) &&
-                    v.value.toLowerCase() <= lookupValue.value.toLowerCase()) {
-                    bestIdx = c;
-                }
-            }
+            firstRow.push(getCell(lookupArr, 0, c));
         }
+        const bestIdx = findLastLessEqual(firstRow, lookupValue);
         return bestIdx >= 0 ? getCell(lookupArr, rows - 1, bestIdx) : ERRORS.NA;
     }
-    let bestIdx = -1;
+    // Array-form LOOKUP, vertical orientation: lookup runs down first column;
+    // result is pulled from the last column of the same row.
+    const firstCol = [];
     for (let r = 0; r < rows; r++) {
-        const v = getCell(lookupArr, r, 0);
-        if (sameType(v, lookupValue)) {
-            if (scalarIsNumber(v) && scalarIsNumber(lookupValue) && v.value <= lookupValue.value) {
-                bestIdx = r;
-            }
-            else if (scalarIsString(v) &&
-                scalarIsString(lookupValue) &&
-                v.value.toLowerCase() <= lookupValue.value.toLowerCase()) {
-                bestIdx = r;
-            }
-        }
+        firstCol.push(getCell(lookupArr, r, 0));
     }
+    const bestIdx = findLastLessEqual(firstCol, lookupValue);
     return bestIdx >= 0 ? getCell(lookupArr, bestIdx, cols - 1) : ERRORS.NA;
 }
+/**
+ * Linear scan for the largest same-kind value that is `<= target`.
+ * Returns the flat-index of that value, or `-1` when no same-kind
+ * value qualifies. Uses `compareScalarsSameKind` so numbers compare by
+ * value, strings case-insensitively — the same ordering Excel uses
+ * for legacy LOOKUP / VLOOKUP / HLOOKUP approximate matches.
+ */
+function findLastLessEqual(flat, target) {
+    let bestIdx = -1;
+    for (let i = 0; i < flat.length; i++) {
+        const v = flat[i];
+        if (v.kind !== target.kind) {
+            continue;
+        }
+        const cmp = compareScalarsSameKind(v, target);
+        if (!Number.isFinite(cmp)) {
+            continue;
+        }
+        if (cmp <= 0) {
+            bestIdx = i;
+        }
+    }
+    return bestIdx;
+}
 export function fnTRANSPOSE(args) {
     if (!isArray(args[0])) {
         const sv = topLeft(args[0]);
@@ -871,10 +935,13 @@ export function fnAREAS(args) {
     if (args.length === 0) {
         return ERRORS.VALUE;
     }
-    // Error in the argument propagates (Excel parity). A reference value
-    // counts as one area; the engine does not yet build multi-area
-    // references via `(A1, B1)` union syntax — when that lands, the arity
-    // should be `v.areas.length`, not a hardcoded 1.
+    // Normally unreachable — the evaluator's reference-aware path in
+    // `evaluateCall` intercepts AREAS before eager dereference happens,
+    // so by the time this fallback runs the reference has already been
+    // flattened into a dereferenced array (losing the area count).
+    // Keep the fallback behaviour aligned with the intercept path:
+    // arrays and scalars that reach here are not references and should
+    // surface as `#VALUE!`.
     const a = args[0];
     if (a.kind === RVKind.Error) {
         return a;
@@ -882,5 +949,5 @@ export function fnAREAS(args) {
     if (a.kind === RVKind.Reference) {
         return rvNumber(a.areas.length);
     }
-    return rvNumber(1);
+    return ERRORS.VALUE;
 }

package/dist/browser/modules/formula/functions/math.d.ts

@@ -42,7 +42,33 @@ export declare const fnPRODUCT: NativeFn;
 export declare const fnSUMPRODUCT: NativeFn;
 export declare const fnABS: NativeFn;
 export declare const fnCEILING: NativeFn;
+/**
+ * CEILING.MATH(number, [significance], [mode]) — rounds away from zero
+ * by default, or toward zero when `mode` is non-zero AND `number` is
+ * negative. Significance is always interpreted by absolute value.
+ *
+ * Different from CEILING: negative numbers with positive significance
+ * are valid (Excel does NOT require same sign), and there is an extra
+ * `mode` switch that flips the rounding direction for negatives.
+ */
+export declare const fnCEILING_MATH: NativeFn;
+/**
+ * CEILING.PRECISE / ISO.CEILING — always rounds toward +∞ (irrespective
+ * of sign), using the absolute value of significance.
+ */
+export declare const fnCEILING_PRECISE: NativeFn;
 export declare const fnFLOOR: NativeFn;
+/**
+ * FLOOR.MATH(number, [significance], [mode]) — rounds toward zero by
+ * default, or away from zero when `mode` is non-zero AND `number` is
+ * negative. Uses `|significance|` so negative significance never
+ * produces #NUM!.
+ */
+export declare const fnFLOOR_MATH: NativeFn;
+/**
+ * FLOOR.PRECISE — always rounds toward −∞ using `|significance|`.
+ */
+export declare const fnFLOOR_PRECISE: NativeFn;
 export declare const fnINT: NativeFn;
 export declare const fnMOD: NativeFn;
 export declare const fnPOWER: NativeFn;