@bilig/formula 0.1.2 → 0.1.4

package/dist/js-evaluator.js

@@ -2,7 +2,9 @@ import { ErrorCode, ValueTag, formatErrorCode } from "@bilig/protocol";
 import { indexToColumn, parseCellAddress, parseRangeAddress } from "./addressing.js";
 import { getBuiltin, hasBuiltin } from "./builtins.js";
 import { getLookupBuiltin } from "./builtins/lookup.js";
-import { evaluateGroupBy, evaluatePivotBy } from "./group-pivot-evaluator.js";
+import { evaluateArraySpecialCall } from "./js-evaluator-array-special-calls.js";
+import { evaluateContextSpecialCall } from "./js-evaluator-context-special-calls.js";
+import { evaluateWorkbookSpecialCall } from "./js-evaluator-workbook-special-calls.js";
 import { isArrayValue, scalarFromEvaluationResult, } from "./runtime-values.js";
 import { rewriteSpecialCall } from "./special-call-rewrites.js";
 function emptyValue() {
@@ -540,29 +542,6 @@ function coerceOptionalTrimModeArgument(value, fallback) {
 function isCellValueError(value) {
     return typeof value === "object" && value !== null && "tag" in value;
 }
-function indexOfWithMatchMode(text, delimiter, startIndex, matchMode) {
-    if (matchMode === 1) {
-        return text.toLowerCase().indexOf(delimiter.toLowerCase(), startIndex);
-    }
-    return text.indexOf(delimiter, startIndex);
-}
-function splitTextByDelimiter(text, delimiter, matchMode) {
-    if (delimiter === "") {
-        return [text];
-    }
-    const parts = [];
-    let cursor = 0;
-    while (cursor <= text.length) {
-        const found = indexOfWithMatchMode(text, delimiter, cursor, matchMode);
-        if (found === -1) {
-            parts.push(text.slice(cursor));
-            break;
-        }
-        parts.push(text.slice(cursor, found));
-        cursor = found + delimiter.length;
-    }
-    return parts;
-}
 function makeArrayStack(rows, cols, values) {
     return { kind: "array", rows, cols, values };
 }
@@ -628,9 +607,6 @@ function aggregateRangeSubset(functionArg, subset, context, totalSet) {
     const result = builtin(...subset);
     return isArrayValue(result) ? scalarFromEvaluationResult(result) : result;
 }
-function isTrimRangeEmptyCell(value) {
-    return value.tag === ValueTag.Empty;
-}
 function applyLambda(lambdaValue, args, context) {
     if (lambdaValue.kind !== "lambda") {
         return stackScalar(lambdaValue.kind === "scalar" && lambdaValue.value.tag === ValueTag.Error
@@ -649,652 +625,62 @@ function applyLambda(lambdaValue, args, context) {
 }
 function evaluateSpecialCall(callee, rawArgs, context, argRefs = []) {
     switch (callee) {
-        case "ROW": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const row = referenceRowNumber(argRefs[0], context);
-            return stackScalar(row === undefined ? error(ErrorCode.Value) : numberValue(row));
-        }
-        case "COLUMN": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const column = referenceColumnNumber(argRefs[0], context);
-            return stackScalar(column === undefined ? error(ErrorCode.Value) : numberValue(column));
-        }
-        case "ISOMITTED": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            return stackScalar({ tag: ValueTag.Boolean, value: rawArgs[0]?.kind === "omitted" });
-        }
-        case "FORMULATEXT": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const address = referenceTopLeftAddress(argRefs[0]);
-            const sheetName = referenceSheetName(argRefs[0], context);
-            if (!address || !sheetName) {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            const formula = context.resolveFormula?.(sheetName, address);
-            return stackScalar(formula
-                ? stringValue(formula.startsWith("=") ? formula : `=${formula}`)
-                : error(ErrorCode.NA));
-        }
-        case "FORMULA": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const address = referenceTopLeftAddress(argRefs[0]);
-            const sheetName = referenceSheetName(argRefs[0], context);
-            if (!address || !sheetName) {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            const formula = context.resolveFormula?.(sheetName, address);
-            return stackScalar(formula
-                ? stringValue(formula.startsWith("=") ? formula : `=${formula}`)
-                : error(ErrorCode.NA));
-        }
-        case "PHONETIC": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const target = rawArgs[0];
-            if (target.kind === "scalar") {
-                return stackScalar(stringValue(toStringValue(target.value)));
-            }
-            if (target.kind === "range") {
-                return stackScalar(stringValue(toStringValue(target.values[0] ?? emptyValue())));
-            }
-            return stackScalar(error(ErrorCode.Value));
-        }
-        case "GETPIVOTDATA": {
-            if (rawArgs.length < 2 || (rawArgs.length - 2) % 2 !== 0) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const dataFieldValue = isSingleCellValue(rawArgs[0]);
-            const address = referenceTopLeftAddress(argRefs[1]);
-            const sheetName = referenceSheetName(argRefs[1], context);
-            if (!dataFieldValue) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            if (!address || !sheetName) {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            const filters = [];
-            for (let index = 2; index < rawArgs.length; index += 2) {
-                const fieldValue = isSingleCellValue(rawArgs[index]);
-                const itemValue = isSingleCellValue(rawArgs[index + 1]);
-                if (!fieldValue || !itemValue) {
-                    return stackScalar(error(ErrorCode.Value));
-                }
-                filters.push({ field: toStringValue(fieldValue), item: itemValue });
-            }
-            return stackScalar(context.resolvePivotData?.({
-                dataField: toStringValue(dataFieldValue),
-                sheetName,
-                address,
-                filters,
-            }) ?? error(ErrorCode.Ref));
-        }
-        case "GROUPBY": {
-            if (rawArgs.length < 3 || rawArgs.length > 8) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const rowFields = matrixFromStackValue(rawArgs[0]);
-            const values = matrixFromStackValue(rawArgs[1]);
-            if (!rowFields || !values) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const sortOrder = vectorIntegerArgument(rawArgs[5]) ??
-                (rawArgs[5] ? [scalarIntegerArgument(rawArgs[5]) ?? Number.NaN] : undefined);
-            const fieldHeadersMode = scalarIntegerArgument(rawArgs[3]);
-            const totalDepth = scalarIntegerArgument(rawArgs[4]);
-            const filterArray = rawArgs[6] ? matrixFromStackValue(rawArgs[6]) : undefined;
-            const fieldRelationship = scalarIntegerArgument(rawArgs[7]);
-            const groupByOptions = {
-                aggregate: (subset, totalSet) => aggregateRangeSubset(rawArgs[2], subset, context, totalSet),
-                ...(fieldHeadersMode !== undefined ? { fieldHeadersMode } : {}),
-                ...(totalDepth !== undefined ? { totalDepth } : {}),
-                ...(sortOrder?.every(Number.isFinite) ? { sortOrder } : {}),
-                ...(filterArray !== undefined ? { filterArray } : {}),
-                ...(fieldRelationship !== undefined ? { fieldRelationship } : {}),
-            };
-            const result = evaluateGroupBy(rowFields, values, groupByOptions);
-            return isArrayValue(result) ? result : stackScalar(result);
-        }
-        case "PIVOTBY": {
-            if (rawArgs.length < 4 || rawArgs.length > 11) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const rowFields = matrixFromStackValue(rawArgs[0]);
-            const colFields = matrixFromStackValue(rawArgs[1]);
-            const values = matrixFromStackValue(rawArgs[2]);
-            if (!rowFields || !colFields || !values) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const rowSortOrder = vectorIntegerArgument(rawArgs[6]) ??
-                (rawArgs[6] ? [scalarIntegerArgument(rawArgs[6]) ?? Number.NaN] : undefined);
-            const colSortOrder = vectorIntegerArgument(rawArgs[8]) ??
-                (rawArgs[8] ? [scalarIntegerArgument(rawArgs[8]) ?? Number.NaN] : undefined);
-            const fieldHeadersMode = scalarIntegerArgument(rawArgs[4]);
-            const rowTotalDepth = scalarIntegerArgument(rawArgs[5]);
-            const colTotalDepth = scalarIntegerArgument(rawArgs[7]);
-            const filterArray = rawArgs[9] ? matrixFromStackValue(rawArgs[9]) : undefined;
-            const relativeTo = scalarIntegerArgument(rawArgs[10]);
-            const pivotByOptions = {
-                aggregate: (subset, totalSet) => aggregateRangeSubset(rawArgs[3], subset, context, totalSet),
-                ...(fieldHeadersMode !== undefined ? { fieldHeadersMode } : {}),
-                ...(rowTotalDepth !== undefined ? { rowTotalDepth } : {}),
-                ...(rowSortOrder?.every(Number.isFinite) ? { rowSortOrder } : {}),
-                ...(colTotalDepth !== undefined ? { colTotalDepth } : {}),
-                ...(colSortOrder?.every(Number.isFinite) ? { colSortOrder } : {}),
-                ...(filterArray !== undefined ? { filterArray } : {}),
-                ...(relativeTo !== undefined ? { relativeTo } : {}),
-            };
-            const result = evaluatePivotBy(rowFields, colFields, values, pivotByOptions);
-            return isArrayValue(result) ? result : stackScalar(result);
-        }
-        case "MULTIPLE.OPERATIONS": {
-            if (rawArgs.length !== 3 && rawArgs.length !== 5) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const formulaAddress = referenceTopLeftAddress(argRefs[0]);
-            const formulaSheetName = referenceSheetName(argRefs[0], context);
-            const rowCellAddress = referenceTopLeftAddress(argRefs[1]);
-            const rowCellSheetName = referenceSheetName(argRefs[1], context);
-            const rowReplacementAddress = referenceTopLeftAddress(argRefs[2]);
-            const rowReplacementSheetName = referenceSheetName(argRefs[2], context);
-            if (!formulaAddress ||
-                !formulaSheetName ||
-                !rowCellAddress ||
-                !rowCellSheetName ||
-                !rowReplacementAddress ||
-                !rowReplacementSheetName) {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            const columnCellAddress = rawArgs.length === 5 ? referenceTopLeftAddress(argRefs[3]) : undefined;
-            const columnCellSheetName = rawArgs.length === 5 ? referenceSheetName(argRefs[3], context) : undefined;
-            const columnReplacementAddress = rawArgs.length === 5 ? referenceTopLeftAddress(argRefs[4]) : undefined;
-            const columnReplacementSheetName = rawArgs.length === 5 ? referenceSheetName(argRefs[4], context) : undefined;
-            if (rawArgs.length === 5 &&
-                (!columnCellAddress ||
-                    !columnCellSheetName ||
-                    !columnReplacementAddress ||
-                    !columnReplacementSheetName)) {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            const request = {
-                formulaSheetName,
-                formulaAddress,
-                rowCellSheetName,
-                rowCellAddress,
-                rowReplacementSheetName,
-                rowReplacementAddress,
-                ...(columnCellSheetName ? { columnCellSheetName } : {}),
-                ...(columnCellAddress ? { columnCellAddress } : {}),
-                ...(columnReplacementSheetName ? { columnReplacementSheetName } : {}),
-                ...(columnReplacementAddress ? { columnReplacementAddress } : {}),
-            };
-            return stackScalar(context.resolveMultipleOperations?.(request) ?? error(ErrorCode.Ref));
-        }
-        case "CHOOSE": {
-            if (rawArgs.length < 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const indexValue = isSingleCellValue(rawArgs[0]);
-            const choice = indexValue ? toNumber(indexValue) : undefined;
-            if (choice === undefined || !Number.isFinite(choice)) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const truncated = Math.trunc(choice);
-            if (truncated < 1 || truncated >= rawArgs.length) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            return cloneStackValue(rawArgs[truncated]);
-        }
-        case "SHEET": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            if (rawArgs.length === 0) {
-                const index = sheetIndexByName(context.sheetName, context);
-                return stackScalar(index === undefined ? error(ErrorCode.NA) : numberValue(index));
-            }
-            if (argRefs[0]) {
-                const index = sheetIndexByName(referenceSheetName(argRefs[0], context) ?? context.sheetName, context);
-                return stackScalar(index === undefined ? error(ErrorCode.NA) : numberValue(index));
-            }
-            const scalar = isSingleCellValue(rawArgs[0]);
-            if (scalar?.tag !== ValueTag.String) {
-                return stackScalar(error(ErrorCode.NA));
-            }
-            const index = sheetIndexByName(scalar.value, context);
-            return stackScalar(index === undefined ? error(ErrorCode.NA) : numberValue(index));
-        }
-        case "SHEETS": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            if (rawArgs.length === 0) {
-                return stackScalar(numberValue(sheetNames(context).length));
-            }
-            if (argRefs[0]) {
-                return stackScalar(numberValue(1));
-            }
-            const scalar = isSingleCellValue(rawArgs[0]);
-            if (scalar?.tag !== ValueTag.String) {
-                return stackScalar(error(ErrorCode.NA));
-            }
-            return stackScalar(sheetIndexByName(scalar.value, context) === undefined
-                ? error(ErrorCode.NA)
-                : numberValue(1));
-        }
-        case "CELL": {
-            if (rawArgs.length < 1 || rawArgs.length > 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const infoType = isSingleCellValue(rawArgs[0]);
-            if (infoType?.tag !== ValueTag.String) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const ref = rawArgs.length === 2 ? argRefs[1] : currentCellReference(context);
-            if (!ref) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const normalizedInfoType = infoType.value.trim().toLowerCase();
-            switch (normalizedInfoType) {
-                case "address": {
-                    const address = absoluteAddress(ref, context);
-                    return stackScalar(address ? stringValue(address) : error(ErrorCode.Value));
-                }
-                case "row": {
-                    const row = referenceRowNumber(ref, context);
-                    return stackScalar(row === undefined ? error(ErrorCode.Value) : numberValue(row));
-                }
-                case "col": {
-                    const column = referenceColumnNumber(ref, context);
-                    return stackScalar(column === undefined ? error(ErrorCode.Value) : numberValue(column));
-                }
-                case "contents": {
-                    const address = referenceTopLeftAddress(ref);
-                    const sheetName = referenceSheetName(ref, context);
-                    if (!address || !sheetName) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    return stackScalar(context.resolveCell(sheetName, address));
-                }
-                case "type": {
-                    const address = referenceTopLeftAddress(ref);
-                    const sheetName = referenceSheetName(ref, context);
-                    if (!address || !sheetName) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    return stackScalar(stringValue(cellTypeCode(context.resolveCell(sheetName, address))));
-                }
-                case "filename":
-                    return stackScalar(stringValue(""));
-                default:
-                    return stackScalar(error(ErrorCode.Value));
-            }
-        }
-        case "INDIRECT": {
-            if (rawArgs.length < 1 || rawArgs.length > 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const refText = coerceScalarTextArgument(rawArgs[0]);
-            if (isCellValueError(refText)) {
-                return stackScalar(refText);
-            }
-            const a1Mode = coerceOptionalBooleanArgument(rawArgs[1], true);
-            if (isCellValueError(a1Mode)) {
-                return stackScalar(a1Mode);
-            }
-            if (!a1Mode) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const normalizedRefText = refText.trim();
-            if (normalizedRefText === "") {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            try {
-                const cell = parseCellAddress(normalizedRefText, context.sheetName);
-                return stackScalar(context.resolveCell(cell.sheetName ?? context.sheetName, cell.text));
-            }
-            catch {
-                // fall through to range/name resolution
-            }
-            try {
-                const range = parseRangeAddress(normalizedRefText, context.sheetName);
-                if (range.kind !== "cells") {
-                    return stackScalar(error(ErrorCode.Ref));
-                }
-                const targetSheetName = range.sheetName ?? context.sheetName;
-                const values = context.resolveRange(targetSheetName, range.start.text, range.end.text, "cells");
-                const rows = range.end.row - range.start.row + 1;
-                const cols = range.end.col - range.start.col + 1;
-                return {
-                    kind: "range",
-                    values,
-                    refKind: "cells",
-                    rows,
-                    cols,
-                };
-            }
-            catch {
-                // fall through to name resolution
-            }
-            const resolvedName = context.resolveName?.(normalizedRefText);
-            return stackScalar(resolvedName ?? error(ErrorCode.Ref));
-        }
-        case "EXPAND": {
-            if (rawArgs.length < 2 || rawArgs.length > 4) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const source = toRangeLike(rawArgs[0]);
-            const rows = coerceOptionalPositiveIntegerArgument(rawArgs[1], source.rows);
-            const cols = coerceOptionalPositiveIntegerArgument(rawArgs[2], source.cols);
-            if (isCellValueError(rows)) {
-                return stackScalar(rows);
-            }
-            if (isCellValueError(cols)) {
-                return stackScalar(cols);
-            }
-            const padArgument = rawArgs[3];
-            const padValue = padArgument === undefined
-                ? error(ErrorCode.NA)
-                : (() => {
-                    const scalar = isSingleCellValue(padArgument);
-                    return scalar ?? error(ErrorCode.Value);
-                })();
-            if (padValue.tag === ValueTag.Error && padArgument !== undefined) {
-                const scalar = isSingleCellValue(padArgument);
-                if (!scalar) {
-                    return stackScalar(error(ErrorCode.Value));
-                }
-            }
-            if (rows < source.rows || cols < source.cols) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const values = [];
-            for (let row = 0; row < rows; row += 1) {
-                for (let col = 0; col < cols; col += 1) {
-                    values.push(row < source.rows && col < source.cols ? getRangeCell(source, row, col) : padValue);
-                }
-            }
-            return makeArrayStack(rows, cols, values);
-        }
-        case "TEXTSPLIT": {
-            if (rawArgs.length < 2 || rawArgs.length > 6) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const text = coerceScalarTextArgument(rawArgs[0]);
-            const columnDelimiter = coerceScalarTextArgument(rawArgs[1]);
-            const rowDelimiter = rawArgs[2] === undefined ? undefined : coerceScalarTextArgument(rawArgs[2]);
-            const ignoreEmpty = coerceOptionalBooleanArgument(rawArgs[3], false);
-            const matchMode = coerceOptionalMatchModeArgument(rawArgs[4], 0);
-            if (isCellValueError(text)) {
-                return stackScalar(text);
-            }
-            if (isCellValueError(columnDelimiter)) {
-                return stackScalar(columnDelimiter);
-            }
-            if (rowDelimiter !== undefined && isCellValueError(rowDelimiter)) {
-                return stackScalar(rowDelimiter);
-            }
-            if (isCellValueError(ignoreEmpty)) {
-                return stackScalar(ignoreEmpty);
-            }
-            if (isCellValueError(matchMode)) {
-                return stackScalar(matchMode);
-            }
-            if (columnDelimiter === "" && rowDelimiter === undefined) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const padArgument = rawArgs[5];
-            const padValue = padArgument === undefined
-                ? error(ErrorCode.NA)
-                : (() => {
-                    const scalar = isSingleCellValue(padArgument);
-                    return scalar ?? error(ErrorCode.Value);
-                })();
-            if (padArgument !== undefined && !isSingleCellValue(padArgument)) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const rowSlices = rowDelimiter === undefined || rowDelimiter === ""
-                ? [text]
-                : splitTextByDelimiter(text, rowDelimiter, matchMode);
-            const matrix = rowSlices.map((rowSlice) => {
-                const parts = columnDelimiter === ""
-                    ? [rowSlice]
-                    : splitTextByDelimiter(rowSlice, columnDelimiter, matchMode);
-                const filtered = ignoreEmpty ? parts.filter((part) => part !== "") : parts;
-                return filtered.length === 0 ? [] : filtered;
-            });
-            const rows = Math.max(matrix.length, 1);
-            const cols = Math.max(1, ...matrix.map((row) => row.length));
-            const values = [];
-            for (let rowIndex = 0; rowIndex < rows; rowIndex += 1) {
-                const row = matrix[rowIndex] ?? [];
-                for (let colIndex = 0; colIndex < cols; colIndex += 1) {
-                    values.push(colIndex < row.length ? stringValue(row[colIndex]) : padValue);
-                }
-            }
-            return makeArrayStack(rows, cols, values);
-        }
-        case "TRIMRANGE": {
-            if (rawArgs.length < 1 || rawArgs.length > 3) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const source = toRangeLike(rawArgs[0]);
-            const trimRows = coerceOptionalTrimModeArgument(rawArgs[1], 3);
-            const trimCols = coerceOptionalTrimModeArgument(rawArgs[2], 3);
-            if (isCellValueError(trimRows)) {
-                return stackScalar(trimRows);
-            }
-            if (isCellValueError(trimCols)) {
-                return stackScalar(trimCols);
-            }
-            let startRow = 0;
-            let endRow = source.rows - 1;
-            let startCol = 0;
-            let endCol = source.cols - 1;
-            const trimLeadingRows = trimRows === 1 || trimRows === 3;
-            const trimTrailingRows = trimRows === 2 || trimRows === 3;
-            const trimLeadingCols = trimCols === 1 || trimCols === 3;
-            const trimTrailingCols = trimCols === 2 || trimCols === 3;
-            if (trimLeadingRows) {
-                while (startRow <= endRow) {
-                    let hasNonEmpty = false;
-                    for (let col = 0; col < source.cols; col += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, startRow, col))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    startRow += 1;
-                }
-            }
-            if (trimTrailingRows) {
-                while (endRow >= startRow) {
-                    let hasNonEmpty = false;
-                    for (let col = 0; col < source.cols; col += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, endRow, col))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    endRow -= 1;
-                }
-            }
-            if (startRow > endRow) {
-                return makeArrayStack(1, 1, [emptyValue()]);
-            }
-            if (trimLeadingCols) {
-                while (startCol <= endCol) {
-                    let hasNonEmpty = false;
-                    for (let row = startRow; row <= endRow; row += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, row, startCol))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    startCol += 1;
-                }
-            }
-            if (trimTrailingCols) {
-                while (endCol >= startCol) {
-                    let hasNonEmpty = false;
-                    for (let row = startRow; row <= endRow; row += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, row, endCol))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    endCol -= 1;
-                }
-            }
-            if (startCol > endCol) {
-                return makeArrayStack(1, 1, [emptyValue()]);
-            }
-            const rows = endRow - startRow + 1;
-            const cols = endCol - startCol + 1;
-            const values = [];
-            for (let row = startRow; row <= endRow; row += 1) {
-                for (let col = startCol; col <= endCol; col += 1) {
-                    values.push(getRangeCell(source, row, col));
-                }
-            }
-            return makeArrayStack(rows, cols, values);
-        }
-        case "MAKEARRAY": {
-            if (rawArgs.length !== 3) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const rows = toPositiveInteger(rawArgs[0]);
-            const cols = toPositiveInteger(rawArgs[1]);
-            if (rows === undefined || cols === undefined) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const lambda = rawArgs[2];
-            const values = [];
-            for (let row = 1; row <= rows; row += 1) {
-                for (let col = 1; col <= cols; col += 1) {
-                    const result = applyLambda(lambda, [
-                        stackScalar({ tag: ValueTag.Number, value: row }),
-                        stackScalar({ tag: ValueTag.Number, value: col }),
-                    ], context);
-                    const scalar = isSingleCellValue(result);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    values.push(scalar);
-                }
-            }
-            return { kind: "array", rows, cols, values };
-        }
-        case "MAP": {
-            if (rawArgs.length < 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const lambda = rawArgs[rawArgs.length - 1];
-            const inputs = rawArgs.slice(0, -1);
-            const shape = getBroadcastShape(inputs);
-            if (!shape) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const ranges = inputs.map(toRangeLike);
-            const values = [];
-            for (let row = 0; row < shape.rows; row += 1) {
-                for (let col = 0; col < shape.cols; col += 1) {
-                    const lambdaArgs = ranges.map((range) => stackScalar(getRangeCell(range, Math.min(row, range.rows - 1), Math.min(col, range.cols - 1))));
-                    const result = applyLambda(lambda, lambdaArgs, context);
-                    const scalar = isSingleCellValue(result);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    values.push(scalar);
-                }
-            }
-            return { kind: "array", rows: shape.rows, cols: shape.cols, values };
-        }
-        case "BYROW":
-        case "BYCOL": {
-            if (rawArgs.length !== 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const source = toRangeLike(rawArgs[0]);
-            const lambda = rawArgs[1];
-            const values = [];
-            if (callee === "BYROW") {
-                for (let row = 0; row < source.rows; row += 1) {
-                    const rowValues = [];
-                    for (let col = 0; col < source.cols; col += 1) {
-                        rowValues.push(getRangeCell(source, row, col));
-                    }
-                    const result = applyLambda(lambda, [{ kind: "range", values: rowValues, rows: 1, cols: source.cols, refKind: "cells" }], context);
-                    const scalar = isSingleCellValue(result);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    values.push(scalar);
-                }
-                return { kind: "array", rows: source.rows, cols: 1, values };
-            }
-            for (let col = 0; col < source.cols; col += 1) {
-                const colValues = [];
-                for (let row = 0; row < source.rows; row += 1) {
-                    colValues.push(getRangeCell(source, row, col));
-                }
-                const result = applyLambda(lambda, [{ kind: "range", values: colValues, rows: source.rows, cols: 1, refKind: "cells" }], context);
-                const scalar = isSingleCellValue(result);
-                if (!scalar) {
-                    return stackScalar(error(ErrorCode.Value));
-                }
-                values.push(scalar);
-            }
-            return { kind: "array", rows: 1, cols: source.cols, values };
-        }
-        case "REDUCE":
-        case "SCAN": {
-            if (rawArgs.length !== 2 && rawArgs.length !== 3) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const hasInitial = rawArgs.length === 3;
-            let accumulator = hasInitial ? cloneStackValue(rawArgs[0]) : stackScalar(emptyValue());
-            const source = toRangeLike(rawArgs[hasInitial ? 1 : 0]);
-            const lambda = rawArgs[hasInitial ? 2 : 1];
-            const scanValues = [];
-            for (const cell of source.values) {
-                accumulator = applyLambda(lambda, [accumulator, stackScalar(cell)], context);
-                if (callee === "SCAN") {
-                    const scalar = isSingleCellValue(accumulator);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    scanValues.push(scalar);
-                }
-            }
-            return callee === "SCAN"
-                ? { kind: "array", rows: source.rows, cols: source.cols, values: scanValues }
-                : accumulator;
-        }
         default:
-            return undefined;
+            return (evaluateWorkbookSpecialCall(callee, rawArgs, context, argRefs, {
+                error,
+                stackScalar,
+                toStringValue,
+                isSingleCellValue,
+                matrixFromStackValue,
+                scalarIntegerArgument,
+                vectorIntegerArgument,
+                aggregateRangeSubset,
+                referenceTopLeftAddress,
+                referenceSheetName,
+                coerceScalarTextArgument,
+                coerceOptionalBooleanArgument,
+                isCellValueError,
+            }) ??
+                evaluateContextSpecialCall(callee, rawArgs, context, argRefs, {
+                    error,
+                    emptyValue,
+                    numberValue,
+                    stringValue,
+                    stackScalar,
+                    cloneStackValue,
+                    toNumber,
+                    toStringValue,
+                    isSingleCellValue,
+                    currentCellReference,
+                    referenceSheetName,
+                    referenceTopLeftAddress,
+                    referenceRowNumber,
+                    referenceColumnNumber,
+                    absoluteAddress,
+                    cellTypeCode,
+                    sheetNames,
+                    sheetIndexByName,
+                }) ??
+                evaluateArraySpecialCall(callee, rawArgs, context, {
+                    error,
+                    emptyValue,
+                    numberValue,
+                    stringValue,
+                    stackScalar,
+                    toRangeLike,
+                    getRangeCell,
+                    getBroadcastShape,
+                    makeArrayStack,
+                    applyLambda,
+                    toPositiveInteger,
+                    coerceScalarTextArgument,
+                    coerceOptionalBooleanArgument,
+                    coerceOptionalMatchModeArgument,
+                    coerceOptionalPositiveIntegerArgument,
+                    coerceOptionalTrimModeArgument,
+                    isCellValueError,
+                    isSingleCellValue,
+                }));
     }
 }
 function lowerNode(node, plan) {