@syncfusion/ej2-calculate 35.1.37

package/src/formulas/logical-extra.js

@@ -0,0 +1,217 @@
+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';
+/**
+ * Extended logical helpers including IFS, SWITCH, XOR, and multi-condition boolean tests.
+ *
+ * Registered functions: TRUE, FALSE, XOR, IFNA, SWITCH.
+ *
+ * @hidden
+ */
+var LogicalExtraFormulas = /** @class */ (function (_super) {
+    __extends(LogicalExtraFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function LogicalExtraFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'TRUE', category: 'Logical', description: 'Returns the logical value TRUE.' },
+            { formulaName: 'FALSE', category: 'Logical', description: 'Returns the logical value FALSE.' },
+            { formulaName: 'XOR', category: 'Logical', description: 'Returns a logical exclusive OR of all arguments.' },
+            { formulaName: 'IFNA', category: 'Logical', description: 'Returns the value you specify if the expression resolves to #N/A; otherwise returns the result of the expression.' },
+            { formulaName: 'SWITCH', category: 'Logical', description: 'Evaluates an expression against a list of values and returns the result corresponding to the first matching value.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the logical value TRUE.
+     *
+     * Excel: `TRUE(...)`.
+     *
+     * @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!`.
+     *
+     * @example
+     * ```ts
+     * engine.computeFormula('=TRUE(1)');
+     * ```
+     */
+    LogicalExtraFormulas.prototype.ComputeTRUE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (args && args.length === 1 && args[0] === '') {
+            return this.parent.trueValue;
+        }
+        if (args && args.length > 0 && !(args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return this.parent.trueValue;
+    };
+    /**
+     * Returns the logical value FALSE.
+     *
+     * Excel: `FALSE(...)`.
+     *
+     * @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!`.
+     */
+    LogicalExtraFormulas.prototype.ComputeFALSE = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (args && args.length === 1 && args[0] === '') {
+            return this.parent.falseValue;
+        }
+        if (args && args.length > 0 && !(args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return this.parent.falseValue;
+    };
+    LogicalExtraFormulas.prototype.isTruthy = function (value) {
+        var upper = value.toUpperCase();
+        if (upper === this.parent.trueValue) {
+            return true;
+        }
+        if (upper === this.parent.falseValue || value === '') {
+            return false;
+        }
+        var num = this.parent.parseFloat(value);
+        return !isNaN(num) && num !== 0;
+    };
+    /**
+     * Returns a logical exclusive OR of all arguments.
+     *
+     * Excel: `XOR(...)`.
+     *
+     * @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!`.
+     */
+    LogicalExtraFormulas.prototype.ComputeXOR = 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[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        var trueCount = 0;
+        for (var i = 0; i < args.length; i++) {
+            var arg = args[i];
+            if (this.parent.isCellReference(arg) && arg.indexOf(':') > -1) {
+                var cells = this.parent.getCellCollection(arg);
+                var list = Array.isArray(cells) ? cells : [cells];
+                for (var c = 0; c < list.length; c++) {
+                    var val = this.parent.getValueFromArg(list[c]);
+                    if (errCollection.indexOf(val) > -1) {
+                        return val;
+                    }
+                    if (this.isTruthy(val)) {
+                        trueCount++;
+                    }
+                }
+            }
+            else {
+                var val = this.parent.getValueFromArg(arg);
+                if (errCollection.indexOf(val) > -1) {
+                    return val;
+                }
+                if (this.isTruthy(val)) {
+                    trueCount++;
+                }
+            }
+        }
+        return (trueCount % 2 === 1) ? this.parent.trueValue : this.parent.falseValue;
+    };
+    /**
+     * Returns the value you specify if the expression resolves to #N/A; otherwise returns the result of the expression.
+     *
+     * Excel: `IFNA(...)`.
+     *
+     * @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`.
+     */
+    LogicalExtraFormulas.prototype.ComputeIFNA = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var value = this.parent.getValueFromArg(args[0]);
+        if (value === this.parent.getErrorStrings()[CommonErrors.NA] || value === '#N/A') {
+            return this.parent.getValueFromArg(args[1]);
+        }
+        return value === '' ? '0' : value;
+    };
+    /**
+     * Evaluates an expression against a list of values and returns the result corresponding to the first matching value.
+     *
+     * Excel: `SWITCH(...)`.
+     *
+     * @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`.
+     */
+    LogicalExtraFormulas.prototype.ComputeSWITCH = 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) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var expression = this.parent.getValueFromArg(args[0]);
+        if (errCollection.indexOf(expression) > -1) {
+            return expression;
+        }
+        var pairs = Math.floor((args.length - 1) / 2);
+        var defaultValue = errCollection[CommonErrors.NA];
+        var hasDefault = (args.length - 1) % 2 === 1;
+        if (hasDefault) {
+            defaultValue = this.parent.getValueFromArg(args[args.length - 1]);
+        }
+        for (var i = 0; i < pairs; i++) {
+            var valueIdx = 1 + i * 2;
+            var resultIdx = valueIdx + 1;
+            var matchVal = this.parent.getValueFromArg(args[valueIdx]);
+            if (errCollection.indexOf(matchVal) > -1) {
+                return matchVal;
+            }
+            if (matchVal === expression ||
+                (!isNaN(this.parent.parseFloat(matchVal)) &&
+                    this.parent.parseFloat(matchVal) === this.parent.parseFloat(expression))) {
+                var result = this.parent.getValueFromArg(args[resultIdx]);
+                return result === '' ? '0' : this.parent.removeTics(result);
+            }
+        }
+        return defaultValue === '' ? '0' : this.parent.removeTics(defaultValue);
+    };
+    return LogicalExtraFormulas;
+}(FormulaModuleBase));
+export { LogicalExtraFormulas };

package/src/formulas/logical.d.ts

@@ -0,0 +1,83 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Boolean logic, conditional branching (IF), and error-coalescing (IFERROR) functions.
+ *
+ * Registered functions: IF, AND, OR, NOT, IFS, IFERROR.
+ *
+ * @hidden
+ */
+export declare class LogicalFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Returns one value if a logical expression is TRUE and another if it is FALSE.
+     *
+     * Excel: `IF(...)`.
+     *
+     * @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('=IF(A1>0,"Yes","No")');
+     * ```
+     */
+    ComputeIF(...args: string[]): string | number;
+    /**
+     * Returns TRUE if all the arguments are considered TRUE, and FALSE otherwise.
+     *
+     * Excel: `AND(...)`.
+     *
+     * @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!`.
+     */
+    ComputeAND(...args: string[]): string;
+    /**
+     * Returns TRUE if any arguments considered TRUE, and all the arguments are FALSE it will return FALSE.
+     *
+     * Excel: `OR(...)`.
+     *
+     * @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!`.
+     */
+    ComputeOR(...args: string[]): string;
+    /**
+     * Returns the inverse of a given logical expression.
+     *
+     * Excel: `NOT(...)`.
+     *
+     * @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!`.
+     */
+    ComputeNOT(...args: string[]): string;
+    /**
+     * Checks multiple conditions and returns a value corresponding to the first TRUE result.
+     *
+     * Excel: `IFS(...)`.
+     *
+     * @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`.
+     */
+    ComputeIFS(...args: string[]): string | number;
+    /**
+     * Returns a value you specify if a formula evaluates to an error; otherwise, it returns the result of the formula.
+     *
+     * Excel: `IFERROR(...)`.
+     *
+     * @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`.
+     */
+    ComputeIFERROR(...args: string[]): number | string;
+}

package/src/formulas/logical.js

@@ -0,0 +1,296 @@
+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 { isNumber } from '../common/number-date';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Boolean logic, conditional branching (IF), and error-coalescing (IFERROR) functions.
+ *
+ * Registered functions: IF, AND, OR, NOT, IFS, IFERROR.
+ *
+ * @hidden
+ */
+var LogicalFormulas = /** @class */ (function (_super) {
+    __extends(LogicalFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function LogicalFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'IF', category: 'Logical', description: 'Returns one value if a logical expression is TRUE and another if it is FALSE' },
+            { formulaName: 'AND', category: 'Logical', description: 'Returns TRUE if all the arguments are considered TRUE, and FALSE otherwise.' },
+            { formulaName: 'OR', category: 'Logical', description: 'Returns TRUE if any arguments considered TRUE, and all the arguments are FALSE it will return FALSE.' },
+            { formulaName: 'NOT', category: 'Logical', description: 'Returns the inverse of a given logical expression.' },
+            { formulaName: 'IFS', category: 'Logical', description: 'Checks multiple conditions and returns a value corresponding to the first TRUE result.' },
+            { formulaName: 'IFERROR', category: 'Logical', description: 'Returns a value you specify if a formula evaluates to an error; otherwise, it returns the result of the formula.' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns one value if a logical expression is TRUE and another if it is FALSE.
+     *
+     * Excel: `IF(...)`.
+     *
+     * @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('=IF(A1>0,"Yes","No")');
+     * ```
+     */
+    LogicalFormulas.prototype.ComputeIF = 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();
+        }
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        if (this.parent.getErrorStrings().indexOf(args[0]) > -1) {
+            return args[0];
+        }
+        var argArr = args;
+        var skipTick;
+        if (argArr.length === 4 && argArr[3] === 'nestedFormulaTrue') {
+            skipTick = true;
+            argArr.pop();
+        }
+        var condition;
+        var result;
+        if (argArr.length > 3 || argArr.length === 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        else if (argArr.length <= 3) {
+            var cellValues = void 0;
+            var cellVal = void 0;
+            var val = '';
+            condition = this.parent.getValueFromArg(argArr[0]);
+            if (this.parent.getErrorStrings().indexOf(condition) > -1) {
+                return condition;
+            }
+            var condUpper = condition.toUpperCase();
+            var parsedVal = this.parent.parseFloat(condition);
+            if (condUpper === this.parent.trueValue || (parsedVal < 0 || parsedVal > 0)) {
+                if (nestedFormula && argArr[1].includes(':')) {
+                    cellValues = this.parent.getCellCollection(argArr[1]);
+                    for (var i = 0; i < cellValues.length; i++) {
+                        cellVal = this.parent.getValueFromArg(cellValues[i]);
+                        if (!isNaN(this.parent.parseFloat(cellVal))) {
+                            val += cellVal + ',';
+                        }
+                    }
+                    return val.slice(0, val.length - 1);
+                }
+                result = argArr[1] === '' ? '0' : this.parent.getValueFromArg(argArr[1], undefined, undefined, undefined, true);
+            }
+            else if (condUpper === this.parent.falseValue || parsedVal === 0) {
+                if (isNullOrUndefined(argArr[2])) {
+                    return this.parent.falseValue;
+                }
+                if (nestedFormula && argArr[2].includes(':')) {
+                    cellValues = this.parent.getCellCollection(argArr[2]);
+                    for (var i = 0; i < cellValues.length; i++) {
+                        cellVal = this.parent.getValueFromArg(cellValues[i]);
+                        if (!isNaN(this.parent.parseFloat(cellVal))) {
+                            val += cellVal + ',';
+                        }
+                    }
+                    return val.slice(0, val.length - 1);
+                }
+                result = argArr[2] === '' ? '0' : this.parent.getValueFromArg(argArr[2], undefined, undefined, undefined, true);
+            }
+            else {
+                return this.parent.formulaErrorStrings[FormulasErrorsStrings.Requires3Args];
+            }
+        }
+        var indexOfTic = result.indexOf(this.parent.tic);
+        if (!skipTick && indexOfTic > -1) {
+            return result.split(this.parent.tic).join('');
+        }
+        else if (skipTick && !isNumber(result) && indexOfTic === -1 && result !== this.parent.trueValue &&
+            result !== this.parent.falseValue && !this.parent.isCellReference(result)) {
+            return '"' + result + '"';
+        }
+        else {
+            return result === '' ? '0' : result;
+        }
+    };
+    /**
+     * Returns TRUE if all the arguments are considered TRUE, and FALSE otherwise.
+     *
+     * Excel: `AND(...)`.
+     *
+     * @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!`.
+     */
+    LogicalFormulas.prototype.ComputeAND = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        if (isNullOrUndefined(args) || (argArr.length === 1 && argArr[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        return this.parent.computeAndOrNot(argArr, 'and');
+    };
+    /**
+     * Returns TRUE if any arguments considered TRUE, and all the arguments are FALSE it will return FALSE.
+     *
+     * Excel: `OR(...)`.
+     *
+     * @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!`.
+     */
+    LogicalFormulas.prototype.ComputeOR = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        if (isNullOrUndefined(args) || (argArr.length === 1 && argArr[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        return this.parent.computeAndOrNot(argArr, 'or');
+    };
+    /**
+     * Returns the inverse of a given logical expression.
+     *
+     * Excel: `NOT(...)`.
+     *
+     * @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!`.
+     */
+    LogicalFormulas.prototype.ComputeNOT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        if (isNullOrUndefined(args) || (args.length > 1 || args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        return this.parent.computeAndOrNot(argArr, 'not');
+    };
+    /**
+     * Checks multiple conditions and returns a value corresponding to the first TRUE result.
+     *
+     * Excel: `IFS(...)`.
+     *
+     * @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`.
+     */
+    LogicalFormulas.prototype.ComputeIFS = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var argArr = args;
+        if (isNullOrUndefined(args) || (argArr.length === 1 && argArr[0] === '') || argArr.length % 2 !== 0) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var condition = '';
+        var result = '';
+        for (var i = 0; i < argArr.length; i++) {
+            condition = this.parent.getValueFromArg(argArr[i]);
+            if (argArr[i] === '') {
+                return this.parent.getErrorStrings()[CommonErrors.NA];
+            }
+            if (this.parent.getErrorStrings().indexOf(condition) > -1) {
+                return condition;
+            }
+            if (condition !== this.parent.trueValue && condition !== this.parent.falseValue) {
+                return this.parent.getErrorStrings()[CommonErrors.Value];
+            }
+            if (condition === this.parent.trueValue) {
+                if (this.parent.isCellReference(argArr[i + 1].split(this.parent.tic).join('')) || argArr[i + 1].includes(this.parent.arithMarker)) {
+                    result = this.parent.getValueFromArg(argArr[i + 1]);
+                    result = result === '' ? '0' : result;
+                }
+                else {
+                    result = argArr[i + 1] === '' ? '0' : this.parent.getValueFromArg(argArr[i + 1]);
+                    if (result.indexOf(this.parent.tic) > -1) {
+                        result = result.split(this.parent.tic).join('');
+                    }
+                }
+                i = i + 1;
+                return result;
+            }
+            else if (condition === this.parent.falseValue) {
+                i = i + 1;
+            }
+        }
+        return this.parent.getErrorStrings()[CommonErrors.NA];
+    };
+    /**
+     * Returns a value you specify if a formula evaluates to an error; otherwise, it returns the result of the formula.
+     *
+     * Excel: `IFERROR(...)`.
+     *
+     * @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`.
+     */
+    LogicalFormulas.prototype.ComputeIFERROR = 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.InvalidArguments];
+        }
+        var argArr = args;
+        var condition;
+        if (argArr.length !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        if (this.parent.isCellReference(argArr[0])) {
+            condition = this.parent.getValueFromArg(argArr[0]) || '0';
+            if (this.parent.getErrorStrings().indexOf(condition) === -1 && condition !== 'NaN') {
+                return condition;
+            }
+        }
+        else {
+            condition = this.parent.getValueFromArg(argArr[0], null, true) || '0';
+            if (this.parent.getErrorStrings().indexOf(condition) === -1 && condition !== 'NaN') {
+                condition = condition.split(this.parent.tic).join('').trim();
+                return condition;
+            }
+        }
+        if (this.parent.isCellReference(argArr[1])) {
+            condition = this.parent.getValueFromArg(argArr[1]) || '0';
+        }
+        else {
+            condition = this.parent.getValueFromArg(argArr[1]) || '0';
+            condition = condition.split(this.parent.tic).join('').trim();
+        }
+        return condition;
+    };
+    return LogicalFormulas;
+}(FormulaModuleBase));
+export { LogicalFormulas };