@univerjs/engine-formula 0.16.1 → 0.17.0

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

@@ -19,6 +19,7 @@ export declare class LexerTreeBuilder extends Disposable {
     private _upLevel;
     private _segment;
     private _bracketState;
+    private _openBracketNormalIndexStack;
     private _squareBracketState;
     private _bracesState;
     private _singleQuotationState;
@@ -92,6 +93,8 @@ export declare class LexerTreeBuilder extends Disposable {
     private _resetSegment;
     private _openBracket;
     private _closeBracket;
+    private _openBracketNormalIndex;
+    private _getNodesByCurrentBracketNormalIndex;
     private _openSquareBracket;
     private _closeSquareBracket;
     private _getCurrentBracket;

package/lib/types/engine/utils/object-compare.d.ts

@@ -1,5 +1,6 @@
-import { compareToken } from '../../basics/token';
+import { ArrayValueObject } from '../value-object/array-value-object';
 import { BaseValueObject } from '../value-object/base-value-object';
+import { compareToken } from '../../basics/token';
 export declare function findCompareToken(str: string): [compareToken, BaseValueObject];
 /**
  * When it contains both comparison characters and wildcard characters
@@ -10,7 +11,5 @@ export declare function findCompareToken(str: string): [compareToken, BaseValueO
 export declare function valueObjectCompare(range: BaseValueObject, criteria: BaseValueObject, operator?: compareToken, isCaseSensitive?: boolean): BaseValueObject;
 /**
  * Find the Boolean intersection of two ArrayValueObjects
- * @param valueObject1
- * @param valueObject2
  */
-export declare function booleanObjectIntersection(valueObject1: BaseValueObject, valueObject2: BaseValueObject): BaseValueObject;
+export declare function booleanObjectIntersection(valueObject1: ArrayValueObject, valueObject2: ArrayValueObject): ArrayValueObject;

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

@@ -28,23 +28,28 @@ export declare function calculateMaxDimensions(variants: BaseValueObject[]): {
  */
 export declare function parsePairedRangeAndCriteria(variants: FunctionVariantType[], targetRange?: FunctionVariantType): {
     isError: boolean;
-    errorObject: Nullable<ErrorValueObject>;
+    errorObject: ErrorValueObject | null;
     rangeIsDifferentSize: boolean;
     criteriaMaxRowLength: number;
     criteriaMaxColumnLength: number;
-    targetRange: Nullable<BaseValueObject>;
+    targetRange: ArrayValueObject | null;
     variants: BaseValueObject[];
 };
 export declare function baseValueObjectToArrayValueObject(valueObject: BaseValueObject): ArrayValueObject;
-export declare function getBooleanResults(variants: BaseValueObject[], maxRowLength: number, maxColumnLength: number, isNumberSensitive?: boolean): BaseValueObject[][];
 /**
- * Two valueObjects of the same type can be compared
- * @param array
- * @param range
- * @param criteria
- * @returns
+ * Get the paired range and criteria result for COUNTIFS, SUMIFS, etc.
+ */
+export declare function getPairedRangeAndCriteriaResult(variants: BaseValueObject[], params: {
+    formulaName: string;
+    maxRowLength: number;
+    maxColumnLength: number;
+    isNumberSensitive?: boolean;
+    targetRange?: ArrayValueObject;
+}): BaseValueObject[][];
+/**
+ * Two ArrayValueObject of the same type can be compared
  */
-export declare function filterSameValueObjectResult(array: ArrayValueObject, range: ArrayValueObject, criteria: BaseValueObject): BaseValueObject;
+export declare function filterSameValueObjectResult(array: ArrayValueObject, range: ArrayValueObject, criteria: BaseValueObject): ArrayValueObject;
 /**
  * Check if the two valueObjects are of the same type
  * @param left

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

@@ -137,18 +137,18 @@ export declare class ArrayValueObject extends BaseValueObject {
     countBlank(): BaseValueObject;
     getNegative(): BaseValueObject;
     getReciprocal(): BaseValueObject;
-    plus(valueObject: BaseValueObject): BaseValueObject;
-    minus(valueObject: BaseValueObject): BaseValueObject;
-    multiply(valueObject: BaseValueObject): BaseValueObject;
-    divided(valueObject: BaseValueObject): BaseValueObject;
-    mod(valueObject: BaseValueObject): BaseValueObject;
+    plus(valueObject: BaseValueObject): ArrayValueObject;
+    minus(valueObject: BaseValueObject): ArrayValueObject;
+    multiply(valueObject: BaseValueObject): ArrayValueObject;
+    divided(valueObject: BaseValueObject): ArrayValueObject;
+    mod(valueObject: BaseValueObject): ArrayValueObject;
     modInverse(valueObject: BaseValueObject): BaseValueObject;
-    compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): BaseValueObject;
-    concatenateFront(valueObject: BaseValueObject): BaseValueObject;
-    concatenateBack(valueObject: BaseValueObject): BaseValueObject;
+    compare(valueObject: BaseValueObject, operator: compareToken, isCaseSensitive?: boolean): ArrayValueObject;
+    concatenateFront(valueObject: BaseValueObject): ArrayValueObject;
+    concatenateBack(valueObject: BaseValueObject): ArrayValueObject;
     map(callbackFn: callbackMapFnType): BaseValueObject;
-    mapValue(callbackFn: callbackMapFnType): BaseValueObject;
-    pow(valueObject: BaseValueObject): BaseValueObject;
+    mapValue(callbackFn: callbackMapFnType): ArrayValueObject;
+    pow(valueObject: BaseValueObject): ArrayValueObject;
     /**
      *
      * @param valueObject In the case of an inverse, it is certainly not an array.
@@ -169,7 +169,7 @@ export declare class ArrayValueObject extends BaseValueObject {
     tanh(): BaseValueObject;
     atan(): BaseValueObject;
     atanh(): BaseValueObject;
-    atan2(valueObject: BaseValueObject): BaseValueObject;
+    atan2(valueObject: BaseValueObject): ArrayValueObject;
     atan2Inverse(valueObject: BaseValueObject): BaseValueObject;
     mean(ddof?: number): BaseValueObject;
     /**
@@ -211,11 +211,11 @@ export declare class ArrayValueObject extends BaseValueObject {
     log10(): BaseValueObject;
     exp(): BaseValueObject;
     abs(): BaseValueObject;
-    round(valueObject: BaseValueObject): BaseValueObject;
+    round(valueObject: BaseValueObject): ArrayValueObject;
     roundInverse(valueObject: BaseValueObject): BaseValueObject;
-    floor(valueObject: BaseValueObject): BaseValueObject;
+    floor(valueObject: BaseValueObject): ArrayValueObject;
     floorInverse(valueObject: BaseValueObject): BaseValueObject;
-    ceil(valueObject: BaseValueObject): BaseValueObject;
+    ceil(valueObject: BaseValueObject): ArrayValueObject;
     ceilInverse(valueObject: BaseValueObject): BaseValueObject;
     toValue(): (string | number | boolean | null)[][];
     private _clearCache;

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

@@ -1,5 +1,5 @@
-import { FUNCTION_NAMES_FINANCIAL } from './function-names';
 import { Accrint } from './accrint';
+import { FUNCTION_NAMES_FINANCIAL } from './function-names';
 import { Npv } from './npv';
 import { Oddfprice } from './oddfprice';
 import { Oddfyield } from './oddfyield';

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

@@ -1,4 +1,5 @@
 import { Cell } from './cell';
 import { FUNCTION_NAMES_INFORMATION } from './function-names';
 import { Isbetween } from './isbetween';
-export declare const functionInformation: ((FUNCTION_NAMES_INFORMATION | typeof Cell)[] | (FUNCTION_NAMES_INFORMATION | typeof Isbetween)[])[];
+import { Isblank } from './isblank';
+export declare const functionInformation: ((FUNCTION_NAMES_INFORMATION | typeof Cell)[] | (FUNCTION_NAMES_INFORMATION | typeof Isbetween)[] | (FUNCTION_NAMES_INFORMATION | typeof Isblank)[])[];

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { 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): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Iserr extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Iserror extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Islogical extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Isna extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Isnontext extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Isnumber extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,7 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { BooleanValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Istext extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(value: BaseValueObject): BaseValueObject;
+    calculate(value: BaseValueObject): BooleanValueObject | ArrayValueObject;
 }

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

@@ -1,5 +1,6 @@
 import { And } from './and';
 import { FUNCTION_NAMES_LOGICAL } from './function-names';
+import { If } from './if';
 import { Iferror } from './iferror';
 import { Makearray } from './makearray';
-export declare const functionLogical: ((FUNCTION_NAMES_LOGICAL | typeof And)[] | (FUNCTION_NAMES_LOGICAL | typeof Iferror)[] | (FUNCTION_NAMES_LOGICAL | typeof Makearray)[])[];
+export declare const functionLogical: ((FUNCTION_NAMES_LOGICAL | typeof And)[] | (FUNCTION_NAMES_LOGICAL | typeof If)[] | (FUNCTION_NAMES_LOGICAL | typeof Iferror)[] | (FUNCTION_NAMES_LOGICAL | typeof Makearray)[])[];

package/lib/types/functions/logical/if/index.d.ts

@@ -1,8 +1,9 @@
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class If extends BaseFunction {
     minParams: number;
     maxParams: number;
-    calculate(logicalTest: BaseValueObject, valueIfTrue: BaseValueObject, valueIfFalse?: BaseValueObject): BaseValueObject;
+    calculate(logicalTest: BaseValueObject, valueIfTrue: BaseValueObject, valueIfFalse?: BaseValueObject): BaseValueObject | ArrayValueObject;
     private _handleSingleObject;
 }

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

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Choosecols extends BaseFunction {
     minParams: number;

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

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Chooserows extends BaseFunction {
     minParams: number;

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

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Column extends BaseFunction {
     minParams: number;

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

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

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

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

package/lib/types/functions/lookup/formulatext/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 { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Formulatext extends BaseFunction {
@@ -6,5 +7,5 @@ export declare class Formulatext extends BaseFunction {
     maxParams: number;
     needsReferenceObject: boolean;
     needsFormulaDataModel: boolean;
-    calculate(reference: FunctionVariantType): BaseValueObject;
+    calculate(reference: FunctionVariantType): BaseValueObject | ArrayValueObject;
 }

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

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Hstack extends BaseFunction {
     minParams: number;

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

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Row extends BaseFunction {
     minParams: number;

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

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject, ErrorValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Sortby extends BaseFunction {
     minParams: number;

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

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

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

@@ -1,5 +1,5 @@
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Vstack extends BaseFunction {
     minParams: number;

package/lib/types/functions/math/aggregate/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 { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Aggregate extends BaseFunction {
@@ -7,7 +8,7 @@ export declare class Aggregate extends BaseFunction {
     needsReferenceObject: boolean;
     needsFilteredOutRows: boolean;
     needsFormulaDataModel: boolean;
-    calculate(functionNum: FunctionVariantType, options: FunctionVariantType, ...refs: FunctionVariantType[]): BaseValueObject;
+    calculate(functionNum: FunctionVariantType, options: FunctionVariantType, ...refs: FunctionVariantType[]): BaseValueObject | ArrayValueObject;
     private _handleSingleObject;
     private _getAggregateOptions;
     private _handleLargeSmallPercentileQuartile;

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

@@ -1,6 +1,5 @@
 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 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 Sumifs)[])[];

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

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

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

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

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

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

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

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

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

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

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

@@ -1,11 +1,9 @@
 import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
-import { BaseValueObject } from '../../../engine/value-object/base-value-object';
 import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
 import { BaseFunction } from '../../base-function';
 export declare class Sumifs extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
-    calculate(sumRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject | ArrayValueObject;
-    private _aggregateResults;
+    calculate(sumRange: FunctionVariantType, ...variants: FunctionVariantType[]): import('../../..').BaseValueObject | ArrayValueObject;
 }

package/lib/types/functions/meta/compare/index.d.ts

@@ -1,5 +1,5 @@
-import { compareToken } from '../../../basics/token';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
+import { compareToken } from '../../../basics/token';
 import { BaseFunction } from '../../base-function';
 export declare class Compare extends BaseFunction {
     minParams: number;

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

@@ -6,5 +6,4 @@ export declare class Averageifs extends BaseFunction {
     maxParams: number;
     needsReferenceObject: boolean;
     calculate(averageRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject;
-    private _aggregateResults;
 }

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

@@ -1,13 +1,9 @@
 import { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';
 import { BaseValueObject } from '../../../engine/value-object/base-value-object';
-import { ArrayValueObject } from '../../../engine/value-object/array-value-object';
-import { NumberValueObject } from '../../../engine/value-object/primitive-object';
 import { BaseFunction } from '../../base-function';
 export declare class Countifs extends BaseFunction {
     minParams: number;
     maxParams: number;
     needsReferenceObject: boolean;
     calculate(...variants: FunctionVariantType[]): BaseValueObject;
-    private _aggregateResults;
 }
-export declare function countTrueValue(array: ArrayValueObject): NumberValueObject;

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

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

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

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

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

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

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

@@ -6,5 +6,4 @@ export declare class Maxifs extends BaseFunction {
     maxParams: number;
     needsReferenceObject: boolean;
     calculate(maxRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject;
-    private _aggregateResults;
 }

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

@@ -6,5 +6,4 @@ export declare class Minifs extends BaseFunction {
     maxParams: number;
     needsReferenceObject: boolean;
     calculate(minRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject;
-    private _aggregateResults;
 }

package/lib/types/index.d.ts

@@ -41,8 +41,8 @@ export { type ISetImageFormulaDataMutationParams, SetImageFormulaDataMutation }
 export { type IRemoveOtherFormulaMutationParams, type ISetOtherFormulaMutationParams, RemoveOtherFormulaMutation, SetOtherFormulaMutation } from './commands/mutations/set-other-formula.mutation';
 export { RemoveSuperTableMutation, SetSuperTableMutation, SetSuperTableOptionMutation } from './commands/mutations/set-super-table.mutation';
 export type { ISetSuperTableMutationParam, ISetSuperTableMutationSearchParam } from './commands/mutations/set-super-table.mutation';
-export { CalculateController } from './controller/calculate.controller';
-export { ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_PLUGIN_CONFIG_KEY, ENGINE_FORMULA_RETURN_DEPENDENCY_TREE, type IUniverEngineFormulaConfig } from './controller/config.schema';
+export { ENGINE_FORMULA_CYCLE_REFERENCE_COUNT, ENGINE_FORMULA_PLUGIN_CONFIG_KEY, ENGINE_FORMULA_RETURN_DEPENDENCY_TREE, type IUniverEngineFormulaConfig } from './config/config';
+export { CalculateController } from './controllers/calculate.controller';
 export { Lexer } from './engine/analysis/lexer';
 export { LexerNode } from './engine/analysis/lexer-node';
 export { LexerTreeBuilder } from './engine/analysis/lexer-tree-builder';

package/lib/types/plugin.d.ts

@@ -1,10 +1,12 @@
-import { IUniverEngineFormulaConfig } from './controller/config.schema';
+import { IUniverEngineFormulaConfig } from './config/config';
 import { IConfigService, Injector, Plugin } from '@univerjs/core';
 export declare class UniverFormulaEnginePlugin extends Plugin {
     protected readonly _config: Partial<IUniverEngineFormulaConfig>;
     protected _injector: Injector;
     protected readonly _configService: IConfigService;
     static pluginName: string;
+    static packageName: string;
+    static version: string;
     constructor(_config: Partial<IUniverEngineFormulaConfig> | undefined, _injector: Injector, _configService: IConfigService);
     onStarting(): void;
     onReady(): void;