@syncfusion/ej2-calculate 35.1.37

package/src/formulas/text-extra.js

@@ -0,0 +1,657 @@
+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 text functions for search, replace, formatting, and character-code conversion.
+ *
+ * Registers 19 functions including LEFT, RIGHT, MID, UPPER, LOWER, and others.
+ *
+ * @hidden
+ */
+var TextExtraFormulas = /** @class */ (function (_super) {
+    __extends(TextExtraFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function TextExtraFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'LEFT', category: 'Text', description: 'Returns the leftmost characters from a text value.' },
+            { formulaName: 'RIGHT', category: 'Text', description: 'Returns the rightmost characters from a text value.' },
+            { formulaName: 'MID', category: 'Text', description: 'Returns a specific number of characters from a text string starting at the position you specify.' },
+            { formulaName: 'UPPER', category: 'Text', description: 'Converts text to uppercase.' },
+            { formulaName: 'LOWER', category: 'Text', description: 'Converts text to lowercase.' },
+            { formulaName: 'TRIM', category: 'Text', description: 'Removes spaces from text except for single spaces between words.' },
+            { formulaName: 'REPLACE', category: 'Text', description: 'Replaces characters within text.' },
+            { formulaName: 'SUBSTITUTE', category: 'Text', description: 'Substitutes new text for old text in a text string.' },
+            { formulaName: 'REPT', category: 'Text', description: 'Repeats text a given number of times.' },
+            { formulaName: 'SEARCH', category: 'Text', description: 'Finds one text value within another (not case-sensitive).' },
+            { formulaName: 'VALUE', category: 'Text', description: 'Converts a text argument to a number.' },
+            { formulaName: 'CLEAN', category: 'Text', description: 'Removes all nonprintable characters from text.' },
+            { formulaName: 'FIXED', category: 'Text', description: 'Formats a number as text with a fixed number of decimals.' },
+            { formulaName: 'TEXTJOIN', category: 'Text', description: 'Combines text from multiple ranges/strings with a delimiter.' },
+            { formulaName: 'LEFTB', category: 'Text', description: 'Returns the leftmost characters from a text value (byte count alias).' },
+            { formulaName: 'RIGHTB', category: 'Text', description: 'Returns the rightmost characters from a text value (byte count alias).' },
+            { formulaName: 'MIDB', category: 'Text', description: 'Returns characters from a text string (byte count alias).' },
+            { formulaName: 'REPLACEB', category: 'Text', description: 'Replaces characters within text (byte count alias).' },
+            { formulaName: 'SEARCHB', category: 'Text', description: 'Finds one text value within another (byte count alias).' }
+        ];
+        return _this;
+    }
+    /**
+     * Returns the leftmost characters from a text value.
+     *
+     * Excel: `LEFT(...)`.
+     *
+     * @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('=LEFT("Calculate",4)');
+     * ```
+     */
+    TextExtraFormulas.prototype.ComputeLEFT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.substringSide(args, true);
+    };
+    /**
+     * Returns the rightmost characters from a text value.
+     *
+     * Excel: `RIGHT(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeRIGHT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.substringSide(args, false);
+    };
+    TextExtraFormulas.prototype.substringSide = function (args, fromLeft) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || (args.length === 1 && args[0] === '')) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+        }
+        if (args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        var count = 1;
+        if (args.length === 2) {
+            var num = this.resolveNumberArg(args[1]);
+            if (typeof num === 'string') {
+                return num;
+            }
+            count = Math.floor(num);
+            if (count < 0) {
+                return errCollection[CommonErrors.Value];
+            }
+        }
+        if (fromLeft) {
+            return text.substring(0, count);
+        }
+        return count >= text.length ? text : text.substring(text.length - count);
+    };
+    /**
+     * Returns a specific number of characters from a text string starting at the position you specify.
+     *
+     * Excel: `MID(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeMID = 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 text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        var start = this.resolveNumberArg(args[1]);
+        var numChars = this.resolveNumberArg(args[2]);
+        if (typeof start === 'string') {
+            return start;
+        }
+        if (typeof numChars === 'string') {
+            return numChars;
+        }
+        var startIdx = Math.floor(start);
+        var length = Math.floor(numChars);
+        if (startIdx < 1 || length < 0) {
+            return errCollection[CommonErrors.Value];
+        }
+        return text.substring(startIdx - 1, startIdx - 1 + length);
+    };
+    /**
+     * Converts text to uppercase.
+     *
+     * Excel: `UPPER(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeUPPER = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.caseTransform(args, true);
+    };
+    /**
+     * Converts text to lowercase.
+     *
+     * Excel: `LOWER(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeLOWER = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.caseTransform(args, false);
+    };
+    TextExtraFormulas.prototype.caseTransform = function (args, upper) {
+        var errCollection = this.parent.getErrorStrings();
+        if (isNullOrUndefined(args) || args.length !== 1) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        return upper ? text.toUpperCase() : text.toLowerCase();
+    };
+    /**
+     * Removes spaces from text except for single spaces between words.
+     *
+     * Excel: `TRIM(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeTRIM = 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 text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        return text.trim().replace(/\s+/g, ' ');
+    };
+    /**
+     * Replaces characters within text.
+     *
+     * Excel: `REPLACE(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeREPLACE = 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 !== 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        var start = this.resolveNumberArg(args[1]);
+        var numChars = this.resolveNumberArg(args[2]);
+        var newText = this.resolveTextArg(args[3]);
+        if (typeof start === 'string') {
+            return start;
+        }
+        if (typeof numChars === 'string') {
+            return numChars;
+        }
+        if (errCollection.indexOf(newText) > -1) {
+            return newText;
+        }
+        var startIdx = Math.floor(start);
+        var length = Math.floor(numChars);
+        if (startIdx < 1 || length < 0) {
+            return errCollection[CommonErrors.Value];
+        }
+        return text.substring(0, startIdx - 1) + newText + text.substring(startIdx - 1 + length);
+    };
+    /**
+     * Substitutes new text for old text in a text string.
+     *
+     * Excel: `SUBSTITUTE(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeSUBSTITUTE = 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 > 4) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]);
+        var oldText = this.resolveTextArg(args[1]);
+        var newText = this.resolveTextArg(args[2]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        if (errCollection.indexOf(oldText) > -1) {
+            return oldText;
+        }
+        if (errCollection.indexOf(newText) > -1) {
+            return newText;
+        }
+        if (oldText === '') {
+            return text;
+        }
+        if (args.length === 3) {
+            return text.split(oldText).join(newText);
+        }
+        var instance = this.resolveNumberArg(args[3]);
+        if (typeof instance === 'string') {
+            return instance;
+        }
+        var nth = Math.floor(instance);
+        if (nth < 1) {
+            return errCollection[CommonErrors.Value];
+        }
+        var found = 0;
+        var index = text.indexOf(oldText);
+        while (index > -1) {
+            found++;
+            if (found === nth) {
+                return text.substring(0, index) + newText + text.substring(index + oldText.length);
+            }
+            index = text.indexOf(oldText, index + oldText.length);
+        }
+        return text;
+    };
+    /**
+     * Repeats text a given number of times.
+     *
+     * Excel: `REPT(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeREPT = 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 !== 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        var times = this.resolveNumberArg(args[1]);
+        if (typeof times === 'string') {
+            return times;
+        }
+        var count = Math.floor(times);
+        if (count < 0) {
+            return errCollection[CommonErrors.Value];
+        }
+        if (count === 0 || text === '') {
+            return '';
+        }
+        return new Array(count + 1).join(text);
+    };
+    /**
+     * Finds one text value within another (not case-sensitive).
+     *
+     * Excel: `SEARCH(...)`.
+     *
+     * @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`.
+     */
+    TextExtraFormulas.prototype.ComputeSEARCH = 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 < 2 || args.length > 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var findText = this.resolveTextArg(args[0]).toLowerCase();
+        var withinText = this.resolveTextArg(args[1]).toLowerCase();
+        if (errCollection.indexOf(findText) > -1) {
+            return findText;
+        }
+        if (errCollection.indexOf(withinText) > -1) {
+            return withinText;
+        }
+        var startNum = 1;
+        if (args.length === 3) {
+            var start = this.resolveNumberArg(args[2]);
+            if (typeof start === 'string') {
+                return start;
+            }
+            startNum = Math.floor(start);
+            if (startNum < 1) {
+                return errCollection[CommonErrors.Value];
+            }
+        }
+        var idx = withinText.indexOf(findText, startNum - 1);
+        if (idx < 0) {
+            return errCollection[CommonErrors.Value];
+        }
+        return (idx + 1).toString();
+    };
+    /**
+     * Converts a text argument to a number.
+     *
+     * Excel: `VALUE(...)`.
+     *
+     * @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`.
+     */
+    TextExtraFormulas.prototype.ComputeVALUE = 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 text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        if (text === '') {
+            return '0';
+        }
+        var cleaned = text.replace(/,/g, '').replace(/\$/g, '').trim();
+        var num = this.parent.parseFloat(cleaned);
+        if (isNaN(num)) {
+            return errCollection[CommonErrors.Value];
+        }
+        return num.toString();
+    };
+    /**
+     * Removes all nonprintable characters from text.
+     *
+     * Excel: `CLEAN(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeCLEAN = 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 text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        var result = '';
+        for (var i = 0; i < text.length; i++) {
+            var code = text.charCodeAt(i);
+            if (code >= 32) {
+                result += text.charAt(i);
+            }
+        }
+        return result;
+    };
+    /**
+     * Formats a number as text with a fixed number of decimals.
+     *
+     * Excel: `FIXED(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeFIXED = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 3) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var number = this.resolveNumberArg(args[0]);
+        if (typeof number === 'string') {
+            return number;
+        }
+        var decimals = 2;
+        if (args.length >= 2 && args[1] !== '') {
+            var d = this.resolveNumberArg(args[1]);
+            if (typeof d === 'string') {
+                return d;
+            }
+            decimals = Math.floor(d);
+        }
+        var noCommas = false;
+        if (args.length === 3 && args[2] !== '') {
+            var flag = this.parent.getValueFromArg(args[2]).toUpperCase();
+            noCommas = flag === this.parent.trueValue || this.parent.parseFloat(flag) !== 0;
+        }
+        if (decimals < 0) {
+            var factor = Math.pow(10, -decimals);
+            var rounded = Math.round(number / factor) * factor;
+            return noCommas ? rounded.toString() : rounded.toLocaleString('en-US');
+        }
+        var fixed = number.toFixed(decimals);
+        if (noCommas) {
+            return fixed;
+        }
+        var parts = fixed.split('.');
+        var intPart = parts[0];
+        var sign = intPart.charAt(0) === '-' ? '-' : '';
+        if (sign) {
+            intPart = intPart.substring(1);
+        }
+        var grouped = '';
+        for (var i = 0; i < intPart.length; i++) {
+            var fromEnd = intPart.length - i;
+            if (i > 0 && fromEnd % 3 === 0) {
+                grouped += ',';
+            }
+            grouped += intPart.charAt(i);
+        }
+        parts[0] = sign + grouped;
+        return parts.join('.');
+    };
+    /**
+     * Combines text from multiple ranges/strings with a delimiter.
+     *
+     * Excel: `TEXTJOIN(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeTEXTJOIN = 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 delimiter = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(delimiter) > -1) {
+            return delimiter;
+        }
+        var ignoreEmptyFlag = this.parent.getValueFromArg(args[1]).toUpperCase();
+        var ignoreEmpty = ignoreEmptyFlag === this.parent.trueValue ||
+            (!isNaN(this.parent.parseFloat(ignoreEmptyFlag)) && this.parent.parseFloat(ignoreEmptyFlag) !== 0);
+        var parts = [];
+        for (var i = 2; 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 (!(ignoreEmpty && val === '')) {
+                        parts.push(val);
+                    }
+                }
+            }
+            else {
+                var val = this.resolveTextArg(arg);
+                if (errCollection.indexOf(val) > -1) {
+                    return val;
+                }
+                if (!(ignoreEmpty && val === '')) {
+                    parts.push(val);
+                }
+            }
+        }
+        return parts.join(delimiter);
+    };
+    /**
+     * Returns the leftmost characters from a text value (byte count alias).
+     *
+     * Excel: `LEFTB(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeLEFTB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.ComputeLEFT.apply(this, args);
+    };
+    /**
+     * Returns the rightmost characters from a text value (byte count alias).
+     *
+     * Excel: `RIGHTB(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeRIGHTB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.ComputeRIGHT.apply(this, args);
+    };
+    /**
+     * Returns characters from a text string (byte count alias).
+     *
+     * Excel: `MIDB(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeMIDB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.ComputeMID.apply(this, args);
+    };
+    /**
+     * Replaces characters within text (byte count alias).
+     *
+     * Excel: `REPLACEB(...)`.
+     *
+     * @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!`.
+     */
+    TextExtraFormulas.prototype.ComputeREPLACEB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.ComputeREPLACE.apply(this, args);
+    };
+    /**
+     * Finds one text value within another (byte count alias).
+     *
+     * Excel: `SEARCHB(...)`.
+     *
+     * @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`.
+     */
+    TextExtraFormulas.prototype.ComputeSEARCHB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return this.ComputeSEARCH.apply(this, args);
+    };
+    return TextExtraFormulas;
+}(FormulaModuleBase));
+export { TextExtraFormulas };