@univerjs/engine-formula 0.10.14-nightly.202511080715 → 0.11.0-nightly.202511151013

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

@@ -1,4 +1,4 @@
-import { BooleanNumber, ICellData, IColumnData, IObjectArrayPrimitiveType, IObjectMatrixPrimitiveType, IRange, IRowData, IUnitRange, Nullable, ObjectMatrix, Styles } from '@univerjs/core';
+import { ICellData, IColumnData, IObjectArrayPrimitiveType, IObjectMatrixPrimitiveType, IRange, IRowData, IUnitRange, Nullable, ObjectMatrix, Styles } from '@univerjs/core';
 export declare const ERROR_VALUE_OBJECT_CLASS_TYPE = "errorValueObject";
 export declare const ASYNC_OBJECT_CLASS_TYPE = "asyncObject";
 export declare const REFERENCE_OBJECT_CLASS_TYPE = "referenceObject";
@@ -92,6 +92,11 @@ export interface IArrayFormulaRangeType {
         [sheetId: string]: IObjectMatrixPrimitiveType<IRange>;
     }>;
 }
+export interface IArrayFormulaEmbeddedMap {
+    [unitId: string]: Nullable<{
+        [sheetId: string]: IObjectMatrixPrimitiveType<boolean>;
+    }>;
+}
 export interface IFeatureDirtyRangeType {
     [unitId: string]: Nullable<{
         [sheetId: string]: IRange[];
@@ -139,7 +144,6 @@ export interface IOtherFormulaDataItem {
 }
 export interface ISuperTable {
     sheetId: string;
-    hasCustomTitle: BooleanNumber;
     titleMap: Map<string, number>;
     range: IRange;
 }
@@ -147,7 +151,8 @@ export declare enum TableOptionType {
     ALL = "#All",
     DATA = "#Data",
     HEADERS = "#Headers",
-    TOTALS = "#Totals"
+    TOTALS = "#Totals",
+    THIS_ROW = "#This Row"
 }
 export interface IUnitExcludedCell {
     [unitId: string]: Nullable<{

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

@@ -86,7 +86,11 @@ export declare enum FunctionType {
     /**
      * Defined name
      */
-    DefinedName = 16
+    DefinedName = 16,
+    /**
+     * Super Table name
+     */
+    Table = 17
 }
 export interface IFunctionParam {
     /**

package/lib/types/basics/inverted-index-cache.d.ts

@@ -1,4 +1,5 @@
 import { NumericTuple } from '@flatten-js/interval-tree';
+export declare const DEFAULT_EMPTY_CELL_KEY: unique symbol;
 export declare class InvertedIndexCache {
     /**
      * {
@@ -14,9 +15,9 @@ export declare class InvertedIndexCache {
      */
     private _cache;
     private _continueBuildingCache;
-    set(unitId: string, sheetId: string, column: number, value: string | number | boolean | null, row: number, isForceUpdate?: boolean): void;
-    getCellValuePositions(unitId: string, sheetId: string, column: number): Map<string | number | boolean | null, Set<number>> | undefined;
-    getCellPositions(unitId: string, sheetId: string, column: number, value: string | number | boolean, rowsInCache: NumericTuple[]): number[] | undefined;
+    set(unitId: string, sheetId: string, column: number, value: string | number | boolean | null | symbol, row: number, isForceUpdate?: boolean): void;
+    getCellValuePositions(unitId: string, sheetId: string, column: number): Map<string | number | boolean | symbol | null, Set<number>> | undefined;
+    getCellPositions(unitId: string, sheetId: string, column: number, value: string | number | boolean | null | symbol, rowsInCache: NumericTuple[]): number[] | undefined;
     setContinueBuildingCache(unitId: string, sheetId: string, column: number, startRow: number, endRow: number): void;
     shouldContinueBuildingCache(unitId: string, sheetId: string, column: number, row: number): boolean;
     canUseCache(unitId: string, sheetId: string, column: number, rangeStartRow: number, rangeEndRow: number): {

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

@@ -35,7 +35,12 @@ export declare const REFERENCE_REGEX_SINGLE_COLUMN_PRECOMPILING: RegExp;
 export declare const REFERENCE_TABLE_ALL_COLUMN_REGEX = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\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 = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\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 = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\u2019\uFF0C\u3002\u3001\u2018\uFF1A\u201C\u300A\u300B\uFF1F~\uFF01@#\uFFE5%\u2026\u2026\uFF08\uFF09\u3010\u3011\\[\\]\\/\\\\]).)+(\\[\\[((?<!#).)*\\]\\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 SUPER_TABLE_COLUMN_REGEX = "[.*?]";
+export declare const REFERENCE_TABLE_TITLE_ONLY_ANY_HASH_REGEX = "^(\\[([^\\[\\]\\/?:\"<>|*\\\\]+)\\])?((?![~!@#$%^&*()_+<>?:,./;\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;
+export declare const REFERENCE_TABLE_TITLE_ONLY_ANY_HASH_REGEX_PRECOMPILING: RegExp;
+export declare const SUPER_TABLE_COLUMN_REGEX = "\\[[^\\]]*?]";
 export declare const SUPER_TABLE_COLUMN_REGEX_PRECOMPILING: RegExp;
 export declare const ARRAY_VALUE_REGEX = "{.*?}";
 export declare const ARRAY_VALUE_REGEX_PRECOMPILING: RegExp;
@@ -46,5 +51,9 @@ export declare function regexTestColumn(token: string): boolean;
 export declare function regexTestSingleRow(token: string): boolean;
 export declare function regexTestSingleColumn(token: string): boolean;
 export declare function regexTestSuperTableColumn(token: string): boolean;
+export declare function regexTestReferenceTableAllColumn(token: string): boolean;
+export declare function regexTestReferenceTableSingleColumn(token: string): boolean;
+export declare function regexTestReferenceTableMultipleColumn(token: string): boolean;
+export declare function regexTestReferenceTableTitleOnlyAnyHash(token: string): boolean;
 export declare function regexTestArrayValue(token: string): boolean;
 export declare function isReferenceString(refString: string): boolean;

package/lib/types/commands/mutations/set-array-formula-data.mutation.d.ts

@@ -1,8 +1,9 @@
 import { IMutation } from '@univerjs/core';
-import { IArrayFormulaRangeType, IArrayFormulaUnitCellType } from '../../basics/common';
+import { IArrayFormulaEmbeddedMap, IArrayFormulaRangeType, IArrayFormulaUnitCellType } from '../../basics/common';
 export interface ISetArrayFormulaDataMutationParams {
     arrayFormulaRange: IArrayFormulaRangeType;
     arrayFormulaCellData: IArrayFormulaUnitCellType;
+    arrayFormulaEmbedded: IArrayFormulaEmbeddedMap;
 }
 /**
  * There is no need to process data here, it is used as the main thread to send data to the worker. The main thread has already updated the data in advance, and there is no need to update it again here.

package/lib/types/commands/mutations/set-defined-name.mutation.d.ts

@@ -9,6 +9,7 @@ export interface ISetDefinedNameMutationParam extends ISetDefinedNameMutationSea
     comment?: string;
     localSheetId?: string;
     hidden?: boolean;
+    formulaOrRefStringWithPrefix?: string;
 }
 /**
  * Generate undo mutation of a `SetDefinedNameMutation`

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

@@ -1,5 +1,6 @@
 import { Nullable, AbsoluteRefType, Disposable } from '@univerjs/core';
 import { IDirtyUnitSheetDefinedNameMap } from '../../basics/common';
+import { IFunctionNames } from '../../basics/function';
 import { IDefinedNamesServiceParam } from '../../services/defined-names.service';
 import { ISequenceArray, ISequenceNode } from '../utils/sequence';
 import { FormulaAstLRU } from '../../basics/cache-lru';
@@ -137,5 +138,6 @@ export declare class LexerTreeBuilder extends Disposable {
     private _nodeMaker;
     private _isScientificNotation;
     private _addSequenceArray;
+    getNewFormulaWithPrefix(formulaString: string, hasFunction: (functionToken: IFunctionNames) => boolean): string | null;
 }
 export {};

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

@@ -23,6 +23,7 @@ export declare class BaseAstNode {
     constructor(_token: string);
     dispose(): void;
     get nodeType(): NodeType;
+    resetCalculationState(): void;
     isAsync(): boolean;
     isAddress(): boolean;
     isForcedCalculateFunction(): boolean;

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

@@ -21,6 +21,10 @@ export declare class FunctionNode extends BaseAstNode {
     executeAsync(): Promise<AstNodePromiseType>;
     execute(): void;
     isFunctionExecutorArgumentsIgnoreNumberPattern(): boolean;
+    /**
+     * If it contains an array formula, set the current cell to the cache and send itself as a ref outward
+     */
+    private _setEmbeddedArrayFormulaToResult;
     /**
      * Compatibility handling for special functions.
      */

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

@@ -8,8 +8,9 @@ export declare class LambdaNode extends BaseAstNode {
     private _lambdaId;
     private _interpreter;
     private _lambdaPrivacyVarKeys;
+    private _runtimeService;
     private _isNotEmpty;
-    constructor(token: string, _lambdaId: string, _interpreter: Interpreter, _lambdaPrivacyVarKeys: string[]);
+    constructor(token: string, _lambdaId: string, _interpreter: Interpreter, _lambdaPrivacyVarKeys: string[], _runtimeService: IFormulaRuntimeService);
     get nodeType(): NodeType;
     setNotEmpty(state?: boolean): void;
     isEmptyParamFunction(): boolean;

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

@@ -1,18 +1,25 @@
 import { BaseFunction } from '../../functions/base-function';
 import { IFunctionService } from '../../services/function.service';
+import { IFormulaRuntimeService } from '../../services/runtime.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 OperatorNode extends BaseAstNode {
     private _functionExecutor;
-    constructor(operatorString: string, _functionExecutor: BaseFunction);
+    private _runtimeService;
+    constructor(operatorString: string, _functionExecutor: BaseFunction, _runtimeService: IFormulaRuntimeService);
     get nodeType(): NodeType;
     execute(): void;
+    /**
+     * If it contains an array formula, set the current cell to the cache and send itself as a ref outward
+     */
+    private _setEmbeddedArrayFormulaToResult;
 }
 export declare class OperatorNodeFactory extends BaseAstNodeFactory {
     private readonly _functionService;
-    constructor(_functionService: IFunctionService);
+    private readonly _runtimeService;
+    constructor(_functionService: IFunctionService, _runtimeService: IFormulaRuntimeService);
     get zIndex(): number;
     create(param: string): BaseAstNode;
     checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined;

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

@@ -1,7 +1,9 @@
 import { IFormulaCurrentConfigService } from '../../services/current-data.service';
 import { IFunctionService } from '../../services/function.service';
 import { IFormulaRuntimeService } from '../../services/runtime.service';
+import { ISuperTableService } from '../../services/super-table.service';
 import { LexerNode } from '../analysis/lexer-node';
+import { TableReferenceObject } from '../reference-object/table-reference-object';
 import { ReferenceObjectType } from '../utils/value-object';
 import { BaseAstNode } from './base-ast-node';
 import { BaseAstNodeFactory } from './base-ast-node-factory';
@@ -11,9 +13,10 @@ export declare class ReferenceNode extends BaseAstNode {
     private _runtimeService;
     private _referenceObjectType;
     private _isPrepareMerge;
+    private _tableReferenceObject?;
     private _refOffsetX;
     private _refOffsetY;
-    constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, operatorString: string, _referenceObjectType: ReferenceObjectType, _isPrepareMerge?: boolean);
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _runtimeService: IFormulaRuntimeService, operatorString: string, _referenceObjectType: ReferenceObjectType, _isPrepareMerge?: boolean, _tableReferenceObject?: TableReferenceObject | undefined);
     get nodeType(): NodeType;
     execute(): void;
     setRefOffset(x?: number, y?: number): void;
@@ -26,8 +29,14 @@ export declare class ReferenceNodeFactory extends BaseAstNodeFactory {
     private readonly _currentConfigService;
     private readonly _formulaRuntimeService;
     private readonly _functionService;
-    constructor(_currentConfigService: IFormulaCurrentConfigService, _formulaRuntimeService: IFormulaRuntimeService, _functionService: IFunctionService);
+    private readonly _superTableService;
+    constructor(_currentConfigService: IFormulaCurrentConfigService, _formulaRuntimeService: IFormulaRuntimeService, _functionService: IFunctionService, _superTableService: ISuperTableService);
     get zIndex(): number;
     checkAndCreateNodeType(param: LexerNode | string): ReferenceNode | undefined;
+    private _getTableMap;
+    private _getNode;
+    private _getTableReferenceNode;
+    private _splitTableStructuredRef;
+    private _checkTokenIsTableReference;
     private _checkParentIsUnionOperator;
 }

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

@@ -4,7 +4,6 @@ import { BaseValueObject } from '../value-object/base-value-object';
 import { FormulaAstLRU } from '../../basics/cache-lru';
 import { ObjectClassType } from '../../basics/object-class-type';
 import { ArrayValueObject } from '../value-object/array-value-object';
-import { StringValueObject } from '../value-object/primitive-object';
 export type NodeValueType = BaseValueObject | BaseReferenceObject | AsyncObject | AsyncArrayObject;
 export type FunctionVariantType = BaseValueObject | BaseReferenceObject;
 export declare const FORMULA_REF_TO_ARRAY_CACHE: FormulaAstLRU<ArrayValueObject>;
@@ -25,6 +24,8 @@ export declare class BaseReferenceObject extends ObjectClassType {
     private _runtimeFeatureCellData;
     private _refOffsetX;
     private _refOffsetY;
+    private _currentRow?;
+    private _currentColumn?;
     constructor(_token: string);
     dispose(): void;
     getToken(): string;
@@ -48,7 +49,7 @@ export declare class BaseReferenceObject extends ObjectClassType {
     };
     isReferenceObject(): boolean;
     iterator(callback: (valueObject: Nullable<BaseValueObject>, rowIndex: number, columnIndex: number) => Nullable<boolean>): Nullable<boolean>;
-    getFirstCell(): BaseValueObject | StringValueObject;
+    getFirstCell(): BaseValueObject;
     getRangeData(): IRange;
     setRangeData(range: IRange): void;
     getUnitId(): string;
@@ -93,12 +94,15 @@ export declare class BaseReferenceObject extends ObjectClassType {
     isRow(): boolean;
     isRange(): boolean;
     isTable(): boolean;
+    isCurrentRowForRange(): boolean;
+    isCurrentColumnForRange(): boolean;
+    isMultiArea(): boolean;
     unionBy(referenceObject: BaseReferenceObject): NodeValueType;
     unionRange(rangeData1: IRange, rangeData2: IRange): IRange;
-    getCellValueObject(cell: ICellData): BaseValueObject | StringValueObject;
+    getCellValueObject(cell: ICellData): BaseValueObject;
     private _getPatternByCell;
-    getCellByRow(row: number): BaseValueObject | StringValueObject;
-    getCellByColumn(column: number): BaseValueObject | StringValueObject;
+    getCellByRow(row: number): BaseValueObject;
+    getCellByColumn(column: number): BaseValueObject;
     getCurrentActiveSheetData(): import('../../basics/common').ISheetItem;
     getCurrentStylesData(): import('@univerjs/core').Styles;
     getCurrentRuntimeSheetData(): import('@univerjs/core').ObjectMatrix<Nullable<ICellData>> | undefined;
@@ -106,7 +110,10 @@ export declare class BaseReferenceObject extends ObjectClassType {
     getCurrentRuntimeActiveArrayFormulaCellData(): import('@univerjs/core').ObjectMatrix<Nullable<ICellData>> | undefined;
     getCellData(row: number, column: number): Nullable<ICellData>;
     getRuntimeFeatureCellValue(row: number, column: number): ICellData | undefined;
-    getCellByPosition(rowRaw?: number, columnRaw?: number): BaseValueObject | StringValueObject;
+    getCellByPosition(rowRaw?: number, columnRaw?: number): BaseValueObject;
+    setCurrentRowAndColumn(row: number, column: number): void;
+    getCurrentRow(): number | undefined;
+    getCurrentColumn(): number | undefined;
     /**
      * Get the pattern of the cell
      * @param unitId

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

@@ -0,0 +1,92 @@
+import { Nullable } from '@univerjs/core';
+import { ArrayValueObject } from '../value-object/array-value-object';
+import { BaseValueObject, ErrorValueObject } from '../value-object/base-value-object';
+import { BaseReferenceObject } from './base-reference-object';
+export type MultiAreaValue = BaseReferenceObject | ErrorValueObject;
+export declare class MultiAreaReferenceObject extends BaseReferenceObject {
+    /**
+     * 2D structure:
+     * - First dimension: stored by rows
+     * - Second dimension: each AreaValue within that row
+     */
+    private _areas;
+    constructor(token: string, areas?: MultiAreaValue[][]);
+    dispose(): void;
+    getAreas(): MultiAreaValue[][];
+    setAreas(areas: MultiAreaValue[][]): void;
+    /**
+     * Append an area:
+     * - If a single AreaValue is passed, it will be wrapped as one row.
+     * - If an AreaValue[] is passed, it will be inserted as an entire row.
+     */
+    addArea(area: MultiAreaValue | MultiAreaValue[]): void;
+    /** Flatten the 2D areas to reuse 1D logic */
+    private _flatAreas;
+    isMultiArea(): boolean;
+    isRange(): boolean;
+    isCell(): boolean;
+    isRow(): boolean;
+    isColumn(): boolean;
+    getRowCount(): number;
+    getColumnCount(): number;
+    isExceedRange(): boolean;
+    setRefOffset(x?: number, y?: number): void;
+    private _getReferenceArea;
+    /**
+     * Multi-area reference may span multiple sheets, but Excel requires
+     * them to be in the same sheet for most functions. We follow Excel semantics
+     * by returning the first area’s identifiers.
+     */
+    getUnitId(): string;
+    getSheetId(): string;
+    getActiveSheetRowCount(): number;
+    getActiveSheetColumnCount(): number;
+    /**
+     * Iterate through all areas in order, flattening the multi-area into
+     * a sequence of cells.
+     *
+     * Note: The order here is "row-major":
+     *   iterate by the row order of _areas, then within each row by the area order.
+     */
+    iterator(callback: (v: Nullable<BaseValueObject>, row: number, col: number) => Nullable<boolean>): void;
+    /**
+     * Excel defines the "first cell" of a multi-area reference
+     * as the first cell of the first area.
+     */
+    getFirstCell(): BaseValueObject;
+    /**
+     * For multi-area, we only take the *first cell* of each area and
+     * arrange them into a 2D ArrayValueObject:
+     *
+     * - outer `_areas` dimension => rows
+     * - inner `_areas[row]` dimension => columns
+     */
+    toArrayValueObject(): ArrayValueObject;
+    getRangePosition(): {
+        startRow: number;
+        endRow: number;
+        startColumn: number;
+        endColumn: number;
+        rangeType?: import('@univerjs/core').RANGE_TYPE;
+        startAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+        endAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+        unitId?: string;
+        sheetId?: string;
+    };
+    toUnitRange(): {
+        range: {
+            startRow: number;
+            endRow: number;
+            startColumn: number;
+            endColumn: number;
+            rangeType?: import('@univerjs/core').RANGE_TYPE;
+            startAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+            endAbsoluteRefType?: import('@univerjs/core').AbsoluteRefType;
+            unitId?: string;
+            sheetId?: string;
+        };
+        sheetId: string;
+        unitId: string;
+    };
+    getRangeData(): import('@univerjs/core').IRange;
+}

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

@@ -1,10 +1,92 @@
-import { ISuperTable, TableOptionType } from '../../basics/common';
+import { ISuperTable, IUnitSheetNameMap, TableOptionType } from '../../basics/common';
 import { BaseReferenceObject } from './base-reference-object';
+/**
+ * Table reference object compatible with Excel Structured References
+ *
+ * Supported (examples):
+ * - =Table[Column]                          // Single column (default DATA)
+ * - =Table[[ColumnA]:[ColumnB]]             // Column range (default DATA)
+ * - =Table[#All] / [#Data] / [#Headers] / [#Totals] / [#This Row]
+ * - =Table[[#All],[Column]]                 // Section + column/column range
+ * - =Table[[#Data],[ColA]:[ColB]]
+ * - =Table[[#This Row],[Column]]
+ *
+ * Not supported (invalid):
+ * - Multiple sections in parallel (e.g., [[#Headers],[#Data]])
+ * - Non-existent sections (e.g., #Title)
+ * - Column indices instead of column names (e.g., [[1]:[3]])
+ */
 export declare class TableReferenceObject extends BaseReferenceObject {
     private _tableData;
+    /**
+     * Structured reference body (with or without outer []):
+     *  - "#Data" / "#All"
+     *  - "[Col]" / "[[ColA]:[ColB]]"
+     *  - "[[#Data],[Col]]" / "[[#All],[ColA]:[ColB]]"
+     */
     private _columnDataString;
-    constructor(token: string, _tableData: ISuperTable, _columnDataString: string, tableOptionMap: Map<string, TableOptionType>);
+    /** Section text to enum mapping ('#All', '#Data', '#Headers', '#Totals', '#This Row') */
+    private _tableOptionMap;
+    private _isCurrentRowForRange;
+    constructor(token: string, _tableData: ISuperTable, 
+    /**
+     * Structured reference body (with or without outer []):
+     *  - "#Data" / "#All"
+     *  - "[Col]" / "[[ColA]:[ColB]]"
+     *  - "[[#Data],[Col]]" / "[[#All],[ColA]:[ColB]]"
+     */
+    _columnDataString: string | undefined, 
+    /** Section text to enum mapping ('#All', '#Data', '#Headers', '#Totals', '#This Row') */
+    _tableOptionMap: Map<string, TableOptionType>);
+    getRangeData(): import('@univerjs/core').IRange;
+    getRefOffset(): {
+        x: number;
+        y: number;
+    };
     isTable(): boolean;
-    private _stringToColumnData;
-    private _columnHandler;
+    isCurrentRowForRange(): boolean;
+    setForcedSheetId(sheetNameMap: IUnitSheetNameMap): void;
+    /**
+     * Parse structured reference body, returning column range and Section type.
+     * Determination rules:
+     *  - Whether it's a Section depends on "whether it starts with # after stripping", not whether it still has brackets.
+     *  - No comma: Either Section, or column/column range
+     *  - Has comma: Left is Section, right is column/column range
+     */
+    private _parseStructuredRef;
+    /** Strip one layer of outer brackets from "[...]" (return as-is if none) */
+    private _stripOuterBracketOnce;
+    /**
+     * Find first comma at depth=0 (used to split Section and column parts)
+     * Compatible with nesting like "[[#Data],[ColA]:[ColB]]".
+     */
+    private _findCommaAtTopLevel;
+    /**
+     * Parse Section, compatible with both "[#Data]" and "#Data" inputs
+     * Returns TableOptionType if matched; returns DATA if not (could throw error instead)
+     */
+    private _parseSectionMaybeBracketed;
+    /**
+     * Section mapping: Only accepts keywords starting with #.
+     * Returns undefined if not a valid Section (caller treats as column or fallback).
+     */
+    private _mapSection;
+    /**
+     * Parse column selection:
+     * - "[Col]" / "Col"               => Single column
+     * - "[[ColA]:[ColB]]" / "[ColA]:[ColB]" / "ColA:ColB"  => Column range
+     *
+     * Rules:
+     * - First find colon at top level, strip one layer of brackets from left and right sides (if present)
+     * - Returns -1 if column name not found (caller should handle as parse error)
+     */
+    private _parseColumnOrRange;
+    /** Strip one layer of outer brackets; return as-is if none (compatible with "[Col]" and "Col") */
+    private _stripOuterBracketIfAny;
+    /** Find range colon at depth=0 */
+    private _findColonAtTopLevel;
+    /** Column title → column index; returns -1 if not found (caller should handle as parse error) */
+    private _titleToIndex;
+    /** Resolve #This Row's row number; takes first data row (tableStartRow+1) when no context available */
+    private _resolveThisRow;
 }

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

@@ -40,6 +40,7 @@ export declare class BaseValueObject extends ObjectClassType {
     isNumber(): boolean;
     isBoolean(): boolean;
     isLambda(): boolean;
+    isDateFormat(): boolean;
     isError(): boolean;
     isNull(): boolean;
     isHyperlink(): boolean;
@@ -82,7 +83,7 @@ export declare class BaseValueObject extends ObjectClassType {
     multiplyBy(value: string | number | boolean): BaseValueObject;
     dividedBy(value: string | number | boolean): BaseValueObject;
     modInverse(valueObject: BaseValueObject): BaseValueObject;
-    compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
+    compareBy(value: string | number | boolean, operator: compareToken, isDateCompare?: boolean): BaseValueObject;
     concatenate(value: string | number | boolean, concatenateType?: ConcatenateType): string;
     pow(valueObject: BaseValueObject): BaseValueObject;
     powInverse(valueObject: BaseValueObject): BaseValueObject;

package/lib/types/engine/value-object/primitive-object.d.ts

@@ -111,12 +111,13 @@ export declare class NumberValueObject extends BaseValueObject {
     mod(valueObject: BaseValueObject): BaseValueObject;
     concatenateFront(valueObject: BaseValueObject): BaseValueObject;
     concatenateBack(valueObject: BaseValueObject): BaseValueObject;
+    isDateFormat(): boolean;
     compare(valueObject: BaseValueObject, operator: compareToken): BaseValueObject;
     plusBy(value: string | number | boolean): BaseValueObject;
     minusBy(value: string | number | boolean): BaseValueObject;
     multiplyBy(value: string | number | boolean): BaseValueObject;
     dividedBy(value: string | number | boolean): BaseValueObject;
-    compareBy(value: string | number | boolean, operator: compareToken): BaseValueObject;
+    compareBy(valueRaw: string | number | boolean, operator: compareToken, isDateCompare?: boolean): BaseValueObject;
     private _compareString;
     private _compareNumber;
     private _compareFiniteNumber;

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

@@ -1,11 +1,10 @@
 import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
-import { StringValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Cell extends BaseFunction {
     needsReferenceObject: boolean;
     minParams: number;
     maxParams: number;
-    calculate(infoType: FunctionVariantType, reference: FunctionVariantType): StringValueObject | FunctionVariantType;
+    calculate(infoType: FunctionVariantType, reference: FunctionVariantType): FunctionVariantType;
     private _handleSingleObject;
     private _getWidthResult;
 }

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

@@ -1,5 +1,5 @@
-import { BaseFunction } from '../../base-function';
 import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { BaseFunction } from '../../base-function';
 export declare class Offset extends BaseFunction {
     minParams: number;
     maxParams: number;

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

@@ -1,9 +1,8 @@
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { StringValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Base extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(number: BaseValueObject, radix: BaseValueObject, minLength?: BaseValueObject): BaseValueObject | StringValueObject;
+    calculate(number: BaseValueObject, radix: BaseValueObject, minLength?: BaseValueObject): BaseValueObject;
     private _handleSingleObject;
 }

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

@@ -1,7 +1,6 @@
-import { Base } from './base';
 import { FUNCTION_NAMES_MATH } from './function-names';
 import { Product } from './product';
 import { Randarray } from './randarray';
 import { Subtotal } from './subtotal';
 import { Sumifs } from './sumifs';
-export declare const functionMath: ((FUNCTION_NAMES_MATH | typeof Base)[] | (FUNCTION_NAMES_MATH | typeof Product)[] | (FUNCTION_NAMES_MATH | typeof Randarray)[] | (FUNCTION_NAMES_MATH | typeof Subtotal)[] | (FUNCTION_NAMES_MATH | typeof Sumifs)[])[];
+export declare const functionMath: ((FUNCTION_NAMES_MATH | typeof Product)[] | (FUNCTION_NAMES_MATH | typeof Randarray)[] | (FUNCTION_NAMES_MATH | typeof Subtotal)[] | (FUNCTION_NAMES_MATH | typeof Sumifs)[])[];

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

@@ -1,4 +1,5 @@
 import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Subtotal extends BaseFunction {
     minParams: number;
@@ -6,7 +7,7 @@ export declare class Subtotal extends BaseFunction {
     needsReferenceObject: boolean;
     needsFilteredOutRows: boolean;
     needsFormulaDataModel: boolean;
-    calculate(functionNum: FunctionVariantType, ...refs: FunctionVariantType[]): FunctionVariantType;
+    calculate(functionNum: FunctionVariantType, ...refs: FunctionVariantType[]): ArrayValueObject | FunctionVariantType;
     private _handleSingleObject;
     private _getIndexNumValue;
     private _average;

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

@@ -4,6 +4,27 @@ export declare class Sumproduct extends BaseFunction {
     minParams: number;
     maxParams: number;
     calculate(array1: BaseValueObject, ...variants: BaseValueObject[]): BaseValueObject;
+    /**
+     * Validate all variants:
+     * - propagate first error BaseValueObject
+     * - ensure array dimensions are compatible with base (rowCount/columnCount)
+     * Returns an ErrorValueObject / BaseValueObject on failure, or null when OK.
+     */
+    private _validateVariants;
+    /**
+     * Core SUMPRODUCT loop.
+     * - baseArray already contains numeric values from array1
+     * - variants may be scalar or array; non-number cells are treated as 0
+     * - any error cell short-circuits with that error
+     */
+    private _sumProduct;
+    /**
+     * Get the value object of a variant at (r, c).
+     * - For scalar variants, returns the variant itself.
+     * - For array variants, returns the cell at (r, c).
+     *   If cell does not exist, returns null and let caller convert to #VALUE!.
+     */
+    private _getVariantCell;
     private _initArray1;
     private _getResultArrayByArray1;
 }

package/lib/types/functions/new-excel-functions.d.ts

@@ -0,0 +1,2 @@
+import { IFunctionNames } from '../basics/function';
+export declare const NEW_EXCEL_FUNCTIONS: Set<IFunctionNames>;

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

@@ -1,7 +1,6 @@
-import { Concat } from './concat';
 import { Concatenate } from './concatenate';
 import { FUNCTION_NAMES_TEXT } from './function-names';
 import { Textafter } from './textafter';
 import { Textbefore } from './textbefore';
 import { Textsplit } from './textsplit';
-export declare const functionText: ((FUNCTION_NAMES_TEXT | typeof Concat)[] | (FUNCTION_NAMES_TEXT | typeof Concatenate)[] | (FUNCTION_NAMES_TEXT | typeof Textafter)[] | (FUNCTION_NAMES_TEXT | typeof Textbefore)[] | (FUNCTION_NAMES_TEXT | typeof Textsplit)[])[];
+export declare const functionText: ((FUNCTION_NAMES_TEXT | typeof Concatenate)[] | (FUNCTION_NAMES_TEXT | typeof Textafter)[] | (FUNCTION_NAMES_TEXT | typeof Textbefore)[] | (FUNCTION_NAMES_TEXT | typeof Textsplit)[])[];