@univerjs/engine-formula 1.0.0-alpha.8 → 1.0.0-beta.0

package/lib/types/basics/regex.d.ts

@@ -32,10 +32,10 @@ export declare const REFERENCE_REGEX_SINGLE_ROW = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\
 export declare const REFERENCE_REGEX_SINGLE_ROW_PRECOMPILING: RegExp;
 export declare const REFERENCE_REGEX_SINGLE_COLUMN = "^'?(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?(((?![\\[\\]\\/?*\\\\]).)*!)?'?\\s*?\\$?[A-Za-z]+$";
 export declare const REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING: RegExp;
-export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+$";
-export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[((?<!#)[\\s\\S])*\\]|\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#)[\\s\\S])*\\]\\])+$";
-export declare const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[((?<!#)[\\s\\S])*\\]\\s*?:\\s*?\\[((?<!#)[\\s\\S])*\\]\\])?$|^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[#.+\\]\\s*?,\\s*?\\[((?<!#)[\\s\\S])*\\]\\s*?:\\s*?\\[((?<!#)[\\s\\S])*\\]\\])?$";
-export declare const REFERENCE_TABLE_TITLE_ONLY_ANY_HASH_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+\\[\\s*#([^\\]]+)\\s*\\]$";
+export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+$";
+export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[[^#]*#?\\]|\\[\\[#.+\\]\\s*?,\\s*?\\[[^#]*#?\\]\\])+$";
+export declare const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[[^#]*#?\\]\\s*?:\\s*?\\[[^#]*#?\\]\\])?$|^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[#.+\\]\\s*?,\\s*?\\[[^#]*#?\\]\\s*?:\\s*?\\[[^#]*#?\\]\\])?$";
+export declare const REFERENCE_TABLE_TITLE_ONLY_ANY_HASH_REGEX = "^(?:(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\]|'(?:[^']|'')+'|[^\\s!\\[\\]]+)!)?(?:\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+\\[\\s*#([^\\]]+)\\s*\\]$";
 export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX_PRECOMPILING: RegExp;
 export declare const REFERENCE_TABLE_SINGLE_COLUMN_REGEX_PRECOMPILING: RegExp;
 export declare const REFERENCE_TABLE_MULTIPLE_COLUMN_REGEX_PRECOMPILING: RegExp;

package/lib/types/engine/analysis/lexer-tree-builder.d.ts

@@ -27,6 +27,9 @@ export declare const FormulaSequenceNodeCache: FormulaAstLRU<(string | ISequence
 interface IInjectDefinedNameParam {
     unitId: Nullable<string>;
     sheetId?: Nullable<string>;
+    refOffsetX: number;
+    refOffsetY: number;
+    hasFunction(functionToken: IFunctionNames): boolean;
     getValueByName(unitId: string, name: string, sheetId?: Nullable<string>): Nullable<IDefinedNamesServiceParam>;
     getDirtyDefinedNameMap(): IDirtyUnitDefinedNameMap;
     getSheetName: (unitId: string, sheetId: string) => string;
@@ -101,6 +104,7 @@ export declare class LexerTreeBuilder extends Disposable {
     nodeMakerTest(formulaString: string): ErrorType.VALUE | (string | LexerNode)[] | undefined;
     treeBuilder(formulaString: string, transformSuffix?: boolean, injectDefinedNameParam?: IInjectDefinedNameParam): ErrorType.VALUE | LexerNode | (string | LexerNode)[] | undefined;
     private _handleDefinedName;
+    private _moveDefinedNameRefOffset;
     private _getHasSheetNameDefinedName;
     private _handleNestedDefinedName;
     private _simpleCheckDefinedName;

package/lib/types/engine/analysis/lexer.d.ts

@@ -17,11 +17,13 @@ import type { Nullable } from '@univerjs/core';
 import { Disposable } from '@univerjs/core';
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IDefinedNamesService } from '../../services/defined-names.service';
+import { IFunctionService } from '../../services/function.service';
 import { LexerTreeBuilder } from './lexer-tree-builder';
 export declare class Lexer extends Disposable {
     private readonly _definedNamesService;
     private readonly _lexerTreeBuilder;
     private readonly _formulaCurrentConfigService;
-    constructor(_definedNamesService: IDefinedNamesService, _lexerTreeBuilder: LexerTreeBuilder, _formulaCurrentConfigService: IFormulaCurrentConfigService);
-    treeBuilder(formulaString: string, transformSuffix?: boolean, unitId?: Nullable<string>): import("../..").ErrorType.VALUE | import("./lexer-node").LexerNode | (string | import("./lexer-node").LexerNode)[] | undefined;
+    private readonly _functionService;
+    constructor(_definedNamesService: IDefinedNamesService, _lexerTreeBuilder: LexerTreeBuilder, _formulaCurrentConfigService: IFormulaCurrentConfigService, _functionService: IFunctionService);
+    treeBuilder(formulaString: string, transformSuffix?: boolean, unitId?: Nullable<string>, refOffsetX?: number, refOffsetY?: number): import("../..").ErrorType.VALUE | import("./lexer-node").LexerNode | (string | import("./lexer-node").LexerNode)[] | undefined;
 }

package/lib/types/engine/ast-node/base-ast-node.d.ts

@@ -52,6 +52,7 @@ export declare class BaseAstNode {
     getToken(): string;
     setValue(value: Nullable<FunctionVariantType>): void;
     getValue(): Nullable<FunctionVariantType>;
+    preservesLazyIfReferenceArray(_child: BaseAstNode): boolean;
     isCalculated(): boolean;
     setCalculated(): void;
     execute(): void;

package/lib/types/engine/ast-node/function-node.d.ts

@@ -35,6 +35,7 @@ export declare class FunctionNode extends BaseAstNode {
     private _unitReferenceResolver;
     constructor(token: string, _functionExecutor: BaseFunction, _currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, _definedNamesService: IDefinedNamesService, _formulaDataModel: FormulaDataModel, _unitReferenceResolver: IFormulaUnitReferenceResolver);
     get nodeType(): NodeType;
+    preservesLazyIfReferenceArray(child: BaseAstNode): boolean;
     executeAsync(): Promise<AstNodePromiseType>;
     execute(): void;
     private _collectVariants;

package/lib/types/engine/ast-node/union-node.d.ts

@@ -13,20 +13,26 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IFunctionService } from '../../services/function.service';
 import { LexerNode } from '../analysis/lexer-node';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
 import { NodeType } from './node-type';
 export declare class UnionNode extends BaseAstNode {
-    constructor(operatorString: string);
+    private readonly _currentConfigService;
+    constructor(operatorString: string, _currentConfigService: Pick<IFormulaCurrentConfigService, 'getSheetsInfo'>);
     get nodeType(): NodeType;
     execute(): void;
+    private _createThreeDimensionalReference;
+    private _normalizeSheetName;
+    private _copyReferenceContext;
     private _unionFunction;
 }
 export declare class UnionNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;
-    constructor(_functionService: IFunctionService);
+    private readonly _currentConfigService;
+    constructor(_functionService: IFunctionService, _currentConfigService: IFormulaCurrentConfigService);
     get zIndex(): number;
     create(param: string): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined;

package/lib/types/engine/reference-object/base-reference-object.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { ICellData, IRange, Nullable } from '@univerjs/core';
+import type { ICellData, IRange, IUnitRange, Nullable } from '@univerjs/core';
 import type { IArrayFormulaRangeType, IRuntimeUnitDataType, IUnitData, IUnitSheetNameMap, IUnitStylesData } from '../../basics/common';
 import type { BaseValueObject } from '../value-object/base-value-object';
 import { ObjectMatrix } from '@univerjs/core';
@@ -146,6 +146,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
         sheetId: string;
         unitId: string;
     };
+    toUnitRanges(): IUnitRange[];
     private _checkIfWorksheetMiss;
     private _getBlankArrayValueObject;
 }

package/lib/types/engine/reference-object/multi-area-reference-object.d.ts

@@ -13,19 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Nullable } from '@univerjs/core';
+import type { IUnitRange, Nullable } from '@univerjs/core';
 import type { ArrayValueObject } from '../value-object/array-value-object';
-import type { BaseValueObject, ErrorValueObject } from '../value-object/base-value-object';
+import type { BaseValueObject } from '../value-object/base-value-object';
+import { ErrorValueObject } from '../value-object/base-value-object';
 import { BaseReferenceObject } from './base-reference-object';
 export type MultiAreaValue = BaseReferenceObject | ErrorValueObject;
+export declare enum MultiAreaArrayMode {
+    FIRST_CELL_GRID = "first-cell-grid",
+    STACK_AREAS = "stack-areas"
+}
 export declare class MultiAreaReferenceObject extends BaseReferenceObject {
+    private readonly _arrayMode;
     /**
      * 2D structure:
      * - First dimension: stored by rows
      * - Second dimension: each AreaValue within that row
      */
     private _areas;
-    constructor(token: string, areas?: MultiAreaValue[][]);
+    constructor(token: string, areas?: MultiAreaValue[][], _arrayMode?: MultiAreaArrayMode);
     dispose(): void;
     getAreas(): MultiAreaValue[][];
     setAreas(areas: MultiAreaValue[][]): void;
@@ -77,11 +83,13 @@ export declare class MultiAreaReferenceObject extends BaseReferenceObject {
      * - inner `_areas[row]` dimension => columns
      */
     toArrayValueObject(): ArrayValueObject;
+    private _stackAreas;
     getRangePosition(): import("@univerjs/core").IRange;
     toUnitRange(): {
         range: import("@univerjs/core").IRange;
         sheetId: string;
         unitId: string;
     };
+    toUnitRanges(): IUnitRange[];
     getRangeData(): import("@univerjs/core").IRange;
 }

package/lib/types/engine/reference-object/table-reference-object.d.ts

@@ -81,7 +81,7 @@ export declare class TableReferenceObject extends BaseReferenceObject {
     private _findCommaAtTopLevel;
     /**
      * Parse Section, compatible with both "[#Data]" and "#Data" inputs
-     * Returns TableOptionType if matched; returns DATA if not (could throw error instead)
+     * Returns TableOptionType if matched; returns undefined when the comma belongs to a column title.
      */
     private _parseSectionMaybeBracketed;
     /**

package/lib/types/engine/utils/generate-ast-node.d.ts

@@ -21,5 +21,5 @@ import type { AstRootNode } from '../ast-node/ast-root-node';
 import type { IFormulaDependencyTree } from '../dependency/dependency-tree';
 import { FormulaAstLRU } from '../../basics/cache-lru';
 export declare const FORMULA_AST_CACHE: FormulaAstLRU<AstRootNode>;
-export declare function generateAstNode(unitId: string, formulaString: string, lexer: Lexer, astTreeBuilder: AstTreeBuilder, currentConfigService: IFormulaCurrentConfigService, subUnitId?: string): AstRootNode;
+export declare function generateAstNode(unitId: string, formulaString: string, lexer: Lexer, astTreeBuilder: AstTreeBuilder, currentConfigService: IFormulaCurrentConfigService, subUnitId?: string, definedNameRefOffsetX?: number, definedNameRefOffsetY?: number): AstRootNode;
 export declare function includeDefinedName(tree: IFormulaDependencyTree, node: Nullable<AstRootNode>, currentConfigService: IFormulaCurrentConfigService): boolean;

package/lib/types/functions/base-function.d.ts

@@ -76,6 +76,10 @@ export declare class BaseFunction {
      * Whether the function needs unevaluated AST children.
      */
     needsAstChildren: boolean;
+    /**
+     * Arguments that preserve a selected lazy IF branch as a reference array.
+     */
+    lazyIfReferenceArrayArgumentIndexes: readonly number[];
     /**
      * Legacy CSE-style array functions should write only the first result cell
      * when they are used as a top-level normal formula.

package/lib/types/functions/compatibility/rank/index.d.ts

@@ -20,6 +20,7 @@ export declare class Rank extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(number: FunctionVariantType, ref: FunctionVariantType, order?: FunctionVariantType): BaseValueObject;
     private _checkRefReferenceObject;
 }

package/lib/types/functions/information/isblank/index.d.ts

@@ -13,12 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';
-import type { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Isblank extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
+    needsReferenceObject: boolean;
+    calculate(value: FunctionVariantType): import("../../..").BaseValueObject | ArrayValueObject;
 }

package/lib/types/functions/lookup/choose/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Choose extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     needsReferenceObject: boolean;
     calculate(indexNum: FunctionVariantType, ...variants: FunctionVariantType[]): FunctionVariantType;
 }

package/lib/types/functions/lookup/function-map.d.ts

@@ -13,10 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { Anchorarray } from './anchorarray';
 import { Choose } from './choose';
 import { FUNCTION_NAMES_LOOKUP } from './function-names';
 import { Hstack } from './hstack';
+import { Index } from './index/index';
 import { Indirect } from './indirect';
 import { Lookup } from './lookup';
 import { Match } from './match';
-export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Choose)[] | (FUNCTION_NAMES_LOOKUP | typeof Hstack)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[])[];
+import { Offset } from './offset';
+export declare const functionLookup: ((FUNCTION_NAMES_LOOKUP | typeof Anchorarray)[] | (FUNCTION_NAMES_LOOKUP | typeof Choose)[] | (FUNCTION_NAMES_LOOKUP | typeof Hstack)[] | (FUNCTION_NAMES_LOOKUP | typeof Index)[] | (FUNCTION_NAMES_LOOKUP | typeof Indirect)[] | (FUNCTION_NAMES_LOOKUP | typeof Lookup)[] | (FUNCTION_NAMES_LOOKUP | typeof Match)[] | (FUNCTION_NAMES_LOOKUP | typeof Offset)[])[];

package/lib/types/functions/lookup/match/index.d.ts

@@ -19,6 +19,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Match extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(lookupValue: BaseValueObject, lookupArray: ArrayValueObject, matchType?: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
     private _getSearchModeValue;

package/lib/types/functions/math/sumproduct/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Sumproduct extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(array1: BaseValueObject, ...variants: BaseValueObject[]): BaseValueObject;
     /**
      * Validate all variants:

package/lib/types/functions/statistical/median/index.d.ts

@@ -18,5 +18,6 @@ import { BaseFunction } from '../../base-function';
 export declare class Median extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(...variants: BaseValueObject[]): BaseValueObject;
 }

package/lib/types/functions/statistical/percentile-exc/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class PercentileExc extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
 }

package/lib/types/functions/statistical/percentile-inc/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class PercentileInc extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(array: BaseValueObject, k: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
 }

package/lib/types/functions/statistical/rank-avg/index.d.ts

@@ -20,6 +20,7 @@ export declare class RankAvg extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(number: FunctionVariantType, ref: FunctionVariantType, order?: FunctionVariantType): BaseValueObject;
     private _getResult;
     private _checkRefReferenceObject;

package/lib/types/functions/statistical/rank-eq/index.d.ts

@@ -20,6 +20,7 @@ export declare class RankEq extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(number: FunctionVariantType, ref: FunctionVariantType, order?: FunctionVariantType): BaseValueObject;
     private _checkRefReferenceObject;
 }

package/lib/types/functions/text/textjoin/index.d.ts

@@ -18,6 +18,7 @@ import { BaseFunction } from '../../base-function';
 export declare class Textjoin extends BaseFunction {
     minParams: number;
     maxParams: number;
+    lazyIfReferenceArrayArgumentIndexes: number[];
     calculate(delimiter: BaseValueObject, ignoreEmpty: BaseValueObject, ...variants: BaseValueObject[]): BaseValueObject;
     private _handleSingleObject;
     private _getDelimiterValues;