@univerjs/engine-formula 0.22.1 → 0.23.0-insiders.20260522-ee0b0a4

package/lib/cjs/index.js

@@ -27,9 +27,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 //#endregion
 let _univerjs_core = require("@univerjs/core");
-let rxjs = require("rxjs");
 let _flatten_js_interval_tree = require("@flatten-js/interval-tree");
 _flatten_js_interval_tree = __toESM(_flatten_js_interval_tree);
+let rxjs = require("rxjs");
 let decimal_js = require("decimal.js");
 decimal_js = __toESM(decimal_js);
 let _univerjs_rpc = require("@univerjs/rpc");
@@ -1132,6 +1132,181 @@ let FunctionType = /* @__PURE__ */ function(FunctionType) {
 	return FunctionType;
 }({});
 
+//#endregion
+//#region src/basics/inverted-index-cache.ts
+const DEFAULT_EMPTY_CELL_KEY = Symbol("EMPTY_CELL");
+const normalizedValueMap = /* @__PURE__ */ new Map();
+function normalizeValue(value) {
+	if (normalizedValueMap.has(value)) return normalizedValueMap.get(value);
+	let _value;
+	if (value === null || value === void 0 || value === "") _value = DEFAULT_EMPTY_CELL_KEY;
+	else if ((0, _univerjs_core.isRealNum)(value) && Number(value).toString() === value.toString()) _value = Number(value) === 0 ? 0 : Number(value);
+	else if (typeof value === "string") _value = value.toLowerCase();
+	else _value = value;
+	normalizedValueMap.set(value, _value);
+	return _value;
+}
+var InvertedIndexCache = class {
+	constructor() {
+		_defineProperty(this, "_cache", /* @__PURE__ */ new Map());
+		_defineProperty(this, "_continueBuildingCache", /* @__PURE__ */ new Map());
+	}
+	set(unitId, sheetId, column, value, row, isForceUpdate = false) {
+		if (!this.shouldContinueBuildingCache(unitId, sheetId, column, row) && !isForceUpdate) return;
+		let unitMap = this._cache.get(unitId);
+		if (unitMap == null) {
+			unitMap = /* @__PURE__ */ new Map();
+			this._cache.set(unitId, unitMap);
+		}
+		let sheetMap = unitMap.get(sheetId);
+		if (sheetMap == null) {
+			sheetMap = /* @__PURE__ */ new Map();
+			unitMap.set(sheetId, sheetMap);
+		}
+		let columnMap = sheetMap.get(column);
+		if (columnMap == null) {
+			columnMap = /* @__PURE__ */ new Map();
+			sheetMap.set(column, columnMap);
+		}
+		if (isForceUpdate) {
+			for (const [_, _cellList] of columnMap) if (_cellList.has(row)) {
+				_cellList.delete(row);
+				break;
+			}
+		}
+		const _value = normalizeValue(value);
+		let cellList = columnMap.get(_value);
+		if (cellList == null) {
+			cellList = /* @__PURE__ */ new Set();
+			columnMap.set(_value, cellList);
+		}
+		cellList.add(row);
+	}
+	getCellValuePositions(unitId, sheetId, column) {
+		var _this$_cache$get;
+		return (_this$_cache$get = this._cache.get(unitId)) === null || _this$_cache$get === void 0 || (_this$_cache$get = _this$_cache$get.get(sheetId)) === null || _this$_cache$get === void 0 ? void 0 : _this$_cache$get.get(column);
+	}
+	getCellPositions(unitId, sheetId, column, value, rowsInCache) {
+		var _this$_cache$get2;
+		const columnMap = (_this$_cache$get2 = this._cache.get(unitId)) === null || _this$_cache$get2 === void 0 || (_this$_cache$get2 = _this$_cache$get2.get(sheetId)) === null || _this$_cache$get2 === void 0 ? void 0 : _this$_cache$get2.get(column);
+		if (!columnMap) return;
+		const result = {
+			errorType: null,
+			matchingRows: []
+		};
+		const _value = normalizeValue(value);
+		if (ERROR_TYPE_SET.has(_value)) result.errorType = _value;
+		else if (_value === 0 || _value === DEFAULT_EMPTY_CELL_KEY) {
+			const rows = [];
+			const rowsForZero = columnMap.get(0);
+			if (rowsForZero) rows.push(...rowsForZero);
+			const rowsForEmpty = columnMap.get(DEFAULT_EMPTY_CELL_KEY);
+			if (rowsForEmpty) rows.push(...rowsForEmpty);
+			result.matchingRows = rows.filter((row) => rowsInCache.some(([start, end]) => row >= start && row <= end));
+		} else {
+			var _columnMap$get;
+			result.matchingRows = Array.from((_columnMap$get = columnMap.get(_value)) !== null && _columnMap$get !== void 0 ? _columnMap$get : []).filter((row) => rowsInCache.some(([start, end]) => row >= start && row <= end));
+		}
+		return result;
+	}
+	setContinueBuildingCache(unitId, sheetId, column, startRow, endRow) {
+		if (column === -1 || startRow === -1 || endRow === -1) return;
+		let unitMap = this._continueBuildingCache.get(unitId);
+		if (unitMap == null) {
+			unitMap = /* @__PURE__ */ new Map();
+			this._continueBuildingCache.set(unitId, unitMap);
+		}
+		let sheetMap = unitMap.get(sheetId);
+		if (sheetMap == null) {
+			sheetMap = /* @__PURE__ */ new Map();
+			unitMap.set(sheetId, sheetMap);
+		}
+		let columnMap = sheetMap.get(column);
+		if (columnMap == null) {
+			columnMap = new _flatten_js_interval_tree.default();
+			columnMap.insert([startRow, endRow]);
+			sheetMap.set(column, columnMap);
+			return;
+		}
+		this._handleNewInterval(columnMap, startRow, endRow);
+	}
+	shouldContinueBuildingCache(unitId, sheetId, column, row) {
+		var _this$_continueBuildi;
+		if (column === -1 || row === -1) return false;
+		const columnMap = (_this$_continueBuildi = this._continueBuildingCache.get(unitId)) === null || _this$_continueBuildi === void 0 || (_this$_continueBuildi = _this$_continueBuildi.get(sheetId)) === null || _this$_continueBuildi === void 0 ? void 0 : _this$_continueBuildi.get(column);
+		if (!columnMap) return true;
+		return columnMap.search([row, row]).length === 0;
+	}
+	canUseCache(unitId, sheetId, column, rangeStartRow, rangeEndRow) {
+		var _this$_continueBuildi2;
+		const columnMap = (_this$_continueBuildi2 = this._continueBuildingCache.get(unitId)) === null || _this$_continueBuildi2 === void 0 || (_this$_continueBuildi2 = _this$_continueBuildi2.get(sheetId)) === null || _this$_continueBuildi2 === void 0 ? void 0 : _this$_continueBuildi2.get(column);
+		if (column === -1 || rangeStartRow === -1 || rangeEndRow === -1 || !columnMap) return {
+			rowsInCache: [],
+			rowsNotInCache: []
+		};
+		const result = columnMap.search([rangeStartRow, rangeEndRow]);
+		if (result.length === 0) return {
+			rowsInCache: [],
+			rowsNotInCache: []
+		};
+		result.sort((a, b) => a[0] - b[0]);
+		const rowsInCache = [];
+		const rowsNotInCache = [];
+		let _rangeStartRow = rangeStartRow;
+		for (let i = 0; i < result.length; i++) {
+			const [start, end] = result[i];
+			if (_rangeStartRow >= start) {
+				if (rangeEndRow <= end) {
+					rowsInCache.push([_rangeStartRow, rangeEndRow]);
+					break;
+				}
+				rowsInCache.push([_rangeStartRow, end]);
+				_rangeStartRow = end + 1;
+				if (i === result.length - 1 && _rangeStartRow <= rangeEndRow) rowsNotInCache.push([_rangeStartRow, rangeEndRow]);
+			} else {
+				if (rangeEndRow > end) {
+					rowsInCache.push([start, end]);
+					rowsNotInCache.push([_rangeStartRow, start - 1]);
+					_rangeStartRow = end + 1;
+					if (i === result.length - 1 && _rangeStartRow <= rangeEndRow) rowsNotInCache.push([_rangeStartRow, rangeEndRow]);
+					continue;
+				}
+				rowsInCache.push([start, rangeEndRow]);
+				rowsNotInCache.push([_rangeStartRow, start - 1]);
+			}
+		}
+		return {
+			rowsInCache,
+			rowsNotInCache
+		};
+	}
+	clear() {
+		this._cache.clear();
+		this._continueBuildingCache.clear();
+		normalizedValueMap.clear();
+	}
+	_handleNewInterval(columnMap, startRow, endRow) {
+		let result = columnMap.search([startRow, endRow]);
+		if (result.length === 0) {
+			const adjacentRange = [startRow - 1 < 0 ? 0 : startRow - 1, endRow + 1];
+			result = columnMap.search(adjacentRange);
+			if (result.length === 0) {
+				columnMap.insert([startRow, endRow]);
+				return;
+			}
+		}
+		let min = startRow;
+		let max = endRow;
+		for (const interval of result) {
+			min = Math.min(min, interval[0]);
+			max = Math.max(max, interval[1]);
+			columnMap.remove(interval);
+		}
+		columnMap.insert([min, max]);
+	}
+};
+const CELL_INVERTED_INDEX_CACHE = new InvertedIndexCache();
+
 //#endregion
 //#region src/basics/match-token.ts
 /**
@@ -2166,159 +2341,986 @@ const SetSuperTableOptionMutation = {
 //#endregion
 //#region src/config/config.ts
 const ENGINE_FORMULA_PLUGIN_CONFIG_KEY = "engine-formula.config";
+const DEFAULT_CYCLE_REFERENCE_COUNT = 1;
 const ENGINE_FORMULA_CYCLE_REFERENCE_COUNT = "CYCLE_REFERENCE_COUNT";
 const ENGINE_FORMULA_RETURN_DEPENDENCY_TREE = "RETURN_DEPENDENCY_TREE";
 const configSymbol = Symbol(ENGINE_FORMULA_PLUGIN_CONFIG_KEY);
 const defaultPluginConfig = {};
 
 //#endregion
-//#region src/engine/utils/reference-cache.ts
-const referenceToRangeCache = new FormulaAstLRU(1e5);
-function deserializeRangeWithSheetWithCache(refString) {
-	const refCache = referenceToRangeCache.get(refString);
-	if (refCache) return refCache;
-	const result = deserializeRangeWithSheet(refString);
-	referenceToRangeCache.set(refString, result);
-	return deserializeRangeWithSheet(refString);
-}
-function clearReferenceToRangeCache() {
-	referenceToRangeCache.clear();
-}
+//#region src/functions/date/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_DATE = /* @__PURE__ */ function(FUNCTION_NAMES_DATE) {
+	FUNCTION_NAMES_DATE["DATE"] = "DATE";
+	FUNCTION_NAMES_DATE["DATEDIF"] = "DATEDIF";
+	FUNCTION_NAMES_DATE["DATEVALUE"] = "DATEVALUE";
+	FUNCTION_NAMES_DATE["DAY"] = "DAY";
+	FUNCTION_NAMES_DATE["DAYS"] = "DAYS";
+	FUNCTION_NAMES_DATE["DAYS360"] = "DAYS360";
+	FUNCTION_NAMES_DATE["EDATE"] = "EDATE";
+	FUNCTION_NAMES_DATE["EOMONTH"] = "EOMONTH";
+	FUNCTION_NAMES_DATE["EPOCHTODATE"] = "EPOCHTODATE";
+	FUNCTION_NAMES_DATE["HOUR"] = "HOUR";
+	FUNCTION_NAMES_DATE["ISOWEEKNUM"] = "ISOWEEKNUM";
+	FUNCTION_NAMES_DATE["MINUTE"] = "MINUTE";
+	FUNCTION_NAMES_DATE["MONTH"] = "MONTH";
+	FUNCTION_NAMES_DATE["NETWORKDAYS"] = "NETWORKDAYS";
+	FUNCTION_NAMES_DATE["NETWORKDAYS_INTL"] = "NETWORKDAYS.INTL";
+	FUNCTION_NAMES_DATE["NOW"] = "NOW";
+	FUNCTION_NAMES_DATE["SECOND"] = "SECOND";
+	FUNCTION_NAMES_DATE["TIME"] = "TIME";
+	FUNCTION_NAMES_DATE["TIMEVALUE"] = "TIMEVALUE";
+	FUNCTION_NAMES_DATE["TO_DATE"] = "TO_DATE";
+	FUNCTION_NAMES_DATE["TODAY"] = "TODAY";
+	FUNCTION_NAMES_DATE["WEEKDAY"] = "WEEKDAY";
+	FUNCTION_NAMES_DATE["WEEKNUM"] = "WEEKNUM";
+	FUNCTION_NAMES_DATE["WORKDAY"] = "WORKDAY";
+	FUNCTION_NAMES_DATE["WORKDAY_INTL"] = "WORKDAY.INTL";
+	FUNCTION_NAMES_DATE["YEAR"] = "YEAR";
+	FUNCTION_NAMES_DATE["YEARFRAC"] = "YEARFRAC";
+	return FUNCTION_NAMES_DATE;
+}({});
 
 //#endregion
-//#region src/engine/utils/sequence.ts
-let sequenceNodeType = /* @__PURE__ */ function(sequenceNodeType) {
-	sequenceNodeType[sequenceNodeType["NORMAL"] = 0] = "NORMAL";
-	sequenceNodeType[sequenceNodeType["NUMBER"] = 1] = "NUMBER";
-	sequenceNodeType[sequenceNodeType["STRING"] = 2] = "STRING";
-	sequenceNodeType[sequenceNodeType["FUNCTION"] = 3] = "FUNCTION";
-	sequenceNodeType[sequenceNodeType["REFERENCE"] = 4] = "REFERENCE";
-	sequenceNodeType[sequenceNodeType["ARRAY"] = 5] = "ARRAY";
-	sequenceNodeType[sequenceNodeType["DEFINED_NAME"] = 6] = "DEFINED_NAME";
-	sequenceNodeType[sequenceNodeType["TABLE"] = 7] = "TABLE";
-	return sequenceNodeType;
+//#region src/functions/engineering/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_ENGINEERING = /* @__PURE__ */ function(FUNCTION_NAMES_ENGINEERING) {
+	FUNCTION_NAMES_ENGINEERING["BESSELI"] = "BESSELI";
+	FUNCTION_NAMES_ENGINEERING["BESSELJ"] = "BESSELJ";
+	FUNCTION_NAMES_ENGINEERING["BESSELK"] = "BESSELK";
+	FUNCTION_NAMES_ENGINEERING["BESSELY"] = "BESSELY";
+	FUNCTION_NAMES_ENGINEERING["BIN2DEC"] = "BIN2DEC";
+	FUNCTION_NAMES_ENGINEERING["BIN2HEX"] = "BIN2HEX";
+	FUNCTION_NAMES_ENGINEERING["BIN2OCT"] = "BIN2OCT";
+	FUNCTION_NAMES_ENGINEERING["BITAND"] = "BITAND";
+	FUNCTION_NAMES_ENGINEERING["BITLSHIFT"] = "BITLSHIFT";
+	FUNCTION_NAMES_ENGINEERING["BITOR"] = "BITOR";
+	FUNCTION_NAMES_ENGINEERING["BITRSHIFT"] = "BITRSHIFT";
+	FUNCTION_NAMES_ENGINEERING["BITXOR"] = "BITXOR";
+	FUNCTION_NAMES_ENGINEERING["COMPLEX"] = "COMPLEX";
+	FUNCTION_NAMES_ENGINEERING["CONVERT"] = "CONVERT";
+	FUNCTION_NAMES_ENGINEERING["DEC2BIN"] = "DEC2BIN";
+	FUNCTION_NAMES_ENGINEERING["DEC2HEX"] = "DEC2HEX";
+	FUNCTION_NAMES_ENGINEERING["DEC2OCT"] = "DEC2OCT";
+	FUNCTION_NAMES_ENGINEERING["DELTA"] = "DELTA";
+	FUNCTION_NAMES_ENGINEERING["ERF"] = "ERF";
+	FUNCTION_NAMES_ENGINEERING["ERF_PRECISE"] = "ERF.PRECISE";
+	FUNCTION_NAMES_ENGINEERING["ERFC"] = "ERFC";
+	FUNCTION_NAMES_ENGINEERING["ERFC_PRECISE"] = "ERFC.PRECISE";
+	FUNCTION_NAMES_ENGINEERING["GESTEP"] = "GESTEP";
+	FUNCTION_NAMES_ENGINEERING["HEX2BIN"] = "HEX2BIN";
+	FUNCTION_NAMES_ENGINEERING["HEX2DEC"] = "HEX2DEC";
+	FUNCTION_NAMES_ENGINEERING["HEX2OCT"] = "HEX2OCT";
+	FUNCTION_NAMES_ENGINEERING["IMABS"] = "IMABS";
+	FUNCTION_NAMES_ENGINEERING["IMAGINARY"] = "IMAGINARY";
+	FUNCTION_NAMES_ENGINEERING["IMARGUMENT"] = "IMARGUMENT";
+	FUNCTION_NAMES_ENGINEERING["IMCONJUGATE"] = "IMCONJUGATE";
+	FUNCTION_NAMES_ENGINEERING["IMCOS"] = "IMCOS";
+	FUNCTION_NAMES_ENGINEERING["IMCOSH"] = "IMCOSH";
+	FUNCTION_NAMES_ENGINEERING["IMCOT"] = "IMCOT";
+	FUNCTION_NAMES_ENGINEERING["IMCOTH"] = "IMCOTH";
+	FUNCTION_NAMES_ENGINEERING["IMCSC"] = "IMCSC";
+	FUNCTION_NAMES_ENGINEERING["IMCSCH"] = "IMCSCH";
+	FUNCTION_NAMES_ENGINEERING["IMDIV"] = "IMDIV";
+	FUNCTION_NAMES_ENGINEERING["IMEXP"] = "IMEXP";
+	FUNCTION_NAMES_ENGINEERING["IMLN"] = "IMLN";
+	FUNCTION_NAMES_ENGINEERING["IMLOG"] = "IMLOG";
+	FUNCTION_NAMES_ENGINEERING["IMLOG10"] = "IMLOG10";
+	FUNCTION_NAMES_ENGINEERING["IMLOG2"] = "IMLOG2";
+	FUNCTION_NAMES_ENGINEERING["IMPOWER"] = "IMPOWER";
+	FUNCTION_NAMES_ENGINEERING["IMPRODUCT"] = "IMPRODUCT";
+	FUNCTION_NAMES_ENGINEERING["IMREAL"] = "IMREAL";
+	FUNCTION_NAMES_ENGINEERING["IMSEC"] = "IMSEC";
+	FUNCTION_NAMES_ENGINEERING["IMSECH"] = "IMSECH";
+	FUNCTION_NAMES_ENGINEERING["IMSIN"] = "IMSIN";
+	FUNCTION_NAMES_ENGINEERING["IMSINH"] = "IMSINH";
+	FUNCTION_NAMES_ENGINEERING["IMSQRT"] = "IMSQRT";
+	FUNCTION_NAMES_ENGINEERING["IMSUB"] = "IMSUB";
+	FUNCTION_NAMES_ENGINEERING["IMSUM"] = "IMSUM";
+	FUNCTION_NAMES_ENGINEERING["IMTAN"] = "IMTAN";
+	FUNCTION_NAMES_ENGINEERING["IMTANH"] = "IMTANH";
+	FUNCTION_NAMES_ENGINEERING["OCT2BIN"] = "OCT2BIN";
+	FUNCTION_NAMES_ENGINEERING["OCT2DEC"] = "OCT2DEC";
+	FUNCTION_NAMES_ENGINEERING["OCT2HEX"] = "OCT2HEX";
+	return FUNCTION_NAMES_ENGINEERING;
 }({});
+
+//#endregion
+//#region src/functions/financial/function-names.ts
 /**
-* Deserialize Sequence to text.
-* @param newSequenceNodes
-* @returns
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
 */
-function generateStringWithSequence(newSequenceNodes) {
-	let sequenceString = "";
-	for (const node of newSequenceNodes) if (typeof node === "string") sequenceString += node;
-	else sequenceString += node.token;
-	return sequenceString;
-}
+let FUNCTION_NAMES_FINANCIAL = /* @__PURE__ */ function(FUNCTION_NAMES_FINANCIAL) {
+	FUNCTION_NAMES_FINANCIAL["ACCRINT"] = "ACCRINT";
+	FUNCTION_NAMES_FINANCIAL["ACCRINTM"] = "ACCRINTM";
+	FUNCTION_NAMES_FINANCIAL["AMORDEGRC"] = "AMORDEGRC";
+	FUNCTION_NAMES_FINANCIAL["AMORLINC"] = "AMORLINC";
+	FUNCTION_NAMES_FINANCIAL["COUPDAYBS"] = "COUPDAYBS";
+	FUNCTION_NAMES_FINANCIAL["COUPDAYS"] = "COUPDAYS";
+	FUNCTION_NAMES_FINANCIAL["COUPDAYSNC"] = "COUPDAYSNC";
+	FUNCTION_NAMES_FINANCIAL["COUPNCD"] = "COUPNCD";
+	FUNCTION_NAMES_FINANCIAL["COUPNUM"] = "COUPNUM";
+	FUNCTION_NAMES_FINANCIAL["COUPPCD"] = "COUPPCD";
+	FUNCTION_NAMES_FINANCIAL["CUMIPMT"] = "CUMIPMT";
+	FUNCTION_NAMES_FINANCIAL["CUMPRINC"] = "CUMPRINC";
+	FUNCTION_NAMES_FINANCIAL["DB"] = "DB";
+	FUNCTION_NAMES_FINANCIAL["DDB"] = "DDB";
+	FUNCTION_NAMES_FINANCIAL["DISC"] = "DISC";
+	FUNCTION_NAMES_FINANCIAL["DOLLARDE"] = "DOLLARDE";
+	FUNCTION_NAMES_FINANCIAL["DOLLARFR"] = "DOLLARFR";
+	FUNCTION_NAMES_FINANCIAL["DURATION"] = "DURATION";
+	FUNCTION_NAMES_FINANCIAL["EFFECT"] = "EFFECT";
+	FUNCTION_NAMES_FINANCIAL["FV"] = "FV";
+	FUNCTION_NAMES_FINANCIAL["FVSCHEDULE"] = "FVSCHEDULE";
+	FUNCTION_NAMES_FINANCIAL["INTRATE"] = "INTRATE";
+	FUNCTION_NAMES_FINANCIAL["IPMT"] = "IPMT";
+	FUNCTION_NAMES_FINANCIAL["IRR"] = "IRR";
+	FUNCTION_NAMES_FINANCIAL["ISPMT"] = "ISPMT";
+	FUNCTION_NAMES_FINANCIAL["MDURATION"] = "MDURATION";
+	FUNCTION_NAMES_FINANCIAL["MIRR"] = "MIRR";
+	FUNCTION_NAMES_FINANCIAL["NOMINAL"] = "NOMINAL";
+	FUNCTION_NAMES_FINANCIAL["NPER"] = "NPER";
+	FUNCTION_NAMES_FINANCIAL["NPV"] = "NPV";
+	FUNCTION_NAMES_FINANCIAL["ODDFPRICE"] = "ODDFPRICE";
+	FUNCTION_NAMES_FINANCIAL["ODDFYIELD"] = "ODDFYIELD";
+	FUNCTION_NAMES_FINANCIAL["ODDLPRICE"] = "ODDLPRICE";
+	FUNCTION_NAMES_FINANCIAL["ODDLYIELD"] = "ODDLYIELD";
+	FUNCTION_NAMES_FINANCIAL["PDURATION"] = "PDURATION";
+	FUNCTION_NAMES_FINANCIAL["PMT"] = "PMT";
+	FUNCTION_NAMES_FINANCIAL["PPMT"] = "PPMT";
+	FUNCTION_NAMES_FINANCIAL["PRICE"] = "PRICE";
+	FUNCTION_NAMES_FINANCIAL["PRICEDISC"] = "PRICEDISC";
+	FUNCTION_NAMES_FINANCIAL["PRICEMAT"] = "PRICEMAT";
+	FUNCTION_NAMES_FINANCIAL["PV"] = "PV";
+	FUNCTION_NAMES_FINANCIAL["RATE"] = "RATE";
+	FUNCTION_NAMES_FINANCIAL["RECEIVED"] = "RECEIVED";
+	FUNCTION_NAMES_FINANCIAL["RRI"] = "RRI";
+	FUNCTION_NAMES_FINANCIAL["SLN"] = "SLN";
+	FUNCTION_NAMES_FINANCIAL["SYD"] = "SYD";
+	FUNCTION_NAMES_FINANCIAL["TBILLEQ"] = "TBILLEQ";
+	FUNCTION_NAMES_FINANCIAL["TBILLPRICE"] = "TBILLPRICE";
+	FUNCTION_NAMES_FINANCIAL["TBILLYIELD"] = "TBILLYIELD";
+	FUNCTION_NAMES_FINANCIAL["VDB"] = "VDB";
+	FUNCTION_NAMES_FINANCIAL["XIRR"] = "XIRR";
+	FUNCTION_NAMES_FINANCIAL["XNPV"] = "XNPV";
+	FUNCTION_NAMES_FINANCIAL["YIELD"] = "YIELD";
+	FUNCTION_NAMES_FINANCIAL["YIELDDISC"] = "YIELDDISC";
+	FUNCTION_NAMES_FINANCIAL["YIELDMAT"] = "YIELDMAT";
+	return FUNCTION_NAMES_FINANCIAL;
+}({});
 
 //#endregion
-//#region src/engine/analysis/lexer-node.ts
-var LexerNode = class LexerNode {
-	constructor() {
-		_defineProperty(this, "_parent", void 0);
-		_defineProperty(this, "_token", "R_1");
-		_defineProperty(this, "_children", []);
-		_defineProperty(this, "_lambdaId", void 0);
-		_defineProperty(this, "_functionDefinitionPrivacyVar", void 0);
-		_defineProperty(this, "_lambdaParameter", "");
-		_defineProperty(this, "_startIndex", -1);
-		_defineProperty(this, "_endIndex", -1);
-		_defineProperty(this, "_definedNames", []);
-	}
-	dispose() {
-		var _this$_functionDefini;
-		this._children.forEach((node) => {
-			if (!(typeof node === "string")) node.dispose();
-		});
-		(_this$_functionDefini = this._functionDefinitionPrivacyVar) === null || _this$_functionDefini === void 0 || _this$_functionDefini.clear();
-		this._functionDefinitionPrivacyVar = null;
-		this._children = [];
-		this._parent = null;
-		this._definedNames = [];
-	}
-	getDefinedNames() {
-		return this._definedNames;
-	}
-	getStartIndex() {
-		return this._startIndex;
-	}
-	getLambdaId() {
-		return this._lambdaId;
-	}
-	setLambdaId(lambdaId) {
-		this._lambdaId = lambdaId;
-	}
-	getFunctionDefinitionPrivacyVar() {
-		return this._functionDefinitionPrivacyVar;
-	}
-	setLambdaPrivacyVar(lambdaPrivacyVar) {
-		this._functionDefinitionPrivacyVar = lambdaPrivacyVar;
-	}
-	getLambdaParameter() {
-		return this._lambdaParameter;
-	}
-	setLambdaParameter(lambdaParameter) {
-		this._lambdaParameter = lambdaParameter;
-	}
-	getParent() {
-		return this._parent;
-	}
-	setParent(lexerNode) {
-		this._parent = lexerNode;
-	}
-	getChildren() {
-		return this._children;
-	}
-	setChildren(children) {
-		this._children = children;
-	}
-	addChildren(children) {
-		this._children.push(children);
-	}
-	addChildrenFirst(children) {
-		this._children.unshift(children);
-	}
-	getToken() {
-		return this._token;
-	}
-	setToken(token) {
-		this._token = token;
-	}
-	setIndex(st, ed) {
-		this._startIndex = st;
-		this._endIndex = ed;
-	}
-	setDefinedNames(definedNames) {
-		this._definedNames = definedNames;
-	}
-	hasDefinedNames() {
-		return this._definedNames.length > 0;
-	}
-	replaceChild(lexerNode, newLexerNode) {
-		const i = this._getIndexInParent(lexerNode);
-		if (i == null) return;
-		this.getChildren().splice(i, 1, newLexerNode);
-		newLexerNode.setParent(this);
-	}
-	changeToParent(newParentLexerNode) {
-		const parentNode = this.getParent();
-		if (parentNode) parentNode.removeChild(this);
-		this.setParent(newParentLexerNode);
-		newParentLexerNode.getChildren().push(this);
-	}
-	removeChild(lexerNode) {
-		const i = this._getIndexInParent(lexerNode);
-		if (i == null) return;
-		this.getChildren().splice(i, 1);
-	}
-	serialize() {
-		const token = this.getToken();
-		const children = this.getChildren();
-		const childrenSerialization = [];
-		const childrenCount = children.length;
-		for (let i = 0; i < childrenCount; i++) {
-			const item = children[i];
-			if (item instanceof LexerNode) childrenSerialization.push(item.serialize());
-			else childrenSerialization.push(item);
+//#region src/functions/information/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_INFORMATION = /* @__PURE__ */ function(FUNCTION_NAMES_INFORMATION) {
+	FUNCTION_NAMES_INFORMATION["CELL"] = "CELL";
+	FUNCTION_NAMES_INFORMATION["ERROR_TYPE"] = "ERROR.TYPE";
+	FUNCTION_NAMES_INFORMATION["INFO"] = "INFO";
+	FUNCTION_NAMES_INFORMATION["ISBETWEEN"] = "ISBETWEEN";
+	FUNCTION_NAMES_INFORMATION["ISBLANK"] = "ISBLANK";
+	FUNCTION_NAMES_INFORMATION["ISDATE"] = "ISDATE";
+	FUNCTION_NAMES_INFORMATION["ISEMAIL"] = "ISEMAIL";
+	FUNCTION_NAMES_INFORMATION["ISERR"] = "ISERR";
+	FUNCTION_NAMES_INFORMATION["ISERROR"] = "ISERROR";
+	FUNCTION_NAMES_INFORMATION["ISEVEN"] = "ISEVEN";
+	FUNCTION_NAMES_INFORMATION["ISFORMULA"] = "ISFORMULA";
+	FUNCTION_NAMES_INFORMATION["ISLOGICAL"] = "ISLOGICAL";
+	FUNCTION_NAMES_INFORMATION["ISNA"] = "ISNA";
+	FUNCTION_NAMES_INFORMATION["ISNONTEXT"] = "ISNONTEXT";
+	FUNCTION_NAMES_INFORMATION["ISNUMBER"] = "ISNUMBER";
+	FUNCTION_NAMES_INFORMATION["ISODD"] = "ISODD";
+	FUNCTION_NAMES_INFORMATION["ISOMITTED"] = "ISOMITTED";
+	FUNCTION_NAMES_INFORMATION["ISREF"] = "ISREF";
+	FUNCTION_NAMES_INFORMATION["ISTEXT"] = "ISTEXT";
+	FUNCTION_NAMES_INFORMATION["ISURL"] = "ISURL";
+	FUNCTION_NAMES_INFORMATION["N"] = "N";
+	FUNCTION_NAMES_INFORMATION["NA"] = "NA";
+	FUNCTION_NAMES_INFORMATION["SHEET"] = "SHEET";
+	FUNCTION_NAMES_INFORMATION["SHEETS"] = "SHEETS";
+	FUNCTION_NAMES_INFORMATION["TYPE"] = "TYPE";
+	return FUNCTION_NAMES_INFORMATION;
+}({});
+
+//#endregion
+//#region src/functions/logical/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_LOGICAL = /* @__PURE__ */ function(FUNCTION_NAMES_LOGICAL) {
+	FUNCTION_NAMES_LOGICAL["AND"] = "AND";
+	FUNCTION_NAMES_LOGICAL["BYCOL"] = "BYCOL";
+	FUNCTION_NAMES_LOGICAL["BYROW"] = "BYROW";
+	FUNCTION_NAMES_LOGICAL["FALSE"] = "FALSE";
+	FUNCTION_NAMES_LOGICAL["IF"] = "IF";
+	FUNCTION_NAMES_LOGICAL["IFERROR"] = "IFERROR";
+	FUNCTION_NAMES_LOGICAL["IFNA"] = "IFNA";
+	FUNCTION_NAMES_LOGICAL["IFS"] = "IFS";
+	FUNCTION_NAMES_LOGICAL["LAMBDA"] = "LAMBDA";
+	FUNCTION_NAMES_LOGICAL["LET"] = "LET";
+	FUNCTION_NAMES_LOGICAL["MAKEARRAY"] = "MAKEARRAY";
+	FUNCTION_NAMES_LOGICAL["MAP"] = "MAP";
+	FUNCTION_NAMES_LOGICAL["NOT"] = "NOT";
+	FUNCTION_NAMES_LOGICAL["OR"] = "OR";
+	FUNCTION_NAMES_LOGICAL["REDUCE"] = "REDUCE";
+	FUNCTION_NAMES_LOGICAL["SCAN"] = "SCAN";
+	FUNCTION_NAMES_LOGICAL["SWITCH"] = "SWITCH";
+	FUNCTION_NAMES_LOGICAL["TRUE"] = "TRUE";
+	FUNCTION_NAMES_LOGICAL["XOR"] = "XOR";
+	return FUNCTION_NAMES_LOGICAL;
+}({});
+
+//#endregion
+//#region src/functions/lookup/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_LOOKUP = /* @__PURE__ */ function(FUNCTION_NAMES_LOOKUP) {
+	FUNCTION_NAMES_LOOKUP["ADDRESS"] = "ADDRESS";
+	FUNCTION_NAMES_LOOKUP["AREAS"] = "AREAS";
+	FUNCTION_NAMES_LOOKUP["CHOOSE"] = "CHOOSE";
+	FUNCTION_NAMES_LOOKUP["CHOOSECOLS"] = "CHOOSECOLS";
+	FUNCTION_NAMES_LOOKUP["CHOOSEROWS"] = "CHOOSEROWS";
+	FUNCTION_NAMES_LOOKUP["COLUMN"] = "COLUMN";
+	FUNCTION_NAMES_LOOKUP["COLUMNS"] = "COLUMNS";
+	FUNCTION_NAMES_LOOKUP["DROP"] = "DROP";
+	FUNCTION_NAMES_LOOKUP["EXPAND"] = "EXPAND";
+	FUNCTION_NAMES_LOOKUP["FILTER"] = "FILTER";
+	FUNCTION_NAMES_LOOKUP["FORMULATEXT"] = "FORMULATEXT";
+	FUNCTION_NAMES_LOOKUP["GETPIVOTDATA"] = "GETPIVOTDATA";
+	FUNCTION_NAMES_LOOKUP["HLOOKUP"] = "HLOOKUP";
+	FUNCTION_NAMES_LOOKUP["HSTACK"] = "HSTACK";
+	FUNCTION_NAMES_LOOKUP["HYPERLINK"] = "HYPERLINK";
+	FUNCTION_NAMES_LOOKUP["IMAGE"] = "IMAGE";
+	FUNCTION_NAMES_LOOKUP["INDEX"] = "INDEX";
+	FUNCTION_NAMES_LOOKUP["INDIRECT"] = "INDIRECT";
+	FUNCTION_NAMES_LOOKUP["LOOKUP"] = "LOOKUP";
+	FUNCTION_NAMES_LOOKUP["MATCH"] = "MATCH";
+	FUNCTION_NAMES_LOOKUP["OFFSET"] = "OFFSET";
+	FUNCTION_NAMES_LOOKUP["ROW"] = "ROW";
+	FUNCTION_NAMES_LOOKUP["ROWS"] = "ROWS";
+	FUNCTION_NAMES_LOOKUP["RTD"] = "RTD";
+	FUNCTION_NAMES_LOOKUP["SORT"] = "SORT";
+	FUNCTION_NAMES_LOOKUP["SORTBY"] = "SORTBY";
+	FUNCTION_NAMES_LOOKUP["TAKE"] = "TAKE";
+	FUNCTION_NAMES_LOOKUP["TOCOL"] = "TOCOL";
+	FUNCTION_NAMES_LOOKUP["TOROW"] = "TOROW";
+	FUNCTION_NAMES_LOOKUP["TRANSPOSE"] = "TRANSPOSE";
+	FUNCTION_NAMES_LOOKUP["UNIQUE"] = "UNIQUE";
+	FUNCTION_NAMES_LOOKUP["VLOOKUP"] = "VLOOKUP";
+	FUNCTION_NAMES_LOOKUP["VSTACK"] = "VSTACK";
+	FUNCTION_NAMES_LOOKUP["WRAPCOLS"] = "WRAPCOLS";
+	FUNCTION_NAMES_LOOKUP["WRAPROWS"] = "WRAPROWS";
+	FUNCTION_NAMES_LOOKUP["XLOOKUP"] = "XLOOKUP";
+	FUNCTION_NAMES_LOOKUP["XMATCH"] = "XMATCH";
+	return FUNCTION_NAMES_LOOKUP;
+}({});
+
+//#endregion
+//#region src/functions/math/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_MATH = /* @__PURE__ */ function(FUNCTION_NAMES_MATH) {
+	FUNCTION_NAMES_MATH["ABS"] = "ABS";
+	FUNCTION_NAMES_MATH["ACOS"] = "ACOS";
+	FUNCTION_NAMES_MATH["ACOSH"] = "ACOSH";
+	FUNCTION_NAMES_MATH["ACOT"] = "ACOT";
+	FUNCTION_NAMES_MATH["ACOTH"] = "ACOTH";
+	FUNCTION_NAMES_MATH["AGGREGATE"] = "AGGREGATE";
+	FUNCTION_NAMES_MATH["ARABIC"] = "ARABIC";
+	FUNCTION_NAMES_MATH["ASIN"] = "ASIN";
+	FUNCTION_NAMES_MATH["ASINH"] = "ASINH";
+	FUNCTION_NAMES_MATH["ATAN"] = "ATAN";
+	FUNCTION_NAMES_MATH["ATAN2"] = "ATAN2";
+	FUNCTION_NAMES_MATH["ATANH"] = "ATANH";
+	FUNCTION_NAMES_MATH["BASE"] = "BASE";
+	FUNCTION_NAMES_MATH["CEILING"] = "CEILING";
+	FUNCTION_NAMES_MATH["CEILING_MATH"] = "CEILING.MATH";
+	FUNCTION_NAMES_MATH["CEILING_PRECISE"] = "CEILING.PRECISE";
+	FUNCTION_NAMES_MATH["COMBIN"] = "COMBIN";
+	FUNCTION_NAMES_MATH["COMBINA"] = "COMBINA";
+	FUNCTION_NAMES_MATH["COS"] = "COS";
+	FUNCTION_NAMES_MATH["COSH"] = "COSH";
+	FUNCTION_NAMES_MATH["COT"] = "COT";
+	FUNCTION_NAMES_MATH["COTH"] = "COTH";
+	FUNCTION_NAMES_MATH["CSC"] = "CSC";
+	FUNCTION_NAMES_MATH["CSCH"] = "CSCH";
+	FUNCTION_NAMES_MATH["DECIMAL"] = "DECIMAL";
+	FUNCTION_NAMES_MATH["DEGREES"] = "DEGREES";
+	FUNCTION_NAMES_MATH["EVEN"] = "EVEN";
+	FUNCTION_NAMES_MATH["EXP"] = "EXP";
+	FUNCTION_NAMES_MATH["FACT"] = "FACT";
+	FUNCTION_NAMES_MATH["FACTDOUBLE"] = "FACTDOUBLE";
+	FUNCTION_NAMES_MATH["FLOOR"] = "FLOOR";
+	FUNCTION_NAMES_MATH["FLOOR_MATH"] = "FLOOR.MATH";
+	FUNCTION_NAMES_MATH["FLOOR_PRECISE"] = "FLOOR.PRECISE";
+	FUNCTION_NAMES_MATH["GCD"] = "GCD";
+	FUNCTION_NAMES_MATH["INT"] = "INT";
+	FUNCTION_NAMES_MATH["ISO_CEILING"] = "ISO.CEILING";
+	FUNCTION_NAMES_MATH["LCM"] = "LCM";
+	FUNCTION_NAMES_MATH["LET"] = "LET";
+	FUNCTION_NAMES_MATH["LN"] = "LN";
+	FUNCTION_NAMES_MATH["LOG"] = "LOG";
+	FUNCTION_NAMES_MATH["LOG10"] = "LOG10";
+	FUNCTION_NAMES_MATH["MDETERM"] = "MDETERM";
+	FUNCTION_NAMES_MATH["MINVERSE"] = "MINVERSE";
+	FUNCTION_NAMES_MATH["MMULT"] = "MMULT";
+	FUNCTION_NAMES_MATH["MOD"] = "MOD";
+	FUNCTION_NAMES_MATH["MROUND"] = "MROUND";
+	FUNCTION_NAMES_MATH["MULTINOMIAL"] = "MULTINOMIAL";
+	FUNCTION_NAMES_MATH["MUNIT"] = "MUNIT";
+	FUNCTION_NAMES_MATH["ODD"] = "ODD";
+	FUNCTION_NAMES_MATH["PI"] = "PI";
+	FUNCTION_NAMES_MATH["POWER"] = "POWER";
+	FUNCTION_NAMES_MATH["PRODUCT"] = "PRODUCT";
+	FUNCTION_NAMES_MATH["QUOTIENT"] = "QUOTIENT";
+	FUNCTION_NAMES_MATH["RADIANS"] = "RADIANS";
+	FUNCTION_NAMES_MATH["RAND"] = "RAND";
+	FUNCTION_NAMES_MATH["RANDARRAY"] = "RANDARRAY";
+	FUNCTION_NAMES_MATH["RANDBETWEEN"] = "RANDBETWEEN";
+	FUNCTION_NAMES_MATH["ROMAN"] = "ROMAN";
+	FUNCTION_NAMES_MATH["ROUND"] = "ROUND";
+	FUNCTION_NAMES_MATH["ROUNDBANK"] = "ROUNDBANK";
+	FUNCTION_NAMES_MATH["ROUNDDOWN"] = "ROUNDDOWN";
+	FUNCTION_NAMES_MATH["ROUNDUP"] = "ROUNDUP";
+	FUNCTION_NAMES_MATH["SEC"] = "SEC";
+	FUNCTION_NAMES_MATH["SECH"] = "SECH";
+	FUNCTION_NAMES_MATH["SERIESSUM"] = "SERIESSUM";
+	FUNCTION_NAMES_MATH["SEQUENCE"] = "SEQUENCE";
+	FUNCTION_NAMES_MATH["SIGN"] = "SIGN";
+	FUNCTION_NAMES_MATH["SIN"] = "SIN";
+	FUNCTION_NAMES_MATH["SINH"] = "SINH";
+	FUNCTION_NAMES_MATH["SQRT"] = "SQRT";
+	FUNCTION_NAMES_MATH["SQRTPI"] = "SQRTPI";
+	FUNCTION_NAMES_MATH["SUBTOTAL"] = "SUBTOTAL";
+	FUNCTION_NAMES_MATH["SUM"] = "SUM";
+	FUNCTION_NAMES_MATH["SUMIF"] = "SUMIF";
+	FUNCTION_NAMES_MATH["SUMIFS"] = "SUMIFS";
+	FUNCTION_NAMES_MATH["SUMPRODUCT"] = "SUMPRODUCT";
+	FUNCTION_NAMES_MATH["SUMSQ"] = "SUMSQ";
+	FUNCTION_NAMES_MATH["SUMX2MY2"] = "SUMX2MY2";
+	FUNCTION_NAMES_MATH["SUMX2PY2"] = "SUMX2PY2";
+	FUNCTION_NAMES_MATH["SUMXMY2"] = "SUMXMY2";
+	FUNCTION_NAMES_MATH["TAN"] = "TAN";
+	FUNCTION_NAMES_MATH["TANH"] = "TANH";
+	FUNCTION_NAMES_MATH["TRUNC"] = "TRUNC";
+	return FUNCTION_NAMES_MATH;
+}({});
+
+//#endregion
+//#region src/functions/statistical/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_STATISTICAL = /* @__PURE__ */ function(FUNCTION_NAMES_STATISTICAL) {
+	FUNCTION_NAMES_STATISTICAL["AVEDEV"] = "AVEDEV";
+	FUNCTION_NAMES_STATISTICAL["AVERAGE"] = "AVERAGE";
+	FUNCTION_NAMES_STATISTICAL["AVERAGE_WEIGHTED"] = "AVERAGE.WEIGHTED";
+	FUNCTION_NAMES_STATISTICAL["AVERAGEA"] = "AVERAGEA";
+	FUNCTION_NAMES_STATISTICAL["AVERAGEIF"] = "AVERAGEIF";
+	FUNCTION_NAMES_STATISTICAL["AVERAGEIFS"] = "AVERAGEIFS";
+	FUNCTION_NAMES_STATISTICAL["BETA_DIST"] = "BETA.DIST";
+	FUNCTION_NAMES_STATISTICAL["BETA_INV"] = "BETA.INV";
+	FUNCTION_NAMES_STATISTICAL["BINOM_DIST"] = "BINOM.DIST";
+	FUNCTION_NAMES_STATISTICAL["BINOM_DIST_RANGE"] = "BINOM.DIST.RANGE";
+	FUNCTION_NAMES_STATISTICAL["BINOM_INV"] = "BINOM.INV";
+	FUNCTION_NAMES_STATISTICAL["CHISQ_DIST"] = "CHISQ.DIST";
+	FUNCTION_NAMES_STATISTICAL["CHISQ_DIST_RT"] = "CHISQ.DIST.RT";
+	FUNCTION_NAMES_STATISTICAL["CHISQ_INV"] = "CHISQ.INV";
+	FUNCTION_NAMES_STATISTICAL["CHISQ_INV_RT"] = "CHISQ.INV.RT";
+	FUNCTION_NAMES_STATISTICAL["CHISQ_TEST"] = "CHISQ.TEST";
+	FUNCTION_NAMES_STATISTICAL["CONFIDENCE_NORM"] = "CONFIDENCE.NORM";
+	FUNCTION_NAMES_STATISTICAL["CONFIDENCE_T"] = "CONFIDENCE.T";
+	FUNCTION_NAMES_STATISTICAL["CORREL"] = "CORREL";
+	FUNCTION_NAMES_STATISTICAL["COUNT"] = "COUNT";
+	FUNCTION_NAMES_STATISTICAL["COUNTA"] = "COUNTA";
+	FUNCTION_NAMES_STATISTICAL["COUNTBLANK"] = "COUNTBLANK";
+	FUNCTION_NAMES_STATISTICAL["COUNTIF"] = "COUNTIF";
+	FUNCTION_NAMES_STATISTICAL["COUNTIFS"] = "COUNTIFS";
+	FUNCTION_NAMES_STATISTICAL["COVARIANCE_P"] = "COVARIANCE.P";
+	FUNCTION_NAMES_STATISTICAL["COVARIANCE_S"] = "COVARIANCE.S";
+	FUNCTION_NAMES_STATISTICAL["DEVSQ"] = "DEVSQ";
+	FUNCTION_NAMES_STATISTICAL["EXPON_DIST"] = "EXPON.DIST";
+	FUNCTION_NAMES_STATISTICAL["F_DIST"] = "F.DIST";
+	FUNCTION_NAMES_STATISTICAL["F_DIST_RT"] = "F.DIST.RT";
+	FUNCTION_NAMES_STATISTICAL["F_INV"] = "F.INV";
+	FUNCTION_NAMES_STATISTICAL["F_INV_RT"] = "F.INV.RT";
+	FUNCTION_NAMES_STATISTICAL["F_TEST"] = "F.TEST";
+	FUNCTION_NAMES_STATISTICAL["FISHER"] = "FISHER";
+	FUNCTION_NAMES_STATISTICAL["FISHERINV"] = "FISHERINV";
+	FUNCTION_NAMES_STATISTICAL["FORECAST"] = "FORECAST";
+	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS"] = "FORECAST.ETS";
+	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS_CONFINT"] = "FORECAST.ETS.CONFINT";
+	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS_SEASONALITY"] = "FORECAST.ETS.SEASONALITY";
+	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS_STAT"] = "FORECAST.ETS.STAT";
+	FUNCTION_NAMES_STATISTICAL["FORECAST_LINEAR"] = "FORECAST.LINEAR";
+	FUNCTION_NAMES_STATISTICAL["FREQUENCY"] = "FREQUENCY";
+	FUNCTION_NAMES_STATISTICAL["GAMMA"] = "GAMMA";
+	FUNCTION_NAMES_STATISTICAL["GAMMA_DIST"] = "GAMMA.DIST";
+	FUNCTION_NAMES_STATISTICAL["GAMMA_INV"] = "GAMMA.INV";
+	FUNCTION_NAMES_STATISTICAL["GAMMALN"] = "GAMMALN";
+	FUNCTION_NAMES_STATISTICAL["GAMMALN_PRECISE"] = "GAMMALN.PRECISE";
+	FUNCTION_NAMES_STATISTICAL["GAUSS"] = "GAUSS";
+	FUNCTION_NAMES_STATISTICAL["GEOMEAN"] = "GEOMEAN";
+	FUNCTION_NAMES_STATISTICAL["GROWTH"] = "GROWTH";
+	FUNCTION_NAMES_STATISTICAL["HARMEAN"] = "HARMEAN";
+	FUNCTION_NAMES_STATISTICAL["HYPGEOM_DIST"] = "HYPGEOM.DIST";
+	FUNCTION_NAMES_STATISTICAL["INTERCEPT"] = "INTERCEPT";
+	FUNCTION_NAMES_STATISTICAL["KURT"] = "KURT";
+	FUNCTION_NAMES_STATISTICAL["LARGE"] = "LARGE";
+	FUNCTION_NAMES_STATISTICAL["LINEST"] = "LINEST";
+	FUNCTION_NAMES_STATISTICAL["LOGEST"] = "LOGEST";
+	FUNCTION_NAMES_STATISTICAL["LOGNORM_DIST"] = "LOGNORM.DIST";
+	FUNCTION_NAMES_STATISTICAL["LOGNORM_INV"] = "LOGNORM.INV";
+	FUNCTION_NAMES_STATISTICAL["MARGINOFERROR"] = "MARGINOFERROR";
+	FUNCTION_NAMES_STATISTICAL["MAX"] = "MAX";
+	FUNCTION_NAMES_STATISTICAL["MAXA"] = "MAXA";
+	FUNCTION_NAMES_STATISTICAL["MAXIFS"] = "MAXIFS";
+	FUNCTION_NAMES_STATISTICAL["MEDIAN"] = "MEDIAN";
+	FUNCTION_NAMES_STATISTICAL["MIN"] = "MIN";
+	FUNCTION_NAMES_STATISTICAL["MINA"] = "MINA";
+	FUNCTION_NAMES_STATISTICAL["MINIFS"] = "MINIFS";
+	FUNCTION_NAMES_STATISTICAL["MODE_MULT"] = "MODE.MULT";
+	FUNCTION_NAMES_STATISTICAL["MODE_SNGL"] = "MODE.SNGL";
+	FUNCTION_NAMES_STATISTICAL["NEGBINOM_DIST"] = "NEGBINOM.DIST";
+	FUNCTION_NAMES_STATISTICAL["NORM_DIST"] = "NORM.DIST";
+	FUNCTION_NAMES_STATISTICAL["NORM_INV"] = "NORM.INV";
+	FUNCTION_NAMES_STATISTICAL["NORM_S_DIST"] = "NORM.S.DIST";
+	FUNCTION_NAMES_STATISTICAL["NORM_S_INV"] = "NORM.S.INV";
+	FUNCTION_NAMES_STATISTICAL["PEARSON"] = "PEARSON";
+	FUNCTION_NAMES_STATISTICAL["PERCENTILE_EXC"] = "PERCENTILE.EXC";
+	FUNCTION_NAMES_STATISTICAL["PERCENTILE_INC"] = "PERCENTILE.INC";
+	FUNCTION_NAMES_STATISTICAL["PERCENTRANK_EXC"] = "PERCENTRANK.EXC";
+	FUNCTION_NAMES_STATISTICAL["PERCENTRANK_INC"] = "PERCENTRANK.INC";
+	FUNCTION_NAMES_STATISTICAL["PERMUT"] = "PERMUT";
+	FUNCTION_NAMES_STATISTICAL["PERMUTATIONA"] = "PERMUTATIONA";
+	FUNCTION_NAMES_STATISTICAL["PHI"] = "PHI";
+	FUNCTION_NAMES_STATISTICAL["POISSON_DIST"] = "POISSON.DIST";
+	FUNCTION_NAMES_STATISTICAL["PROB"] = "PROB";
+	FUNCTION_NAMES_STATISTICAL["QUARTILE_EXC"] = "QUARTILE.EXC";
+	FUNCTION_NAMES_STATISTICAL["QUARTILE_INC"] = "QUARTILE.INC";
+	FUNCTION_NAMES_STATISTICAL["RANK_AVG"] = "RANK.AVG";
+	FUNCTION_NAMES_STATISTICAL["RANK_EQ"] = "RANK.EQ";
+	FUNCTION_NAMES_STATISTICAL["RSQ"] = "RSQ";
+	FUNCTION_NAMES_STATISTICAL["SKEW"] = "SKEW";
+	FUNCTION_NAMES_STATISTICAL["SKEW_P"] = "SKEW.P";
+	FUNCTION_NAMES_STATISTICAL["SLOPE"] = "SLOPE";
+	FUNCTION_NAMES_STATISTICAL["SMALL"] = "SMALL";
+	FUNCTION_NAMES_STATISTICAL["STANDARDIZE"] = "STANDARDIZE";
+	FUNCTION_NAMES_STATISTICAL["STDEV_P"] = "STDEV.P";
+	FUNCTION_NAMES_STATISTICAL["STDEV_S"] = "STDEV.S";
+	FUNCTION_NAMES_STATISTICAL["STDEVA"] = "STDEVA";
+	FUNCTION_NAMES_STATISTICAL["STDEVPA"] = "STDEVPA";
+	FUNCTION_NAMES_STATISTICAL["STEYX"] = "STEYX";
+	FUNCTION_NAMES_STATISTICAL["T_DIST"] = "T.DIST";
+	FUNCTION_NAMES_STATISTICAL["T_DIST_2T"] = "T.DIST.2T";
+	FUNCTION_NAMES_STATISTICAL["T_DIST_RT"] = "T.DIST.RT";
+	FUNCTION_NAMES_STATISTICAL["T_INV"] = "T.INV";
+	FUNCTION_NAMES_STATISTICAL["T_INV_2T"] = "T.INV.2T";
+	FUNCTION_NAMES_STATISTICAL["T_TEST"] = "T.TEST";
+	FUNCTION_NAMES_STATISTICAL["TREND"] = "TREND";
+	FUNCTION_NAMES_STATISTICAL["TRIMMEAN"] = "TRIMMEAN";
+	FUNCTION_NAMES_STATISTICAL["VAR_P"] = "VAR.P";
+	FUNCTION_NAMES_STATISTICAL["VAR_S"] = "VAR.S";
+	FUNCTION_NAMES_STATISTICAL["VARA"] = "VARA";
+	FUNCTION_NAMES_STATISTICAL["VARPA"] = "VARPA";
+	FUNCTION_NAMES_STATISTICAL["WEIBULL_DIST"] = "WEIBULL.DIST";
+	FUNCTION_NAMES_STATISTICAL["Z_TEST"] = "Z.TEST";
+	return FUNCTION_NAMES_STATISTICAL;
+}({});
+
+//#endregion
+//#region src/functions/text/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_TEXT = /* @__PURE__ */ function(FUNCTION_NAMES_TEXT) {
+	FUNCTION_NAMES_TEXT["ASC"] = "ASC";
+	FUNCTION_NAMES_TEXT["ARRAYTOTEXT"] = "ARRAYTOTEXT";
+	FUNCTION_NAMES_TEXT["BAHTTEXT"] = "BAHTTEXT";
+	FUNCTION_NAMES_TEXT["CHAR"] = "CHAR";
+	FUNCTION_NAMES_TEXT["CLEAN"] = "CLEAN";
+	FUNCTION_NAMES_TEXT["CODE"] = "CODE";
+	FUNCTION_NAMES_TEXT["CONCAT"] = "CONCAT";
+	FUNCTION_NAMES_TEXT["CONCATENATE"] = "CONCATENATE";
+	FUNCTION_NAMES_TEXT["DBCS"] = "DBCS";
+	FUNCTION_NAMES_TEXT["DOLLAR"] = "DOLLAR";
+	FUNCTION_NAMES_TEXT["EXACT"] = "EXACT";
+	FUNCTION_NAMES_TEXT["FIND"] = "FIND";
+	FUNCTION_NAMES_TEXT["FINDB"] = "FINDB";
+	FUNCTION_NAMES_TEXT["FIXED"] = "FIXED";
+	FUNCTION_NAMES_TEXT["LEFT"] = "LEFT";
+	FUNCTION_NAMES_TEXT["LEFTB"] = "LEFTB";
+	FUNCTION_NAMES_TEXT["LEN"] = "LEN";
+	FUNCTION_NAMES_TEXT["LENB"] = "LENB";
+	FUNCTION_NAMES_TEXT["LOWER"] = "LOWER";
+	FUNCTION_NAMES_TEXT["MID"] = "MID";
+	FUNCTION_NAMES_TEXT["MIDB"] = "MIDB";
+	FUNCTION_NAMES_TEXT["NUMBERSTRING"] = "NUMBERSTRING";
+	FUNCTION_NAMES_TEXT["NUMBERVALUE"] = "NUMBERVALUE";
+	FUNCTION_NAMES_TEXT["PHONETIC"] = "PHONETIC";
+	FUNCTION_NAMES_TEXT["PROPER"] = "PROPER";
+	FUNCTION_NAMES_TEXT["REGEXEXTRACT"] = "REGEXEXTRACT";
+	FUNCTION_NAMES_TEXT["REGEXMATCH"] = "REGEXMATCH";
+	FUNCTION_NAMES_TEXT["REGEXREPLACE"] = "REGEXREPLACE";
+	FUNCTION_NAMES_TEXT["REPLACE"] = "REPLACE";
+	FUNCTION_NAMES_TEXT["REPLACEB"] = "REPLACEB";
+	FUNCTION_NAMES_TEXT["REPT"] = "REPT";
+	FUNCTION_NAMES_TEXT["RIGHT"] = "RIGHT";
+	FUNCTION_NAMES_TEXT["RIGHTB"] = "RIGHTB";
+	FUNCTION_NAMES_TEXT["SEARCH"] = "SEARCH";
+	FUNCTION_NAMES_TEXT["SEARCHB"] = "SEARCHB";
+	FUNCTION_NAMES_TEXT["SUBSTITUTE"] = "SUBSTITUTE";
+	FUNCTION_NAMES_TEXT["T"] = "T";
+	FUNCTION_NAMES_TEXT["TEXT"] = "TEXT";
+	FUNCTION_NAMES_TEXT["TEXTAFTER"] = "TEXTAFTER";
+	FUNCTION_NAMES_TEXT["TEXTBEFORE"] = "TEXTBEFORE";
+	FUNCTION_NAMES_TEXT["TEXTJOIN"] = "TEXTJOIN";
+	FUNCTION_NAMES_TEXT["TEXTSPLIT"] = "TEXTSPLIT";
+	FUNCTION_NAMES_TEXT["TRIM"] = "TRIM";
+	FUNCTION_NAMES_TEXT["UNICHAR"] = "UNICHAR";
+	FUNCTION_NAMES_TEXT["UNICODE"] = "UNICODE";
+	FUNCTION_NAMES_TEXT["UPPER"] = "UPPER";
+	FUNCTION_NAMES_TEXT["VALUE"] = "VALUE";
+	FUNCTION_NAMES_TEXT["VALUETOTEXT"] = "VALUETOTEXT";
+	FUNCTION_NAMES_TEXT["CALL"] = "CALL";
+	FUNCTION_NAMES_TEXT["EUROCONVERT"] = "EUROCONVERT";
+	FUNCTION_NAMES_TEXT["REGISTER_ID"] = "REGISTER.ID";
+	return FUNCTION_NAMES_TEXT;
+}({});
+
+//#endregion
+//#region src/functions/web/function-names.ts
+/**
+* Copyright 2023-present DreamNum Co., Ltd.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+let FUNCTION_NAMES_WEB = /* @__PURE__ */ function(FUNCTION_NAMES_WEB) {
+	FUNCTION_NAMES_WEB["ENCODEURL"] = "ENCODEURL";
+	FUNCTION_NAMES_WEB["FILTERXML"] = "FILTERXML";
+	FUNCTION_NAMES_WEB["WEBSERVICE"] = "WEBSERVICE";
+	return FUNCTION_NAMES_WEB;
+}({});
+
+//#endregion
+//#region src/functions/new-excel-functions.ts
+const NEW_EXCEL_FUNCTIONS = new Set([
+	"ACOT",
+	"ACOTH",
+	"ARABIC",
+	"BASE",
+	"CEILING.MATH",
+	"CEILING.PRECISE",
+	"COMBINA",
+	"COT",
+	"COTH",
+	"CSC",
+	"CSCH",
+	"DECIMAL",
+	"FLOOR.MATH",
+	"FLOOR.PRECISE",
+	"MUNIT",
+	"RANDARRAY",
+	"SEC",
+	"SECH",
+	"SEQUENCE",
+	"CHOOSECOLS",
+	"CHOOSEROWS",
+	"DROP",
+	"EXPAND",
+	"FILTER",
+	"FORMULATEXT",
+	"HSTACK",
+	"SORT",
+	"SORTBY",
+	"TAKE",
+	"TOCOL",
+	"TOROW",
+	"UNIQUE",
+	"VSTACK",
+	"WRAPCOLS",
+	"WRAPROWS",
+	"XLOOKUP",
+	"XMATCH",
+	"BITAND",
+	"BITLSHIFT",
+	"BITOR",
+	"BITRSHIFT",
+	"BITXOR",
+	"ERF.PRECISE",
+	"ERFC.PRECISE",
+	"IMCOSH",
+	"IMCOT",
+	"IMCSC",
+	"IMCSCH",
+	"IMSEC",
+	"IMSECH",
+	"IMSINH",
+	"IMTAN",
+	"ISFORMULA",
+	"SHEET",
+	"SHEETS",
+	"IFNA",
+	"IFS",
+	"SWITCH",
+	"XOR",
+	"BETA.DIST",
+	"BETA.INV",
+	"BINOM.DIST",
+	"BINOM.DIST.RANGE",
+	"BINOM.INV",
+	"CHISQ.DIST",
+	"CHISQ.DIST.RT",
+	"CHISQ.INV",
+	"CHISQ.INV.RT",
+	"CHISQ.TEST",
+	"CONFIDENCE.NORM",
+	"CONFIDENCE.T",
+	"COVARIANCE.P",
+	"COVARIANCE.S",
+	"EXPON.DIST",
+	"F.DIST",
+	"F.DIST.RT",
+	"F.INV",
+	"F.INV.RT",
+	"F.TEST",
+	"FORECAST.LINEAR",
+	"GAMMA",
+	"GAMMA.DIST",
+	"GAMMA.INV",
+	"GAMMALN.PRECISE",
+	"GAUSS",
+	"HYPGEOM.DIST",
+	"LOGNORM.DIST",
+	"LOGNORM.INV",
+	"MAXIFS",
+	"MINIFS",
+	"MODE.MULT",
+	"MODE.SNGL",
+	"NEGBINOM.DIST",
+	"NORM.DIST",
+	"NORM.INV",
+	"NORM.S.DIST",
+	"NORM.S.INV",
+	"PERCENTILE.EXC",
+	"PERCENTILE.INC",
+	"PERCENTRANK.EXC",
+	"PERCENTRANK.INC",
+	"PERMUTATIONA",
+	"PHI",
+	"POISSON.DIST",
+	"QUARTILE.EXC",
+	"QUARTILE.INC",
+	"RANK.AVG",
+	"RANK.EQ",
+	"SKEW.P",
+	"STDEV.P",
+	"STDEV.S",
+	"T.DIST",
+	"T.DIST.2T",
+	"T.DIST.RT",
+	"T.INV",
+	"T.INV.2T",
+	"T.TEST",
+	"VAR.P",
+	"VAR.S",
+	"WEIBULL.DIST",
+	"Z.TEST",
+	"ARRAYTOTEXT",
+	"ENCODEURL",
+	"NUMBERVALUE",
+	"TEXTAFTER",
+	"TEXTBEFORE",
+	"TEXTJOIN",
+	"TEXTSPLIT",
+	"UNICHAR",
+	"UNICODE",
+	"VALUETOTEXT",
+	"DAYS",
+	"ISOWEEKNUM",
+	"PDURATION",
+	"RRI",
+	"BYCOL",
+	"BYROW",
+	"MAKEARRAY",
+	"MAP",
+	"REDUCE",
+	"SCAN"
+]);
+
+//#endregion
+//#region src/engine/utils/reference-cache.ts
+const referenceToRangeCache = new FormulaAstLRU(1e5);
+function deserializeRangeWithSheetWithCache(refString) {
+	const refCache = referenceToRangeCache.get(refString);
+	if (refCache) return refCache;
+	const result = deserializeRangeWithSheet(refString);
+	referenceToRangeCache.set(refString, result);
+	return deserializeRangeWithSheet(refString);
+}
+function clearReferenceToRangeCache() {
+	referenceToRangeCache.clear();
+}
+
+//#endregion
+//#region src/engine/utils/sequence.ts
+let sequenceNodeType = /* @__PURE__ */ function(sequenceNodeType) {
+	sequenceNodeType[sequenceNodeType["NORMAL"] = 0] = "NORMAL";
+	sequenceNodeType[sequenceNodeType["NUMBER"] = 1] = "NUMBER";
+	sequenceNodeType[sequenceNodeType["STRING"] = 2] = "STRING";
+	sequenceNodeType[sequenceNodeType["FUNCTION"] = 3] = "FUNCTION";
+	sequenceNodeType[sequenceNodeType["REFERENCE"] = 4] = "REFERENCE";
+	sequenceNodeType[sequenceNodeType["ARRAY"] = 5] = "ARRAY";
+	sequenceNodeType[sequenceNodeType["DEFINED_NAME"] = 6] = "DEFINED_NAME";
+	sequenceNodeType[sequenceNodeType["TABLE"] = 7] = "TABLE";
+	return sequenceNodeType;
+}({});
+/**
+* Deserialize Sequence to text.
+* @param newSequenceNodes
+* @returns
+*/
+function generateStringWithSequence(newSequenceNodes) {
+	let sequenceString = "";
+	for (const node of newSequenceNodes) if (typeof node === "string") sequenceString += node;
+	else sequenceString += node.token;
+	return sequenceString;
+}
+
+//#endregion
+//#region src/engine/analysis/lexer-node.ts
+var LexerNode = class LexerNode {
+	constructor() {
+		_defineProperty(this, "_parent", void 0);
+		_defineProperty(this, "_token", "R_1");
+		_defineProperty(this, "_children", []);
+		_defineProperty(this, "_lambdaId", void 0);
+		_defineProperty(this, "_functionDefinitionPrivacyVar", void 0);
+		_defineProperty(this, "_lambdaParameter", "");
+		_defineProperty(this, "_startIndex", -1);
+		_defineProperty(this, "_endIndex", -1);
+		_defineProperty(this, "_definedNames", []);
+	}
+	dispose() {
+		var _this$_functionDefini;
+		this._children.forEach((node) => {
+			if (!(typeof node === "string")) node.dispose();
+		});
+		(_this$_functionDefini = this._functionDefinitionPrivacyVar) === null || _this$_functionDefini === void 0 || _this$_functionDefini.clear();
+		this._functionDefinitionPrivacyVar = null;
+		this._children = [];
+		this._parent = null;
+		this._definedNames = [];
+	}
+	getDefinedNames() {
+		return this._definedNames;
+	}
+	getStartIndex() {
+		return this._startIndex;
+	}
+	getLambdaId() {
+		return this._lambdaId;
+	}
+	setLambdaId(lambdaId) {
+		this._lambdaId = lambdaId;
+	}
+	getFunctionDefinitionPrivacyVar() {
+		return this._functionDefinitionPrivacyVar;
+	}
+	setLambdaPrivacyVar(lambdaPrivacyVar) {
+		this._functionDefinitionPrivacyVar = lambdaPrivacyVar;
+	}
+	getLambdaParameter() {
+		return this._lambdaParameter;
+	}
+	setLambdaParameter(lambdaParameter) {
+		this._lambdaParameter = lambdaParameter;
+	}
+	getParent() {
+		return this._parent;
+	}
+	setParent(lexerNode) {
+		this._parent = lexerNode;
+	}
+	getChildren() {
+		return this._children;
+	}
+	setChildren(children) {
+		this._children = children;
+	}
+	addChildren(children) {
+		this._children.push(children);
+	}
+	addChildrenFirst(children) {
+		this._children.unshift(children);
+	}
+	getToken() {
+		return this._token;
+	}
+	setToken(token) {
+		this._token = token;
+	}
+	setIndex(st, ed) {
+		this._startIndex = st;
+		this._endIndex = ed;
+	}
+	setDefinedNames(definedNames) {
+		this._definedNames = definedNames;
+	}
+	hasDefinedNames() {
+		return this._definedNames.length > 0;
+	}
+	replaceChild(lexerNode, newLexerNode) {
+		const i = this._getIndexInParent(lexerNode);
+		if (i == null) return;
+		this.getChildren().splice(i, 1, newLexerNode);
+		newLexerNode.setParent(this);
+	}
+	changeToParent(newParentLexerNode) {
+		const parentNode = this.getParent();
+		if (parentNode) parentNode.removeChild(this);
+		this.setParent(newParentLexerNode);
+		newParentLexerNode.getChildren().push(this);
+	}
+	removeChild(lexerNode) {
+		const i = this._getIndexInParent(lexerNode);
+		if (i == null) return;
+		this.getChildren().splice(i, 1);
+	}
+	serialize() {
+		const token = this.getToken();
+		const children = this.getChildren();
+		const childrenSerialization = [];
+		const childrenCount = children.length;
+		for (let i = 0; i < childrenCount; i++) {
+			const item = children[i];
+			if (item instanceof LexerNode) childrenSerialization.push(item.serialize());
+			else childrenSerialization.push(item);
 		}
 		return {
 			token,
@@ -2355,6 +3357,19 @@ var LexerTreeBuilder = class extends _univerjs_core.Disposable {
 		_defineProperty(this, "_colonState", false);
 		_defineProperty(this, "_formulaErrorCount", 0);
 		_defineProperty(this, "_tableBracketState", false);
+		_defineProperty(this, "_hasNewExcelFunction", false);
+		_defineProperty(this, "_lambdaFunctionParameterSet", /* @__PURE__ */ new Set());
+		_defineProperty(this, "_xlpmPrefix", "_xlpm.");
+		_defineProperty(this, "_xlfnPrefix", "_xlfn.");
+		_defineProperty(this, "_currentUnitId", "");
+	}
+	_resetPrefix() {
+		this._xlpmPrefix = "_xlpm.";
+		this._xlfnPrefix = "_xlfn.";
+	}
+	_clearPrefix() {
+		this._xlpmPrefix = "";
+		this._xlfnPrefix = "";
 	}
 	dispose() {
 		this._resetTemp();
@@ -3479,11 +4494,289 @@ var LexerTreeBuilder = class extends _univerjs_core.Disposable {
 		});
 	}
 	getNewFormulaWithPrefix(formulaString, hasFunction) {
+		const lexerNode = this.treeBuilder(formulaString, false);
+		if (!lexerNode || lexerNode === "#VALUE!" || Array.isArray(lexerNode)) return null;
+		const formulaStrings = [];
+		this._hasNewExcelFunction = false;
+		this._generateNewFunctionString(lexerNode, formulaStrings, hasFunction);
+		if (this._hasNewExcelFunction) return `=${formulaStrings.join("")}`;
 		return null;
 	}
+	_generateNewFunctionString(lexerNode, formulaStrings, hasFunction) {
+		const token = lexerNode.getToken();
+		const tokenTrim = token.trim();
+		const tokenTrimUpper = tokenTrim.toUpperCase();
+		const tokenForFunction = this._clearFunctionString(tokenTrimUpper);
+		const isFunctionNode = hasFunction(tokenForFunction);
+		let curNodeType = 0;
+		if (token === "R_1") curNodeType = 3;
+		else if (token === "P_1") curNodeType = 4;
+		else if (token === "L_1") curNodeType = 5;
+		else if (NEW_EXCEL_FUNCTIONS.has(tokenForFunction)) {
+			formulaStrings.push(`${this._xlfnPrefix}${tokenTrim}`);
+			this._hasNewExcelFunction = true;
+		} else if (tokenTrimUpper === "LAMBDA") {
+			formulaStrings.push(`${this._xlfnPrefix}${tokenTrim}`);
+			this._hasNewExcelFunction = true;
+			curNodeType = 2;
+		} else if (tokenTrimUpper === "LET") {
+			formulaStrings.push(`${this._xlfnPrefix}${tokenTrim}`);
+			this._hasNewExcelFunction = true;
+			curNodeType = 1;
+		} else if (tokenTrimUpper === ":") curNodeType = 8;
+		else if (SUFFIX_TOKEN_SET.has(tokenTrimUpper)) curNodeType = 7;
+		else if (tokenTrimUpper === "-") {
+			if (this._checkAddBracketForMinus(lexerNode)) curNodeType = 9;
+			formulaStrings.push(token);
+		} else {
+			formulaStrings.push(token);
+			curNodeType = 10;
+		}
+		if (isFunctionNode) {
+			if (curNodeType !== 2 && curNodeType !== 1) curNodeType = 6;
+			formulaStrings.push("(");
+		} else if (curNodeType === 9) formulaStrings.push("(");
+		const children = lexerNode.getChildren();
+		const childrenCount = children.length;
+		if (curNodeType === 2) {
+			const firstChild = children[0];
+			let firstIsInputIndex = 0;
+			if (firstChild instanceof LexerNode) {
+				if (firstChild.getToken() === "L_1") firstIsInputIndex = 1;
+			}
+			for (let i = firstIsInputIndex; i < childrenCount - 1; i++) {
+				const item = children[i];
+				if (item instanceof LexerNode) {
+					const varName = item.getChildren()[0];
+					if (typeof varName === "string") {
+						if (this._lambdaFunctionParameterSet.has(varName)) console.error(`Lambda parameter name "${varName}" is duplicated.`);
+						this._lambdaFunctionParameterSet.add(varName);
+						formulaStrings.push(`${this._xlpmPrefix}${varName}`);
+						this._hasNewExcelFunction = true;
+					}
+				}
+				formulaStrings.push(",");
+			}
+			this._handleNewFunctionChild(children[childrenCount - 1], formulaStrings, hasFunction);
+			if (firstIsInputIndex === 1) {
+				formulaStrings.push(")");
+				formulaStrings.push("(");
+				this._generateNewFunctionString(firstChild, formulaStrings, hasFunction);
+				formulaStrings.push(")");
+			} else formulaStrings.push(")");
+			return;
+		} else if (curNodeType === 1) {
+			for (let i = 0; i < childrenCount - 1; i++) {
+				const item = children[i];
+				if (item instanceof LexerNode && i % 2 === 0) {
+					const varName = item.getChildren()[0];
+					if (typeof varName === "string") {
+						if (this._lambdaFunctionParameterSet.has(varName)) console.error(`Let variable name "${varName}" is duplicated.`);
+						this._lambdaFunctionParameterSet.add(varName);
+						formulaStrings.push(`${this._xlpmPrefix}${varName}`);
+						this._hasNewExcelFunction = true;
+						formulaStrings.push(",");
+						continue;
+					}
+				}
+				this._handleNewFunctionChild(item, formulaStrings, hasFunction);
+				if (item instanceof LexerNode) {
+					const nextItem = children[i + 1];
+					if (nextItem && nextItem instanceof LexerNode) formulaStrings.push(",");
+				}
+			}
+			this._handleNewFunctionChild(children[childrenCount - 1], formulaStrings, hasFunction);
+			formulaStrings.push(")");
+			return;
+		} else if (curNodeType === 8) {
+			const firstNode = children[0];
+			const secondNode = children[1];
+			this._handleNewFunctionChild(firstNode, formulaStrings, hasFunction);
+			formulaStrings.push(token);
+			this._handleNewFunctionChild(secondNode, formulaStrings, hasFunction);
+			return;
+		}
+		for (let i = 0; i < childrenCount; i++) {
+			const item = children[i];
+			this._handleNewFunctionChild(item, formulaStrings, hasFunction);
+			if (item instanceof LexerNode) {
+				const nextItem = children[i + 1];
+				if (nextItem && nextItem instanceof LexerNode) formulaStrings.push(",");
+			}
+		}
+		if (curNodeType === 7) formulaStrings.push(token);
+		if (isFunctionNode) formulaStrings.push(")");
+		else if (curNodeType === 9) formulaStrings.push(")");
+	}
+	_handleNewFunctionChild(item, formulaStrings, hasFunction) {
+		if (item instanceof LexerNode) this._generateNewFunctionString(item, formulaStrings, hasFunction);
+		else if (this._lambdaFunctionParameterSet.has(item)) {
+			formulaStrings.push(`${this._xlpmPrefix}${item}`);
+			this._hasNewExcelFunction = true;
+		} else formulaStrings.push(item);
+	}
+	_clearFunctionString(token) {
+		let t = token.trim();
+		if (!t) return t;
+		const firstChar = t[0];
+		if (firstChar === "@" || firstChar === "-" || firstChar === "+") t = t.slice(1);
+		if (!t) return t;
+		const lastChar = t[t.length - 1];
+		if (SUFFIX_TOKEN_SET.has(lastChar)) t = t.slice(0, -1);
+		return t;
+	}
+	_checkAddBracketForMinus(node) {
+		const childrenFirst = node.getChildren()[0];
+		if (!childrenFirst || !(childrenFirst instanceof LexerNode) || node.getChildren().length > 1) return false;
+		const children = childrenFirst.getChildren();
+		const childrenCount = children.length;
+		if (childrenCount === 1) return false;
+		for (let i = 0; i < childrenCount; i++) {
+			const item = children[i];
+			if (!(item instanceof LexerNode) && OPERATOR_TOKEN_SET.has(item)) return true;
+		}
+		return false;
+	}
 	getFormulaExprTree(formulaString, unitId, hasFunction, getDefinedNameName, getTable) {
+		const lexerNode = this.treeBuilder(formulaString, false);
+		if (!lexerNode || lexerNode === "#VALUE!" || Array.isArray(lexerNode)) return null;
+		this._clearPrefix();
+		this._currentUnitId = unitId;
+		const newNode = this._generateExprTree(lexerNode, hasFunction, getDefinedNameName, getTable);
+		this._currentUnitId = "";
+		this._resetPrefix();
+		return newNode;
+	}
+	_generateExprTree(lexerNodeRoot, hasFunction, getDefinedNameName, getTable) {
+		const newNode = {
+			value: "",
+			children: [],
+			startIndex: 0
+		};
+		let lexerNode = lexerNodeRoot;
+		if (lexerNode instanceof LexerNode && (lexerNode.getToken() === "R_1" || lexerNode.getToken() === "P_1") && lexerNode.getChildren().length === 1) lexerNode = lexerNode.getChildren()[0];
+		if (!(lexerNode instanceof LexerNode)) return this._handleTextNodeForExprTree(lexerNode, getDefinedNameName, getTable);
+		const children = lexerNode.getChildren();
+		const childrenCount = children.length;
+		const formulaStrings = [];
+		this._generateNewFunctionString(lexerNode, formulaStrings, hasFunction);
+		newNode.value = formulaStrings.join("");
+		newNode.startIndex = lexerNode.getStartIndex();
+		const curNodeType = this._getCurNodeTypeForExprTree(lexerNode);
+		if (curNodeType === 2) {
+			const firstChild = children[0];
+			if (firstChild instanceof LexerNode) {
+				if (firstChild.getToken().trim() !== "L_1") return newNode;
+				this._handleLambdaForExprTree(firstChild, newNode, hasFunction, getDefinedNameName, getTable);
+			}
+			return newNode;
+		} else if (curNodeType === 1) {
+			for (let i = 0; i < childrenCount - 1; i++) {
+				const item = children[i];
+				if (item instanceof LexerNode && i % 2 === 1) {
+					const itemChildren = item.getChildren();
+					if (itemChildren.length === 1 && !(itemChildren[0] instanceof LexerNode)) continue;
+					const childNode = this._generateExprTree(item, hasFunction, getDefinedNameName, getTable);
+					childNode && newNode.children.push(childNode);
+				}
+			}
+			return newNode;
+		} else if (curNodeType === 8) {
+			const firstNode = children[0];
+			if (firstNode instanceof LexerNode) {
+				const firstChildNode = firstNode.getChildren()[0];
+				if (firstChildNode instanceof LexerNode) newNode.startIndex = firstChildNode.getStartIndex();
+			}
+			if (this._checkColonNodeForExprTree(lexerNode)) return newNode;
+		} else if (curNodeType === 7) {
+			const firstNode = children[0];
+			if (firstNode instanceof LexerNode) {
+				const firstChildNode = firstNode.getChildren()[0];
+				if (firstChildNode instanceof LexerNode) newNode.startIndex = firstChildNode.getStartIndex();
+			}
+		}
+		this._handleChildrenForExprTree(children, curNodeType, newNode, hasFunction, getDefinedNameName, getTable);
+		return newNode;
+	}
+	_handleChildrenForExprTree(children, curNodeType, newNode, hasFunction, getDefinedNameName, getTable) {
+		for (let i = 0; i < children.length; i++) {
+			let item = children[i];
+			if (!(item instanceof LexerNode)) {
+				const childNode = this._handleTextNodeForExprTree(item, getDefinedNameName, getTable);
+				childNode && newNode.children.push(childNode);
+				continue;
+			}
+			const itemChildren = item.getChildren();
+			if (itemChildren.length === 1 && !(itemChildren[0] instanceof LexerNode)) {
+				const itemChild = itemChildren[0];
+				if (!getDefinedNameName(this._currentUnitId, itemChild) && !this._getTableNameFromStructuredRef(itemChild, getTable) && !isReferenceString(itemChild)) continue;
+			}
+			if (curNodeType === 8) {
+				const refNode = itemChildren[0];
+				if (refNode instanceof LexerNode) {
+					if (isReferenceString(refNode.getToken().trim())) continue;
+					item = refNode;
+				}
+			}
+			const childNode = this._generateExprTree(item, hasFunction, getDefinedNameName, getTable);
+			childNode && newNode.children.push(childNode);
+		}
+	}
+	_checkColonNodeForExprTree(item) {
+		const itemChildren = item.getChildren();
+		if (itemChildren.length < 2) return false;
+		const firstChild = itemChildren[0];
+		const secondChild = itemChildren[1];
+		if (!(firstChild instanceof LexerNode) || !(secondChild instanceof LexerNode)) return false;
+		const firstGrandChild = firstChild.getChildren()[0];
+		const secondGrandChild = secondChild.getChildren()[0];
+		if (!(firstGrandChild instanceof LexerNode) || !(secondGrandChild instanceof LexerNode)) return false;
+		const firstChildToken = firstGrandChild.getToken().trim();
+		const secondChildToken = secondGrandChild.getToken().trim();
+		if (isReferenceString(`${firstChildToken}${":"}${secondChildToken}`)) return true;
+		return false;
+	}
+	_handleTextNodeForExprTree(item, getDefinedNameName, getTable) {
+		const itemTrim = item.trim();
+		if (itemTrim.startsWith("{") && itemTrim.endsWith("}") || getDefinedNameName(this._currentUnitId, itemTrim) || this._getTableNameFromStructuredRef(itemTrim, getTable) || isReferenceString(itemTrim)) return {
+			value: itemTrim,
+			children: [],
+			startIndex: -1
+		};
 		return null;
 	}
+	_getTableNameFromStructuredRef(token, getTable) {
+		const { tableName } = splitTableStructuredRef(token);
+		if (getTable(this._currentUnitId, tableName)) return tableName;
+		return null;
+	}
+	_handleLambdaForExprTree(firstChild, newNode, hasFunction, getDefinedNameName, getTable) {
+		const firstGrandchildren = firstChild.getChildren();
+		for (let i = 0; i < firstGrandchildren.length; i++) {
+			const item = firstGrandchildren[i];
+			if (!(item instanceof LexerNode)) continue;
+			const itemChildren = item.getChildren();
+			if (itemChildren.length === 1 && !(itemChildren[0] instanceof LexerNode)) continue;
+			const childNode = this._generateExprTree(item, hasFunction, getDefinedNameName, getTable);
+			childNode && newNode.children.push(childNode);
+		}
+	}
+	_getCurNodeTypeForExprTree(lexerNode) {
+		const token = lexerNode.getToken();
+		const tokenTrimUpper = token.trim().toUpperCase();
+		let curNodeType = 0;
+		if (token === "R_1") curNodeType = 3;
+		else if (token === "P_1") curNodeType = 4;
+		else if (token === "L_1") curNodeType = 5;
+		else if (tokenTrimUpper === "LAMBDA") curNodeType = 2;
+		else if (tokenTrimUpper === "LET") curNodeType = 1;
+		else if (tokenTrimUpper === ":") curNodeType = 8;
+		else if (SUFFIX_TOKEN_SET.has(tokenTrimUpper)) curNodeType = 7;
+		else if (tokenTrimUpper === "-") {
+			if (this._checkAddBracketForMinus(lexerNode)) curNodeType = 9;
+		} else curNodeType = 10;
+		return curNodeType;
+	}
 };
 
 //#endregion
@@ -3539,13 +4832,24 @@ function updateFormulaDataByCellValue(sheetFormulaDataMatrix, newSheetFormulaDat
 }
 function clearArrayFormulaCellDataByCell(arrayFormulaRangeMatrix, arrayFormulaCellDataMatrix, r, c) {
 	const arrayFormulaRangeValue = arrayFormulaRangeMatrix === null || arrayFormulaRangeMatrix === void 0 ? void 0 : arrayFormulaRangeMatrix.getValue(r, c);
-	if (arrayFormulaRangeValue == null) return true;
+	if (arrayFormulaRangeValue == null) {
+		let changed = false;
+		arrayFormulaRangeMatrix.forValue((_, __, range) => {
+			if (_univerjs_core.Rectangle.contains(range, (0, _univerjs_core.cellToRange)(r, c))) {
+				arrayFormulaCellDataMatrix.realDeleteValue(r, c);
+				changed = true;
+				return false;
+			}
+		});
+		return changed;
+	}
+	const targetArrayFormulaRange = arrayFormulaRangeValue;
 	const intersection = [];
 	arrayFormulaRangeMatrix.forValue((rangeRow, rangeCol, range) => {
 		if (rangeRow === r && rangeCol === c) return;
-		if (_univerjs_core.Rectangle.intersects(range, arrayFormulaRangeValue)) intersection.push(range);
+		if (_univerjs_core.Rectangle.intersects(range, targetArrayFormulaRange)) intersection.push(range);
 	});
-	const { startRow, startColumn, endRow, endColumn } = arrayFormulaRangeValue;
+	const { startRow, startColumn, endRow, endColumn } = targetArrayFormulaRange;
 	for (let row = startRow; row <= endRow; row++) for (let col = startColumn; col <= endColumn; col++) {
 		let isOverlapping = false;
 		const currentCell = (0, _univerjs_core.cellToRange)(row, col);
@@ -3558,6 +4862,7 @@ function clearArrayFormulaCellDataByCell(arrayFormulaRangeMatrix, arrayFormulaCe
 		});
 		if (!isOverlapping) arrayFormulaCellDataMatrix.realDeleteValue(row, col);
 	}
+	return true;
 }
 
 //#endregion
@@ -3596,7 +4901,7 @@ let FormulaDataModel = class FormulaDataModel extends _univerjs_core.Disposable
 					const range = rangeMatrix.getValue(row, column);
 					if (range == null) return true;
 					const { startRow, startColumn, endRow, endColumn } = range;
-					for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) arrayFormulaCellMatrixData.setValue(r, c, null);
+					for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) arrayFormulaCellMatrixData.realDeleteValue(r, c);
 					rangeMatrix.realDeleteValue(row, column);
 				});
 				if (this._arrayFormulaCellData[unitId]) this._arrayFormulaCellData[unitId][sheetId] = arrayFormulaCellMatrixData.getData();
@@ -3621,10 +4926,11 @@ let FormulaDataModel = class FormulaDataModel extends _univerjs_core.Disposable
 					const arrayFormulaRange = arrayFormulaRangeMatrix === null || arrayFormulaRangeMatrix === void 0 ? void 0 : arrayFormulaRangeMatrix.getValue(row, column);
 					if (arrayFormulaRange == null) return true;
 					const { startRow, startColumn, endRow, endColumn } = arrayFormulaRange;
-					for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) arrayFormulaCellMatrixData.setValue(r, c, null);
+					for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) arrayFormulaCellMatrixData.realDeleteValue(r, c);
 				});
 				cellMatrixData.forValue((row, column, cellData) => {
-					arrayFormulaCellMatrixData.setValue(row, column, cellData);
+					if (cellData == null) arrayFormulaCellMatrixData.realDeleteValue(row, column);
+					else arrayFormulaCellMatrixData.setValue(row, column, cellData);
 				});
 				if (this._arrayFormulaCellData[unitId]) this._arrayFormulaCellData[unitId][sheetId] = arrayFormulaCellMatrixData.getData();
 			});
@@ -3850,23 +5156,34 @@ let FormulaDataModel = class FormulaDataModel extends _univerjs_core.Disposable
 	updateArrayFormulaRange(unitId, sheetId, cellValue) {
 		var _this$_arrayFormulaRa5;
 		const arrayFormulaRange = (_this$_arrayFormulaRa5 = this._arrayFormulaRange[unitId]) === null || _this$_arrayFormulaRa5 === void 0 ? void 0 : _this$_arrayFormulaRa5[sheetId];
-		if (!arrayFormulaRange) return;
+		if (!arrayFormulaRange) return false;
 		const arrayFormulaRangeMatrix = new _univerjs_core.ObjectMatrix(arrayFormulaRange);
-		new _univerjs_core.ObjectMatrix(cellValue).forValue((r, c, cell) => {
-			arrayFormulaRangeMatrix.realDeleteValue(r, c);
+		const cellMatrix = new _univerjs_core.ObjectMatrix(cellValue);
+		let changed = false;
+		cellMatrix.forValue((r, c) => {
+			if (arrayFormulaRangeMatrix.getValue(r, c) != null) {
+				arrayFormulaRangeMatrix.realDeleteValue(r, c);
+				changed = true;
+			}
 		});
+		if (changed && this._arrayFormulaRange[unitId]) this._arrayFormulaRange[unitId][sheetId] = arrayFormulaRangeMatrix.getData();
+		return changed;
 	}
 	updateArrayFormulaCellData(unitId, sheetId, cellValue) {
 		var _this$_arrayFormulaRa6, _this$_arrayFormulaCe4;
 		const arrayFormulaRange = (_this$_arrayFormulaRa6 = this._arrayFormulaRange[unitId]) === null || _this$_arrayFormulaRa6 === void 0 ? void 0 : _this$_arrayFormulaRa6[sheetId];
-		if (!arrayFormulaRange) return;
+		if (!arrayFormulaRange) return false;
 		const arrayFormulaRangeMatrix = new _univerjs_core.ObjectMatrix(arrayFormulaRange);
 		const arrayFormulaCellData = (_this$_arrayFormulaCe4 = this._arrayFormulaCellData[unitId]) === null || _this$_arrayFormulaCe4 === void 0 ? void 0 : _this$_arrayFormulaCe4[sheetId];
-		if (!arrayFormulaCellData) return;
+		if (!arrayFormulaCellData) return false;
 		const arrayFormulaCellDataMatrix = new _univerjs_core.ObjectMatrix(arrayFormulaCellData);
-		new _univerjs_core.ObjectMatrix(cellValue).forValue((r, c, cell) => {
-			clearArrayFormulaCellDataByCell(arrayFormulaRangeMatrix, arrayFormulaCellDataMatrix, r, c);
+		const cellMatrix = new _univerjs_core.ObjectMatrix(cellValue);
+		let changed = false;
+		cellMatrix.forValue((r, c) => {
+			changed = clearArrayFormulaCellDataByCell(arrayFormulaRangeMatrix, arrayFormulaCellDataMatrix, r, c) || changed;
 		});
+		if (changed && this._arrayFormulaCellData[unitId]) this._arrayFormulaCellData[unitId][sheetId] = arrayFormulaCellDataMatrix.getData();
+		return changed;
 	}
 	updateImageFormulaData(unitId, sheetId, cellValue) {
 		var _this$_unitImageFormu;
@@ -3924,7 +5241,7 @@ let FormulaDataModel = class FormulaDataModel extends _univerjs_core.Disposable
 						const column = Number(columnStr);
 						const currentCell = sheetInstance.getCellRaw(row, column);
 						const isFormula = (0, _univerjs_core.isFormulaString)(currentCell === null || currentCell === void 0 ? void 0 : currentCell.f) || (0, _univerjs_core.isFormulaId)(currentCell === null || currentCell === void 0 ? void 0 : currentCell.si);
-						const noValue = (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === void 0 || (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === null || (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === "";
+						const noValue = (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === void 0 || (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === null || (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === "" || (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === 0 || (currentCell === null || currentCell === void 0 ? void 0 : currentCell.v) === "0";
 						if (!(isFormula && noValue)) continue;
 						if (!columnRanges[column]) columnRanges[column] = [];
 						const lastRange = columnRanges[column].slice(-1)[0];
@@ -4023,181 +5340,6 @@ function initSheetFormulaData(formulaData, unitId, sheetId, cellMatrix) {
 	return { [unitId]: { [sheetId]: newSheetFormulaData } };
 }
 
-//#endregion
-//#region src/basics/inverted-index-cache.ts
-const DEFAULT_EMPTY_CELL_KEY = Symbol("EMPTY_CELL");
-const normalizedValueMap = /* @__PURE__ */ new Map();
-function normalizeValue(value) {
-	if (normalizedValueMap.has(value)) return normalizedValueMap.get(value);
-	let _value;
-	if (value === null || value === void 0 || value === "") _value = DEFAULT_EMPTY_CELL_KEY;
-	else if ((0, _univerjs_core.isRealNum)(value) && Number(value).toString() === value.toString()) _value = Number(value) === 0 ? 0 : Number(value);
-	else if (typeof value === "string") _value = value.toLowerCase();
-	else _value = value;
-	normalizedValueMap.set(value, _value);
-	return _value;
-}
-var InvertedIndexCache = class {
-	constructor() {
-		_defineProperty(this, "_cache", /* @__PURE__ */ new Map());
-		_defineProperty(this, "_continueBuildingCache", /* @__PURE__ */ new Map());
-	}
-	set(unitId, sheetId, column, value, row, isForceUpdate = false) {
-		if (!this.shouldContinueBuildingCache(unitId, sheetId, column, row) && !isForceUpdate) return;
-		let unitMap = this._cache.get(unitId);
-		if (unitMap == null) {
-			unitMap = /* @__PURE__ */ new Map();
-			this._cache.set(unitId, unitMap);
-		}
-		let sheetMap = unitMap.get(sheetId);
-		if (sheetMap == null) {
-			sheetMap = /* @__PURE__ */ new Map();
-			unitMap.set(sheetId, sheetMap);
-		}
-		let columnMap = sheetMap.get(column);
-		if (columnMap == null) {
-			columnMap = /* @__PURE__ */ new Map();
-			sheetMap.set(column, columnMap);
-		}
-		if (isForceUpdate) {
-			for (const [_, _cellList] of columnMap) if (_cellList.has(row)) {
-				_cellList.delete(row);
-				break;
-			}
-		}
-		const _value = normalizeValue(value);
-		let cellList = columnMap.get(_value);
-		if (cellList == null) {
-			cellList = /* @__PURE__ */ new Set();
-			columnMap.set(_value, cellList);
-		}
-		cellList.add(row);
-	}
-	getCellValuePositions(unitId, sheetId, column) {
-		var _this$_cache$get;
-		return (_this$_cache$get = this._cache.get(unitId)) === null || _this$_cache$get === void 0 || (_this$_cache$get = _this$_cache$get.get(sheetId)) === null || _this$_cache$get === void 0 ? void 0 : _this$_cache$get.get(column);
-	}
-	getCellPositions(unitId, sheetId, column, value, rowsInCache) {
-		var _this$_cache$get2;
-		const columnMap = (_this$_cache$get2 = this._cache.get(unitId)) === null || _this$_cache$get2 === void 0 || (_this$_cache$get2 = _this$_cache$get2.get(sheetId)) === null || _this$_cache$get2 === void 0 ? void 0 : _this$_cache$get2.get(column);
-		if (!columnMap) return;
-		const result = {
-			errorType: null,
-			matchingRows: []
-		};
-		const _value = normalizeValue(value);
-		if (ERROR_TYPE_SET.has(_value)) result.errorType = _value;
-		else if (_value === 0 || _value === DEFAULT_EMPTY_CELL_KEY) {
-			const rows = [];
-			const rowsForZero = columnMap.get(0);
-			if (rowsForZero) rows.push(...rowsForZero);
-			const rowsForEmpty = columnMap.get(DEFAULT_EMPTY_CELL_KEY);
-			if (rowsForEmpty) rows.push(...rowsForEmpty);
-			result.matchingRows = rows.filter((row) => rowsInCache.some(([start, end]) => row >= start && row <= end));
-		} else {
-			var _columnMap$get;
-			result.matchingRows = Array.from((_columnMap$get = columnMap.get(_value)) !== null && _columnMap$get !== void 0 ? _columnMap$get : []).filter((row) => rowsInCache.some(([start, end]) => row >= start && row <= end));
-		}
-		return result;
-	}
-	setContinueBuildingCache(unitId, sheetId, column, startRow, endRow) {
-		if (column === -1 || startRow === -1 || endRow === -1) return;
-		let unitMap = this._continueBuildingCache.get(unitId);
-		if (unitMap == null) {
-			unitMap = /* @__PURE__ */ new Map();
-			this._continueBuildingCache.set(unitId, unitMap);
-		}
-		let sheetMap = unitMap.get(sheetId);
-		if (sheetMap == null) {
-			sheetMap = /* @__PURE__ */ new Map();
-			unitMap.set(sheetId, sheetMap);
-		}
-		let columnMap = sheetMap.get(column);
-		if (columnMap == null) {
-			columnMap = new _flatten_js_interval_tree.default();
-			columnMap.insert([startRow, endRow]);
-			sheetMap.set(column, columnMap);
-			return;
-		}
-		this._handleNewInterval(columnMap, startRow, endRow);
-	}
-	shouldContinueBuildingCache(unitId, sheetId, column, row) {
-		var _this$_continueBuildi;
-		if (column === -1 || row === -1) return false;
-		const columnMap = (_this$_continueBuildi = this._continueBuildingCache.get(unitId)) === null || _this$_continueBuildi === void 0 || (_this$_continueBuildi = _this$_continueBuildi.get(sheetId)) === null || _this$_continueBuildi === void 0 ? void 0 : _this$_continueBuildi.get(column);
-		if (!columnMap) return true;
-		return columnMap.search([row, row]).length === 0;
-	}
-	canUseCache(unitId, sheetId, column, rangeStartRow, rangeEndRow) {
-		var _this$_continueBuildi2;
-		const columnMap = (_this$_continueBuildi2 = this._continueBuildingCache.get(unitId)) === null || _this$_continueBuildi2 === void 0 || (_this$_continueBuildi2 = _this$_continueBuildi2.get(sheetId)) === null || _this$_continueBuildi2 === void 0 ? void 0 : _this$_continueBuildi2.get(column);
-		if (column === -1 || rangeStartRow === -1 || rangeEndRow === -1 || !columnMap) return {
-			rowsInCache: [],
-			rowsNotInCache: []
-		};
-		const result = columnMap.search([rangeStartRow, rangeEndRow]);
-		if (result.length === 0) return {
-			rowsInCache: [],
-			rowsNotInCache: []
-		};
-		result.sort((a, b) => a[0] - b[0]);
-		const rowsInCache = [];
-		const rowsNotInCache = [];
-		let _rangeStartRow = rangeStartRow;
-		for (let i = 0; i < result.length; i++) {
-			const [start, end] = result[i];
-			if (_rangeStartRow >= start) {
-				if (rangeEndRow <= end) {
-					rowsInCache.push([_rangeStartRow, rangeEndRow]);
-					break;
-				}
-				rowsInCache.push([_rangeStartRow, end]);
-				_rangeStartRow = end + 1;
-				if (i === result.length - 1 && _rangeStartRow <= rangeEndRow) rowsNotInCache.push([_rangeStartRow, rangeEndRow]);
-			} else {
-				if (rangeEndRow > end) {
-					rowsInCache.push([start, end]);
-					rowsNotInCache.push([_rangeStartRow, start - 1]);
-					_rangeStartRow = end + 1;
-					if (i === result.length - 1 && _rangeStartRow <= rangeEndRow) rowsNotInCache.push([_rangeStartRow, rangeEndRow]);
-					continue;
-				}
-				rowsInCache.push([start, rangeEndRow]);
-				rowsNotInCache.push([_rangeStartRow, start - 1]);
-			}
-		}
-		return {
-			rowsInCache,
-			rowsNotInCache
-		};
-	}
-	clear() {
-		this._cache.clear();
-		this._continueBuildingCache.clear();
-		normalizedValueMap.clear();
-	}
-	_handleNewInterval(columnMap, startRow, endRow) {
-		let result = columnMap.search([startRow, endRow]);
-		if (result.length === 0) {
-			const adjacentRange = [startRow - 1 < 0 ? 0 : startRow - 1, endRow + 1];
-			result = columnMap.search(adjacentRange);
-			if (result.length === 0) {
-				columnMap.insert([startRow, endRow]);
-				return;
-			}
-		}
-		let min = startRow;
-		let max = endRow;
-		for (const interval of result) {
-			min = Math.min(min, interval[0]);
-			max = Math.max(max, interval[1]);
-			columnMap.remove(interval);
-		}
-		columnMap.insert([min, max]);
-	}
-};
-const CELL_INVERTED_INDEX_CACHE = new InvertedIndexCache();
-
 //#endregion
 //#region src/services/sheet-row-filtered.service.ts
 /**
@@ -8386,7 +9528,10 @@ let FormulaRuntimeService = class FormulaRuntimeService extends _univerjs_core.D
 				endColumn: endColumn - startColumn + column
 			};
 			arrayData.setValue(row, column, arrayRange);
-			if (this._checkIfArrayFormulaRangeHasData(unitId, sheetId, row, column, arrayRange) || this._checkIfArrayFormulaExceeded(rowCount, columnCount, arrayRange)) {
+			const hasDataInArrayFormulaRange = this._checkIfArrayFormulaRangeHasData(unitId, sheetId, row, column, arrayRange);
+			const isArrayFormulaExceeded = this._checkIfArrayFormulaExceeded(rowCount, columnCount, arrayRange);
+			if (hasDataInArrayFormulaRange || isArrayFormulaExceeded) {
+				var _this$_currentConfigS;
 				const errorObject = this._getValueObjectOfRuntimeData(ErrorValueObject.create("#SPILL!"));
 				sheetData.setValue(row, column, errorObject);
 				clearArrayUnitData.setValue(row, column, errorObject);
@@ -8396,17 +9541,21 @@ let FormulaRuntimeService = class FormulaRuntimeService extends _univerjs_core.D
 				* In this case, you need to clear the previous range data to prevent other formulas from referencing the old values.
 				*/
 				const unitData = this._currentConfigService.getUnitData();
+				const arrayData = this._currentConfigService.getArrayFormulaCellData();
+				const previousArrayFormulaRange = (_this$_currentConfigS = this._currentConfigService.getArrayFormulaRange()[unitId]) === null || _this$_currentConfigS === void 0 || (_this$_currentConfigS = _this$_currentConfigS[sheetId]) === null || _this$_currentConfigS === void 0 || (_this$_currentConfigS = _this$_currentConfigS[row]) === null || _this$_currentConfigS === void 0 ? void 0 : _this$_currentConfigS[column];
 				objectValueRefOrArray.iterator((_, rowIndex, columnIndex) => {
-					var _unitData$unitId;
+					var _unitData$unitId, _arrayData$unitId;
 					const currentRow = rowIndex - startRow + row;
 					const currentColumn = columnIndex - startColumn + column;
 					const cell = (_unitData$unitId = unitData[unitId]) === null || _unitData$unitId === void 0 || (_unitData$unitId = _unitData$unitId[sheetId]) === null || _unitData$unitId === void 0 ? void 0 : _unitData$unitId.cellData.getValue(currentRow, currentColumn);
+					const arrayDataCell = arrayData === null || arrayData === void 0 || (_arrayData$unitId = arrayData[unitId]) === null || _arrayData$unitId === void 0 || (_arrayData$unitId = _arrayData$unitId[sheetId]) === null || _arrayData$unitId === void 0 ? void 0 : _arrayData$unitId.getValue(currentRow, currentColumn);
+					const shouldClearPreviousCellOfCurrentArrayFormula = this._arrayCellHasData(arrayDataCell) && this._isInArrayFormulaRange(previousArrayFormulaRange, currentRow, currentColumn) && (cell == null || this._isSameCellValue(cell, arrayDataCell));
 					if (rowIndex === startRow && columnIndex === startColumn) runtimeArrayUnitData.setValue(row, column, errorObject);
+					else if (shouldClearPreviousCellOfCurrentArrayFormula) sheetData.setValue(currentRow, currentColumn, null);
 					else if (cell != null) {
 						if (cell.v == null) cell.v = "";
-						runtimeArrayUnitData.setValue(currentRow, currentColumn, cell);
+						sheetData.setValue(currentRow, currentColumn, { ...cell });
 					} else if (this._isInOtherArrayFormulaRange(unitId, sheetId, row, column, currentRow, currentColumn)) return true;
-					else runtimeArrayUnitData.setValue(currentRow, currentColumn, { v: "" });
 				});
 			} else {
 				const spillError = ErrorValueObject.create("#SPILL!");
@@ -8519,954 +9668,282 @@ let FormulaRuntimeService = class FormulaRuntimeService extends _univerjs_core.D
 	getRuntimeState() {
 		return {
 			totalFormulasToCalculate: this.getTotalFormulasToCalculate(),
-			completedFormulasCount: this.getCompletedFormulasCount(),
-			totalArrayFormulasToCalculate: this.getTotalArrayFormulasToCalculate(),
-			completedArrayFormulasCount: this.getCompletedArrayFormulasCount(),
-			stage: this.getFormulaExecuteStage(),
-			formulaCycleIndex: this.getFormulaCycleIndex()
-		};
-	}
-	clearArrayObjectCache() {
-		FORMULA_REF_TO_ARRAY_CACHE.clear();
-	}
-	_checkIfArrayFormulaRangeHasData(formulaUnitId, formulaSheetId, formulaRow, formulaColumn, arrayRange) {
-		var _this$_unitArrayFormu;
-		const { startRow, startColumn, endRow, endColumn } = arrayRange;
-		const unitData = this._currentConfigService.getUnitData();
-		const arrayData = this._currentConfigService.getArrayFormulaCellData();
-		(_this$_unitArrayFormu = this._unitArrayFormulaRange[formulaUnitId]) === null || _this$_unitArrayFormu === void 0 || (_this$_unitArrayFormu = _this$_unitArrayFormu[formulaSheetId]) === null || _this$_unitArrayFormu === void 0 || (_this$_unitArrayFormu = _this$_unitArrayFormu[formulaRow]) === null || _this$_unitArrayFormu === void 0 || _this$_unitArrayFormu[formulaColumn];
-		for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) {
-			var _this$_runtimeData, _arrayData$formulaUni, _unitData$formulaUnit;
-			if (r === formulaRow && formulaColumn === c) continue;
-			const cell = (_this$_runtimeData = this._runtimeData) === null || _this$_runtimeData === void 0 || (_this$_runtimeData = _this$_runtimeData[formulaUnitId]) === null || _this$_runtimeData === void 0 || (_this$_runtimeData = _this$_runtimeData[formulaSheetId]) === null || _this$_runtimeData === void 0 ? void 0 : _this$_runtimeData.getValue(r, c);
-			arrayData === null || arrayData === void 0 || (_arrayData$formulaUni = arrayData[formulaUnitId]) === null || _arrayData$formulaUni === void 0 || (_arrayData$formulaUni = _arrayData$formulaUni[formulaSheetId]) === null || _arrayData$formulaUni === void 0 || _arrayData$formulaUni.getValue(r, c);
-			const currentCell = unitData === null || unitData === void 0 || (_unitData$formulaUnit = unitData[formulaUnitId]) === null || _unitData$formulaUnit === void 0 || (_unitData$formulaUnit = _unitData$formulaUnit[formulaSheetId]) === null || _unitData$formulaUnit === void 0 || (_unitData$formulaUnit = _unitData$formulaUnit.cellData) === null || _unitData$formulaUnit === void 0 ? void 0 : _unitData$formulaUnit.getValue(r, c);
-			const featureCell = this._getRuntimeFeatureCellValue(r, c, formulaSheetId, formulaUnitId);
-			if (!isNullCellForFormula(cell) || this._isInOtherArrayFormulaRange(formulaUnitId, formulaSheetId, formulaRow, formulaColumn, r, c) || !isNullCellForFormula(currentCell) || !isNullCellForFormula(featureCell)) return true;
-		}
-		return false;
-	}
-	_getRuntimeFeatureCellValue(row, column, sheetId, unitId) {
-		return getRuntimeFeatureCell(row, column, sheetId, unitId, this._runtimeFeatureCellData);
-	}
-	_arrayCellHasData(cell) {
-		if (cell === null || cell === void 0) return false;
-		if (cell.v !== void 0) return true;
-		return false;
-	}
-	/**
-	* If the current array formula in the extended area intersects with the existing array formula, a #SPILL! error will be reported. Note that if other array formulas are already #SPILL!, they will not conflict with the current array formula
-	* @param formulaUnitId
-	* @param formulaSheetId
-	* @param formulaRow
-	* @param formulaColumn
-	* @param r
-	* @param c
-	* @returns
-	*/
-	_isInOtherArrayFormulaRange(formulaUnitId, formulaSheetId, formulaRow, formulaColumn, r, c) {
-		var _this$_currentConfigS;
-		const arrayFormulaRange = (_this$_currentConfigS = this._currentConfigService.getArrayFormulaRange()[formulaUnitId]) === null || _this$_currentConfigS === void 0 ? void 0 : _this$_currentConfigS[formulaSheetId];
-		if (arrayFormulaRange == null) return false;
-		let isCellOverlapping = false;
-		new _univerjs_core.ObjectMatrix(arrayFormulaRange).forValue((rangeRow, rangeCol, range) => {
-			var _this$_runtimeData$fo;
-			if (rangeRow === formulaRow && rangeCol === formulaColumn) return;
-			const isOverlapping = this._isInArrayFormulaRange(range, r, c);
-			const cell = (_this$_runtimeData$fo = this._runtimeData[formulaUnitId]) === null || _this$_runtimeData$fo === void 0 || (_this$_runtimeData$fo = _this$_runtimeData$fo[formulaSheetId]) === null || _this$_runtimeData$fo === void 0 ? void 0 : _this$_runtimeData$fo.getValue(rangeRow, rangeCol);
-			if (isOverlapping && (cell === null || cell === void 0 ? void 0 : cell.v) !== "#SPILL!") isCellOverlapping = true;
-		});
-		return isCellOverlapping;
-	}
-	_isInArrayFormulaRange(range, r, c) {
-		if (range == null) return false;
-		const { startRow, startColumn, endRow, endColumn } = range;
-		if (r >= startRow && r <= endRow && c >= startColumn && c <= endColumn) return true;
-		return false;
-	}
-	_checkIfArrayFormulaExceeded(rowCount, columnCount, arrayRange) {
-		if (arrayRange.endRow >= rowCount || arrayRange.endColumn >= columnCount) return true;
-		return false;
-	}
-	_isInDirtyRange(unitId, sheetId, row, column) {
-		const dirtyRanges = this._currentConfigService.getDirtyRanges();
-		if (dirtyRanges.length === 0) return true;
-		return isInDirtyRange(dirtyRanges, unitId, sheetId, row, column);
-	}
-};
-FormulaRuntimeService = __decorate([__decorateParam(0, IFormulaCurrentConfigService), __decorateParam(1, IHyperlinkEngineFormulaService)], FormulaRuntimeService);
-const IFormulaRuntimeService = (0, _univerjs_core.createIdentifier)("univer.formula.runtime.service");
-
-//#endregion
-//#region src/engine/ast-node/node-type.ts
-const NODE_ORDER_MAP = new Map([
-	[1, 7],
-	[2, 9],
-	[3, 8],
-	[4, 6],
-	[5, 1],
-	[6, 2],
-	[9, 10],
-	[10, 3],
-	[11, 4],
-	[12, 5]
-]);
-
-//#endregion
-//#region src/engine/ast-node/base-ast-node.ts
-var BaseAstNode = class {
-	constructor(_token) {
-		this._token = _token;
-		_defineProperty(this, "_children", []);
-		_defineProperty(this, "_definedNames", void 0);
-		_defineProperty(this, "_parent", void 0);
-		_defineProperty(this, "_valueObject", void 0);
-		_defineProperty(this, "_calculateState", false);
-		_defineProperty(this, "_async", false);
-		_defineProperty(this, "_address", false);
-		_defineProperty(this, "_isForcedCalculateFunction", false);
-	}
-	dispose() {
-		var _this$_valueObject;
-		this._children.forEach((node) => {
-			node.dispose();
-		});
-		(_this$_valueObject = this._valueObject) === null || _this$_valueObject === void 0 || _this$_valueObject.dispose();
-		this._valueObject = null;
-		this._children = [];
-		this._definedNames = null;
-		this._parent = null;
-	}
-	get nodeType() {
-		return 8;
-	}
-	resetCalculationState() {
-		this._children.forEach((node) => {
-			node.resetCalculationState();
-		});
-		this._valueObject = null;
-		this._calculateState = false;
-	}
-	isAsync() {
-		return this._async;
-	}
-	isAddress() {
-		return this._address;
-	}
-	isForcedCalculateFunction() {
-		return this._isForcedCalculateFunction;
-	}
-	setAsync() {
-		this._async = true;
-	}
-	setAddress() {
-		this._address = true;
-	}
-	getParent() {
-		return this._parent;
-	}
-	setParent(node) {
-		this._parent = node;
-		node.addChildren(this);
-	}
-	setForcedCalculateFunction() {
-		this._isForcedCalculateFunction = true;
-	}
-	getChildren() {
-		return this._children;
-	}
-	addChildren(...astNode) {
-		this._children.push(...astNode);
-	}
-	getToken() {
-		return this._token;
-	}
-	setValue(value) {
-		this._valueObject = value;
-	}
-	getValue() {
-		return this._valueObject;
-	}
-	isCalculated() {
-		return this._calculateState;
-	}
-	setCalculated() {
-		this._calculateState = true;
-	}
-	execute() {}
-	setNotEmpty(state = true) {}
-	async executeAsync() {
-		return Promise.resolve(0);
-	}
-	serialize() {
-		const token = this.getToken();
-		const children = this.getChildren();
-		const childrenSerialization = [];
-		const childrenCount = children.length;
-		for (let i = 0; i < childrenCount; i++) {
-			const item = children[i];
-			childrenSerialization.push(item.serialize());
-		}
-		const result = {
-			token,
-			nodeType: this.nodeType
-		};
-		if (childrenCount > 0) result.children = childrenSerialization;
-		return result;
-	}
-	hasDefinedName(definedName) {
-		var _this$_definedNames;
-		return ((_this$_definedNames = this._definedNames) === null || _this$_definedNames === void 0 ? void 0 : _this$_definedNames.includes(definedName)) || false;
-	}
-	setDefinedNames(definedNames) {
-		this._definedNames = definedNames;
-	}
-	getDefinedNames() {
-		return this._definedNames;
-	}
-};
-var ErrorNode = class ErrorNode extends BaseAstNode {
-	constructor(errorType) {
-		super(errorType);
-		_defineProperty(this, "_errorValueObject", void 0);
-		this._errorValueObject = ErrorValueObject.create(errorType);
-	}
-	get nodeType() {
-		return 7;
-	}
-	static create(errorType) {
-		return new ErrorNode(errorType);
-	}
-	getValue() {
-		return this._errorValueObject;
-	}
-};
-
-//#endregion
-//#region src/engine/ast-node/base-ast-node-factory.ts
-var BaseAstNodeFactory = class {
-	get zIndex() {
-		return 0;
-	}
-	dispose() {}
-	create(param, currentRow, currentColumn) {
-		let token;
-		if (param instanceof LexerNode) token = param.getToken();
-		else token = param;
-		return new BaseAstNode(token);
+			completedFormulasCount: this.getCompletedFormulasCount(),
+			totalArrayFormulasToCalculate: this.getTotalArrayFormulasToCalculate(),
+			completedArrayFormulasCount: this.getCompletedArrayFormulasCount(),
+			stage: this.getFormulaExecuteStage(),
+			formulaCycleIndex: this.getFormulaCycleIndex()
+		};
 	}
-};
-
-//#endregion
-//#region src/engine/ast-node/ast-root-node.ts
-var AstRootNode = class extends BaseAstNode {
-	get nodeType() {
-		return 9;
+	clearArrayObjectCache() {
+		FORMULA_REF_TO_ARRAY_CACHE.clear();
 	}
-	execute() {
-		const children = this.getChildren();
-		if (children.length > 1) {
-			this.setValue(ErrorValueObject.create("#VALUE!"));
-			return;
+	_checkIfArrayFormulaRangeHasData(formulaUnitId, formulaSheetId, formulaRow, formulaColumn, arrayRange) {
+		var _this$_currentConfigS2;
+		const { startRow, startColumn, endRow, endColumn } = arrayRange;
+		const unitData = this._currentConfigService.getUnitData();
+		const arrayData = this._currentConfigService.getArrayFormulaCellData();
+		const previousArrayFormulaRange = (_this$_currentConfigS2 = this._currentConfigService.getArrayFormulaRange()[formulaUnitId]) === null || _this$_currentConfigS2 === void 0 || (_this$_currentConfigS2 = _this$_currentConfigS2[formulaSheetId]) === null || _this$_currentConfigS2 === void 0 || (_this$_currentConfigS2 = _this$_currentConfigS2[formulaRow]) === null || _this$_currentConfigS2 === void 0 ? void 0 : _this$_currentConfigS2[formulaColumn];
+		for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) {
+			var _this$_runtimeData, _arrayData$formulaUni, _unitData$formulaUnit;
+			if (r === formulaRow && formulaColumn === c) continue;
+			const cell = (_this$_runtimeData = this._runtimeData) === null || _this$_runtimeData === void 0 || (_this$_runtimeData = _this$_runtimeData[formulaUnitId]) === null || _this$_runtimeData === void 0 || (_this$_runtimeData = _this$_runtimeData[formulaSheetId]) === null || _this$_runtimeData === void 0 ? void 0 : _this$_runtimeData.getValue(r, c);
+			const arrayDataCell = arrayData === null || arrayData === void 0 || (_arrayData$formulaUni = arrayData[formulaUnitId]) === null || _arrayData$formulaUni === void 0 || (_arrayData$formulaUni = _arrayData$formulaUni[formulaSheetId]) === null || _arrayData$formulaUni === void 0 ? void 0 : _arrayData$formulaUni.getValue(r, c);
+			const currentCell = unitData === null || unitData === void 0 || (_unitData$formulaUnit = unitData[formulaUnitId]) === null || _unitData$formulaUnit === void 0 || (_unitData$formulaUnit = _unitData$formulaUnit[formulaSheetId]) === null || _unitData$formulaUnit === void 0 || (_unitData$formulaUnit = _unitData$formulaUnit.cellData) === null || _unitData$formulaUnit === void 0 ? void 0 : _unitData$formulaUnit.getValue(r, c);
+			const featureCell = this._getRuntimeFeatureCellValue(r, c, formulaSheetId, formulaUnitId);
+			const isPreviousCellOfCurrentArrayFormula = this._arrayCellHasData(arrayDataCell) && this._isInArrayFormulaRange(previousArrayFormulaRange, r, c) && (currentCell == null || this._isSameCellValue(currentCell, arrayDataCell));
+			const hasRuntimeCell = !isNullCellForFormula(cell);
+			const isInOtherArrayFormulaRange = this._isInOtherArrayFormulaRange(formulaUnitId, formulaSheetId, formulaRow, formulaColumn, r, c);
+			const currentCellBlocks = !isNullCellForFormula(currentCell) && !isPreviousCellOfCurrentArrayFormula;
+			const featureCellBlocks = !isNullCellForFormula(featureCell);
+			if (hasRuntimeCell || isInOtherArrayFormulaRange || currentCellBlocks || featureCellBlocks) return true;
 		}
-		const node = children[0];
-		if (node == null)
- /**
-		* fix: https://github.com/dream-num/univer/issues/1415
-		*/
-		this.setValue(ErrorValueObject.create("#VALUE!"));
-		else this.setValue(node.getValue());
+		return false;
 	}
-};
-var AstRootNodeFactory = class extends BaseAstNodeFactory {
-	get zIndex() {
-		return NODE_ORDER_MAP.get(9) || 100;
+	_getRuntimeFeatureCellValue(row, column, sheetId, unitId) {
+		return getRuntimeFeatureCell(row, column, sheetId, unitId, this._runtimeFeatureCellData);
 	}
-	checkAndCreateNodeType(param) {
-		if (!(param instanceof LexerNode)) return;
-		if (param.getToken() === "R_1") return new AstRootNode("R_1");
+	_arrayCellHasData(cell) {
+		if (cell === null || cell === void 0) return false;
+		if (cell.v !== void 0) return true;
+		return false;
 	}
-};
-
-//#endregion
-//#region src/functions/date/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_DATE = /* @__PURE__ */ function(FUNCTION_NAMES_DATE) {
-	FUNCTION_NAMES_DATE["DATE"] = "DATE";
-	FUNCTION_NAMES_DATE["DATEDIF"] = "DATEDIF";
-	FUNCTION_NAMES_DATE["DATEVALUE"] = "DATEVALUE";
-	FUNCTION_NAMES_DATE["DAY"] = "DAY";
-	FUNCTION_NAMES_DATE["DAYS"] = "DAYS";
-	FUNCTION_NAMES_DATE["DAYS360"] = "DAYS360";
-	FUNCTION_NAMES_DATE["EDATE"] = "EDATE";
-	FUNCTION_NAMES_DATE["EOMONTH"] = "EOMONTH";
-	FUNCTION_NAMES_DATE["EPOCHTODATE"] = "EPOCHTODATE";
-	FUNCTION_NAMES_DATE["HOUR"] = "HOUR";
-	FUNCTION_NAMES_DATE["ISOWEEKNUM"] = "ISOWEEKNUM";
-	FUNCTION_NAMES_DATE["MINUTE"] = "MINUTE";
-	FUNCTION_NAMES_DATE["MONTH"] = "MONTH";
-	FUNCTION_NAMES_DATE["NETWORKDAYS"] = "NETWORKDAYS";
-	FUNCTION_NAMES_DATE["NETWORKDAYS_INTL"] = "NETWORKDAYS.INTL";
-	FUNCTION_NAMES_DATE["NOW"] = "NOW";
-	FUNCTION_NAMES_DATE["SECOND"] = "SECOND";
-	FUNCTION_NAMES_DATE["TIME"] = "TIME";
-	FUNCTION_NAMES_DATE["TIMEVALUE"] = "TIMEVALUE";
-	FUNCTION_NAMES_DATE["TO_DATE"] = "TO_DATE";
-	FUNCTION_NAMES_DATE["TODAY"] = "TODAY";
-	FUNCTION_NAMES_DATE["WEEKDAY"] = "WEEKDAY";
-	FUNCTION_NAMES_DATE["WEEKNUM"] = "WEEKNUM";
-	FUNCTION_NAMES_DATE["WORKDAY"] = "WORKDAY";
-	FUNCTION_NAMES_DATE["WORKDAY_INTL"] = "WORKDAY.INTL";
-	FUNCTION_NAMES_DATE["YEAR"] = "YEAR";
-	FUNCTION_NAMES_DATE["YEARFRAC"] = "YEARFRAC";
-	return FUNCTION_NAMES_DATE;
-}({});
-
-//#endregion
-//#region src/functions/engineering/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_ENGINEERING = /* @__PURE__ */ function(FUNCTION_NAMES_ENGINEERING) {
-	FUNCTION_NAMES_ENGINEERING["BESSELI"] = "BESSELI";
-	FUNCTION_NAMES_ENGINEERING["BESSELJ"] = "BESSELJ";
-	FUNCTION_NAMES_ENGINEERING["BESSELK"] = "BESSELK";
-	FUNCTION_NAMES_ENGINEERING["BESSELY"] = "BESSELY";
-	FUNCTION_NAMES_ENGINEERING["BIN2DEC"] = "BIN2DEC";
-	FUNCTION_NAMES_ENGINEERING["BIN2HEX"] = "BIN2HEX";
-	FUNCTION_NAMES_ENGINEERING["BIN2OCT"] = "BIN2OCT";
-	FUNCTION_NAMES_ENGINEERING["BITAND"] = "BITAND";
-	FUNCTION_NAMES_ENGINEERING["BITLSHIFT"] = "BITLSHIFT";
-	FUNCTION_NAMES_ENGINEERING["BITOR"] = "BITOR";
-	FUNCTION_NAMES_ENGINEERING["BITRSHIFT"] = "BITRSHIFT";
-	FUNCTION_NAMES_ENGINEERING["BITXOR"] = "BITXOR";
-	FUNCTION_NAMES_ENGINEERING["COMPLEX"] = "COMPLEX";
-	FUNCTION_NAMES_ENGINEERING["CONVERT"] = "CONVERT";
-	FUNCTION_NAMES_ENGINEERING["DEC2BIN"] = "DEC2BIN";
-	FUNCTION_NAMES_ENGINEERING["DEC2HEX"] = "DEC2HEX";
-	FUNCTION_NAMES_ENGINEERING["DEC2OCT"] = "DEC2OCT";
-	FUNCTION_NAMES_ENGINEERING["DELTA"] = "DELTA";
-	FUNCTION_NAMES_ENGINEERING["ERF"] = "ERF";
-	FUNCTION_NAMES_ENGINEERING["ERF_PRECISE"] = "ERF.PRECISE";
-	FUNCTION_NAMES_ENGINEERING["ERFC"] = "ERFC";
-	FUNCTION_NAMES_ENGINEERING["ERFC_PRECISE"] = "ERFC.PRECISE";
-	FUNCTION_NAMES_ENGINEERING["GESTEP"] = "GESTEP";
-	FUNCTION_NAMES_ENGINEERING["HEX2BIN"] = "HEX2BIN";
-	FUNCTION_NAMES_ENGINEERING["HEX2DEC"] = "HEX2DEC";
-	FUNCTION_NAMES_ENGINEERING["HEX2OCT"] = "HEX2OCT";
-	FUNCTION_NAMES_ENGINEERING["IMABS"] = "IMABS";
-	FUNCTION_NAMES_ENGINEERING["IMAGINARY"] = "IMAGINARY";
-	FUNCTION_NAMES_ENGINEERING["IMARGUMENT"] = "IMARGUMENT";
-	FUNCTION_NAMES_ENGINEERING["IMCONJUGATE"] = "IMCONJUGATE";
-	FUNCTION_NAMES_ENGINEERING["IMCOS"] = "IMCOS";
-	FUNCTION_NAMES_ENGINEERING["IMCOSH"] = "IMCOSH";
-	FUNCTION_NAMES_ENGINEERING["IMCOT"] = "IMCOT";
-	FUNCTION_NAMES_ENGINEERING["IMCOTH"] = "IMCOTH";
-	FUNCTION_NAMES_ENGINEERING["IMCSC"] = "IMCSC";
-	FUNCTION_NAMES_ENGINEERING["IMCSCH"] = "IMCSCH";
-	FUNCTION_NAMES_ENGINEERING["IMDIV"] = "IMDIV";
-	FUNCTION_NAMES_ENGINEERING["IMEXP"] = "IMEXP";
-	FUNCTION_NAMES_ENGINEERING["IMLN"] = "IMLN";
-	FUNCTION_NAMES_ENGINEERING["IMLOG"] = "IMLOG";
-	FUNCTION_NAMES_ENGINEERING["IMLOG10"] = "IMLOG10";
-	FUNCTION_NAMES_ENGINEERING["IMLOG2"] = "IMLOG2";
-	FUNCTION_NAMES_ENGINEERING["IMPOWER"] = "IMPOWER";
-	FUNCTION_NAMES_ENGINEERING["IMPRODUCT"] = "IMPRODUCT";
-	FUNCTION_NAMES_ENGINEERING["IMREAL"] = "IMREAL";
-	FUNCTION_NAMES_ENGINEERING["IMSEC"] = "IMSEC";
-	FUNCTION_NAMES_ENGINEERING["IMSECH"] = "IMSECH";
-	FUNCTION_NAMES_ENGINEERING["IMSIN"] = "IMSIN";
-	FUNCTION_NAMES_ENGINEERING["IMSINH"] = "IMSINH";
-	FUNCTION_NAMES_ENGINEERING["IMSQRT"] = "IMSQRT";
-	FUNCTION_NAMES_ENGINEERING["IMSUB"] = "IMSUB";
-	FUNCTION_NAMES_ENGINEERING["IMSUM"] = "IMSUM";
-	FUNCTION_NAMES_ENGINEERING["IMTAN"] = "IMTAN";
-	FUNCTION_NAMES_ENGINEERING["IMTANH"] = "IMTANH";
-	FUNCTION_NAMES_ENGINEERING["OCT2BIN"] = "OCT2BIN";
-	FUNCTION_NAMES_ENGINEERING["OCT2DEC"] = "OCT2DEC";
-	FUNCTION_NAMES_ENGINEERING["OCT2HEX"] = "OCT2HEX";
-	return FUNCTION_NAMES_ENGINEERING;
-}({});
-
-//#endregion
-//#region src/functions/financial/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_FINANCIAL = /* @__PURE__ */ function(FUNCTION_NAMES_FINANCIAL) {
-	FUNCTION_NAMES_FINANCIAL["ACCRINT"] = "ACCRINT";
-	FUNCTION_NAMES_FINANCIAL["ACCRINTM"] = "ACCRINTM";
-	FUNCTION_NAMES_FINANCIAL["AMORDEGRC"] = "AMORDEGRC";
-	FUNCTION_NAMES_FINANCIAL["AMORLINC"] = "AMORLINC";
-	FUNCTION_NAMES_FINANCIAL["COUPDAYBS"] = "COUPDAYBS";
-	FUNCTION_NAMES_FINANCIAL["COUPDAYS"] = "COUPDAYS";
-	FUNCTION_NAMES_FINANCIAL["COUPDAYSNC"] = "COUPDAYSNC";
-	FUNCTION_NAMES_FINANCIAL["COUPNCD"] = "COUPNCD";
-	FUNCTION_NAMES_FINANCIAL["COUPNUM"] = "COUPNUM";
-	FUNCTION_NAMES_FINANCIAL["COUPPCD"] = "COUPPCD";
-	FUNCTION_NAMES_FINANCIAL["CUMIPMT"] = "CUMIPMT";
-	FUNCTION_NAMES_FINANCIAL["CUMPRINC"] = "CUMPRINC";
-	FUNCTION_NAMES_FINANCIAL["DB"] = "DB";
-	FUNCTION_NAMES_FINANCIAL["DDB"] = "DDB";
-	FUNCTION_NAMES_FINANCIAL["DISC"] = "DISC";
-	FUNCTION_NAMES_FINANCIAL["DOLLARDE"] = "DOLLARDE";
-	FUNCTION_NAMES_FINANCIAL["DOLLARFR"] = "DOLLARFR";
-	FUNCTION_NAMES_FINANCIAL["DURATION"] = "DURATION";
-	FUNCTION_NAMES_FINANCIAL["EFFECT"] = "EFFECT";
-	FUNCTION_NAMES_FINANCIAL["FV"] = "FV";
-	FUNCTION_NAMES_FINANCIAL["FVSCHEDULE"] = "FVSCHEDULE";
-	FUNCTION_NAMES_FINANCIAL["INTRATE"] = "INTRATE";
-	FUNCTION_NAMES_FINANCIAL["IPMT"] = "IPMT";
-	FUNCTION_NAMES_FINANCIAL["IRR"] = "IRR";
-	FUNCTION_NAMES_FINANCIAL["ISPMT"] = "ISPMT";
-	FUNCTION_NAMES_FINANCIAL["MDURATION"] = "MDURATION";
-	FUNCTION_NAMES_FINANCIAL["MIRR"] = "MIRR";
-	FUNCTION_NAMES_FINANCIAL["NOMINAL"] = "NOMINAL";
-	FUNCTION_NAMES_FINANCIAL["NPER"] = "NPER";
-	FUNCTION_NAMES_FINANCIAL["NPV"] = "NPV";
-	FUNCTION_NAMES_FINANCIAL["ODDFPRICE"] = "ODDFPRICE";
-	FUNCTION_NAMES_FINANCIAL["ODDFYIELD"] = "ODDFYIELD";
-	FUNCTION_NAMES_FINANCIAL["ODDLPRICE"] = "ODDLPRICE";
-	FUNCTION_NAMES_FINANCIAL["ODDLYIELD"] = "ODDLYIELD";
-	FUNCTION_NAMES_FINANCIAL["PDURATION"] = "PDURATION";
-	FUNCTION_NAMES_FINANCIAL["PMT"] = "PMT";
-	FUNCTION_NAMES_FINANCIAL["PPMT"] = "PPMT";
-	FUNCTION_NAMES_FINANCIAL["PRICE"] = "PRICE";
-	FUNCTION_NAMES_FINANCIAL["PRICEDISC"] = "PRICEDISC";
-	FUNCTION_NAMES_FINANCIAL["PRICEMAT"] = "PRICEMAT";
-	FUNCTION_NAMES_FINANCIAL["PV"] = "PV";
-	FUNCTION_NAMES_FINANCIAL["RATE"] = "RATE";
-	FUNCTION_NAMES_FINANCIAL["RECEIVED"] = "RECEIVED";
-	FUNCTION_NAMES_FINANCIAL["RRI"] = "RRI";
-	FUNCTION_NAMES_FINANCIAL["SLN"] = "SLN";
-	FUNCTION_NAMES_FINANCIAL["SYD"] = "SYD";
-	FUNCTION_NAMES_FINANCIAL["TBILLEQ"] = "TBILLEQ";
-	FUNCTION_NAMES_FINANCIAL["TBILLPRICE"] = "TBILLPRICE";
-	FUNCTION_NAMES_FINANCIAL["TBILLYIELD"] = "TBILLYIELD";
-	FUNCTION_NAMES_FINANCIAL["VDB"] = "VDB";
-	FUNCTION_NAMES_FINANCIAL["XIRR"] = "XIRR";
-	FUNCTION_NAMES_FINANCIAL["XNPV"] = "XNPV";
-	FUNCTION_NAMES_FINANCIAL["YIELD"] = "YIELD";
-	FUNCTION_NAMES_FINANCIAL["YIELDDISC"] = "YIELDDISC";
-	FUNCTION_NAMES_FINANCIAL["YIELDMAT"] = "YIELDMAT";
-	return FUNCTION_NAMES_FINANCIAL;
-}({});
-
-//#endregion
-//#region src/functions/information/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_INFORMATION = /* @__PURE__ */ function(FUNCTION_NAMES_INFORMATION) {
-	FUNCTION_NAMES_INFORMATION["CELL"] = "CELL";
-	FUNCTION_NAMES_INFORMATION["ERROR_TYPE"] = "ERROR.TYPE";
-	FUNCTION_NAMES_INFORMATION["INFO"] = "INFO";
-	FUNCTION_NAMES_INFORMATION["ISBETWEEN"] = "ISBETWEEN";
-	FUNCTION_NAMES_INFORMATION["ISBLANK"] = "ISBLANK";
-	FUNCTION_NAMES_INFORMATION["ISDATE"] = "ISDATE";
-	FUNCTION_NAMES_INFORMATION["ISEMAIL"] = "ISEMAIL";
-	FUNCTION_NAMES_INFORMATION["ISERR"] = "ISERR";
-	FUNCTION_NAMES_INFORMATION["ISERROR"] = "ISERROR";
-	FUNCTION_NAMES_INFORMATION["ISEVEN"] = "ISEVEN";
-	FUNCTION_NAMES_INFORMATION["ISFORMULA"] = "ISFORMULA";
-	FUNCTION_NAMES_INFORMATION["ISLOGICAL"] = "ISLOGICAL";
-	FUNCTION_NAMES_INFORMATION["ISNA"] = "ISNA";
-	FUNCTION_NAMES_INFORMATION["ISNONTEXT"] = "ISNONTEXT";
-	FUNCTION_NAMES_INFORMATION["ISNUMBER"] = "ISNUMBER";
-	FUNCTION_NAMES_INFORMATION["ISODD"] = "ISODD";
-	FUNCTION_NAMES_INFORMATION["ISOMITTED"] = "ISOMITTED";
-	FUNCTION_NAMES_INFORMATION["ISREF"] = "ISREF";
-	FUNCTION_NAMES_INFORMATION["ISTEXT"] = "ISTEXT";
-	FUNCTION_NAMES_INFORMATION["ISURL"] = "ISURL";
-	FUNCTION_NAMES_INFORMATION["N"] = "N";
-	FUNCTION_NAMES_INFORMATION["NA"] = "NA";
-	FUNCTION_NAMES_INFORMATION["SHEET"] = "SHEET";
-	FUNCTION_NAMES_INFORMATION["SHEETS"] = "SHEETS";
-	FUNCTION_NAMES_INFORMATION["TYPE"] = "TYPE";
-	return FUNCTION_NAMES_INFORMATION;
-}({});
-
-//#endregion
-//#region src/functions/logical/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_LOGICAL = /* @__PURE__ */ function(FUNCTION_NAMES_LOGICAL) {
-	FUNCTION_NAMES_LOGICAL["AND"] = "AND";
-	FUNCTION_NAMES_LOGICAL["BYCOL"] = "BYCOL";
-	FUNCTION_NAMES_LOGICAL["BYROW"] = "BYROW";
-	FUNCTION_NAMES_LOGICAL["FALSE"] = "FALSE";
-	FUNCTION_NAMES_LOGICAL["IF"] = "IF";
-	FUNCTION_NAMES_LOGICAL["IFERROR"] = "IFERROR";
-	FUNCTION_NAMES_LOGICAL["IFNA"] = "IFNA";
-	FUNCTION_NAMES_LOGICAL["IFS"] = "IFS";
-	FUNCTION_NAMES_LOGICAL["LAMBDA"] = "LAMBDA";
-	FUNCTION_NAMES_LOGICAL["LET"] = "LET";
-	FUNCTION_NAMES_LOGICAL["MAKEARRAY"] = "MAKEARRAY";
-	FUNCTION_NAMES_LOGICAL["MAP"] = "MAP";
-	FUNCTION_NAMES_LOGICAL["NOT"] = "NOT";
-	FUNCTION_NAMES_LOGICAL["OR"] = "OR";
-	FUNCTION_NAMES_LOGICAL["REDUCE"] = "REDUCE";
-	FUNCTION_NAMES_LOGICAL["SCAN"] = "SCAN";
-	FUNCTION_NAMES_LOGICAL["SWITCH"] = "SWITCH";
-	FUNCTION_NAMES_LOGICAL["TRUE"] = "TRUE";
-	FUNCTION_NAMES_LOGICAL["XOR"] = "XOR";
-	return FUNCTION_NAMES_LOGICAL;
-}({});
-
-//#endregion
-//#region src/functions/lookup/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_LOOKUP = /* @__PURE__ */ function(FUNCTION_NAMES_LOOKUP) {
-	FUNCTION_NAMES_LOOKUP["ADDRESS"] = "ADDRESS";
-	FUNCTION_NAMES_LOOKUP["AREAS"] = "AREAS";
-	FUNCTION_NAMES_LOOKUP["CHOOSE"] = "CHOOSE";
-	FUNCTION_NAMES_LOOKUP["CHOOSECOLS"] = "CHOOSECOLS";
-	FUNCTION_NAMES_LOOKUP["CHOOSEROWS"] = "CHOOSEROWS";
-	FUNCTION_NAMES_LOOKUP["COLUMN"] = "COLUMN";
-	FUNCTION_NAMES_LOOKUP["COLUMNS"] = "COLUMNS";
-	FUNCTION_NAMES_LOOKUP["DROP"] = "DROP";
-	FUNCTION_NAMES_LOOKUP["EXPAND"] = "EXPAND";
-	FUNCTION_NAMES_LOOKUP["FILTER"] = "FILTER";
-	FUNCTION_NAMES_LOOKUP["FORMULATEXT"] = "FORMULATEXT";
-	FUNCTION_NAMES_LOOKUP["GETPIVOTDATA"] = "GETPIVOTDATA";
-	FUNCTION_NAMES_LOOKUP["HLOOKUP"] = "HLOOKUP";
-	FUNCTION_NAMES_LOOKUP["HSTACK"] = "HSTACK";
-	FUNCTION_NAMES_LOOKUP["HYPERLINK"] = "HYPERLINK";
-	FUNCTION_NAMES_LOOKUP["IMAGE"] = "IMAGE";
-	FUNCTION_NAMES_LOOKUP["INDEX"] = "INDEX";
-	FUNCTION_NAMES_LOOKUP["INDIRECT"] = "INDIRECT";
-	FUNCTION_NAMES_LOOKUP["LOOKUP"] = "LOOKUP";
-	FUNCTION_NAMES_LOOKUP["MATCH"] = "MATCH";
-	FUNCTION_NAMES_LOOKUP["OFFSET"] = "OFFSET";
-	FUNCTION_NAMES_LOOKUP["ROW"] = "ROW";
-	FUNCTION_NAMES_LOOKUP["ROWS"] = "ROWS";
-	FUNCTION_NAMES_LOOKUP["RTD"] = "RTD";
-	FUNCTION_NAMES_LOOKUP["SORT"] = "SORT";
-	FUNCTION_NAMES_LOOKUP["SORTBY"] = "SORTBY";
-	FUNCTION_NAMES_LOOKUP["TAKE"] = "TAKE";
-	FUNCTION_NAMES_LOOKUP["TOCOL"] = "TOCOL";
-	FUNCTION_NAMES_LOOKUP["TOROW"] = "TOROW";
-	FUNCTION_NAMES_LOOKUP["TRANSPOSE"] = "TRANSPOSE";
-	FUNCTION_NAMES_LOOKUP["UNIQUE"] = "UNIQUE";
-	FUNCTION_NAMES_LOOKUP["VLOOKUP"] = "VLOOKUP";
-	FUNCTION_NAMES_LOOKUP["VSTACK"] = "VSTACK";
-	FUNCTION_NAMES_LOOKUP["WRAPCOLS"] = "WRAPCOLS";
-	FUNCTION_NAMES_LOOKUP["WRAPROWS"] = "WRAPROWS";
-	FUNCTION_NAMES_LOOKUP["XLOOKUP"] = "XLOOKUP";
-	FUNCTION_NAMES_LOOKUP["XMATCH"] = "XMATCH";
-	return FUNCTION_NAMES_LOOKUP;
-}({});
-
-//#endregion
-//#region src/functions/math/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_MATH = /* @__PURE__ */ function(FUNCTION_NAMES_MATH) {
-	FUNCTION_NAMES_MATH["ABS"] = "ABS";
-	FUNCTION_NAMES_MATH["ACOS"] = "ACOS";
-	FUNCTION_NAMES_MATH["ACOSH"] = "ACOSH";
-	FUNCTION_NAMES_MATH["ACOT"] = "ACOT";
-	FUNCTION_NAMES_MATH["ACOTH"] = "ACOTH";
-	FUNCTION_NAMES_MATH["AGGREGATE"] = "AGGREGATE";
-	FUNCTION_NAMES_MATH["ARABIC"] = "ARABIC";
-	FUNCTION_NAMES_MATH["ASIN"] = "ASIN";
-	FUNCTION_NAMES_MATH["ASINH"] = "ASINH";
-	FUNCTION_NAMES_MATH["ATAN"] = "ATAN";
-	FUNCTION_NAMES_MATH["ATAN2"] = "ATAN2";
-	FUNCTION_NAMES_MATH["ATANH"] = "ATANH";
-	FUNCTION_NAMES_MATH["BASE"] = "BASE";
-	FUNCTION_NAMES_MATH["CEILING"] = "CEILING";
-	FUNCTION_NAMES_MATH["CEILING_MATH"] = "CEILING.MATH";
-	FUNCTION_NAMES_MATH["CEILING_PRECISE"] = "CEILING.PRECISE";
-	FUNCTION_NAMES_MATH["COMBIN"] = "COMBIN";
-	FUNCTION_NAMES_MATH["COMBINA"] = "COMBINA";
-	FUNCTION_NAMES_MATH["COS"] = "COS";
-	FUNCTION_NAMES_MATH["COSH"] = "COSH";
-	FUNCTION_NAMES_MATH["COT"] = "COT";
-	FUNCTION_NAMES_MATH["COTH"] = "COTH";
-	FUNCTION_NAMES_MATH["CSC"] = "CSC";
-	FUNCTION_NAMES_MATH["CSCH"] = "CSCH";
-	FUNCTION_NAMES_MATH["DECIMAL"] = "DECIMAL";
-	FUNCTION_NAMES_MATH["DEGREES"] = "DEGREES";
-	FUNCTION_NAMES_MATH["EVEN"] = "EVEN";
-	FUNCTION_NAMES_MATH["EXP"] = "EXP";
-	FUNCTION_NAMES_MATH["FACT"] = "FACT";
-	FUNCTION_NAMES_MATH["FACTDOUBLE"] = "FACTDOUBLE";
-	FUNCTION_NAMES_MATH["FLOOR"] = "FLOOR";
-	FUNCTION_NAMES_MATH["FLOOR_MATH"] = "FLOOR.MATH";
-	FUNCTION_NAMES_MATH["FLOOR_PRECISE"] = "FLOOR.PRECISE";
-	FUNCTION_NAMES_MATH["GCD"] = "GCD";
-	FUNCTION_NAMES_MATH["INT"] = "INT";
-	FUNCTION_NAMES_MATH["ISO_CEILING"] = "ISO.CEILING";
-	FUNCTION_NAMES_MATH["LCM"] = "LCM";
-	FUNCTION_NAMES_MATH["LET"] = "LET";
-	FUNCTION_NAMES_MATH["LN"] = "LN";
-	FUNCTION_NAMES_MATH["LOG"] = "LOG";
-	FUNCTION_NAMES_MATH["LOG10"] = "LOG10";
-	FUNCTION_NAMES_MATH["MDETERM"] = "MDETERM";
-	FUNCTION_NAMES_MATH["MINVERSE"] = "MINVERSE";
-	FUNCTION_NAMES_MATH["MMULT"] = "MMULT";
-	FUNCTION_NAMES_MATH["MOD"] = "MOD";
-	FUNCTION_NAMES_MATH["MROUND"] = "MROUND";
-	FUNCTION_NAMES_MATH["MULTINOMIAL"] = "MULTINOMIAL";
-	FUNCTION_NAMES_MATH["MUNIT"] = "MUNIT";
-	FUNCTION_NAMES_MATH["ODD"] = "ODD";
-	FUNCTION_NAMES_MATH["PI"] = "PI";
-	FUNCTION_NAMES_MATH["POWER"] = "POWER";
-	FUNCTION_NAMES_MATH["PRODUCT"] = "PRODUCT";
-	FUNCTION_NAMES_MATH["QUOTIENT"] = "QUOTIENT";
-	FUNCTION_NAMES_MATH["RADIANS"] = "RADIANS";
-	FUNCTION_NAMES_MATH["RAND"] = "RAND";
-	FUNCTION_NAMES_MATH["RANDARRAY"] = "RANDARRAY";
-	FUNCTION_NAMES_MATH["RANDBETWEEN"] = "RANDBETWEEN";
-	FUNCTION_NAMES_MATH["ROMAN"] = "ROMAN";
-	FUNCTION_NAMES_MATH["ROUND"] = "ROUND";
-	FUNCTION_NAMES_MATH["ROUNDBANK"] = "ROUNDBANK";
-	FUNCTION_NAMES_MATH["ROUNDDOWN"] = "ROUNDDOWN";
-	FUNCTION_NAMES_MATH["ROUNDUP"] = "ROUNDUP";
-	FUNCTION_NAMES_MATH["SEC"] = "SEC";
-	FUNCTION_NAMES_MATH["SECH"] = "SECH";
-	FUNCTION_NAMES_MATH["SERIESSUM"] = "SERIESSUM";
-	FUNCTION_NAMES_MATH["SEQUENCE"] = "SEQUENCE";
-	FUNCTION_NAMES_MATH["SIGN"] = "SIGN";
-	FUNCTION_NAMES_MATH["SIN"] = "SIN";
-	FUNCTION_NAMES_MATH["SINH"] = "SINH";
-	FUNCTION_NAMES_MATH["SQRT"] = "SQRT";
-	FUNCTION_NAMES_MATH["SQRTPI"] = "SQRTPI";
-	FUNCTION_NAMES_MATH["SUBTOTAL"] = "SUBTOTAL";
-	FUNCTION_NAMES_MATH["SUM"] = "SUM";
-	FUNCTION_NAMES_MATH["SUMIF"] = "SUMIF";
-	FUNCTION_NAMES_MATH["SUMIFS"] = "SUMIFS";
-	FUNCTION_NAMES_MATH["SUMPRODUCT"] = "SUMPRODUCT";
-	FUNCTION_NAMES_MATH["SUMSQ"] = "SUMSQ";
-	FUNCTION_NAMES_MATH["SUMX2MY2"] = "SUMX2MY2";
-	FUNCTION_NAMES_MATH["SUMX2PY2"] = "SUMX2PY2";
-	FUNCTION_NAMES_MATH["SUMXMY2"] = "SUMXMY2";
-	FUNCTION_NAMES_MATH["TAN"] = "TAN";
-	FUNCTION_NAMES_MATH["TANH"] = "TANH";
-	FUNCTION_NAMES_MATH["TRUNC"] = "TRUNC";
-	return FUNCTION_NAMES_MATH;
-}({});
+	/**
+	* If the current array formula in the extended area intersects with the existing array formula, a #SPILL! error will be reported. Note that if other array formulas are already #SPILL!, they will not conflict with the current array formula
+	* @param formulaUnitId
+	* @param formulaSheetId
+	* @param formulaRow
+	* @param formulaColumn
+	* @param r
+	* @param c
+	* @returns
+	*/
+	_isInOtherArrayFormulaRange(formulaUnitId, formulaSheetId, formulaRow, formulaColumn, r, c) {
+		var _this$_currentConfigS3;
+		const arrayFormulaRange = (_this$_currentConfigS3 = this._currentConfigService.getArrayFormulaRange()[formulaUnitId]) === null || _this$_currentConfigS3 === void 0 ? void 0 : _this$_currentConfigS3[formulaSheetId];
+		if (arrayFormulaRange == null) return false;
+		let isCellOverlapping = false;
+		new _univerjs_core.ObjectMatrix(arrayFormulaRange).forValue((rangeRow, rangeCol, range) => {
+			var _this$_runtimeData$fo;
+			if (rangeRow === formulaRow && rangeCol === formulaColumn) return;
+			const isOverlapping = this._isInArrayFormulaRange(range, r, c);
+			const cell = (_this$_runtimeData$fo = this._runtimeData[formulaUnitId]) === null || _this$_runtimeData$fo === void 0 || (_this$_runtimeData$fo = _this$_runtimeData$fo[formulaSheetId]) === null || _this$_runtimeData$fo === void 0 ? void 0 : _this$_runtimeData$fo.getValue(rangeRow, rangeCol);
+			if (isOverlapping && (cell === null || cell === void 0 ? void 0 : cell.v) !== "#SPILL!") isCellOverlapping = true;
+		});
+		return isCellOverlapping;
+	}
+	_isInArrayFormulaRange(range, r, c) {
+		if (range == null) return false;
+		const { startRow, startColumn, endRow, endColumn } = range;
+		if (r >= startRow && r <= endRow && c >= startColumn && c <= endColumn) return true;
+		return false;
+	}
+	_isSameCellValue(cell, arrayDataCell) {
+		return (cell === null || cell === void 0 ? void 0 : cell.v) === (arrayDataCell === null || arrayDataCell === void 0 ? void 0 : arrayDataCell.v) && (cell === null || cell === void 0 ? void 0 : cell.t) === (arrayDataCell === null || arrayDataCell === void 0 ? void 0 : arrayDataCell.t);
+	}
+	_checkIfArrayFormulaExceeded(rowCount, columnCount, arrayRange) {
+		if (arrayRange.endRow >= rowCount || arrayRange.endColumn >= columnCount) return true;
+		return false;
+	}
+	_isInDirtyRange(unitId, sheetId, row, column) {
+		const dirtyRanges = this._currentConfigService.getDirtyRanges();
+		if (dirtyRanges.length === 0) return true;
+		return isInDirtyRange(dirtyRanges, unitId, sheetId, row, column);
+	}
+};
+FormulaRuntimeService = __decorate([__decorateParam(0, IFormulaCurrentConfigService), __decorateParam(1, IHyperlinkEngineFormulaService)], FormulaRuntimeService);
+const IFormulaRuntimeService = (0, _univerjs_core.createIdentifier)("univer.formula.runtime.service");
 
 //#endregion
-//#region src/functions/statistical/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_STATISTICAL = /* @__PURE__ */ function(FUNCTION_NAMES_STATISTICAL) {
-	FUNCTION_NAMES_STATISTICAL["AVEDEV"] = "AVEDEV";
-	FUNCTION_NAMES_STATISTICAL["AVERAGE"] = "AVERAGE";
-	FUNCTION_NAMES_STATISTICAL["AVERAGE_WEIGHTED"] = "AVERAGE.WEIGHTED";
-	FUNCTION_NAMES_STATISTICAL["AVERAGEA"] = "AVERAGEA";
-	FUNCTION_NAMES_STATISTICAL["AVERAGEIF"] = "AVERAGEIF";
-	FUNCTION_NAMES_STATISTICAL["AVERAGEIFS"] = "AVERAGEIFS";
-	FUNCTION_NAMES_STATISTICAL["BETA_DIST"] = "BETA.DIST";
-	FUNCTION_NAMES_STATISTICAL["BETA_INV"] = "BETA.INV";
-	FUNCTION_NAMES_STATISTICAL["BINOM_DIST"] = "BINOM.DIST";
-	FUNCTION_NAMES_STATISTICAL["BINOM_DIST_RANGE"] = "BINOM.DIST.RANGE";
-	FUNCTION_NAMES_STATISTICAL["BINOM_INV"] = "BINOM.INV";
-	FUNCTION_NAMES_STATISTICAL["CHISQ_DIST"] = "CHISQ.DIST";
-	FUNCTION_NAMES_STATISTICAL["CHISQ_DIST_RT"] = "CHISQ.DIST.RT";
-	FUNCTION_NAMES_STATISTICAL["CHISQ_INV"] = "CHISQ.INV";
-	FUNCTION_NAMES_STATISTICAL["CHISQ_INV_RT"] = "CHISQ.INV.RT";
-	FUNCTION_NAMES_STATISTICAL["CHISQ_TEST"] = "CHISQ.TEST";
-	FUNCTION_NAMES_STATISTICAL["CONFIDENCE_NORM"] = "CONFIDENCE.NORM";
-	FUNCTION_NAMES_STATISTICAL["CONFIDENCE_T"] = "CONFIDENCE.T";
-	FUNCTION_NAMES_STATISTICAL["CORREL"] = "CORREL";
-	FUNCTION_NAMES_STATISTICAL["COUNT"] = "COUNT";
-	FUNCTION_NAMES_STATISTICAL["COUNTA"] = "COUNTA";
-	FUNCTION_NAMES_STATISTICAL["COUNTBLANK"] = "COUNTBLANK";
-	FUNCTION_NAMES_STATISTICAL["COUNTIF"] = "COUNTIF";
-	FUNCTION_NAMES_STATISTICAL["COUNTIFS"] = "COUNTIFS";
-	FUNCTION_NAMES_STATISTICAL["COVARIANCE_P"] = "COVARIANCE.P";
-	FUNCTION_NAMES_STATISTICAL["COVARIANCE_S"] = "COVARIANCE.S";
-	FUNCTION_NAMES_STATISTICAL["DEVSQ"] = "DEVSQ";
-	FUNCTION_NAMES_STATISTICAL["EXPON_DIST"] = "EXPON.DIST";
-	FUNCTION_NAMES_STATISTICAL["F_DIST"] = "F.DIST";
-	FUNCTION_NAMES_STATISTICAL["F_DIST_RT"] = "F.DIST.RT";
-	FUNCTION_NAMES_STATISTICAL["F_INV"] = "F.INV";
-	FUNCTION_NAMES_STATISTICAL["F_INV_RT"] = "F.INV.RT";
-	FUNCTION_NAMES_STATISTICAL["F_TEST"] = "F.TEST";
-	FUNCTION_NAMES_STATISTICAL["FISHER"] = "FISHER";
-	FUNCTION_NAMES_STATISTICAL["FISHERINV"] = "FISHERINV";
-	FUNCTION_NAMES_STATISTICAL["FORECAST"] = "FORECAST";
-	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS"] = "FORECAST.ETS";
-	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS_CONFINT"] = "FORECAST.ETS.CONFINT";
-	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS_SEASONALITY"] = "FORECAST.ETS.SEASONALITY";
-	FUNCTION_NAMES_STATISTICAL["FORECAST_ETS_STAT"] = "FORECAST.ETS.STAT";
-	FUNCTION_NAMES_STATISTICAL["FORECAST_LINEAR"] = "FORECAST.LINEAR";
-	FUNCTION_NAMES_STATISTICAL["FREQUENCY"] = "FREQUENCY";
-	FUNCTION_NAMES_STATISTICAL["GAMMA"] = "GAMMA";
-	FUNCTION_NAMES_STATISTICAL["GAMMA_DIST"] = "GAMMA.DIST";
-	FUNCTION_NAMES_STATISTICAL["GAMMA_INV"] = "GAMMA.INV";
-	FUNCTION_NAMES_STATISTICAL["GAMMALN"] = "GAMMALN";
-	FUNCTION_NAMES_STATISTICAL["GAMMALN_PRECISE"] = "GAMMALN.PRECISE";
-	FUNCTION_NAMES_STATISTICAL["GAUSS"] = "GAUSS";
-	FUNCTION_NAMES_STATISTICAL["GEOMEAN"] = "GEOMEAN";
-	FUNCTION_NAMES_STATISTICAL["GROWTH"] = "GROWTH";
-	FUNCTION_NAMES_STATISTICAL["HARMEAN"] = "HARMEAN";
-	FUNCTION_NAMES_STATISTICAL["HYPGEOM_DIST"] = "HYPGEOM.DIST";
-	FUNCTION_NAMES_STATISTICAL["INTERCEPT"] = "INTERCEPT";
-	FUNCTION_NAMES_STATISTICAL["KURT"] = "KURT";
-	FUNCTION_NAMES_STATISTICAL["LARGE"] = "LARGE";
-	FUNCTION_NAMES_STATISTICAL["LINEST"] = "LINEST";
-	FUNCTION_NAMES_STATISTICAL["LOGEST"] = "LOGEST";
-	FUNCTION_NAMES_STATISTICAL["LOGNORM_DIST"] = "LOGNORM.DIST";
-	FUNCTION_NAMES_STATISTICAL["LOGNORM_INV"] = "LOGNORM.INV";
-	FUNCTION_NAMES_STATISTICAL["MARGINOFERROR"] = "MARGINOFERROR";
-	FUNCTION_NAMES_STATISTICAL["MAX"] = "MAX";
-	FUNCTION_NAMES_STATISTICAL["MAXA"] = "MAXA";
-	FUNCTION_NAMES_STATISTICAL["MAXIFS"] = "MAXIFS";
-	FUNCTION_NAMES_STATISTICAL["MEDIAN"] = "MEDIAN";
-	FUNCTION_NAMES_STATISTICAL["MIN"] = "MIN";
-	FUNCTION_NAMES_STATISTICAL["MINA"] = "MINA";
-	FUNCTION_NAMES_STATISTICAL["MINIFS"] = "MINIFS";
-	FUNCTION_NAMES_STATISTICAL["MODE_MULT"] = "MODE.MULT";
-	FUNCTION_NAMES_STATISTICAL["MODE_SNGL"] = "MODE.SNGL";
-	FUNCTION_NAMES_STATISTICAL["NEGBINOM_DIST"] = "NEGBINOM.DIST";
-	FUNCTION_NAMES_STATISTICAL["NORM_DIST"] = "NORM.DIST";
-	FUNCTION_NAMES_STATISTICAL["NORM_INV"] = "NORM.INV";
-	FUNCTION_NAMES_STATISTICAL["NORM_S_DIST"] = "NORM.S.DIST";
-	FUNCTION_NAMES_STATISTICAL["NORM_S_INV"] = "NORM.S.INV";
-	FUNCTION_NAMES_STATISTICAL["PEARSON"] = "PEARSON";
-	FUNCTION_NAMES_STATISTICAL["PERCENTILE_EXC"] = "PERCENTILE.EXC";
-	FUNCTION_NAMES_STATISTICAL["PERCENTILE_INC"] = "PERCENTILE.INC";
-	FUNCTION_NAMES_STATISTICAL["PERCENTRANK_EXC"] = "PERCENTRANK.EXC";
-	FUNCTION_NAMES_STATISTICAL["PERCENTRANK_INC"] = "PERCENTRANK.INC";
-	FUNCTION_NAMES_STATISTICAL["PERMUT"] = "PERMUT";
-	FUNCTION_NAMES_STATISTICAL["PERMUTATIONA"] = "PERMUTATIONA";
-	FUNCTION_NAMES_STATISTICAL["PHI"] = "PHI";
-	FUNCTION_NAMES_STATISTICAL["POISSON_DIST"] = "POISSON.DIST";
-	FUNCTION_NAMES_STATISTICAL["PROB"] = "PROB";
-	FUNCTION_NAMES_STATISTICAL["QUARTILE_EXC"] = "QUARTILE.EXC";
-	FUNCTION_NAMES_STATISTICAL["QUARTILE_INC"] = "QUARTILE.INC";
-	FUNCTION_NAMES_STATISTICAL["RANK_AVG"] = "RANK.AVG";
-	FUNCTION_NAMES_STATISTICAL["RANK_EQ"] = "RANK.EQ";
-	FUNCTION_NAMES_STATISTICAL["RSQ"] = "RSQ";
-	FUNCTION_NAMES_STATISTICAL["SKEW"] = "SKEW";
-	FUNCTION_NAMES_STATISTICAL["SKEW_P"] = "SKEW.P";
-	FUNCTION_NAMES_STATISTICAL["SLOPE"] = "SLOPE";
-	FUNCTION_NAMES_STATISTICAL["SMALL"] = "SMALL";
-	FUNCTION_NAMES_STATISTICAL["STANDARDIZE"] = "STANDARDIZE";
-	FUNCTION_NAMES_STATISTICAL["STDEV_P"] = "STDEV.P";
-	FUNCTION_NAMES_STATISTICAL["STDEV_S"] = "STDEV.S";
-	FUNCTION_NAMES_STATISTICAL["STDEVA"] = "STDEVA";
-	FUNCTION_NAMES_STATISTICAL["STDEVPA"] = "STDEVPA";
-	FUNCTION_NAMES_STATISTICAL["STEYX"] = "STEYX";
-	FUNCTION_NAMES_STATISTICAL["T_DIST"] = "T.DIST";
-	FUNCTION_NAMES_STATISTICAL["T_DIST_2T"] = "T.DIST.2T";
-	FUNCTION_NAMES_STATISTICAL["T_DIST_RT"] = "T.DIST.RT";
-	FUNCTION_NAMES_STATISTICAL["T_INV"] = "T.INV";
-	FUNCTION_NAMES_STATISTICAL["T_INV_2T"] = "T.INV.2T";
-	FUNCTION_NAMES_STATISTICAL["T_TEST"] = "T.TEST";
-	FUNCTION_NAMES_STATISTICAL["TREND"] = "TREND";
-	FUNCTION_NAMES_STATISTICAL["TRIMMEAN"] = "TRIMMEAN";
-	FUNCTION_NAMES_STATISTICAL["VAR_P"] = "VAR.P";
-	FUNCTION_NAMES_STATISTICAL["VAR_S"] = "VAR.S";
-	FUNCTION_NAMES_STATISTICAL["VARA"] = "VARA";
-	FUNCTION_NAMES_STATISTICAL["VARPA"] = "VARPA";
-	FUNCTION_NAMES_STATISTICAL["WEIBULL_DIST"] = "WEIBULL.DIST";
-	FUNCTION_NAMES_STATISTICAL["Z_TEST"] = "Z.TEST";
-	return FUNCTION_NAMES_STATISTICAL;
-}({});
+//#region src/engine/ast-node/node-type.ts
+const NODE_ORDER_MAP = new Map([
+	[1, 7],
+	[2, 9],
+	[3, 8],
+	[4, 6],
+	[5, 1],
+	[6, 2],
+	[9, 10],
+	[10, 3],
+	[11, 4],
+	[12, 5]
+]);
 
 //#endregion
-//#region src/functions/text/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_TEXT = /* @__PURE__ */ function(FUNCTION_NAMES_TEXT) {
-	FUNCTION_NAMES_TEXT["ASC"] = "ASC";
-	FUNCTION_NAMES_TEXT["ARRAYTOTEXT"] = "ARRAYTOTEXT";
-	FUNCTION_NAMES_TEXT["BAHTTEXT"] = "BAHTTEXT";
-	FUNCTION_NAMES_TEXT["CHAR"] = "CHAR";
-	FUNCTION_NAMES_TEXT["CLEAN"] = "CLEAN";
-	FUNCTION_NAMES_TEXT["CODE"] = "CODE";
-	FUNCTION_NAMES_TEXT["CONCAT"] = "CONCAT";
-	FUNCTION_NAMES_TEXT["CONCATENATE"] = "CONCATENATE";
-	FUNCTION_NAMES_TEXT["DBCS"] = "DBCS";
-	FUNCTION_NAMES_TEXT["DOLLAR"] = "DOLLAR";
-	FUNCTION_NAMES_TEXT["EXACT"] = "EXACT";
-	FUNCTION_NAMES_TEXT["FIND"] = "FIND";
-	FUNCTION_NAMES_TEXT["FINDB"] = "FINDB";
-	FUNCTION_NAMES_TEXT["FIXED"] = "FIXED";
-	FUNCTION_NAMES_TEXT["LEFT"] = "LEFT";
-	FUNCTION_NAMES_TEXT["LEFTB"] = "LEFTB";
-	FUNCTION_NAMES_TEXT["LEN"] = "LEN";
-	FUNCTION_NAMES_TEXT["LENB"] = "LENB";
-	FUNCTION_NAMES_TEXT["LOWER"] = "LOWER";
-	FUNCTION_NAMES_TEXT["MID"] = "MID";
-	FUNCTION_NAMES_TEXT["MIDB"] = "MIDB";
-	FUNCTION_NAMES_TEXT["NUMBERSTRING"] = "NUMBERSTRING";
-	FUNCTION_NAMES_TEXT["NUMBERVALUE"] = "NUMBERVALUE";
-	FUNCTION_NAMES_TEXT["PHONETIC"] = "PHONETIC";
-	FUNCTION_NAMES_TEXT["PROPER"] = "PROPER";
-	FUNCTION_NAMES_TEXT["REGEXEXTRACT"] = "REGEXEXTRACT";
-	FUNCTION_NAMES_TEXT["REGEXMATCH"] = "REGEXMATCH";
-	FUNCTION_NAMES_TEXT["REGEXREPLACE"] = "REGEXREPLACE";
-	FUNCTION_NAMES_TEXT["REPLACE"] = "REPLACE";
-	FUNCTION_NAMES_TEXT["REPLACEB"] = "REPLACEB";
-	FUNCTION_NAMES_TEXT["REPT"] = "REPT";
-	FUNCTION_NAMES_TEXT["RIGHT"] = "RIGHT";
-	FUNCTION_NAMES_TEXT["RIGHTB"] = "RIGHTB";
-	FUNCTION_NAMES_TEXT["SEARCH"] = "SEARCH";
-	FUNCTION_NAMES_TEXT["SEARCHB"] = "SEARCHB";
-	FUNCTION_NAMES_TEXT["SUBSTITUTE"] = "SUBSTITUTE";
-	FUNCTION_NAMES_TEXT["T"] = "T";
-	FUNCTION_NAMES_TEXT["TEXT"] = "TEXT";
-	FUNCTION_NAMES_TEXT["TEXTAFTER"] = "TEXTAFTER";
-	FUNCTION_NAMES_TEXT["TEXTBEFORE"] = "TEXTBEFORE";
-	FUNCTION_NAMES_TEXT["TEXTJOIN"] = "TEXTJOIN";
-	FUNCTION_NAMES_TEXT["TEXTSPLIT"] = "TEXTSPLIT";
-	FUNCTION_NAMES_TEXT["TRIM"] = "TRIM";
-	FUNCTION_NAMES_TEXT["UNICHAR"] = "UNICHAR";
-	FUNCTION_NAMES_TEXT["UNICODE"] = "UNICODE";
-	FUNCTION_NAMES_TEXT["UPPER"] = "UPPER";
-	FUNCTION_NAMES_TEXT["VALUE"] = "VALUE";
-	FUNCTION_NAMES_TEXT["VALUETOTEXT"] = "VALUETOTEXT";
-	FUNCTION_NAMES_TEXT["CALL"] = "CALL";
-	FUNCTION_NAMES_TEXT["EUROCONVERT"] = "EUROCONVERT";
-	FUNCTION_NAMES_TEXT["REGISTER_ID"] = "REGISTER.ID";
-	return FUNCTION_NAMES_TEXT;
-}({});
+//#region src/engine/ast-node/base-ast-node.ts
+var BaseAstNode = class {
+	constructor(_token) {
+		this._token = _token;
+		_defineProperty(this, "_children", []);
+		_defineProperty(this, "_definedNames", void 0);
+		_defineProperty(this, "_parent", void 0);
+		_defineProperty(this, "_valueObject", void 0);
+		_defineProperty(this, "_calculateState", false);
+		_defineProperty(this, "_async", false);
+		_defineProperty(this, "_address", false);
+		_defineProperty(this, "_isForcedCalculateFunction", false);
+	}
+	dispose() {
+		var _this$_valueObject;
+		this._children.forEach((node) => {
+			node.dispose();
+		});
+		(_this$_valueObject = this._valueObject) === null || _this$_valueObject === void 0 || _this$_valueObject.dispose();
+		this._valueObject = null;
+		this._children = [];
+		this._definedNames = null;
+		this._parent = null;
+	}
+	get nodeType() {
+		return 8;
+	}
+	resetCalculationState() {
+		this._children.forEach((node) => {
+			node.resetCalculationState();
+		});
+		this._valueObject = null;
+		this._calculateState = false;
+	}
+	isAsync() {
+		return this._async;
+	}
+	isAddress() {
+		return this._address;
+	}
+	isForcedCalculateFunction() {
+		return this._isForcedCalculateFunction;
+	}
+	setAsync() {
+		this._async = true;
+	}
+	setAddress() {
+		this._address = true;
+	}
+	getParent() {
+		return this._parent;
+	}
+	setParent(node) {
+		this._parent = node;
+		node.addChildren(this);
+	}
+	setForcedCalculateFunction() {
+		this._isForcedCalculateFunction = true;
+	}
+	getChildren() {
+		return this._children;
+	}
+	addChildren(...astNode) {
+		this._children.push(...astNode);
+	}
+	getToken() {
+		return this._token;
+	}
+	setValue(value) {
+		this._valueObject = value;
+	}
+	getValue() {
+		return this._valueObject;
+	}
+	isCalculated() {
+		return this._calculateState;
+	}
+	setCalculated() {
+		this._calculateState = true;
+	}
+	execute() {}
+	setNotEmpty(state = true) {}
+	async executeAsync() {
+		return Promise.resolve(0);
+	}
+	serialize() {
+		const token = this.getToken();
+		const children = this.getChildren();
+		const childrenSerialization = [];
+		const childrenCount = children.length;
+		for (let i = 0; i < childrenCount; i++) {
+			const item = children[i];
+			childrenSerialization.push(item.serialize());
+		}
+		const result = {
+			token,
+			nodeType: this.nodeType
+		};
+		if (childrenCount > 0) result.children = childrenSerialization;
+		return result;
+	}
+	hasDefinedName(definedName) {
+		var _this$_definedNames;
+		return ((_this$_definedNames = this._definedNames) === null || _this$_definedNames === void 0 ? void 0 : _this$_definedNames.includes(definedName)) || false;
+	}
+	setDefinedNames(definedNames) {
+		this._definedNames = definedNames;
+	}
+	getDefinedNames() {
+		return this._definedNames;
+	}
+};
+var ErrorNode = class ErrorNode extends BaseAstNode {
+	constructor(errorType) {
+		super(errorType);
+		_defineProperty(this, "_errorValueObject", void 0);
+		this._errorValueObject = ErrorValueObject.create(errorType);
+	}
+	get nodeType() {
+		return 7;
+	}
+	static create(errorType) {
+		return new ErrorNode(errorType);
+	}
+	getValue() {
+		return this._errorValueObject;
+	}
+};
 
 //#endregion
-//#region src/functions/web/function-names.ts
-/**
-* Copyright 2023-present DreamNum Co., Ltd.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-let FUNCTION_NAMES_WEB = /* @__PURE__ */ function(FUNCTION_NAMES_WEB) {
-	FUNCTION_NAMES_WEB["ENCODEURL"] = "ENCODEURL";
-	FUNCTION_NAMES_WEB["FILTERXML"] = "FILTERXML";
-	FUNCTION_NAMES_WEB["WEBSERVICE"] = "WEBSERVICE";
-	return FUNCTION_NAMES_WEB;
-}({});
+//#region src/engine/ast-node/base-ast-node-factory.ts
+var BaseAstNodeFactory = class {
+	get zIndex() {
+		return 0;
+	}
+	dispose() {}
+	create(param, currentRow, currentColumn) {
+		let token;
+		if (param instanceof LexerNode) token = param.getToken();
+		else token = param;
+		return new BaseAstNode(token);
+	}
+};
+
+//#endregion
+//#region src/engine/ast-node/ast-root-node.ts
+var AstRootNode = class extends BaseAstNode {
+	get nodeType() {
+		return 9;
+	}
+	execute() {
+		const children = this.getChildren();
+		if (children.length > 1) {
+			this.setValue(ErrorValueObject.create("#VALUE!"));
+			return;
+		}
+		const node = children[0];
+		if (node == null)
+ /**
+		* fix: https://github.com/dream-num/univer/issues/1415
+		*/
+		this.setValue(ErrorValueObject.create("#VALUE!"));
+		else this.setValue(node.getValue());
+	}
+};
+var AstRootNodeFactory = class extends BaseAstNodeFactory {
+	get zIndex() {
+		return NODE_ORDER_MAP.get(9) || 100;
+	}
+	checkAndCreateNodeType(param) {
+		if (!(param instanceof LexerNode)) return;
+		if (param.getToken() === "R_1") return new AstRootNode("R_1");
+	}
+};
 
 //#endregion
 //#region src/functions/column-like-functions.ts
@@ -9493,7 +9970,8 @@ const FORMULA_CACHE_LRU_COUNT = 5e3;
 const FORMULA_AST_CACHE = new FormulaAstLRU(FORMULA_CACHE_LRU_COUNT);
 function generateAstNode(unitId, formulaString, lexer, astTreeBuilder, currentConfigService) {
 	let astNode = FORMULA_AST_CACHE.get(`${unitId}${formulaString}`);
-	if (astNode && !isDirtyDefinedForNode(astNode, currentConfigService)) return astNode;
+	const noCache = checkIsChangedByDefinedName(unitId, formulaString, currentConfigService);
+	if (!noCache && astNode && !isDirtyDefinedForNode(astNode, currentConfigService)) return astNode;
 	const lexerNode = lexer.treeBuilder(formulaString);
 	if (ERROR_TYPE_SET.has(lexerNode)) return ErrorNode.create(lexerNode);
 	astNode = astTreeBuilder.parse(lexerNode);
@@ -9501,9 +9979,20 @@ function generateAstNode(unitId, formulaString, lexer, astTreeBuilder, currentCo
 		console.error("generateAstNode astNode is null");
 		return ErrorNode.create(lexerNode);
 	}
-	FORMULA_AST_CACHE.set(`${unitId}${formulaString}`, astNode);
+	if (!noCache) FORMULA_AST_CACHE.set(`${unitId}${formulaString}`, astNode);
 	return astNode;
 }
+function checkIsChangedByDefinedName(unitId, formula, currentConfigService) {
+	const unitDefinedNameMap = currentConfigService.getDirtyDefinedNameMap()[unitId];
+	if (unitDefinedNameMap == null) return false;
+	const formulaText = normalizeFormulaText(formula);
+	const names = Object.keys(unitDefinedNameMap);
+	for (let i = 0, len = names.length; i < len; i++) if (normalizeFormulaText(names[i]) === formulaText) return true;
+	return false;
+}
+function normalizeFormulaText(formula) {
+	return formula.startsWith("=") ? formula.slice(1) : formula;
+}
 function isDirtyDefinedForNode(node, currentConfigService) {
 	const definedNameMap = currentConfigService.getDirtyDefinedNameMap();
 	const executeUnitId = currentConfigService.getExecuteUnitId();
@@ -11367,6 +11856,8 @@ var DependencyManagerBaseService = class extends _univerjs_core.Disposable {
 	updateDependencyTreeDirtyState(treeId, isDirty) {
 		throw new Error("Method not implemented.");
 	}
+	openKdTree() {}
+	closeKdTree() {}
 };
 /**
 * Passively marked as dirty, register the reference and execution actions of the feature plugin.
@@ -11378,89 +11869,16 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 	constructor(..._args2) {
 		super(..._args2);
 		_defineProperty(this, "_allTreeMap", /* @__PURE__ */ new Map());
-	}
-	dispose() {
-		super.dispose();
-		this.reset();
-	}
-	buildDependencyTree(shouldBeBuildTrees, dependencyTrees = []) {
-		const allTrees = this.getAllTree();
-		if (shouldBeBuildTrees.length === 0) {
-			this._buildReverseDependency(allTrees, dependencyTrees);
-			return allTrees;
-		}
-		this._buildDependencyTree(allTrees, shouldBeBuildTrees);
-		this._buildReverseDependency(allTrees, shouldBeBuildTrees);
-		return allTrees;
-	}
-	/**
-	* Build the dependency relationship between the trees.
-	* @param allTrees  all FormulaDependencyTree
-	* @param shouldBeBuildTrees  FormulaDependencyTree[] | FormulaDependencyTreeCache
-	*/
-	_buildDependencyTree(allTrees, shouldBeBuildTrees) {
-		const shouldBeBuildTreeMap = /* @__PURE__ */ new Map();
-		for (let i = 0; i < shouldBeBuildTrees.length; i++) {
-			const tree = shouldBeBuildTrees[i];
-			shouldBeBuildTreeMap.set(tree.treeId, tree);
-		}
-		for (let i = 0; i < allTrees.length; i++) {
-			const tree = allTrees[i];
-			const RTreeItem = tree.toRTreeItem();
-			const searchResults = this._dependencyRTreeCache.bulkSearch(RTreeItem);
-			for (const id of searchResults) {
-				const shouldBeBuildTree = shouldBeBuildTreeMap.get(id);
-				if (shouldBeBuildTree && tree !== shouldBeBuildTree && !shouldBeBuildTree.hasChildren(tree.treeId)) shouldBeBuildTree.pushChildren(tree);
-			}
-		}
-		shouldBeBuildTreeMap.clear();
-	}
-	/**
-	* Build the reverse dependency relationship between the trees.
-	* @param allTrees
-	* @param dependencyTrees
-	*/
-	_buildReverseDependency(allTrees, dependencyTrees) {
-		const allTreeMap = /* @__PURE__ */ new Map();
-		for (let i = 0; i < allTrees.length; i++) {
-			const tree = allTrees[i];
-			allTreeMap.set(tree.treeId, tree);
-		}
-		for (let i = 0; i < dependencyTrees.length; i++) {
-			const tree = dependencyTrees[i];
-			const RTreeItem = tree.toRTreeItem();
-			const searchResults = this._dependencyRTreeCache.bulkSearch(RTreeItem);
-			for (const id of searchResults) {
-				const allTree = allTreeMap.get(id);
-				if (allTree && tree !== allTree && !allTree.hasChildren(tree.treeId)) allTree.pushChildren(tree);
-			}
-		}
-		allTreeMap.clear();
-	}
-	/**
-	* Get all FormulaDependencyTree from _otherFormulaData, _featureFormulaData, _formulaData
-	* return FormulaDependencyTree[]
-	*/
-	getAllTree() {
-		const trees = [];
-		this._allTreeMap.forEach((tree) => {
-			tree.resetState();
-			trees.push(tree);
-		});
-		return trees;
-	}
-	getTreeById(treeId) {
-		return this._allTreeMap.get(treeId);
+		_defineProperty(this, "_dependencyRTreeCache", new _univerjs_core.RTree(true));
 	}
 	reset() {
 		this._otherFormulaData.clear();
 		this._featureFormulaData.clear();
 		this._formulaData.clear();
-		this._definedNameMap.clear();
-		this._otherFormulaDataMainData.clear();
 		this._dependencyRTreeCache.clear();
 		this._allTreeMap.clear();
 		this._restDependencyTreeId();
+		this._otherFormulaDataMainData.clear();
 	}
 	addOtherFormulaDependency(unitId, sheetId, formulaId, dependencyTree) {
 		if (!this._otherFormulaData.has(unitId)) this._otherFormulaData.set(unitId, /* @__PURE__ */ new Map());
@@ -11469,7 +11887,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 		const sheetMap = unitMap.get(sheetId);
 		if (!sheetMap.has(formulaId)) sheetMap.set(formulaId, new _univerjs_core.ObjectMatrix());
 		sheetMap.get(formulaId).setValue(dependencyTree.refOffsetX, dependencyTree.refOffsetY, dependencyTree.treeId);
-		this._addAllTreeMap(dependencyTree);
 	}
 	removeOtherFormulaDependency(unitId, sheetId, formulaIds) {
 		const unitMap = this._otherFormulaData.get(unitId);
@@ -11480,7 +11897,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 				if (treeSet == null) return;
 				treeSet.forValue((row, column, treeId) => {
 					this._removeDependencyRTreeCache(treeId);
-					this.clearDependencyForTree(this._allTreeMap.get(treeId));
 					this._removeAllTreeMap(treeId);
 				});
 				sheetMap.delete(formulaId);
@@ -11499,11 +11915,7 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 				const formulaTreeSet = sheetMap.get(formulaId);
 				if (formulaTreeSet == null) continue;
 				formulaTreeSet.forValue((row, column, treeId) => {
-					const tree = this._allTreeMap.get(treeId);
-					if (tree) {
-						this.clearDependencyForTree(tree);
-						this._removeAllTreeMap(treeId);
-					}
+					if (this._allTreeMap.get(treeId)) this._removeAllTreeMap(treeId);
 				});
 				this._otherFormulaDataMainData.delete(formulaId);
 			}
@@ -11516,11 +11928,7 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 					const formulaTreeSet = sheetMap.get(formulaId);
 					if (formulaTreeSet == null) continue;
 					formulaTreeSet.forValue((row, column, treeId) => {
-						const tree = this._allTreeMap.get(treeId);
-						if (tree) {
-							this.clearDependencyForTree(tree);
-							this._removeAllTreeMap(treeId);
-						}
+						if (this._allTreeMap.get(treeId)) this._removeAllTreeMap(treeId);
 					});
 					this._otherFormulaDataMainData.delete(formulaId);
 				}
@@ -11533,7 +11941,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 		const unitMap = this._featureFormulaData.get(unitId);
 		if (!unitMap.has(sheetId)) unitMap.set(sheetId, /* @__PURE__ */ new Map());
 		unitMap.get(sheetId).set(featureId, dependencyTree.treeId);
-		this._addAllTreeMap(dependencyTree);
 	}
 	removeFeatureFormulaDependency(unitId, sheetId, featureIds) {
 		const unitMap = this._featureFormulaData.get(unitId);
@@ -11544,7 +11951,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 				if (deleteTreeId == null) return;
 				this._removeDependencyRTreeCache(deleteTreeId);
 				sheetMap.delete(featureId);
-				this.clearDependencyForTree(this._allTreeMap.get(deleteTreeId));
 				this._removeAllTreeMap(deleteTreeId);
 			});
 		}
@@ -11556,7 +11962,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 			this._removeDependencyRTreeCacheById(unitId, sheetId);
 			sheetMap.forEach((featureTreeId) => {
 				if (featureTreeId == null) return;
-				this.clearDependencyForTree(this._allTreeMap.get(featureTreeId));
 				this._removeAllTreeMap(featureTreeId);
 			});
 			sheetMap.clear();
@@ -11565,7 +11970,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 				this._removeDependencyRTreeCacheById(unitId, sheetId);
 				sheetMap.forEach((featureTreeId) => {
 					if (featureTreeId == null) return;
-					this.clearDependencyForTree(this._allTreeMap.get(featureTreeId));
 					this._removeAllTreeMap(featureTreeId);
 				});
 			});
@@ -11577,7 +11981,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 		const unitMap = this._formulaData.get(unitId);
 		if (!unitMap.has(sheetId)) unitMap.set(sheetId, new _univerjs_core.ObjectMatrix());
 		unitMap.get(sheetId).setValue(row, column, dependencyTree.treeId);
-		this._addAllTreeMap(dependencyTree);
 	}
 	removeFormulaDependency(unitId, sheetId, row, column) {
 		const unitMap = this._formulaData.get(unitId);
@@ -11587,7 +11990,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 			if (deleteTreeId == null) return;
 			this._removeDependencyRTreeCache(deleteTreeId);
 			sheetMatrix.realDeleteValue(row, column);
-			this.clearDependencyForTree(this._allTreeMap.get(deleteTreeId));
 			this._removeAllTreeMap(deleteTreeId);
 		}
 	}
@@ -11598,7 +12000,6 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 			this._removeDependencyRTreeCacheById(unitId, sheetId);
 			sheetMatrix.forValue((row, column, treeId) => {
 				if (treeId == null) return true;
-				this.clearDependencyForTree(this._allTreeMap.get(treeId));
 				this._removeAllTreeMap(treeId);
 			});
 			sheetMatrix.reset();
@@ -11607,47 +12008,23 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 				this._removeDependencyRTreeCacheById(unitId, sheetId);
 				sheetMatrix.forValue((row, column, treeId) => {
 					if (treeId == null) return true;
-					this.clearDependencyForTree(this._allTreeMap.get(treeId));
 					this._removeAllTreeMap(treeId);
 				});
 			});
 			this._formulaData.delete(unitId);
 		}
 	}
-	/**
-	* Clear the dependency relationship of the tree.
-	* establish the relationship between the parent and the child.
-	* @param shouldBeClearTree
-	*/
-	clearDependencyForTree(shouldBeClearTree) {
-		if (shouldBeClearTree == null) return;
-		const parents = shouldBeClearTree.parents;
-		const children = shouldBeClearTree.children;
-		const allTreeMap = this._allTreeMap;
-		for (const parentTreeId of parents) {
-			const parent = allTreeMap.get(parentTreeId);
-			parent === null || parent === void 0 || parent.children.delete(shouldBeClearTree.treeId);
-		}
-		for (const childTreeId of children) {
-			const child = allTreeMap.get(childTreeId);
-			child === null || child === void 0 || child.parents.delete(shouldBeClearTree.treeId);
-		}
-		shouldBeClearTree.dispose();
-	}
 	_removeDependencyRTreeCache(treeId) {
 		if (treeId == null) return;
 		const treeRangeMap = this._allTreeMap.get(treeId);
 		if (treeRangeMap) {
 			const searchRanges = [];
-			for (let i = 0; i < treeRangeMap.rangeList.length; i++) {
-				const { unitId, sheetId, range } = treeRangeMap.rangeList[i];
-				searchRanges.push({
-					unitId,
-					sheetId,
-					range,
-					id: treeId
-				});
-			}
+			for (const [unitId, sheetMap] of treeRangeMap) for (const [sheetId, range] of sheetMap) searchRanges.push({
+				unitId,
+				sheetId,
+				range,
+				id: treeId
+			});
 			this._dependencyRTreeCache.bulkRemove(searchRanges);
 		}
 	}
@@ -11658,23 +12035,100 @@ var DependencyManagerService = class extends DependencyManagerBaseService {
 			if (treeSet) {
 				for (const treeId of treeSet) {
 					this._removeDependencyRTreeCache(treeId);
-					this.clearDependencyForTree(this._allTreeMap.get(treeId));
 					this._removeAllTreeMap(treeId);
 				}
 				treeSet.clear();
 			}
 		}
 	}
+	openKdTree() {
+		this._dependencyRTreeCache.openKdTree();
+	}
+	closeKdTree() {
+		this._dependencyRTreeCache.closeKdTree();
+	}
 	_removeAllTreeMap(treeId) {
 		if (treeId == null) return;
 		this._allTreeMap.delete(treeId);
 	}
 	_addAllTreeMap(tree) {
-		this._allTreeMap.set(tree.treeId, tree);
+		const rangeList = tree.rangeList;
+		let oldTreeMap = this._allTreeMap.get(tree.treeId);
+		for (let i = 0; i < rangeList.length; i++) {
+			var _oldTreeMap$get, _oldTreeMap$get2;
+			let { unitId, sheetId, range } = rangeList[i];
+			if (!oldTreeMap) {
+				oldTreeMap = /* @__PURE__ */ new Map();
+				this._allTreeMap.set(tree.treeId, oldTreeMap);
+			}
+			if (!oldTreeMap.has(unitId)) oldTreeMap.set(unitId, /* @__PURE__ */ new Map());
+			const oldRange = oldTreeMap === null || oldTreeMap === void 0 || (_oldTreeMap$get = oldTreeMap.get(unitId)) === null || _oldTreeMap$get === void 0 ? void 0 : _oldTreeMap$get.get(sheetId);
+			if (oldRange) range = {
+				startRow: Math.min(range.startRow, oldRange.startRow),
+				startColumn: Math.min(range.startColumn, oldRange.startColumn),
+				endRow: Math.max(range.endRow, oldRange.endRow),
+				endColumn: Math.max(range.endColumn, oldRange.endColumn)
+			};
+			(_oldTreeMap$get2 = oldTreeMap.get(unitId)) === null || _oldTreeMap$get2 === void 0 || _oldTreeMap$get2.set(sheetId, range);
+		}
 	}
-	updateDependencyTreeDirtyState(treeId, isDirty) {
-		const tree = this._allTreeMap.get(treeId);
-		if (tree) tree.isDirty = isDirty;
+	dispose() {
+		super.dispose();
+		this.reset();
+	}
+	buildDependencyTree(shouldBeBuildTrees, dependencyTrees = []) {
+		const allTrees = this.getAllTree();
+		if (shouldBeBuildTrees.length === 0) {
+			this._buildReverseDependency(allTrees, dependencyTrees);
+			return allTrees;
+		}
+		this._buildDependencyTree(allTrees, shouldBeBuildTrees);
+		this._buildReverseDependency(allTrees, shouldBeBuildTrees);
+		return allTrees;
+	}
+	/**
+	* Build the dependency relationship between the trees.
+	* @param allTrees  all FormulaDependencyTree
+	* @param shouldBeBuildTrees  FormulaDependencyTree[] | FormulaDependencyTreeCache
+	*/
+	_buildDependencyTree(allTrees, shouldBeBuildTrees) {
+		const shouldBeBuildTreeMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < shouldBeBuildTrees.length; i++) {
+			const tree = shouldBeBuildTrees[i];
+			shouldBeBuildTreeMap.set(tree.treeId, tree);
+		}
+		for (let i = 0; i < allTrees.length; i++) {
+			const tree = allTrees[i];
+			const RTreeItem = tree.toRTreeItem();
+			const searchResults = this._dependencyRTreeCache.bulkSearch(RTreeItem);
+			for (const id of searchResults) {
+				const shouldBeBuildTree = shouldBeBuildTreeMap.get(id);
+				if (shouldBeBuildTree && tree !== shouldBeBuildTree && !shouldBeBuildTree.hasChildren(tree.treeId)) shouldBeBuildTree.pushChildren(tree);
+			}
+		}
+		shouldBeBuildTreeMap.clear();
+	}
+	/**
+	* Build the reverse dependency relationship between the trees.
+	* @param allTrees
+	* @param dependencyTrees
+	*/
+	_buildReverseDependency(allTrees, dependencyTrees) {
+		const allTreeMap = /* @__PURE__ */ new Map();
+		for (let i = 0; i < allTrees.length; i++) {
+			const tree = allTrees[i];
+			allTreeMap.set(tree.treeId, tree);
+		}
+		for (let i = 0; i < dependencyTrees.length; i++) {
+			const tree = dependencyTrees[i];
+			const RTreeItem = tree.toRTreeItem();
+			const searchResults = this._dependencyRTreeCache.bulkSearch(RTreeItem);
+			for (const id of searchResults) {
+				const allTree = allTreeMap.get(id);
+				if (allTree && tree !== allTree && !allTree.hasChildren(tree.treeId)) allTree.pushChildren(tree);
+			}
+		}
+		allTreeMap.clear();
 	}
 };
 const IDependencyManagerService = (0, _univerjs_core.createIdentifier)("univer.formula.dependency-manager.service");
@@ -12217,12 +12671,14 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		this._lexerTreeBuilder = _lexerTreeBuilder;
 		_defineProperty(this, "_updateRangeFlattenCache", /* @__PURE__ */ new Map());
 		_defineProperty(this, "_dependencyRTreeCacheForAddressFunction", new _univerjs_core.RTree());
+		_defineProperty(this, "_dependencyTreeCache", /* @__PURE__ */ new Map());
 		_defineProperty(this, "_executedAddressFunctionNodeIds", /* @__PURE__ */ new Set());
 		_defineProperty(this, "_formulaDependencyTreeModel", /* @__PURE__ */ new Map());
 		this._initUnitDispose();
 	}
 	dispose() {
 		super.dispose();
+		this._dependencyTreeCache.clear();
 		this._updateRangeFlattenCache.clear();
 		this._dependencyRTreeCacheForAddressFunction.clear();
 		FORMULA_AST_CACHE.clear();
@@ -12252,87 +12708,301 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 			});
 		});
 		const unitData = this._currentConfigService.getUnitData();
-		const treeList = await this._generateTreeList(formulaData, otherFormulaData, unitData);
-		if (isCalculateTreeModel) this._runtimeService.setDependencyTreeModelData(this._getAllDependencyJson(treeList));
-		const updateTreeList = this._getUpdateTreeListAndMakeDependency(treeList);
-		let finalTreeList = this._calculateRunList(updateTreeList);
-		if (this._dependencyFeatureCalculation(finalTreeList)) {
-			finalTreeList.forEach((tree) => {
-				tree.resetState();
-			});
-			finalTreeList = this._calculateRunList(finalTreeList);
-		}
+		await this._generateTreeList(formulaData, otherFormulaData, unitData);
+		this._dependencyManagerService.openKdTree();
+		const updateTreeList = this._getUpdateTreeListAndMakeDependency();
+		const finalTreeList = this._calculateRunList(updateTreeList);
 		if (this._checkIsCycleDependency(finalTreeList)) this._runtimeService.enableCycleDependency();
+		if (isCalculateTreeModel) this._runtimeService.setDependencyTreeModelData(this._getAllDependencyJson(Array.from(this._dependencyTreeCache.values())));
+		this._dependencyTreeCache.clear();
 		this._dependencyRTreeCacheForAddressFunction.clear();
+		this._dependencyManagerService.closeKdTree();
 		this._runtimeService.clearArrayObjectCache();
 		return Promise.resolve(finalTreeList);
 	}
-	_dependencyFeatureCalculation(newTreeList) {
-		const featureMap = this._featureCalculationManagerService.getReferenceExecutorMap();
-		if (featureMap.size === 0) return;
+	_isCyclicUtilMap(treeId, colorMap) {
+		const WHITE = 0;
+		const GRAY = 1;
+		const BLACK = 2;
+		const stack = [treeId];
+		while (stack.length > 0) {
+			const currentTreeId = stack[stack.length - 1];
+			if ((colorMap.get(currentTreeId) || WHITE) === WHITE) {
+				colorMap.set(currentTreeId, GRAY);
+				const node = this._dependencyTreeCache.get(currentTreeId);
+				if (node == null) {
+					colorMap.set(currentTreeId, BLACK);
+					stack.pop();
+					continue;
+				}
+				const parents = this._dependencyManagerService.searchDependency(node.toRTreeItem());
+				for (const parentTreeId of parents) {
+					const parentColor = colorMap.get(parentTreeId) || WHITE;
+					if (parentColor === GRAY) return true;
+					else if (parentColor === WHITE) stack.push(parentTreeId);
+				}
+			} else {
+				colorMap.set(currentTreeId, BLACK);
+				stack.pop();
+			}
+		}
+		return false;
+	}
+	_checkIsCycleDependency(treeList) {
+		const colorMap = /* @__PURE__ */ new Map();
+		for (const tree of treeList) if (!colorMap.has(tree.treeId)) {
+			if (this._isCyclicUtilMap(tree.treeId, colorMap)) return true;
+		}
+		colorMap.clear();
+		return false;
+	}
+	_getFeatureFormulaTree(featureId, treeId, params) {
+		const { unitId, subUnitId, dependencyRanges, getDirtyData } = params;
+		const FDtree = new FormulaDependencyTree(treeId || generateRandomDependencyTreeId(this._dependencyManagerService));
+		FDtree.unitId = unitId;
+		FDtree.subUnitId = subUnitId;
+		FDtree.rangeList = dependencyRanges;
+		FDtree.getDirtyData = getDirtyData;
+		const allDependency = getDirtyData(this._currentConfigService.getDirtyData(), this._runtimeService.getAllRuntimeData());
+		FDtree.featureDirtyRanges = this._convertDirtyRangesToUnitRange(allDependency.dirtyRanges);
+		FDtree.featureId = featureId;
+		FDtree.type = 2;
+		this._dependencyManagerService.addFeatureFormulaDependency(unitId, subUnitId, featureId, FDtree);
+		this._dependencyTreeCache.set(FDtree.treeId, FDtree);
+		if (this._dependencyManagerService.getFeatureFormulaDependency(params.unitId, params.subUnitId, featureId)) FDtree.isCache = true;
+		return FDtree;
+	}
+	_registerOtherFormulas(otherFormulaData, otherFormulaDataKeys, treeList) {
 		/**
-		* Clear the dependency relationships of all featureCalculation nodes in the tree.
-		* Because each execution requires rebuilding the reverse dependencies,
-		* the previous dependencies may become outdated due to data changes in applications such as pivot tables,
-		* which can result in an outdated dirty mark range.
+		* Register formulas in doc, slide, and other types of applications.
 		*/
-		this._clearFeatureCalculationNode(newTreeList);
-		let hasFeatureCalculation = false;
-		featureMap.forEach((subUnitMap, _) => {
-			subUnitMap.forEach((featureMap, _) => {
-				featureMap.forEach((params, featureId) => {
-					const { unitId, subUnitId, getDirtyData } = params;
-					const allDependency = getDirtyData(this._currentConfigService.getDirtyData(), this._runtimeService.getAllRuntimeData());
-					const dirtyRanges = this._convertDirtyRangesToUnitRange(allDependency.dirtyRanges);
-					const intersectTrees = this._intersectFeatureCalculation(dirtyRanges, newTreeList, {
-						unitId,
-						subUnitId,
-						featureId
-					});
-					if (intersectTrees.length > 0) {
-						let featureTree = this._getExistTreeList({
-							unitId,
-							subUnitId,
-							featureId
-						}, newTreeList);
-						if (featureTree == null) {
-							featureTree = this._getFeatureFormulaTree(featureId, generateRandomDependencyTreeId(this._dependencyManagerService), params);
-							newTreeList.push(featureTree);
+		for (const unitId of otherFormulaDataKeys) {
+			const subComponentData = otherFormulaData[unitId];
+			if (subComponentData == null) continue;
+			const subComponentKeys = Object.keys(subComponentData);
+			for (const subUnitId of subComponentKeys) {
+				const subFormulaData = subComponentData[subUnitId];
+				if (subFormulaData == null) continue;
+				const { rowCount = Infinity, columnCount = Infinity } = this._currentConfigService.getSheetRowColumnCount(unitId, subUnitId) || {};
+				const subFormulaDataKeys = Object.keys(subFormulaData);
+				for (const subFormulaDataId of subFormulaDataKeys) {
+					var _treeMatrix$getValue;
+					const hasOtherFormula = this._dependencyManagerService.hasOtherFormulaDataMainData(subFormulaDataId);
+					const { f: formulaString, ranges } = subFormulaData[subFormulaDataId];
+					let isCache = false;
+					if (hasOtherFormula) isCache = true;
+					const { firstRow, firstColumn } = this._getFirstCellOfRange(ranges);
+					const treeMatrix = this._dependencyManagerService.getOtherFormulaDependency(unitId, subUnitId, subFormulaDataId);
+					const firstFDtree = new FormulaDependencyTree((_treeMatrix$getValue = treeMatrix === null || treeMatrix === void 0 ? void 0 : treeMatrix.getValue(0, 0)) !== null && _treeMatrix$getValue !== void 0 ? _treeMatrix$getValue : generateRandomDependencyTreeId(this._dependencyManagerService));
+					for (let i = 0; i < ranges.length; i++) {
+						const range = ranges[i];
+						const { startRow, startColumn } = range;
+						let { endRow, endColumn } = range;
+						endRow = Math.min(endRow, rowCount - 1);
+						endColumn = Math.min(endColumn, columnCount - 1);
+						for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) {
+							const x = c - firstColumn;
+							const y = r - firstRow;
+							if (x === 0 && y === 0) {
+								firstFDtree.formula = formulaString;
+								firstFDtree.unitId = unitId;
+								firstFDtree.subUnitId = subUnitId;
+								firstFDtree.formulaId = subFormulaDataId;
+								firstFDtree.type = 1;
+								firstFDtree.isCache = isCache;
+								treeList.push(firstFDtree);
+								this._dependencyTreeCache.set(firstFDtree.treeId, firstFDtree);
+								this._dependencyManagerService.addOtherFormulaDependency(unitId, subUnitId, subFormulaDataId, firstFDtree);
+								this._dependencyManagerService.addFormulaDependencyByDefinedName(firstFDtree);
+								continue;
+							}
+							const virtual = new FormulaDependencyTreeVirtual();
+							virtual.treeId = (treeMatrix === null || treeMatrix === void 0 ? void 0 : treeMatrix.getValue(x, y)) || generateRandomDependencyTreeId(this._dependencyManagerService);
+							virtual.refTree = firstFDtree;
+							virtual.refOffsetX = x;
+							virtual.refOffsetY = y;
+							virtual.isCache = isCache;
+							virtual.type = 1;
+							this._dependencyManagerService.addOtherFormulaDependency(unitId, subUnitId, subFormulaDataId, virtual);
+							this._dependencyManagerService.addFormulaDependencyByDefinedName(virtual);
+							treeList.push(virtual);
+							this._dependencyTreeCache.set(virtual.treeId, virtual);
 						}
-						featureTree.parents = /* @__PURE__ */ new Set();
-						intersectTrees.forEach((tree) => {
-							if (tree.hasChildren(featureTree.treeId)) return;
-							tree.pushChildren(featureTree);
-						});
-						hasFeatureCalculation = true;
 					}
+					this._dependencyManagerService.addOtherFormulaDependencyMainData(subFormulaDataId);
+				}
+			}
+		}
+	}
+	_registerFormulas(formulaDataKeys, formulaData, unitData, treeList) {
+		/**
+		* Register formulas in the sheet.
+		*/
+		for (const unitId of formulaDataKeys) {
+			const sheetData = formulaData[unitId];
+			if (sheetData == null) continue;
+			const sheetDataKeys = Object.keys(sheetData);
+			for (const sheetId of sheetDataKeys) {
+				const matrixData = new _univerjs_core.ObjectMatrix(sheetData[sheetId] || {});
+				const sIdCache = /* @__PURE__ */ new Map();
+				matrixData.forValue((row, column, formulaDataItem) => {
+					if (formulaDataItem == null) return true;
+					const { x = 0, y = 0, si } = formulaDataItem;
+					if (!(x === 0 && y === 0 && si != null)) return true;
+					const FDtree = this._createFDtree(unitId, sheetId, row, column, unitData, formulaDataItem);
+					const treeId = this._dependencyManagerService.getFormulaDependency(unitId, sheetId, row, column);
+					if (treeId != null) FDtree.treeId = treeId;
+					else {
+						this._dependencyManagerService.addFormulaDependency(unitId, sheetId, row, column, FDtree);
+						this._dependencyManagerService.addFormulaDependencyByDefinedName(FDtree);
+					}
+					sIdCache.set(si, FDtree);
+					treeList.push(FDtree);
+					this._dependencyTreeCache.set(FDtree.treeId, FDtree);
 				});
-			});
-		});
-		return hasFeatureCalculation;
+				matrixData.forValue((row, column, formulaDataItem) => {
+					if (formulaDataItem == null) return true;
+					const { x = 0, y = 0, si } = formulaDataItem;
+					if (x === 0 && y === 0 && si != null) return true;
+					let FDtree;
+					if (si && sIdCache.has(si)) {
+						const cache = sIdCache.get(si);
+						FDtree = this._createVirtualFDtree(cache, formulaDataItem);
+					} else FDtree = this._createFDtree(unitId, sheetId, row, column, unitData, formulaDataItem);
+					const treeId = this._dependencyManagerService.getFormulaDependency(unitId, sheetId, row, column);
+					if (treeId != null) FDtree.treeId = treeId;
+					else {
+						this._dependencyManagerService.addFormulaDependency(unitId, sheetId, row, column, FDtree);
+						this._dependencyManagerService.addFormulaDependencyByDefinedName(FDtree);
+					}
+					treeList.push(FDtree);
+					this._dependencyTreeCache.set(FDtree.treeId, FDtree);
+				});
+				sIdCache.clear();
+			}
+		}
+	}
+	_createFDtree(unitId, sheetId, row, column, unitData, formulaDataItem) {
+		const { f: formulaString, x = 0, y = 0 } = formulaDataItem;
+		const FDtree = new FormulaDependencyTree(generateRandomDependencyTreeId(this._dependencyManagerService));
+		const sheetItem = unitData[unitId][sheetId];
+		FDtree.formula = formulaString;
+		FDtree.unitId = unitId;
+		FDtree.subUnitId = sheetId;
+		FDtree.row = row;
+		FDtree.column = column;
+		FDtree.rowCount = sheetItem.rowCount;
+		FDtree.columnCount = sheetItem.columnCount;
+		return FDtree;
 	}
-	_clearFeatureCalculationNode(newTreeList) {
-		const featureMap = this._featureCalculationManagerService.getReferenceExecutorMap();
-		newTreeList.forEach((tree) => {
-			const newChildren = /* @__PURE__ */ new Set();
-			for (const childTreeId of tree.children) {
-				var _featureMap$get;
-				const child = this._dependencyManagerService.getTreeById(childTreeId);
-				if (!child) continue;
-				if (!child.featureId) newChildren.add(childTreeId);
-				else if (!((_featureMap$get = featureMap.get(tree.unitId)) === null || _featureMap$get === void 0 || (_featureMap$get = _featureMap$get.get(tree.subUnitId)) === null || _featureMap$get === void 0 ? void 0 : _featureMap$get.has(child.featureId))) newChildren.add(childTreeId);
+	/**
+	* Build a formula dependency tree based on the dependency relationships.
+	* @param treeList
+	*/
+	_getUpdateTreeListAndMakeDependency() {
+		const newTreeList = [];
+		const existTree = /* @__PURE__ */ new Set();
+		const forceCalculate = this._currentConfigService.isForceCalculate();
+		const dirtyRanges = this._currentConfigService.getDirtyRanges();
+		const treeIds = this._dependencyManagerService.searchDependency(dirtyRanges);
+		const addressSearchResults = this._dependencyRTreeCacheForAddressFunction.bulkSearch(dirtyRanges);
+		for (const addressSearchResult of addressSearchResults) treeIds.add(addressSearchResult);
+		for (const [treeId, tree] of this._dependencyTreeCache)
+ /**
+		* forceCalculate: Mandatory calculation, adding all formulas to dependencies
+		* tree.dependencyRange: Formula dependent modification range
+		* includeTree: modification range contains formula
+		*/
+		if ((forceCalculate || tree.isDirty || tree.dependencySheetName(this._currentConfigService.getDirtyNameMap()) || treeIds.has(treeId) && !tree.isExcludeRange(this._currentConfigService.getExcludedRange())) && !existTree.has(treeId)) {
+			newTreeList.push(tree);
+			existTree.add(treeId);
+		}
+		for (const [treeId, tree] of this._dependencyTreeCache) {
+			if (tree.isVirtual) continue;
+			tree.rangeList.length = 0;
+		}
+		return newTreeList;
+	}
+	_getTreeById(treeId) {
+		return this._dependencyTreeCache.get(treeId);
+	}
+	_getTreeNode(tree) {
+		return generateAstNode(tree.unitId, tree.formula, this._lexer, this._astTreeBuilder, this._currentConfigService);
+	}
+	*_traverse(treeList, skippedTreeIds) {
+		const stack = treeList;
+		const cacheStack = /* @__PURE__ */ new Set();
+		while (stack.length > 0) {
+			const tree = stack.pop();
+			cacheStack.clear();
+			if (tree === void 0 || tree.isSkip()) continue;
+			if (tree.isAdded()) {
+				yield tree;
+				tree.setSkip();
+				skippedTreeIds.add(tree.treeId);
+				continue;
 			}
-			tree.children = newChildren;
-			const newParents = /* @__PURE__ */ new Set();
-			for (const parentTreeId of tree.parents) {
-				var _featureMap$get2;
-				const parent = this._dependencyManagerService.getTreeById(parentTreeId);
-				if (!parent) continue;
-				if (!parent.featureId) newParents.add(parentTreeId);
-				else if (!((_featureMap$get2 = featureMap.get(tree.unitId)) === null || _featureMap$get2 === void 0 || (_featureMap$get2 = _featureMap$get2.get(tree.subUnitId)) === null || _featureMap$get2 === void 0 ? void 0 : _featureMap$get2.has(parent.featureId))) newParents.add(parentTreeId);
+			const searchResults = this._dependencyManagerService.searchDependency(tree.toRTreeItem(), skippedTreeIds);
+			const addressSearchResults = this._dependencyRTreeCacheForAddressFunction.bulkSearch(tree.toRTreeItem(), skippedTreeIds);
+			for (const addressSearchResult of addressSearchResults) searchResults.add(addressSearchResult);
+			for (const parentTreeId of searchResults) {
+				const parentTree = this._dependencyTreeCache.get(parentTreeId);
+				if (!parentTree) {
+					console.error("Dependency tree not found for treeId:", parentTreeId);
+					continue;
+				}
+				if (parentTree.isAdded() || tree.isSkip()) continue;
+				cacheStack.add(parentTree);
 			}
-			tree.parents = newParents;
-		});
+			searchResults.clear();
+			if (cacheStack.size === 0) {
+				yield tree;
+				tree.setSkip();
+				skippedTreeIds.add(tree.treeId);
+			} else {
+				tree.setAdded();
+				stack.push(tree);
+				for (const cacheTree of cacheStack) stack.push(cacheTree);
+			}
+		}
+		stack.length = 0;
+		cacheStack.clear();
+	}
+	_calculateRunList(treeList) {
+		const formulaRunList = [];
+		const skippedTreeIds = /* @__PURE__ */ new Set();
+		for (const tree of this._traverse(treeList, skippedTreeIds)) formulaRunList.push(tree);
+		return formulaRunList;
+	}
+	async _getAllTreeList() {
+		await this._initializeGenerateTreeList();
+		return Array.from(this._dependencyTreeCache.values());
+	}
+	_getDependencyTreeParenIds(tree) {
+		return this._dependencyManagerService.searchDependency(tree.toRTreeItem());
+	}
+	_getDependencyTreeChildrenIds(tree) {
+		const childrenIds = /* @__PURE__ */ new Set();
+		const rangeList = tree.rangeList;
+		for (const [treeId, dependencyTree] of this._dependencyTreeCache) for (const unitRange of rangeList) {
+			const unitId = unitRange.unitId;
+			const sheetId = unitRange.sheetId;
+			if (dependencyTree.unitId !== unitId || dependencyTree.subUnitId !== sheetId) continue;
+			const range = unitRange.range;
+			if (dependencyTree.inRangeData(range)) {
+				childrenIds.add(treeId);
+				break;
+			}
+		}
+		return childrenIds;
+	}
+	_startFormulaDependencyTreeModel() {
+		this._dependencyManagerService.openKdTree();
+	}
+	_endFormulaDependencyTreeModel() {
+		this._formulaDependencyTreeModel.clear();
+		this._dependencyTreeCache.clear();
+		this._dependencyManagerService.closeKdTree();
 	}
 	/**
 	* TODO @DR-Univer: The next step will be to try changing the incoming dirtyRanges to an array, thus avoiding conversion.
@@ -12354,23 +13024,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		}
 		return unitRange;
 	}
-	_intersectFeatureCalculation(dirtyRanges, newTreeList, param) {
-		const dependencyTree = [];
-		const treeIds = this._dependencyManagerService.searchDependency(dirtyRanges);
-		for (let i = 0, len = newTreeList.length; i < len; i++) {
-			const tree = newTreeList[i];
-			if (tree.unitId === param.unitId && tree.subUnitId === param.subUnitId && tree.featureId === param.featureId) continue;
-			if (treeIds.has(tree.treeId)) dependencyTree.push(tree);
-		}
-		return dependencyTree;
-	}
-	_getExistTreeList(param, treeList) {
-		const { unitId, subUnitId, featureId } = param;
-		for (let i = 0, len = treeList.length; i < len; i++) {
-			const tree = treeList[i];
-			if (tree.unitId === unitId && tree.subUnitId === subUnitId && tree.featureId === featureId) return tree;
-		}
-	}
 	_isCyclicUtil(treeId, visited, recursionStack) {
 		const node = this._dependencyManagerService.getTreeById(treeId);
 		if (node == null) return false;
@@ -12385,15 +13038,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		recursionStack.delete(node.treeId);
 		return false;
 	}
-	_checkIsCycleDependency(treeList) {
-		const visited = /* @__PURE__ */ new Set();
-		const recursionStack = /* @__PURE__ */ new Set();
-		for (let i = 0, len = treeList.length; i < len; i++) {
-			const tree = treeList[i];
-			if (this._isCyclicUtil(tree.treeId, visited, recursionStack) === true) return true;
-		}
-		return false;
-	}
 	/**
 	* Generate nodes for the dependency tree, where each node contains all the reference data ranges included in each formula.
 	* @param formulaData
@@ -12440,82 +13084,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 			});
 		});
 	}
-	_getFeatureFormulaTree(featureId, treeId, params) {
-		const { unitId, subUnitId, dependencyRanges, getDirtyData } = params;
-		const FDtree = new FormulaDependencyTree(treeId || generateRandomDependencyTreeId(this._dependencyManagerService));
-		FDtree.unitId = unitId;
-		FDtree.subUnitId = subUnitId;
-		FDtree.rangeList = dependencyRanges;
-		FDtree.getDirtyData = getDirtyData;
-		const allDependency = getDirtyData(this._currentConfigService.getDirtyData(), this._runtimeService.getAllRuntimeData());
-		FDtree.featureDirtyRanges = this._convertDirtyRangesToUnitRange(allDependency.dirtyRanges);
-		FDtree.featureId = featureId;
-		FDtree.type = 2;
-		this._dependencyManagerService.addFeatureFormulaDependency(unitId, subUnitId, featureId, FDtree);
-		if (this._dependencyManagerService.getFeatureFormulaDependency(params.unitId, params.subUnitId, featureId)) FDtree.isCache = true;
-		return FDtree;
-	}
-	_registerOtherFormulas(otherFormulaData, otherFormulaDataKeys, treeList) {
-		/**
-		* Register formulas in doc, slide, and other types of applications.
-		*/
-		for (const unitId of otherFormulaDataKeys) {
-			const subComponentData = otherFormulaData[unitId];
-			if (subComponentData == null) continue;
-			const subComponentKeys = Object.keys(subComponentData);
-			for (const subUnitId of subComponentKeys) {
-				const subFormulaData = subComponentData[subUnitId];
-				if (subFormulaData == null) continue;
-				const { rowCount = Infinity, columnCount = Infinity } = this._currentConfigService.getSheetRowColumnCount(unitId, subUnitId) || {};
-				const subFormulaDataKeys = Object.keys(subFormulaData);
-				for (const subFormulaDataId of subFormulaDataKeys) {
-					const hasOtherFormula = this._dependencyManagerService.hasOtherFormulaDataMainData(subFormulaDataId);
-					const { f: formulaString, ranges } = subFormulaData[subFormulaDataId];
-					let isCache = false;
-					if (hasOtherFormula) isCache = true;
-					const node = generateAstNode(unitId, formulaString, this._lexer, this._astTreeBuilder, this._currentConfigService);
-					const { firstRow, firstColumn } = this._getFirstCellOfRange(ranges);
-					const treeMatrix = this._dependencyManagerService.getOtherFormulaDependency(unitId, subUnitId, subFormulaDataId);
-					const firstFDtree = new FormulaDependencyTree((treeMatrix === null || treeMatrix === void 0 ? void 0 : treeMatrix.getValue(0, 0)) || generateRandomDependencyTreeId(this._dependencyManagerService));
-					for (let i = 0; i < ranges.length; i++) {
-						const range = ranges[i];
-						const { startRow, startColumn } = range;
-						let { endRow, endColumn } = range;
-						endRow = Math.min(endRow, rowCount - 1);
-						endColumn = Math.min(endColumn, columnCount - 1);
-						for (let r = startRow; r <= endRow; r++) for (let c = startColumn; c <= endColumn; c++) {
-							const x = c - firstColumn;
-							const y = r - firstRow;
-							if (x === 0 && y === 0) {
-								firstFDtree.node = node;
-								firstFDtree.formula = formulaString;
-								firstFDtree.unitId = unitId;
-								firstFDtree.subUnitId = subUnitId;
-								firstFDtree.formulaId = subFormulaDataId;
-								firstFDtree.type = 1;
-								firstFDtree.isCache = isCache;
-								treeList.push(firstFDtree);
-								this._dependencyManagerService.addOtherFormulaDependency(unitId, subUnitId, subFormulaDataId, firstFDtree);
-								this._dependencyManagerService.addFormulaDependencyByDefinedName(firstFDtree);
-								continue;
-							}
-							const virtual = new FormulaDependencyTreeVirtual();
-							virtual.treeId = (treeMatrix === null || treeMatrix === void 0 ? void 0 : treeMatrix.getValue(x, y)) || generateRandomDependencyTreeId(this._dependencyManagerService);
-							virtual.refTree = firstFDtree;
-							virtual.refOffsetX = x;
-							virtual.refOffsetY = y;
-							virtual.isCache = isCache;
-							virtual.type = 1;
-							this._dependencyManagerService.addOtherFormulaDependency(unitId, subUnitId, subFormulaDataId, virtual);
-							this._dependencyManagerService.addFormulaDependencyByDefinedName(virtual);
-							treeList.push(virtual);
-						}
-					}
-					this._dependencyManagerService.addOtherFormulaDependencyMainData(subFormulaDataId);
-				}
-			}
-		}
-	}
 	_getFirstCellOfRange(ranges) {
 		const range = ranges[0];
 		return {
@@ -12523,72 +13091,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 			firstColumn: range.startColumn
 		};
 	}
-	_registerFormulas(formulaDataKeys, formulaData, unitData, treeList) {
-		/**
-		* Register formulas in the sheet.
-		*/
-		for (const unitId of formulaDataKeys) {
-			const sheetData = formulaData[unitId];
-			if (sheetData == null) continue;
-			const sheetDataKeys = Object.keys(sheetData);
-			for (const sheetId of sheetDataKeys) {
-				const matrixData = new _univerjs_core.ObjectMatrix(sheetData[sheetId] || {});
-				const sIdCache = /* @__PURE__ */ new Map();
-				matrixData.forValue((row, column, formulaDataItem) => {
-					if (formulaDataItem == null) return true;
-					const { x = 0, y = 0, si } = formulaDataItem;
-					if (!(x === 0 && y === 0 && si != null)) return true;
-					const FDtree = this._createFDtree(unitId, sheetId, row, column, unitData, formulaDataItem);
-					const treeId = this._dependencyManagerService.getFormulaDependency(unitId, sheetId, row, column);
-					if (treeId != null) {
-						FDtree.treeId = treeId;
-						FDtree.isCache = true;
-						this._dependencyManagerService.updateDependencyTreeDirtyState(treeId, false);
-					} else {
-						this._dependencyManagerService.addFormulaDependency(unitId, sheetId, row, column, FDtree);
-						this._dependencyManagerService.addFormulaDependencyByDefinedName(FDtree);
-					}
-					sIdCache.set(si, FDtree);
-					treeList.push(FDtree);
-				});
-				matrixData.forValue((row, column, formulaDataItem) => {
-					if (formulaDataItem == null) return true;
-					const { x = 0, y = 0, si } = formulaDataItem;
-					if (x === 0 && y === 0 && si != null) return true;
-					let FDtree;
-					if (si && sIdCache.has(si)) {
-						const cache = sIdCache.get(si);
-						FDtree = this._createVirtualFDtree(cache, formulaDataItem);
-					} else FDtree = this._createFDtree(unitId, sheetId, row, column, unitData, formulaDataItem);
-					const treeId = this._dependencyManagerService.getFormulaDependency(unitId, sheetId, row, column);
-					if (treeId != null) {
-						FDtree.treeId = treeId;
-						FDtree.isCache = true;
-						this._dependencyManagerService.updateDependencyTreeDirtyState(treeId, false);
-					} else {
-						this._dependencyManagerService.addFormulaDependency(unitId, sheetId, row, column, FDtree);
-						this._dependencyManagerService.addFormulaDependencyByDefinedName(FDtree);
-					}
-					treeList.push(FDtree);
-				});
-				sIdCache.clear();
-			}
-		}
-	}
-	_createFDtree(unitId, sheetId, row, column, unitData, formulaDataItem) {
-		const { f: formulaString, x = 0, y = 0 } = formulaDataItem;
-		const FDtree = new FormulaDependencyTree(generateRandomDependencyTreeId(this._dependencyManagerService));
-		const sheetItem = unitData[unitId][sheetId];
-		FDtree.node = generateAstNode(unitId, formulaString, this._lexer, this._astTreeBuilder, this._currentConfigService);
-		FDtree.formula = formulaString;
-		FDtree.unitId = unitId;
-		FDtree.subUnitId = sheetId;
-		FDtree.row = row;
-		FDtree.column = column;
-		FDtree.rowCount = sheetItem.rowCount;
-		FDtree.columnCount = sheetItem.columnCount;
-		return FDtree;
-	}
 	_createVirtualFDtree(tree, formulaDataItem) {
 		const { x = 0, y = 0 } = formulaDataItem;
 		const virtual = new FormulaDependencyTreeVirtual();
@@ -12698,9 +13200,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		this._nodeTraversalReferenceFunction(node, referenceFunctionList);
 		return referenceFunctionList;
 	}
-	_getTreeNode(tree) {
-		return tree.node;
-	}
 	async _buildDirtyRangesByAddressFunction(treeDependencyCache, tree) {
 		const addressFunctionNodes = tree.addressFunctionNodes;
 		if (addressFunctionNodes.length === 0) return;
@@ -12803,9 +13302,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		if (newDirtyRanges.length > 0) this._searchDependencyByAddressFunction(treeDependencyCache, newDirtyRanges, searchResults);
 		return searchResults;
 	}
-	_getTreeById(treeId) {
-		return this._dependencyManagerService.getTreeById(treeId);
-	}
 	_addDependencyTreeByAddressFunction(tree, addressFunctionRangeList) {
 		const searchRanges = [];
 		for (let i = 0; i < addressFunctionRangeList.length; i++) {
@@ -12834,33 +13330,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		}
 		return rangeList;
 	}
-	/**
-	* Build a formula dependency tree based on the dependency relationships.
-	* @param treeList
-	*/
-	_getUpdateTreeListAndMakeDependency(treeList) {
-		const newTreeList = [];
-		const existTree = /* @__PURE__ */ new Set();
-		const forceCalculate = this._currentConfigService.isForceCalculate();
-		const dirtyRanges = this._currentConfigService.getDirtyRanges();
-		const treeIds = this._dependencyManagerService.searchDependency(dirtyRanges);
-		const addressSearchResults = this._dependencyRTreeCacheForAddressFunction.bulkSearch(dirtyRanges);
-		for (const addressSearchResult of addressSearchResults) treeIds.add(addressSearchResult);
-		const allTree = this._dependencyManagerService.buildDependencyTree(treeList);
-		for (const tree of allTree) {
-			const treeId = tree.treeId;
-			/**
-			* forceCalculate: Mandatory calculation, adding all formulas to dependencies
-			* tree.dependencyRange: Formula dependent modification range
-			* includeTree: modification range contains formula
-			*/
-			if ((forceCalculate || tree.isDirty || tree.dependencySheetName(this._currentConfigService.getDirtyNameMap()) || treeIds.has(treeId) && !tree.isExcludeRange(this._currentConfigService.getExcludedRange())) && !existTree.has(treeId)) {
-				newTreeList.push(tree);
-				existTree.add(treeId);
-			}
-		}
-		return newTreeList;
-	}
 	_includeTreeFeature(tree) {
 		const unitId = tree.unitId;
 		const subUnitId = tree.subUnitId;
@@ -12932,63 +13401,12 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		for (const range of ranges) if (tree.inRangeData(range)) return true;
 		return false;
 	}
-	/**
-	* Generate the final formula calculation order array by traversing the dependency tree established via depth-first search.
-	* @param treeList
-	*/
-	_calculateRunList(treeList) {
-		treeList.length;
-		const stack = treeList;
-		const formulaRunList = [];
-		const cacheStack = [];
-		while (stack.length > 0) {
-			const tree = stack.pop();
-			if (tree === void 0 || tree.isSkip()) continue;
-			if (tree.isAdded()) {
-				formulaRunList.push(tree);
-				tree.setSkip();
-				continue;
-			}
-			cacheStack.length = 0;
-			for (const parentTreeId of tree.parents) {
-				const parentTree = this._dependencyManagerService.getTreeById(parentTreeId);
-				if (!parentTree) {
-					console.error("Dependency tree not found for treeId:", parentTreeId);
-					continue;
-				}
-				if (parentTree.isAdded() || tree.isSkip()) continue;
-				cacheStack.push(parentTree);
-			}
-			const addressSearchResults = this._dependencyRTreeCacheForAddressFunction.bulkSearch(tree.toRTreeItem());
-			for (const parentTreeId of addressSearchResults) {
-				const parentTree = this._dependencyManagerService.getTreeById(parentTreeId);
-				if (!parentTree) {
-					console.error("Dependency tree not found for treeId:", parentTreeId);
-					continue;
-				}
-				if (parentTree.isAdded() || tree.isSkip()) continue;
-				cacheStack.push(parentTree);
-			}
-			if (cacheStack.length === 0) {
-				formulaRunList.push(tree);
-				tree.setSkip();
-			} else {
-				tree.setAdded();
-				stack.push(tree, ...cacheStack);
-			}
-		}
-		return formulaRunList;
-	}
 	async _initializeGenerateTreeList() {
 		const formulaData = this._currentConfigService.getFormulaData();
 		const otherFormulaData = this._otherFormulaManagerService.getOtherFormulaData();
 		const unitData = this._currentConfigService.getUnitData();
 		return await this._generateTreeList(formulaData, otherFormulaData, unitData);
 	}
-	async _getAllTreeList() {
-		const treeList = await this._initializeGenerateTreeList();
-		return this._dependencyManagerService.buildDependencyTree(treeList);
-	}
 	_getTreeModel(treeId) {
 		let treeModel = this._formulaDependencyTreeModel.get(treeId);
 		if (!treeModel) {
@@ -13002,12 +13420,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		}
 		return treeModel;
 	}
-	_getDependencyTreeParenIds(tree) {
-		return tree.parents;
-	}
-	_getDependencyTreeChildrenIds(tree) {
-		return tree.children;
-	}
 	_getFormulaDependencyTreeModel(tree) {
 		const treeModel = this._getTreeModel(tree.treeId);
 		const parentIds = this._getDependencyTreeParenIds(tree);
@@ -13020,10 +13432,6 @@ let FormulaDependencyGenerator = class FormulaDependencyGenerator extends _unive
 		}
 		return treeModel;
 	}
-	_endFormulaDependencyTreeModel() {
-		this._formulaDependencyTreeModel.clear();
-	}
-	_startFormulaDependencyTreeModel() {}
 	_getAllDependencyJson(treeList) {
 		this._startFormulaDependencyTreeModel();
 		const results = [];
@@ -13271,7 +13679,7 @@ let CalculateFormulaService = class CalculateFormulaService extends _univerjs_co
 		if (isArrayFormulaState) this._runtimeService.setFormulaExecuteStage(5);
 		else this._runtimeService.setFormulaExecuteStage(2);
 		this._executionInProgressListener$.next(this._runtimeService.getRuntimeState());
-		const treeList = (await this._formulaDependencyGenerator.generate(this._isCalculateTreeModel)).reverse();
+		const treeList = await this._formulaDependencyGenerator.generate(this._isCalculateTreeModel);
 		const interpreter = this._interpreter;
 		if (isArrayFormulaState) {
 			this._runtimeService.setFormulaExecuteStage(6);
@@ -13284,11 +13692,16 @@ let CalculateFormulaService = class CalculateFormulaService extends _univerjs_co
 		let pendingTasks = [];
 		const config = this._configService.getConfig(ENGINE_FORMULA_PLUGIN_CONFIG_KEY);
 		const intervalCount = (config === null || config === void 0 ? void 0 : config.intervalCount) || 500;
+		let i = 0;
 		const treeCount = treeList.length;
-		for (let i = 0; i < treeCount; i++) {
-			var _nodeData$node;
-			const tree = treeList[i];
-			const nodeData = tree.nodeData;
+		while (treeList.length > 0) {
+			const tree = treeList.pop();
+			const node = generateAstNode(tree.unitId, tree.formula, this._lexer, this._astTreeBuilder, this._currentConfigService);
+			const nodeData = {
+				node,
+				refOffsetX: tree.refOffsetX,
+				refOffsetY: tree.refOffsetY
+			};
 			const getDirtyData = tree.getDirtyData;
 			if (i % intervalCount === 0) {
 				/**
@@ -13330,7 +13743,8 @@ let CalculateFormulaService = class CalculateFormulaService extends _univerjs_co
 				if (tree.formulaId != null) this._runtimeService.setRuntimeOtherData(tree.formulaId, tree.refOffsetX, tree.refOffsetY, value);
 				else this._runtimeService.setRuntimeData(value);
 			}
-			(_nodeData$node = nodeData.node) === null || _nodeData$node === void 0 || _nodeData$node.resetCalculationState();
+			node.resetCalculationState();
+			i++;
 		}
 		pendingTasks.forEach((cancel) => cancel());
 		pendingTasks = [];
@@ -15843,13 +16257,26 @@ function isRowHidden(rowData, rowIndex) {
 	if (!row) return false;
 	return row.hd === _univerjs_core.BooleanNumber.TRUE;
 }
+const NESTED_AGGREGATE_FORMULA_CACHE = /* @__PURE__ */ new WeakMap();
 function isNestedAggregateOrSubtotal(cellData, rowIndex, columnIndex, sheetId, unitId, formulaDataModel) {
 	const cellValue = cellData.getValue(rowIndex, columnIndex);
-	if ((cellValue === null || cellValue === void 0 ? void 0 : cellValue.f) || (cellValue === null || cellValue === void 0 ? void 0 : cellValue.si)) {
-		const formulaString = formulaDataModel.getFormulaStringByCell(rowIndex, columnIndex, sheetId, unitId);
-		if (formulaString && (formulaString.indexOf(`${"SUBTOTAL"}(`) > -1 || formulaString.indexOf(`${"AGGREGATE"}(`) > -1)) return true;
-	}
-	return false;
+	if (!(cellValue === null || cellValue === void 0 ? void 0 : cellValue.f) && !(cellValue === null || cellValue === void 0 ? void 0 : cellValue.si)) return false;
+	if (typeof cellValue.f === "string") return hasNestedAggregateFormula(cellValue.f);
+	if (cellValue.si == null) return false;
+	let cache = NESTED_AGGREGATE_FORMULA_CACHE.get(formulaDataModel);
+	if (cache == null) {
+		cache = /* @__PURE__ */ new Map();
+		NESTED_AGGREGATE_FORMULA_CACHE.set(formulaDataModel, cache);
+	}
+	const cacheKey = `${unitId}\0${sheetId}\0${cellValue.si}`;
+	const cached = cache.get(cacheKey);
+	if (cached != null) return cached;
+	const result = hasNestedAggregateFormula(formulaDataModel.getFormulaStringByCell(rowIndex, columnIndex, sheetId, unitId));
+	cache.set(cacheKey, result);
+	return result;
+}
+function hasNestedAggregateFormula(formulaString) {
+	return !!formulaString && (formulaString.indexOf(`${"SUBTOTAL"}(`) > -1 || formulaString.indexOf(`${"AGGREGATE"}(`) > -1);
 }
 function getModeSnglResult(valueCountMap, valueMaxCount) {
 	const result = Object.entries(valueCountMap).filter(([_, { count }]) => count === valueMaxCount).sort((a, b) => a[1].order - b[1].order).map(([value]) => +value);
@@ -15924,40 +16351,54 @@ function getAggregateResult(options, refs) {
 		});
 		if (errorValueObject === null || errorValueObject === void 0 ? void 0 : errorValueObject.isError()) return errorValueObject;
 	}
+	let result;
 	switch (type) {
 		case "AVERAGE":
-			if (n === 0) return ErrorValueObject.create("#DIV/0!");
-			return NumberValueObject.create(sum / n);
-		case "COUNT": return NumberValueObject.create(count);
-		case "COUNTA": return NumberValueObject.create(counta);
-		case "MAX": return NumberValueObject.create(max);
-		case "MIN": return NumberValueObject.create(min);
-		case "PRODUCT": return NumberValueObject.create(n === 0 ? 0 : product);
+			result = n === 0 ? ErrorValueObject.create("#DIV/0!") : NumberValueObject.create(sum / n);
+			break;
+		case "COUNT":
+			result = NumberValueObject.create(count);
+			break;
+		case "COUNTA":
+			result = NumberValueObject.create(counta);
+			break;
+		case "MAX":
+			result = NumberValueObject.create(max);
+			break;
+		case "MIN":
+			result = NumberValueObject.create(min);
+			break;
+		case "PRODUCT":
+			result = NumberValueObject.create(n === 0 ? 0 : product);
+			break;
 		case "STDEV":
 		case "STDEV.S":
-			if (n < 2) return ErrorValueObject.create("#DIV/0!");
-			return createNewArray([valueObjects], 1, n).std(1);
+			result = n < 2 ? ErrorValueObject.create("#DIV/0!") : createNewArray([valueObjects], 1, n).std(1);
+			break;
 		case "STDEVP":
 		case "STDEV.P":
-			if (n === 0) return ErrorValueObject.create("#DIV/0!");
-			return createNewArray([valueObjects], 1, n).std();
-		case "SUM": return NumberValueObject.create(sum);
+			result = n === 0 ? ErrorValueObject.create("#DIV/0!") : createNewArray([valueObjects], 1, n).std();
+			break;
+		case "SUM":
+			result = NumberValueObject.create(sum);
+			break;
 		case "VAR":
 		case "VAR.S":
-			if (n < 2) return ErrorValueObject.create("#DIV/0!");
-			return createNewArray([valueObjects], 1, n).var(1);
+			result = n < 2 ? ErrorValueObject.create("#DIV/0!") : createNewArray([valueObjects], 1, n).var(1);
+			break;
 		case "VARP":
 		case "VAR.P":
-			if (n === 0) return ErrorValueObject.create("#DIV/0!");
-			return createNewArray([valueObjects], 1, n).var();
+			result = n === 0 ? ErrorValueObject.create("#DIV/0!") : createNewArray([valueObjects], 1, n).var();
+			break;
 		case "MEDIAN":
-			if (n === 0) return ErrorValueObject.create("#NUM!");
-			return getMedianResult(valueObjects.map((vo) => +vo.getValue()));
+			result = n === 0 ? ErrorValueObject.create("#NUM!") : getMedianResult(valueObjects.map((vo) => +vo.getValue()));
+			break;
 		case "MODE.SNGL":
-			if (valueCountOrder === 0 || valueMaxCount === 1) return ErrorValueObject.create("#N/A");
-			return getModeSnglResult(valueCountMap, valueMaxCount);
-		default: return ErrorValueObject.create("#VALUE!");
+			result = valueCountOrder === 0 || valueMaxCount === 1 ? ErrorValueObject.create("#N/A") : getModeSnglResult(valueCountMap, valueMaxCount);
+			break;
+		default: result = ErrorValueObject.create("#VALUE!");
 	}
+	return result;
 }
 function getArrayValuesByAggregateIgnoreOptions(array, options, formulaDataModel) {
 	const { ignoreRowHidden = false, ignoreErrorValues = false, ignoreNested = false } = options !== null && options !== void 0 ? options : {};
@@ -39960,152 +40401,6 @@ const ALL_IMPLEMENTED_FUNCTIONS = [
 ];
 const ALL_IMPLEMENTED_FUNCTIONS_SET = new Set(ALL_IMPLEMENTED_FUNCTIONS.map(([_, name]) => name));
 
-//#endregion
-//#region src/functions/new-excel-functions.ts
-const NEW_EXCEL_FUNCTIONS = new Set([
-	"ACOT",
-	"ACOTH",
-	"ARABIC",
-	"BASE",
-	"CEILING.MATH",
-	"CEILING.PRECISE",
-	"COMBINA",
-	"COT",
-	"COTH",
-	"CSC",
-	"CSCH",
-	"DECIMAL",
-	"FLOOR.MATH",
-	"FLOOR.PRECISE",
-	"MUNIT",
-	"RANDARRAY",
-	"SEC",
-	"SECH",
-	"SEQUENCE",
-	"CHOOSECOLS",
-	"CHOOSEROWS",
-	"DROP",
-	"EXPAND",
-	"FILTER",
-	"FORMULATEXT",
-	"HSTACK",
-	"SORT",
-	"SORTBY",
-	"TAKE",
-	"TOCOL",
-	"TOROW",
-	"UNIQUE",
-	"VSTACK",
-	"WRAPCOLS",
-	"WRAPROWS",
-	"XLOOKUP",
-	"XMATCH",
-	"BITAND",
-	"BITLSHIFT",
-	"BITOR",
-	"BITRSHIFT",
-	"BITXOR",
-	"ERF.PRECISE",
-	"ERFC.PRECISE",
-	"IMCOSH",
-	"IMCOT",
-	"IMCSC",
-	"IMCSCH",
-	"IMSEC",
-	"IMSECH",
-	"IMSINH",
-	"IMTAN",
-	"ISFORMULA",
-	"SHEET",
-	"SHEETS",
-	"IFNA",
-	"IFS",
-	"SWITCH",
-	"XOR",
-	"BETA.DIST",
-	"BETA.INV",
-	"BINOM.DIST",
-	"BINOM.DIST.RANGE",
-	"BINOM.INV",
-	"CHISQ.DIST",
-	"CHISQ.DIST.RT",
-	"CHISQ.INV",
-	"CHISQ.INV.RT",
-	"CHISQ.TEST",
-	"CONFIDENCE.NORM",
-	"CONFIDENCE.T",
-	"COVARIANCE.P",
-	"COVARIANCE.S",
-	"EXPON.DIST",
-	"F.DIST",
-	"F.DIST.RT",
-	"F.INV",
-	"F.INV.RT",
-	"F.TEST",
-	"FORECAST.LINEAR",
-	"GAMMA",
-	"GAMMA.DIST",
-	"GAMMA.INV",
-	"GAMMALN.PRECISE",
-	"GAUSS",
-	"HYPGEOM.DIST",
-	"LOGNORM.DIST",
-	"LOGNORM.INV",
-	"MAXIFS",
-	"MINIFS",
-	"MODE.MULT",
-	"MODE.SNGL",
-	"NEGBINOM.DIST",
-	"NORM.DIST",
-	"NORM.INV",
-	"NORM.S.DIST",
-	"NORM.S.INV",
-	"PERCENTILE.EXC",
-	"PERCENTILE.INC",
-	"PERCENTRANK.EXC",
-	"PERCENTRANK.INC",
-	"PERMUTATIONA",
-	"PHI",
-	"POISSON.DIST",
-	"QUARTILE.EXC",
-	"QUARTILE.INC",
-	"RANK.AVG",
-	"RANK.EQ",
-	"SKEW.P",
-	"STDEV.P",
-	"STDEV.S",
-	"T.DIST",
-	"T.DIST.2T",
-	"T.DIST.RT",
-	"T.INV",
-	"T.INV.2T",
-	"T.TEST",
-	"VAR.P",
-	"VAR.S",
-	"WEIBULL.DIST",
-	"Z.TEST",
-	"ARRAYTOTEXT",
-	"ENCODEURL",
-	"NUMBERVALUE",
-	"TEXTAFTER",
-	"TEXTBEFORE",
-	"TEXTJOIN",
-	"TEXTSPLIT",
-	"UNICHAR",
-	"UNICODE",
-	"VALUETOTEXT",
-	"DAYS",
-	"ISOWEEKNUM",
-	"PDURATION",
-	"RRI",
-	"BYCOL",
-	"BYROW",
-	"MAKEARRAY",
-	"MAP",
-	"REDUCE",
-	"SCAN"
-]);
-
 //#endregion
 //#region src/functions/univer/function-names.ts
 /**
@@ -40152,7 +40447,7 @@ function getObjectValue(result, isUseStrip = false) {
 //#endregion
 //#region package.json
 var name = "@univerjs/engine-formula";
-var version = "0.22.1";
+var version = "0.23.0-insiders.20260522-ee0b0a4";
 
 //#endregion
 //#region src/services/global-computing-status.service.ts
@@ -40551,6 +40846,7 @@ let RegisterOtherFormulaService = class RegisterOtherFormulaService extends _uni
 				} }
 			};
 			this._commandService.executeCommand(SetOtherFormulaMutation.id, params, { onlyLocal: true }).then(() => {
+				if (this._disposed) return;
 				this._commandService.executeCommand(OtherFormulaMarkDirty.id, { [unitId]: { [subUnitId]: { [formulaId]: true } } }, { onlyLocal: true });
 			});
 		};
@@ -40738,6 +41034,7 @@ exports.BaseReferenceObject = BaseReferenceObject;
 exports.BaseValueObject = BaseValueObject;
 exports.BooleanValue = BooleanValue;
 exports.BooleanValueObject = BooleanValueObject;
+exports.CELL_INVERTED_INDEX_CACHE = CELL_INVERTED_INDEX_CACHE;
 Object.defineProperty(exports, 'CalculateController', {
   enumerable: true,
   get: function () {
@@ -40751,6 +41048,7 @@ Object.defineProperty(exports, 'CalculateFormulaService', {
   }
 });
 exports.CustomFunction = CustomFunction;
+exports.DEFAULT_CYCLE_REFERENCE_COUNT = DEFAULT_CYCLE_REFERENCE_COUNT;
 exports.DEFAULT_INTERVAL_COUNT = DEFAULT_INTERVAL_COUNT;
 exports.DEFAULT_TOKEN_LAMBDA_FUNCTION_NAME = DEFAULT_TOKEN_LAMBDA_FUNCTION_NAME;
 exports.DEFAULT_TOKEN_LET_FUNCTION_NAME = DEFAULT_TOKEN_LET_FUNCTION_NAME;
@@ -40771,6 +41069,7 @@ exports.ENGINE_FORMULA_RETURN_DEPENDENCY_TREE = ENGINE_FORMULA_RETURN_DEPENDENCY
 exports.ERROR_TYPE_SET = ERROR_TYPE_SET;
 exports.ErrorType = ErrorType;
 exports.ErrorValueObject = ErrorValueObject;
+exports.FORMULA_REF_TO_ARRAY_CACHE = FORMULA_REF_TO_ARRAY_CACHE;
 exports.FUNCTION_NAMES_ARRAY = FUNCTION_NAMES_ARRAY;
 exports.FUNCTION_NAMES_COMPATIBILITY = FUNCTION_NAMES_COMPATIBILITY;
 exports.FUNCTION_NAMES_CUBE = FUNCTION_NAMES_CUBE;