@syncfusion/ej2-calculate 35.1.37

package/src/formulas/text-advanced.d.ts

@@ -0,0 +1,64 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * Advanced text parsing, regex-style extraction, and structured text transforms.
+ *
+ * Registered functions: ASC, TEXTBEFORE, VALUETOTEXT, ARRAYTOTEXT.
+ *
+ * @hidden
+ */
+export declare class TextAdvancedFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Changes full-width characters to half-width.
+     *
+     * Excel: `ASC(...)`.
+     *
+     * @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('=ASC(1)');
+     * ```
+     */
+    ComputeASC(...args: string[]): string | number;
+    /**
+     * Returns text before a given character or string.
+     *
+     * Excel: `TEXTBEFORE(...)`.
+     *
+     * @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`.
+     */
+    ComputeTEXTBEFORE(...args: string[]): string | number;
+    /**
+     * Returns text from any specified value.
+     *
+     * Excel: `VALUETOTEXT(...)`.
+     *
+     * @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`.
+     */
+    ComputeVALUETOTEXT(...args: string[]): string | number;
+    /**
+     * Returns the text representation of an array.
+     *
+     * Excel: `ARRAYTOTEXT(...)`.
+     *
+     * @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`.
+     */
+    ComputeARRAYTOTEXT(...args: string[]): string | number;
+}

package/src/formulas/text-advanced.js

@@ -0,0 +1,222 @@
+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';
+/**
+ * Advanced text parsing, regex-style extraction, and structured text transforms.
+ *
+ * Registered functions: ASC, TEXTBEFORE, VALUETOTEXT, ARRAYTOTEXT.
+ *
+ * @hidden
+ */
+var TextAdvancedFormulas = /** @class */ (function (_super) {
+    __extends(TextAdvancedFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function TextAdvancedFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'ASC', category: 'Text', description: 'Changes full-width characters to half-width.' },
+            { formulaName: 'TEXTBEFORE', category: 'Text', description: 'Returns text before a given character or string.' },
+            { formulaName: 'VALUETOTEXT', category: 'Text', description: 'Returns text from any specified value.' },
+            { formulaName: 'ARRAYTOTEXT', category: 'Text', description: 'Returns the text representation of an array.' }
+        ];
+        return _this;
+    }
+    /**
+     * Changes full-width characters to half-width.
+     *
+     * Excel: `ASC(...)`.
+     *
+     * @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('=ASC(1)');
+     * ```
+     */
+    TextAdvancedFormulas.prototype.ComputeASC = 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 text = this.resolveTextArg(args[0]);
+        if (this.parent.getErrorStrings().indexOf(text) > -1) {
+            return text;
+        }
+        var result = '';
+        for (var i = 0; i < text.length; i++) {
+            var code = text.charCodeAt(i);
+            if (code >= 0xFF01 && code <= 0xFF5E) {
+                result += String.fromCharCode(code - 0xFEE0);
+            }
+            else if (code === 0x3000) {
+                result += ' ';
+            }
+            else {
+                result += text.charAt(i);
+            }
+        }
+        return result;
+    };
+    /**
+     * Returns text before a given character or string.
+     *
+     * Excel: `TEXTBEFORE(...)`.
+     *
+     * @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`.
+     */
+    TextAdvancedFormulas.prototype.ComputeTEXTBEFORE = 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 > 6) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var text = this.resolveTextArg(args[0]);
+        if (errCollection.indexOf(text) > -1) {
+            return text;
+        }
+        var delimiter = this.resolveTextArg(args[1]);
+        if (errCollection.indexOf(delimiter) > -1) {
+            return delimiter;
+        }
+        var instance = 1;
+        if (args.length >= 3 && args[2] !== '') {
+            var inst = this.resolveNumberArg(args[2]);
+            if (typeof inst === 'string') {
+                return inst;
+            }
+            instance = Math.floor(inst);
+            if (instance < 1) {
+                return errCollection[CommonErrors.Value];
+            }
+        }
+        var start = 0;
+        for (var i = 0; i < instance; i++) {
+            var idx = text.indexOf(delimiter, start);
+            if (idx < 0) {
+                if (args.length >= 6 && args[5] !== '') {
+                    return this.resolveTextArg(args[5]);
+                }
+                return errCollection[CommonErrors.NA];
+            }
+            if (i === instance - 1) {
+                return text.substring(0, idx);
+            }
+            start = idx + delimiter.length;
+        }
+        return text;
+    };
+    /**
+     * Returns text from any specified value.
+     *
+     * Excel: `VALUETOTEXT(...)`.
+     *
+     * @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`.
+     */
+    TextAdvancedFormulas.prototype.ComputeVALUETOTEXT = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var val = this.parent.getValueFromArg(args[0]);
+        if (errCollection.indexOf(val) > -1) {
+            return val;
+        }
+        if (val === '') {
+            return '';
+        }
+        var concise = true;
+        if (args.length === 2) {
+            var fmt = this.resolveNumberArg(args[1]);
+            if (typeof fmt === 'string') {
+                return fmt;
+            }
+            concise = fmt === 0;
+        }
+        if (!concise && !this.parent.isCellReference(args[0]) && args[0].indexOf(this.parent.tic) > -1) {
+            return this.parent.removeTics(val);
+        }
+        return val;
+    };
+    /**
+     * Returns the text representation of an array.
+     *
+     * Excel: `ARRAYTOTEXT(...)`.
+     *
+     * @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`.
+     */
+    TextAdvancedFormulas.prototype.ComputeARRAYTOTEXT = function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (isNullOrUndefined(args) || args.length < 1 || args.length > 2) {
+            return this.parent.formulaErrorStrings[FormulasErrorsStrings.WrongNumberArguments];
+        }
+        var errCollection = this.parent.getErrorStrings();
+        var parts = [];
+        var collect = function (arg) {
+            if (_this.parent.isCellReference(arg) && arg.indexOf(':') > -1) {
+                var cells = _this.parent.getCellCollection(arg);
+                var list = Array.isArray(cells) ? cells : [cells];
+                for (var i = 0; i < list.length; i++) {
+                    var val = _this.parent.getValueFromArg(list[i]);
+                    if (errCollection.indexOf(val) > -1) {
+                        return val;
+                    }
+                    parts.push(val);
+                }
+            }
+            else {
+                var val = _this.resolveTextArg(arg);
+                if (errCollection.indexOf(val) > -1) {
+                    return val;
+                }
+                parts.push(val);
+            }
+            return null;
+        };
+        var err = collect(args[0]);
+        if (err) {
+            return err;
+        }
+        return parts.join(this.parent.getParseArgumentSeparator());
+    };
+    return TextAdvancedFormulas;
+}(FormulaModuleBase));
+export { TextAdvancedFormulas };

package/src/formulas/text-ecma.d.ts

@@ -0,0 +1,54 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * ECMA text function aliases and byte-oriented variants (FINDB, LENB, USDOLLAR).
+ *
+ * Registered functions: USDOLLAR, FINDB, LENB.
+ *
+ * @hidden
+ */
+export declare class TextEcmaFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * Converts a number to text using currency format (US dollar).
+     *
+     * Excel: `USDOLLAR(...)`.
+     *
+     * @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('=USDOLLAR(1)');
+     * ```
+     */
+    ComputeUSDOLLAR(...args: string[]): string | number;
+    /**
+     * Finds text within another string (byte-count alias of FIND).
+     *
+     * Excel: `FINDB(...)`.
+     *
+     * @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`.
+     */
+    ComputeFINDB(...args: string[]): string | number;
+    /**
+     * Returns the length of a text string (byte-count alias of LEN).
+     *
+     * Excel: `LENB(...)`.
+     *
+     * @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`.
+     */
+    ComputeLENB(...args: string[]): string | number;
+}

package/src/formulas/text-ecma.js

@@ -0,0 +1,106 @@
+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 } from '../common/index';
+import { FormulaModuleBase } from './formula-module-base';
+/**
+ * ECMA text function aliases and byte-oriented variants (FINDB, LENB, USDOLLAR).
+ *
+ * Registered functions: USDOLLAR, FINDB, LENB.
+ *
+ * @hidden
+ */
+var TextEcmaFormulas = /** @class */ (function (_super) {
+    __extends(TextEcmaFormulas, _super);
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    function TextEcmaFormulas(owner) {
+        var _this = _super.call(this, owner) || this;
+        /** Formula definitions registered with {@link BasicFormulas}. */
+        _this.formulas = [
+            { formulaName: 'USDOLLAR', category: 'Text', description: 'Converts a number to text using currency format (US dollar).' },
+            { formulaName: 'FINDB', category: 'Text', description: 'Finds text within another string (byte-count alias of FIND).' },
+            { formulaName: 'LENB', category: 'Text', description: 'Returns the length of a text string (byte-count alias of LEN).' }
+        ];
+        return _this;
+    }
+    /**
+     * Converts a number to text using currency format (US dollar).
+     *
+     * Excel: `USDOLLAR(...)`.
+     *
+     * @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('=USDOLLAR(1)');
+     * ```
+     */
+    TextEcmaFormulas.prototype.ComputeUSDOLLAR = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var fn = this.owner['ComputeDOLLAR'];
+        if (fn) {
+            return fn.apply(void 0, args);
+        }
+        return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+    };
+    /**
+     * Finds text within another string (byte-count alias of FIND).
+     *
+     * Excel: `FINDB(...)`.
+     *
+     * @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`.
+     */
+    TextEcmaFormulas.prototype.ComputeFINDB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var fn = this.owner['ComputeFIND'];
+        if (fn) {
+            return fn.apply(void 0, args);
+        }
+        return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+    };
+    /**
+     * Returns the length of a text string (byte-count alias of LEN).
+     *
+     * Excel: `LENB(...)`.
+     *
+     * @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`.
+     */
+    TextEcmaFormulas.prototype.ComputeLENB = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var fn = this.owner['ComputeLEN'];
+        if (fn) {
+            return fn.apply(void 0, args);
+        }
+        return this.parent.formulaErrorStrings[FormulasErrorsStrings.InvalidArguments];
+    };
+    return TextEcmaFormulas;
+}(FormulaModuleBase));
+export { TextEcmaFormulas };

package/src/formulas/text-extra.d.ts

@@ -0,0 +1,216 @@
+import { IBasicFormula } from '../common/index';
+import { FormulaOwner } from './formula-owner';
+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
+ */
+export declare class TextExtraFormulas extends FormulaModuleBase {
+    /** Formula definitions registered with {@link BasicFormulas}. */
+    formulas: IBasicFormula[];
+    /**
+     * @hidden
+     * @param {FormulaOwner} owner - Formula registration owner ({@link BasicFormulas}).
+     */
+    constructor(owner: FormulaOwner);
+    /**
+     * 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)');
+     * ```
+     */
+    ComputeLEFT(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeRIGHT(...args: string[]): string;
+    private substringSide;
+    /**
+     * 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!`.
+     */
+    ComputeMID(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeUPPER(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeLOWER(...args: string[]): string;
+    private caseTransform;
+    /**
+     * 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!`.
+     */
+    ComputeTRIM(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeREPLACE(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeSUBSTITUTE(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeREPT(...args: string[]): string;
+    /**
+     * 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`.
+     */
+    ComputeSEARCH(...args: string[]): string | number;
+    /**
+     * 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`.
+     */
+    ComputeVALUE(...args: string[]): string | number;
+    /**
+     * 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!`.
+     */
+    ComputeCLEAN(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeFIXED(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeTEXTJOIN(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeLEFTB(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeRIGHTB(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeMIDB(...args: string[]): string;
+    /**
+     * 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!`.
+     */
+    ComputeREPLACEB(...args: string[]): string;
+    /**
+     * 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`.
+     */
+    ComputeSEARCHB(...args: string[]): string | number;
+}