@syncfusion/ej2-calculate 35.1.37

package/src/formulas/lookup-ref-extra.js

@@ -0,0 +1,180 @@
+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 } from '../common/index';
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Supplementary reference helpers for row/column indexing and dynamic range resolution.
+ *
+ * Registered functions: INDIRECT, AREAS, FORMULATEXT, ISREF.
+ *
+ * @hidden
+ */
+var LookupRefExtraFormulas = /** @class */ (function (_super) {
+    __extends(LookupRefExtraFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function LookupRefExtraFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'INDIRECT', category: 'Lookup & Reference', description: 'Returns a reference indicated by a text value.' },
+            { formulaName: 'AREAS', category: 'Lookup & Reference', description: 'Returns the number of areas in a reference.' },
+            { formulaName: 'FORMULATEXT', category: 'Lookup & Reference', description: 'Returns the formula in a cell as text.' },
+            { formulaName: 'ISREF', category: 'Information', description: 'Returns TRUE if the value is a reference.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns a reference indicated by a text value.
+     *
+     * Excel: `INDIRECT(...)`.
+     *
+     * @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('=INDIRECT(1)');
+     * ```
+     */
+    LookupRefExtraFormulas.prototype.ComputeINDIRECT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var refText = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(refText) > -1) {
+            return refText;
+        }
+        refText = refText.split('$').join('');
+        var a1Style = true;
+        if (args.length === 2) {
+            var style = this.resolveNumberArg(args[1]);
+            if (typeof style === 'string') {
+                return style;
+            }
+            a1Style = style !== 0;
+        }
+        if (!a1Style) {
+            return errCollection[CommonErrors.Value];
+        }
+        if (!this.parent.isCellReference(refText.split(':')[0])) {
+            return errCollection[CommonErrors.Ref];
+        }
+        if (refText.indexOf(':') > -1) {
+            var cells = this.parent.getCellCollection(refText);
+            var list = Array.isArray(cells) ? cells : [cells];
+            var values = [];
+            for (var i = 0; i < list.length; i++) {
+                var val = this.parent.getValueFromArg(list[i]);
+                if (errCollection.indexOf(val) > -1) {
+                    return val;
+                }
+                values.push(val);
+            }
+            return values.join(this.parent.getParseArgumentSeparator());
+        }
+        return this.parent.getValueFromArg(refText);
+    };
+    /**
+     * Returns the number of areas in a reference.
+     *
+     * Excel: `AREAS(...)`.
+     *
+     * @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`.
+     */
+    LookupRefExtraFormulas.prototype.ComputeAREAS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        if (!this.parent.isCellReference(ref.split(':')[0]) && ref.indexOf('(') === -1) {
+            return errCollection[CommonErrors.Value];
+        }
+        if (ref.indexOf(',') > -1) {
+            return ref.split(',').length.toString();
+        }
+        return '1';
+    };
+    /**
+     * Returns the formula in a cell as text.
+     *
+     * Excel: `FORMULATEXT(...)`.
+     *
+     * @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`.
+     */
+    LookupRefExtraFormulas.prototype.ComputeFORMULATEXT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        if (!this.parent.isCellReference(ref)) {
+            return errCollection[CommonErrors.Value];
+        }
+        var sheetPrefix = ref.indexOf('!') > -1 ? ref.substring(0, ref.lastIndexOf('!') + 1) : '';
+        var cell = ref.indexOf('!') > -1 ? ref.substring(ref.lastIndexOf('!') + 1) : ref;
+        var key = '!' + this.parent.getSheetID(this.parent.grid) + '!' + cell;
+        var fullKey = sheetPrefix ? ref : key;
+        var infoTable = this.parent.getFormulaInfoTable();
+        var lookupKey = sheetPrefix ? fullKey : key;
+        if (infoTable.has(lookupKey)) {
+            return infoTable.get(lookupKey).getFormulaText();
+        }
+        return errCollection[CommonErrors.NA];
+    };
+    /**
+     * Returns TRUE if the value is a reference.
+     *
+     * Excel: `ISREF(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {boolean} - Boolean result, nested-formula numeric string (`"0"`/`"1"`), or an Excel error token.
+     */
+    LookupRefExtraFormulas.prototype.ComputeISREF = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        return this.parent.isCellReference(ref.split(':')[0]);
+    };
+    return LookupRefExtraFormulas;
+}(FormulaModuleBase));
+export { LookupRefExtraFormulas };

package/src/formulas/lookup-ref.d.ts

@@ -0,0 +1,84 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Cell and range reference utilities: ADDRESS, INDIRECT, OFFSET, and sheet-aware lookups.
+ *
+ * Registered functions: ROW, ROWS, COLUMN, COLUMNS, HYPERLINK, OFFSET.
+ *
+ * @hidden
+ */
+export declare class LookupRefFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns the row number of a reference.
+     *
+     * Excel: `ROW(...)`.
+     *
+     * @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('=ROW(1)');
+     * ```
+     */
+    ComputeROW(...args: string[]): string | number;
+    /**
+     * Returns the column number of a reference.
+     *
+     * Excel: `COLUMN(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOLUMN(...args: string[]): string | number;
+    /**
+     * Returns the number of rows in a reference.
+     *
+     * Excel: `ROWS(...)`.
+     *
+     * @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`.
+     */
+    ComputeROWS(...args: string[]): string | number;
+    /**
+     * Returns the number of columns in a reference.
+     *
+     * Excel: `COLUMNS(...)`.
+     *
+     * @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`.
+     */
+    ComputeCOLUMNS(...args: string[]): string | number;
+    /**
+     * Creates a shortcut that opens a document on a network server, intranet, or Internet.
+     *
+     * Excel: `HYPERLINK(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    ComputeHYPERLINK(...args: string[]): string;
+    /**
+     * Returns a reference offset from a given reference.
+     *
+     * Excel: `OFFSET(...)`.
+     *
+     * @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`.
+     */
+    ComputeOFFSET(...args: string[]): string | number;
+}

package/src/formulas/lookup-ref.js

@@ -0,0 +1,263 @@
+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 } from '../common/index';
+import { isNullOrUndefined } from '@syncfusion/ej2-base';
+import { getAlphalabel } from '../base/index';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Cell and range reference utilities: ADDRESS, INDIRECT, OFFSET, and sheet-aware lookups.
+ *
+ * Registered functions: ROW, ROWS, COLUMN, COLUMNS, HYPERLINK, OFFSET.
+ *
+ * @hidden
+ */
+var LookupRefFormulas = /** @class */ (function (_super) {
+    __extends(LookupRefFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function LookupRefFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'ROW', category: 'Lookup & Reference', description: 'Returns the row number of a reference.' },
+            { formulaName: 'ROWS', category: 'Lookup & Reference', description: 'Returns the number of rows in a reference.' },
+            { formulaName: 'COLUMN', category: 'Lookup & Reference', description: 'Returns the column number of a reference.' },
+            { formulaName: 'COLUMNS', category: 'Lookup & Reference', description: 'Returns the number of columns in a reference.' },
+            { formulaName: 'HYPERLINK', category: 'Lookup & Reference', description: 'Creates a shortcut that opens a document on a network server, intranet, or Internet.' },
+            { formulaName: 'OFFSET', category: 'Lookup & Reference', description: 'Returns a reference offset from a given reference.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the row number of a reference.
+     *
+     * Excel: `ROW(...)`.
+     *
+     * @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('=ROW(1)');
+     * ```
+     */
+    LookupRefFormulas.prototype.ComputeROW = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            var act = this.parent.actCell || this.parent.cell || 'A1';
+            var cell = act.indexOf('!') > -1 ? act.substring(act.lastIndexOf('!') + 1) : act;
+            return this.parent.rowIndex(cell).toString();
+        }
+        if (args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        if (!this.parent.isCellReference(ref.split(':')[0])) {
+            return this.parent.getErrorStrings()[CommonErrors.Value];
+        }
+        var first = ref.indexOf(':') > -1 ? ref.split(':')[0] : ref;
+        var stripped = first.indexOf('!') > -1 ? first.substring(first.lastIndexOf('!') + 1) : first;
+        return this.parent.rowIndex(stripped).toString();
+    };
+    /**
+     * Returns the column number of a reference.
+     *
+     * Excel: `COLUMN(...)`.
+     *
+     * @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`.
+     */
+    LookupRefFormulas.prototype.ComputeCOLUMN = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            var act = this.parent.actCell || this.parent.cell || 'A1';
+            var cell = act.indexOf('!') > -1 ? act.substring(act.lastIndexOf('!') + 1) : act;
+            return this.parent.colIndex(cell).toString();
+        }
+        if (args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        if (!this.parent.isCellReference(ref.split(':')[0])) {
+            return this.parent.getErrorStrings()[CommonErrors.Value];
+        }
+        var first = ref.indexOf(':') > -1 ? ref.split(':')[0] : ref;
+        var stripped = first.indexOf('!') > -1 ? first.substring(first.lastIndexOf('!') + 1) : first;
+        return this.parent.colIndex(stripped).toString();
+    };
+    /**
+     * Returns the number of rows in a reference.
+     *
+     * Excel: `ROWS(...)`.
+     *
+     * @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`.
+     */
+    LookupRefFormulas.prototype.ComputeROWS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1 || args[0] === '') {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        if (ref.indexOf(':') === -1) {
+            if (!this.parent.isCellReference(ref)) {
+                return this.parent.getErrorStrings()[CommonErrors.Value];
+            }
+            return '1';
+        }
+        var parts = ref.split(':');
+        var a = parts[0].indexOf('!') > -1 ? parts[0].substring(parts[0].lastIndexOf('!') + 1) : parts[0];
+        var b = parts[1].indexOf('!') > -1 ? parts[1].substring(parts[1].lastIndexOf('!') + 1) : parts[1];
+        return (Math.abs(this.parent.rowIndex(b) - this.parent.rowIndex(a)) + 1).toString();
+    };
+    /**
+     * Returns the number of columns in a reference.
+     *
+     * Excel: `COLUMNS(...)`.
+     *
+     * @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`.
+     */
+    LookupRefFormulas.prototype.ComputeCOLUMNS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 1 || args[0] === '') {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        if (ref.indexOf(':') === -1) {
+            if (!this.parent.isCellReference(ref)) {
+                return this.parent.getErrorStrings()[CommonErrors.Value];
+            }
+            return '1';
+        }
+        var parts = ref.split(':');
+        var a = parts[0].indexOf('!') > -1 ? parts[0].substring(parts[0].lastIndexOf('!') + 1) : parts[0];
+        var b = parts[1].indexOf('!') > -1 ? parts[1].substring(parts[1].lastIndexOf('!') + 1) : parts[1];
+        return (Math.abs(this.parent.colIndex(b) - this.parent.colIndex(a)) + 1).toString();
+    };
+    /**
+     * Creates a shortcut that opens a document on a network server, intranet, or Internet.
+     *
+     * Excel: `HYPERLINK(...)`.
+     *
+     * @hidden
+     * @param {string[]} args - Formula argument tokens from the Calculate engine.
+     * @returns {string | number} - Computed text result or an Excel error token such as `#VALUE!`.
+     */
+    LookupRefFormulas.prototype.ComputeHYPERLINK = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var link = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(link) > -1) {
+            return link;
+        }
+        if (args.length === 2) {
+            var friendly = this.resolveTextArg(args[1]);
+            if (errCollection.indexOf(friendly) > -1) {
+                return friendly;
+            }
+            return friendly;
+        }
+        return link;
+    };
+    /**
+     * Returns a reference offset from a given reference.
+     *
+     * Excel: `OFFSET(...)`.
+     *
+     * @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`.
+     */
+    LookupRefFormulas.prototype.ComputeOFFSET = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length < 3 || args.length > 5) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var ref = args[0].split('$').join('');
+        if (!this.parent.isCellReference(ref.split(':')[0])) {
+            return errCollection[CommonErrors.Value];
+        }
+        var rows = this.resolveNumberArg(args[1]);
+        var cols = this.resolveNumberArg(args[2]);
+        if (typeof rows === 'string') {
+            return rows;
+        }
+        if (typeof cols === 'string') {
+            return cols;
+        }
+        var height = 1;
+        var width = 1;
+        if (args.length >= 4 && args[3] !== '') {
+            var h = this.resolveNumberArg(args[3]);
+            if (typeof h === 'string') {
+                return h;
+            }
+            height = Math.floor(h);
+        }
+        if (args.length === 5 && args[4] !== '') {
+            var w = this.resolveNumberArg(args[4]);
+            if (typeof w === 'string') {
+                return w;
+            }
+            width = Math.floor(w);
+        }
+        if (height < 1 || width < 1) {
+            return errCollection[CommonErrors.Ref];
+        }
+        var first = ref.indexOf(':') > -1 ? ref.split(':')[0] : ref;
+        var sheet = first.indexOf('!') > -1 ? first.substring(0, first.lastIndexOf('!') + 1) : '';
+        var cell = first.indexOf('!') > -1 ? first.substring(first.lastIndexOf('!') + 1) : first;
+        var baseRow = this.parent.rowIndex(cell) + Math.floor(rows);
+        var baseCol = this.parent.colIndex(cell) + Math.floor(cols);
+        if (baseRow < 1 || baseCol < 1) {
+            return errCollection[CommonErrors.Ref];
+        }
+        var start = sheet + getAlphalabel(baseCol) + baseRow;
+        if (height === 1 && width === 1) {
+            return this.parent.getValueFromArg(start);
+        }
+        return this.parent.getValueFromArg(start) || start;
+    };
+    return LookupRefFormulas;
+}(FormulaModuleBase));
+export { LookupRefFormulas };

package/src/formulas/lookup.d.ts

@@ -0,0 +1,114 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+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
+ */
+export declare class LookupFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * 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)');
+     * ```
+     */
+    ComputeCHOOSE(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeINDEX(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeMATCH(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeLOOKUP(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeVLOOKUP(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeHLOOKUP(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeADDRESS(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeSUBTOTAL(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeTEXT(...args: string[]): string | number;
+}