@syncfusion/ej2-calculate 35.1.37

package/src/formulas/lookup.js

@@ -0,0 +1,881 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { FormulasErrorsStrings, CommonErrors, getSkeletonVal } from '../common/index';
+import { getAlphalabel } from '../base/index';
+import { isNullOrUndefined, Internationalization } from '@syncfusion/ej2-base';
+import { dateToInt, isNumber } from '../common/number-date';
+import { getCellAddress, getRangeIndexes } from '../common/address';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Vertical and horizontal table lookups (VLOOKUP, HLOOKUP) and reference indexing.
+ *
+ * Registers 9 functions including CHOOSE, INDEX, MATCH, LOOKUP, VLOOKUP, and others.
+ *
+ * @hidden
+ */
+var LookupFormulas = /** @class */ (function (_super) {
+    __extends(LookupFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function LookupFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'CHOOSE', category: 'Lookup & Reference', description: 'Returns a value from a list, given an index number.' },
+            { formulaName: 'INDEX', category: 'Lookup & Reference', description: 'Returns a value from a table, given a row and column number.' },
+            { formulaName: 'MATCH', category: 'Lookup & Reference', description: 'Returns the relative position of an checked item in range that matches a specified value in a specified order' },
+            { formulaName: 'LOOKUP', category: 'Lookup & Reference', description: 'Looks for a value in a one-row or one-column range, then returns a value from the same position in a second one-row or one-column range.' },
+            { formulaName: 'VLOOKUP', category: 'Lookup & Reference', description: 'Looks for a specific value in the first column of a lookup range and returns a corresponding value from a different column within the same row.' },
+            { formulaName: 'HLOOKUP', category: 'Lookup & Reference', description: 'Looks for a value in the top row of the array of values and then returns a value in the same column from a row in the array that you specify.' },
+            { formulaName: 'ADDRESS', category: 'Lookup & Reference', description: 'Returns a cell reference as text, given specified row and column numbers.' },
+            { formulaName: 'SUBTOTAL', category: 'Lookup & Reference', description: 'Returns a subtotal in a list or database.' },
+            { formulaName: 'TEXT', category: 'Lookup & Reference', description: 'Converts a value to text in specified number format.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns a value from a list, given an index number.
+     *
+     * Excel: `CHOOSE(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=CHOOSE(1)');
+     * ```
+     */
+    LookupFormulas.prototype.ComputeCHOOSE = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || (args[0] === '' && args.length === 1)) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length < 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var processArgs = function (actuaValue) {
+            actuaValue = _this.parent.getValueFromArg(actuaValue);
+            if (actuaValue.toUpperCase() === _this.parent.trueValue) {
+                actuaValue = '1';
+            }
+            else if (actuaValue.toUpperCase() === _this.parent.falseValue) {
+                actuaValue = '0';
+            }
+            return actuaValue;
+        };
+        var getIndexValue;
+        getIndexValue = processArgs(args[0]);
+        if (errCollection.indexOf(getIndexValue) > -1) {
+            return getIndexValue;
+        }
+        if (this.parent.isCellReference(args[0])) {
+            if (args[0].indexOf(':') > -1) {
+                return errCollection[CommonErrors.Value];
+            }
+        }
+        else {
+            getIndexValue = this.parent.removeTics(getIndexValue);
+            if (getIndexValue.split('%').length === 2 && this.parent.isNumber(getIndexValue.split('%')[0])) {
+                getIndexValue = (Number(getIndexValue.split('%')[0]) * 0.01).toString();
+            }
+        }
+        getIndexValue = Math.floor(this.parent.parseFloat(getIndexValue));
+        if (getIndexValue < 1 || isNaN(getIndexValue) || isNullOrUndefined(args[getIndexValue])) {
+            return errCollection[CommonErrors.Value];
+        }
+        getIndexValue = args[getIndexValue];
+        if (getIndexValue === '') {
+            getIndexValue = '0';
+        }
+        if (this.parent.isCellReference(getIndexValue)) {
+            if (getIndexValue.indexOf(':') > -1) {
+                return errCollection[CommonErrors.Value];
+            }
+            return this.parent.getValueFromArg(getIndexValue);
+        }
+        else {
+            if (getIndexValue.indexOf(this.parent.tic) > -1 && (errCollection.indexOf(getIndexValue.split(this.parent.tic).join('')) > -1 ||
+                (this.parent.removeTics(getIndexValue).match(/^(\d*\.\d+|\d+)\s*[-*/]\s*(\d*\.\d+|\d+)$/)))) {
+                getIndexValue = this.parent.removeTics(getIndexValue);
+            }
+            getIndexValue = this.parent.removeTics(this.parent.getValueFromArg(getIndexValue));
+            if (getIndexValue.indexOf(this.parent.tic + this.parent.tic) > -1) {
+                return getIndexValue.replace(/""/g, this.parent.tic);
+            }
+            if (getIndexValue.split('%').length === 2 && this.parent.isNumber(getIndexValue.split('%')[0])) {
+                getIndexValue = (Number(getIndexValue.split('%')[0]) * 0.01).toString();
+            }
+            return getIndexValue;
+        }
+    };
+    /**
+     * Returns a value from a table, given a row and column number.
+     *
+     * Excel: `INDEX(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeINDEX = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var nestedFormula;
+        var value;
+        var errCollection = this.parent.getErrorStrings();
+        if (args.length && args[args.length - 1] === 'nestedFormulaTrue') {
+            nestedFormula = true;
+            args.pop();
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length < 2 || args.length > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        else if (args[0] === '' || args[3] === '' || (args[3] && (args[3] === '0' || args[3] === 'FALSE'))) {
+            return errCollection[CommonErrors.Value];
+        }
+        var row;
+        var col;
+        var area;
+        var processArgs = function (actualValue) {
+            if (isNullOrUndefined(actualValue) || actualValue === '') {
+                return 1;
+            }
+            var value = _this.parent.getValueFromArg(actualValue);
+            if (errCollection.indexOf(value) > -1) {
+                return value;
+            }
+            if (value.toUpperCase() === _this.parent.trueValue) {
+                value = '1';
+            }
+            else if (value.toUpperCase() === _this.parent.falseValue) {
+                value = '0';
+            }
+            if (value.indexOf(_this.parent.tic) > -1) {
+                value = _this.parent.removeTics(value);
+                if (actualValue.indexOf(_this.parent.tic) === -1 || value.trim() === '') {
+                    return errCollection[CommonErrors.Value];
+                }
+            }
+            if (value.split('%').length === 2 && _this.parent.isNumber(value.split('%')[0])) {
+                value = (Number(value.split('%')[0]) / 100).toString();
+            }
+            value = parseInt(Number(value).toString(), 10);
+            if (isNaN(value) || value < 0) {
+                return errCollection[CommonErrors.Value];
+            }
+            else if (value === 0) {
+                value = 1;
+            }
+            return value;
+        };
+        if (args[3]) {
+            area = processArgs(args[3]);
+            if (errCollection.indexOf(area.toString()) > -1) {
+                return area.toString();
+            }
+        }
+        if (args[0].startsWith(this.parent.tic) && args[0].endsWith(this.parent.tic)) {
+            args[0] = args[0].substring(1, args[0].length - 1);
+        }
+        var rangeArr = args[0].split(this.parent.getParseArgumentSeparator());
+        args[0] = rangeArr[area ? area - 1 : 0];
+        if (!args[0]) {
+            return errCollection[CommonErrors.Ref];
+        }
+        value = args[0];
+        row = processArgs(args[1]);
+        if (errCollection.indexOf(row.toString()) > -1) {
+            return row.toString();
+        }
+        col = processArgs(args[2]);
+        if (errCollection.indexOf(col.toString()) > -1) {
+            return col.toString();
+        }
+        var i = value.indexOf(':');
+        if (i === -1) {
+            if (row > 1 || col > 1) {
+                return errCollection[CommonErrors.Ref];
+            }
+            value = this.parent.isCellReference(value) ? this.parent.getValueFromArg(value) : value;
+        }
+        else {
+            var startRow = this.parent.rowIndex(value.substring(0, i));
+            var endRow = this.parent.rowIndex(value.substring(i + 1));
+            var startCol = this.parent.colIndex(value.substring(0, i));
+            var endCol = this.parent.colIndex(value.substring(i + 1));
+            if (row > endRow - startRow + 1 || col > endCol - startCol + 1) {
+                return errCollection[CommonErrors.Ref];
+            }
+            row = startRow + row - 1;
+            col = startCol + col - 1;
+            value = this.parent.getValueFromArg(this.getSheetReference(value) + this.parent.convertAlpha(col) + row);
+        }
+        if (value === '') {
+            return 0;
+        }
+        if (nestedFormula && errCollection.indexOf(value) === -1 &&
+            !this.parent.isNumber(value) && value !== this.parent.trueValue && value !== this.parent.falseValue) {
+            return this.parent.tic + value + this.parent.tic;
+        }
+        return value;
+    };
+    /**
+     * Returns the relative position of an checked item in range that matches a specified value in a specified order.
+     *
+     * Excel: `MATCH(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeMATCH = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args.slice();
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(argArr) || (argArr.length === 1 && argArr[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (argArr.length < 2 || argArr.length > 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        // args[0] codes
+        argArr[0] = this.parent.getValueFromArg(args[0]);
+        var isStringValue = argArr[0].indexOf(this.parent.tic) > -1;
+        argArr[0] = argArr[0].split(this.parent.tic).join('');
+        if (errCollection.indexOf(argArr[0]) > -1) {
+            return argArr[0];
+        }
+        if (argArr[0] === '') {
+            return errCollection[CommonErrors.NA];
+        }
+        if (isNaN(Number(argArr[0]))) {
+            isStringValue = true;
+        }
+        // args[2] codes
+        var matchType;
+        if (isNullOrUndefined(args[2])) {
+            argArr[2] = '1';
+        }
+        else {
+            argArr[2] = this.parent.getValueFromArg(argArr[2]);
+            if ((argArr[2].indexOf(this.parent.tic) > -1) && isNaN(Number(argArr[2].split(this.parent.tic).join('')))) {
+                return errCollection[CommonErrors.Value];
+            }
+            if (argArr[2].toUpperCase() === this.parent.trueValue) {
+                argArr[2] = '1';
+            }
+            else if (argArr[2].toUpperCase() === this.parent.falseValue) {
+                argArr[2] = '0';
+            }
+        }
+        matchType = parseFloat(argArr[2]);
+        if ([-1, 0, 1].indexOf(matchType) === -1) {
+            matchType = 0;
+        }
+        // args[1] codes
+        var valueCollection = [];
+        var isStringCollection = false;
+        var grid = this.parent.grid;
+        var curGrid = this.parent.grid;
+        var isWildCardVal;
+        if (argArr[1].indexOf(':') > -1 || this.parent.isCellReference(argArr[1])) {
+            var cellIdxs = getRangeIndexes(argArr[1]);
+            var startRow = cellIdxs[0];
+            var startCol = cellIdxs[1];
+            var endRow_1 = cellIdxs[2];
+            var endCol_1 = cellIdxs[3];
+            if (startRow >= 1048576 || endRow_1 >= 1048576 || startCol >= 16384 || endCol_1 >= 16384) {
+                return errCollection[CommonErrors.Name];
+            }
+            if (startRow !== endRow_1 && startCol !== endCol_1) {
+                return errCollection[CommonErrors.NA];
+            }
+            var sheetToken = '';
+            var family = this.parent.getSheetFamilyItem(grid);
+            if (argArr[1].startsWith('!')) {
+                sheetToken = argArr[1].substring(0, argArr[1].replace('!', '').indexOf('!') + 2);
+                if (family.tokenToParentObject !== null) {
+                    grid = family.tokenToParentObject.get(sheetToken);
+                }
+            }
+            else if (family.parentObjectToToken !== null) {
+                sheetToken = family.parentObjectToToken.get(grid);
+            }
+            var sheetId = this.parent.getSheetId(grid);
+            var getCellValue = this.parent.getCellValueFn(grid, this.parent.cell, sheetId, true);
+            var j_1 = 0;
+            var cellValue_1;
+            var performAction = void 0;
+            var result_1;
+            if (matchType === 0) {
+                isWildCardVal = argArr[0].indexOf('*') > -1 || argArr[0].indexOf('?') > -1;
+                performAction = function () {
+                    if (isWildCardVal) {
+                        cellValue_1 = _this.parent.findWildCardValue(argArr[0], cellValue_1);
+                    }
+                    if (argArr[0] === cellValue_1) {
+                        endCol_1 = -2;
+                        endRow_1 = -2;
+                        result_1 = j_1 + 1;
+                        return;
+                    }
+                    j_1++;
+                };
+            }
+            else {
+                performAction = function () {
+                    valueCollection[j_1] = cellValue_1;
+                    j_1++;
+                };
+            }
+            for (var r = startRow; r <= endRow_1; r++) {
+                for (var c = startCol; c <= endCol_1; c++) {
+                    cellValue_1 = getCellValue(r + 1, c + 1, getCellAddress(r, c));
+                    if (!isStringCollection && isNaN(Number(cellValue_1))) {
+                        isStringCollection = true;
+                    }
+                    performAction();
+                }
+            }
+            if (result_1) {
+                this.parent.grid = curGrid;
+                return result_1;
+            }
+            if (isStringValue !== isStringCollection) {
+                this.parent.grid = curGrid;
+                return errCollection[CommonErrors.NA];
+            }
+        }
+        else if (!isNullOrUndefined(argArr[1]) && argArr[1].includes(this.parent.tic + this.parent.tic)) {
+            var criterias = argArr[1].split(this.parent.tic + this.parent.tic);
+            criterias.forEach(function (criteria) {
+                criteria = criteria.trim().split(_this.parent.tic).join('');
+                if (criteria) {
+                    valueCollection.push(criteria);
+                }
+            });
+        }
+        var index = 0;
+        var indexVal = '';
+        var isIndexFound = false;
+        var matchValue = !isNaN(Number(argArr[0])) ? Number(argArr[0]) : argArr[0];
+        for (var i = 0; i < valueCollection.length; i++) {
+            if (valueCollection[i] === '') {
+                if (i === (valueCollection.length - 1)) {
+                    valueCollection.pop();
+                }
+                continue;
+            }
+            else if (matchType === -1 && (isStringValue || isStringCollection)) {
+                break;
+            }
+            var matchCollectionValue = !isNaN(Number(valueCollection[i])) ?
+                Number(valueCollection[i]) : valueCollection[i];
+            if (matchType === 1) {
+                if (matchValue === matchCollectionValue) {
+                    index = i + 1;
+                    isIndexFound = true;
+                    if (isNaN(Number(argArr[0]))) {
+                        isStringValue = false;
+                    }
+                }
+                else if ((matchValue > matchCollectionValue) && !isStringValue && !isIndexFound) {
+                    if (!indexVal || (matchCollectionValue > (!isNaN(Number(indexVal)) ? Number(indexVal) : indexVal))) {
+                        index = i + 1;
+                        indexVal = valueCollection[i];
+                    }
+                }
+            }
+            else if (matchType === 0) {
+                if (isWildCardVal) {
+                    valueCollection[i] = this.parent.findWildCardValue(argArr[0], valueCollection[i]);
+                }
+                if (argArr[0] === valueCollection[i]) {
+                    return i + 1;
+                }
+            }
+            else if (matchType === -1) {
+                if ((Number(valueCollection[i]) > Number(valueCollection[i + 1]))
+                    || i === valueCollection.length - 1) {
+                    if (matchValue === matchCollectionValue) {
+                        index = i + 1;
+                        matchValue = undefined;
+                    }
+                    else if (matchValue < matchCollectionValue) {
+                        if (!indexVal || (matchCollectionValue < (!isNaN(Number(indexVal)) ? Number(indexVal) : indexVal))) {
+                            index = i + 1;
+                            indexVal = valueCollection[i];
+                        }
+                    }
+                }
+                else {
+                    this.parent.grid = curGrid;
+                    return errCollection[CommonErrors.NA];
+                }
+            }
+        }
+        if (isStringValue && isStringCollection && matchType === 1) {
+            index = valueCollection.length;
+        }
+        this.parent.grid = curGrid;
+        return index ? index : errCollection[CommonErrors.NA];
+    };
+    /**
+     * Looks for a value in a one-row or one-column range, then returns a value from the same position in a second one-row or one-column range.
+     *
+     * Excel: `LOOKUP(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeLOOKUP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        if (isNullOrUndefined(argArr) || (argArr.length === 1 && argArr[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return this.parent.computeLookup(argArr);
+    };
+    /**
+     * Looks for a specific value in the first column of a lookup range and returns a corresponding value from a different column within the same row.
+     *
+     * Excel: `VLOOKUP(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeVLOOKUP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        return this.parent.computeVHLookup(argArr, true);
+    };
+    /**
+     * Looks for a value in the top row of the array of values and then returns a value in the same column from a row in the array that you specify.
+     *
+     * Excel: `HLOOKUP(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeHLOOKUP = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        return this.parent.computeVHLookup(argArr);
+    };
+    /**
+     * Returns a cell reference as text, given specified row and column numbers.
+     *
+     * Excel: `ADDRESS(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeADDRESS = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var value;
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0].trim() === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length < 2 || args.length > 5) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        else if (args[0].split(this.parent.tic).join('').trim() === '' || args[1].split(this.parent.tic).join('').trim() === '') {
+            return errCollection[CommonErrors.Value];
+        }
+        var processArgs = function (actualValue) {
+            var value = _this.parent.getValueFromArg(actualValue).trim();
+            if (errCollection.indexOf(value) > -1) {
+                return value;
+            }
+            if (value.toUpperCase() === _this.parent.trueValue) {
+                value = '1';
+            }
+            else if (value.toUpperCase() === _this.parent.falseValue) {
+                value = '0';
+            }
+            if (_this.parent.isCellReference(actualValue) && value.indexOf(_this.parent.tic) > -1) {
+                return errCollection[CommonErrors.Value];
+            }
+            value = _this.parent.removeTics(value);
+            if (value.split('%').length === 2 && _this.parent.isNumber(value.split('%')[0])) {
+                value = (Number(value.split('%')[0]) / 100).toString();
+            }
+            return value;
+        };
+        /* For argArr[0] */
+        var rowIndex = processArgs(args[0], 0);
+        if (errCollection.indexOf(rowIndex) > -1) {
+            return rowIndex;
+        }
+        rowIndex = Number(rowIndex);
+        if (isNaN(rowIndex) || rowIndex < 1) {
+            return errCollection[CommonErrors.Value];
+        }
+        else {
+            rowIndex = rowIndex.toString();
+        }
+        /* For argArr[1] */
+        var colIndex = processArgs(args[1], 1);
+        if (errCollection.indexOf(colIndex) > -1) {
+            return colIndex;
+        }
+        colIndex = Number(colIndex);
+        if (isNaN(colIndex) || colIndex < 1) {
+            return errCollection[CommonErrors.Value];
+        }
+        else {
+            colIndex = colIndex.toString();
+        }
+        /* For argArr[2] */
+        var absIndex;
+        var refStyle;
+        if (isNullOrUndefined(args[2]) || args[2].trim() === '') {
+            absIndex = '1';
+        }
+        else {
+            absIndex = processArgs(args[2], 2);
+            if (errCollection.indexOf(absIndex) > -1) {
+                return absIndex;
+            }
+            absIndex = Number(absIndex);
+            if (isNaN(absIndex) || absIndex < 1 || absIndex > 4) {
+                return errCollection[CommonErrors.Value];
+            }
+            else {
+                absIndex = absIndex.toString();
+            }
+        }
+        if (isNullOrUndefined(args[3]) || args[3].trim() === '') {
+            refStyle = '1';
+        }
+        else {
+            refStyle = processArgs(args[3], 3);
+            if (errCollection.indexOf(refStyle) > -1) {
+                return refStyle;
+            }
+            if (refStyle.toUpperCase() === this.parent.trueValue || Number(refStyle) > 1) {
+                refStyle = '1';
+            }
+            else if (refStyle === '' || refStyle.toUpperCase() === this.parent.falseValue) {
+                refStyle = '0';
+            }
+        }
+        if (refStyle === '1') {
+            if (absIndex === '1') {
+                value = '$' + getAlphalabel(parseInt(colIndex, 10)) + '$' + parseInt(rowIndex, 10);
+            }
+            else if (absIndex === '2') {
+                value = getAlphalabel(parseInt(colIndex, 10)) + '$' + parseInt(rowIndex, 10);
+            }
+            else if (absIndex === '3') {
+                value = '$' + getAlphalabel(parseInt(colIndex, 10)) + parseInt(rowIndex, 10);
+            }
+            else if (absIndex === '4') {
+                value = getAlphalabel(parseInt(colIndex, 10)) + parseInt(rowIndex, 10);
+            }
+        }
+        else if (refStyle === '0') {
+            if (absIndex === '1') {
+                value = 'R' + parseInt(rowIndex, 10) + 'C' + parseInt(colIndex, 10);
+            }
+            else if (absIndex === '2') {
+                value = 'R' + parseInt(rowIndex, 10) + 'C[' + parseInt(colIndex, 10) + ']';
+            }
+            else if (absIndex === '3') {
+                value = 'R[' + parseInt(rowIndex, 10) + ']C' + parseInt(colIndex, 10);
+            }
+            else if (absIndex === '4') {
+                value = 'R[' + parseInt(rowIndex, 10) + ']C[' + parseInt(colIndex, 10) + ']';
+            }
+        }
+        else {
+            return errCollection[CommonErrors.Name];
+        }
+        var val;
+        if (!isNullOrUndefined(args[4]) && args[4] !== '') {
+            val = this.parent.getValueFromArg(args[4]).split(this.parent.tic).join('');
+            if (errCollection.indexOf(val) > -1) {
+                return val;
+            }
+        }
+        if (!isNullOrUndefined(val)) {
+            value = val + '!' + value;
+        }
+        return value;
+    };
+    /**
+     * Returns a subtotal in a list or database.
+     *
+     * Excel: `SUBTOTAL(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeSUBTOTAL = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        var value;
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        else if (args.length < 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        value = this.parent.getValueFromArg(args[0]).trim();
+        if (errCollection.indexOf(value) > -1) {
+            return value;
+        }
+        if (value.split(this.parent.tic).join('').trim() === '') {
+            return errCollection[CommonErrors.Value];
+        }
+        if (!this.parent.isCellReference(args[0])) {
+            value = this.parent.removeTics(value);
+        }
+        if (value.toUpperCase() === this.parent.trueValue) {
+            value = '1';
+        }
+        else if (value.toUpperCase() === this.parent.falseValue) {
+            value = '0';
+        }
+        else if (value.split('%').length === 2 && this.parent.isNumber(value.split('%')[0])) {
+            value = (Number(value.split('%')[0]) / 100).toString();
+        }
+        value = this.parent.parseFloat(value);
+        if (isNaN(value) || ((1 > value || value > 11) && (101 > value || value > 111))) {
+            return errCollection[CommonErrors.Value];
+        }
+        var cellRef = args.slice(1, args.length);
+        switch (value) {
+            case 1:
+            case 101:
+                value = (_a = this.owner).ComputeAVERAGE.apply(_a, cellRef.concat(['isSubtotal']));
+                break;
+            case 2:
+            case 102:
+                value = (_b = this.owner).ComputeCOUNT.apply(_b, cellRef.concat(['isSubtotal']));
+                break;
+            case 3:
+            case 103:
+                value = (_c = this.owner).ComputeCOUNTA.apply(_c, cellRef.concat(['isSubtotal']));
+                break;
+            case 4:
+            case 104:
+                value = (_d = this.owner).ComputeMAX.apply(_d, cellRef.concat(['isSubtotal']));
+                break;
+            case 5:
+            case 105:
+                value = (_e = this.owner).ComputeMIN.apply(_e, cellRef.concat(['isSubtotal']));
+                break;
+            case 6:
+            case 106:
+                value = (_f = this.owner).ComputePRODUCT.apply(_f, cellRef.concat(['isSubtotal']));
+                break;
+            case 7:
+            case 107:
+                value = (_g = this.owner).ComputeDAY.apply(_g, cellRef);
+                break;
+            case 8:
+            case 108:
+                value = (_h = this.owner).ComputeCONCAT.apply(_h, cellRef);
+                break;
+            case 9:
+            case 109:
+                value = (_j = this.owner).ComputeSUM.apply(_j, cellRef.concat(['isSubtotal']));
+                break;
+            case 10:
+            case 110:
+                value = (_k = this.owner).ComputeAVERAGEA.apply(_k, cellRef);
+                break;
+            case 11:
+            case 111:
+                value = (_l = this.owner).ComputeABS.apply(_l, cellRef);
+                break;
+            default:
+                value = errCollection[CommonErrors.Value];
+                break;
+        }
+        return value;
+    };
+    /**
+     * Converts a value to text in specified number format.
+     *
+     * Excel: `TEXT(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed Excel-compatible numeric or text result, or an error token such as `#VALUE!`, `#NUM!`, `#N/A`.
+     */
+    LookupFormulas.prototype.ComputeTEXT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var nestedFormula;
+        if (args.length && args[args.length - 1] === 'nestedFormulaTrue') {
+            nestedFormula = true;
+            args.pop();
+        }
+        var argsLength = args.length;
+        var firstArg = args[0];
+        var secondArg = args[1];
+        if (argsLength !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var s1 = firstArg;
+        var s2 = secondArg;
+        if (secondArg === '') {
+            return this.parent.getValueFromArg(s1);
+        }
+        var dTime = new Date(1900, 0, 1, 0, 0, 0);
+        var checkString = s1 + ',' + s2;
+        var intl = new Internationalization();
+        if (this.parent.getErrorStrings().indexOf(checkString) > -1) {
+            return checkString;
+        }
+        s1 = this.parent.getValueFromArg(s1);
+        if (isNumber(s1.split(this.parent.tic).join(''))) {
+            s1 = s1.split(this.parent.tic).join('');
+        }
+        if (secondArg.startsWith('"') && secondArg.endsWith('"')) {
+            s2 = s2.split(this.parent.tic).join('');
+        }
+        else {
+            s2 = this.parent.getValueFromArg(s2);
+        }
+        if (s2 === '') {
+            return '';
+        }
+        if (s1 === '' && (s2.length > 0 && (s2.toUpperCase().indexOf('M') > -1 || s2.toUpperCase().indexOf('D') > -1
+            || s2.toUpperCase().indexOf('Y') > -1 || s2.toUpperCase().indexOf('S') > -1 || s2.toUpperCase().indexOf('T') > -1)
+            || s2.toUpperCase().indexOf('H') > -1)) {
+            s1 = dTime.toString();
+        }
+        var d = this.parseDouble(s1);
+        if (isNaN(d) && this.parent.isDate(new Date(s1)) !== null) {
+            d = this.parent.toOADate(new Date(s1));
+        }
+        dTime = Date.parse(s1.split(this.parent.tic).join(''));
+        if (!isNaN(d) || !isNaN(dTime)) {
+            if (s2.length > 0 && s2.indexOf('#') === -1 && (s2.toUpperCase().indexOf('M') > -1 || s2.toUpperCase().indexOf('D') > -1
+                || s2.toUpperCase().indexOf('Y') > -1 || s2.toUpperCase().indexOf('S') > -1 || s2.toUpperCase().indexOf('T') > -1)
+                || s2.toUpperCase().indexOf('H') > -1) {
+                s2 = s2.split('Y').join('y').split('D').join('d').split('H').join('h');
+                s2 = s2.split('S').join('s').split('m').join('M').split('AM/PM').join('tt');
+                var formatChar = s2.split('');
+                var isH = false;
+                var isMFound = false;
+                var i = 0;
+                // let mcount: number = 0;
+                var lastCharIndex = 0;
+                var totalCharforM = 0;
+                for (i = 0; i < formatChar.length;) {
+                    var c = formatChar[i];
+                    if (c === 's' && formatChar[lastCharIndex] === 'M') {
+                        formatChar[lastCharIndex] = 'm';
+                        if (formatChar[lastCharIndex - 1] === 'M') {
+                            formatChar[lastCharIndex - 1] = 'm';
+                        }
+                    }
+                    if (this.parent.isChar(c)) {
+                        lastCharIndex = i;
+                        if (c === 'M') {
+                            // mcount++;
+                            totalCharforM++;
+                        }
+                    }
+                    else if (totalCharforM > 1) {
+                        totalCharforM++;
+                    }
+                    if (c === 'M' && isH) {
+                        formatChar[i] = 'm';
+                        isMFound = true;
+                    }
+                    if (c === 'h') {
+                        isH = true;
+                    }
+                    else if (this.parent.isChar(c) && c !== 'M' && c !== 'h' && !isMFound) {
+                        isH = false;
+                        isMFound = false;
+                    }
+                    i++;
+                }
+                s2 = String(formatChar);
+                s2 = s2.split(',').join('').split('\n').join(' ');
+                var dt = this.parent.fromOADate(d);
+                if (d === 0) {
+                    dt = dTime;
+                }
+                var getSkeleton = getSkeletonVal(s2);
+                if (getSkeleton === '') {
+                    var date = dateToInt(dt);
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    var dateString = this.parent.parentObject.getDisplayText({ format: s2, value: date });
+                    return dateString;
+                }
+                var dFormatter = intl.getDateFormat({ skeleton: getSkeleton, type: 'date' });
+                var formattedString = dFormatter(dt);
+                s1 = formattedString;
+            }
+            else {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                s1 = this.parent.parentObject.getDisplayText({ format: s2, value: d });
+            }
+        }
+        return nestedFormula ? this.parent.tic + s1 + this.parent.tic : s1;
+    };
+    return LookupFormulas;
+}(FormulaModuleBase));
+export { LookupFormulas };