@cj-tech-master/excelts 9.2.1 → 9.3.0

package/dist/cjs/modules/formula/functions/dynamic-array.js

@@ -0,0 +1,881 @@
+"use strict";
+/**
+ * Dynamic Array Functions — Native RuntimeValue Implementation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnFILTER = fnFILTER;
+exports.fnSORT = fnSORT;
+exports.fnUNIQUE = fnUNIQUE;
+exports.fnSORTBY = fnSORTBY;
+exports.fnSUBTOTAL = fnSUBTOTAL;
+exports.fnAGGREGATE = fnAGGREGATE;
+exports.fnSEQUENCE = fnSEQUENCE;
+exports.fnRANDARRAY = fnRANDARRAY;
+exports.fnTOCOL = fnTOCOL;
+exports.fnTOROW = fnTOROW;
+exports.fnCHOOSEROWS = fnCHOOSEROWS;
+exports.fnCHOOSECOLS = fnCHOOSECOLS;
+exports.fnVSTACK = fnVSTACK;
+exports.fnHSTACK = fnHSTACK;
+exports.fnTAKE = fnTAKE;
+exports.fnDROP = fnDROP;
+exports.fnWRAPROWS = fnWRAPROWS;
+exports.fnWRAPCOLS = fnWRAPCOLS;
+exports.fnEXPAND = fnEXPAND;
+const values_1 = require("../runtime/values");
+const _shared_1 = require("./_shared");
+const math_1 = require("./math");
+const statistical_1 = require("./statistical");
+function isScalarError(v) {
+    return v.kind === 4 /* RVKind.Error */;
+}
+function isScalarBlankOrEmpty(v) {
+    return v.kind === 0 /* RVKind.Blank */ || (v.kind === 2 /* RVKind.String */ && v.value === "");
+}
+/**
+ * Kind-priority ordering for cross-type sorting.
+ *
+ * `compareScalarsSameKind` returns `NaN` when the two operands have
+ * different kinds, so SORT/SORTBY need a deterministic tiebreak. Excel's
+ * workbook-grade sort groups values by kind — Numbers before Strings,
+ * Strings before Booleans, Booleans before Blanks/Errors — which is the
+ * priority we encode here.
+ */
+function kindPriority(k) {
+    switch (k) {
+        case 1 /* RVKind.Number */:
+            return 0;
+        case 2 /* RVKind.String */:
+            return 1;
+        case 3 /* RVKind.Boolean */:
+            return 2;
+        case 0 /* RVKind.Blank */:
+            return 3;
+        case 4 /* RVKind.Error */:
+            return 4;
+        default:
+            return 5;
+    }
+}
+/**
+ * Locale-independent comparator for SORT / SORTBY.
+ *
+ * Uses `compareScalarsSameKind` for same-kind ordering (strings compared
+ * case-insensitively, not via `localeCompare`, so results are stable
+ * across machines) and falls back to `kindPriority` when the operands
+ * differ in kind.
+ */
+function compareForSort(a, b) {
+    if (a.kind !== b.kind) {
+        return kindPriority(a.kind) - kindPriority(b.kind);
+    }
+    const cmp = (0, values_1.compareScalarsSameKind)(a, b);
+    return Number.isNaN(cmp) ? 0 : cmp;
+}
+function fnFILTER(args) {
+    const dataArr = (0, _shared_1.asArray)(args[0]);
+    const includeArr = (0, _shared_1.asArray)(args[1]);
+    if (!dataArr || !includeArr) {
+        return values_1.ERRORS.VALUE;
+    }
+    // Excel requires `include` to be a 1-column vector matching data's
+    // height (the common row-filter shape). A mismatched shape previously
+    // let rows slip through silently because `getCell` out-of-bounds
+    // returns BLANK, which reads as FALSE.
+    if (includeArr.width !== 1 || includeArr.height !== dataArr.height) {
+        return values_1.ERRORS.VALUE;
+    }
+    const ifEmpty = args.length > 2 ? (0, values_1.topLeft)(args[2]) : null;
+    const resultRows = [];
+    for (let r = 0; r < dataArr.height; r++) {
+        const inc = (0, _shared_1.getCell)(includeArr, r, 0);
+        if (inc.kind === 4 /* RVKind.Error */) {
+            return inc;
+        }
+        if ((inc.kind === 3 /* RVKind.Boolean */ && inc.value) ||
+            (inc.kind === 1 /* RVKind.Number */ && inc.value !== 0)) {
+            const row = [];
+            for (let c = 0; c < dataArr.width; c++) {
+                row.push((0, _shared_1.getCell)(dataArr, r, c));
+            }
+            resultRows.push(row);
+        }
+    }
+    if (resultRows.length === 0) {
+        return ifEmpty !== null ? (0, values_1.rvArray)([[ifEmpty]]) : values_1.ERRORS.CALC;
+    }
+    return (0, values_1.rvArray)(resultRows);
+}
+function fnSORT(args) {
+    const dataArr = (0, _shared_1.asArray)(args[0]);
+    if (!dataArr) {
+        return values_1.ERRORS.VALUE;
+    }
+    const rows = [];
+    for (let r = 0; r < dataArr.height; r++) {
+        const row = [];
+        for (let c = 0; c < dataArr.width; c++) {
+            row.push((0, _shared_1.getCell)(dataArr, r, c));
+        }
+        rows.push(row);
+    }
+    const sortIndexV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(sortIndexV)) {
+        return sortIndexV;
+    }
+    const sortOrderV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(sortOrderV)) {
+        return sortOrderV;
+    }
+    const byColV = args.length > 3 ? (0, values_1.toBooleanRV)(args[3]) : { kind: 3 /* RVKind.Boolean */, value: false };
+    if ((0, values_1.isError)(byColV)) {
+        return byColV;
+    }
+    // Truncate the index so fractional inputs don't silently become NaN
+    // when used as array subscripts. Then bounds-check against the axis
+    // SORT will actually walk — this turns `SORT(arr, 0)` / out-of-range
+    // values into the documented #VALUE! instead of a soft-fail.
+    const sortIndex = Math.trunc(sortIndexV.value);
+    if (byColV.value) {
+        if (sortIndex < 1 || sortIndex > dataArr.height) {
+            return values_1.ERRORS.VALUE;
+        }
+        const colIndices = Array.from({ length: dataArr.width }, (_, i) => i);
+        const rowIdx = sortIndex - 1;
+        colIndices.sort((a, b) => {
+            const va = (0, _shared_1.getCell)(dataArr, rowIdx, a);
+            const vb = (0, _shared_1.getCell)(dataArr, rowIdx, b);
+            return compareForSort(va, vb) * sortOrderV.value;
+        });
+        return (0, values_1.rvArray)(rows.map(row => colIndices.map(c => row[c])));
+    }
+    if (sortIndex < 1 || sortIndex > dataArr.width) {
+        return values_1.ERRORS.VALUE;
+    }
+    const col = sortIndex - 1;
+    rows.sort((a, b) => compareForSort(a[col], b[col]) * sortOrderV.value);
+    return (0, values_1.rvArray)(rows);
+}
+function fnUNIQUE(args) {
+    const dataArr = (0, _shared_1.asArray)(args[0]);
+    if (!dataArr) {
+        return values_1.ERRORS.VALUE;
+    }
+    const byColV = args.length > 1 ? (0, values_1.toBooleanRV)(args[1]) : { kind: 3 /* RVKind.Boolean */, value: false };
+    if ((0, values_1.isError)(byColV)) {
+        return byColV;
+    }
+    const exactlyOnceV = args.length > 2 ? (0, values_1.toBooleanRV)(args[2]) : { kind: 3 /* RVKind.Boolean */, value: false };
+    if ((0, values_1.isError)(exactlyOnceV)) {
+        return exactlyOnceV;
+    }
+    if (byColV.value) {
+        const transposed = [];
+        for (let c = 0; c < dataArr.width; c++) {
+            const col = [];
+            for (let r = 0; r < dataArr.height; r++) {
+                col.push((0, _shared_1.getCell)(dataArr, r, c));
+            }
+            transposed.push(col);
+        }
+        const unique = applyUnique(transposed, exactlyOnceV.value);
+        if (unique.length === 0) {
+            return values_1.ERRORS.VALUE;
+        }
+        const numRows = unique[0].length;
+        const result = [];
+        for (let r = 0; r < numRows; r++) {
+            result.push(unique.map(ci => ci[r]));
+        }
+        return (0, values_1.rvArray)(result);
+    }
+    const dataRows = [];
+    for (let r = 0; r < dataArr.height; r++) {
+        const row = [];
+        for (let c = 0; c < dataArr.width; c++) {
+            row.push((0, _shared_1.getCell)(dataArr, r, c));
+        }
+        dataRows.push(row);
+    }
+    const result = applyUnique(dataRows, exactlyOnceV.value);
+    return result.length > 0 ? (0, values_1.rvArray)(result) : values_1.ERRORS.VALUE;
+}
+function applyUnique(rows, exactlyOnce) {
+    const keyCount = new Map();
+    const keyToRows = new Map();
+    const order = [];
+    for (const row of rows) {
+        // Key the row by (kind, textual form) per cell so that UNIQUE preserves
+        // Excel's type-aware equality: the number `1` and the string `"1"` are
+        // distinct entries. Without the kind prefix they would collide because
+        // `toStringRV` renders both as `"1"`.
+        const key = row.map(c => `${c.kind}\u0001${scalarUniqueKey(c)}`).join("\u0002");
+        if (!keyCount.has(key)) {
+            order.push(key);
+            keyToRows.set(key, row);
+        }
+        keyCount.set(key, (keyCount.get(key) ?? 0) + 1);
+    }
+    const result = [];
+    for (const key of order) {
+        if (exactlyOnce && (keyCount.get(key) ?? 0) > 1) {
+            continue;
+        }
+        result.push(keyToRows.get(key));
+    }
+    return result;
+}
+/**
+ * Produce a string that fully identifies a scalar for equality purposes,
+ * distinguishing kinds that stringify identically but must not merge.
+ */
+function scalarUniqueKey(v) {
+    if (v.kind === 1 /* RVKind.Number */) {
+        // Using `toString` instead of localised formatting keeps NaN/Infinity
+        // / -0 distinguishable from `0`, which matters for exact duplication
+        // detection.
+        return Object.is(v.value, -0) ? "-0" : String(v.value);
+    }
+    if (v.kind === 3 /* RVKind.Boolean */) {
+        return v.value ? "1" : "0";
+    }
+    if (v.kind === 4 /* RVKind.Error */) {
+        return v.code;
+    }
+    if (v.kind === 0 /* RVKind.Blank */) {
+        return "";
+    }
+    return v.value.toLowerCase();
+}
+function fnSORTBY(args) {
+    const dataArr = (0, _shared_1.asArray)(args[0]);
+    if (!dataArr || args.length < 2) {
+        return values_1.ERRORS.VALUE;
+    }
+    const data = [];
+    for (let r = 0; r < dataArr.height; r++) {
+        const row = [];
+        for (let c = 0; c < dataArr.width; c++) {
+            row.push((0, _shared_1.getCell)(dataArr, r, c));
+        }
+        data.push({ row, idx: r });
+    }
+    const sortKeys = [];
+    for (let i = 1; i < args.length; i += 2) {
+        const keyArr = (0, _shared_1.asArray)(args[i]);
+        if (!keyArr) {
+            return values_1.ERRORS.VALUE;
+        }
+        const orderV = i + 1 < args.length ? (0, values_1.toNumberRV)(args[i + 1]) : (0, values_1.rvNumber)(1);
+        if ((0, values_1.isError)(orderV)) {
+            return orderV;
+        }
+        sortKeys.push({ arr: keyArr, order: orderV.value });
+    }
+    data.sort((a, b) => {
+        for (const sk of sortKeys) {
+            const va = (0, _shared_1.getCell)(sk.arr, a.idx, 0);
+            const vb = (0, _shared_1.getCell)(sk.arr, b.idx, 0);
+            const cmp = compareForSort(va, vb);
+            if (cmp !== 0) {
+                return cmp * sk.order;
+            }
+        }
+        return 0;
+    });
+    return (0, values_1.rvArray)(data.map(d => d.row));
+}
+function fnSUBTOTAL(args) {
+    const funcNumV = (0, values_1.toNumberRV)(args[0]);
+    if ((0, values_1.isError)(funcNumV)) {
+        return funcNumV;
+    }
+    // Excel skips cells whose own formula is SUBTOTAL/AGGREGATE to avoid
+    // double-counting when an outer aggregate spans a totals row or another
+    // subtotal cell. `buildRangeArray` marks those cells via
+    // `subtotalMask`; we strip them here before handing off to the
+    // underlying aggregator.
+    let dataArgs = (0, _shared_1.stripSubtotalMaskedCells)(args.slice(1));
+    // Truncate toward zero: Excel rejects non-integer function codes, so
+    // `SUBTOTAL(9.5, …)` should behave as `SUBTOTAL(9, …)` rather than
+    // slipping through the switch and returning #VALUE!. (R6-P1-9)
+    const rawFn = Math.trunc(funcNumV.value);
+    const fn = rawFn > 100 ? rawFn - 100 : rawFn;
+    // The 1xx variants (101-111) additionally skip hidden rows. Excel's
+    // plain 1-11 codes only skip filter-hidden rows — but our worksheet
+    // model carries a single `row.hidden` boolean that conflates the two
+    // states, so we apply hidden-row stripping only to the 1xx variants
+    // (matching manual-hide semantics; filter-hide remains a limitation
+    // at the adapter layer, not here).
+    if (rawFn > 100) {
+        dataArgs = (0, _shared_1.stripHiddenRowCells)(dataArgs);
+    }
+    switch (fn) {
+        case 1:
+            return (0, math_1.fnAVERAGE)(dataArgs);
+        case 2:
+            return (0, math_1.fnCOUNT)(dataArgs);
+        case 3:
+            return (0, math_1.fnCOUNTA)(dataArgs);
+        case 4:
+            return (0, math_1.fnMAX)(dataArgs);
+        case 5:
+            return (0, math_1.fnMIN)(dataArgs);
+        case 6:
+            return (0, math_1.fnPRODUCT)(dataArgs);
+        case 7:
+            return (0, statistical_1.fnSTDEV)(dataArgs);
+        case 8:
+            return (0, statistical_1.fnSTDEVP)(dataArgs);
+        case 9:
+            return (0, math_1.fnSUM)(dataArgs);
+        case 10:
+            return (0, statistical_1.fnVAR)(dataArgs);
+        case 11:
+            return (0, statistical_1.fnVARP)(dataArgs);
+        default:
+            return values_1.ERRORS.VALUE;
+    }
+}
+function fnAGGREGATE(args) {
+    const funcNumV = (0, values_1.toNumberRV)(args[0]);
+    if ((0, values_1.isError)(funcNumV)) {
+        return funcNumV;
+    }
+    // Resolve the "options" parameter (arg[1]). Excel's option codes
+    // (0–7) control which cells to skip:
+    //   0 or omitted → ignore nested SUBTOTAL/AGGREGATE
+    //   1 → ignore hidden rows + nested
+    //   2 → ignore errors + nested
+    //   3 → ignore hidden rows + errors + nested
+    //   4 → ignore nothing
+    //   5 → ignore hidden rows (keep nested)
+    //   6 → ignore errors (keep nested)
+    //   7 → ignore hidden rows + errors (keep nested)
+    const optV = args[1] !== undefined ? (0, values_1.toNumberRV)(args[1]) : undefined;
+    if (optV && (0, values_1.isError)(optV)) {
+        return optV;
+    }
+    const option = optV ? Math.trunc(optV.value) : 0;
+    const skipNested = option <= 3; // 0,1,2,3 skip nested SUBTOTAL/AGGREGATE
+    const skipHidden = option === 1 || option === 3 || option === 5 || option === 7;
+    const skipErrors = option === 2 || option === 3 || option === 6 || option === 7;
+    let dataArgs = args.slice(2);
+    if (skipNested) {
+        dataArgs = (0, _shared_1.stripSubtotalMaskedCells)(dataArgs);
+    }
+    if (skipHidden) {
+        dataArgs = (0, _shared_1.stripHiddenRowCells)(dataArgs);
+    }
+    if (skipErrors) {
+        dataArgs = (0, _shared_1.stripErrorCells)(dataArgs);
+    }
+    // Excel rejects non-integer function codes; truncate toward zero
+    // so AGGREGATE(9.5, …) behaves as AGGREGATE(9, …), matching SUBTOTAL.
+    const fnCode = Math.trunc(funcNumV.value);
+    switch (fnCode) {
+        case 1:
+            return (0, math_1.fnAVERAGE)(dataArgs);
+        case 2:
+            return (0, math_1.fnCOUNT)(dataArgs);
+        case 3:
+            return (0, math_1.fnCOUNTA)(dataArgs);
+        case 4:
+            return (0, math_1.fnMAX)(dataArgs);
+        case 5:
+            return (0, math_1.fnMIN)(dataArgs);
+        case 6:
+            return (0, math_1.fnPRODUCT)(dataArgs);
+        case 7:
+            return (0, statistical_1.fnSTDEV)(dataArgs);
+        case 8:
+            return (0, statistical_1.fnSTDEVP)(dataArgs);
+        case 9:
+            return (0, math_1.fnSUM)(dataArgs);
+        case 10:
+            return (0, statistical_1.fnVAR)(dataArgs);
+        case 11:
+            return (0, statistical_1.fnVARP)(dataArgs);
+        case 12:
+            return (0, statistical_1.fnMEDIAN)(dataArgs);
+        case 13:
+            return (0, statistical_1.fnMODE)(dataArgs);
+        case 14:
+            return (0, statistical_1.fnLARGE)(dataArgs);
+        case 15:
+            return (0, statistical_1.fnSMALL)(dataArgs);
+        case 16:
+            return (0, statistical_1.fnPERCENTILE)(dataArgs);
+        case 17:
+            return (0, statistical_1.fnQUARTILE)(dataArgs);
+        case 18:
+            return (0, statistical_1.fnPERCENTILEEXC)(dataArgs);
+        case 19:
+            return (0, statistical_1.fnQUARTILEEXC)(dataArgs);
+        default:
+            return values_1.ERRORS.VALUE;
+    }
+}
+function fnSEQUENCE(args) {
+    const rowsV = (0, values_1.toNumberRV)(args[0]);
+    if ((0, values_1.isError)(rowsV)) {
+        return rowsV;
+    }
+    const colsV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(colsV)) {
+        return colsV;
+    }
+    const startV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(startV)) {
+        return startV;
+    }
+    const stepV = args.length > 3 ? (0, values_1.toNumberRV)(args[3]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(stepV)) {
+        return stepV;
+    }
+    // Excel truncates row/col counts toward zero and rejects anything
+    // below 1. Without this guard `SEQUENCE(-3)` would produce an empty
+    // ArrayValue which breaks downstream rectangularisation, and
+    // `SEQUENCE(2.5, 2)` would generate 3 rows instead of Excel's 2.
+    const rowCount = Math.trunc(rowsV.value);
+    const colCount = Math.trunc(colsV.value);
+    if (!Number.isFinite(rowCount) || !Number.isFinite(colCount) || rowCount < 1 || colCount < 1) {
+        return values_1.ERRORS.NUM;
+    }
+    // Bound the output to the same 10M-cell budget the rest of the array
+    // pipeline uses. SEQUENCE(1e9, 1e9) would otherwise try to allocate
+    // 1e18 scalars before OOM-ing (R6-P1-4).
+    if (rowCount * colCount > 10000000) {
+        return values_1.ERRORS.NUM;
+    }
+    const result = [];
+    let val = startV.value;
+    for (let r = 0; r < rowCount; r++) {
+        const row = [];
+        for (let c = 0; c < colCount; c++) {
+            row.push((0, values_1.rvNumber)(val));
+            val += stepV.value;
+        }
+        result.push(row);
+    }
+    return (0, values_1.rvArray)(result);
+}
+function fnRANDARRAY(args) {
+    const rowsV = args.length > 0 ? (0, values_1.toNumberRV)(args[0]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(rowsV)) {
+        return rowsV;
+    }
+    const colsV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(colsV)) {
+        return colsV;
+    }
+    const minV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(0);
+    if ((0, values_1.isError)(minV)) {
+        return minV;
+    }
+    const maxV = args.length > 3 ? (0, values_1.toNumberRV)(args[3]) : (0, values_1.rvNumber)(1);
+    if ((0, values_1.isError)(maxV)) {
+        return maxV;
+    }
+    const wholeV = args.length > 4 ? (0, values_1.toBooleanRV)(args[4]) : { kind: 3 /* RVKind.Boolean */, value: false };
+    if ((0, values_1.isError)(wholeV)) {
+        return wholeV;
+    }
+    const rowCount = Math.trunc(rowsV.value);
+    const colCount = Math.trunc(colsV.value);
+    // Excel rejects rows/cols < 1 and min > max with #VALUE!, and when the
+    // `whole` flag is TRUE it additionally requires integer min/max.
+    if (!Number.isFinite(rowCount) ||
+        !Number.isFinite(colCount) ||
+        rowCount < 1 ||
+        colCount < 1 ||
+        minV.value > maxV.value) {
+        return values_1.ERRORS.VALUE;
+    }
+    if (wholeV.value && (!Number.isInteger(minV.value) || !Number.isInteger(maxV.value))) {
+        return values_1.ERRORS.VALUE;
+    }
+    // Same 10M-cell budget as SEQUENCE / MAKEARRAY / broadcastBinaryOp —
+    // otherwise `RANDARRAY(1e6, 1e6)` OOMs the host. (R6-P1-4)
+    if (rowCount * colCount > 10000000) {
+        return values_1.ERRORS.NUM;
+    }
+    const result = [];
+    for (let r = 0; r < rowCount; r++) {
+        const row = [];
+        for (let c = 0; c < colCount; c++) {
+            if (wholeV.value) {
+                // Draw a uniform integer in [min, max] inclusive. The old code
+                // did `Math.floor(min + random() * (max - min))` which excluded
+                // `max` almost always.
+                const span = maxV.value - minV.value + 1;
+                row.push((0, values_1.rvNumber)(minV.value + Math.floor(Math.random() * span)));
+            }
+            else {
+                row.push((0, values_1.rvNumber)(minV.value + Math.random() * (maxV.value - minV.value)));
+            }
+        }
+        result.push(row);
+    }
+    return (0, values_1.rvArray)(result);
+}
+function fnTOCOL(args) {
+    if (!(0, values_1.isArray)(args[0])) {
+        return (0, values_1.rvArray)([[(0, values_1.topLeft)(args[0])]]);
+    }
+    const arr = args[0];
+    const ignoreV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(0);
+    if ((0, values_1.isError)(ignoreV)) {
+        return ignoreV;
+    }
+    const scanV = args.length > 2 ? (0, values_1.toBooleanRV)(args[2]) : { kind: 3 /* RVKind.Boolean */, value: false };
+    if ((0, values_1.isError)(scanV)) {
+        return scanV;
+    }
+    const result = [];
+    const addCell = (v) => {
+        if (ignoreV.value === 1 && isScalarBlankOrEmpty(v)) {
+            return;
+        }
+        if (ignoreV.value === 2 && isScalarError(v)) {
+            return;
+        }
+        if (ignoreV.value === 3 && (isScalarBlankOrEmpty(v) || isScalarError(v))) {
+            return;
+        }
+        result.push([v]);
+    };
+    if (scanV.value) {
+        for (let c = 0; c < arr.width; c++) {
+            for (let r = 0; r < arr.height; r++) {
+                addCell((0, _shared_1.getCell)(arr, r, c));
+            }
+        }
+    }
+    else {
+        for (let r = 0; r < arr.height; r++) {
+            for (let c = 0; c < arr.width; c++) {
+                addCell((0, _shared_1.getCell)(arr, r, c));
+            }
+        }
+    }
+    return result.length > 0 ? (0, values_1.rvArray)(result) : values_1.ERRORS.CALC;
+}
+function fnTOROW(args) {
+    if (!(0, values_1.isArray)(args[0])) {
+        return (0, values_1.rvArray)([[(0, values_1.topLeft)(args[0])]]);
+    }
+    const arr = args[0];
+    const ignoreV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(0);
+    if ((0, values_1.isError)(ignoreV)) {
+        return ignoreV;
+    }
+    const scanV = args.length > 2 ? (0, values_1.toBooleanRV)(args[2]) : { kind: 3 /* RVKind.Boolean */, value: false };
+    if ((0, values_1.isError)(scanV)) {
+        return scanV;
+    }
+    const result = [];
+    const addCell = (v) => {
+        if (ignoreV.value === 1 && isScalarBlankOrEmpty(v)) {
+            return;
+        }
+        if (ignoreV.value === 2 && isScalarError(v)) {
+            return;
+        }
+        if (ignoreV.value === 3 && (isScalarBlankOrEmpty(v) || isScalarError(v))) {
+            return;
+        }
+        result.push(v);
+    };
+    if (scanV.value) {
+        for (let c = 0; c < arr.width; c++) {
+            for (let r = 0; r < arr.height; r++) {
+                addCell((0, _shared_1.getCell)(arr, r, c));
+            }
+        }
+    }
+    else {
+        for (let r = 0; r < arr.height; r++) {
+            for (let c = 0; c < arr.width; c++) {
+                addCell((0, _shared_1.getCell)(arr, r, c));
+            }
+        }
+    }
+    return result.length > 0 ? (0, values_1.rvArray)([result]) : values_1.ERRORS.CALC;
+}
+function fnCHOOSEROWS(args) {
+    const d = (0, _shared_1.asArray)(args[0]);
+    if (!d) {
+        return values_1.ERRORS.VALUE;
+    }
+    const result = [];
+    for (let i = 1; i < args.length; i++) {
+        const nV = (0, values_1.toNumberRV)(args[i]);
+        if ((0, values_1.isError)(nV)) {
+            return nV;
+        }
+        const idx = nV.value > 0 ? nV.value - 1 : d.height + nV.value;
+        if (idx < 0 || idx >= d.height) {
+            return values_1.ERRORS.VALUE;
+        }
+        const row = [];
+        for (let c = 0; c < d.width; c++) {
+            row.push((0, _shared_1.getCell)(d, idx, c));
+        }
+        result.push(row);
+    }
+    return (0, values_1.rvArray)(result);
+}
+function fnCHOOSECOLS(args) {
+    const d = (0, _shared_1.asArray)(args[0]);
+    if (!d) {
+        return values_1.ERRORS.VALUE;
+    }
+    const ci = [];
+    for (let i = 1; i < args.length; i++) {
+        const nV = (0, values_1.toNumberRV)(args[i]);
+        if ((0, values_1.isError)(nV)) {
+            return nV;
+        }
+        const idx = nV.value > 0 ? nV.value - 1 : d.width + nV.value;
+        if (idx < 0 || idx >= d.width) {
+            return values_1.ERRORS.VALUE;
+        }
+        ci.push(idx);
+    }
+    const result = [];
+    for (let r = 0; r < d.height; r++) {
+        result.push(ci.map(c => (0, _shared_1.getCell)(d, r, c)));
+    }
+    return (0, values_1.rvArray)(result);
+}
+function fnVSTACK(args) {
+    const rows = [];
+    let maxWidth = 0;
+    for (const a of args) {
+        if (a.kind === 5 /* RVKind.Array */) {
+            for (let r = 0; r < a.height; r++) {
+                const row = [];
+                for (let c = 0; c < a.width; c++) {
+                    row.push(a.rows[r][c]);
+                }
+                rows.push(row);
+                if (a.width > maxWidth) {
+                    maxWidth = a.width;
+                }
+            }
+        }
+        else {
+            rows.push([(0, values_1.topLeft)(a)]);
+            if (maxWidth < 1) {
+                maxWidth = 1;
+            }
+        }
+    }
+    if (rows.length === 0) {
+        return values_1.ERRORS.VALUE;
+    }
+    // Pad with #N/A (not BLANK) to match Excel, and to stay symmetric with
+    // HSTACK's existing behaviour. The previous code left short rows to be
+    // rectangularised by `rvArray`, which used BLANK — visually wrong and
+    // inconsistent with how HSTACK reports "missing" cells.
+    for (const row of rows) {
+        while (row.length < maxWidth) {
+            row.push(values_1.ERRORS.NA);
+        }
+    }
+    return (0, values_1.rvArray)(rows);
+}
+function fnHSTACK(args) {
+    let maxRows = 0;
+    const arrays = [];
+    for (const a of args) {
+        if (a.kind === 5 /* RVKind.Array */) {
+            arrays.push(a);
+            if (a.height > maxRows) {
+                maxRows = a.height;
+            }
+        }
+        else {
+            arrays.push((0, values_1.rvArray)([[(0, values_1.topLeft)(a)]]));
+            if (maxRows < 1) {
+                maxRows = 1;
+            }
+        }
+    }
+    const result = [];
+    for (let r = 0; r < maxRows; r++) {
+        const row = [];
+        for (const arr of arrays) {
+            if (r < arr.height) {
+                for (let c = 0; c < arr.width; c++) {
+                    row.push(arr.rows[r][c]);
+                }
+            }
+            else {
+                for (let c = 0; c < arr.width; c++) {
+                    row.push(values_1.ERRORS.NA);
+                }
+            }
+        }
+        result.push(row);
+    }
+    return (0, values_1.rvArray)(result);
+}
+function fnTAKE(args) {
+    const d = (0, _shared_1.asArray)(args[0]);
+    if (!d) {
+        return values_1.ERRORS.VALUE;
+    }
+    const rowsV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(d.height);
+    if ((0, values_1.isError)(rowsV)) {
+        return rowsV;
+    }
+    const colsV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(d.width);
+    if ((0, values_1.isError)(colsV)) {
+        return colsV;
+    }
+    const rS = rowsV.value >= 0 ? 0 : Math.max(0, d.height + rowsV.value);
+    const rE = rowsV.value >= 0 ? Math.min(rowsV.value, d.height) : d.height;
+    const cS = colsV.value >= 0 ? 0 : Math.max(0, d.width + colsV.value);
+    const cE = colsV.value >= 0 ? Math.min(colsV.value, d.width) : d.width;
+    const result = [];
+    for (let r = rS; r < rE; r++) {
+        const row = [];
+        for (let c = cS; c < cE; c++) {
+            row.push((0, _shared_1.getCell)(d, r, c));
+        }
+        result.push(row);
+    }
+    return result.length > 0 ? (0, values_1.rvArray)(result) : values_1.ERRORS.CALC;
+}
+function fnDROP(args) {
+    const d = (0, _shared_1.asArray)(args[0]);
+    if (!d) {
+        return values_1.ERRORS.VALUE;
+    }
+    const rowsV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(0);
+    if ((0, values_1.isError)(rowsV)) {
+        return rowsV;
+    }
+    const colsV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(0);
+    if ((0, values_1.isError)(colsV)) {
+        return colsV;
+    }
+    const rS = rowsV.value >= 0 ? rowsV.value : 0;
+    const rE = rowsV.value >= 0 ? d.height : d.height + rowsV.value;
+    const cS = colsV.value >= 0 ? colsV.value : 0;
+    const cE = colsV.value >= 0 ? d.width : d.width + colsV.value;
+    const result = [];
+    for (let r = rS; r < rE; r++) {
+        const row = [];
+        for (let c = cS; c < cE; c++) {
+            row.push((0, _shared_1.getCell)(d, r, c));
+        }
+        if (row.length > 0) {
+            result.push(row);
+        }
+    }
+    return result.length > 0 ? (0, values_1.rvArray)(result) : values_1.ERRORS.CALC;
+}
+function fnWRAPROWS(args) {
+    if (!(0, values_1.isArray)(args[0])) {
+        return values_1.ERRORS.VALUE;
+    }
+    const arr = args[0];
+    const flat = [];
+    for (let r = 0; r < arr.height; r++) {
+        for (let c = 0; c < arr.width; c++) {
+            flat.push((0, _shared_1.getCell)(arr, r, c));
+        }
+    }
+    const wcV = (0, values_1.toNumberRV)(args[1]);
+    if ((0, values_1.isError)(wcV)) {
+        return wcV;
+    }
+    if (wcV.value < 1) {
+        return values_1.ERRORS.VALUE;
+    }
+    const pad = args.length > 2 ? (0, values_1.topLeft)(args[2]) : values_1.ERRORS.NA;
+    const result = [];
+    for (let i = 0; i < flat.length; i += wcV.value) {
+        const row = flat.slice(i, i + wcV.value);
+        while (row.length < wcV.value) {
+            row.push(pad);
+        }
+        result.push(row);
+    }
+    return (0, values_1.rvArray)(result);
+}
+function fnWRAPCOLS(args) {
+    if (!(0, values_1.isArray)(args[0])) {
+        return values_1.ERRORS.VALUE;
+    }
+    const arr = args[0];
+    const flat = [];
+    for (let r = 0; r < arr.height; r++) {
+        for (let c = 0; c < arr.width; c++) {
+            flat.push((0, _shared_1.getCell)(arr, r, c));
+        }
+    }
+    const wcV = (0, values_1.toNumberRV)(args[1]);
+    if ((0, values_1.isError)(wcV)) {
+        return wcV;
+    }
+    if (wcV.value < 1) {
+        return values_1.ERRORS.VALUE;
+    }
+    const pad = args.length > 2 ? (0, values_1.topLeft)(args[2]) : values_1.ERRORS.NA;
+    const numCols = Math.ceil(flat.length / wcV.value);
+    const result = [];
+    for (let r = 0; r < wcV.value; r++) {
+        const row = [];
+        for (let c = 0; c < numCols; c++) {
+            const idx = c * wcV.value + r;
+            row.push(idx < flat.length ? flat[idx] : pad);
+        }
+        result.push(row);
+    }
+    return (0, values_1.rvArray)(result);
+}
+function fnEXPAND(args) {
+    const d = (0, _shared_1.asArray)(args[0]);
+    if (!d) {
+        return values_1.ERRORS.VALUE;
+    }
+    const rowsV = args.length > 1 ? (0, values_1.toNumberRV)(args[1]) : (0, values_1.rvNumber)(d.height);
+    if ((0, values_1.isError)(rowsV)) {
+        return rowsV;
+    }
+    const colsV = args.length > 2 ? (0, values_1.toNumberRV)(args[2]) : (0, values_1.rvNumber)(d.width);
+    if ((0, values_1.isError)(colsV)) {
+        return colsV;
+    }
+    // Excel requires the target to be at least as large as the source, and
+    // both dimensions to be positive. Without Math.trunc the inner loop
+    // runs `c < rowsV.value` comparisons against a float, which produces
+    // an off-by-one depending on the fractional part (R6-P1-5).
+    const rowCount = Math.trunc(rowsV.value);
+    const colCount = Math.trunc(colsV.value);
+    if (!Number.isFinite(rowCount) ||
+        !Number.isFinite(colCount) ||
+        rowCount < d.height ||
+        colCount < d.width) {
+        return values_1.ERRORS.VALUE;
+    }
+    // Cap the output size to the same 10M-cell budget the other dynamic
+    // array producers use (see MAKEARRAY, broadcastBinaryOp).
+    if (rowCount * colCount > 10000000) {
+        return values_1.ERRORS.NUM;
+    }
+    const pad = args.length > 3 ? (0, values_1.topLeft)(args[3]) : values_1.ERRORS.NA;
+    const result = [];
+    for (let r = 0; r < rowCount; r++) {
+        const row = [];
+        for (let c = 0; c < colCount; c++) {
+            row.push(r < d.height && c < d.width ? (0, _shared_1.getCell)(d, r, c) : pad);
+        }
+        result.push(row);
+    }
+    return (0, values_1.rvArray)(result);
+}