@cj-tech-master/excelts 9.3.1 → 9.4.0

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

@@ -26,26 +26,9 @@ const _shared_1 = require("./_shared");
 function sameType(a, b) {
     return a.kind === b.kind;
 }
-function scalarIsNumber(v) {
-    return v.kind === 1 /* RVKind.Number */;
-}
 function scalarIsString(v) {
     return v.kind === 2 /* 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 = values_1.compareScalarsSameKind;
 // ============================================================================
 // Functions
 // ============================================================================
@@ -78,7 +61,7 @@ function fnINDEX(args) {
         return (0, values_1.topLeft)(args[0]);
     }
     const arr = args[0];
-    const rowNumV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(0);
+    const rowNumV = args.length > 1 ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[1])) : (0, values_1.rvNumber)(0);
     if ((0, values_1.isError)(rowNumV)) {
         return rowNumV;
     }
@@ -86,7 +69,7 @@ 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 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(0);
+    const colNumV = args.length > 2 ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[2])) : (0, values_1.rvNumber)(0);
     if ((0, values_1.isError)(colNumV)) {
         return colNumV;
     }
@@ -103,6 +86,10 @@ function fnINDEX(args) {
         if (c < 0 || c >= arr.width) {
             return values_1.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([(0, _shared_1.getCell)(arr, r, c)]);
@@ -115,6 +102,12 @@ function fnINDEX(args) {
         if (r < 0 || r >= arr.height) {
             return values_1.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 (0, values_1.rvArray)([[...arr.rows[r]]]);
     }
     // Single cell
@@ -134,7 +127,11 @@ function fnMATCH(args) {
         return values_1.ERRORS.NA;
     }
     const lookupArr = args[1];
-    const matchTypeV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.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 !== 0 /* RVKind.Blank */ ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[2])) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(matchTypeV)) {
         return matchTypeV;
     }
@@ -162,6 +159,12 @@ 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 ? (0, _shared_1.unescapeExcelWildcard)(lookupStr).toLowerCase() : null;
         for (let i = 0; i < flat.length; i++) {
             if ((0, values_1.scalarEquals)(flat[i], lookupValue)) {
                 return (0, values_1.rvNumber)(i + 1);
@@ -173,7 +176,7 @@ function fnMATCH(args) {
                         return (0, values_1.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
@@ -181,8 +184,7 @@ 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 = (0, _shared_1.unescapeExcelWildcard)(lookupValue.value).toLowerCase();
-                    if (fi.value.toLowerCase() === literal) {
+                    if (fi.value.toLowerCase() === lookupLiteralLc) {
                         return (0, values_1.rvNumber)(i + 1);
                     }
                 }
@@ -195,23 +197,18 @@ 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 = (0, values_1.compareScalarsSameKind)(v, lookupValue);
+            if (!Number.isFinite(cmp)) {
+                continue;
+            }
+            if (cmp <= 0) {
+                bestIdx = i;
+            }
+            else {
+                break;
             }
         }
         return bestIdx >= 0 ? (0, values_1.rvNumber)(bestIdx + 1) : values_1.ERRORS.NA;
@@ -220,23 +217,18 @@ 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 = (0, values_1.compareScalarsSameKind)(v, lookupValue);
+        if (!Number.isFinite(cmp)) {
+            continue;
+        }
+        if (cmp >= 0) {
+            bestIdx = i;
+        }
+        else {
+            break;
         }
     }
     return bestIdx >= 0 ? (0, values_1.rvNumber)(bestIdx + 1) : values_1.ERRORS.NA;
@@ -250,13 +242,18 @@ function fnVLOOKUP(args) {
         return values_1.ERRORS.NA;
     }
     const table = args[1];
-    const colIndexV = (0, values_1.toNumberRV)(args[2]);
+    const colIndexV = (0, values_1.toNumberRV)((0, values_1.topLeft)(args[2]));
     if ((0, values_1.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 ? (0, values_1.toBooleanRV)(args[3]) : { kind: 3 /* 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 !== 0 /* RVKind.Blank */
+        ? (0, values_1.toBooleanRV)((0, values_1.topLeft)(args[3]))
+        : { kind: 3 /* RVKind.Boolean */, value: true };
     if ((0, values_1.isError)(rangeLookupV)) {
         return rangeLookupV;
     }
@@ -265,39 +262,65 @@ function fnVLOOKUP(args) {
         return values_1.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 === 2 /* RVKind.String */ ? lookupValue.value : null;
+        let wildcardRe = null;
+        let literalLc = null;
+        if (lookupStr !== null && (0, _shared_1.hasUnescapedWildcard)(lookupStr)) {
+            try {
+                wildcardRe = new RegExp("^" + (0, _shared_1.excelWildcardToRegex)(lookupStr) + "$", "i");
+            }
+            catch {
+                wildcardRe = null;
+            }
+        }
+        else if (lookupStr !== null && /~[*?~]/.test(lookupStr)) {
+            literalLc = (0, _shared_1.unescapeExcelWildcard)(lookupStr).toLowerCase();
+        }
         for (let r = 0; r < table.height; r++) {
             const cell = (0, _shared_1.getCell)(table, r, 0);
             if ((0, values_1.scalarEquals)(cell, lookupValue)) {
                 return (0, _shared_1.getCell)(table, r, colIndex - 1);
             }
-            if (scalarStringEquals(cell, lookupValue)) {
+            if (wildcardRe && cell.kind === 2 /* RVKind.String */ && wildcardRe.test(cell.value)) {
+                return (0, _shared_1.getCell)(table, r, colIndex - 1);
+            }
+            if (literalLc !== null &&
+                cell.kind === 2 /* RVKind.String */ &&
+                cell.value.toLowerCase() === literalLc) {
                 return (0, _shared_1.getCell)(table, r, colIndex - 1);
             }
         }
         return values_1.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 = (0, _shared_1.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 = (0, values_1.compareScalarsSameKind)(v, lookupValue);
+        if (!Number.isFinite(cmp)) {
+            continue;
+        }
+        if (cmp <= 0) {
+            bestRow = r;
+        }
+        else {
+            break;
         }
     }
     return bestRow >= 0 ? (0, _shared_1.getCell)(table, bestRow, colIndex - 1) : values_1.ERRORS.NA;
@@ -311,13 +334,16 @@ function fnHLOOKUP(args) {
         return values_1.ERRORS.NA;
     }
     const table = args[1];
-    const rowIndexV = (0, values_1.toNumberRV)(args[2]);
+    const rowIndexV = (0, values_1.toNumberRV)((0, values_1.topLeft)(args[2]));
     if ((0, values_1.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 ? (0, values_1.toBooleanRV)(args[3]) : { kind: 3 /* RVKind.Boolean */, value: true };
+    // Blank `range_lookup` → Excel default TRUE (see VLOOKUP rationale).
+    const rangeLookupV = args.length > 3 && args[3].kind !== 0 /* RVKind.Blank */
+        ? (0, values_1.toBooleanRV)((0, values_1.topLeft)(args[3]))
+        : { kind: 3 /* RVKind.Boolean */, value: true };
     if ((0, values_1.isError)(rangeLookupV)) {
         return rangeLookupV;
     }
@@ -326,8 +352,33 @@ function fnHLOOKUP(args) {
         return values_1.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 === 2 /* RVKind.String */ ? lookupValue.value : null;
+        let wildcardRe = null;
+        let literalLc = null;
+        if (lookupStr !== null && (0, _shared_1.hasUnescapedWildcard)(lookupStr)) {
+            try {
+                wildcardRe = new RegExp("^" + (0, _shared_1.excelWildcardToRegex)(lookupStr) + "$", "i");
+            }
+            catch {
+                wildcardRe = null;
+            }
+        }
+        else if (lookupStr !== null && /~[*?~]/.test(lookupStr)) {
+            literalLc = (0, _shared_1.unescapeExcelWildcard)(lookupStr).toLowerCase();
+        }
         for (let c = 0; c < table.width; c++) {
-            if ((0, values_1.scalarEquals)((0, _shared_1.getCell)(table, 0, c), lookupValue)) {
+            const cell = (0, _shared_1.getCell)(table, 0, c);
+            if ((0, values_1.scalarEquals)(cell, lookupValue)) {
+                return (0, _shared_1.getCell)(table, rowIndex - 1, c);
+            }
+            if (wildcardRe && cell.kind === 2 /* RVKind.String */ && wildcardRe.test(cell.value)) {
+                return (0, _shared_1.getCell)(table, rowIndex - 1, c);
+            }
+            if (literalLc !== null &&
+                cell.kind === 2 /* RVKind.String */ &&
+                cell.value.toLowerCase() === literalLc) {
                 return (0, _shared_1.getCell)(table, rowIndex - 1, c);
             }
         }
@@ -336,18 +387,18 @@ function fnHLOOKUP(args) {
     let bestCol = -1;
     for (let c = 0; c < table.width; c++) {
         const hv = (0, _shared_1.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 = (0, values_1.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 ? (0, _shared_1.getCell)(table, rowIndex - 1, bestCol) : values_1.ERRORS.NA;
@@ -365,17 +416,30 @@ function fnXLOOKUP(args) {
         return values_1.ERRORS.VALUE;
     }
     const returnArr = args[2];
-    const ifNotFound = args.length > 3 ? (0, values_1.topLeft)(args[3]) : null;
-    const matchModeV = args.length > 4 ? (0, values_1.toNumberRV)(args[4]) : (0, values_1.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 !== 0 /* RVKind.Blank */ ? (0, values_1.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 !== 0 /* RVKind.Blank */ ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[4])) : (0, values_1.rvNumber)(0);
     if ((0, values_1.isError)(matchModeV)) {
         return matchModeV;
     }
     const matchMode = matchModeV.value;
-    const searchModeV = args.length > 5 ? (0, values_1.toNumberRV)(args[5]) : (0, values_1.rvNumber)(1);
+    if (matchMode !== 0 && matchMode !== -1 && matchMode !== 1 && matchMode !== 2) {
+        return values_1.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 !== 0 /* RVKind.Blank */ ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[5])) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(searchModeV)) {
         return searchModeV;
     }
     const searchMode = searchModeV.value;
+    if (searchMode !== 1 && searchMode !== -1 && searchMode !== 2 && searchMode !== -2) {
+        return values_1.ERRORS.VALUE;
+    }
     // Flatten lookup array to 1D
     const flat = [];
     const isRow = lookupArr.height === 1;
@@ -480,10 +544,6 @@ function fnXLOOKUP(args) {
                 foundIdx = i;
                 break;
             }
-            if (scalarStringEquals(flat[i], lookupValue)) {
-                foundIdx = i;
-                break;
-            }
         }
     }
     else if (matchMode === -1) {
@@ -586,16 +646,23 @@ function fnXMATCH(args) {
         return values_1.ERRORS.VALUE;
     }
     const lookupArr = args[1];
-    const matchModeV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(0);
+    // Blank `match_mode` → 0 (exact). Same validation as XLOOKUP.
+    const matchModeV = args.length > 2 && args[2].kind !== 0 /* RVKind.Blank */ ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[2])) : (0, values_1.rvNumber)(0);
     if ((0, values_1.isError)(matchModeV)) {
         return matchModeV;
     }
     const matchMode = matchModeV.value;
-    const searchModeV = args.length > 3 ? (0, values_1.toNumberRV)(args[3]) : (0, values_1.rvNumber)(1);
+    if (matchMode !== 0 && matchMode !== -1 && matchMode !== 1 && matchMode !== 2) {
+        return values_1.ERRORS.VALUE;
+    }
+    const searchModeV = args.length > 3 && args[3].kind !== 0 /* RVKind.Blank */ ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[3])) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(searchModeV)) {
         return searchModeV;
     }
     const searchMode = searchModeV.value;
+    if (searchMode !== 1 && searchMode !== -1 && searchMode !== 2 && searchMode !== -2) {
+        return values_1.ERRORS.VALUE;
+    }
     const flat = [];
     if (lookupArr.height === 1) {
         for (let c = 0; c < lookupArr.width; c++) {
@@ -615,9 +682,6 @@ function fnXMATCH(args) {
             if ((0, values_1.scalarEquals)(flat[i], lookupValue)) {
                 return (0, values_1.rvNumber)(i + 1);
             }
-            if (scalarStringEquals(flat[i], lookupValue)) {
-                return (0, values_1.rvNumber)(i + 1);
-            }
         }
         return values_1.ERRORS.NA;
     }
@@ -665,11 +729,11 @@ 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 = (0, values_1.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 || (0, values_1.compareScalarsSameKind)(flat[i], flat[best]) > 0)) {
                 best = i;
             }
         }
@@ -679,11 +743,11 @@ 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 = (0, values_1.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 || (0, values_1.compareScalarsSameKind)(flat[i], flat[best]) < 0)) {
                 best = i;
             }
         }
@@ -692,12 +756,12 @@ function fnXMATCH(args) {
     return values_1.ERRORS.NA;
 }
 function fnADDRESS(args) {
-    const rowNumV = (0, values_1.toNumberRV)(args[0]);
+    const rowNumV = (0, values_1.toNumberRV)((0, values_1.topLeft)(args[0]));
     if ((0, values_1.isError)(rowNumV)) {
         return rowNumV;
     }
     const rowNum = Math.trunc(rowNumV.value);
-    const colNumV = (0, values_1.toNumberRV)(args[1]);
+    const colNumV = (0, values_1.toNumberRV)((0, values_1.topLeft)(args[1]));
     if ((0, values_1.isError)(colNumV)) {
         return colNumV;
     }
@@ -708,7 +772,10 @@ function fnADDRESS(args) {
     if (!Number.isFinite(rowNum) || !Number.isFinite(colNum) || rowNum < 1 || colNum < 1) {
         return values_1.ERRORS.VALUE;
     }
-    const absNumV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.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 !== 0 /* RVKind.Blank */ ? (0, values_1.toNumberRV)((0, values_1.topLeft)(args[2])) : (0, values_1.rvNumber)(1);
     if ((0, values_1.isError)(absNumV)) {
         return absNumV;
     }
@@ -720,7 +787,7 @@ function fnADDRESS(args) {
     // a1 style (true/default) vs r1c1 (false)
     const a1Arg = args.length > 3 ? (0, values_1.topLeft)(args[3]) : { kind: 3 /* RVKind.Boolean */, value: true };
     const a1 = a1Arg.kind === 3 /* RVKind.Boolean */ ? a1Arg.value : true;
-    const sheetText = args.length > 4 ? (0, values_1.toStringRV)(args[4]) : "";
+    const sheetText = args.length > 4 ? (0, values_1.toStringRV)((0, values_1.topLeft)(args[4])) : "";
     if (!a1) {
         // R1C1 style
         const rPart = absNum === 1 || absNum === 2 ? `R${rowNum}` : `R[${rowNum}]`;
@@ -793,20 +860,7 @@ function fnLOOKUP(args) {
                 flat.push((0, _shared_1.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 values_1.ERRORS.NA;
         }
@@ -827,38 +881,48 @@ function fnLOOKUP(args) {
         return values_1.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 = (0, _shared_1.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((0, _shared_1.getCell)(lookupArr, 0, c));
         }
+        const bestIdx = findLastLessEqual(firstRow, lookupValue);
         return bestIdx >= 0 ? (0, _shared_1.getCell)(lookupArr, rows - 1, bestIdx) : values_1.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 = (0, _shared_1.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((0, _shared_1.getCell)(lookupArr, r, 0));
     }
+    const bestIdx = findLastLessEqual(firstCol, lookupValue);
     return bestIdx >= 0 ? (0, _shared_1.getCell)(lookupArr, bestIdx, cols - 1) : values_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 = (0, values_1.compareScalarsSameKind)(v, target);
+        if (!Number.isFinite(cmp)) {
+            continue;
+        }
+        if (cmp <= 0) {
+            bestIdx = i;
+        }
+    }
+    return bestIdx;
+}
 function fnTRANSPOSE(args) {
     if (!(0, values_1.isArray)(args[0])) {
         const sv = (0, values_1.topLeft)(args[0]);
@@ -887,10 +951,13 @@ function fnAREAS(args) {
     if (args.length === 0) {
         return values_1.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 === 4 /* RVKind.Error */) {
         return a;
@@ -898,5 +965,5 @@ function fnAREAS(args) {
     if (a.kind === 6 /* RVKind.Reference */) {
         return (0, values_1.rvNumber)(a.areas.length);
     }
-    return (0, values_1.rvNumber)(1);
+    return values_1.ERRORS.VALUE;
 }