@univerjs/sheets-numfmt 0.1.0-alpha.1

package/lib/esm/index.js

@@ -0,0 +1,2832 @@
+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 _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+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 _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+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 ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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 _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
+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 _class;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = function(decorators, target, key2, kind) {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key2) : target;
+    for(var i = decorators.length - 1, decorator; i >= 0; i--)if (decorator = decorators[i]) result = (kind ? decorator(target, key2, result) : decorator(result)) || result;
+    if (kind && result) __defProp(target, key2, result);
+    return result;
+};
+var __decorateParam = function(index, decorator) {
+    return function(target, key2) {
+        return decorator(target, key2, index);
+    };
+};
+// src/numfmt-plugin.ts
+import { Plugin, PluginType } from "@univerjs/core";
+import { Inject as Inject6, Injector as Injector5 } from "@wendellhu/redi";
+// src/base/const/PLUGIN_NAME.ts
+var SHEET_NUMFMT_PLUGIN = "SHEET_NUMFMT_PLUGIN";
+// src/controllers/numfmt.controller.ts
+import { CellValueType, Disposable, DisposableCollection, ICommandService as ICommandService5, IUniverInstanceService as IUniverInstanceService5, LifecycleStages as LifecycleStages2, LocaleService as LocaleService6, LocaleType, ObjectMatrix, OnLifecycle, Range as Range4, Rectangle, ThemeService, toDisposable } from "@univerjs/core";
+import { IRenderManagerService } from "@univerjs/engine-render";
+import { ClearSelectionAllCommand, ClearSelectionFormatCommand, factorySetNumfmtUndoMutation as factorySetNumfmtUndoMutation2, INTERCEPTOR_POINT, INumfmtService as INumfmtService4, SelectionManagerService as SelectionManagerService5, SetNumfmtMutation as SetNumfmtMutation2, SheetInterceptorService } from "@univerjs/sheets";
+import { APPLY_TYPE, getRepeatRange, IAutoFillService, SheetSkeletonManagerService } from "@univerjs/sheets-ui";
+import { ComponentManager, IMenuService, ISidebarService } from "@univerjs/ui";
+import { Inject as Inject2, Injector } from "@wendellhu/redi";
+import { combineLatest, merge, Observable as Observable2 } from "rxjs";
+import { debounceTime, distinctUntilChanged, map, switchMap, tap } from "rxjs/operators";
+// src/commands/commands/add.decimal.command.ts
+import { CommandType as CommandType2, ICommandService as ICommandService2, IUniverInstanceService as IUniverInstanceService2, Range } from "@univerjs/core";
+import { INumfmtService, SelectionManagerService } from "@univerjs/sheets";
+// src/utils/decimal.ts
+import numfmt from "@univerjs/engine-numfmt";
+var getDecimalFromPattern = function(pattern) {
+    var defaultValue = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0;
+    if (!pattern) {
+        return defaultValue;
+    }
+    var info = numfmt.getInfo(pattern);
+    var _info_maxDecimals;
+    return (_info_maxDecimals = info.maxDecimals) !== null && _info_maxDecimals !== void 0 ? _info_maxDecimals : defaultValue;
+};
+var isPatternEqualWithoutDecimal = function(patternA, patternB) {
+    if (patternA && !patternB || !patternA && patternB) {
+        return false;
+    }
+    var getString = function(tokens) {
+        return tokens.reduce(function(pre, cur) {
+            if (pre.isEnd) {
+                return pre;
+            }
+            var str = cur.value || cur.num;
+            if (cur.type === "point") {
+                pre.isEnd = true;
+                return pre;
+            }
+            return _object_spread_props(_object_spread({}, pre), {
+                result: pre.result + str
+            });
+        }, {
+            isEnd: false,
+            result: ""
+        }).result;
+    };
+    var partitionsA = numfmt.getInfo(patternA)._partitions;
+    var partitionsB = numfmt.getInfo(patternB)._partitions;
+    var A1 = getString(partitionsA[0].tokens);
+    var B1 = getString(partitionsB[0].tokens);
+    var A2 = getString(partitionsA[1].tokens);
+    var B2 = getString(partitionsB[1].tokens);
+    return A1 === B1 && A2 === B2 && partitionsA[1].color === partitionsB[1].color;
+};
+var getDecimalString = function(length) {
+    return new Array(Math.min(Math.max(0, Number(length)), 30)).fill(0).join("");
+};
+var setPatternDecimal = function(patterns, decimalLength) {
+    var tokens = patterns.split(";").map(function(pattern) {
+        if (/\.0?/.test(pattern)) {
+            return pattern.replace(/\.0*/g, "".concat(decimalLength > 0 ? "." : "").concat(getDecimalString(Number(decimalLength || 0))));
+        }
+        if (/0([^0]?)|0$/.test(pattern)) {
+            return pattern.replace(/0([^0]+)|0$/, "0".concat(decimalLength > 0 ? "." : "").concat(getDecimalString(Number(decimalLength || 0)), "$1"));
+        }
+        return pattern;
+    });
+    return tokens.join(";");
+};
+var isPatternHasDecimal = function(pattern) {
+    return /\.0?/.test(pattern) || /0([^0]?)|0$/.test(pattern);
+};
+// src/commands/commands/set.numfmt.command.ts
+import { CommandType, ICommandService, IUndoRedoService, IUniverInstanceService } from "@univerjs/core";
+import { factorySetNumfmtUndoMutation, SetNumfmtMutation } from "@univerjs/sheets";
+var SetNumfmtCommand = {
+    id: "sheet.command.numfmt.set.numfmt",
+    type: CommandType.COMMAND,
+    handler: function(accessor, params) {
+        if (!params) {
+            return false;
+        }
+        var commandService = accessor.get(ICommandService);
+        var univerInstanceService = accessor.get(IUniverInstanceService);
+        var undoRedoService = accessor.get(IUndoRedoService);
+        var workbook = univerInstanceService.getCurrentUniverSheetInstance();
+        var workbookId = workbook.getUnitId();
+        var worksheet = workbook.getActiveSheet();
+        var worksheetId = worksheet.getSheetId();
+        var redoOption = _object_spread_props(_object_spread({}, params), {
+            workbookId: workbookId,
+            worksheetId: worksheetId
+        });
+        var undoOption = factorySetNumfmtUndoMutation(accessor, redoOption);
+        var result = commandService.syncExecuteCommand(SetNumfmtMutation.id, redoOption);
+        if (result) {
+            undoRedoService.pushUndoRedo({
+                unitID: workbookId,
+                undoMutations: [
+                    {
+                        id: SetNumfmtMutation.id,
+                        params: undoOption
+                    }
+                ],
+                redoMutations: [
+                    {
+                        id: SetNumfmtMutation.id,
+                        params: redoOption
+                    }
+                ]
+            });
+        }
+        return result;
+    }
+};
+// src/commands/commands/add.decimal.command.ts
+var AddDecimalCommand = {
+    id: "sheet.command.numfmt.add.decimal.command",
+    type: CommandType2.COMMAND,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor) {
+            var commandService, selectionManagerService, numfmtService, univerInstanceService, selections, workbook, sheet, workbookId, worksheetId, maxDecimals, decimals, pattern, values, result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        commandService = accessor.get(ICommandService2);
+                        selectionManagerService = accessor.get(SelectionManagerService);
+                        numfmtService = accessor.get(INumfmtService);
+                        univerInstanceService = accessor.get(IUniverInstanceService2);
+                        selections = selectionManagerService.getSelections();
+                        if (!selections || !selections.length) {
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        workbook = univerInstanceService.getCurrentUniverSheetInstance();
+                        sheet = workbook.getActiveSheet();
+                        workbookId = workbook.getUnitId();
+                        worksheetId = sheet.getSheetId();
+                        maxDecimals = 0;
+                        selections.forEach(function(selection) {
+                            Range.foreach(selection.range, function(row, col) {
+                                var numfmtValue = numfmtService.getValue(workbookId, worksheetId, row, col);
+                                if (!numfmtValue) {
+                                    return;
+                                }
+                                var decimals2 = getDecimalFromPattern(numfmtValue.pattern);
+                                maxDecimals = decimals2 > maxDecimals ? decimals2 : maxDecimals;
+                            });
+                        });
+                        decimals = maxDecimals + 1;
+                        pattern = setPatternDecimal("0".concat(decimals > 0 ? ".0" : ""), decimals);
+                        values = [];
+                        selections.forEach(function(selection) {
+                            Range.foreach(selection.range, function(row, col) {
+                                var numfmtValue = numfmtService.getValue(workbookId, worksheetId, row, col);
+                                if (!numfmtValue || isPatternEqualWithoutDecimal(numfmtValue.pattern, "0.0")) {
+                                    values.push({
+                                        row: row,
+                                        col: col,
+                                        pattern: pattern
+                                    });
+                                } else {
+                                    var decimals2 = getDecimalFromPattern(numfmtValue.pattern);
+                                    var pattern2 = setPatternDecimal(numfmtValue.pattern, decimals2 + 1);
+                                    pattern2 !== numfmtValue.pattern && values.push({
+                                        row: row,
+                                        col: col,
+                                        pattern: pattern2
+                                    });
+                                }
+                            });
+                        });
+                        if (!values.length) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            commandService.executeCommand(SetNumfmtCommand.id, {
+                                values: values
+                            })
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            result
+                        ];
+                    case 2:
+                        return [
+                            2,
+                            false
+                        ];
+                }
+            });
+        });
+        return function(accessor) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/commands/commands/set.currency.command.ts
+import { CommandType as CommandType3, ICommandService as ICommandService3, Range as Range2 } from "@univerjs/core";
+import { SelectionManagerService as SelectionManagerService2 } from "@univerjs/sheets";
+// src/base/const/FORMATDETAIL.ts
+var DATEFMTLISG = [
+    {
+        label: "1930-08-05",
+        suffix: "yyyy-MM-dd"
+    },
+    {
+        label: "1930/08/05",
+        suffix: "yyyy/MM/dd"
+    },
+    {
+        label: "1930年08月05日",
+        suffix: 'yyyy"年"MM"月"dd"日"'
+    },
+    {
+        label: "08-05",
+        suffix: "MM-dd"
+    },
+    {
+        label: "8月5日",
+        suffix: 'M"月"d"日"'
+    },
+    {
+        label: "13:30:30",
+        suffix: "h:mm:ss"
+    },
+    {
+        label: "13:30",
+        suffix: "h:mm"
+    },
+    {
+        label: "下午01:30",
+        suffix: "A/P hh:mm"
+    },
+    {
+        label: "下午1:30",
+        suffix: "A/P h:mm"
+    },
+    {
+        label: "下午1:30:30",
+        suffix: "A/P h:mm:ss"
+    },
+    {
+        label: "08-05 下午 01:30",
+        suffix: "MM-dd A/P hh:mm"
+    }
+];
+var NUMBERFORMAT = [
+    {
+        label: "(1,235)",
+        suffix: "#,##0_);(#,##0)"
+    },
+    {
+        label: "(1,235) ",
+        suffix: "#,##0_);[Red](#,##0)",
+        color: "red"
+    },
+    {
+        label: "1,234.56",
+        suffix: "#,##0.00_);#,##0.00"
+    },
+    {
+        label: "1,234.56",
+        suffix: "#,##0.00_);[Red]#,##0.00",
+        color: "red"
+    },
+    {
+        label: "-1,234.56",
+        suffix: "#,##0.00_);-#,##0.00"
+    },
+    {
+        label: "-1,234.56",
+        suffix: "#,##0.00_);[Red]-#,##0.00",
+        color: "red"
+    }
+];
+var CURRENCYFORMAT = [
+    {
+        label: function(suffix) {
+            return "".concat(suffix, "1,235");
+        },
+        suffix: function(suffix) {
+            return '"'.concat(suffix, '"#,##0.00_);"').concat(suffix, '"#,##0.00');
+        }
+    },
+    {
+        label: function(suffix) {
+            return "".concat(suffix, "1,235");
+        },
+        suffix: function(suffix) {
+            return '"'.concat(suffix, '"#,##0.00_);[Red]"').concat(suffix, '"#,##0.00');
+        },
+        color: "red"
+    },
+    {
+        label: function(suffix) {
+            return "(".concat(suffix, "1,235)");
+        },
+        suffix: function(suffix) {
+            return '"'.concat(suffix, '"#,##0.00_);("').concat(suffix, '"#,##0.00)');
+        }
+    },
+    {
+        label: function(suffix) {
+            return "(".concat(suffix, "1,235)");
+        },
+        suffix: function(suffix) {
+            return '"'.concat(suffix, '"#,##0.00_);[Red]("').concat(suffix, '"#,##0.00)');
+        },
+        color: "red"
+    },
+    {
+        label: function(suffix) {
+            return "-".concat(suffix, "1,235");
+        },
+        suffix: function(suffix) {
+            return '"'.concat(suffix, '"#,##0.00_);-"').concat(suffix, '"#,##0.00');
+        }
+    },
+    {
+        label: function(suffix) {
+            return "-".concat(suffix, "1,235");
+        },
+        suffix: function(suffix) {
+            return '"'.concat(suffix, '"#,##0.00_);[Red]-"').concat(suffix, '"#,##0.00');
+        },
+        color: "red"
+    }
+];
+// src/commands/commands/set.currency.command.ts
+var SetCurrencyCommand = {
+    id: "sheet.command.numfmt.set.currency",
+    type: CommandType3.COMMAND,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor) {
+            var commandService, selectionManagerService, selections, values, suffix, result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        commandService = accessor.get(ICommandService3);
+                        selectionManagerService = accessor.get(SelectionManagerService2);
+                        selections = selectionManagerService.getSelections();
+                        if (!selections || !selections.length) {
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        values = [];
+                        suffix = CURRENCYFORMAT[0].suffix("\xa5");
+                        selections.forEach(function(selection) {
+                            Range2.foreach(selection.range, function(row, col) {
+                                values.push({
+                                    row: row,
+                                    col: col,
+                                    pattern: suffix,
+                                    type: "currency"
+                                });
+                            });
+                        });
+                        return [
+                            4,
+                            commandService.executeCommand(SetNumfmtCommand.id, {
+                                values: values
+                            })
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        });
+        return function(accessor) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/commands/commands/subtract.decimal.command.ts
+import { CommandType as CommandType4, ICommandService as ICommandService4, IUniverInstanceService as IUniverInstanceService3, Range as Range3 } from "@univerjs/core";
+import { INumfmtService as INumfmtService2, SelectionManagerService as SelectionManagerService3 } from "@univerjs/sheets";
+var SubtractDecimalCommand = {
+    id: "sheet.command.numfmt.subtract.decimal.command",
+    type: CommandType4.COMMAND,
+    handler: function() {
+        var _ref = _async_to_generator(function(accessor) {
+            var commandService, selectionManagerService, numfmtService, univerInstanceService, selections, workbook, sheet, workbookId, worksheetId, maxDecimals, decimals, pattern, values, result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        commandService = accessor.get(ICommandService4);
+                        selectionManagerService = accessor.get(SelectionManagerService3);
+                        numfmtService = accessor.get(INumfmtService2);
+                        univerInstanceService = accessor.get(IUniverInstanceService3);
+                        selections = selectionManagerService.getSelections();
+                        if (!selections || !selections.length) {
+                            return [
+                                2,
+                                false
+                            ];
+                        }
+                        workbook = univerInstanceService.getCurrentUniverSheetInstance();
+                        sheet = workbook.getActiveSheet();
+                        workbookId = workbook.getUnitId();
+                        worksheetId = sheet.getSheetId();
+                        maxDecimals = 0;
+                        selections.forEach(function(selection) {
+                            Range3.foreach(selection.range, function(row, col) {
+                                var numfmtValue = numfmtService.getValue(workbookId, worksheetId, row, col);
+                                if (!numfmtValue) {
+                                    return;
+                                }
+                                var decimals2 = getDecimalFromPattern(numfmtValue.pattern);
+                                maxDecimals = decimals2 > maxDecimals ? decimals2 : maxDecimals;
+                            });
+                        });
+                        decimals = maxDecimals - 1;
+                        pattern = setPatternDecimal("0".concat(decimals > 0 ? ".0" : "."), decimals);
+                        values = [];
+                        selections.forEach(function(selection) {
+                            Range3.foreach(selection.range, function(row, col) {
+                                var numfmtValue = numfmtService.getValue(workbookId, worksheetId, row, col);
+                                if (!numfmtValue || isPatternEqualWithoutDecimal(numfmtValue.pattern, "0.0")) {
+                                    values.push({
+                                        row: row,
+                                        col: col,
+                                        pattern: pattern
+                                    });
+                                } else {
+                                    var decimals2 = getDecimalFromPattern(numfmtValue.pattern);
+                                    values.push({
+                                        row: row,
+                                        col: col,
+                                        pattern: setPatternDecimal(numfmtValue.pattern, decimals2 - 1)
+                                    });
+                                }
+                            });
+                        });
+                        return [
+                            4,
+                            commandService.executeCommand(SetNumfmtCommand.id, {
+                                values: values
+                            })
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        });
+        return function(accessor) {
+            return _ref.apply(this, arguments);
+        };
+    }()
+};
+// src/commands/operators/close.numfmt.panel.operator.ts
+import { CommandType as CommandType5 } from "@univerjs/core";
+var CloseNumfmtPanelOperator = {
+    id: "sheet.operation.close.numfmt.panel",
+    type: CommandType5.OPERATION,
+    handler: function() {
+        return(// do nothing,just notify panel is closed
+        true);
+    }
+};
+// src/commands/operators/open.numfmt.panel.operator.ts
+import { CommandType as CommandType6 } from "@univerjs/core";
+// src/controllers/type.ts
+import { LifecycleStages, runOnLifecycle } from "@univerjs/core";
+import { createIdentifier } from "@wendellhu/redi";
+var INumfmtController = createIdentifier("INumfmtController");
+runOnLifecycle(LifecycleStages.Rendered, INumfmtController);
+// src/commands/operators/open.numfmt.panel.operator.ts
+var OpenNumfmtPanelOperator = {
+    id: "sheet.operation.open.numfmt.panel",
+    type: CommandType6.OPERATION,
+    handler: function(accessor) {
+        var numfmtController = accessor.get(INumfmtController);
+        numfmtController.openPanel();
+        return true;
+    }
+};
+// src/components/index.tsx
+import { LocaleService as LocaleService5 } from "@univerjs/core";
+import { Button, Select as Select3 } from "@univerjs/design";
+import { useDependency as useDependency6 } from "@wendellhu/redi/react-bindings";
+import React6, { useEffect as useEffect3, useMemo as useMemo5, useRef as useRef2, useState as useState7 } from "react";
+// src/context/user-habit.ts
+import { createContext } from "react";
+var UserHabitCurrencyContext = createContext([]);
+// src/hooks/useCurrencyOptions.ts
+import { useDependency } from "@wendellhu/redi/react-bindings";
+import { useEffect, useState } from "react";
+// src/base/const/CURRENCY-SYMBOLS.ts
+var currencySymbols = [
+    "$",
+    "\xa3",
+    "\xa5",
+    "\xa4",
+    "֏",
+    "؋",
+    "৳",
+    "฿",
+    // '៛',
+    "₡",
+    "₦",
+    "₩",
+    "₪",
+    "₫",
+    "€",
+    "₭",
+    "₮",
+    "₱",
+    "₲",
+    "₴",
+    "₸",
+    "₹",
+    "₺",
+    "₼",
+    "₽",
+    "₾",
+    "₿"
+];
+// src/controllers/user-habit.controller.ts
+import { ILocalStorageService } from "@univerjs/core";
+import { Inject } from "@wendellhu/redi";
+var UserHabitController = /*#__PURE__*/ function() {
+    "use strict";
+    function UserHabitController(_localStorageService) {
+        _class_call_check(this, UserHabitController);
+        this._localStorageService = _localStorageService;
+    }
+    _create_class(UserHabitController, [
+        {
+            key: "_getKey",
+            value: function _getKey(habit) {
+                return "userHabitController_".concat(habit);
+            }
+        },
+        {
+            key: "addHabit",
+            value: function addHabit(habit, initValue) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var key2;
+                    return _ts_generator(this, function(_state) {
+                        key2 = _this._getKey(habit);
+                        return [
+                            2,
+                            _this._localStorageService.getItem(key2).then(function(item) {
+                                if (!item) {
+                                    _this._localStorageService.setItem(key2, initValue);
+                                }
+                            })
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "markHabit",
+            value: function markHabit(habit, value) {
+                var _this = this;
+                var key2 = this._getKey(habit);
+                this._localStorageService.getItem(key2).then(function(list) {
+                    if (list) {
+                        var index = list.findIndex(function(item) {
+                            return item === value;
+                        });
+                        index > -1 && list.splice(index, 1);
+                        list.unshift(value);
+                        _this._localStorageService.setItem(key2, list);
+                    }
+                });
+            }
+        },
+        {
+            key: "getHabit",
+            value: function getHabit(habit, sortList) {
+                var _this = this;
+                return _async_to_generator(function() {
+                    var key2, result, priority;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                key2 = _this._getKey(habit);
+                                return [
+                                    4,
+                                    _this._localStorageService.getItem(key2)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                if (sortList && result) {
+                                    priority = result.map(function(item, index, arr) {
+                                        var length = arr.length;
+                                        return {
+                                            value: item,
+                                            priority: length - index
+                                        };
+                                    });
+                                    return [
+                                        2,
+                                        sortList.sort(function(a, b) {
+                                            var _priority_find, _priority_find1;
+                                            var ap = ((_priority_find = priority.find(function(item) {
+                                                return item.value === a;
+                                            })) === null || _priority_find === void 0 ? void 0 : _priority_find.priority) || -1;
+                                            var bp = ((_priority_find1 = priority.find(function(item) {
+                                                return item.value === b;
+                                            })) === null || _priority_find1 === void 0 ? void 0 : _priority_find1.priority) || -1;
+                                            return bp - ap;
+                                        })
+                                    ];
+                                }
+                                return [
+                                    2,
+                                    result || []
+                                ];
+                        }
+                    });
+                })();
+            }
+        },
+        {
+            key: "deleteHabit",
+            value: function deleteHabit(habit) {
+                this._localStorageService.removeItem(habit);
+            }
+        }
+    ]);
+    return UserHabitController;
+}();
+UserHabitController = __decorateClass([
+    __decorateParam(0, Inject(ILocalStorageService))
+], UserHabitController);
+// src/hooks/useCurrencyOptions.ts
+var key = "numfmtCurrency";
+var useCurrencyOptions = function(onOptionChange) {
+    var userHabitController = useDependency(UserHabitController);
+    var _useState = _sliced_to_array(useState(currencySymbols), 2), options = _useState[0], optionsSet = _useState[1];
+    useEffect(function() {
+        userHabitController.addHabit("numfmtCurrency", []).then(function() {
+            userHabitController.getHabit(key, _to_consumable_array(currencySymbols)).then(function(list) {
+                optionsSet(list);
+                onOptionChange && onOptionChange(list);
+            });
+        });
+    }, []);
+    var mark = function(v) {
+        userHabitController.markHabit(key, v);
+    };
+    return {
+        userHabitCurrency: options,
+        mark: mark
+    };
+};
+// src/hooks/useNextTick.ts
+import { useEffect as useEffect2, useRef, useState as useState2 } from "react";
+var useNextTick = function() {
+    var effectList = useRef([]);
+    var _useState2 = _sliced_to_array(useState2({}), 2), value = _useState2[0], dispatch = _useState2[1];
+    useEffect2(function() {
+        effectList.current.forEach(function(fn) {
+            fn();
+        });
+        effectList.current = [];
+    }, [
+        value
+    ]);
+    var nextTick = function(fn) {
+        effectList.current.push(fn);
+        dispatch({});
+    };
+    return nextTick;
+};
+// src/utils/currency.ts
+var getCurrencyType = function(pattern) {
+    var item = currencySymbols.find(function(code) {
+        return pattern.includes(code);
+    });
+    return item;
+};
+// src/components/accounting/index.tsx
+import { LocaleService } from "@univerjs/core";
+import { InputNumber, Select } from "@univerjs/design";
+import { useDependency as useDependency2 } from "@wendellhu/redi/react-bindings";
+import React, { useContext, useMemo, useState as useState3 } from "react";
+var isAccountingPanel = function(pattern) {
+    var type = getCurrencyType(pattern);
+    return !!type && pattern.startsWith("_(");
+};
+var AccountingPanel = function(props) {
+    var _useState3 = _sliced_to_array(useState3(function() {
+        return getDecimalFromPattern(props.defaultPattern || "", 2);
+    }), 2), decimal = _useState3[0], decimalSet = _useState3[1];
+    var userHabitCurrency = useContext(UserHabitCurrencyContext);
+    var _useState31 = _sliced_to_array(useState3(function() {
+        return getCurrencyType(props.defaultPattern) || userHabitCurrency[0];
+    }), 2), suffix = _useState31[0], suffixSet = _useState31[1];
+    var options = useMemo(function() {
+        return userHabitCurrency.map(function(key2) {
+            return {
+                label: key2,
+                value: key2
+            };
+        });
+    }, []);
+    var localeService = useDependency2(LocaleService);
+    var t = localeService.t;
+    props.action.current = function() {
+        return setPatternDecimal('_("'.concat(suffix, '"* #,##0').concat(decimal > 0 ? ".0" : "", "_)"), decimal);
+    };
+    var onSelect = function(v) {
+        suffixSet(v);
+        props.onChange(setPatternDecimal('_("'.concat(v, '"* #,##0').concat(decimal > 0 ? ".0" : "", "_)"), decimal));
+    };
+    var onDecimalChange = function(v) {
+        var decimal2 = v || 0;
+        decimalSet(decimal2);
+        props.onChange(setPatternDecimal('_("'.concat(suffix, '"* #,##0').concat(decimal2 > 0 ? ".0" : "", "_)"), decimal2));
+    };
+    return /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement("div", {
+        className: "m-t-16 options "
+    }, /* @__PURE__ */ React.createElement("div", {
+        className: "option"
+    }, /* @__PURE__ */ React.createElement("div", {
+        className: "label"
+    }, t("sheet.numfmt.decimalLength")), /* @__PURE__ */ React.createElement("div", {
+        className: "m-t-8 w-120"
+    }, /* @__PURE__ */ React.createElement(InputNumber, {
+        value: decimal,
+        max: 20,
+        min: 0,
+        onChange: onDecimalChange
+    }))), /* @__PURE__ */ React.createElement("div", {
+        className: "option"
+    }, /* @__PURE__ */ React.createElement("div", {
+        className: "label"
+    }, t("sheet.numfmt.currencyType")), /* @__PURE__ */ React.createElement("div", {
+        className: "m-t-8 w-140"
+    }, /* @__PURE__ */ React.createElement(Select, {
+        onChange: onSelect,
+        options: options,
+        value: suffix
+    })))), /* @__PURE__ */ React.createElement("div", {
+        className: "describe m-t-14"
+    }, t("sheet.numfmt.accountingDes")));
+};
+// src/components/currency/index.tsx
+import { LocaleService as LocaleService2 } from "@univerjs/core";
+import { InputNumber as InputNumber2, Select as Select2, SelectList } from "@univerjs/design";
+import { useDependency as useDependency3 } from "@wendellhu/redi/react-bindings";
+import React2, { useContext as useContext2, useMemo as useMemo2, useState as useState4 } from "react";
+// src/utils/options.ts
+var getCurrencyFormatOptions = function(suffix) {
+    return CURRENCYFORMAT.map(function(item) {
+        return {
+            label: item.label(suffix),
+            value: item.suffix(suffix),
+            color: item.color
+        };
+    });
+};
+var getDateFormatOptions = function() {
+    return DATEFMTLISG.map(function(item) {
+        return {
+            label: item.label,
+            value: item.suffix
+        };
+    });
+};
+var getNumberFormatOptions = function() {
+    return NUMBERFORMAT.map(function(item) {
+        return {
+            label: item.label,
+            value: item.suffix,
+            color: item.color
+        };
+    });
+};
+// src/components/currency/index.tsx
+var isCurrencyPanel = function(pattern) {
+    var type = getCurrencyType(pattern);
+    return !!type && !pattern.startsWith("_(");
+};
+var CurrencyPanel = function(props) {
+    var localeService = useDependency3(LocaleService2);
+    var t = localeService.t;
+    var userHabitCurrency = useContext2(UserHabitCurrencyContext);
+    var _useState4 = _sliced_to_array(useState4(function() {
+        return getCurrencyType(props.defaultPattern) || userHabitCurrency[0];
+    }), 2), suffix = _useState4[0], suffixSet = _useState4[1];
+    var _useState41 = _sliced_to_array(useState4(function() {
+        return getDecimalFromPattern(props.defaultPattern || "", 2);
+    }), 2), decimal = _useState41[0], decimalSet = _useState41[1];
+    var _useState42 = _sliced_to_array(useState4(function() {
+        var _negativeOptions2_find;
+        var negativeOptions2 = getCurrencyFormatOptions(suffix);
+        var pattern2 = ((_negativeOptions2_find = negativeOptions2.find(function(item) {
+            return isPatternEqualWithoutDecimal(item.value, props.defaultPattern);
+        })) === null || _negativeOptions2_find === void 0 ? void 0 : _negativeOptions2_find.value) || negativeOptions2[0].value;
+        return pattern2;
+    }), 2), pattern = _useState42[0], patternSet = _useState42[1];
+    var negativeOptions = useMemo2(function() {
+        return getCurrencyFormatOptions(suffix);
+    }, [
+        suffix
+    ]);
+    var options = useMemo2(function() {
+        return userHabitCurrency.map(function(key2) {
+            return {
+                label: key2,
+                value: key2
+            };
+        });
+    }, [
+        userHabitCurrency
+    ]);
+    props.action.current = function() {
+        return setPatternDecimal(pattern, decimal);
+    };
+    var onSelect = function(value) {
+        suffixSet(value);
+        var pattern2 = getCurrencyFormatOptions(value)[0].value;
+        patternSet(pattern2);
+        props.onChange(setPatternDecimal(pattern2, decimal));
+    };
+    var onChange = function(value) {
+        patternSet(value);
+        props.onChange(setPatternDecimal(value, decimal));
+    };
+    var onDecimalChange = function(v) {
+        decimalSet(v || 0);
+        props.onChange(setPatternDecimal(pattern, v || 0));
+    };
+    return /* @__PURE__ */ React2.createElement("div", null, /* @__PURE__ */ React2.createElement("div", {
+        className: "m-t-16 options "
+    }, /* @__PURE__ */ React2.createElement("div", {
+        className: "option"
+    }, /* @__PURE__ */ React2.createElement("div", {
+        className: "label"
+    }, t("sheet.numfmt.decimalLength")), /* @__PURE__ */ React2.createElement("div", {
+        className: "m-t-8 w-120"
+    }, /* @__PURE__ */ React2.createElement(InputNumber2, {
+        value: decimal,
+        max: 20,
+        min: 0,
+        onChange: onDecimalChange
+    }))), /* @__PURE__ */ React2.createElement("div", {
+        className: "option"
+    }, /* @__PURE__ */ React2.createElement("div", {
+        className: "label"
+    }, " ", t("sheet.numfmt.currencyType")), /* @__PURE__ */ React2.createElement("div", {
+        className: "m-t-8 w-140"
+    }, /* @__PURE__ */ React2.createElement(Select2, {
+        onChange: onSelect,
+        options: options,
+        value: suffix
+    })))), /* @__PURE__ */ React2.createElement("div", {
+        className: "m-t-16 label"
+    }, " ", t("sheet.numfmt.negType")), /* @__PURE__ */ React2.createElement("div", {
+        className: "m-t-8"
+    }, /* @__PURE__ */ React2.createElement(SelectList, {
+        onChange: onChange,
+        options: negativeOptions,
+        value: pattern
+    })), /* @__PURE__ */ React2.createElement("div", {
+        className: "describe m-t-14"
+    }, t("sheet.numfmt.currencyDes")));
+};
+// src/components/date/index.tsx
+import { LocaleService as LocaleService3 } from "@univerjs/core";
+import { SelectList as SelectList2 } from "@univerjs/design";
+import numfmt2 from "@univerjs/engine-numfmt";
+import { useDependency as useDependency4 } from "@wendellhu/redi/react-bindings";
+import React3, { useMemo as useMemo3, useState as useState5 } from "react";
+var isDatePanel = function(pattern) {
+    var info = numfmt2.getInfo(pattern);
+    return getDateFormatOptions().map(function(item) {
+        return item.value;
+    }).includes(pattern) || [
+        "date",
+        "datetime",
+        "time"
+    ].includes(info.type);
+};
+var DatePanel = function(props) {
+    var options = useMemo3(getDateFormatOptions, []);
+    var localeService = useDependency4(LocaleService3);
+    var t = localeService.t;
+    var _useState5 = _sliced_to_array(useState5(function() {
+        if (props.defaultPattern) {
+            var item = options.find(function(item2) {
+                return item2.value === props.defaultPattern;
+            });
+            if (item) {
+                return item.value;
+            }
+        }
+        return options[0].value;
+    }), 2), suffix = _useState5[0], suffixSet = _useState5[1];
+    props.action.current = function() {
+        return suffix;
+    };
+    var onChange = function(v) {
+        suffixSet(v);
+        props.onChange(v);
+    };
+    return /* @__PURE__ */ React3.createElement("div", null, /* @__PURE__ */ React3.createElement("div", {
+        className: "m-t-16 label"
+    }, t("sheet.numfmt.dateType")), /* @__PURE__ */ React3.createElement("div", {
+        className: "m-t-8"
+    }, /* @__PURE__ */ React3.createElement(SelectList2, {
+        value: suffix,
+        options: options,
+        onChange: onChange
+    })), /* @__PURE__ */ React3.createElement("div", {
+        className: "describe m-t-14"
+    }, t("sheet.numfmt.dateDes")));
+};
+// src/components/general/index.tsx
+import { LocaleService as LocaleService4 } from "@univerjs/core";
+import { useDependency as useDependency5 } from "@wendellhu/redi/react-bindings";
+import React4 from "react";
+var isGeneralPanel = function(pattern) {
+    return !pattern;
+};
+var GeneralPanel = function(props) {
+    var localeService = useDependency5(LocaleService4);
+    var t = localeService.t;
+    props.action.current = function() {
+        return "";
+    };
+    return /* @__PURE__ */ React4.createElement("div", null, /* @__PURE__ */ React4.createElement("div", {
+        className: "describe m-t-14"
+    }, t("sheet.numfmt.generalDes")));
+};
+// src/components/thousandth-percentile/index.tsx
+import { InputNumber as InputNumber3, SelectList as SelectList3 } from "@univerjs/design";
+import React5, { useMemo as useMemo4, useState as useState6 } from "react";
+var isThousandthPercentilePanel = function(pattern) {
+    return getNumberFormatOptions().some(function(item) {
+        return isPatternEqualWithoutDecimal(item.value, pattern);
+    });
+};
+var ThousandthPercentilePanel = function(props) {
+    var options = useMemo4(getNumberFormatOptions, []);
+    var _useState6 = _sliced_to_array(useState6(function() {
+        return getDecimalFromPattern(props.defaultPattern || "", 0);
+    }), 2), decimal = _useState6[0], decimalSet = _useState6[1];
+    var _useState61 = _sliced_to_array(useState6(function() {
+        var item = options.find(function(item2) {
+            return isPatternEqualWithoutDecimal(item2.value, props.defaultPattern || "");
+        });
+        return (item === null || item === void 0 ? void 0 : item.value) || options[0].value;
+    }), 2), suffix = _useState61[0], suffixSet = _useState61[1];
+    var pattern = useMemo4(function() {
+        return setPatternDecimal(suffix, Number(decimal || 0));
+    }, [
+        suffix,
+        decimal
+    ]);
+    var isInputDisable = useMemo4(function() {
+        return !isPatternHasDecimal(suffix);
+    }, [
+        suffix
+    ]);
+    var handleClick = function(v) {
+        decimalSet(getDecimalFromPattern(v, 0));
+        suffixSet(v);
+    };
+    props.action.current = function() {
+        return pattern;
+    };
+    return /* @__PURE__ */ React5.createElement("div", null, /* @__PURE__ */ React5.createElement("div", {
+        className: "m-t-16 label"
+    }, "小数位数"), /* @__PURE__ */ React5.createElement("div", {
+        className: "m-t-8"
+    }, /* @__PURE__ */ React5.createElement(InputNumber3, {
+        disabled: isInputDisable,
+        value: decimal,
+        max: 20,
+        min: 0,
+        onChange: function(value) {
+            return decimalSet(value || 0);
+        }
+    })), /* @__PURE__ */ React5.createElement("div", {
+        className: "m-t-16 label"
+    }, " 负数类型"), /* @__PURE__ */ React5.createElement("div", {
+        className: "m-t-8"
+    }, /* @__PURE__ */ React5.createElement(SelectList3, {
+        onChange: handleClick,
+        options: options,
+        value: suffix
+    })), /* @__PURE__ */ React5.createElement("div", {
+        className: "describe m-t-14"
+    }, "数值格式用于一般数字的表示。货币和会计格式则提供货币值计算的专用格式。"));
+};
+// src/components/index.tsx
+var SheetNumfmtPanel = function(props) {
+    var findDefaultType = function findDefaultType() {
+        var list = [
+            isGeneralPanel,
+            isAccountingPanel,
+            isCurrencyPanel,
+            isDatePanel,
+            isThousandthPercentilePanel
+        ];
+        return list.reduce(function(pre, curFn, index) {
+            return pre || (curFn(defaultPattern) ? typeOptions[index].label : "");
+        }, "") || typeOptions[0].label;
+    };
+    var _props_value = props.value, defaultValue = _props_value.defaultValue, defaultPattern = _props_value.defaultPattern, row = _props_value.row, col = _props_value.col;
+    var localeService = useDependency6(LocaleService5);
+    var getCurrentPattern = useRef2(function() {
+        return "";
+    });
+    var t = localeService.t;
+    var nextTick = useNextTick();
+    var pattern = useRef2("");
+    var typeOptions = useMemo5(function() {
+        return [
+            {
+                label: "sheet.numfmt.general",
+                component: GeneralPanel
+            },
+            {
+                label: "sheet.numfmt.accounting",
+                component: AccountingPanel
+            },
+            {
+                label: "sheet.numfmt.currency",
+                component: CurrencyPanel
+            },
+            {
+                label: "sheet.numfmt.date",
+                component: DatePanel
+            },
+            {
+                label: "sheet.numfmt.thousandthPercentile",
+                component: ThousandthPercentilePanel
+            }
+        ].map(function(item) {
+            return _object_spread_props(_object_spread({}, item), {
+                label: t(item.label)
+            });
+        });
+    }, []);
+    var _useState7 = _sliced_to_array(useState7(findDefaultType), 2), type = _useState7[0], typeSet = _useState7[1];
+    var _useState71 = _sliced_to_array(useState7(function() {
+        return "".concat(row, "_").concat(col);
+    }), 2), key2 = _useState71[0], keySet = _useState71[1];
+    var _useCurrencyOptions = useCurrencyOptions(function() {
+        return keySet("".concat(row, "_").concat(col, "_userCurrency'"));
+    }), mark = _useCurrencyOptions.mark, userHabitCurrency = _useCurrencyOptions.userHabitCurrency;
+    var BusinessComponent = useMemo5(function() {
+        var _typeOptions_find;
+        return (_typeOptions_find = typeOptions.find(function(item) {
+            return item.label === type;
+        })) === null || _typeOptions_find === void 0 ? void 0 : _typeOptions_find.component;
+    }, [
+        type
+    ]);
+    var selectOptions = typeOptions.map(function(option) {
+        return {
+            label: option.label,
+            value: option.label
+        };
+    });
+    var handleSelect = function(value) {
+        typeSet(value);
+        nextTick(function() {
+            return props.onChange({
+                type: "change",
+                value: getCurrentPattern.current() || ""
+            });
+        });
+    };
+    var handleChange = function(v) {
+        pattern.current = v;
+        props.onChange({
+            type: "change",
+            value: v
+        });
+    };
+    var handleConfirm = function() {
+        var currency = getCurrencyType(pattern.current);
+        if (currency) {
+            mark(currency);
+        }
+        props.onChange({
+            type: "confirm",
+            value: pattern.current
+        });
+    };
+    var handleCancel = function() {
+        props.onChange({
+            type: "cancel",
+            value: pattern.current
+        });
+    };
+    var subProps = {
+        onChange: handleChange,
+        defaultValue: defaultValue,
+        defaultPattern: defaultPattern,
+        action: getCurrentPattern
+    };
+    useEffect3(function() {
+        typeSet(findDefaultType());
+        keySet("".concat(row, "_").concat(col));
+    }, [
+        row,
+        col
+    ]);
+    return /* @__PURE__ */ React6.createElement("div", {
+        className: "numfmt-panel p-b-20"
+    }, /* @__PURE__ */ React6.createElement("div", null, /* @__PURE__ */ React6.createElement("div", {
+        className: "label m-t-14"
+    }, t("sheet.numfmt.numfmtType")), /* @__PURE__ */ React6.createElement("div", {
+        className: "m-t-8"
+    }, /* @__PURE__ */ React6.createElement(Select3, {
+        onChange: handleSelect,
+        options: selectOptions,
+        value: type
+    })), /* @__PURE__ */ React6.createElement("div", null, BusinessComponent && /* @__PURE__ */ React6.createElement(UserHabitCurrencyContext.Provider, {
+        value: userHabitCurrency
+    }, /* @__PURE__ */ React6.createElement(BusinessComponent, _object_spread_props(_object_spread({}, subProps), {
+        key: key2
+    }))))), /* @__PURE__ */ React6.createElement("div", {
+        className: "btn-list m-t-14 m-b-20"
+    }, /* @__PURE__ */ React6.createElement(Button, {
+        size: "small",
+        onClick: handleCancel,
+        className: "m-r-12"
+    }, t("sheet.numfmt.cancel")), /* @__PURE__ */ React6.createElement(Button, {
+        type: "primary",
+        size: "small",
+        onClick: handleConfirm
+    }, t("sheet.numfmt.confirm"))));
+};
+// src/locale/zh-CN.ts
+var zhCn = {
+    sheet: {
+        numfmt: {
+            title: "数据格式",
+            numfmtType: "格式类型",
+            cancel: "取消",
+            confirm: "确认",
+            general: "常规",
+            accounting: "会计",
+            currency: "货币",
+            date: "日期",
+            thousandthPercentile: "千分位符",
+            preview: "示例",
+            decimalLength: "小数位数",
+            currencyType: "货币类型",
+            currencyDes: "货币格式用于表示一般货币数值。会计格式可以对一列数值进行小数点对齐",
+            accountingDes: "会计数字格式可对一列数值进行货币符号和小数点对齐",
+            dateType: "日期类型",
+            dateDes: "日期格式将日期和时间系列数值品示为日期值。",
+            negType: "负数类型",
+            generalDes: "常规格式不包含任何特定的数字格式。",
+            thousandthPercentileDes: "千分位符格式用于一般数字的表示。货币和会计格式则提供货币值计算的专用格式。"
+        }
+    }
+};
+// src/menu/menu.ts
+import { IUniverInstanceService as IUniverInstanceService4 } from "@univerjs/core";
+import { AddDigitsSingle, MoreDownSingle as MoreDownSingle2, ReduceDigitsSingle, RmbSingle } from "@univerjs/icons";
+import { INumfmtService as INumfmtService3, SelectionManagerService as SelectionManagerService4 } from "@univerjs/sheets";
+import { MenuGroup, MenuItemType, MenuPosition } from "@univerjs/ui";
+import { Observable } from "rxjs";
+// src/components/more-numfmt-type/MoreNumfmtType.tsx
+import { MoreDownSingle } from "@univerjs/icons";
+import React7 from "react";
+var MoreNumfmtType = function(props) {
+    var _props_value;
+    var value = (_props_value = props.value) !== null && _props_value !== void 0 ? _props_value : "常规";
+    return /* @__PURE__ */ React7.createElement("span", {
+        className: "more-numfmt-type"
+    }, value, /* @__PURE__ */ React7.createElement("div", {
+        className: "icon"
+    }, /* @__PURE__ */ React7.createElement(MoreDownSingle, null)));
+};
+// src/menu/menu.ts
+var CurrencyMenuItem = function(componentManager) {
+    var iconKey = "icon-rmbSingle";
+    componentManager.register(iconKey, RmbSingle);
+    componentManager.register("MoreDownSingle", MoreDownSingle2);
+    return function() {
+        return {
+            icon: iconKey,
+            id: SetCurrencyCommand.id,
+            title: "numfmt.menu.currency",
+            tooltip: "numfmt.menu.currency",
+            type: MenuItemType.BUTTON,
+            group: MenuGroup.TOOLBAR_FORMULAS_INSERT,
+            positions: [
+                MenuPosition.TOOLBAR_START
+            ]
+        };
+    };
+};
+var AddDecimalMenuItem = function(componentManager) {
+    var iconKey = "icon-addDigitsSingle";
+    componentManager.register(iconKey, AddDigitsSingle);
+    return function() {
+        return {
+            icon: iconKey,
+            id: AddDecimalCommand.id,
+            title: "numfmt.menu.add.decimal",
+            tooltip: "numfmt.menu.add.decimal",
+            type: MenuItemType.BUTTON,
+            positions: [
+                MenuPosition.TOOLBAR_START
+            ],
+            group: MenuGroup.TOOLBAR_FORMULAS_INSERT
+        };
+    };
+};
+var SubtractDecimalMenuItem = function(componentManager) {
+    var iconKey = "icon-reduceDigitsSingle";
+    componentManager.register(iconKey, ReduceDigitsSingle);
+    return function() {
+        return {
+            icon: iconKey,
+            id: SubtractDecimalCommand.id,
+            title: "numfmt.menu.subtract.decimal",
+            tooltip: "numfmt.menu.subtract.decimal",
+            type: MenuItemType.BUTTON,
+            group: MenuGroup.TOOLBAR_FORMULAS_INSERT,
+            positions: [
+                MenuPosition.TOOLBAR_START
+            ]
+        };
+    };
+};
+var FactoryOtherMenuItem = function(componentManager) {
+    componentManager.register("sheet.numfmt.moreNumfmtType", MoreNumfmtType);
+    return function(_accessor) {
+        var numfmtService = _accessor.get(INumfmtService3);
+        var univerInstanceService = _accessor.get(IUniverInstanceService4);
+        var selectionManagerService = _accessor.get(SelectionManagerService4);
+        var value$ = new Observable(function(subscribe) {
+            return selectionManagerService.selectionInfo$.subscribe(function(selections) {
+                if (selections && selections[0]) {
+                    var workbook = univerInstanceService.getCurrentUniverSheetInstance();
+                    var worksheet = workbook.getActiveSheet();
+                    var range = selections[0].range;
+                    var row = range.startRow;
+                    var col = range.startColumn;
+                    var numfmtValue = numfmtService.getValue(workbook.getUnitId(), worksheet.getSheetId(), row, col);
+                    var value = "常规";
+                    if (numfmtValue) {
+                        var pattern = numfmtValue.pattern;
+                        if (isAccountingPanel(pattern)) {
+                            value = "会计";
+                        }
+                        if (isCurrencyPanel(pattern)) {
+                            value = "货币";
+                        }
+                        if (isDatePanel(pattern)) {
+                            value = "日期";
+                        }
+                        if (isThousandthPercentilePanel(pattern)) {
+                            value = "千分位";
+                        }
+                    }
+                    subscribe.next(value);
+                }
+            });
+        });
+        return {
+            // icon: 'MoreDownSingle',
+            label: "sheet.numfmt.moreNumfmtType",
+            id: OpenNumfmtPanelOperator.id,
+            // title: 'numfmt.menu.preview',
+            tooltip: "numfmt.menu.preview",
+            type: MenuItemType.BUTTON,
+            group: MenuGroup.TOOLBAR_FORMULAS_INSERT,
+            positions: [
+                MenuPosition.TOOLBAR_START
+            ],
+            value$: value$
+        };
+    };
+};
+// src/utils/pattern.ts
+import numfmt3 from "@univerjs/engine-numfmt";
+var getPatternType = function(pattern) {
+    return numfmt3.getInfo(pattern).type || "unknown";
+};
+var getPatternPreview = function(pattern, value) {
+    var info = numfmt3.getInfo(pattern);
+    var negInfo = info._partitions[1];
+    var result = numfmt3.format(pattern, value, {
+        locale: "zh-CN"
+    });
+    if (value < 0) {
+        return {
+            result: result,
+            color: negInfo.color
+        };
+    }
+    return {
+        result: result
+    };
+};
+// src/controllers/numfmt.controller.ts
+var NumfmtController = /*#__PURE__*/ function(Disposable) {
+    "use strict";
+    _inherits(NumfmtController, Disposable);
+    var _super = _create_super(NumfmtController);
+    function NumfmtController(_sheetInterceptorService, _themeService, _injector, _univerInstanceService, _sheetSkeletonManagerService, _commandService, _selectionManagerService, _renderManagerService, _numfmtService, _componentManager, _menuService, _sidebarService, _localeService, _autoFillService) {
+        _class_call_check(this, NumfmtController);
+        var _this;
+        _this = _super.call(this);
+        /**
+   * If _previewPattern is null ,the realTimeRenderingInterceptor will skip and if it is '',realTimeRenderingInterceptor will clear numfmt.
+   * @private
+   * @type {(string | null)}
+   * @memberof NumfmtController
+   */ _define_property(_assert_this_initialized(_this), "_previewPattern", "");
+        _define_property(_assert_this_initialized(_this), "openPanel", function() {
+            var sidebarService = _this._sidebarService;
+            var selectionManagerService = _this._selectionManagerService;
+            var commandService = _this._commandService;
+            var univerInstanceService = _this._univerInstanceService;
+            var numfmtService = _this._numfmtService;
+            var localeService = _this._localeService;
+            var selections = selectionManagerService.getSelectionRanges() || [];
+            var range = selections[0];
+            if (!range) {
+                return false;
+            }
+            var workbook = univerInstanceService.getCurrentUniverSheetInstance();
+            var sheet = workbook.getActiveSheet();
+            var cellValue = sheet.getCellRaw(range.startRow, range.startColumn);
+            var numfmtValue = numfmtService.getValue(workbook.getUnitId(), sheet.getSheetId(), range.startRow, range.startColumn);
+            var pattern = "";
+            if (numfmtValue) {
+                pattern = numfmtValue.pattern;
+            }
+            var defaultValue = (cellValue === null || cellValue === void 0 ? void 0 : cellValue.t) === CellValueType.NUMBER ? cellValue.v : 12345678;
+            var props = {
+                onChange: function(config) {
+                    if (config.type === "change") {
+                        var _this__renderManagerService_getRenderById_mainComponent, _this__renderManagerService_getRenderById;
+                        _this._previewPattern = config.value;
+                        _this._sheetSkeletonManagerService.reCalculate();
+                        (_this__renderManagerService_getRenderById = _this._renderManagerService.getRenderById(workbook.getUnitId())) === null || _this__renderManagerService_getRenderById === void 0 ? void 0 : (_this__renderManagerService_getRenderById_mainComponent = _this__renderManagerService_getRenderById.mainComponent) === null || _this__renderManagerService_getRenderById_mainComponent === void 0 ? void 0 : _this__renderManagerService_getRenderById_mainComponent.makeDirty();
+                    } else if (config.type === "confirm") {
+                        var selections2 = selectionManagerService.getSelectionRanges() || [];
+                        var params = {
+                            values: []
+                        };
+                        var patternType = getPatternType(config.value);
+                        selections2.forEach(function(rangeInfo) {
+                            Range4.foreach(rangeInfo, function(row, col) {
+                                params.values.push({
+                                    row: row,
+                                    col: col,
+                                    pattern: config.value,
+                                    type: patternType
+                                });
+                            });
+                        });
+                        commandService.executeCommand(SetNumfmtCommand.id, params);
+                        sidebarService.close();
+                    } else if (config.type === "cancel") {
+                        sidebarService.close();
+                    }
+                },
+                value: {
+                    defaultPattern: pattern,
+                    defaultValue: defaultValue,
+                    row: range.startRow,
+                    col: range.startColumn
+                }
+            };
+            sidebarService.open({
+                header: {
+                    title: localeService.t("sheet.numfmt.title")
+                },
+                children: _object_spread({
+                    label: SHEET_NUMFMT_PLUGIN
+                }, props),
+                onClose: function() {
+                    commandService.executeCommand(CloseNumfmtPanelOperator.id);
+                }
+            });
+        });
+        _define_property(_assert_this_initialized(_this), "_initLocal", function() {
+            var _obj;
+            _this._localeService.load((_obj = {}, _define_property(_obj, LocaleType.ZH_CN, zhCn), _define_property(_obj, LocaleType.EN_US, zhCn), _obj));
+        });
+        _this._sheetInterceptorService = _sheetInterceptorService;
+        _this._themeService = _themeService;
+        _this._injector = _injector;
+        _this._univerInstanceService = _univerInstanceService;
+        _this._sheetSkeletonManagerService = _sheetSkeletonManagerService;
+        _this._commandService = _commandService;
+        _this._selectionManagerService = _selectionManagerService;
+        _this._renderManagerService = _renderManagerService;
+        _this._numfmtService = _numfmtService;
+        _this._componentManager = _componentManager;
+        _this._menuService = _menuService;
+        _this._sidebarService = _sidebarService;
+        _this._localeService = _localeService;
+        _this._autoFillService = _autoFillService;
+        _this._initInterceptorCommands();
+        _this._initRealTimeRenderingInterceptor();
+        _this._initPanel();
+        _this._initCommands();
+        _this._commandExecutedListener();
+        _this._initMenu();
+        _this._initInterceptorCellContent();
+        _this._initLocal();
+        _this._initAutoFill();
+        return _this;
+    }
+    _create_class(NumfmtController, [
+        {
+            key: "_initAutoFill",
+            value: function _initAutoFill() {
+                var _this = this;
+                var noopReturnFunc = function() {
+                    return {
+                        redos: [],
+                        undos: []
+                    };
+                };
+                var loopFunc = function(sourceStartCell, targetStartCell, relativeRange) {
+                    var workbookId = _this._univerInstanceService.getCurrentUniverSheetInstance().getUnitId();
+                    var worksheetId = _this._univerInstanceService.getCurrentUniverSheetInstance().getActiveSheet().getSheetId();
+                    var sourceRange = {
+                        startRow: sourceStartCell.row,
+                        startColumn: sourceStartCell.col,
+                        endColumn: sourceStartCell.col,
+                        endRow: sourceStartCell.row
+                    };
+                    var targetRange = {
+                        startRow: targetStartCell.row,
+                        startColumn: targetStartCell.col,
+                        endColumn: targetStartCell.col,
+                        endRow: targetStartCell.row
+                    };
+                    var values = [];
+                    Range4.foreach(relativeRange, function(row, col) {
+                        var sourcePositionRange = Rectangle.getPositionRange({
+                            startRow: row,
+                            startColumn: col,
+                            endColumn: col,
+                            endRow: row
+                        }, sourceRange);
+                        var oldNumfmtValue = _this._numfmtService.getValue(workbookId, worksheetId, sourcePositionRange.startRow, sourcePositionRange.startColumn);
+                        if (oldNumfmtValue) {
+                            var targetPositionRange = Rectangle.getPositionRange({
+                                startRow: row,
+                                startColumn: col,
+                                endColumn: col,
+                                endRow: row
+                            }, targetRange);
+                            values.push({
+                                pattern: oldNumfmtValue.pattern,
+                                type: oldNumfmtValue.type,
+                                row: targetPositionRange.startRow,
+                                col: targetPositionRange.startColumn
+                            });
+                        }
+                    });
+                    if (values.length) {
+                        var redo = {
+                            id: SetNumfmtMutation2.id,
+                            params: {
+                                values: values,
+                                workbookId: workbookId,
+                                worksheetId: worksheetId
+                            }
+                        };
+                        var undo = {
+                            id: SetNumfmtMutation2.id,
+                            params: {
+                                values: factorySetNumfmtUndoMutation2(_this._injector, redo.params),
+                                workbookId: workbookId,
+                                worksheetId: worksheetId
+                            }
+                        };
+                        return {
+                            redos: [
+                                redo
+                            ],
+                            undos: [
+                                undo
+                            ]
+                        };
+                    }
+                    return {
+                        redos: [],
+                        undos: []
+                    };
+                };
+                var generalApplyFunc = function(sourceRange, targetRange) {
+                    var totalUndos = [];
+                    var totalRedos = [];
+                    var sourceStartCell = {
+                        row: sourceRange.startRow,
+                        col: sourceRange.startColumn
+                    };
+                    var repeats = getRepeatRange(sourceRange, targetRange);
+                    repeats.forEach(function(repeat) {
+                        var _totalUndos, _totalRedos;
+                        var _loopFunc = loopFunc(sourceStartCell, repeat.repeatStartCell, repeat.relativeRange), undos = _loopFunc.undos, redos = _loopFunc.redos;
+                        (_totalUndos = totalUndos).push.apply(_totalUndos, _to_consumable_array(undos));
+                        (_totalRedos = totalRedos).push.apply(_totalRedos, _to_consumable_array(redos));
+                    });
+                    return {
+                        undos: totalUndos,
+                        redos: totalRedos
+                    };
+                };
+                var _obj;
+                var hook = {
+                    hookName: SHEET_NUMFMT_PLUGIN,
+                    hook: (_obj = {}, _define_property(_obj, APPLY_TYPE.COPY, generalApplyFunc), _define_property(_obj, APPLY_TYPE.NO_FORMAT, noopReturnFunc), _define_property(_obj, APPLY_TYPE.ONLY_FORMAT, generalApplyFunc), _define_property(_obj, APPLY_TYPE.SERIES, generalApplyFunc), _obj)
+                };
+                this.disposeWithMe(this._autoFillService.addHook(hook));
+            }
+        },
+        {
+            key: "_initCommands",
+            value: function _initCommands() {
+                var _this = this;
+                [
+                    AddDecimalCommand,
+                    SubtractDecimalCommand,
+                    SetCurrencyCommand,
+                    OpenNumfmtPanelOperator,
+                    CloseNumfmtPanelOperator,
+                    SetNumfmtCommand
+                ].forEach(function(config) {
+                    _this.disposeWithMe(_this._commandService.registerCommand(config));
+                });
+            }
+        },
+        {
+            key: "_initPanel",
+            value: function _initPanel() {
+                this._componentManager.register(SHEET_NUMFMT_PLUGIN, SheetNumfmtPanel);
+            }
+        },
+        {
+            key: "_initMenu",
+            value: function _initMenu() {
+                var _this = this;
+                [
+                    AddDecimalMenuItem,
+                    SubtractDecimalMenuItem,
+                    CurrencyMenuItem,
+                    FactoryOtherMenuItem
+                ].map(function(factory) {
+                    return factory(_this._componentManager);
+                }).forEach(function(configFactory) {
+                    _this.disposeWithMe(_this._menuService.addMenuItem(configFactory(_this._injector)));
+                });
+            }
+        },
+        {
+            key: "_initInterceptorCommands",
+            value: function _initInterceptorCommands() {
+                var self = this;
+                this.disposeWithMe(this._sheetInterceptorService.interceptCommand({
+                    getMutations: function getMutations(command) {
+                        switch(command.id){
+                            case ClearSelectionAllCommand.id:
+                            case ClearSelectionFormatCommand.id:
+                                {
+                                    var workbookId = self._univerInstanceService.getCurrentUniverSheetInstance().getUnitId();
+                                    var worksheetId = self._univerInstanceService.getCurrentUniverSheetInstance().getActiveSheet().getSheetId();
+                                    var selections = self._selectionManagerService.getSelectionRanges();
+                                    if (!(selections === null || selections === void 0 ? void 0 : selections.length)) {
+                                        break;
+                                    }
+                                    var redos = {
+                                        workbookId: workbookId,
+                                        worksheetId: worksheetId,
+                                        values: []
+                                    };
+                                    selections.forEach(function(range) {
+                                        Range4.foreach(range, function(row, col) {
+                                            redos.values.push({
+                                                row: row,
+                                                col: col
+                                            });
+                                        });
+                                    });
+                                    var undos = factorySetNumfmtUndoMutation2(self._injector, redos);
+                                    return {
+                                        redos: [
+                                            {
+                                                id: SetNumfmtMutation2.id,
+                                                params: redos
+                                            }
+                                        ],
+                                        undos: [
+                                            {
+                                                id: SetNumfmtMutation2.id,
+                                                params: undos
+                                            }
+                                        ]
+                                    };
+                                }
+                        }
+                        return {
+                            redos: [],
+                            undos: []
+                        };
+                    }
+                }));
+            }
+        },
+        {
+            key: "_initInterceptorCellContent",
+            value: function _initInterceptorCellContent() {
+                var _this = this;
+                var renderCache = new ObjectMatrix();
+                this.disposeWithMe(this._sheetInterceptorService.intercept(INTERCEPTOR_POINT.CELL_CONTENT, {
+                    handler: function(cell, location, next) {
+                        var workbookId = location.workbookId;
+                        var sheetId = location.worksheetId;
+                        var numfmtValue = _this._numfmtService.getValue(workbookId, sheetId, location.row, location.col);
+                        if (!numfmtValue) {
+                            return next(cell);
+                        }
+                        var originCellValue = cell;
+                        if (!originCellValue) {
+                            return next(cell);
+                        }
+                        if (originCellValue.t !== CellValueType.NUMBER) {
+                            return next(cell);
+                        }
+                        var numfmtRes = "";
+                        var cache = renderCache.getValue(location.row, location.col);
+                        if (cache && cache.parameters === originCellValue.v) {
+                            return _object_spread({}, cell, cache.result);
+                        }
+                        var info = getPatternPreview(numfmtValue.pattern, Number(originCellValue.v));
+                        numfmtRes = info.result;
+                        if (!numfmtRes) {
+                            return next(cell);
+                        }
+                        var res = {
+                            v: numfmtRes
+                        };
+                        if (info.color) {
+                            var color = _this._themeService.getCurrentTheme()["".concat(info.color, "500")];
+                            if (color) {
+                                res.s = {
+                                    cl: {
+                                        rgb: color
+                                    }
+                                };
+                            }
+                        }
+                        renderCache.setValue(location.row, location.col, {
+                            result: res,
+                            parameters: originCellValue.v
+                        });
+                        return _object_spread({}, cell, res);
+                    }
+                }));
+                this.disposeWithMe(this._commandService.onCommandExecuted(function(commandInfo) {
+                    if (commandInfo.id === SetNumfmtMutation2.id) {
+                        var params = commandInfo.params;
+                        params.values.map(function(value) {
+                            return {
+                                row: value.row,
+                                col: value.col
+                            };
+                        }).forEach(function(param) {
+                            var row = param.row, col = param.col;
+                            renderCache.realDeleteValue(row, col);
+                        });
+                    }
+                }));
+                this.disposeWithMe(toDisposable(this._sheetSkeletonManagerService.currentSkeleton$.pipe(map(function(skeleton) {
+                    return skeleton === null || skeleton === void 0 ? void 0 : skeleton.sheetId;
+                }), distinctUntilChanged()).subscribe(function() {
+                    renderCache.reset();
+                })));
+            }
+        },
+        {
+            key: "_initRealTimeRenderingInterceptor",
+            value: function _initRealTimeRenderingInterceptor() {
+                var _this = this;
+                var isPanelOpenObserver = new Observable2(function(subscribe) {
+                    _this._commandService.onCommandExecuted(function(commandInfo) {
+                        if (commandInfo.id === OpenNumfmtPanelOperator.id) {
+                            subscribe.next(true);
+                        }
+                        if (commandInfo.id === CloseNumfmtPanelOperator.id) {
+                            subscribe.next(false);
+                        }
+                    });
+                });
+                var combineOpenAndSelection$ = combineLatest([
+                    isPanelOpenObserver,
+                    this._selectionManagerService.selectionInfo$.pipe(map(function(selectionInfos) {
+                        if (!selectionInfos) {
+                            return [];
+                        }
+                        return selectionInfos.map(function(selectionInfo) {
+                            return selectionInfo.range;
+                        });
+                    }))
+                ]);
+                this.disposeWithMe(toDisposable(combineOpenAndSelection$.pipe(switchMap(function(param) {
+                    var _param = _sliced_to_array(param, 2), isOpen = _param[0], selectionRanges = _param[1];
+                    return new Observable2(function(subscribe) {
+                        var disposableCollection = new DisposableCollection();
+                        isOpen && selectionRanges.length && subscribe.next({
+                            selectionRanges: selectionRanges,
+                            disposableCollection: disposableCollection
+                        });
+                        return function() {
+                            disposableCollection.dispose();
+                        };
+                    });
+                }), tap(function() {
+                    _this._previewPattern = null;
+                })).subscribe(function(param) {
+                    var disposableCollection = param.disposableCollection, selectionRanges = param.selectionRanges;
+                    var _this__renderManagerService_getRenderById_mainComponent, _this__renderManagerService_getRenderById;
+                    var workbook = _this._univerInstanceService.getCurrentUniverSheetInstance();
+                    _this.openPanel();
+                    disposableCollection.add(_this._sheetInterceptorService.intercept(INTERCEPTOR_POINT.CELL_CONTENT, {
+                        priority: 99,
+                        handler: function(cell, location, next) {
+                            var row = location.row, col = location.col;
+                            if (selectionRanges.find(function(range) {
+                                return range.startColumn <= col && range.endColumn >= col && range.startRow <= row && range.endRow >= row;
+                            })) {
+                                var rawValue = location.worksheet.getCellRaw(row, col);
+                                var value = rawValue === null || rawValue === void 0 ? void 0 : rawValue.v;
+                                var type = rawValue === null || rawValue === void 0 ? void 0 : rawValue.t;
+                                if (value === void 0 || value === null || type !== CellValueType.NUMBER || _this._previewPattern === null) {
+                                    return next(cell);
+                                }
+                                var info = getPatternPreview(_this._previewPattern, value);
+                                if (info.color) {
+                                    var colorMap = _this._themeService.getCurrentTheme();
+                                    var color = colorMap["".concat(info.color, "500")];
+                                    return _object_spread_props(_object_spread({}, cell), {
+                                        v: info.result,
+                                        t: CellValueType.STRING,
+                                        s: {
+                                            cl: {
+                                                rgb: color
+                                            }
+                                        }
+                                    });
+                                }
+                                return _object_spread_props(_object_spread({}, cell), {
+                                    v: info.result,
+                                    t: CellValueType.STRING
+                                });
+                            }
+                            return next();
+                        }
+                    }));
+                    (_this__renderManagerService_getRenderById = _this._renderManagerService.getRenderById(workbook.getUnitId())) === null || _this__renderManagerService_getRenderById === void 0 ? void 0 : (_this__renderManagerService_getRenderById_mainComponent = _this__renderManagerService_getRenderById.mainComponent) === null || _this__renderManagerService_getRenderById_mainComponent === void 0 ? void 0 : _this__renderManagerService_getRenderById_mainComponent.makeDirty();
+                })));
+            }
+        },
+        {
+            key: "_commandExecutedListener",
+            value: function _commandExecutedListener() {
+                var _this = this;
+                this.disposeWithMe(toDisposable(merge(new Observable2(function(subscribe) {
+                    var disposable = _this._commandService.onCommandExecuted(function(command) {
+                        if (SetNumfmtMutation2.id === command.id) {
+                            var params = command.params;
+                            subscribe.next(params.workbookId);
+                        }
+                    });
+                    return function() {
+                        disposable.dispose();
+                    };
+                }), this._numfmtService.modelReplace$).pipe(debounceTime(16)).subscribe(function(workbookId) {
+                    var _this__renderManagerService_getRenderById_mainComponent, _this__renderManagerService_getRenderById;
+                    _this._sheetSkeletonManagerService.reCalculate();
+                    (_this__renderManagerService_getRenderById = _this._renderManagerService.getRenderById(workbookId)) === null || _this__renderManagerService_getRenderById === void 0 ? void 0 : (_this__renderManagerService_getRenderById_mainComponent = _this__renderManagerService_getRenderById.mainComponent) === null || _this__renderManagerService_getRenderById_mainComponent === void 0 ? void 0 : _this__renderManagerService_getRenderById_mainComponent.makeDirty();
+                })));
+            }
+        }
+    ]);
+    return NumfmtController;
+}(Disposable);
+NumfmtController = __decorateClass([
+    OnLifecycle(LifecycleStages2.Rendered, NumfmtController),
+    __decorateParam(0, Inject2(SheetInterceptorService)),
+    __decorateParam(1, Inject2(ThemeService)),
+    __decorateParam(2, Inject2(Injector)),
+    __decorateParam(3, Inject2(IUniverInstanceService5)),
+    __decorateParam(4, Inject2(SheetSkeletonManagerService)),
+    __decorateParam(5, Inject2(ICommandService5)),
+    __decorateParam(6, Inject2(SelectionManagerService5)),
+    __decorateParam(7, Inject2(IRenderManagerService)),
+    __decorateParam(8, Inject2(INumfmtService4)),
+    __decorateParam(9, Inject2(ComponentManager)),
+    __decorateParam(10, Inject2(IMenuService)),
+    __decorateParam(11, Inject2(ISidebarService)),
+    __decorateParam(12, Inject2(LocaleService6)),
+    __decorateParam(13, Inject2(IAutoFillService))
+], NumfmtController);
+// src/controllers/numfmt.editor.controller.ts
+import { CellValueType as CellValueType2, Disposable as Disposable2, IUniverInstanceService as IUniverInstanceService6, LifecycleStages as LifecycleStages3, OnLifecycle as OnLifecycle2, toDisposable as toDisposable2 } from "@univerjs/core";
+import numfmt4 from "@univerjs/engine-numfmt";
+import { factorySetNumfmtUndoMutation as factorySetNumfmtUndoMutation3, INumfmtService as INumfmtService5, SetNumfmtMutation as SetNumfmtMutation3, SetRangeValuesCommand, SheetInterceptorService as SheetInterceptorService2 } from "@univerjs/sheets";
+import { IEditorBridgeService } from "@univerjs/sheets-ui";
+import { Inject as Inject3, Injector as Injector2 } from "@wendellhu/redi";
+var createCollectEffectMutation = function() {
+    var list = [];
+    var add = function(workbookId, worksheetId, row, col, value) {
+        return list.push({
+            workbookId: workbookId,
+            worksheetId: worksheetId,
+            row: row,
+            col: col,
+            value: value
+        });
+    };
+    var getEffects = function() {
+        return list;
+    };
+    var clean = function() {
+        list = [];
+    };
+    return {
+        add: add,
+        getEffects: getEffects,
+        clean: clean
+    };
+};
+var NumfmtEditorController = /*#__PURE__*/ function(Disposable2) {
+    "use strict";
+    _inherits(NumfmtEditorController, Disposable2);
+    var _super = _create_super(NumfmtEditorController);
+    function NumfmtEditorController(_sheetInterceptorService, _numfmtService, _univerInstanceService, _injector, _editorBridgeService) {
+        _class_call_check(this, NumfmtEditorController);
+        var _this;
+        _this = _super.call(this);
+        // collect effect mutations when edit end and push this to  commands stack in next commands progress
+        _define_property(_assert_this_initialized(_this), "_collectEffectMutation", createCollectEffectMutation());
+        _this._sheetInterceptorService = _sheetInterceptorService;
+        _this._numfmtService = _numfmtService;
+        _this._univerInstanceService = _univerInstanceService;
+        _this._injector = _injector;
+        _this._editorBridgeService = _editorBridgeService;
+        _this._initInterceptorEditorStart();
+        _this._initInterceptorEditorEnd();
+        _this._initInterceptorCommands();
+        return _this;
+    }
+    _create_class(NumfmtEditorController, [
+        {
+            key: "_initInterceptorEditorStart",
+            value: function _initInterceptorEditorStart() {
+                var _this = this;
+                this.disposeWithMe(toDisposable2(this._editorBridgeService.interceptor.intercept(this._editorBridgeService.interceptor.getInterceptPoints().BEFORE_CELL_EDIT, {
+                    handler: function(value, context, next) {
+                        var row = context.row;
+                        var col = context.col;
+                        var numfmtCell = _this._numfmtService.getValue(context.workbookId, context.worksheetId, row, col);
+                        if (numfmtCell) {
+                            var type = getPatternType(numfmtCell.pattern);
+                            switch(type){
+                                case "scientific":
+                                case "percent":
+                                case "currency":
+                                case "grouped":
+                                case "number":
+                                    {
+                                        var cell = context.worksheet.getCellRaw(row, col);
+                                        return cell ? filterAtr(cell, [
+                                            "s"
+                                        ]) : cell;
+                                    }
+                                case "date":
+                                case "time":
+                                case "datetime":
+                                default:
+                                    {
+                                        return next && next(value);
+                                    }
+                            }
+                        }
+                        return next(value);
+                    }
+                })));
+            }
+        },
+        {
+            /**
+   * Process the  values after  edit
+   * @private
+   * @memberof NumfmtService
+   */ key: "_initInterceptorEditorEnd",
+            value: function _initInterceptorEditorEnd() {
+                var _this = this;
+                this.disposeWithMe(toDisposable2(this._editorBridgeService.interceptor.intercept(this._editorBridgeService.interceptor.getInterceptPoints().AFTER_CELL_EDIT, {
+                    handler: function(value, context, next) {
+                        _this._collectEffectMutation.clean();
+                        var currentNumfmtValue = _this._numfmtService.getValue(context.workbookId, context.worksheetId, context.row, context.col);
+                        var clean = function() {
+                            currentNumfmtValue && _this._collectEffectMutation.add(context.workbookId, context.worksheetId, context.row, context.col, null);
+                        };
+                        if (!(value === null || value === void 0 ? void 0 : value.v)) {
+                            clean();
+                            return next(value);
+                        }
+                        var content = String(value.v);
+                        var dateInfo = numfmt4.parseDate(content) || numfmt4.parseTime(content);
+                        var isTranslateDate = !!dateInfo;
+                        if (isTranslateDate) {
+                            if (dateInfo && dateInfo.z) {
+                                var v = Number(dateInfo.v);
+                                _this._collectEffectMutation.add(context.workbookId, context.worksheetId, context.row, context.col, {
+                                    type: "date",
+                                    pattern: dateInfo.z
+                                });
+                                return _object_spread_props(_object_spread({}, value), {
+                                    v: v,
+                                    t: CellValueType2.NUMBER
+                                });
+                            }
+                        } else if ([
+                            "date",
+                            "time",
+                            "datetime"
+                        ].includes((currentNumfmtValue === null || currentNumfmtValue === void 0 ? void 0 : currentNumfmtValue.type) || "") || !isNumeric(content)) {
+                            clean();
+                        }
+                        return next(value);
+                    }
+                })));
+            }
+        },
+        {
+            key: "_initInterceptorCommands",
+            value: function _initInterceptorCommands() {
+                var self = this;
+                this.disposeWithMe(this._sheetInterceptorService.interceptCommand({
+                    getMutations: function getMutations(command) {
+                        switch(command.id){
+                            case SetRangeValuesCommand.id:
+                                {
+                                    var workbookId = self._univerInstanceService.getCurrentUniverSheetInstance().getUnitId();
+                                    var worksheetId = self._univerInstanceService.getCurrentUniverSheetInstance().getActiveSheet().getSheetId();
+                                    var list = self._collectEffectMutation.getEffects();
+                                    if (!list.length) {
+                                        return {
+                                            redos: [],
+                                            undos: []
+                                        };
+                                    }
+                                    var redos = {
+                                        workbookId: workbookId,
+                                        worksheetId: worksheetId,
+                                        values: list.map(function(item) {
+                                            var _item_value;
+                                            return {
+                                                pattern: item.value ? item.value.pattern : "",
+                                                row: item.row,
+                                                col: item.col,
+                                                type: (_item_value = item.value) === null || _item_value === void 0 ? void 0 : _item_value.type
+                                            };
+                                        })
+                                    };
+                                    var undos = factorySetNumfmtUndoMutation3(self._injector, redos);
+                                    return {
+                                        redos: [
+                                            {
+                                                id: SetNumfmtMutation3.id,
+                                                params: redos
+                                            }
+                                        ],
+                                        undos: [
+                                            {
+                                                id: SetNumfmtMutation3.id,
+                                                params: undos
+                                            }
+                                        ]
+                                    };
+                                }
+                        }
+                        return {
+                            redos: [],
+                            undos: []
+                        };
+                    }
+                }));
+            }
+        }
+    ]);
+    return NumfmtEditorController;
+}(Disposable2);
+NumfmtEditorController = __decorateClass([
+    OnLifecycle2(LifecycleStages3.Rendered, NumfmtEditorController),
+    __decorateParam(0, Inject3(SheetInterceptorService2)),
+    __decorateParam(1, Inject3(INumfmtService5)),
+    __decorateParam(2, Inject3(IUniverInstanceService6)),
+    __decorateParam(3, Inject3(Injector2)),
+    __decorateParam(4, Inject3(IEditorBridgeService))
+], NumfmtEditorController);
+var filterAtr = function(obj, filterKey) {
+    var keys = Object.keys(obj).filter(function(key2) {
+        return !filterKey.includes(key2);
+    });
+    return keys.reduce(function(pre, cur) {
+        pre[cur] = obj[cur];
+        return pre;
+    }, {});
+};
+function isNumeric(str) {
+    return /^-?\d+(\.\d+)?$/.test(str);
+}
+// src/controllers/numfmt.ref-range.controller.ts
+import { Disposable as Disposable3, DisposableCollection as DisposableCollection2, ICommandService as ICommandService6, IUniverInstanceService as IUniverInstanceService7, LifecycleStages as LifecycleStages4, OnLifecycle as OnLifecycle3, toDisposable as toDisposable3 } from "@univerjs/core";
+import { EffectRefRangId, factorySetNumfmtUndoMutation as factorySetNumfmtUndoMutation4, handleDeleteRangeMoveLeft, handleDeleteRangeMoveUp, handleInsertCol, handleInsertRangeMoveDown, handleInsertRangeMoveRight, handleInsertRow, handleIRemoveCol, handleIRemoveRow, handleMoveRange, INumfmtService as INumfmtService6, RefRangeService, runRefRangeMutations, SetNumfmtMutation as SetNumfmtMutation4 } from "@univerjs/sheets";
+import { SheetSkeletonManagerService as SheetSkeletonManagerService2 } from "@univerjs/sheets-ui";
+import { Inject as Inject4, Injector as Injector3 } from "@wendellhu/redi";
+import { merge as merge2, Observable as Observable3 } from "rxjs";
+import { bufferTime, distinctUntilChanged as distinctUntilChanged2, filter, map as map2, switchMap as switchMap2 } from "rxjs/operators";
+var NumfmtRefRangeController = /*#__PURE__*/ function(Disposable3) {
+    "use strict";
+    _inherits(NumfmtRefRangeController, Disposable3);
+    var _super = _create_super(NumfmtRefRangeController);
+    function NumfmtRefRangeController(_numfmtService, _univerInstanceService, _injector, _refRangeService, _sheetSkeletonManagerService, _commandService) {
+        _class_call_check(this, NumfmtRefRangeController);
+        var _this;
+        _this = _super.call(this);
+        _this._numfmtService = _numfmtService;
+        _this._univerInstanceService = _univerInstanceService;
+        _this._injector = _injector;
+        _this._refRangeService = _refRangeService;
+        _this._sheetSkeletonManagerService = _sheetSkeletonManagerService;
+        _this._commandService = _commandService;
+        _this._registerRefRange();
+        _this._mergeRefMutations();
+        return _this;
+    }
+    _create_class(NumfmtRefRangeController, [
+        {
+            key: "_mergeRefMutations",
+            value: function _mergeRefMutations() {
+                this.disposeWithMe(this._refRangeService.intercept({
+                    handler: function(list, current, next) {
+                        if (!list || !list.length || !current.length) {
+                            return next(list);
+                        }
+                        var theLastMutation = list[list.length - 1];
+                        var theFirstMutation = current[0];
+                        if (theLastMutation.id === SetNumfmtMutation4.id && theFirstMutation.id === SetNumfmtMutation4.id) {
+                            var theLastMutationParams = theLastMutation.params;
+                            var theFirstMutationParams = theFirstMutation.params;
+                            if (theLastMutationParams.workbookId === theFirstMutationParams.workbookId && theLastMutationParams.worksheetId === theFirstMutationParams.worksheetId) {
+                                var values = theLastMutationParams.values;
+                                current.forEach(function(mutation) {
+                                    var params = mutation.params;
+                                    params.values.forEach(function(item) {
+                                        values.push(item);
+                                    });
+                                });
+                                return list;
+                            }
+                        }
+                        return next(list);
+                    }
+                }));
+            }
+        },
+        {
+            key: "_registerRefRange",
+            value: function _registerRefRange() {
+                var _this = this;
+                this.disposeWithMe(toDisposable3(merge2(this._sheetSkeletonManagerService.currentSkeleton$.pipe(map2(function(skeleton) {
+                    return skeleton === null || skeleton === void 0 ? void 0 : skeleton.sheetId;
+                }), distinctUntilChanged2()), this._numfmtService.modelReplace$).pipe(switchMap2(function() {
+                    return new Observable3(function(subscribe) {
+                        var disposableCollection = new DisposableCollection2();
+                        subscribe.next(disposableCollection);
+                        return function() {
+                            disposableCollection.dispose();
+                        };
+                    });
+                })).subscribe(function(disposableCollection) {
+                    var workbook = _this._univerInstanceService.getCurrentUniverSheetInstance();
+                    var workbookId = workbook.getUnitId();
+                    var worksheetId = _this._univerInstanceService.getCurrentUniverSheetInstance().getActiveSheet().getSheetId();
+                    var model = _this._numfmtService.getModel(workbookId, worksheetId);
+                    var disposableMap = /* @__PURE__ */ new Map();
+                    var register = function(commandInfo, preValues, row, col) {
+                        var targetRange = {
+                            startRow: row,
+                            startColumn: col,
+                            endRow: row,
+                            endColumn: col
+                        };
+                        var operators = [];
+                        switch(commandInfo.id){
+                            case EffectRefRangId.DeleteRangeMoveLeftCommandId:
+                                {
+                                    operators = handleDeleteRangeMoveLeft(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.DeleteRangeMoveUpCommandId:
+                                {
+                                    operators = handleDeleteRangeMoveUp(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.InsertColCommandId:
+                                {
+                                    operators = handleInsertCol(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.InsertRangeMoveDownCommandId:
+                                {
+                                    operators = handleInsertRangeMoveDown(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.InsertRangeMoveRightCommandId:
+                                {
+                                    operators = handleInsertRangeMoveRight(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.InsertRowCommandId:
+                                {
+                                    operators = handleInsertRow(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.MoveRangeCommandId:
+                                {
+                                    operators = handleMoveRange(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.RemoveColCommandId:
+                                {
+                                    operators = handleIRemoveCol(commandInfo, targetRange);
+                                    break;
+                                }
+                            case EffectRefRangId.RemoveRowCommandId:
+                                {
+                                    operators = handleIRemoveRow(commandInfo, targetRange);
+                                    break;
+                                }
+                        }
+                        var resultRange = runRefRangeMutations(operators, targetRange);
+                        var isPreSetNumfmt = preValues.reduce(function(list, item) {
+                            var _list;
+                            (_list = list).push.apply(_list, _to_consumable_array(item.redos));
+                            return list;
+                        }, []).filter(function(item) {
+                            return item.id === SetNumfmtMutation4.id;
+                        }).some(function(mutation) {
+                            return mutation.params.values.some(function(item) {
+                                return item.row === row && item.col === col && !!item.pattern;
+                            });
+                        });
+                        if (!resultRange && !isPreSetNumfmt) {
+                            var redoParams = {
+                                workbookId: workbookId,
+                                worksheetId: worksheetId,
+                                values: [
+                                    {
+                                        row: row,
+                                        col: col
+                                    }
+                                ]
+                            };
+                            var undoParams = factorySetNumfmtUndoMutation4(_this._injector, redoParams);
+                            return {
+                                redos: [
+                                    {
+                                        id: SetNumfmtMutation4.id,
+                                        params: redoParams
+                                    }
+                                ],
+                                undos: [
+                                    {
+                                        id: SetNumfmtMutation4.id,
+                                        params: undoParams
+                                    }
+                                ]
+                            };
+                        }
+                        var numfmtValue = _this._numfmtService.getValue(workbookId, worksheetId, row, col);
+                        if (numfmtValue && resultRange) {
+                            var redoParams1 = {
+                                workbookId: workbookId,
+                                worksheetId: worksheetId,
+                                values: [
+                                    _object_spread_props(_object_spread({}, numfmtValue), {
+                                        row: resultRange.startRow,
+                                        col: resultRange.startColumn
+                                    })
+                                ]
+                            };
+                            if (!isPreSetNumfmt) {
+                                redoParams1.values.unshift({
+                                    row: row,
+                                    col: col
+                                });
+                            }
+                            var undoParams1 = factorySetNumfmtUndoMutation4(_this._injector, redoParams1);
+                            return {
+                                redos: [
+                                    {
+                                        id: SetNumfmtMutation4.id,
+                                        params: redoParams1
+                                    }
+                                ],
+                                undos: [
+                                    {
+                                        id: SetNumfmtMutation4.id,
+                                        params: undoParams1
+                                    }
+                                ]
+                            };
+                        }
+                        return {
+                            redos: [],
+                            undos: []
+                        };
+                    };
+                    model && model.forValue(function(row, col) {
+                        var targetRange = {
+                            startRow: row,
+                            startColumn: col,
+                            endRow: row,
+                            endColumn: col
+                        };
+                        var disposable = _this._refRangeService.registerRefRange(targetRange, function(commandInfo, preValues) {
+                            return register(commandInfo, preValues, row, col);
+                        });
+                        disposableMap.set("".concat(row, "_").concat(col), disposable);
+                        disposableCollection.add(disposable);
+                    });
+                    disposableCollection.add(toDisposable3(new Observable3(function(subscribe) {
+                        disposableCollection.add(_this._commandService.onCommandExecuted(function(commandInfo) {
+                            if (commandInfo.id === SetNumfmtMutation4.id) {
+                                subscribe.next(commandInfo.params);
+                            }
+                        }));
+                    }).pipe(filter(function(commandInfo) {
+                        return commandInfo.workbookId === workbookId && commandInfo.worksheetId === worksheetId;
+                    }), map2(function(commandInfo) {
+                        return commandInfo.values;
+                    }), bufferTime(300), // updating the listener moves to the next queue
+                    map2(function(values) {
+                        return values.reduce(function(pre, cur) {
+                            var _pre;
+                            (_pre = pre).push.apply(_pre, _to_consumable_array(cur));
+                            return pre;
+                        }, []);
+                    }), filter(function(values) {
+                        return !!values.length;
+                    })).subscribe(function(values) {
+                        values.forEach(function(value) {
+                            var row = value.row, col = value.col;
+                            var key2 = "".concat(row, "_").concat(col);
+                            var disposable = disposableMap.get(key2);
+                            disposableMap.delete(key2);
+                            disposable && disposable.dispose();
+                            if (value.pattern) {
+                                var targetRange = {
+                                    startRow: row,
+                                    startColumn: col,
+                                    endRow: row,
+                                    endColumn: col
+                                };
+                                var disposable2 = _this._refRangeService.registerRefRange(targetRange, function(commandInfo, preValues) {
+                                    return register(commandInfo, preValues, row, col);
+                                });
+                                disposableMap.set(key2, disposable2);
+                                disposableCollection.add(disposable2);
+                            }
+                        });
+                    })));
+                })));
+            }
+        }
+    ]);
+    return NumfmtRefRangeController;
+}(Disposable3);
+NumfmtRefRangeController = __decorateClass([
+    OnLifecycle3(LifecycleStages4.Rendered, NumfmtRefRangeController),
+    __decorateParam(0, Inject4(INumfmtService6)),
+    __decorateParam(1, Inject4(IUniverInstanceService7)),
+    __decorateParam(2, Inject4(Injector3)),
+    __decorateParam(3, Inject4(RefRangeService)),
+    __decorateParam(4, Inject4(SheetSkeletonManagerService2)),
+    __decorateParam(5, Inject4(ICommandService6))
+], NumfmtRefRangeController);
+// src/controllers/numfmt.sheet.controller.ts
+import { Disposable as Disposable4, IUniverInstanceService as IUniverInstanceService8, LifecycleStages as LifecycleStages5, OnLifecycle as OnLifecycle4 } from "@univerjs/core";
+import { factorySetNumfmtUndoMutation as factorySetNumfmtUndoMutation5, INumfmtService as INumfmtService7, RemoveSheetCommand, SetNumfmtMutation as SetNumfmtMutation5, SheetInterceptorService as SheetInterceptorService3 } from "@univerjs/sheets";
+import { Inject as Inject5, Injector as Injector4 } from "@wendellhu/redi";
+var NumfmtSheetController = /*#__PURE__*/ function(Disposable4) {
+    "use strict";
+    _inherits(NumfmtSheetController, Disposable4);
+    var _super = _create_super(NumfmtSheetController);
+    function NumfmtSheetController(_numfmtService, _sheetInterceptorService, _univerInstanceService, _injector) {
+        _class_call_check(this, NumfmtSheetController);
+        var _this;
+        _this = _super.call(this);
+        _this._numfmtService = _numfmtService;
+        _this._sheetInterceptorService = _sheetInterceptorService;
+        _this._univerInstanceService = _univerInstanceService;
+        _this._injector = _injector;
+        _this._initSheetChange();
+        return _this;
+    }
+    _create_class(NumfmtSheetController, [
+        {
+            key: "_initSheetChange",
+            value: function _initSheetChange() {
+                var _this = this;
+                this.disposeWithMe(this._sheetInterceptorService.interceptCommand({
+                    getMutations: function(commandInfo) {
+                        if (commandInfo.id === RemoveSheetCommand.id) {
+                            var params = commandInfo.params;
+                            var workbookId = params.workbookId || getWorkbookId(_this._univerInstanceService);
+                            var worksheetId = params.worksheetId || getWorksheetId(_this._univerInstanceService);
+                            var model = _this._numfmtService.getModel(workbookId, worksheetId);
+                            if (!model) {
+                                return {
+                                    redos: [],
+                                    undos: []
+                                };
+                            }
+                            var values = [];
+                            model.forValue(function(row, col) {
+                                values.push({
+                                    row: row,
+                                    col: col
+                                });
+                            });
+                            var redoParams = {
+                                workbookId: workbookId,
+                                worksheetId: worksheetId,
+                                values: values
+                            };
+                            var undoParams = factorySetNumfmtUndoMutation5(_this._injector, redoParams);
+                            return {
+                                redos: [
+                                    {
+                                        id: SetNumfmtMutation5.id,
+                                        params: redoParams
+                                    }
+                                ],
+                                undos: [
+                                    {
+                                        id: SetNumfmtMutation5.id,
+                                        params: undoParams
+                                    }
+                                ]
+                            };
+                        }
+                        return {
+                            redos: [],
+                            undos: []
+                        };
+                    }
+                }));
+            }
+        }
+    ]);
+    return NumfmtSheetController;
+}(Disposable4);
+NumfmtSheetController = __decorateClass([
+    OnLifecycle4(LifecycleStages5.Rendered, NumfmtSheetController),
+    __decorateParam(0, Inject5(INumfmtService7)),
+    __decorateParam(1, Inject5(SheetInterceptorService3)),
+    __decorateParam(2, Inject5(IUniverInstanceService8)),
+    __decorateParam(3, Inject5(Injector4))
+], NumfmtSheetController);
+var getWorkbookId = function(u) {
+    return u.getCurrentUniverSheetInstance().getUnitId();
+};
+var getWorksheetId = function(u) {
+    return u.getCurrentUniverSheetInstance().getActiveSheet().getSheetId();
+};
+// src/numfmt-plugin.ts
+var NumfmtPlugin = (_class = /*#__PURE__*/ function(Plugin) {
+    "use strict";
+    _inherits(_class, Plugin);
+    var _super = _create_super(_class);
+    function _class(_injector) {
+        _class_call_check(this, _class);
+        var _this;
+        _this = _super.call(this, SHEET_NUMFMT_PLUGIN);
+        _this._injector = _injector;
+        return _this;
+    }
+    _create_class(_class, [
+        {
+            key: "onStarting",
+            value: function onStarting() {
+                this._injector.add([
+                    INumfmtController,
+                    {
+                        useClass: NumfmtController,
+                        lazy: false
+                    }
+                ]);
+                this._injector.add([
+                    NumfmtEditorController
+                ]);
+                this._injector.add([
+                    UserHabitController
+                ]);
+                this._injector.add([
+                    NumfmtRefRangeController
+                ]);
+                this._injector.add([
+                    NumfmtSheetController
+                ]);
+            }
+        }
+    ]);
+    return _class;
+}(_wrap_native_super(Plugin)), _define_property(_class, "type", PluginType.Sheet), _class);
+NumfmtPlugin = __decorateClass([
+    __decorateParam(0, Inject6(Injector5))
+], NumfmtPlugin);
+export { NumfmtPlugin };