@univerjs/sheets-formula 0.1.0-alpha.1

package/lib/cjs/index.js

@@ -0,0 +1,4215 @@
+"use strict";
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var _import_core17_Plugin, _class;
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && typeof from === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toESM = function(mod, isNodeMode, target) {
+    return target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(// If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+        value: mod,
+        enumerable: true
+    }) : target, mod);
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+var __decorateClass = function(decorators, target, key, kind) {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+    for(var i = decorators.length - 1, decorator; i >= 0; i--)if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+    if (kind && result) __defProp(target, key, result);
+    return result;
+};
+var __decorateParam = function(index, decorator) {
+    return function(target, key) {
+        return decorator(target, key, index);
+    };
+};
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+    FormulaUIPlugin: function() {
+        return FormulaUIPlugin;
+    }
+});
+module.exports = __toCommonJS(src_exports);
+// src/formula-ui-plugin.ts
+var import_core17 = require("@univerjs/core");
+var import_redi8 = require("@wendellhu/redi");
+// src/common/plugin-name.ts
+var FORMULA_UI_PLUGIN_NAME = "formula-ui";
+// src/controllers/formula-auto-fill.controller.ts
+var import_core = require("@univerjs/core");
+var import_engine_formula = require("@univerjs/engine-formula");
+var import_sheets_ui = require("@univerjs/sheets-ui");
+var import_redi = require("@wendellhu/redi");
+var FormulaAutoFillController = /*#__PURE__*/ function(_import_core_Disposable) {
+    _inherits(FormulaAutoFillController, _import_core_Disposable);
+    var _super = _create_super(FormulaAutoFillController);
+    function FormulaAutoFillController(_autoFillService, _formulaEngineService) {
+        _class_call_check(this, FormulaAutoFillController);
+        var _this;
+        _this = _super.call(this);
+        _this._autoFillService = _autoFillService;
+        _this._formulaEngineService = _formulaEngineService;
+        _this._initialize();
+        return _this;
+    }
+    _create_class(FormulaAutoFillController, [
+        {
+            key: "_initialize",
+            value: function _initialize() {
+                this._registerAutoFill();
+            }
+        },
+        {
+            key: "_registerAutoFill",
+            value: function _registerAutoFill() {
+                var _this = this;
+                var formulaRule = {
+                    type: import_sheets_ui.DATA_TYPE.FORMULA,
+                    priority: 1001,
+                    match: function(cellData) {
+                        return (0, import_core.isFormulaString)(cellData === null || cellData === void 0 ? void 0 : cellData.f);
+                    },
+                    isContinue: function(prev, cur) {
+                        if (prev.type === import_sheets_ui.DATA_TYPE.FORMULA) {
+                            return true;
+                        }
+                        return false;
+                    },
+                    applyFunctions: _define_property({}, import_sheets_ui.APPLY_TYPE.COPY, function(dataWithIndex, len, direction, copyDataPiece) {
+                        var data = dataWithIndex.data, index = dataWithIndex.index;
+                        return _this._fillCopyFormula(data, len, direction, index, copyDataPiece);
+                    })
+                };
+                this._autoFillService.registerRule(formulaRule);
+            }
+        },
+        {
+            key: "_fillCopyFormula",
+            value: function _fillCopyFormula(data, len, direction, index, copyDataPiece) {
+                var step = getDataLength(copyDataPiece);
+                var applyData = [];
+                var formulaIdMap = /* @__PURE__ */ new Map();
+                for(var i = 1; i <= len; i++){
+                    var index2 = (i - 1) % data.length;
+                    var d = import_core.Tools.deepClone(data[index2]);
+                    if (d) {
+                        var _data_index2;
+                        var originalFormula = (_data_index2 = data[index2]) === null || _data_index2 === void 0 ? void 0 : _data_index2.f;
+                        if (originalFormula) {
+                            var formulaId = formulaIdMap.get(index2);
+                            if (!formulaId) {
+                                formulaId = import_core.Tools.generateRandomId(6);
+                                formulaIdMap.set(index2, formulaId);
+                                var _directionToOffset = directionToOffset(step, direction), offsetX = _directionToOffset.offsetX, offsetY = _directionToOffset.offsetY;
+                                var shiftedFormula = this._formulaEngineService.moveFormulaRefOffset(originalFormula, offsetX, offsetY);
+                                d.si = formulaId;
+                                d.f = shiftedFormula;
+                                d.v = null;
+                                d.p = null;
+                            } else {
+                                d.si = formulaId;
+                                d.f = null;
+                                d.v = null;
+                                d.p = null;
+                            }
+                            if (direction === import_core.Direction.DOWN || direction === import_core.Direction.RIGHT) {
+                                applyData.push(d);
+                            } else {
+                                applyData.unshift(d);
+                            }
+                        }
+                    }
+                }
+                return applyData;
+            }
+        }
+    ]);
+    return FormulaAutoFillController;
+}(import_core.Disposable);
+FormulaAutoFillController = __decorateClass([
+    (0, import_core.OnLifecycle)(import_core.LifecycleStages.Ready, FormulaAutoFillController),
+    __decorateParam(0, import_sheets_ui.IAutoFillService),
+    __decorateParam(1, (0, import_redi.Inject)(import_engine_formula.FormulaEngineService))
+], FormulaAutoFillController);
+function directionToOffset(step, direction) {
+    var offsetX = 0;
+    var offsetY = 0;
+    switch(direction){
+        case import_core.Direction.UP:
+            offsetY = -step;
+            break;
+        case import_core.Direction.RIGHT:
+            offsetX = step;
+            break;
+        case import_core.Direction.DOWN:
+            offsetY = step;
+            break;
+        case import_core.Direction.LEFT:
+            offsetX = -step;
+            break;
+    }
+    return {
+        offsetX: offsetX,
+        offsetY: offsetY
+    };
+}
+function getDataLength(copyDataPiece) {
+    var length = 0;
+    for(var t in copyDataPiece){
+        copyDataPiece[t].forEach(function(item) {
+            length += item.data.length;
+        });
+    }
+    return length;
+}
+// src/controllers/formula-input.controller.ts
+var import_core3 = require("@univerjs/core");
+var import_engine_formula3 = require("@univerjs/engine-formula");
+var import_engine_render = require("@univerjs/engine-render");
+var import_sheets_ui2 = require("@univerjs/sheets-ui");
+var import_ui = require("@univerjs/ui");
+var import_redi3 = require("@wendellhu/redi");
+// src/commands/operations/reference-absolute.operation.ts
+var import_core2 = require("@univerjs/core");
+var ReferenceAbsoluteOperation = {
+    id: "formula-ui.operation.change-ref-to-absolute",
+    type: import_core2.CommandType.OPERATION,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor) {
+            return _ts_generator(this, function(_state) {
+                return [
+                    2,
+                    true
+                ];
+            });
+        });
+        return function(accessor) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/services/formula-input.service.ts
+var import_engine_formula2 = require("@univerjs/engine-formula");
+var import_redi2 = require("@wendellhu/redi");
+var import_rxjs = require("rxjs");
+var FormulaInputService = /*#__PURE__*/ function() {
+    function FormulaInputService(_formulaEngineService) {
+        _class_call_check(this, FormulaInputService);
+        _define_property(this, "_sequenceNodes", []);
+        _define_property(this, "_isSelectionMoving", false);
+        _define_property(this, "_isLockedOnSelectionChangeRefString", false);
+        _define_property(this, "_isLockedOnSelectionInsertRefString", false);
+        _define_property(this, "_syncToEditor$", new import_rxjs.Subject());
+        _define_property(this, "syncToEditor$", this._syncToEditor$.asObservable());
+        _define_property(this, "_changeRef$", new import_rxjs.Subject());
+        _define_property(this, "changeRef$", this._changeRef$.asObservable());
+        _define_property(this, "_inputFormula$", new import_rxjs.Subject());
+        _define_property(this, "inputFormula$", this._inputFormula$.asObservable());
+        this._formulaEngineService = _formulaEngineService;
+    }
+    _create_class(FormulaInputService, [
+        {
+            key: "dispose",
+            value: function dispose() {
+                this._sequenceNodes = [];
+            }
+        },
+        {
+            key: "inputFormula",
+            value: function inputFormula(formulaString) {
+                this._inputFormula$.next(formulaString);
+            }
+        },
+        {
+            key: "syncToEditor",
+            value: function syncToEditor(textSelectionOffset) {
+                this._syncToEditor$.next({
+                    sequences: this.getSequenceNodes(),
+                    textSelectionOffset: textSelectionOffset
+                });
+            }
+        },
+        {
+            key: "getSequenceNodes",
+            value: function getSequenceNodes() {
+                return _to_consumable_array(this._sequenceNodes);
+            }
+        },
+        {
+            key: "setSequenceNodes",
+            value: function setSequenceNodes(nodes) {
+                this._sequenceNodes = nodes;
+            }
+        },
+        {
+            key: "clearSequenceNodes",
+            value: function clearSequenceNodes() {
+                this._sequenceNodes = [];
+            }
+        },
+        {
+            key: "getCurrentSequenceNode",
+            value: function getCurrentSequenceNode(strIndex) {
+                return this._sequenceNodes[this.getCurrentSequenceNodeIndex(strIndex)];
+            }
+        },
+        {
+            key: "getCurrentSequenceNodeByIndex",
+            value: function getCurrentSequenceNodeByIndex(nodeIndex) {
+                return this._sequenceNodes[nodeIndex];
+            }
+        },
+        {
+            /**
+   * Query the text coordinates in the sequenceNodes and determine the actual insertion index.
+   * @param sequenceNodes
+   * @param strIndex
+   * @returns
+   */ key: "getCurrentSequenceNodeIndex",
+            value: function getCurrentSequenceNodeIndex(strIndex) {
+                var nodeIndex = 0;
+                for(var i = 0, len = this._sequenceNodes.length; i < len; i++){
+                    var node = this._sequenceNodes[i];
+                    if (typeof node === "string") {
+                        nodeIndex++;
+                    } else {
+                        var endIndex = node.endIndex;
+                        nodeIndex = endIndex;
+                    }
+                    if (strIndex <= nodeIndex) {
+                        return i;
+                    }
+                }
+                return this._sequenceNodes.length;
+            }
+        },
+        {
+            /**
+   * Synchronize the reference text based on the changes of the selection.
+   * @param refIndex
+   * @param rangeWithCoord
+   * @returns
+   */ key: "updateSequenceRef",
+            value: function updateSequenceRef(nodeIndex, refString) {
+                var node = this._sequenceNodes[nodeIndex];
+                if (typeof node === "string" || node.nodeType !== import_engine_formula2.sequenceNodeType.REFERENCE) {
+                    return;
+                }
+                var difference = refString.length - node.token.length;
+                var newNode = _object_spread({}, node);
+                newNode.token = refString;
+                newNode.endIndex += difference;
+                this._sequenceNodes[nodeIndex] = newNode;
+                for(var i = nodeIndex + 1, len = this._sequenceNodes.length; i < len; i++){
+                    var node2 = this._sequenceNodes[i];
+                    if (typeof node2 === "string") {
+                        continue;
+                    }
+                    var newNode2 = _object_spread({}, node2);
+                    newNode2.startIndex += difference;
+                    newNode2.endIndex += difference;
+                    this._sequenceNodes[i] = newNode2;
+                }
+                this._changeRef$.next(true);
+            }
+        },
+        {
+            /**
+   * When the cursor is on the right side of a formula token,
+   * you can add reference text to the formula by drawing a selection.
+   * @param index
+   * @param range
+   */ key: "insertSequenceRef",
+            value: function insertSequenceRef(index, refString) {
+                var refStringCount = refString.length;
+                var nodeIndex = this.getCurrentSequenceNodeIndex(index);
+                this._sequenceNodes.splice(nodeIndex, 0, {
+                    token: refString,
+                    startIndex: index,
+                    endIndex: index + refStringCount - 1,
+                    nodeType: import_engine_formula2.sequenceNodeType.REFERENCE
+                });
+                for(var i = nodeIndex + 1, len = this._sequenceNodes.length; i < len; i++){
+                    var node = this._sequenceNodes[i];
+                    if (typeof node === "string") {
+                        continue;
+                    }
+                    var newNode = _object_spread({}, node);
+                    newNode.startIndex += refStringCount;
+                    newNode.endIndex += refStringCount;
+                    this._sequenceNodes[i] = newNode;
+                }
+                this._changeRef$.next(true);
+            }
+        },
+        {
+            /**
+   * Insert a string at the cursor position in the text corresponding to the sequenceNodes.
+   * @param sequenceNodes
+   * @param index
+   * @param content
+   */ key: "insertSequenceString",
+            value: function insertSequenceString(index, content) {
+                var _this__sequenceNodes;
+                var nodeIndex = this.getCurrentSequenceNodeIndex(index);
+                var str = content.split("");
+                (_this__sequenceNodes = this._sequenceNodes).splice.apply(_this__sequenceNodes, [
+                    nodeIndex,
+                    0
+                ].concat(_to_consumable_array(str)));
+                var contentCount = str.length;
+                for(var i = nodeIndex + contentCount, len = this._sequenceNodes.length; i < len; i++){
+                    var node = this._sequenceNodes[i];
+                    if (typeof node === "string") {
+                        continue;
+                    }
+                    var newNode = _object_spread({}, node);
+                    newNode.startIndex += contentCount;
+                    newNode.endIndex += contentCount;
+                    this._sequenceNodes[i] = newNode;
+                }
+                this._changeRef$.next(true);
+            }
+        },
+        {
+            key: "enableSelectionMoving",
+            value: function enableSelectionMoving() {
+                this._isSelectionMoving = true;
+            }
+        },
+        {
+            key: "disableSelectionMoving",
+            value: function disableSelectionMoving() {
+                this._isSelectionMoving = false;
+            }
+        },
+        {
+            key: "isSelectionMoving",
+            value: function isSelectionMoving() {
+                return this._isSelectionMoving;
+            }
+        },
+        {
+            key: "enableLockedSelectionChange",
+            value: function enableLockedSelectionChange() {
+                this._isLockedOnSelectionChangeRefString = true;
+            }
+        },
+        {
+            key: "disableLockedSelectionChange",
+            value: function disableLockedSelectionChange() {
+                this._isLockedOnSelectionChangeRefString = false;
+            }
+        },
+        {
+            key: "isLockedSelectionChange",
+            value: function isLockedSelectionChange() {
+                return this._isLockedOnSelectionChangeRefString;
+            }
+        },
+        {
+            key: "enableLockedSelectionInsert",
+            value: function enableLockedSelectionInsert() {
+                this._isLockedOnSelectionInsertRefString = true;
+            }
+        },
+        {
+            key: "disableLockedSelectionInsert",
+            value: function disableLockedSelectionInsert() {
+                this._isLockedOnSelectionInsertRefString = false;
+            }
+        },
+        {
+            key: "isLockedSelectionInsert",
+            value: function isLockedSelectionInsert() {
+                return this._isLockedOnSelectionInsertRefString;
+            }
+        }
+    ]);
+    return FormulaInputService;
+}();
+FormulaInputService = __decorateClass([
+    __decorateParam(0, (0, import_redi2.Inject)(import_engine_formula2.FormulaEngineService))
+], FormulaInputService);
+var IFormulaInputService = (0, import_redi2.createIdentifier)("formula-ui.input-service");
+// src/controllers/formula-input.controller.ts
+var FormulaInputController = /*#__PURE__*/ function(_import_core3_Disposable) {
+    _inherits(FormulaInputController, _import_core3_Disposable);
+    var _super = _create_super(FormulaInputController);
+    function FormulaInputController(_commandService, _textSelectionRenderManager, _editorBridgeService, _formulaEngineService, _renderManagerService, _formulaInputService) {
+        _class_call_check(this, FormulaInputController);
+        var _this;
+        _this = _super.call(this);
+        _define_property(_assert_this_initialized(_this), "_userCursorMove", false);
+        _this._commandService = _commandService;
+        _this._textSelectionRenderManager = _textSelectionRenderManager;
+        _this._editorBridgeService = _editorBridgeService;
+        _this._formulaEngineService = _formulaEngineService;
+        _this._renderManagerService = _renderManagerService;
+        _this._formulaInputService = _formulaInputService;
+        _this._initialize();
+        return _this;
+    }
+    _create_class(FormulaInputController, [
+        {
+            key: "_initialize",
+            value: function _initialize() {
+                this._commandExecutedListener();
+                this._initialEditorInputChange();
+                this._userMouseListener();
+                this._inputFormulaListener();
+            }
+        },
+        {
+            key: "_initialEditorInputChange",
+            value: function _initialEditorInputChange() {
+                var _this = this;
+                this.disposeWithMe((0, import_core3.toDisposable)(this._textSelectionRenderManager.onInputBefore$.subscribe(function(param) {
+                    var e = param === null || param === void 0 ? void 0 : param.event;
+                    if (e == null) {
+                        return;
+                    }
+                    if (e.which !== import_ui.KeyCode.F4) {
+                        _this._userCursorMove = false;
+                    }
+                })));
+            }
+        },
+        {
+            key: "_userMouseListener",
+            value: function _userMouseListener() {
+                var _this = this;
+                var editorObject = this._getEditorObject();
+                if (editorObject == null) {
+                    return;
+                }
+                var documentComponent = editorObject.document;
+                this.disposeWithMe((0, import_core3.toDisposable)(documentComponent.onPointerDownObserver.add(function() {
+                    _this._userCursorMove = true;
+                })));
+            }
+        },
+        {
+            key: "_inputFormulaListener",
+            value: function _inputFormulaListener() {
+                var _this = this;
+                this.disposeWithMe((0, import_core3.toDisposable)(this._formulaInputService.inputFormula$.subscribe(function(formulaString) {
+                    var visibleState = _this._editorBridgeService.isVisible();
+                    if (visibleState.visible === false) {
+                        _this._editorBridgeService.changeVisible({
+                            visible: true,
+                            eventType: import_engine_render.DeviceInputEventType.Dblclick
+                        });
+                    }
+                    var lastSequenceNodes = _this._formulaEngineService.buildSequenceNodes(formulaString) || [];
+                    _this._formulaInputService.setSequenceNodes(lastSequenceNodes);
+                    _this._formulaInputService.syncToEditor(formulaString.length - 1);
+                })));
+            }
+        },
+        {
+            key: "_changeRefString",
+            value: function _changeRefString() {
+                var activeRange = this._textSelectionRenderManager.getActiveRange();
+                if (activeRange == null) {
+                    return;
+                }
+                var startOffset = activeRange.startOffset;
+                var strIndex = startOffset - 2;
+                var nodeIndex = this._formulaInputService.getCurrentSequenceNodeIndex(strIndex);
+                var node = this._formulaInputService.getCurrentSequenceNodeByIndex(nodeIndex);
+                if (node == null || typeof node === "string" || node.nodeType !== import_engine_formula3.sequenceNodeType.REFERENCE) {
+                    return;
+                }
+                var tokenArray = node.token.split("!");
+                var token = node.token;
+                if (tokenArray.length > 1) {
+                    token = tokenArray[tokenArray.length - 1];
+                }
+                var unitIDAndSheetName = "";
+                for(var i = 0, len = tokenArray.length; i < len - 1; i++){
+                    unitIDAndSheetName += tokenArray[i];
+                }
+                var finalToken = token;
+                if (token.indexOf(import_engine_formula3.matchToken.COLON) > -1) {
+                    if (!this._userCursorMove) {
+                        finalToken = this._changeRangeRef(token);
+                    } else {
+                        var refStringSplit = token.split(import_engine_formula3.matchToken.COLON);
+                        var prefix = refStringSplit[0];
+                        var suffix = refStringSplit[1];
+                        var relativeIndex = strIndex - node.startIndex;
+                        if (relativeIndex <= prefix.length) {
+                            finalToken = this._changeSingleRef(prefix) + import_engine_formula3.matchToken.COLON + suffix;
+                        } else {
+                            finalToken = prefix + import_engine_formula3.matchToken.COLON + this._changeSingleRef(suffix);
+                        }
+                    }
+                } else {
+                    finalToken = this._changeSingleRef(token);
+                }
+                finalToken = unitIDAndSheetName + finalToken;
+                var difference = finalToken.length - node.token.length;
+                this._formulaInputService.updateSequenceRef(nodeIndex, finalToken);
+                this._formulaInputService.syncToEditor(strIndex + difference + 1);
+            }
+        },
+        {
+            key: "_changeRangeRef",
+            value: function _changeRangeRef(token) {
+                var range = (0, import_core3.deserializeRangeWithSheet)(token).range;
+                var resultToken = "";
+                if (range.startAbsoluteRefType === import_core3.AbsoluteRefType.NONE || range.startAbsoluteRefType == null) {
+                    range.startAbsoluteRefType = import_core3.AbsoluteRefType.ALL;
+                    range.endAbsoluteRefType = import_core3.AbsoluteRefType.ALL;
+                } else {
+                    range.startAbsoluteRefType = import_core3.AbsoluteRefType.NONE;
+                    range.endAbsoluteRefType = import_core3.AbsoluteRefType.NONE;
+                }
+                resultToken = (0, import_core3.serializeRange)(range);
+                return resultToken;
+            }
+        },
+        {
+            key: "_changeSingleRef",
+            value: function _changeSingleRef(token) {
+                var range = (0, import_core3.deserializeRangeWithSheet)(token).range;
+                var type = range.startAbsoluteRefType;
+                var resultToken = "";
+                if (type === import_core3.AbsoluteRefType.NONE || type == null) {
+                    range.startAbsoluteRefType = import_core3.AbsoluteRefType.ALL;
+                    range.endAbsoluteRefType = import_core3.AbsoluteRefType.ALL;
+                } else if (type === import_core3.AbsoluteRefType.ALL) {
+                    range.startAbsoluteRefType = import_core3.AbsoluteRefType.ROW;
+                    range.endAbsoluteRefType = import_core3.AbsoluteRefType.ROW;
+                } else if (type === import_core3.AbsoluteRefType.ROW) {
+                    range.startAbsoluteRefType = import_core3.AbsoluteRefType.COLUMN;
+                    range.endAbsoluteRefType = import_core3.AbsoluteRefType.COLUMN;
+                } else {
+                    range.startAbsoluteRefType = import_core3.AbsoluteRefType.NONE;
+                    range.endAbsoluteRefType = import_core3.AbsoluteRefType.NONE;
+                }
+                resultToken = (0, import_core3.serializeRange)(range);
+                return resultToken;
+            }
+        },
+        {
+            key: "_commandExecutedListener",
+            value: function _commandExecutedListener() {
+                var _this = this;
+                var updateCommandList = [
+                    ReferenceAbsoluteOperation.id
+                ];
+                this.disposeWithMe(this._commandService.onCommandExecuted(function(command) {
+                    if (!updateCommandList.includes(command.id)) {
+                        return;
+                    }
+                    _this._changeRefString();
+                }));
+            }
+        },
+        {
+            key: "_getEditorObject",
+            value: function _getEditorObject() {
+                return (0, import_sheets_ui2.getEditorObject)(this._editorBridgeService.getCurrentEditorId(), this._renderManagerService);
+            }
+        }
+    ]);
+    return FormulaInputController;
+}(import_core3.Disposable);
+FormulaInputController = __decorateClass([
+    (0, import_core3.OnLifecycle)(import_core3.LifecycleStages.Steady, FormulaInputController),
+    __decorateParam(0, import_core3.ICommandService),
+    __decorateParam(1, import_engine_render.ITextSelectionRenderManager),
+    __decorateParam(2, (0, import_redi3.Inject)(import_sheets_ui2.IEditorBridgeService)),
+    __decorateParam(3, (0, import_redi3.Inject)(import_engine_formula3.FormulaEngineService)),
+    __decorateParam(4, import_engine_render.IRenderManagerService),
+    __decorateParam(5, IFormulaInputService)
+], FormulaInputController);
+// src/controllers/formula-ui.controller.ts
+var import_core15 = require("@univerjs/core");
+var import_ui6 = require("@univerjs/ui");
+var import_redi6 = require("@wendellhu/redi");
+var import_react_bindings6 = require("@wendellhu/redi/react-bindings");
+// src/commands/commands/insert-function.command.ts
+var import_core4 = require("@univerjs/core");
+var import_sheets = require("@univerjs/sheets");
+var InsertFunctionCommand = {
+    id: "formula-ui.command.insert-function",
+    type: import_core4.CommandType.COMMAND,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor, params) {
+            var list, commandService, cellMatrix, setRangeValuesParams;
+            return _ts_generator(this, function(_state) {
+                list = params.list;
+                commandService = accessor.get(import_core4.ICommandService);
+                cellMatrix = new import_core4.ObjectMatrix();
+                list.forEach(function(item) {
+                    var range = item.range, primary = item.primary, formula = item.formula;
+                    var row = primary.row, column = primary.column;
+                    var formulaId = import_core4.Tools.generateRandomId(6);
+                    cellMatrix.setValue(row, column, {
+                        f: formula,
+                        si: formulaId
+                    });
+                    var startRow = range.startRow, startColumn = range.startColumn, endRow = range.endRow, endColumn = range.endColumn;
+                    for(var i = startRow; i <= endRow; i++){
+                        for(var j = startColumn; j <= endColumn; j++){
+                            if (i !== row || j !== column) {
+                                cellMatrix.setValue(i, j, {
+                                    si: formulaId
+                                });
+                            }
+                        }
+                    }
+                });
+                setRangeValuesParams = {
+                    value: cellMatrix.getData()
+                };
+                return [
+                    2,
+                    commandService.executeCommand(import_sheets.SetRangeValuesCommand.id, setRangeValuesParams)
+                ];
+            });
+        });
+        return function(accessor, params) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/commands/operations/editor-formula.operation.ts
+var import_core5 = require("@univerjs/core");
+var SelectEditorFormulaOperation = {
+    id: "formula-ui.operation.select-editor-formula",
+    type: import_core5.CommandType.OPERATION,
+    handler: function(accessor, params) {
+        return(// const { eventType, keycode } = params;
+        // const formulaPromptService = accessor.get(IFormulaPromptService);
+        // const editorBridgeService = accessor.get(IEditorBridgeService);
+        // switch (keycode) {
+        //     case KeyCode.ARROW_DOWN:
+        //         formulaPromptService.navigate({ direction: Direction.DOWN });
+        //         break;
+        //     case KeyCode.ARROW_UP:
+        //         formulaPromptService.navigate({ direction: Direction.UP });
+        //         break;
+        //     // case KeyCode.ENTER:
+        //     // case KeyCode.TAB:
+        //     //     if (formulaPromptService.isSearching()) {
+        //     //         formulaPromptService.accept(true);
+        //     //     } else {
+        //     //         const editorBridgeParameters = {
+        //     //             visible: false,
+        //     //             eventType,
+        //     //             keycode,
+        //     //         };
+        //     //         editorBridgeService.changeVisible(editorBridgeParameters);
+        //     //     }
+        //     //     break;
+        //     default:
+        //         break;
+        // }
+        true);
+    }
+};
+// src/commands/operations/help-function.operation.ts
+var import_core6 = require("@univerjs/core");
+// src/services/prompt.service.ts
+var import_redi4 = require("@wendellhu/redi");
+var import_rxjs2 = require("rxjs");
+var IFormulaPromptService = (0, import_redi4.createIdentifier)("formula-ui.prompt-service");
+var FormulaPromptService = /*#__PURE__*/ function() {
+    function FormulaPromptService() {
+        _class_call_check(this, FormulaPromptService);
+        _define_property(this, "_search$", new import_rxjs2.Subject());
+        _define_property(this, "_help$", new import_rxjs2.Subject());
+        _define_property(this, "_navigate$", new import_rxjs2.Subject());
+        _define_property(this, "_accept$", new import_rxjs2.Subject());
+        _define_property(this, "_acceptFormulaName$", new import_rxjs2.Subject());
+        _define_property(this, "search$", this._search$.asObservable());
+        _define_property(this, "help$", this._help$.asObservable());
+        _define_property(this, "navigate$", this._navigate$.asObservable());
+        _define_property(this, "accept$", this._accept$.asObservable());
+        _define_property(this, "acceptFormulaName$", this._acceptFormulaName$.asObservable());
+        _define_property(this, "_searching", false);
+        _define_property(this, "_helping", false);
+        _define_property(this, "_isInsertRefString", false);
+    }
+    _create_class(FormulaPromptService, [
+        {
+            key: "dispose",
+            value: function dispose() {
+                this._search$.complete();
+                this._help$.complete();
+                this._navigate$.complete();
+                this._accept$.complete();
+                this._acceptFormulaName$.complete();
+            }
+        },
+        {
+            key: "search",
+            value: function search(param) {
+                this._searching = param.visible;
+                this._search$.next(param);
+            }
+        },
+        {
+            key: "isSearching",
+            value: function isSearching() {
+                return this._searching;
+            }
+        },
+        {
+            key: "help",
+            value: function help(param) {
+                this._helping = param.visible;
+                this._help$.next(param);
+            }
+        },
+        {
+            key: "isHelping",
+            value: function isHelping() {
+                return this._helping;
+            }
+        },
+        {
+            key: "navigate",
+            value: function navigate(param) {
+                this._navigate$.next(param);
+            }
+        },
+        {
+            key: "accept",
+            value: function accept(param) {
+                this._accept$.next(param);
+            }
+        },
+        {
+            key: "acceptFormulaName",
+            value: function acceptFormulaName(param) {
+                this._acceptFormulaName$.next(param);
+            }
+        }
+    ]);
+    return FormulaPromptService;
+}();
+// src/commands/operations/help-function.operation.ts
+var HelpFunctionOperation = {
+    id: "formula-ui.operation.help-function",
+    type: import_core6.CommandType.OPERATION,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor, params) {
+            var promptService;
+            return _ts_generator(this, function(_state) {
+                promptService = accessor.get(IFormulaPromptService);
+                promptService.help(params);
+                return [
+                    2,
+                    true
+                ];
+            });
+        });
+        return function(accessor, params) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/commands/operations/insert-function.operation.ts
+var import_core7 = require("@univerjs/core");
+var import_sheets2 = require("@univerjs/sheets");
+var InsertFunctionOperation = {
+    id: "formula-ui.operation.insert-function",
+    type: import_core7.CommandType.OPERATION,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor, params) {
+            var selectionManagerService, formulaInputService, currentSelections, univerInstanceService, cellMatrix, value, commandService, list;
+            return _ts_generator(this, function(_state) {
+                selectionManagerService = accessor.get(import_sheets2.SelectionManagerService);
+                formulaInputService = accessor.get(IFormulaInputService);
+                currentSelections = selectionManagerService.getSelections();
+                if (!currentSelections || !currentSelections.length) {
+                    return [
+                        2,
+                        false
+                    ];
+                }
+                univerInstanceService = accessor.get(import_core7.IUniverInstanceService);
+                cellMatrix = univerInstanceService.getCurrentUniverSheetInstance().getActiveSheet().getCellMatrix();
+                value = params.value;
+                commandService = accessor.get(import_core7.ICommandService);
+                list = [];
+                currentSelections.some(function(selection) {
+                    var range = selection.range, primary = selection.primary;
+                    var _primary_actualRow;
+                    var row = (_primary_actualRow = primary === null || primary === void 0 ? void 0 : primary.actualRow) !== null && _primary_actualRow !== void 0 ? _primary_actualRow : range.startRow;
+                    var _primary_actualColumn;
+                    var column = (_primary_actualColumn = primary === null || primary === void 0 ? void 0 : primary.actualColumn) !== null && _primary_actualColumn !== void 0 ? _primary_actualColumn : range.startColumn;
+                    var refRange = findRefRange(cellMatrix, row, column);
+                    if (!refRange) {
+                        formulaInputService.inputFormula("=".concat(value, "("));
+                        return true;
+                    }
+                    var rangeString = (0, import_core7.serializeRange)(refRange);
+                    var formulaString = "=".concat(value, "(").concat(rangeString, ")");
+                    list.push({
+                        range: range,
+                        primary: {
+                            row: row,
+                            column: column
+                        },
+                        formula: formulaString
+                    });
+                    return false;
+                });
+                if (list.length === 0) return [
+                    2,
+                    false
+                ];
+                return [
+                    2,
+                    commandService.executeCommand(InsertFunctionCommand.id, {
+                        list: list
+                    })
+                ];
+            });
+        });
+        return function(accessor, params) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+function findRefRange(cellMatrix, row, column) {
+    var startRow = findStartRow(cellMatrix, row, column);
+    if (startRow !== row) {
+        return {
+            startRow: startRow,
+            endRow: row - 1,
+            startColumn: column,
+            endColumn: column
+        };
+    }
+    var startColumn = findStartColumn(cellMatrix, row, column);
+    if (startColumn !== column) {
+        return {
+            startRow: row,
+            endRow: row,
+            startColumn: startColumn,
+            endColumn: column - 1
+        };
+    }
+    return null;
+}
+function findStartRow(cellMatrix, row, column) {
+    var isFirstNumber = false;
+    if (row === 0) return row;
+    for(var r = row - 1; r >= 0; r--){
+        var cell = cellMatrix.getValue(r, column);
+        if (isNumberCell(cell) && !isFirstNumber) {
+            if (r === 0) return 0;
+            isFirstNumber = true;
+        } else if (isFirstNumber && !isNumberCell(cell)) {
+            return r + 1;
+        } else if (isFirstNumber && r === 0) {
+            return 0;
+        }
+    }
+    return row;
+}
+function findStartColumn(cellMatrix, row, column) {
+    var isFirstNumber = false;
+    if (column === 0) return column;
+    for(var c = column - 1; c >= 0; c--){
+        var cell = cellMatrix.getValue(row, c);
+        if (isNumberCell(cell) && !isFirstNumber) {
+            if (c === 0) return 0;
+            isFirstNumber = true;
+        } else if (isFirstNumber && !isNumberCell(cell)) {
+            return c + 1;
+        } else if (isFirstNumber && c === 0) {
+            return 0;
+        }
+    }
+    return column;
+}
+function isNumberCell(cell) {
+    return cell && (import_core7.Tools.isStringNumber(cell.v) || (0, import_core7.getCellValueType)(cell) === import_core7.CellValueType.NUMBER);
+}
+// src/commands/operations/more-functions.operation.ts
+var import_core8 = require("@univerjs/core");
+var import_ui2 = require("@univerjs/ui");
+// src/views/more-functions/interface.ts
+var MORE_FUNCTIONS_COMPONENT = "".concat(FORMULA_UI_PLUGIN_NAME, "_MORE_FUNCTIONS_COMPONENT");
+// src/commands/operations/more-functions.operation.ts
+var MoreFunctionsOperation = {
+    id: "formula-ui.operation.more-functions",
+    type: import_core8.CommandType.OPERATION,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor) {
+            var sidebarService;
+            return _ts_generator(this, function(_state) {
+                sidebarService = accessor.get(import_ui2.ISidebarService);
+                sidebarService.open({
+                    header: {
+                        title: "formula.insert.tooltip"
+                    },
+                    children: {
+                        label: MORE_FUNCTIONS_COMPONENT
+                    }
+                });
+                return [
+                    2,
+                    true
+                ];
+            });
+        });
+        return function(accessor) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/commands/operations/search-function.operation.ts
+var import_core9 = require("@univerjs/core");
+var SearchFunctionOperation = {
+    id: "formula-ui.operation.search-function",
+    type: import_core9.CommandType.OPERATION,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor, params) {
+            var promptService;
+            return _ts_generator(this, function(_state) {
+                promptService = accessor.get(IFormulaPromptService);
+                promptService.search(params);
+                return [
+                    2,
+                    true
+                ];
+            });
+        });
+        return function(accessor, params) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/views/FormulaPromptContainer.tsx
+var import_react4 = __toESM(require("react"));
+// src/views/prompt/error-function/error-function.tsx
+var import_sheets_ui3 = require("@univerjs/sheets-ui");
+var import_react_bindings = require("@wendellhu/redi/react-bindings");
+var import_react = __toESM(require("react"));
+// stylePlugin:/Users/jikkaixiao/dev/univer/packages/sheets-formula/src/views/prompt/error-function/index.module.less
+var index_module_default = {
+    "formulaErrorFunction": "univer-formula-error-function"
+};
+// src/views/prompt/error-function/error-function.tsx
+function ErrorFunction() {
+    var _ref = _sliced_to_array((0, import_react.useState)(false), 2), visible = _ref[0], setVisible = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react.useState)({
+        left: 0,
+        top: 0
+    }), 2), position = _ref1[0], setPosition = _ref1[1];
+    var promptService = (0, import_react_bindings.useDependency)(IFormulaPromptService);
+    var cellEditorManagerService = (0, import_react_bindings.useDependency)(import_sheets_ui3.ICellEditorManagerService);
+    (0, import_react.useEffect)(function() {
+        var subscription = promptService.help$.subscribe(function(params) {
+            var selection = cellEditorManagerService.getState();
+            if (!selection) return;
+            var visible2 = params.visible;
+            if (!visible2) {
+                setVisible(visible2);
+                return;
+            }
+            var _selection_endX = selection.endX, endX = _selection_endX === void 0 ? 0 : _selection_endX, _selection_startY = selection.startY, startY = _selection_startY === void 0 ? 0 : _selection_startY;
+            setPosition({
+                left: endX,
+                top: startY
+            });
+            setVisible(visible2);
+        });
+        return function() {
+            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+        };
+    }, []);
+    return visible ? /* @__PURE__ */ import_react.default.createElement("div", {
+        className: index_module_default.formulaErrorFunction,
+        style: {
+            left: position.left,
+            top: position.top
+        }
+    }) : null;
+}
+// src/views/prompt/help-function/HelpFunction.tsx
+var import_core10 = require("@univerjs/core");
+var import_design = require("@univerjs/design");
+var import_icons = require("@univerjs/icons");
+var import_sheets_ui4 = require("@univerjs/sheets-ui");
+var import_react_bindings2 = require("@wendellhu/redi/react-bindings");
+var import_react2 = __toESM(require("react"));
+// stylePlugin:/Users/jikkaixiao/dev/univer/packages/sheets-formula/src/views/prompt/help-function/index.module.less
+var index_module_default2 = {
+    "formulaHelpFunction": "univer-formula-help-function",
+    "formulaHelpFunctionTitle": "univer-formula-help-function-title",
+    "formulaHelpFunctionTitleIcons": "univer-formula-help-function-title-icons",
+    "formulaHelpFunctionTitleIcon": "univer-formula-help-function-title-icon",
+    "formulaHelpFunctionContent": "univer-formula-help-function-content",
+    "formulaHelpFunctionContentInner": "univer-formula-help-function-content-inner",
+    "formulaHelpFunctionContentParams": "univer-formula-help-function-content-params",
+    "formulaHelpFunctionContentParamsTitle": "univer-formula-help-function-content-params-title",
+    "formulaHelpFunctionContentParamsDetail": "univer-formula-help-function-content-params-detail",
+    "formulaHelpFunctionActive": "univer-formula-help-function-active",
+    "formulaHelpDecorator": "univer-formula-help-decorator"
+};
+// src/views/prompt/help-function/HelpFunction.tsx
+function HelpFunction() {
+    var _ref = _sliced_to_array((0, import_react2.useState)(false), 2), visible = _ref[0], setVisible = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react2.useState)(true), 2), contentVisible = _ref1[0], setContentVisible = _ref1[1];
+    var _ref2 = _sliced_to_array((0, import_react2.useState)(true), 2), helpVisible = _ref2[0], setHelpVisible = _ref2[1];
+    var _ref3 = _sliced_to_array((0, import_react2.useState)(0), 2), paramIndex = _ref3[0], setParamIndex = _ref3[1];
+    var _ref4 = _sliced_to_array((0, import_react2.useState)([
+        0,
+        0
+    ]), 2), offset = _ref4[0], setOffset = _ref4[1];
+    var _ref5 = _sliced_to_array((0, import_react2.useState)({
+        left: 0,
+        top: 0
+    }), 2), decoratorPosition = _ref5[0], setDecoratorPosition = _ref5[1];
+    var _ref6 = _sliced_to_array((0, import_react2.useState)(null), 2), functionInfo = _ref6[0], setFunctionInfo = _ref6[1];
+    var promptService = (0, import_react_bindings2.useDependency)(IFormulaPromptService);
+    var cellEditorManagerService = (0, import_react_bindings2.useDependency)(import_sheets_ui4.ICellEditorManagerService);
+    var localeService = (0, import_react_bindings2.useDependency)(import_core10.LocaleService);
+    var formulaEditorManagerService = (0, import_react_bindings2.useDependency)(import_sheets_ui4.IFormulaEditorManagerService);
+    var contextService = (0, import_react_bindings2.useDependency)(import_core10.IContextService);
+    var required = localeService.t("formula.prompt.required");
+    var optional = localeService.t("formula.prompt.optional");
+    (0, import_react2.useEffect)(function() {
+        var subscription = promptService.help$.subscribe(function(params) {
+            var visible2 = params.visible, paramIndex2 = params.paramIndex, functionInfo2 = params.functionInfo;
+            if (!visible2) {
+                setVisible(visible2);
+                return;
+            }
+            var isFocusFormulaEditor = contextService.getContextValue(import_core10.FOCUSING_FORMULA_EDITOR);
+            var position = isFocusFormulaEditor ? formulaEditorManagerService.getPosition() : cellEditorManagerService.getRect();
+            if (position == null) {
+                return;
+            }
+            var left = position.left, top = position.top, height = position.height;
+            var localeInfo = {
+                functionName: functionInfo2.functionName,
+                functionType: functionInfo2.functionType,
+                description: localeService.t(functionInfo2.description),
+                abstract: localeService.t(functionInfo2.abstract),
+                functionParameter: functionInfo2.functionParameter.map(function(item) {
+                    return {
+                        name: localeService.t(item.name),
+                        detail: localeService.t(item.detail),
+                        example: item.example,
+                        require: item.require,
+                        repeat: item.repeat
+                    };
+                })
+            };
+            setOffset([
+                left,
+                top + height
+            ]);
+            setParamIndex(paramIndex2);
+            setFunctionInfo(localeInfo);
+            setDecoratorPosition({
+                left: left,
+                top: top
+            });
+            setVisible(visible2);
+        });
+        return function() {
+            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+        };
+    }, []);
+    function handleSwitchActive(paramIndex2) {
+        setParamIndex(paramIndex2);
+    }
+    return /* @__PURE__ */ import_react2.default.createElement(import_react2.default.Fragment, null, helpVisible ? /* @__PURE__ */ import_react2.default.createElement(import_design.Popup, {
+        visible: visible,
+        offset: offset
+    }, functionInfo ? /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunction
+    }, /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionTitle
+    }, /* @__PURE__ */ import_react2.default.createElement(Help, {
+        prefix: functionInfo.functionName,
+        value: functionInfo.functionParameter,
+        active: paramIndex,
+        onClick: handleSwitchActive
+    }), /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionTitleIcons
+    }, /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionTitleIcon,
+        style: {
+            transform: contentVisible ? "rotateZ(-90deg)" : "rotateZ(90deg)"
+        },
+        onClick: function() {
+            return setContentVisible(!contentVisible);
+        }
+    }, /* @__PURE__ */ import_react2.default.createElement(import_icons.MoreSingle, null)), /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionTitleIcon,
+        onClick: function() {
+            return setHelpVisible(!helpVisible);
+        }
+    }, /* @__PURE__ */ import_react2.default.createElement(import_icons.CloseSingle, null)))), /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionContent,
+        style: {
+            height: contentVisible ? "unset" : 0
+        }
+    }, /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionContentInner
+    }, /* @__PURE__ */ import_react2.default.createElement(Params, {
+        title: localeService.t("formula.prompt.helpExample"),
+        value: "".concat(functionInfo.functionName, "(").concat(functionInfo.functionParameter.map(function(item) {
+            return item.example;
+        }).join(","), ")")
+    }), /* @__PURE__ */ import_react2.default.createElement(Params, {
+        title: localeService.t("formula.prompt.helpAbstract"),
+        value: functionInfo.description
+    }), functionInfo && functionInfo.functionParameter && functionInfo.functionParameter.map(function(item, i) {
+        return /* @__PURE__ */ import_react2.default.createElement(Params, {
+            key: i,
+            className: paramIndex === i ? index_module_default2.formulaHelpFunctionActive : "",
+            title: item.name,
+            value: "".concat(item.require ? required : optional, " ").concat(item.detail)
+        });
+    })))) : /* @__PURE__ */ import_react2.default.createElement(import_react2.default.Fragment, null)) : visible ? /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpDecorator,
+        onClick: function() {
+            return setHelpVisible(!helpVisible);
+        },
+        style: {
+            left: decoratorPosition.left - 24,
+            top: decoratorPosition.top
+        }
+    }, /* @__PURE__ */ import_react2.default.createElement(import_icons.DetailsSingle, null)) : /* @__PURE__ */ import_react2.default.createElement(import_react2.default.Fragment, null));
+}
+var Params = function(props) {
+    return /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionContentParams
+    }, /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: "".concat(index_module_default2.formulaHelpFunctionContentParamsTitle, " ").concat(props.className)
+    }, props.title), /* @__PURE__ */ import_react2.default.createElement("div", {
+        className: index_module_default2.formulaHelpFunctionContentParamsDetail
+    }, props.value));
+};
+var Help = function(props) {
+    var prefix = props.prefix, value = props.value, active = props.active, onClick = props.onClick;
+    return /* @__PURE__ */ import_react2.default.createElement("div", null, /* @__PURE__ */ import_react2.default.createElement("span", null, prefix, "("), value && value.map(function(item, i) {
+        return(// TODO@Dushusir: more params needs to be active
+        /* @__PURE__ */ import_react2.default.createElement("span", {
+            key: i
+        }, /* @__PURE__ */ import_react2.default.createElement("span", {
+            className: active === i ? index_module_default2.formulaHelpFunctionActive : "",
+            onClick: function() {
+                return onClick(i);
+            }
+        }, item.repeat ? "[".concat(item.name, ",...]") : item.name), i === value.length - 1 ? "" : ","));
+    }), ")");
+};
+// src/views/prompt/search-function/SearchFunction.tsx
+var import_core11 = require("@univerjs/core");
+var import_design2 = require("@univerjs/design");
+var import_sheets_ui5 = require("@univerjs/sheets-ui");
+var import_react_bindings3 = require("@wendellhu/redi/react-bindings");
+var import_react3 = __toESM(require("react"));
+// stylePlugin:/Users/jikkaixiao/dev/univer/packages/sheets-formula/src/views/prompt/search-function/index.module.less
+var index_module_default3 = {
+    "formulaSearchFunction": "univer-formula-search-function",
+    "formulaSearchFunctionItem": "univer-formula-search-function-item",
+    "formulaSearchFunctionItemName": "univer-formula-search-function-item-name",
+    "formulaSearchFunctionItemNameLight": "univer-formula-search-function-item-name-light",
+    "formulaSearchFunctionItemDesc": "univer-formula-search-function-item-desc",
+    "formulaSearchFunctionItemActive": "univer-formula-search-function-item-active"
+};
+// src/views/prompt/search-function/SearchFunction.tsx
+function SearchFunction() {
+    var _ref = _sliced_to_array((0, import_react3.useState)(false), 2), visible = _ref[0], setVisible = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react3.useState)(0), 2), active = _ref1[0], setActive = _ref1[1];
+    var _ref2 = _sliced_to_array((0, import_react3.useState)([
+        0,
+        0
+    ]), 2), offset = _ref2[0], setOffset = _ref2[1];
+    var _ref3 = _sliced_to_array((0, import_react3.useState)([]), 2), searchList = _ref3[0], setSearchList = _ref3[1];
+    var _ref4 = _sliced_to_array((0, import_react3.useState)(""), 2), searchText = _ref4[0], setSearchText = _ref4[1];
+    var promptService = (0, import_react_bindings3.useDependency)(IFormulaPromptService);
+    var cellEditorManagerService = (0, import_react_bindings3.useDependency)(import_sheets_ui5.ICellEditorManagerService);
+    var formulaEditorManagerService = (0, import_react_bindings3.useDependency)(import_sheets_ui5.IFormulaEditorManagerService);
+    var contextService = (0, import_react_bindings3.useDependency)(import_core11.IContextService);
+    (0, import_react3.useEffect)(function() {
+        var updatedSearchList = [];
+        var updatedActive = 0;
+        var subscribeSearch = promptService.search$.subscribe(function(params) {
+            var visible2 = params.visible, searchText2 = params.searchText, searchList2 = params.searchList;
+            if (!visible2) {
+                setVisible(visible2);
+                return;
+            }
+            var isFocusFormulaEditor = contextService.getContextValue(import_core11.FOCUSING_FORMULA_EDITOR);
+            var position = isFocusFormulaEditor ? formulaEditorManagerService.getPosition() : cellEditorManagerService.getRect();
+            if (position == null) {
+                return;
+            }
+            var left = position.left, top = position.top, height = position.height;
+            setSearchText(searchText2);
+            setSearchList(searchList2);
+            updatedSearchList = searchList2;
+            setOffset([
+                left,
+                top + height
+            ]);
+            setVisible(visible2);
+            setActive(0);
+        });
+        var subscribeNavigate = promptService.navigate$.subscribe(function(params) {
+            var direction = params.direction;
+            if (direction === import_core11.Direction.UP) {
+                var nextActive = updatedActive - 1;
+                nextActive = nextActive < 0 ? updatedSearchList.length - 1 : nextActive;
+                setActive(nextActive);
+                updatedActive = nextActive;
+            } else if (direction === import_core11.Direction.DOWN) {
+                var nextActive1 = updatedActive + 1;
+                nextActive1 = nextActive1 >= updatedSearchList.length ? 0 : nextActive1;
+                setActive(nextActive1);
+                updatedActive = nextActive1;
+            }
+        });
+        var subscribeAccept = promptService.accept$.subscribe(function(params) {
+            var functionName = updatedSearchList[updatedActive].name;
+            promptService.acceptFormulaName(functionName);
+        });
+        return function() {
+            subscribeSearch === null || subscribeSearch === void 0 ? void 0 : subscribeSearch.unsubscribe();
+            subscribeNavigate === null || subscribeNavigate === void 0 ? void 0 : subscribeNavigate.unsubscribe();
+            subscribeAccept === null || subscribeAccept === void 0 ? void 0 : subscribeAccept.unsubscribe();
+        };
+    }, []);
+    function handleLiMouseEnter(index) {
+        setActive(index);
+    }
+    function handleLiMouseLeave() {
+        setActive(-1);
+    }
+    return /* @__PURE__ */ import_react3.default.createElement(import_design2.Popup, {
+        visible: visible,
+        offset: offset
+    }, /* @__PURE__ */ import_react3.default.createElement("ul", {
+        className: index_module_default3.formulaSearchFunction
+    }, searchList.map(function(item, index) {
+        return /* @__PURE__ */ import_react3.default.createElement("li", {
+            key: index,
+            className: active === index ? "".concat(index_module_default3.formulaSearchFunctionItem, " ").concat(index_module_default3.formulaSearchFunctionItemActive) : index_module_default3.formulaSearchFunctionItem,
+            onMouseEnter: function() {
+                return handleLiMouseEnter(index);
+            },
+            onMouseLeave: handleLiMouseLeave,
+            onClick: function() {
+                return promptService.acceptFormulaName(item.name);
+            }
+        }, /* @__PURE__ */ import_react3.default.createElement("span", {
+            className: index_module_default3.formulaSearchFunctionItemName
+        }, /* @__PURE__ */ import_react3.default.createElement("span", {
+            className: index_module_default3.formulaSearchFunctionItemNameLight
+        }, searchText), /* @__PURE__ */ import_react3.default.createElement("span", null, item.name.slice(searchText.length))), /* @__PURE__ */ import_react3.default.createElement("span", {
+            className: index_module_default3.formulaSearchFunctionItemDesc
+        }, item.desc));
+    })));
+}
+// src/views/FormulaPromptContainer.tsx
+function RenderFormulaPromptContent() {
+    return /* @__PURE__ */ import_react4.default.createElement(import_react4.default.Fragment, null, /* @__PURE__ */ import_react4.default.createElement(SearchFunction, null), /* @__PURE__ */ import_react4.default.createElement(HelpFunction, null), /* @__PURE__ */ import_react4.default.createElement(ErrorFunction, null));
+}
+// src/views/more-functions/MoreFunctions.tsx
+var import_core14 = require("@univerjs/core");
+var import_design4 = require("@univerjs/design");
+var import_ui3 = require("@univerjs/ui");
+var import_react_bindings5 = require("@wendellhu/redi/react-bindings");
+var import_react9 = __toESM(require("react"));
+// stylePlugin:/Users/jikkaixiao/dev/univer/packages/sheets-formula/src/views/more-functions/index.module.less
+var index_module_default4 = {
+    "formulaMoreFunctions": "univer-formula-more-functions",
+    "formulaMoreFunctionsOperation": "univer-formula-more-functions-operation"
+};
+// src/views/more-functions/input-params/InputParams.tsx
+var import_sheets_ui6 = require("@univerjs/sheets-ui");
+var import_react7 = __toESM(require("react"));
+// src/views/more-functions/function-help/FunctionHelp.tsx
+var import_react5 = __toESM(require("react"));
+function FunctionHelp(props) {
+    var prefix = props.prefix, value = props.value;
+    return /* @__PURE__ */ import_react5.default.createElement("div", null, /* @__PURE__ */ import_react5.default.createElement("span", null, prefix, "("), value && value.map(function(item, i) {
+        return /* @__PURE__ */ import_react5.default.createElement("span", {
+            key: i
+        }, /* @__PURE__ */ import_react5.default.createElement("span", null, item.repeat ? "[".concat(item.name, ",...]") : item.name), i === value.length - 1 ? "" : ",");
+    }), ")");
+}
+// src/views/more-functions/function-params/FunctionParams.tsx
+var import_react6 = __toESM(require("react"));
+// stylePlugin:/Users/jikkaixiao/dev/univer/packages/sheets-formula/src/views/more-functions/function-params/index.module.less
+var index_module_default5 = {
+    "formulaFunctionParams": "univer-formula-function-params",
+    "formulaFunctionParamsTitle": "univer-formula-function-params-title",
+    "formulaFunctionParamsDetail": "univer-formula-function-params-detail"
+};
+// src/views/more-functions/function-params/FunctionParams.tsx
+function FunctionParams(props) {
+    var className = props.className, value = props.value, title = props.title;
+    return /* @__PURE__ */ import_react6.default.createElement("div", {
+        className: index_module_default5.formulaFunctionParams
+    }, /* @__PURE__ */ import_react6.default.createElement("div", {
+        className: "".concat(index_module_default5.formulaFunctionParamsTitle, " ").concat(className)
+    }, title), /* @__PURE__ */ import_react6.default.createElement("div", {
+        className: index_module_default5.formulaFunctionParamsDetail
+    }, value));
+}
+// stylePlugin:/Users/jikkaixiao/dev/univer/packages/sheets-formula/src/views/more-functions/input-params/index.module.less
+var index_module_default6 = {
+    "formulaInputParamsList": "univer-formula-input-params-list",
+    "formulaInputParamsListItemName": "univer-formula-input-params-list-item-name",
+    "formulaInputParamsListItemSelector": "univer-formula-input-params-list-item-selector"
+};
+// src/views/more-functions/input-params/InputParams.tsx
+function InputParams(props) {
+    var functionInfo = props.functionInfo, onChange = props.onChange;
+    if (!functionInfo) return null;
+    var _ref = _sliced_to_array((0, import_react7.useState)([]), 2), params = _ref[0], setParams = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react7.useState)(functionInfo.functionParameter), 2), functionParameter = _ref1[0], setFunctionParameter = _ref1[1];
+    var _ref2 = _sliced_to_array((0, import_react7.useState)(-1), 2), activeIndex = _ref2[0], setActiveIndex = _ref2[1];
+    function handleChange(range, paramIndex) {
+        var newParams = _to_consumable_array(params);
+        newParams[paramIndex] = range;
+        setParams(newParams);
+        onChange(newParams);
+    }
+    function handleActive(i) {
+        if (i === functionParameter.length - 1 && functionParameter[i].repeat) {
+            var newFunctionParameter = _to_consumable_array(functionParameter);
+            newFunctionParameter.push(functionParameter[i]);
+            setFunctionParameter(newFunctionParameter);
+        }
+        setActiveIndex(i);
+    }
+    return /* @__PURE__ */ import_react7.default.createElement("div", {
+        className: index_module_default6.formulaInputParams
+    }, /* @__PURE__ */ import_react7.default.createElement("div", {
+        className: index_module_default6.formulaInputParamsList
+    }, functionParameter.map(function(item, i) {
+        return /* @__PURE__ */ import_react7.default.createElement("div", {
+            key: i
+        }, /* @__PURE__ */ import_react7.default.createElement("div", {
+            className: index_module_default6.formulaInputParamsListItemName
+        }, item.name), /* @__PURE__ */ import_react7.default.createElement("div", {
+            className: index_module_default6.formulaInputParamsListItemSelector
+        }, /* @__PURE__ */ import_react7.default.createElement(import_sheets_ui6.RangeSelector, {
+            onChange: function(range) {
+                return handleChange(range, i);
+            },
+            onActive: function() {
+                return handleActive(i);
+            }
+        })));
+    })), /* @__PURE__ */ import_react7.default.createElement("div", {
+        className: index_module_default6.formulaInputParamsInfo
+    }, /* @__PURE__ */ import_react7.default.createElement(FunctionParams, {
+        title: activeIndex === -1 ? /* @__PURE__ */ import_react7.default.createElement(FunctionHelp, {
+            prefix: functionInfo.functionName,
+            value: functionParameter
+        }) : functionParameter[activeIndex].name,
+        value: activeIndex === -1 ? functionInfo.description : functionParameter[activeIndex].detail
+    })));
+}
+// src/views/more-functions/select-function/SelectFunction.tsx
+var import_core13 = require("@univerjs/core");
+var import_design3 = require("@univerjs/design");
+var import_engine_formula7 = require("@univerjs/engine-formula");
+var import_icons2 = require("@univerjs/icons");
+var import_react_bindings4 = require("@wendellhu/redi/react-bindings");
+var import_react8 = __toESM(require("react"));
+// src/services/description.service.ts
+var import_core12 = require("@univerjs/core");
+var import_engine_formula6 = require("@univerjs/engine-formula");
+var import_redi5 = require("@wendellhu/redi");
+// src/services/function-list/array.ts
+var FUNCTION_LIST_ARRAY = [];
+// src/services/function-list/compatibility.ts
+var FUNCTION_LIST_COMPATIBILITY = [];
+// src/services/function-list/cube.ts
+var FUNCTION_LIST_CUBE = [];
+// src/services/function-list/database.ts
+var FUNCTION_LIST_DATABASE = [];
+// src/services/function-list/date.ts
+var FUNCTION_LIST_DATE = [];
+// src/services/function-list/engineering.ts
+var FUNCTION_LIST_ENGINEERING = [];
+// src/services/function-list/financial.ts
+var FUNCTION_LIST_FINANCIAL = [];
+// src/services/function-list/information.ts
+var FUNCTION_LIST_INFORMATION = [];
+// src/services/function-list/logical.ts
+var FUNCTION_LIST_LOGICAL = [];
+// src/services/function-list/lookup.ts
+var FUNCTION_LIST_LOOKUP = [];
+// src/services/function-list/math.ts
+var import_engine_formula4 = require("@univerjs/engine-formula");
+var import_formula = require("@univerjs/formula");
+var FUNCTION_LIST_MATH = [
+    {
+        functionName: import_engine_formula4.FUNCTION_NAMES.SUM,
+        aliasFunctionName: "formula.functionList.SUM.aliasFunctionName",
+        functionType: import_engine_formula4.FunctionType.Math,
+        description: "formula.functionList.SUM.description",
+        abstract: "formula.functionList.SUM.abstract",
+        functionParameter: [
+            {
+                name: "formula.functionList.SUM.functionParameter.number1.name",
+                detail: "formula.functionList.SUM.functionParameter.number1.detail",
+                example: "A1:A20",
+                require: 1,
+                repeat: 0
+            },
+            {
+                name: "formula.functionList.SUM.functionParameter.number2.name",
+                detail: "formula.functionList.SUM.functionParameter.number2.detail",
+                example: "B2:B10",
+                require: 0,
+                repeat: 1
+            }
+        ]
+    },
+    {
+        functionName: import_formula.FUNCTION_NAMES_MATH.SUMIF,
+        aliasFunctionName: "formula.functionList.SUMIF.aliasFunctionName",
+        functionType: import_engine_formula4.FunctionType.Math,
+        description: "formula.functionList.SUMIF.description",
+        abstract: "formula.functionList.SUMIF.abstract",
+        functionParameter: [
+            {
+                name: "formula.functionList.SUMIF.functionParameter.range.name",
+                detail: "formula.functionList.SUMIF.functionParameter.range.detail",
+                example: "A1:A20",
+                require: 1,
+                repeat: 0
+            },
+            {
+                name: "formula.functionList.SUMIF.functionParameter.criteria.name",
+                detail: "formula.functionList.SUMIF.functionParameter.criteria.detail",
+                example: ">5",
+                require: 1,
+                repeat: 0
+            },
+            {
+                name: "formula.functionList.SUMIF.functionParameter.sum_range.name",
+                detail: "formula.functionList.SUMIF.functionParameter.sum_range.detail",
+                example: "B1:B20",
+                require: 0,
+                repeat: 0
+            }
+        ]
+    }
+];
+// src/services/function-list/statistical.ts
+var import_engine_formula5 = require("@univerjs/engine-formula");
+var FUNCTION_LIST_STATISTICAL = [
+    {
+        functionName: import_engine_formula5.FUNCTION_NAMES.AVERAGE,
+        aliasFunctionName: "formula.functionList.AVERAGE.aliasFunctionName",
+        functionType: import_engine_formula5.FunctionType.Statistical,
+        description: "formula.functionList.AVERAGE.description",
+        abstract: "formula.functionList.AVERAGE.abstract",
+        functionParameter: [
+            {
+                name: "formula.functionList.AVERAGE.functionParameter.number1.name",
+                detail: "formula.functionList.AVERAGE.functionParameter.number1.detail",
+                example: "A1:A20",
+                require: 1,
+                repeat: 0
+            },
+            {
+                name: "formula.functionList.AVERAGE.functionParameter.number2.name",
+                detail: "formula.functionList.AVERAGE.functionParameter.number2.detail",
+                example: "B2:B10",
+                require: 0,
+                repeat: 1
+            }
+        ]
+    },
+    {
+        functionName: import_engine_formula5.FUNCTION_NAMES.MAX,
+        aliasFunctionName: "formula.functionList.MAX.aliasFunctionName",
+        functionType: import_engine_formula5.FunctionType.Statistical,
+        description: "formula.functionList.MAX.description",
+        abstract: "formula.functionList.MAX.abstract",
+        functionParameter: [
+            {
+                name: "formula.functionList.MAX.functionParameter.number1.name",
+                detail: "formula.functionList.MAX.functionParameter.number1.detail",
+                example: "A1:A20",
+                require: 1,
+                repeat: 0
+            },
+            {
+                name: "formula.functionList.MAX.functionParameter.number2.name",
+                detail: "formula.functionList.MAX.functionParameter.number2.detail",
+                example: "B2:B10",
+                require: 0,
+                repeat: 1
+            }
+        ]
+    },
+    {
+        functionName: import_engine_formula5.FUNCTION_NAMES.COUNT,
+        aliasFunctionName: "formula.functionList.COUNT.aliasFunctionName",
+        functionType: import_engine_formula5.FunctionType.Statistical,
+        description: "formula.functionList.COUNT.description",
+        abstract: "formula.functionList.COUNT.abstract",
+        functionParameter: [
+            {
+                name: "formula.functionList.COUNT.functionParameter.value1.name",
+                detail: "formula.functionList.COUNT.functionParameter.value1.detail",
+                example: "A1:A20",
+                require: 1,
+                repeat: 0
+            },
+            {
+                name: "formula.functionList.COUNT.functionParameter.value2.name",
+                detail: "formula.functionList.COUNT.functionParameter.value2.detail",
+                example: "B2:B10",
+                require: 0,
+                repeat: 1
+            }
+        ]
+    },
+    {
+        functionName: import_engine_formula5.FUNCTION_NAMES.MIN,
+        aliasFunctionName: "formula.functionList.MIN.aliasFunctionName",
+        functionType: import_engine_formula5.FunctionType.Statistical,
+        description: "formula.functionList.MIN.description",
+        abstract: "formula.functionList.MIN.abstract",
+        functionParameter: [
+            {
+                name: "formula.functionList.MIN.functionParameter.number1.name",
+                detail: "formula.functionList.MIN.functionParameter.number1.detail",
+                example: "A1:A20",
+                require: 1,
+                repeat: 0
+            },
+            {
+                name: "formula.functionList.MIN.functionParameter.number2.name",
+                detail: "formula.functionList.MIN.functionParameter.number2.detail",
+                example: "B2:B10",
+                require: 0,
+                repeat: 1
+            }
+        ]
+    }
+];
+// src/services/function-list/text.ts
+var FUNCTION_LIST_TEXT = [];
+// src/services/function-list/univer.ts
+var FUNCTION_LIST_UNIVER = [];
+// src/services/function-list/web.ts
+var FUNCTION_LIST_WEB = [];
+// src/services/function-list/function-list.ts
+var FUNCTION_LIST = _to_consumable_array(FUNCTION_LIST_FINANCIAL).concat(_to_consumable_array(FUNCTION_LIST_DATE), _to_consumable_array(FUNCTION_LIST_MATH), _to_consumable_array(FUNCTION_LIST_STATISTICAL), _to_consumable_array(FUNCTION_LIST_LOOKUP), _to_consumable_array(FUNCTION_LIST_DATABASE), _to_consumable_array(FUNCTION_LIST_TEXT), _to_consumable_array(FUNCTION_LIST_LOGICAL), _to_consumable_array(FUNCTION_LIST_INFORMATION), _to_consumable_array(FUNCTION_LIST_ENGINEERING), _to_consumable_array(FUNCTION_LIST_CUBE), _to_consumable_array(FUNCTION_LIST_COMPATIBILITY), _to_consumable_array(FUNCTION_LIST_WEB), _to_consumable_array(FUNCTION_LIST_ARRAY), _to_consumable_array(FUNCTION_LIST_UNIVER));
+// src/services/utils.ts
+function getFunctionTypeValues(enumObj, localeService) {
+    return Object.keys(enumObj).filter(function(key) {
+        return isNaN(Number(key));
+    }).map(function(key) {
+        return {
+            label: localeService.t("formula.functionType.".concat(key.toLocaleLowerCase())),
+            value: "".concat(enumObj[key])
+        };
+    });
+}
+function getFunctionName(item, localeService) {
+    var functionName = "";
+    if (item.aliasFunctionName) {
+        functionName = localeService.t(item.aliasFunctionName);
+        if (functionName === item.aliasFunctionName) {
+            functionName = item.functionName;
+        }
+    } else {
+        functionName = item.functionName;
+    }
+    return functionName;
+}
+// src/services/description.service.ts
+var IDescriptionService = (0, import_redi5.createIdentifier)("formula-ui.description-service");
+var DescriptionService = /*#__PURE__*/ function() {
+    function DescriptionService(_description, _formulaEngineService, _localeService) {
+        _class_call_check(this, DescriptionService);
+        this._description = _description;
+        this._formulaEngineService = _formulaEngineService;
+        this._localeService = _localeService;
+        this._initialize();
+        this._registerDescription();
+    }
+    _create_class(DescriptionService, [
+        {
+            key: "dispose",
+            value: function dispose() {
+                this._localeService.localeChanged$.complete();
+            }
+        },
+        {
+            key: "getDescriptions",
+            value: function getDescriptions() {
+                return this._formulaEngineService.getDescriptions();
+            }
+        },
+        {
+            key: "hasFunction",
+            value: function hasFunction(searchText) {
+                var functionList = this._formulaEngineService.getDescriptions();
+                return functionList.get(searchText.toLocaleUpperCase()) !== void 0;
+            }
+        },
+        {
+            key: "getFunctionInfo",
+            value: function getFunctionInfo(searchText) {
+                var functionList = this._formulaEngineService.getDescriptions();
+                return functionList.get(searchText.toLocaleUpperCase());
+            }
+        },
+        {
+            key: "getSearchListByName",
+            value: function getSearchListByName(searchText) {
+                var searchList = [];
+                var functionList = this._formulaEngineService.getDescriptions();
+                searchText = searchText.toLocaleUpperCase();
+                functionList.forEach(function(item) {
+                    var functionName = item.functionName, abstract = item.abstract;
+                    if (functionName.indexOf(searchText) > -1) {
+                        searchList.push({
+                            name: functionName,
+                            desc: abstract
+                        });
+                    }
+                });
+                return searchList;
+            }
+        },
+        {
+            key: "getSearchListByType",
+            value: function getSearchListByType(type) {
+                var searchList = [];
+                var functionList = this._formulaEngineService.getDescriptions();
+                functionList.forEach(function(item) {
+                    var functionName = item.functionName, functionType = item.functionType, abstract = item.abstract;
+                    if (functionType === type || type === -1) {
+                        searchList.push({
+                            name: functionName,
+                            desc: abstract
+                        });
+                    }
+                });
+                return searchList;
+            }
+        },
+        {
+            key: "_initialize",
+            value: function _initialize() {
+                var _this = this;
+                this._localeService.localeChanged$.subscribe(function() {
+                    _this._registerDescription();
+                });
+            }
+        },
+        {
+            key: "_registerDescription",
+            value: function _registerDescription() {
+                var _this__formulaEngineService;
+                var localeService = this._localeService;
+                var functionList = FUNCTION_LIST.concat(this._description || []);
+                var functionListLocale = functionList.map(function(functionInfo) {
+                    return {
+                        functionName: getFunctionName(functionInfo, localeService),
+                        functionType: functionInfo.functionType,
+                        description: localeService.t(functionInfo.description),
+                        abstract: localeService.t(functionInfo.abstract),
+                        functionParameter: functionInfo.functionParameter.map(function(item) {
+                            return {
+                                name: localeService.t(item.name),
+                                detail: localeService.t(item.detail),
+                                example: item.example,
+                                require: item.require,
+                                repeat: item.repeat
+                            };
+                        })
+                    };
+                });
+                (_this__formulaEngineService = this._formulaEngineService).registerDescription.apply(_this__formulaEngineService, _to_consumable_array(functionListLocale));
+            }
+        }
+    ]);
+    return DescriptionService;
+}();
+DescriptionService = __decorateClass([
+    __decorateParam(1, (0, import_redi5.Inject)(import_engine_formula6.FormulaEngineService)),
+    __decorateParam(2, (0, import_redi5.Inject)(import_core12.LocaleService))
+], DescriptionService);
+// stylePlugin:/Users/jikkaixiao/dev/univer/packages/sheets-formula/src/views/more-functions/select-function/index.module.less
+var index_module_default7 = {
+    "formulaSelectFunctionSelect": "univer-formula-select-function-select",
+    "formulaSelectFunctionResult": "univer-formula-select-function-result",
+    "formulaSelectFunctionResultItem": "univer-formula-select-function-result-item",
+    "formulaSelectFunctionResultItemNameLight": "univer-formula-select-function-result-item-name-light",
+    "formulaSelectFunctionResultItemSelected": "univer-formula-select-function-result-item-selected",
+    "formulaSelectFunctionResultItemActive": "univer-formula-select-function-result-item-active",
+    "formulaSelectFunctionContent": "univer-formula-select-function-content"
+};
+// src/views/more-functions/select-function/SelectFunction.tsx
+function SelectFunction(props) {
+    var onChange = props.onChange;
+    var allTypeValue = "-1";
+    var _ref = _sliced_to_array((0, import_react8.useState)(""), 2), searchText = _ref[0], setSearchText = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react8.useState)([]), 2), selectList = _ref1[0], setSelectList = _ref1[1];
+    var _ref2 = _sliced_to_array((0, import_react8.useState)(0), 2), active = _ref2[0], setActive = _ref2[1];
+    var _ref3 = _sliced_to_array((0, import_react8.useState)(allTypeValue), 2), typeSelected = _ref3[0], setTypeSelected = _ref3[1];
+    var _ref4 = _sliced_to_array((0, import_react8.useState)(0), 2), nameSelected = _ref4[0], setNameSelected = _ref4[1];
+    var _ref5 = _sliced_to_array((0, import_react8.useState)(null), 2), functionInfo = _ref5[0], setFunctionInfo = _ref5[1];
+    var descriptionService = (0, import_react_bindings4.useDependency)(IDescriptionService);
+    var localeService = (0, import_react_bindings4.useDependency)(import_core13.LocaleService);
+    var options = getFunctionTypeValues(import_engine_formula7.FunctionType, localeService);
+    options.unshift({
+        label: localeService.t("formula.moreFunctions.allFunctions"),
+        value: allTypeValue
+    });
+    var required = localeService.t("formula.prompt.required");
+    var optional = localeService.t("formula.prompt.optional");
+    (0, import_react8.useEffect)(function() {
+        handleSelectChange(allTypeValue);
+    }, []);
+    (0, import_react8.useEffect)(function() {
+        setCurrentFunctionInfo(0);
+    }, [
+        selectList
+    ]);
+    var highlightSearchText = function(text) {
+        var regex = new RegExp("(".concat(searchText.toLocaleUpperCase(), ")"));
+        var parts = text.split(regex).filter(Boolean);
+        return parts.map(function(part, index) {
+            if (part.match(regex)) {
+                return /* @__PURE__ */ import_react8.default.createElement("span", {
+                    key: index,
+                    className: index_module_default7.formulaSelectFunctionResultItemNameLight
+                }, part);
+            }
+            return part;
+        });
+    };
+    var setCurrentFunctionInfo = function(selectedIndex) {
+        if (selectList.length === 0) {
+            setFunctionInfo(null);
+            return;
+        }
+        setNameSelected(selectedIndex);
+        var functionInfo2 = descriptionService.getFunctionInfo(selectList[selectedIndex].name);
+        if (!functionInfo2) {
+            setFunctionInfo(null);
+            return;
+        }
+        setFunctionInfo(functionInfo2);
+        onChange(functionInfo2);
+    };
+    function handleSelectChange(value) {
+        setTypeSelected(value);
+        var selectList2 = descriptionService.getSearchListByType(+value);
+        setSelectList(selectList2);
+    }
+    function handleSearchInputChange(value) {
+        setSearchText(value);
+        var selectList2 = descriptionService.getSearchListByName(value);
+        setSelectList(selectList2);
+    }
+    function handleSelectListKeyDown(e) {
+        e.stopPropagation();
+        if (e.key === "ArrowDown") {
+            var nextActive = active + 1;
+            setActive(nextActive === selectList.length ? 0 : nextActive);
+        } else if (e.key === "ArrowUp") {
+            var nextActive1 = active - 1;
+            setActive(nextActive1 === -1 ? selectList.length - 1 : nextActive1);
+        } else if (e.key === "Enter") {
+            setCurrentFunctionInfo(active);
+        }
+    }
+    var handleLiMouseEnter = function(index) {
+        setActive(index);
+    };
+    var handleLiMouseLeave = function() {
+        setActive(-1);
+    };
+    return /* @__PURE__ */ import_react8.default.createElement("div", null, /* @__PURE__ */ import_react8.default.createElement("div", {
+        className: index_module_default7.formulaSelectFunctionSelect
+    }, /* @__PURE__ */ import_react8.default.createElement(import_design3.Select, {
+        value: typeSelected,
+        options: options,
+        onChange: handleSelectChange
+    }), /* @__PURE__ */ import_react8.default.createElement(import_design3.Input, {
+        placeholder: localeService.t("formula.moreFunctions.searchFunctionPlaceholder"),
+        onKeyDown: handleSelectListKeyDown,
+        value: searchText,
+        onChange: handleSearchInputChange,
+        size: "large",
+        allowClear: true
+    })), /* @__PURE__ */ import_react8.default.createElement("ul", {
+        className: index_module_default7.formulaSelectFunctionResult,
+        onKeyDown: handleSelectListKeyDown,
+        tabIndex: -1
+    }, selectList.map(function(param, index) {
+        var name = param.name;
+        return /* @__PURE__ */ import_react8.default.createElement("li", {
+            key: index,
+            className: active === index ? "".concat(index_module_default7.formulaSelectFunctionResultItem, " ").concat(index_module_default7.formulaSelectFunctionResultItemActive) : index_module_default7.formulaSelectFunctionResultItem,
+            onMouseEnter: function() {
+                return handleLiMouseEnter(index);
+            },
+            onMouseLeave: handleLiMouseLeave,
+            onClick: function() {
+                return setCurrentFunctionInfo(index);
+            }
+        }, nameSelected === index && /* @__PURE__ */ import_react8.default.createElement(import_icons2.CheckMarkSingle, {
+            className: index_module_default7.formulaSelectFunctionResultItemSelected
+        }), /* @__PURE__ */ import_react8.default.createElement("span", {
+            className: index_module_default7.formulaSelectFunctionResultItemName
+        }, highlightSearchText(name)));
+    })), functionInfo && /* @__PURE__ */ import_react8.default.createElement("div", {
+        className: index_module_default7.formulaSelectFunctionContent
+    }, /* @__PURE__ */ import_react8.default.createElement(FunctionParams, {
+        title: functionInfo.functionName,
+        value: functionInfo.description
+    }), /* @__PURE__ */ import_react8.default.createElement(FunctionParams, {
+        title: localeService.t("formula.moreFunctions.syntax"),
+        value: /* @__PURE__ */ import_react8.default.createElement(FunctionHelp, {
+            prefix: functionInfo.functionName,
+            value: functionInfo.functionParameter
+        })
+    }), /* @__PURE__ */ import_react8.default.createElement(FunctionParams, {
+        title: localeService.t("formula.prompt.helpExample"),
+        value: "".concat(functionInfo.functionName, "(").concat(functionInfo.functionParameter.map(function(item) {
+            return item.example;
+        }).join(","), ")")
+    }), functionInfo.functionParameter && functionInfo.functionParameter.map(function(item, i) {
+        return /* @__PURE__ */ import_react8.default.createElement(FunctionParams, {
+            key: i,
+            title: item.name,
+            value: "".concat(item.require ? required : optional, " ").concat(item.detail)
+        });
+    })));
+}
+// src/views/more-functions/MoreFunctions.tsx
+function MoreFunctions() {
+    var _ref = _sliced_to_array((0, import_react9.useState)(true), 2), selectFunction = _ref[0], setSelectFunction = _ref[1];
+    var _ref1 = _sliced_to_array((0, import_react9.useState)(false), 2), inputParams = _ref1[0], setInputParams = _ref1[1];
+    var _ref2 = _sliced_to_array((0, import_react9.useState)([]), 2), params = _ref2[0], setParams = _ref2[1];
+    var _ref3 = _sliced_to_array((0, import_react9.useState)(null), 2), functionInfo = _ref3[0], setFunctionInfo = _ref3[1];
+    var localeService = (0, import_react_bindings5.useDependency)(import_core14.LocaleService);
+    var sidebarService = (0, import_react_bindings5.useDependency)(import_ui3.ISidebarService);
+    var formulaInputService = (0, import_react_bindings5.useDependency)(IFormulaInputService);
+    function handleClickNextPrev() {
+        if (selectFunction) {}
+        setSelectFunction(!selectFunction);
+        setInputParams(!inputParams);
+    }
+    function handleConfirm() {
+        formulaInputService.inputFormula("=".concat(functionInfo === null || functionInfo === void 0 ? void 0 : functionInfo.functionName, "("));
+    }
+    return /* @__PURE__ */ import_react9.default.createElement("div", {
+        className: index_module_default4.formulaMoreFunctions
+    }, selectFunction && /* @__PURE__ */ import_react9.default.createElement(SelectFunction, {
+        onChange: setFunctionInfo
+    }), inputParams && /* @__PURE__ */ import_react9.default.createElement(InputParams, {
+        functionInfo: functionInfo,
+        onChange: setParams
+    }), /* @__PURE__ */ import_react9.default.createElement("div", {
+        className: index_module_default4.formulaMoreFunctionsOperation
+    }, inputParams && /* @__PURE__ */ import_react9.default.createElement(import_design4.Button, {
+        type: "primary",
+        onClick: handleClickNextPrev
+    }, localeService.t("formula.moreFunctions.next")), inputParams && /* @__PURE__ */ import_react9.default.createElement(import_design4.Button, {
+        onClick: handleClickNextPrev
+    }, localeService.t("formula.moreFunctions.prev")), selectFunction && /* @__PURE__ */ import_react9.default.createElement(import_design4.Button, {
+        type: "primary",
+        onClick: handleConfirm
+    }, localeService.t("formula.moreFunctions.confirm"))));
+}
+// src/controllers/menu.ts
+var import_ui4 = require("@univerjs/ui");
+function InsertFunctionMenuItemFactory(accessor) {
+    return {
+        id: InsertFunctionOperation.id,
+        icon: "FunctionSingle",
+        tooltip: "formula.insert.tooltip",
+        group: import_ui4.MenuGroup.TOOLBAR_FORMULAS_INSERT,
+        type: import_ui4.MenuItemType.SELECTOR,
+        positions: [
+            import_ui4.MenuPosition.TOOLBAR_START
+        ],
+        selections: [
+            {
+                label: "SUM",
+                value: "SUM",
+                icon: "SumSingle"
+            },
+            {
+                label: "AVERAGE",
+                value: "AVERAGE",
+                icon: "AvgSingle"
+            },
+            {
+                label: "COUNT",
+                value: "COUNT",
+                icon: "CntSingle"
+            },
+            {
+                label: "MAX",
+                value: "MAX",
+                icon: "MaxSingle"
+            },
+            {
+                label: "MIN",
+                value: "MIN",
+                icon: "MinSingle"
+            }
+        ]
+    };
+}
+function MoreFunctionsMenuItemFactory(accessor) {
+    return {
+        id: MoreFunctionsOperation.id,
+        title: "formula.insert.more",
+        positions: InsertFunctionOperation.id,
+        type: import_ui4.MenuItemType.BUTTON
+    };
+}
+// src/controllers/shortcuts/prompt.shortcut.ts
+var import_engine_render2 = require("@univerjs/engine-render");
+var import_sheets_ui7 = require("@univerjs/sheets-ui");
+var import_ui5 = require("@univerjs/ui");
+// src/common/prompt.ts
+var META_KEY_CTRL_AND_SHIFT = "meta_key_ctrl_And_Shift";
+// src/controllers/shortcuts/prompt.shortcut.ts
+var PROMPT_SELECTION_KEYCODE_ARROW_LIST = [
+    import_ui5.KeyCode.ARROW_DOWN,
+    import_ui5.KeyCode.ARROW_UP,
+    import_ui5.KeyCode.ARROW_LEFT,
+    import_ui5.KeyCode.ARROW_RIGHT
+];
+var PROMPT_SELECTION_KEYCODE_LIST = _to_consumable_array(PROMPT_SELECTION_KEYCODE_ARROW_LIST).concat([
+    import_ui5.KeyCode.ENTER,
+    import_ui5.KeyCode.TAB
+]);
+function promptSelectionShortcutItem() {
+    var shortcutList = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = PROMPT_SELECTION_KEYCODE_LIST[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var keycode = _step.value;
+            shortcutList.push({
+                id: SelectEditorFormulaOperation.id,
+                binding: keycode,
+                preconditions: function(contextService) {
+                    return (0, import_sheets_ui7.whenEditorInputFormulaActivated)(contextService);
+                },
+                staticParameters: {
+                    eventType: import_engine_render2.DeviceInputEventType.Keyboard,
+                    keycode: keycode
+                }
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return shortcutList;
+}
+function promptSelectionShortcutItemShift() {
+    var shortcutList = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = PROMPT_SELECTION_KEYCODE_ARROW_LIST[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var keycode = _step.value;
+            shortcutList.push({
+                id: SelectEditorFormulaOperation.id,
+                binding: keycode | import_ui5.MetaKeys.SHIFT,
+                preconditions: function(contextService) {
+                    return (0, import_sheets_ui7.whenEditorInputFormulaActivated)(contextService);
+                },
+                staticParameters: {
+                    eventType: import_engine_render2.DeviceInputEventType.Keyboard,
+                    keycode: keycode,
+                    metaKey: import_ui5.MetaKeys.SHIFT
+                }
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return shortcutList;
+}
+function promptSelectionShortcutItemCtrl() {
+    var shortcutList = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = PROMPT_SELECTION_KEYCODE_ARROW_LIST[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var keycode = _step.value;
+            shortcutList.push({
+                id: SelectEditorFormulaOperation.id,
+                binding: keycode | import_ui5.MetaKeys.CTRL_COMMAND,
+                preconditions: function(contextService) {
+                    return (0, import_sheets_ui7.whenEditorInputFormulaActivated)(contextService);
+                },
+                staticParameters: {
+                    eventType: import_engine_render2.DeviceInputEventType.Keyboard,
+                    keycode: keycode,
+                    metaKey: import_ui5.MetaKeys.CTRL_COMMAND
+                }
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return shortcutList;
+}
+function promptSelectionShortcutItemCtrlAndShift() {
+    var shortcutList = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = PROMPT_SELECTION_KEYCODE_ARROW_LIST[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var keycode = _step.value;
+            shortcutList.push({
+                id: SelectEditorFormulaOperation.id,
+                binding: keycode | import_ui5.MetaKeys.SHIFT | import_ui5.MetaKeys.CTRL_COMMAND,
+                preconditions: function(contextService) {
+                    return (0, import_sheets_ui7.whenEditorInputFormulaActivated)(contextService);
+                },
+                staticParameters: {
+                    eventType: import_engine_render2.DeviceInputEventType.Keyboard,
+                    keycode: keycode,
+                    metaKey: META_KEY_CTRL_AND_SHIFT
+                }
+            });
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return shortcutList;
+}
+var ChangeRefToAbsoluteShortcut = {
+    id: ReferenceAbsoluteOperation.id,
+    binding: import_ui5.KeyCode.F4,
+    preconditions: function(contextService) {
+        return (0, import_sheets_ui7.whenEditorInputFormulaActivated)(contextService);
+    }
+};
+// src/controllers/formula-ui.controller.ts
+var FormulaUIController = /*#__PURE__*/ function(_import_core15_Disposable) {
+    _inherits(FormulaUIController, _import_core15_Disposable);
+    var _super = _create_super(FormulaUIController);
+    function FormulaUIController(_injector, _menuService, _commandService, _shortcutService, _uiController, _componentManager) {
+        _class_call_check(this, FormulaUIController);
+        var _this;
+        _this = _super.call(this);
+        _this._injector = _injector;
+        _this._menuService = _menuService;
+        _this._commandService = _commandService;
+        _this._shortcutService = _shortcutService;
+        _this._uiController = _uiController;
+        _this._componentManager = _componentManager;
+        _this._initialize();
+        return _this;
+    }
+    _create_class(FormulaUIController, [
+        {
+            key: "_initialize",
+            value: function _initialize() {
+                this._registerCommands();
+                this._registerMenus();
+                this._registerShortcuts();
+                this._registerComponents();
+            }
+        },
+        {
+            key: "_registerMenus",
+            value: function _registerMenus() {
+                var _this = this;
+                [
+                    InsertFunctionMenuItemFactory,
+                    MoreFunctionsMenuItemFactory
+                ].forEach(function(factory) {
+                    _this.disposeWithMe(_this._menuService.addMenuItem(_this._injector.invoke(factory)));
+                });
+            }
+        },
+        {
+            key: "_registerCommands",
+            value: function _registerCommands() {
+                var _this = this;
+                [
+                    InsertFunctionCommand,
+                    InsertFunctionOperation,
+                    MoreFunctionsOperation,
+                    SearchFunctionOperation,
+                    HelpFunctionOperation,
+                    SelectEditorFormulaOperation,
+                    ReferenceAbsoluteOperation
+                ].forEach(function(command) {
+                    return _this.disposeWithMe(_this._commandService.registerCommand(command));
+                });
+            }
+        },
+        {
+            key: "_registerShortcuts",
+            value: function _registerShortcuts() {
+                var _this = this;
+                _to_consumable_array(promptSelectionShortcutItem()).concat(_to_consumable_array(promptSelectionShortcutItemShift()), _to_consumable_array(promptSelectionShortcutItemCtrl()), _to_consumable_array(promptSelectionShortcutItemCtrlAndShift()), [
+                    ChangeRefToAbsoluteShortcut
+                ]).forEach(function(item) {
+                    _this.disposeWithMe(_this._shortcutService.registerShortcut(item));
+                });
+            }
+        },
+        {
+            key: "_registerComponents",
+            value: function _registerComponents() {
+                var _this = this;
+                this.disposeWithMe(this._uiController.registerContentComponent(function() {
+                    return (0, import_react_bindings6.connectInjector)(RenderFormulaPromptContent, _this._injector);
+                }));
+                this._componentManager.register(MORE_FUNCTIONS_COMPONENT, MoreFunctions);
+            }
+        }
+    ]);
+    return FormulaUIController;
+}(import_core15.Disposable);
+FormulaUIController = __decorateClass([
+    (0, import_core15.OnLifecycle)(import_core15.LifecycleStages.Ready, FormulaUIController),
+    __decorateParam(0, (0, import_redi6.Inject)(import_redi6.Injector)),
+    __decorateParam(1, import_ui6.IMenuService),
+    __decorateParam(2, import_core15.ICommandService),
+    __decorateParam(3, import_ui6.IShortcutService),
+    __decorateParam(4, import_ui6.IUIController),
+    __decorateParam(5, (0, import_redi6.Inject)(import_ui6.ComponentManager))
+], FormulaUIController);
+// src/controllers/prompt.controller.ts
+var import_core16 = require("@univerjs/core");
+var import_docs = require("@univerjs/docs");
+var import_engine_formula8 = require("@univerjs/engine-formula");
+var import_engine_render3 = require("@univerjs/engine-render");
+var import_sheets3 = require("@univerjs/sheets");
+var import_sheets_ui8 = require("@univerjs/sheets-ui");
+var import_ui7 = require("@univerjs/ui");
+var import_redi7 = require("@wendellhu/redi");
+// src/common/selection.ts
+var import_tinycolor = require("@ctrl/tinycolor");
+var FORMULA_REF_SELECTION_PLUGIN_NAME = "formula_reference_selection_plugin_name";
+function getFormulaRefSelectionStyle(themeService, refColor, id) {
+    var style = themeService.getCurrentTheme();
+    var fill = new import_tinycolor.TinyColor(refColor).setAlpha(0.05).toString();
+    return {
+        id: id,
+        strokeWidth: 2,
+        stroke: refColor,
+        // strokeDash: 10,
+        fill: fill,
+        widgets: {
+            tl: true,
+            tc: true,
+            tr: true,
+            ml: true,
+            mr: true,
+            bl: true,
+            bc: true,
+            br: true
+        },
+        widgetSize: 6,
+        widgetStrokeWidth: 1,
+        widgetStroke: style.colorWhite,
+        hasAutoFill: false,
+        hasRowHeader: false,
+        hasColumnHeader: false
+    };
+}
+// src/controllers/prompt.controller.ts
+var PromptController = /*#__PURE__*/ function(_import_core16_Disposable) {
+    _inherits(PromptController, _import_core16_Disposable);
+    var _super = _create_super(PromptController);
+    function PromptController(_commandService, _localeService, _contextService, _textSelectionRenderManager, _editorBridgeService, _formulaPromptService, _formulaEngineService, _renderManagerService, _themeService, _selectionManagerService, _sheetSkeletonManagerService, _currentUniverService, _selectionRenderService, _descriptionService, _textSelectionManagerService, _formulaInputService, _docViewModelManagerService) {
+        _class_call_check(this, PromptController);
+        var _this;
+        _this = _super.call(this);
+        _define_property(_assert_this_initialized(_this), "_formulaRefColors", []);
+        _define_property(_assert_this_initialized(_this), "_previousSequenceNodes", void 0);
+        _define_property(_assert_this_initialized(_this), "_previousRangesCount", 0);
+        _define_property(_assert_this_initialized(_this), "_previousInsertRefStringIndex", void 0);
+        _define_property(_assert_this_initialized(_this), "_currentInsertRefStringIndex", -1);
+        _define_property(_assert_this_initialized(_this), "_currentUnitId", void 0);
+        _define_property(_assert_this_initialized(_this), "_currentSheetId", void 0);
+        _define_property(_assert_this_initialized(_this), "_arrowMoveActionState", 0 /* InitialState */ );
+        _define_property(_assert_this_initialized(_this), "_isSelectionMovingRefSelections", []);
+        _define_property(_assert_this_initialized(_this), "_stringColor", "");
+        _define_property(_assert_this_initialized(_this), "_numberColor", "");
+        _define_property(_assert_this_initialized(_this), "_insertSelections", []);
+        _define_property(_assert_this_initialized(_this), "_inputPanelState", 0 /* InitialState */ );
+        _this._commandService = _commandService;
+        _this._localeService = _localeService;
+        _this._contextService = _contextService;
+        _this._textSelectionRenderManager = _textSelectionRenderManager;
+        _this._editorBridgeService = _editorBridgeService;
+        _this._formulaPromptService = _formulaPromptService;
+        _this._formulaEngineService = _formulaEngineService;
+        _this._renderManagerService = _renderManagerService;
+        _this._themeService = _themeService;
+        _this._selectionManagerService = _selectionManagerService;
+        _this._sheetSkeletonManagerService = _sheetSkeletonManagerService;
+        _this._currentUniverService = _currentUniverService;
+        _this._selectionRenderService = _selectionRenderService;
+        _this._descriptionService = _descriptionService;
+        _this._textSelectionManagerService = _textSelectionManagerService;
+        _this._formulaInputService = _formulaInputService;
+        _this._docViewModelManagerService = _docViewModelManagerService;
+        _this._initialize();
+        return _this;
+    }
+    _create_class(PromptController, [
+        {
+            key: "dispose",
+            value: function dispose() {
+                this._formulaRefColors = [];
+                this._resetTemp();
+            }
+        },
+        {
+            key: "_resetTemp",
+            value: function _resetTemp() {
+                this._previousSequenceNodes = null;
+                this._previousInsertRefStringIndex = null;
+                this._currentUnitId = null;
+                this._currentSheetId = null;
+                this._isSelectionMovingRefSelections = [];
+                this._previousRangesCount = 0;
+                this._currentInsertRefStringIndex = -1;
+            }
+        },
+        {
+            key: "_initialize",
+            value: function _initialize() {
+                this._initialCursorSync();
+                this._initAcceptFormula();
+                this._initialFormulaTheme();
+                this._initialRefSelectionUpdateEvent();
+                this._initialRefSelectionInsertEvent();
+                this._initialExitEditor();
+                this._initialEditorInputChange();
+                this._commandExecutedListener();
+                this._cursorStateListener();
+                this._syncEditorListener();
+            }
+        },
+        {
+            key: "_initialFormulaTheme",
+            value: function _initialFormulaTheme() {
+                var style = this._themeService.getCurrentTheme();
+                this._formulaRefColors = [
+                    style.loopColor1,
+                    style.loopColor2,
+                    style.loopColor3,
+                    style.loopColor4,
+                    style.loopColor5,
+                    style.loopColor6,
+                    style.loopColor7,
+                    style.loopColor8,
+                    style.loopColor9,
+                    style.loopColor10,
+                    style.loopColor11,
+                    style.loopColor12
+                ];
+                this._numberColor = style.hyacinth700;
+                this._stringColor = style.verdancy800;
+            }
+        },
+        {
+            key: "_initialCursorSync",
+            value: function _initialCursorSync() {
+                var _this = this;
+                this.disposeWithMe((0, import_core16.toDisposable)(this._textSelectionRenderManager.textSelection$.subscribe(function() {
+                    if (_this._editorBridgeService.isVisible().visible === false || _this._formulaInputService.isSelectionMoving()) {
+                        return;
+                    }
+                    var currentBody = _this._getCurrentBody();
+                    var dataStream = (currentBody === null || currentBody === void 0 ? void 0 : currentBody.dataStream) || "";
+                    _this._contextSwitch(dataStream);
+                    _this._changeKeepVisibleHideState();
+                    _this._switchSelectionPlugin();
+                    if (_this._formulaInputService.isLockedSelectionChange()) {
+                        return;
+                    }
+                    _this._highlightFormula();
+                    _this._changeFunctionPanelState();
+                })));
+            }
+        },
+        {
+            key: "_initialEditorInputChange",
+            value: function _initialEditorInputChange() {
+                var _this = this;
+                this.disposeWithMe((0, import_core16.toDisposable)(this._textSelectionRenderManager.onInputBefore$.subscribe(function(param) {
+                    _this._previousSequenceNodes = null;
+                    _this._previousInsertRefStringIndex = null;
+                    _this._selectionRenderService.enableSkipRemainLast();
+                    var e = param === null || param === void 0 ? void 0 : param.event;
+                    if (e == null) {
+                        return;
+                    }
+                    if (![
+                        import_ui7.KeyCode.ARROW_DOWN,
+                        import_ui7.KeyCode.ARROW_UP,
+                        import_ui7.KeyCode.ARROW_LEFT,
+                        import_ui7.KeyCode.ARROW_RIGHT
+                    ].includes(e.which)) {
+                        if (_this._arrowMoveActionState !== 1 /* moveCursor */ ) {
+                            _this._arrowMoveActionState = 2 /* moveRefReady */ ;
+                        }
+                        _this._inputPanelState = 1 /* keyNormal */ ;
+                    } else {
+                        _this._inputPanelState = 2 /* keyArrow */ ;
+                    }
+                })));
+            }
+        },
+        {
+            key: "_initialExitEditor",
+            value: function _initialExitEditor() {
+                var _this = this;
+                this.disposeWithMe((0, import_core16.toDisposable)(this._editorBridgeService.afterVisible$.subscribe(function(visibleParam) {
+                    if (visibleParam.visible === true) {
+                        var _this__getCurrentUnitIdAndSheetId = _this._getCurrentUnitIdAndSheetId(), unitId = _this__getCurrentUnitIdAndSheetId.unitId, sheetId = _this__getCurrentUnitIdAndSheetId.sheetId;
+                        if (_this._currentUnitId == null) {
+                            _this._currentUnitId = unitId;
+                        }
+                        if (_this._currentSheetId == null) {
+                            _this._currentSheetId = sheetId;
+                        }
+                        return;
+                    }
+                    var current = _this._selectionManagerService.getCurrent();
+                    if ((current === null || current === void 0 ? void 0 : current.pluginName) === import_sheets3.NORMAL_SELECTION_PLUGIN_NAME) {
+                        _this._disableForceKeepVisible();
+                        return;
+                    }
+                    _this._selectionManagerService.clear();
+                    _this._selectionManagerService.changePlugin(import_sheets3.NORMAL_SELECTION_PLUGIN_NAME);
+                    _this._updateEditorModel("\r\n", []);
+                    _this._contextService.setContextValue(import_core16.FOCUSING_EDITOR_INPUT_FORMULA, false);
+                    _this._disableForceKeepVisible();
+                    _this._selectionRenderService.resetStyle();
+                    _this._resetTemp();
+                    _this._hideFunctionPanel();
+                })));
+            }
+        },
+        {
+            key: "_initialRefSelectionUpdateEvent",
+            value: function _initialRefSelectionUpdateEvent() {
+                var _this = this;
+                var disposableCollection = new import_core16.DisposableCollection();
+                this.disposeWithMe((0, import_core16.toDisposable)(this._selectionManagerService.selectionInfo$.subscribe(function() {
+                    disposableCollection.dispose();
+                    var current = _this._selectionManagerService.getCurrent();
+                    _this._formulaInputService.disableSelectionMoving();
+                    if ((current === null || current === void 0 ? void 0 : current.pluginName) !== FORMULA_REF_SELECTION_PLUGIN_NAME) {
+                        return;
+                    }
+                    _this._updateRefSelectionStyle(_this._isSelectionMovingRefSelections);
+                    var selectionControls = _this._selectionRenderService.getCurrentControls();
+                    selectionControls.forEach(function(controlSelection) {
+                        controlSelection.disableHelperSelection();
+                        disposableCollection.add((0, import_core16.toDisposable)(controlSelection.selectionMoving$.subscribe(function(toRange) {
+                            _this._changeControlSelection(toRange, controlSelection);
+                        })));
+                        disposableCollection.add((0, import_core16.toDisposable)(controlSelection.selectionScaling$.subscribe(function(toRange) {
+                            _this._changeControlSelection(toRange, controlSelection);
+                        })));
+                        disposableCollection.add((0, import_core16.toDisposable)(controlSelection.selectionMoved$.subscribe(function() {
+                            _this._formulaInputService.disableLockedSelectionChange();
+                        })));
+                        disposableCollection.add((0, import_core16.toDisposable)(controlSelection.selectionScaled$.subscribe(function() {
+                            _this._formulaInputService.disableLockedSelectionChange();
+                        })));
+                    });
+                })));
+            }
+        },
+        {
+            key: "_syncEditorListener",
+            value: function _syncEditorListener() {
+                var _this = this;
+                this.disposeWithMe((0, import_core16.toDisposable)(this._formulaInputService.syncToEditor$.subscribe(function(param) {
+                    var sequences = param.sequences, textSelectionOffset = param.textSelectionOffset;
+                    _this._syncToEditor(sequences, textSelectionOffset);
+                })));
+            }
+        },
+        {
+            key: "_selectionChanging",
+            value: function _selectionChanging(ranges) {
+                var isSync = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+                if (ranges == null) {
+                    return;
+                }
+                if (!this._formulaInputService.isLockedSelectionInsert()) {
+                    return;
+                }
+                this._formulaInputService.enableSelectionMoving();
+                this._inertControlSelection(ranges);
+                if (ranges == null || isSync === false) {
+                    return;
+                }
+                var currentRange = ranges[ranges.length - 1];
+                this._inertControlSelectionReplace(currentRange);
+            }
+        },
+        {
+            key: "_initialRefSelectionInsertEvent",
+            value: function _initialRefSelectionInsertEvent() {
+                var _this = this;
+                this.disposeWithMe((0, import_core16.toDisposable)(this._selectionRenderService.selectionMoving$.subscribe(this._selectionChanging.bind(this))));
+                this.disposeWithMe((0, import_core16.toDisposable)(this._selectionRenderService.selectionMoveStart$.subscribe(function(ranges) {
+                    _this._selectionChanging(ranges, true);
+                })));
+            }
+        },
+        {
+            key: "_initAcceptFormula",
+            value: function _initAcceptFormula() {
+                var _this = this;
+                this.disposeWithMe((0, import_core16.toDisposable)(this._formulaPromptService.acceptFormulaName$.subscribe(function(formulaString) {
+                    var activeRange = _this._textSelectionRenderManager.getActiveRange();
+                    if (activeRange == null) {
+                        _this._hideFunctionPanel();
+                        return;
+                    }
+                    var startOffset = activeRange.startOffset;
+                    var lastSequenceNodes = _this._formulaInputService.getSequenceNodes();
+                    var nodeIndex = _this._formulaInputService.getCurrentSequenceNodeIndex(startOffset - 2);
+                    var node = lastSequenceNodes[nodeIndex];
+                    if (node == null || typeof node === "string") {
+                        _this._hideFunctionPanel();
+                        return;
+                    }
+                    var difference = formulaString.length - node.token.length;
+                    var newNode = _object_spread({}, node);
+                    newNode.token = formulaString;
+                    newNode.endIndex += difference;
+                    lastSequenceNodes[nodeIndex] = newNode;
+                    lastSequenceNodes.splice(nodeIndex + 1, 0, import_engine_formula8.matchToken.OPEN_BRACKET);
+                    var formulaStringCount = formulaString.length + 1;
+                    for(var i = nodeIndex + 2, len = lastSequenceNodes.length; i < len; i++){
+                        var node2 = lastSequenceNodes[i];
+                        if (typeof node2 === "string") {
+                            continue;
+                        }
+                        var newNode2 = _object_spread({}, node2);
+                        newNode2.startIndex += formulaStringCount;
+                        newNode2.endIndex += formulaStringCount;
+                        lastSequenceNodes[i] = newNode2;
+                    }
+                    _this._syncToEditor(lastSequenceNodes, newNode.endIndex + 2);
+                })));
+            }
+        },
+        {
+            key: "_changeFunctionPanelState",
+            value: function _changeFunctionPanelState() {
+                var activeRange = this._textSelectionRenderManager.getActiveRange();
+                if (activeRange == null) {
+                    this._hideFunctionPanel();
+                    return;
+                }
+                var startOffset = activeRange.startOffset;
+                var currentSequenceNode = this._formulaInputService.getCurrentSequenceNode(startOffset - 2);
+                if (currentSequenceNode == null) {
+                    this._hideFunctionPanel();
+                    return;
+                }
+                if (typeof currentSequenceNode !== "string" && currentSequenceNode.nodeType === import_engine_formula8.sequenceNodeType.FUNCTION) {
+                    var token = currentSequenceNode.token.toUpperCase();
+                    if (this._inputPanelState === 1 /* keyNormal */ ) {
+                        var searchList = this._descriptionService.getSearchListByName(token);
+                        this._hideFunctionPanel();
+                        if (searchList == null || searchList.length === 0) {
+                            return;
+                        }
+                        this._commandService.executeCommand(SearchFunctionOperation.id, {
+                            visible: true,
+                            searchText: token,
+                            searchList: searchList
+                        });
+                    } else if (this._descriptionService.hasFunction(token)) {
+                        this._changeHelpFunctionPanelState(token, -1);
+                    }
+                    return;
+                }
+                var currentBody = this._getCurrentBody();
+                var dataStream = (currentBody === null || currentBody === void 0 ? void 0 : currentBody.dataStream) || "";
+                var functionAndParameter = this._formulaEngineService.getFunctionAndParameter(dataStream, startOffset - 1);
+                if (functionAndParameter == null) {
+                    this._hideFunctionPanel();
+                    return;
+                }
+                var functionName = functionAndParameter.functionName, paramIndex = functionAndParameter.paramIndex;
+                this._changeHelpFunctionPanelState(functionName.toUpperCase(), paramIndex);
+            }
+        },
+        {
+            key: "_changeHelpFunctionPanelState",
+            value: function _changeHelpFunctionPanelState(token, paramIndex) {
+                var functionInfo = this._descriptionService.getFunctionInfo(token);
+                this._hideFunctionPanel();
+                if (functionInfo == null) {
+                    return;
+                }
+                this._commandService.executeCommand(HelpFunctionOperation.id, {
+                    visible: true,
+                    paramIndex: paramIndex,
+                    functionInfo: functionInfo
+                });
+            }
+        },
+        {
+            key: "_hideFunctionPanel",
+            value: function _hideFunctionPanel() {
+                this._commandService.executeCommand(SearchFunctionOperation.id, {
+                    visible: false,
+                    searchText: ""
+                });
+                this._commandService.executeCommand(HelpFunctionOperation.id, {
+                    visible: false,
+                    paramIndex: -1
+                });
+            }
+        },
+        {
+            /**
+   * If the cursor is located at a formula token,
+   * it is necessary to prohibit the behavior of closing the editor by clicking on the canvas,
+   * in order to generate reference text for the formula.
+   */ key: "_changeKeepVisibleHideState",
+            value: function _changeKeepVisibleHideState() {
+                if (this._getContextState() === false) {
+                    this._disableForceKeepVisible();
+                    return;
+                }
+                var char = this._getCurrentChar();
+                if (char == null) {
+                    this._disableForceKeepVisible();
+                    return;
+                }
+                if (this._matchRefDrawToken(char)) {
+                    this._editorBridgeService.enableForceKeepVisible();
+                    this._formulaInputService.enableLockedSelectionInsert();
+                    this._selectionRenderService.enableRemainLast();
+                    if (this._arrowMoveActionState !== 1 /* moveCursor */ ) {
+                        this._arrowMoveActionState = 2 /* moveRefReady */ ;
+                    }
+                } else {
+                    this._disableForceKeepVisible();
+                }
+            }
+        },
+        {
+            /**
+   * Determine whether the character is a token keyword for the formula engine.
+   * @param char
+   * @returns
+   */ key: "_matchRefDrawToken",
+            value: function _matchRefDrawToken(char) {
+                return (0, import_engine_formula8.isFormulaLexerToken)(char) && char !== import_engine_formula8.matchToken.CLOSE_BRACES && char !== import_engine_formula8.matchToken.CLOSE_BRACKET && char !== import_engine_formula8.matchToken.SINGLE_QUOTATION && char !== import_engine_formula8.matchToken.DOUBLE_QUOTATION || char === " ";
+            }
+        },
+        {
+            /**
+   *
+   * @returns Return the character under the current cursor in the editor.
+   */ key: "_getCurrentChar",
+            value: function _getCurrentChar() {
+                var activeRange = this._textSelectionRenderManager.getActiveRange();
+                if (activeRange == null) {
+                    return;
+                }
+                var startOffset = activeRange.startOffset;
+                var body = this._getCurrentBody();
+                if (body == null || startOffset == null) {
+                    return;
+                }
+                var dataStream = body.dataStream;
+                return dataStream[startOffset - 1];
+            }
+        },
+        {
+            /**
+   * Disable the ref string generation mode. In the ref string generation mode,
+   * users can select a certain area using the mouse and arrow keys, and convert the area into a ref string.
+   */ key: "_disableForceKeepVisible",
+            value: function _disableForceKeepVisible() {
+                this._editorBridgeService.disableForceKeepVisible();
+                this._formulaInputService.disableLockedSelectionInsert();
+                this._currentInsertRefStringIndex = -1;
+                this._selectionRenderService.disableRemainLast();
+                if (this._arrowMoveActionState === 2 /* moveRefReady */ ) {
+                    this._arrowMoveActionState = 4 /* exitInput */ ;
+                }
+            }
+        },
+        {
+            key: "_getCurrentBody",
+            value: function _getCurrentBody() {
+                var _documentModel_snapshot;
+                var editorUnitId = this._editorBridgeService.getCurrentEditorId();
+                if (editorUnitId == null) {
+                    return;
+                }
+                var documentModel = this._currentUniverService.getUniverDocInstance(editorUnitId);
+                return documentModel === null || documentModel === void 0 ? void 0 : (_documentModel_snapshot = documentModel.snapshot) === null || _documentModel_snapshot === void 0 ? void 0 : _documentModel_snapshot.body;
+            }
+        },
+        {
+            key: "_getFormulaAndCellEditorBody",
+            value: function _getFormulaAndCellEditorBody() {
+                var _this = this;
+                var unitIds = [
+                    import_core16.DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY,
+                    import_core16.DOCS_NORMAL_EDITOR_UNIT_ID_KEY
+                ];
+                return unitIds.map(function(unitId) {
+                    var dataModel = _this._currentUniverService.getUniverDocInstance(unitId);
+                    return dataModel === null || dataModel === void 0 ? void 0 : dataModel.getBody();
+                });
+            }
+        },
+        {
+            /**
+   * Detect whether the user's input content is a formula. If it is a formula,
+   * serialize the current input content into a sequenceNode;
+   * otherwise, close the formula panel.
+   * @param currentInputValue The text content entered by the user in the editor.
+   * @returns
+   */ key: "_contextSwitch",
+            value: function _contextSwitch(currentInputValue) {
+                if ((0, import_core16.isFormulaString)(currentInputValue)) {
+                    this._contextService.setContextValue(import_core16.FOCUSING_EDITOR_INPUT_FORMULA, true);
+                    var lastSequenceNodes = this._formulaEngineService.buildSequenceNodes(currentInputValue.replace(/\r/g, "").replace(/\n/g, "")) || [];
+                    this._formulaInputService.setSequenceNodes(lastSequenceNodes);
+                    var activeRange = this._textSelectionRenderManager.getActiveRange();
+                    if (activeRange == null) {
+                        return;
+                    }
+                    var startOffset = activeRange.startOffset;
+                    this._currentInsertRefStringIndex = startOffset - 1;
+                } else {
+                    this._contextService.setContextValue(import_core16.FOCUSING_EDITOR_INPUT_FORMULA, false);
+                    this._formulaInputService.disableLockedSelectionChange();
+                    this._formulaInputService.disableLockedSelectionInsert();
+                    this._formulaInputService.clearSequenceNodes();
+                    this._hideFunctionPanel();
+                }
+            }
+        },
+        {
+            key: "_getContextState",
+            value: function _getContextState() {
+                return this._contextService.getContextValue(import_core16.FOCUSING_EDITOR_INPUT_FORMULA);
+            }
+        },
+        {
+            /**
+   * Switch from formula selection state to regular selection state.
+   */ key: "_switchSelectionPlugin",
+            value: function _switchSelectionPlugin() {
+                if (this._getContextState() === true) {
+                    this._selectionManagerService.changePluginNoRefresh(FORMULA_REF_SELECTION_PLUGIN_NAME);
+                    var style = (0, import_sheets3.getNormalSelectionStyle)(this._themeService);
+                    style.strokeDash = 8;
+                    style.hasAutoFill = false;
+                    style.hasRowHeader = false;
+                    style.hasColumnHeader = false;
+                    this._selectionRenderService.setStyle(style);
+                } else {
+                    this._selectionManagerService.changePluginNoRefresh(import_sheets3.NORMAL_SELECTION_PLUGIN_NAME);
+                    this._selectionRenderService.resetStyle();
+                }
+            }
+        },
+        {
+            /**
+   * Highlight cell editor and formula bar editor.
+   */ key: "_highlightFormula",
+            value: function _highlightFormula() {
+                if (this._getContextState() === false) {
+                    return;
+                }
+                var sequenceNodes = this._formulaInputService.getSequenceNodes();
+                var bodyList = this._getFormulaAndCellEditorBody().filter(function(b) {
+                    return !!b;
+                });
+                this._selectionManagerService.clear();
+                if (sequenceNodes == null || sequenceNodes.length === 0) {
+                    bodyList.forEach(function(body) {
+                        return body.textRuns = [];
+                    });
+                } else {
+                    var _this__buildTextRuns = this._buildTextRuns(sequenceNodes), textRuns = _this__buildTextRuns.textRuns, refSelections = _this__buildTextRuns.refSelections;
+                    bodyList.forEach(function(body) {
+                        return body.textRuns = textRuns;
+                    });
+                    this._refreshSelectionForReference(refSelections);
+                }
+                this._refreshFormulaAndCellEditor();
+            }
+        },
+        {
+            /**
+   * :
+   * #
+   * Generate styles for formula text, highlighting references, text, numbers, and arrays.
+   * @returns
+   */ key: "_buildTextRuns",
+            value: function _buildTextRuns(sequenceNodes) {
+                var textRuns = [];
+                var refSelections = [];
+                var refColorIndex = 0;
+                for(var i = 0, len = sequenceNodes.length; i < len; i++){
+                    var node = sequenceNodes[i];
+                    if (typeof node === "string") {
+                        continue;
+                    }
+                    var startIndex = node.startIndex, endIndex = node.endIndex, nodeType = node.nodeType, token = node.token;
+                    var themeColor = "";
+                    if (nodeType === import_engine_formula8.sequenceNodeType.REFERENCE) {
+                        var colorIndex = refColorIndex % this._formulaRefColors.length;
+                        themeColor = this._formulaRefColors[colorIndex];
+                        refSelections.push({
+                            refIndex: i,
+                            themeColor: themeColor,
+                            token: token
+                        });
+                        refColorIndex++;
+                    } else if (nodeType === import_engine_formula8.sequenceNodeType.NUMBER) {
+                        themeColor = this._numberColor;
+                    } else if (nodeType === import_engine_formula8.sequenceNodeType.STRING) {
+                        themeColor = this._stringColor;
+                    } else if (nodeType === import_engine_formula8.sequenceNodeType.ARRAY) {
+                        themeColor = this._stringColor;
+                    }
+                    if (themeColor.length > 0) {
+                        textRuns.push({
+                            st: startIndex + 1,
+                            ed: endIndex + 2,
+                            ts: {
+                                cl: {
+                                    rgb: themeColor
+                                }
+                            }
+                        });
+                    }
+                }
+                return {
+                    textRuns: textRuns,
+                    refSelections: refSelections
+                };
+            }
+        },
+        {
+            /**
+   * Draw the referenced selection text based on the style and token.
+   * @param refSelections
+   * @returns
+   */ key: "_refreshSelectionForReference",
+            value: function _refreshSelectionForReference(refSelections) {
+                var _this = this, _loop = function(i, len) {
+                    var _this__insertSelections_find;
+                    var refSelection = refSelections[i];
+                    var themeColor = refSelection.themeColor, token = refSelection.token, refIndex = refSelection.refIndex;
+                    var gridRange = (0, import_core16.deserializeRangeWithSheet)(token);
+                    var refUnitId = gridRange.unitId, sheetName = gridRange.sheetName, range = gridRange.range;
+                    if (refUnitId != null && refUnitId.length > 0 && unitId !== refUnitId) {
+                        return "continue";
+                    }
+                    var refSheetId = _this._getSheetIdByName(unitId, sheetName.trim());
+                    if (refSheetId != null && refSheetId !== sheetId) {
+                        return "continue";
+                    }
+                    var primary = (_this__insertSelections_find = _this._insertSelections.find(function(selection) {
+                        var _selection_range = selection.range, startRow = _selection_range.startRow, startColumn = _selection_range.startColumn, endRow = _selection_range.endRow, endColumn = _selection_range.endColumn;
+                        if (startRow === range.startRow && startColumn === range.startColumn && endRow === range.endRow && endColumn === range.endColumn) {
+                            return true;
+                        }
+                        return false;
+                    })) === null || _this__insertSelections_find === void 0 ? void 0 : _this__insertSelections_find.primary;
+                    if (primary != null) {
+                        lastRange = {
+                            range: range,
+                            primary: primary,
+                            style: getFormulaRefSelectionStyle(_this._themeService, themeColor, refIndex.toString())
+                        };
+                        return "continue";
+                    }
+                    selectionWithStyle.push({
+                        range: range,
+                        primary: primary,
+                        style: getFormulaRefSelectionStyle(_this._themeService, themeColor, refIndex.toString())
+                    });
+                };
+                var _this__getCurrentUnitIdAndSheetId = this._getCurrentUnitIdAndSheetId(), unitId = _this__getCurrentUnitIdAndSheetId.unitId, sheetId = _this__getCurrentUnitIdAndSheetId.sheetId;
+                var selectionWithStyle = [];
+                var workbook = this._currentUniverService.getUniverSheetInstance(unitId);
+                var worksheet = workbook === null || workbook === void 0 ? void 0 : workbook.getSheetBySheetId(sheetId);
+                if (worksheet == null) {
+                    return;
+                }
+                var lastRange = null;
+                for(var i = 0, len = refSelections.length; i < len; i++)_loop(i, len);
+                if (lastRange) {
+                    selectionWithStyle.push(lastRange);
+                }
+                if (selectionWithStyle.length === 0) {
+                    return;
+                }
+                this._selectionManagerService.add(selectionWithStyle);
+            }
+        },
+        {
+            key: "_getSheetIdByName",
+            value: function _getSheetIdByName(unitId, sheetName) {
+                var _workbook_getSheetBySheetName;
+                var workbook = this._currentUniverService.getUniverSheetInstance(unitId);
+                return workbook === null || workbook === void 0 ? void 0 : (_workbook_getSheetBySheetName = workbook.getSheetBySheetName((0, import_engine_formula8.normalizeSheetName)(sheetName))) === null || _workbook_getSheetBySheetName === void 0 ? void 0 : _workbook_getSheetBySheetName.getSheetId();
+            }
+        },
+        {
+            key: "_getSheetNameById",
+            value: function _getSheetNameById(unitId, sheetId) {
+                var _workbook_getSheetBySheetId;
+                var workbook = this._currentUniverService.getUniverSheetInstance(unitId);
+                var sheetName = (workbook === null || workbook === void 0 ? void 0 : (_workbook_getSheetBySheetId = workbook.getSheetBySheetId(sheetId)) === null || _workbook_getSheetBySheetId === void 0 ? void 0 : _workbook_getSheetBySheetId.getName()) || "";
+                if (sheetName.length > 0 && (0, import_engine_formula8.includeFormulaLexerToken)(sheetName)) {
+                    sheetName = "'".concat(sheetName, "'");
+                }
+                return sheetName;
+            }
+        },
+        {
+            key: "_getCurrentUnitIdAndSheetId",
+            value: function _getCurrentUnitIdAndSheetId() {
+                var current = this._sheetSkeletonManagerService.getCurrent();
+                if (current == null) {
+                    var workbook = this._currentUniverService.getCurrentUniverSheetInstance();
+                    var worksheet = workbook.getActiveSheet();
+                    return {
+                        unitId: workbook.getUnitId(),
+                        sheetId: worksheet.getSheetId()
+                    };
+                }
+                var unitId = current.unitId, sheetId = current.sheetId;
+                return {
+                    unitId: unitId,
+                    sheetId: sheetId
+                };
+            }
+        },
+        {
+            /**
+   * Convert the selection range to a ref string for the formula engine, such as A1:B1
+   * @param range
+   * @returns
+   */ key: "_getRefString",
+            value: function _getRefString(range) {
+                var _this__getCurrentUnitIdAndSheetId = this._getCurrentUnitIdAndSheetId(), unitId = _this__getCurrentUnitIdAndSheetId.unitId, sheetId = _this__getCurrentUnitIdAndSheetId.sheetId;
+                var refUnitId = "";
+                var refSheetName = "";
+                if (unitId === this._currentUnitId) {
+                    refUnitId = "";
+                } else {
+                    refUnitId = unitId;
+                }
+                if (sheetId === this._currentSheetId) {
+                    refSheetName = "";
+                } else {
+                    refSheetName = this._getSheetNameById(unitId, sheetId);
+                }
+                var startRow = range.startRow, endRow = range.endRow, startColumn = range.startColumn, endColumn = range.endColumn;
+                return (0, import_core16.serializeRangeToRefString)({
+                    sheetName: refSheetName,
+                    unitId: refUnitId,
+                    range: {
+                        startRow: startRow,
+                        endRow: endRow,
+                        startColumn: startColumn,
+                        endColumn: endColumn
+                    }
+                });
+            }
+        },
+        {
+            key: "_syncToEditor",
+            value: /**
+   * Restore the sequenceNode generated by the lexer to the text in the editor, and set the cursor position.
+   * @param sequenceNodes
+   * @param textSelectionOffset
+   * @returns
+   */ function _syncToEditor(sequenceNodes, textSelectionOffset) {
+                var canUndo = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
+                var _this = this;
+                return _async_to_generator(function() {
+                    var dataStream, _this__buildTextRuns, textRuns, refSelections, activeRange, collapsed, style;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                dataStream = (0, import_engine_formula8.generateStringWithSequence)(sequenceNodes);
+                                _this__buildTextRuns = _this._buildTextRuns(sequenceNodes), textRuns = _this__buildTextRuns.textRuns, refSelections = _this__buildTextRuns.refSelections;
+                                _this._isSelectionMovingRefSelections = refSelections;
+                                activeRange = _this._textSelectionManagerService.getLast();
+                                if (activeRange == null) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                collapsed = activeRange.collapsed, style = activeRange.style;
+                                _this._currentInsertRefStringIndex = textSelectionOffset;
+                                return [
+                                    4,
+                                    _this._fitEditorSize()
+                                ];
+                            case 1:
+                                _state.sent();
+                                if (canUndo) {
+                                    _this._commandService.executeCommand(import_docs.ReplaceContentCommand.id, {
+                                        unitId: _this._editorBridgeService.getCurrentEditorId(),
+                                        body: {
+                                            dataStream: "=".concat(dataStream),
+                                            textRuns: textRuns
+                                        },
+                                        textRanges: [
+                                            {
+                                                startOffset: textSelectionOffset + 1,
+                                                endOffset: textSelectionOffset + 1,
+                                                collapsed: collapsed,
+                                                style: style
+                                            }
+                                        ],
+                                        segmentId: null
+                                    });
+                                } else {
+                                    _this._updateEditorModel("=".concat(dataStream, "\r\n"), textRuns);
+                                    _this._textSelectionManagerService.replaceTextRanges([
+                                        {
+                                            startOffset: textSelectionOffset + 1,
+                                            endOffset: textSelectionOffset + 1,
+                                            collapsed: collapsed,
+                                            style: style
+                                        }
+                                    ]);
+                                }
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "_fitEditorSize",
+            value: function _fitEditorSize() {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var editorUnitId;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                editorUnitId = _this._editorBridgeService.getCurrentEditorId();
+                                if (editorUnitId == null) {
+                                    return [
+                                        2
+                                    ];
+                                }
+                                return [
+                                    4,
+                                    _this._commandService.syncExecuteCommand(import_sheets_ui8.SetEditorResizeOperation.id, {
+                                        unitId: editorUnitId
+                                    })
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            /**
+   * Update the editor's model value to facilitate formula updates.
+   * @param dataStream
+   * @param textRuns
+   * @returns
+   */ key: "_updateEditorModel",
+            value: function _updateEditorModel(dataStream, textRuns) {
+                var editorUnitId = this._editorBridgeService.getCurrentEditorId();
+                if (editorUnitId == null) {
+                    return;
+                }
+                var documentDataModel = this._currentUniverService.getUniverDocInstance(editorUnitId);
+                var docViewModel = this._docViewModelManagerService.getViewModel(editorUnitId);
+                if (docViewModel == null || documentDataModel == null) {
+                    return;
+                }
+                var snapshot = documentDataModel === null || documentDataModel === void 0 ? void 0 : documentDataModel.getSnapshot();
+                if (snapshot == null) {
+                    return;
+                }
+                var newBody = {
+                    dataStream: dataStream,
+                    textRuns: textRuns
+                };
+                snapshot.body = newBody;
+                docViewModel.reset(documentDataModel);
+            }
+        },
+        {
+            key: "_inertControlSelectionReplace",
+            value: function _inertControlSelectionReplace(currentRange) {
+                var _this = this;
+                if (this._previousSequenceNodes == null) {
+                    this._previousSequenceNodes = this._formulaInputService.getSequenceNodes();
+                }
+                if (this._previousInsertRefStringIndex == null) {
+                    this._previousInsertRefStringIndex = this._currentInsertRefStringIndex;
+                }
+                var insertNodes = import_core16.Tools.deepClone(this._previousSequenceNodes);
+                if (insertNodes == null) {
+                    return;
+                }
+                var refString = this._getRefString(currentRange);
+                this._formulaInputService.setSequenceNodes(insertNodes);
+                this._formulaInputService.insertSequenceRef(this._previousInsertRefStringIndex, refString);
+                this._syncToEditor(insertNodes, this._previousInsertRefStringIndex + refString.length);
+                var selectionDatas = this._selectionRenderService.getSelectionDataWithStyle();
+                this._insertSelections = [];
+                selectionDatas.forEach(function(currentSelection) {
+                    var range = (0, import_sheets3.convertSelectionDataToRange)(currentSelection);
+                    _this._insertSelections.push(range);
+                });
+            }
+        },
+        {
+            key: "_inertControlSelection",
+            value: function _inertControlSelection(ranges) {
+                var currentRange = ranges[ranges.length - 1];
+                if ((ranges.length === this._previousRangesCount || this._previousRangesCount === 0) && this._previousSequenceNodes != null) {
+                    this._inertControlSelectionReplace(currentRange);
+                } else {
+                    var insertNodes = this._formulaInputService.getSequenceNodes();
+                    if (insertNodes == null) {
+                        return;
+                    }
+                    var char = this._getCurrentChar();
+                    if (char == null) {
+                        return;
+                    }
+                    this._previousInsertRefStringIndex = this._currentInsertRefStringIndex;
+                    if (!this._matchRefDrawToken(char)) {
+                        this._formulaInputService.insertSequenceString(this._currentInsertRefStringIndex, import_engine_formula8.matchToken.COMMA);
+                        insertNodes = this._formulaInputService.getSequenceNodes();
+                        this._previousInsertRefStringIndex += 1;
+                    }
+                    this._previousSequenceNodes = import_core16.Tools.deepClone(insertNodes);
+                    var refString = this._getRefString(currentRange);
+                    this._formulaInputService.setSequenceNodes(insertNodes);
+                    this._formulaInputService.insertSequenceRef(this._previousInsertRefStringIndex, refString);
+                    this._selectionRenderService.disableSkipRemainLast();
+                }
+                this._arrowMoveActionState = 2 /* moveRefReady */ ;
+                this._previousRangesCount = ranges.length;
+            }
+        },
+        {
+            key: "_updateRefSelectionStyle",
+            value: function _updateRefSelectionStyle(refSelections) {
+                var _this = this, _loop = function(i, len) {
+                    var refSelection = refSelections[i];
+                    var refIndex = refSelection.refIndex, themeColor = refSelection.themeColor, token = refSelection.token;
+                    var rangeWithSheet = (0, import_core16.deserializeRangeWithSheet)(token);
+                    var refUnitId = rangeWithSheet.unitId, sheetName = rangeWithSheet.sheetName, range = rangeWithSheet.range;
+                    if (refUnitId != null && refUnitId.length > 0 && unitId !== refUnitId) {
+                        return "continue";
+                    }
+                    var refSheetId = _this._getSheetIdByName(unitId, sheetName.trim());
+                    if (refSheetId != null && refSheetId !== sheetId) {
+                        return "continue";
+                    }
+                    var control = controls.find(function(c) {
+                        var _c_getRange = c.getRange(), startRow = _c_getRange.startRow, startColumn = _c_getRange.startColumn, endRow = _c_getRange.endRow, endColumn = _c_getRange.endColumn;
+                        if (startRow === range.startRow && startColumn === range.startColumn && endRow === range.endRow && endColumn === range.endColumn) {
+                            return true;
+                        }
+                        return false;
+                    });
+                    if (control == null) {
+                        return "continue";
+                    }
+                    var style = getFormulaRefSelectionStyle(_this._themeService, themeColor, refIndex.toString());
+                    control.updateStyle(style);
+                };
+                var controls = this._selectionRenderService.getCurrentControls();
+                var _this__getCurrentUnitIdAndSheetId = this._getCurrentUnitIdAndSheetId(), unitId = _this__getCurrentUnitIdAndSheetId.unitId, sheetId = _this__getCurrentUnitIdAndSheetId.sheetId;
+                for(var i = 0, len = refSelections.length; i < len; i++)_loop(i, len);
+            }
+        },
+        {
+            key: "_changeControlSelection",
+            value: function _changeControlSelection(toRange, controlSelection) {
+                var _controlSelection_selectionStyle;
+                if (!toRange) {
+                    return;
+                }
+                this._formulaInputService.enableLockedSelectionChange();
+                var id = (_controlSelection_selectionStyle = controlSelection.selectionStyle) === null || _controlSelection_selectionStyle === void 0 ? void 0 : _controlSelection_selectionStyle.id;
+                if (id == null || !import_core16.Tools.isStringNumber(id)) {
+                    return;
+                }
+                var startRow = toRange.startRow, endRow = toRange.endRow, startColumn = toRange.startColumn, endColumn = toRange.endColumn;
+                var refString = this._getRefString({
+                    startRow: startRow,
+                    endRow: endRow,
+                    startColumn: startColumn,
+                    endColumn: endColumn
+                });
+                var nodeIndex = Number(id);
+                this._formulaInputService.updateSequenceRef(nodeIndex, refString);
+                var sequenceNodes = this._formulaInputService.getSequenceNodes();
+                var node = sequenceNodes[nodeIndex];
+                if (typeof node === "string") {
+                    return;
+                }
+                this._syncToEditor(sequenceNodes, node.endIndex + 1);
+                controlSelection.update(toRange);
+            }
+        },
+        {
+            key: "_refreshFormulaAndCellEditor",
+            value: function _refreshFormulaAndCellEditor() {
+                var unitIds = [
+                    import_core16.DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY,
+                    import_core16.DOCS_NORMAL_EDITOR_UNIT_ID_KEY
+                ];
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = unitIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var unitId = _step.value;
+                        var _documentComponent_getSkeleton;
+                        var editorObject = (0, import_sheets_ui8.getEditorObject)(unitId, this._renderManagerService);
+                        var documentComponent = editorObject === null || editorObject === void 0 ? void 0 : editorObject.document;
+                        if (documentComponent == null) {
+                            continue;
+                        }
+                        (_documentComponent_getSkeleton = documentComponent.getSkeleton()) === null || _documentComponent_getSkeleton === void 0 ? void 0 : _documentComponent_getSkeleton.calculate();
+                        documentComponent.makeDirty();
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            }
+        },
+        {
+            key: "_cursorStateListener",
+            value: function _cursorStateListener() {
+                var _this = this;
+                var editorObject = this._getEditorObject();
+                if (editorObject == null) {
+                    return;
+                }
+                var documentComponent = editorObject.document;
+                this.disposeWithMe((0, import_core16.toDisposable)(documentComponent.onPointerDownObserver.add(function() {
+                    _this._arrowMoveActionState = 1 /* moveCursor */ ;
+                    _this._inputPanelState = 3 /* mouse */ ;
+                })));
+            }
+        },
+        {
+            key: "_commandExecutedListener",
+            value: function _commandExecutedListener() {
+                var _this = this;
+                var updateCommandList = [
+                    SelectEditorFormulaOperation.id
+                ];
+                this.disposeWithMe(this._commandService.onCommandExecuted(function(command) {
+                    if (updateCommandList.includes(command.id)) {
+                        var params = command.params;
+                        var keycode = params.keycode, metaKey = params.metaKey;
+                        if (keycode === import_ui7.KeyCode.ENTER) {
+                            if (_this._formulaPromptService.isSearching()) {
+                                _this._formulaPromptService.accept(true);
+                                return;
+                            }
+                            _this._editorBridgeService.changeVisible({
+                                visible: false,
+                                eventType: import_engine_render3.DeviceInputEventType.Keyboard,
+                                keycode: keycode
+                            });
+                            _this._commandService.executeCommand(import_sheets_ui8.MoveSelectionCommand.id, {
+                                direction: import_core16.Direction.DOWN
+                            });
+                            return;
+                        }
+                        if (keycode === import_ui7.KeyCode.TAB) {
+                            if (_this._formulaPromptService.isSearching()) {
+                                _this._formulaPromptService.accept(true);
+                                return;
+                            }
+                            _this._editorBridgeService.changeVisible({
+                                visible: false,
+                                eventType: import_engine_render3.DeviceInputEventType.Keyboard,
+                                keycode: keycode
+                            });
+                            _this._commandService.executeCommand(import_sheets_ui8.MoveSelectionCommand.id, {
+                                direction: import_core16.Direction.RIGHT
+                            });
+                            return;
+                        }
+                        if (_this._formulaPromptService.isSearching()) {
+                            if (keycode === import_ui7.KeyCode.ARROW_DOWN) {
+                                _this._formulaPromptService.navigate({
+                                    direction: import_core16.Direction.DOWN
+                                });
+                                return;
+                            }
+                            if (keycode === import_ui7.KeyCode.ARROW_UP) {
+                                _this._formulaPromptService.navigate({
+                                    direction: import_core16.Direction.UP
+                                });
+                                return;
+                            }
+                        }
+                        if (_this._arrowMoveActionState === 1 /* moveCursor */ ) {
+                            _this._moveInEditor(keycode);
+                            return;
+                        }
+                        if (_this._arrowMoveActionState === 4 /* exitInput */ ) {
+                            _this._editorBridgeService.changeVisible({
+                                visible: false,
+                                eventType: import_engine_render3.DeviceInputEventType.Keyboard,
+                                keycode: keycode
+                            });
+                            return;
+                        }
+                        if (_this._arrowMoveActionState === 2 /* moveRefReady */ ) {
+                            _this._arrowMoveActionState = 3 /* movingRef */ ;
+                        }
+                        var previousRanges = _this._selectionManagerService.getSelectionRanges() || [];
+                        if (previousRanges.length === 0) {
+                            var selectionData = _this._selectionManagerService.getLastByPlugin(import_sheets3.NORMAL_SELECTION_PLUGIN_NAME);
+                            if (selectionData != null) {
+                                var selectionDataNew = import_core16.Tools.deepClone(selectionData);
+                                _this._selectionManagerService.add([
+                                    selectionDataNew
+                                ]);
+                            }
+                        }
+                        var direction = import_core16.Direction.DOWN;
+                        if (keycode === import_ui7.KeyCode.ARROW_DOWN) {
+                            direction = import_core16.Direction.DOWN;
+                        } else if (keycode === import_ui7.KeyCode.ARROW_UP) {
+                            direction = import_core16.Direction.UP;
+                        } else if (keycode === import_ui7.KeyCode.ARROW_LEFT) {
+                            direction = import_core16.Direction.LEFT;
+                        } else if (keycode === import_ui7.KeyCode.ARROW_RIGHT) {
+                            direction = import_core16.Direction.RIGHT;
+                        }
+                        if (metaKey === import_ui7.MetaKeys.CTRL_COMMAND) {
+                            _this._commandService.executeCommand(import_sheets_ui8.MoveSelectionCommand.id, {
+                                direction: direction,
+                                jumpOver: import_sheets_ui8.JumpOver.moveGap
+                            });
+                        } else if (metaKey === import_ui7.MetaKeys.SHIFT) {
+                            _this._commandService.executeCommand(import_sheets_ui8.ExpandSelectionCommand.id, {
+                                direction: direction
+                            });
+                        } else if (metaKey === META_KEY_CTRL_AND_SHIFT) {
+                            _this._commandService.executeCommand(import_sheets_ui8.ExpandSelectionCommand.id, {
+                                direction: direction,
+                                jumpOver: import_sheets_ui8.JumpOver.moveGap
+                            });
+                        } else {
+                            _this._commandService.executeCommand(import_sheets_ui8.MoveSelectionCommand.id, {
+                                direction: direction
+                            });
+                        }
+                        var ranges = _this._selectionManagerService.getSelectionRanges() || [];
+                        var currentRange = ranges[ranges.length - 1];
+                        _this._inertControlSelectionReplace(currentRange);
+                    }
+                }));
+            }
+        },
+        {
+            key: "_moveInEditor",
+            value: function _moveInEditor(keycode) {
+                if (keycode == null) {
+                    return;
+                }
+                var direction = import_core16.Direction.LEFT;
+                if (keycode === import_ui7.KeyCode.ARROW_DOWN) {
+                    direction = import_core16.Direction.DOWN;
+                } else if (keycode === import_ui7.KeyCode.ARROW_UP) {
+                    direction = import_core16.Direction.UP;
+                } else if (keycode === import_ui7.KeyCode.ARROW_RIGHT) {
+                    direction = import_core16.Direction.RIGHT;
+                }
+                this._commandService.executeCommand(import_docs.MoveCursorOperation.id, {
+                    direction: direction
+                });
+            }
+        },
+        {
+            key: "_getEditorObject",
+            value: function _getEditorObject() {
+                return (0, import_sheets_ui8.getEditorObject)(this._editorBridgeService.getCurrentEditorId(), this._renderManagerService);
+            }
+        }
+    ]);
+    return PromptController;
+}(import_core16.Disposable);
+PromptController = __decorateClass([
+    (0, import_core16.OnLifecycle)(import_core16.LifecycleStages.Steady, PromptController),
+    __decorateParam(0, import_core16.ICommandService),
+    __decorateParam(1, (0, import_redi7.Inject)(import_core16.LocaleService)),
+    __decorateParam(2, import_core16.IContextService),
+    __decorateParam(3, import_engine_render3.ITextSelectionRenderManager),
+    __decorateParam(4, (0, import_redi7.Inject)(import_sheets_ui8.IEditorBridgeService)),
+    __decorateParam(5, (0, import_redi7.Inject)(IFormulaPromptService)),
+    __decorateParam(6, (0, import_redi7.Inject)(import_engine_formula8.FormulaEngineService)),
+    __decorateParam(7, import_engine_render3.IRenderManagerService),
+    __decorateParam(8, (0, import_redi7.Inject)(import_core16.ThemeService)),
+    __decorateParam(9, (0, import_redi7.Inject)(import_sheets3.SelectionManagerService)),
+    __decorateParam(10, (0, import_redi7.Inject)(import_sheets_ui8.SheetSkeletonManagerService)),
+    __decorateParam(11, import_core16.IUniverInstanceService),
+    __decorateParam(12, (0, import_redi7.Inject)(import_sheets_ui8.ISelectionRenderService)),
+    __decorateParam(13, (0, import_redi7.Inject)(IDescriptionService)),
+    __decorateParam(14, (0, import_redi7.Inject)(import_docs.TextSelectionManagerService)),
+    __decorateParam(15, IFormulaInputService),
+    __decorateParam(16, (0, import_redi7.Inject)(import_docs.DocViewModelManagerService))
+], PromptController);
+// src/locale/function-list/array/en-US.ts
+var en_US_default = {};
+// src/locale/function-list/compatibility/en-US.ts
+var en_US_default2 = {};
+// src/locale/function-list/cube/en-US.ts
+var en_US_default3 = {};
+// src/locale/function-list/database/en-US.ts
+var en_US_default4 = {};
+// src/locale/function-list/date/en-US.ts
+var en_US_default5 = {};
+// src/locale/function-list/engineering/en-US.ts
+var en_US_default6 = {};
+// src/locale/function-list/financial/en-US.ts
+var en_US_default7 = {};
+// src/locale/function-list/information/en-US.ts
+var en_US_default8 = {};
+// src/locale/function-list/logical/en-US.ts
+var en_US_default9 = {};
+// src/locale/function-list/lookup/en-US.ts
+var en_US_default10 = {};
+// src/locale/function-list/math/en-US.ts
+var en_US_default11 = {
+    SUM: {
+        description: "You can add individual values, cell references or ranges or a mix of all three.",
+        abstract: "Adds its arguments",
+        functionParameter: {
+            number1: {
+                name: "number1",
+                detail: "The first number you want to add. The number can be like 4, a cell reference like B6, or a cell range like B2:B8."
+            },
+            number2: {
+                name: "number2",
+                detail: "This is the second number you want to add. You can specify up to 255 numbers in this way."
+            }
+        }
+    },
+    SUMIF: {
+        description: "Sum the values in a range that meet criteria that you specify.",
+        abstract: "Adds the cells specified by a given criteria",
+        functionParameter: {
+            range: {
+                name: "range",
+                detail: "The range of cells that you want evaluated by criteria."
+            },
+            criteria: {
+                name: "criteria",
+                detail: "The criteria in the form of a number, expression, a cell reference, text, or a function that defines which cells will be added. Wildcard characters can be included - a question mark (?) to match any single character, an asterisk (*) to match any sequence of characters. If you want to find an actual question mark or asterisk, type a tilde (~) preceding the character."
+            },
+            sum_range: {
+                name: "sum_range",
+                detail: "The actual cells to add, if you want to add cells other than those specified in the range argument. If the sum_range argument is omitted, Excel adds the cells that are specified in the range argument (the same cells to which the criteria is applied)."
+            }
+        }
+    }
+};
+// src/locale/function-list/statistical/en-US.ts
+var en_US_default12 = {
+    AVERAGE: {
+        description: "Returns the average (arithmetic mean) of the arguments.",
+        abstract: "Returns the average of its arguments",
+        functionParameter: {
+            number1: {
+                name: "number1",
+                detail: "The first number, cell reference, or range for which you want the average."
+            },
+            number2: {
+                name: "number2",
+                detail: "Additional numbers, cell references or ranges for which you want the average, up to a maximum of 255."
+            }
+        }
+    },
+    COUNT: {
+        description: "Counts the number of cells that contain numbers, and counts numbers within the list of arguments.",
+        abstract: "Counts how many numbers are in the list of arguments",
+        functionParameter: {
+            value1: {
+                name: "value1",
+                detail: "The first item, cell reference, or range within which you want to count numbers."
+            },
+            value2: {
+                name: "value2",
+                detail: "Up to 255 additional items, cell references, or ranges within which you want to count numbers."
+            }
+        }
+    },
+    MAX: {
+        description: "Returns the largest value in a set of values.",
+        abstract: "Returns the maximum value in a list of arguments",
+        functionParameter: {
+            number1: {
+                name: "number1",
+                detail: "The first number, cell reference, or range to calculate the maximum value from."
+            },
+            number2: {
+                name: "number2",
+                detail: "Additional numbers, cell references or ranges to calculate the maximum value from, up to a maximum of 255."
+            }
+        }
+    },
+    MIN: {
+        description: "Returns the smallest number in a set of values.",
+        abstract: "Returns the minimum value in a list of arguments",
+        functionParameter: {
+            number1: {
+                name: "number1",
+                detail: "The first number, cell reference, or range to calculate the minimum value from."
+            },
+            number2: {
+                name: "number2",
+                detail: "Additional numbers, cell references or ranges to calculate the minimum value from, up to a maximum of 255."
+            }
+        }
+    }
+};
+// src/locale/function-list/text/en-US.ts
+var en_US_default13 = {};
+// src/locale/function-list/univer/en-US.ts
+var en_US_default14 = {};
+// src/locale/function-list/web/en-US.ts
+var en_US_default15 = {};
+// src/locale/en-US.ts
+var en_US_default16 = {
+    formula: {
+        insert: {
+            tooltip: "Functions",
+            sum: "SUM",
+            average: "AVERAGE",
+            count: "COUNT",
+            max: "MAX",
+            min: "MIN",
+            more: "More Functions..."
+        },
+        functionList: _object_spread({}, en_US_default7, en_US_default5, en_US_default11, en_US_default12, en_US_default10, en_US_default4, en_US_default13, en_US_default9, en_US_default8, en_US_default6, en_US_default3, en_US_default2, en_US_default15, en_US_default, en_US_default14),
+        prompt: {
+            helpExample: "EXAMPLE",
+            helpAbstract: "ABOUT",
+            required: "Required.",
+            optional: "Optional."
+        },
+        functionType: {
+            financial: "Financial",
+            date: "Date & Time",
+            math: "Math & Trig",
+            statistical: "Statistical",
+            lookup: "Lookup & Reference",
+            database: "Database",
+            text: "Text",
+            logical: "Logical",
+            information: "Information",
+            engineering: "Engineering",
+            cube: "Cube",
+            compatibility: "Compatibility",
+            web: "Web",
+            array: "Array",
+            univer: "Univer"
+        },
+        moreFunctions: {
+            confirm: "Confirm",
+            prev: "Previous",
+            next: "Next",
+            searchFunctionPlaceholder: "Search function",
+            allFunctions: "All Functions",
+            syntax: "SYNTAX"
+        }
+    }
+};
+// src/locale/function-list/array/zh-CN.ts
+var zh_CN_default = {};
+// src/locale/function-list/compatibility/zh-CN.ts
+var zh_CN_default2 = {};
+// src/locale/function-list/cube/zh-CN.ts
+var zh_CN_default3 = {};
+// src/locale/function-list/database/zh-CN.ts
+var zh_CN_default4 = {};
+// src/locale/function-list/date/zh-CN.ts
+var zh_CN_default5 = {};
+// src/locale/function-list/engineering/zh-CN.ts
+var zh_CN_default6 = {};
+// src/locale/function-list/financial/zh-CN.ts
+var zh_CN_default7 = {};
+// src/locale/function-list/information/zh-CN.ts
+var zh_CN_default8 = {};
+// src/locale/function-list/logical/zh-CN.ts
+var zh_CN_default9 = {};
+// src/locale/function-list/lookup/zh-CN.ts
+var zh_CN_default10 = {};
+// src/locale/function-list/math/zh-CN.ts
+var zh_CN_default11 = {
+    SUM: {
+        description: "将单个值、单元格引用或是区域相加，或者将三者的组合相加。",
+        abstract: "求参数的和",
+        functionParameter: {
+            number1: {
+                name: "数值1",
+                detail: "要相加的第一个数字。 该数字可以是 4 之类的数字，B6 之类的单元格引用或 B2:B8 之类的单元格范围。"
+            },
+            number2: {
+                name: "数值2",
+                detail: "这是要相加的第二个数字。 可以按照这种方式最多指定 255 个数字。"
+            }
+        }
+    },
+    SUMIF: {
+        description: "对范围中符合指定条件的值求和。",
+        abstract: "按给定条件对指定单元格求和",
+        functionParameter: {
+            range: {
+                name: "范围",
+                detail: "要根据条件进行检测的范围。"
+            },
+            criteria: {
+                name: "条件",
+                detail: "以数字、表达式、单元格引用、文本或函数的形式来定义将添加哪些单元格。可包括的通配符字符 - 问号（？）以匹配任意单个字符，星号（*）以匹配任意字符序列。 如果要查找实际的问号或星号，请在该字符前键入波形符（~）。"
+            },
+            sum_range: {
+                name: "求和范围",
+                detail: "要添加的实际单元格，如果要添加在范围参数指定以外的其他单元格。 如果省略sum_range参数，Excel就会添加范围参数中指定的单元格（与应用标准的单元格相同）。"
+            }
+        }
+    }
+};
+// src/locale/function-list/statistical/zh-CN.ts
+var zh_CN_default12 = {
+    AVERAGE: {
+        description: "返回参数的平均值（算术平均值）。",
+        abstract: "返回参数平均值",
+        functionParameter: {
+            number1: {
+                name: "数值1",
+                detail: "要计算平均值的第一个数字、单元格引用或单元格区域。"
+            },
+            number2: {
+                name: "数值2",
+                detail: "要计算平均值的其他数字、单元格引用或单元格区域，最多可包含 255 个。"
+            }
+        }
+    },
+    COUNT: {
+        description: "计算包含数字的单元格个数以及参数列表中数字的个数。",
+        abstract: "计算参数列表中数字的个数",
+        functionParameter: {
+            value1: {
+                name: "值1",
+                detail: "要计算其中数字的个数的第一项、单元格引用或区域。"
+            },
+            value2: {
+                name: "值2",
+                detail: "要计算其中数字的个数的其他项、单元格引用或区域，最多可包含 255 个。"
+            }
+        }
+    },
+    MAX: {
+        description: "返回一组值中的最大值。",
+        abstract: "返回参数列表中的最大值",
+        functionParameter: {
+            number1: {
+                name: "数值1",
+                detail: "要计算最大值的第一个数字、单元格引用或单元格区域。"
+            },
+            number2: {
+                name: "数值2",
+                detail: "要计算最大值的其他数字、单元格引用或单元格区域，最多可包含 255 个。"
+            }
+        }
+    },
+    MIN: {
+        description: "返回一组值中的最小值。",
+        abstract: "返回参数列表中的最小值",
+        functionParameter: {
+            number1: {
+                name: "数值1",
+                detail: "要计算最小值的第一个数字、单元格引用或单元格区域。"
+            },
+            number2: {
+                name: "数值2",
+                detail: "要计算最小值的其他数字、单元格引用或单元格区域，最多可包含 255 个。"
+            }
+        }
+    }
+};
+// src/locale/function-list/text/zh-CN.ts
+var zh_CN_default13 = {};
+// src/locale/function-list/univer/zh-CN.ts
+var zh_CN_default14 = {};
+// src/locale/function-list/web/zh-CN.ts
+var zh_CN_default15 = {};
+// src/locale/zh-CN.ts
+var zh_CN_default16 = {
+    formula: {
+        insert: {
+            tooltip: "函数",
+            sum: "求和",
+            average: "平均值",
+            count: "计数",
+            max: "最大值",
+            min: "最小值",
+            more: "更多函数..."
+        },
+        functionList: _object_spread({}, zh_CN_default7, zh_CN_default5, zh_CN_default11, zh_CN_default12, zh_CN_default10, zh_CN_default4, zh_CN_default13, zh_CN_default9, zh_CN_default8, zh_CN_default6, zh_CN_default3, zh_CN_default2, zh_CN_default15, zh_CN_default, zh_CN_default14),
+        prompt: {
+            helpExample: "示例",
+            helpAbstract: "简介",
+            required: "必需。",
+            optional: "可选。"
+        },
+        functionType: {
+            financial: "财务",
+            date: "日期与时间",
+            math: "数学与三角函数",
+            statistical: "统计",
+            lookup: "查找与引用",
+            database: "数据库",
+            text: "文本",
+            logical: "逻辑",
+            information: "信息",
+            engineering: "工程",
+            cube: "多维数据集",
+            compatibility: "兼容性",
+            web: "Web",
+            array: "数组",
+            univer: "Univer"
+        },
+        moreFunctions: {
+            confirm: "应用",
+            prev: "上一步",
+            next: "下一步",
+            searchFunctionPlaceholder: "搜索函数",
+            allFunctions: "全部函数",
+            syntax: "语法"
+        }
+    }
+};
+// src/formula-ui-plugin.ts
+var FormulaUIPlugin = (_class = /*#__PURE__*/ function(_superClass) {
+    _inherits(_class, _superClass);
+    var _super = _create_super(_class);
+    function _class(_config, _injector, _localeService, _currentUniverService) {
+        _class_call_check(this, _class);
+        var _this;
+        _this = _super.call(this, FORMULA_UI_PLUGIN_NAME);
+        _this._config = _config;
+        _this._injector = _injector;
+        _this._localeService = _localeService;
+        _this._currentUniverService = _currentUniverService;
+        return _this;
+    }
+    _create_class(_class, [
+        {
+            key: "initialize",
+            value: function initialize() {
+                var _this = this;
+                this._localeService.load({
+                    enUS: en_US_default16
+                });
+                var dependencies = [
+                    // services
+                    [
+                        IFormulaPromptService,
+                        {
+                            useClass: FormulaPromptService
+                        }
+                    ],
+                    [
+                        IFormulaInputService,
+                        {
+                            useClass: FormulaInputService
+                        }
+                    ],
+                    [
+                        IDescriptionService,
+                        {
+                            useFactory: function() {
+                                var _this__config;
+                                return _this._injector.createInstance(DescriptionService, ((_this__config = _this._config) === null || _this__config === void 0 ? void 0 : _this__config.description) || []);
+                            }
+                        }
+                    ],
+                    // controllers
+                    [
+                        FormulaUIController
+                    ],
+                    [
+                        PromptController
+                    ],
+                    [
+                        FormulaInputController
+                    ],
+                    [
+                        FormulaAutoFillController
+                    ]
+                ];
+                dependencies.forEach(function(dependency) {
+                    return _this._injector.add(dependency);
+                });
+            }
+        },
+        {
+            key: "onReady",
+            value: function onReady() {
+                this.initialize();
+            }
+        }
+    ]);
+    return _class;
+}(_import_core17_Plugin = import_core17.Plugin), _define_property(_class, "type", import_core17.PluginType.Sheet), _class);
+FormulaUIPlugin = __decorateClass([
+    __decorateParam(1, (0, import_redi8.Inject)(import_redi8.Injector)),
+    __decorateParam(2, (0, import_redi8.Inject)(import_core17.LocaleService)),
+    __decorateParam(3, import_core17.IUniverInstanceService)
+], FormulaUIPlugin);