@univerjs/sheets-data-validation 0.4.1 → 0.4.2-nightly.202410301606

package/lib/dv-validator-service-9VDfOza1.mjs

@@ -0,0 +1,2032 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { Inject, ICommandService, Disposable, ObjectMatrix, Range, Injector, UniverInstanceType, DataValidationType, isFormulaString, IUniverInstanceService, getOriginCellValue, debounce, Rectangle, Tools, DataValidationStatus, WrapStrategy, DataValidationOperator, CommandType, IUndoRedoService, sequenceExecute, LifecycleService, LifecycleStages, bufferDebounceTime } from "@univerjs/core";
+import { DataValidationModel, DataValidatorRegistryService, UpdateRuleType, BaseDataValidator, AddDataValidationMutation, RemoveDataValidationMutation, UpdateDataValidationMutation, getRuleSetting, getRuleOptions } from "@univerjs/data-validation";
+import { LexerTreeBuilder, ERROR_TYPE_SET } from "@univerjs/engine-formula";
+import { SetRangeValuesMutation, RemoveSheetMutation, getSheetCommandTarget, SetRangeValuesUndoMutationFactory } from "@univerjs/sheets";
+import { Subject, bufferWhen, filter } from "rxjs";
+import { RegisterOtherFormulaService } from "@univerjs/sheets-formula";
+var __defProp$4 = Object.defineProperty, __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor, __decorateClass$4 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$4(target, key, result), result;
+}, "__decorateClass$4"), __decorateParam$4 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$4"), _a;
+let DataValidationCacheService = (_a = class extends Disposable {
+  constructor(_commandService) {
+    super();
+    __publicField(this, "_cacheMatrix", /* @__PURE__ */ new Map());
+    __publicField(this, "_dirtyRanges$", new Subject());
+    __publicField(this, "dirtyRanges$", this._dirtyRanges$.asObservable());
+    this._commandService = _commandService, this._initDirtyRanges();
+  }
+  _initDirtyRanges() {
+    this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo) => {
+      if (commandInfo.id === SetRangeValuesMutation.id) {
+        const { cellValue, unitId, subUnitId } = commandInfo.params;
+        if (cellValue) {
+          const range = new ObjectMatrix(cellValue).getDataRange();
+          if (range.endRow === -1) return;
+          this._dirtyRanges$.next({
+            unitId,
+            subUnitId,
+            ranges: [range]
+          });
+        }
+      }
+    }));
+  }
+  _ensureCache(unitId, subUnitId) {
+    let unitMap = this._cacheMatrix.get(unitId);
+    unitMap || (unitMap = /* @__PURE__ */ new Map(), this._cacheMatrix.set(unitId, unitMap));
+    let cacheMatrix = unitMap.get(subUnitId);
+    return cacheMatrix || (cacheMatrix = new ObjectMatrix(), unitMap.set(subUnitId, cacheMatrix)), cacheMatrix;
+  }
+  ensureCache(unitId, subUnitId) {
+    return this._ensureCache(unitId, subUnitId);
+  }
+  addRule(unitId, subUnitId, rule) {
+    this.markRangeDirty(unitId, subUnitId, rule.ranges);
+  }
+  removeRule(unitId, subUnitId, rule) {
+    this._deleteRange(unitId, subUnitId, rule.ranges);
+  }
+  updateRuleRanges(unitId, subUnitId, ruleId, newRanges, oldRanges) {
+    const cache = this._ensureCache(unitId, subUnitId);
+    oldRanges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        const item = cache.getValue(row, col);
+        item && (item.temp = !0);
+      });
+    }), newRanges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        const item = cache.getValue(row, col);
+        item && item.ruleId === ruleId ? item.temp = !1 : cache.setValue(row, col, void 0);
+      });
+    }), oldRanges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        const item = cache.getValue(row, col);
+        item && item.temp === !0 && cache.realDeleteValue(row, col);
+      });
+    }), this._dirtyRanges$.next({ unitId, subUnitId, ranges: [...oldRanges, ...newRanges] });
+  }
+  markRangeDirty(unitId, subUnitId, ranges) {
+    const cache = this._ensureCache(unitId, subUnitId);
+    ranges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        cache.setValue(row, col, void 0);
+      });
+    }), this._dirtyRanges$.next({ unitId, subUnitId, ranges });
+  }
+  markCellDirty(unitId, subUnitId, row, col) {
+    this._ensureCache(unitId, subUnitId).setValue(row, col, void 0), this._dirtyRanges$.next({ unitId, subUnitId, ranges: [{ startRow: row, startColumn: col, endRow: row, endColumn: col }] });
+  }
+  _deleteRange(unitId, subUnitId, ranges) {
+    const cache = this._ensureCache(unitId, subUnitId);
+    ranges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        cache.realDeleteValue(row, col);
+      });
+    }), this._dirtyRanges$.next({ unitId, subUnitId, ranges });
+  }
+  getValue(unitId, subUnitId, row, col) {
+    return this._ensureCache(unitId, subUnitId).getValue(row, col);
+  }
+  setValue(unitId, subUnitId, row, col, value) {
+    return this._ensureCache(unitId, subUnitId).setValue(row, col, value);
+  }
+}, __name(_a, "DataValidationCacheService"), _a);
+DataValidationCacheService = __decorateClass$4([
+  __decorateParam$4(0, Inject(ICommandService))
+], DataValidationCacheService);
+var __defProp$3 = Object.defineProperty, __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor, __decorateClass$3 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$3(target, key, result), result;
+}, "__decorateClass$3"), __decorateParam$3 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$3");
+function transformFormula(lexerTreeBuilder, formula, originRow, originCol, targetRow, targetCol) {
+  return lexerTreeBuilder.moveFormulaRefOffset(formula, targetCol - originCol, targetRow - originRow);
+}
+__name(transformFormula, "transformFormula");
+var _a2;
+let DataValidationCustomFormulaService = (_a2 = class extends Disposable {
+  constructor(_instanceSrv, _registerOtherFormulaService, _lexerTreeBuilder, _dataValidationModel, _dataValidationCacheService, _injector) {
+    super();
+    __publicField(this, "_formulaMap", /* @__PURE__ */ new Map());
+    /**
+     * Map of origin formula of rule
+     */
+    __publicField(this, "_ruleFormulaMap", /* @__PURE__ */ new Map());
+    /**
+     * reflect of formulaId to cell, only store transformable formula
+     */
+    __publicField(this, "_formulaCellMap", /* @__PURE__ */ new Map());
+    this._instanceSrv = _instanceSrv, this._registerOtherFormulaService = _registerOtherFormulaService, this._lexerTreeBuilder = _lexerTreeBuilder, this._dataValidationModel = _dataValidationModel, this._dataValidationCacheService = _dataValidationCacheService, this._injector = _injector, this._initFormulaResultHandler();
+  }
+  _initFormulaResultHandler() {
+    this.disposeWithMe(this._registerOtherFormulaService.formulaResult$.subscribe((resultMap) => {
+      for (const unitId in resultMap) {
+        const unitMap = resultMap[unitId];
+        if (this._instanceSrv.getUnitType(unitId) === UniverInstanceType.UNIVER_SHEET)
+          for (const subUnitId in unitMap) {
+            const results = unitMap[subUnitId], { formulaCellMap, ruleFormulaMap } = this._ensureMaps(unitId, subUnitId);
+            results.forEach((result) => {
+              var _a7, _b;
+              const ruleInfo = ruleFormulaMap.get((_a7 = result.extra) == null ? void 0 : _a7.ruleId), cellInfo = formulaCellMap.get(result.formulaId), rule = this._dataValidationModel.getRuleById(unitId, subUnitId, (_b = result.extra) == null ? void 0 : _b.ruleId);
+              rule && ruleInfo && !ruleInfo.isTransformable && this._dataValidationCacheService.markRangeDirty(unitId, subUnitId, rule.ranges), cellInfo && this._dataValidationCacheService.markCellDirty(unitId, subUnitId, cellInfo.row, cellInfo.column);
+            });
+          }
+      }
+    }));
+  }
+  _ensureMaps(unitId, subUnitId) {
+    let formulaUnitMap = this._formulaMap.get(unitId), ruleFormulaUnitMap = this._ruleFormulaMap.get(unitId), formulaCellUnitMap = this._formulaCellMap.get(unitId);
+    (!formulaUnitMap || !ruleFormulaUnitMap || !formulaCellUnitMap) && (formulaUnitMap = /* @__PURE__ */ new Map(), ruleFormulaUnitMap = /* @__PURE__ */ new Map(), formulaCellUnitMap = /* @__PURE__ */ new Map(), this._formulaMap.set(unitId, formulaUnitMap), this._ruleFormulaMap.set(unitId, ruleFormulaUnitMap), this._formulaCellMap.set(unitId, formulaCellUnitMap));
+    let formulaMap = formulaUnitMap.get(subUnitId), ruleFormulaMap = ruleFormulaUnitMap.get(subUnitId), formulaCellMap = formulaCellUnitMap.get(subUnitId);
+    return (!formulaMap || !ruleFormulaMap || !formulaCellMap) && (formulaMap = new ObjectMatrix(), formulaUnitMap.set(subUnitId, formulaMap), ruleFormulaMap = /* @__PURE__ */ new Map(), ruleFormulaUnitMap.set(subUnitId, ruleFormulaMap), formulaCellMap = /* @__PURE__ */ new Map(), formulaCellUnitMap.set(subUnitId, formulaCellMap)), {
+      formulaMap,
+      ruleFormulaMap,
+      formulaCellMap
+    };
+  }
+  _registerFormula(unitId, subUnitId, ruleId, formulaString) {
+    return this._registerOtherFormulaService.registerFormula(unitId, subUnitId, formulaString, { ruleId });
+  }
+  deleteByRuleId(unitId, subUnitId, ruleId) {
+    const { formulaMap, formulaCellMap, ruleFormulaMap } = this._ensureMaps(unitId, subUnitId), rule = this._dataValidationModel.getRuleById(unitId, subUnitId, ruleId), formulaIdList = /* @__PURE__ */ new Set(), formulaInfo = ruleFormulaMap.get(ruleId);
+    !rule || !formulaInfo || (ruleFormulaMap.delete(ruleId), rule.ranges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        const value = formulaMap.getValue(row, col);
+        if (value && value.ruleId === ruleId) {
+          const { formulaId } = value;
+          formulaMap.realDeleteValue(row, col), formulaIdList.add(formulaId), formulaCellMap.delete(formulaId);
+        }
+      });
+    }), this._registerOtherFormulaService.deleteFormula(unitId, subUnitId, Array.from(formulaIdList.values())));
+  }
+  _addFormulaByRange(unitId, subUnitId, ruleId, formula, ranges) {
+    const { formulaMap, ruleFormulaMap, formulaCellMap } = this._ensureMaps(unitId, subUnitId);
+    if (!formula)
+      return;
+    const originRow = ranges[0].startRow, originCol = ranges[0].startColumn;
+    let originFormulaId;
+    ranges.forEach((range) => {
+      Range.foreach(range, (row, column) => {
+        const relativeFormula = transformFormula(
+          this._lexerTreeBuilder,
+          formula,
+          originRow,
+          originCol,
+          row,
+          column
+        ), formulaId = this._registerFormula(unitId, subUnitId, ruleId, relativeFormula);
+        formulaMap.setValue(row, column, {
+          formulaId,
+          // formulaText: relativeFormula,
+          ruleId
+        }), formulaCellMap.set(formulaId, { row, column });
+      });
+    }), ruleFormulaMap.set(ruleId, {
+      formula,
+      originCol,
+      originRow,
+      formulaId: originFormulaId,
+      isTransformable: !0
+    });
+  }
+  addRule(unitId, subUnitId, rule) {
+    const { ranges, formula1, uid: ruleId, type } = rule;
+    type !== DataValidationType.CUSTOM || !formula1 || !isFormulaString(formula1) || this._addFormulaByRange(unitId, subUnitId, ruleId, formula1, ranges);
+  }
+  updateRuleRanges(unitId, subUnitId, ruleId, oldRanges, newRanges) {
+    const { formulaMap, ruleFormulaMap, formulaCellMap } = this._ensureMaps(unitId, subUnitId), info = ruleFormulaMap.get(ruleId);
+    if (!info)
+      return;
+    const { formula, originCol, originRow, isTransformable, formulaId } = info, deleteFormulaIdList = /* @__PURE__ */ new Set();
+    oldRanges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        const value = formulaMap.getValue(row, col);
+        value && value.ruleId === ruleId && (value.temp = !0);
+      });
+    }), newRanges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        var _a7;
+        const oldValue = (_a7 = formulaMap.getValue(row, col)) != null ? _a7 : {};
+        if (oldValue.ruleId !== ruleId) {
+          const oldRuleFormula = ruleFormulaMap.get(oldValue.ruleId);
+          if (oldRuleFormula != null && oldRuleFormula.isTransformable && deleteFormulaIdList.add(oldValue.formulaId), isTransformable) {
+            const relativeText = transformFormula(this._lexerTreeBuilder, formula, originRow, originCol, row, col), formulaId2 = this._registerFormula(unitId, subUnitId, ruleId, relativeText);
+            formulaMap.setValue(row, col, {
+              ruleId,
+              formulaId: formulaId2
+            }), formulaCellMap.set(formulaId2, { row, column: col });
+          } else
+            formulaMap.setValue(row, col, {
+              // formulaText: formula,
+              ruleId,
+              formulaId
+            });
+        } else
+          oldValue.temp = !1;
+      });
+    }), oldRanges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        const value = formulaMap.getValue(row, col);
+        value && value.ruleId === ruleId && value.temp === !0 && (formulaMap.realDeleteValue(row, col), isTransformable && deleteFormulaIdList.add(value.formulaId));
+      });
+    }), deleteFormulaIdList.forEach((formulaId2) => {
+      formulaCellMap.delete(formulaId2);
+    }), this._registerOtherFormulaService.deleteFormula(unitId, subUnitId, Array.from(deleteFormulaIdList.values()));
+  }
+  updateRuleFormula(unitId, subUnitId, ruleId, ranges, formula) {
+    const { ruleFormulaMap } = this._ensureMaps(unitId, subUnitId), current = ruleFormulaMap.get(ruleId);
+    (!current || current.formula !== formula) && this._addFormulaByRange(unitId, subUnitId, ruleId, formula, ranges);
+  }
+  getCellFormulaValue(unitId, subUnitId, row, col) {
+    const { formulaMap } = this._ensureMaps(unitId, subUnitId), current = formulaMap.getValue(row, col);
+    return current ? this._registerOtherFormulaService.getFormulaValue(unitId, subUnitId, current.formulaId) : Promise.resolve(void 0);
+  }
+  getRuleFormulaInfo(unitId, subUnitId, ruleId) {
+    const { ruleFormulaMap } = this._ensureMaps(unitId, subUnitId);
+    return ruleFormulaMap.get(ruleId);
+  }
+}, __name(_a2, "DataValidationCustomFormulaService"), _a2);
+DataValidationCustomFormulaService = __decorateClass$3([
+  __decorateParam$3(0, IUniverInstanceService),
+  __decorateParam$3(1, Inject(RegisterOtherFormulaService)),
+  __decorateParam$3(2, Inject(LexerTreeBuilder)),
+  __decorateParam$3(3, Inject(DataValidationModel)),
+  __decorateParam$3(4, Inject(DataValidationCacheService)),
+  __decorateParam$3(5, Inject(Injector))
+], DataValidationCustomFormulaService);
+var __defProp$2 = Object.defineProperty, __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor, __decorateClass$2 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$2(target, key, result), result;
+}, "__decorateClass$2"), __decorateParam$2 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$2"), _a3;
+let DataValidationFormulaService = (_a3 = class extends Disposable {
+  constructor(_instanceService, _registerOtherFormulaService, _dataValidationCacheService, _dataValidationModel) {
+    super();
+    __publicField(this, "_formulaRuleMap", /* @__PURE__ */ new Map());
+    this._instanceService = _instanceService, this._registerOtherFormulaService = _registerOtherFormulaService, this._dataValidationCacheService = _dataValidationCacheService, this._dataValidationModel = _dataValidationModel, this._initFormulaResultHandler();
+  }
+  _initFormulaResultHandler() {
+    this.disposeWithMe(this._registerOtherFormulaService.formulaResult$.subscribe((resultMap) => {
+      for (const unitId in resultMap) {
+        const unitMap = resultMap[unitId];
+        if (this._instanceService.getUnitType(unitId) === UniverInstanceType.UNIVER_SHEET)
+          for (const subUnitId in unitMap) {
+            const results = unitMap[subUnitId], formulaMap = this._ensureRuleFormulaMap(unitId, subUnitId);
+            results.forEach((result) => {
+              var _a7, _b;
+              if (formulaMap.get((_a7 = result.extra) == null ? void 0 : _a7.ruleId)) {
+                const rule = this._dataValidationModel.getRuleById(unitId, subUnitId, (_b = result.extra) == null ? void 0 : _b.ruleId);
+                rule && this._dataValidationCacheService.markRangeDirty(unitId, subUnitId, rule.ranges);
+              }
+            });
+          }
+      }
+    }));
+  }
+  _ensureRuleFormulaMap(unitId, subUnitId) {
+    let unitMap = this._formulaRuleMap.get(unitId);
+    unitMap || (unitMap = /* @__PURE__ */ new Map(), this._formulaRuleMap.set(unitId, unitMap));
+    let subUnitMap = unitMap.get(subUnitId);
+    return subUnitMap || (subUnitMap = /* @__PURE__ */ new Map(), unitMap.set(subUnitId, subUnitMap)), subUnitMap;
+  }
+  addRule(unitId, subUnitId, ruleId, formula1, formula2) {
+    const isFormula1Legal = isFormulaString(formula1), isFormula2Legal = isFormulaString(formula2);
+    if (!isFormula1Legal && !isFormula2Legal)
+      return;
+    const formulaRuleMap = this._ensureRuleFormulaMap(unitId, subUnitId), item = [void 0, void 0];
+    if (isFormula1Legal) {
+      const id = this._registerOtherFormulaService.registerFormula(unitId, subUnitId, formula1, { ruleId });
+      item[0] = { id, text: formula1 };
+    }
+    if (isFormula2Legal) {
+      const id = this._registerOtherFormulaService.registerFormula(unitId, subUnitId, formula2, { ruleId });
+      item[1] = { id, text: formula2 };
+    }
+    formulaRuleMap.set(ruleId, item);
+  }
+  removeRule(unitId, subUnitId, ruleId) {
+    const item = this._ensureRuleFormulaMap(unitId, subUnitId).get(ruleId);
+    if (!item)
+      return;
+    const [formula1, formula2] = item, idList = [formula1 == null ? void 0 : formula1.id, formula2 == null ? void 0 : formula2.id].filter(Boolean);
+    idList.length && this._registerOtherFormulaService.deleteFormula(unitId, subUnitId, idList);
+  }
+  updateRuleFormulaText(unitId, subUnitId, ruleId, formula1, formula2) {
+    const item = this._ensureRuleFormulaMap(unitId, subUnitId).get(ruleId);
+    if (!item) {
+      this.addRule(unitId, subUnitId, ruleId, formula1, formula2);
+      return;
+    }
+    const [oldFormula1, oldFormula2] = item;
+    if ((oldFormula1 == null ? void 0 : oldFormula1.text) !== formula1)
+      if (oldFormula1 && this._registerOtherFormulaService.deleteFormula(unitId, subUnitId, [oldFormula1.id]), isFormulaString(formula1)) {
+        const formulaId = this._registerOtherFormulaService.registerFormula(unitId, subUnitId, formula1, { ruleId });
+        item[0] = {
+          text: formula1,
+          id: formulaId
+        };
+      } else
+        item[0] = void 0;
+    if ((oldFormula2 == null ? void 0 : oldFormula2.text) !== formula2)
+      if (oldFormula2 && this._registerOtherFormulaService.deleteFormula(unitId, subUnitId, [oldFormula2.id]), isFormulaString(formula2)) {
+        const formulaId = this._registerOtherFormulaService.registerFormula(unitId, subUnitId, formula2, { ruleId });
+        item[1] = {
+          text: formula2,
+          id: formulaId
+        };
+      } else
+        item[1] = void 0;
+  }
+  getRuleFormulaResult(unitId, subUnitId, ruleId) {
+    const formulaInfo = this._ensureRuleFormulaMap(unitId, subUnitId).get(ruleId);
+    if (!formulaInfo)
+      return Promise.resolve(null);
+    const getResult = /* @__PURE__ */ __name(async (info) => info && this._registerOtherFormulaService.getFormulaValue(unitId, subUnitId, info.id), "getResult");
+    return Promise.all([
+      getResult(formulaInfo[0]),
+      getResult(formulaInfo[1])
+    ]);
+  }
+  getRuleFormulaResultSync(unitId, subUnitId, ruleId) {
+    const formulaInfo = this._ensureRuleFormulaMap(unitId, subUnitId).get(ruleId);
+    if (formulaInfo)
+      return formulaInfo.map((i) => {
+        if (i)
+          return this._registerOtherFormulaService.getFormulaValueSync(unitId, subUnitId, i.id);
+      });
+  }
+  getRuleFormulaInfo(unitId, subUnitId, ruleId) {
+    return this._ensureRuleFormulaMap(unitId, subUnitId).get(ruleId);
+  }
+}, __name(_a3, "DataValidationFormulaService"), _a3);
+DataValidationFormulaService = __decorateClass$2([
+  __decorateParam$2(0, IUniverInstanceService),
+  __decorateParam$2(1, Inject(RegisterOtherFormulaService)),
+  __decorateParam$2(2, Inject(DataValidationCacheService)),
+  __decorateParam$2(3, Inject(DataValidationModel))
+], DataValidationFormulaService);
+function getCellValueOrigin(cell) {
+  return getOriginCellValue(cell);
+}
+__name(getCellValueOrigin, "getCellValueOrigin");
+function getStringCellValue(cell) {
+  var _a7;
+  return String((_a7 = getCellValueOrigin(cell)) != null ? _a7 : "");
+}
+__name(getStringCellValue, "getStringCellValue");
+var _a4;
+const Interval = (_a4 = class {
+  /**
+   * Accept two comparable values and creates new instance of interval
+   * Predicate Interval.comparable_less(low, high) supposed to return true on these values
+   * @param low
+   * @param high
+   */
+  constructor(low, high) {
+    this.low = low, this.high = high;
+  }
+  /**
+   * Clone interval
+   * @returns {Interval}
+   */
+  clone() {
+    return new _a4(this.low, this.high);
+  }
+  /**
+   * Propery max returns clone of this interval
+   * @returns {Interval}
+   */
+  get max() {
+    return this.clone();
+  }
+  /**
+   * Predicate returns true is this interval less than other interval
+   * @param other_interval
+   * @returns {boolean}
+   */
+  less_than(other_interval) {
+    return this.low < other_interval.low || this.low === other_interval.low && this.high < other_interval.high;
+  }
+  /**
+   * Predicate returns true is this interval equals to other interval
+   * @param other_interval
+   * @returns {boolean}
+   */
+  equal_to(other_interval) {
+    return this.low === other_interval.low && this.high === other_interval.high;
+  }
+  /**
+   * Predicate returns true if this interval intersects other interval
+   * @param other_interval
+   * @returns {boolean}
+   */
+  intersect(other_interval) {
+    return !this.not_intersect(other_interval);
+  }
+  /**
+   * Predicate returns true if this interval does not intersect other interval
+   * @param other_interval
+   * @returns {boolean}
+   */
+  not_intersect(other_interval) {
+    return this.high < other_interval.low || other_interval.high < this.low;
+  }
+  /**
+   * Returns new interval merged with other interval
+   * @param {Interval} other_interval - Other interval to merge with
+   * @returns {Interval}
+   */
+  merge(other_interval) {
+    return new _a4(
+      this.low === void 0 ? other_interval.low : this.low < other_interval.low ? this.low : other_interval.low,
+      this.high === void 0 ? other_interval.high : this.high > other_interval.high ? this.high : other_interval.high
+    );
+  }
+  /**
+   * Returns how key should return
+   */
+  output() {
+    return [this.low, this.high];
+  }
+  /**
+   * Function returns maximum between two comparable values
+   * @param interval1
+   * @param interval2
+   * @returns {Interval}
+   */
+  static comparable_max(interval1, interval2) {
+    return interval1.merge(interval2);
+  }
+  /**
+   * Predicate returns true if first value less than second value
+   * @param val1
+   * @param val2
+   * @returns {boolean}
+   */
+  static comparable_less_than(val1, val2) {
+    return val1 < val2;
+  }
+}, __name(_a4, "Interval"), _a4), RB_TREE_COLOR_RED = 0, RB_TREE_COLOR_BLACK = 1, _Node = class _Node {
+  constructor(key = void 0, value = void 0, left = null, right = null, parent = null, color = RB_TREE_COLOR_BLACK) {
+    if (this.left = left, this.right = right, this.parent = parent, this.color = color, this.item = { key, value }, key && key instanceof Array && key.length === 2 && !Number.isNaN(key[0]) && !Number.isNaN(key[1])) {
+      let [low, high] = key;
+      low > high && ([low, high] = [high, low]), this.item.key = new Interval(low, high);
+    }
+    this.max = this.item.key ? this.item.key.max : void 0;
+  }
+  isNil() {
+    return this.item.key === void 0 && this.item.value === void 0 && this.left === null && this.right === null && this.color === RB_TREE_COLOR_BLACK;
+  }
+  _value_less_than(other_node) {
+    return this.item.value && other_node.item.value && this.item.value.less_than ? this.item.value.less_than(other_node.item.value) : this.item.value < other_node.item.value;
+  }
+  less_than(other_node) {
+    return this.item.value === this.item.key && other_node.item.value === other_node.item.key ? this.item.key.less_than(other_node.item.key) : this.item.key.less_than(other_node.item.key) || this.item.key.equal_to(other_node.item.key) && this._value_less_than(other_node);
+  }
+  _value_equal(other_node) {
+    return this.item.value && other_node.item.value && this.item.value.equal_to ? this.item.value.equal_to(other_node.item.value) : this.item.value === other_node.item.value;
+  }
+  equal_to(other_node) {
+    return this.item.value === this.item.key && other_node.item.value === other_node.item.key ? this.item.key.equal_to(other_node.item.key) : this.item.key.equal_to(other_node.item.key) && this._value_equal(other_node);
+  }
+  intersect(other_node) {
+    return this.item.key.intersect(other_node.item.key);
+  }
+  copy_data(other_node) {
+    this.item.key = other_node.item.key, this.item.value = other_node.item.value;
+  }
+  update_max() {
+    if (this.max = this.item.key ? this.item.key.max : void 0, this.right && this.right.max) {
+      const comparable_max = this.item.key.constructor.comparable_max;
+      this.max = comparable_max(this.max, this.right.max);
+    }
+    if (this.left && this.left.max) {
+      const comparable_max = this.item.key.constructor.comparable_max;
+      this.max = comparable_max(this.max, this.left.max);
+    }
+  }
+  // Other_node does not intersect any node of left subtree, if this.left.max < other_node.item.key.low
+  not_intersect_left_subtree(search_node) {
+    const comparable_less_than = this.item.key.constructor.comparable_less_than;
+    let high = this.left.max.high !== void 0 ? this.left.max.high : this.left.max;
+    return comparable_less_than(high, search_node.item.key.low);
+  }
+  // Other_node does not intersect right subtree if other_node.item.key.high < this.right.key.low
+  not_intersect_right_subtree(search_node) {
+    const comparable_less_than = this.item.key.constructor.comparable_less_than;
+    let low = this.right.max.low !== void 0 ? this.right.max.low : this.right.item.key.low;
+    return comparable_less_than(search_node.item.key.high, low);
+  }
+};
+__name(_Node, "Node");
+let Node = _Node;
+const _IntervalTree = class _IntervalTree {
+  /**
+   * Construct new empty instance of IntervalTree
+   */
+  constructor() {
+    this.root = null, this.nil_node = new Node();
+  }
+  /**
+   * Returns number of items stored in the interval tree
+   * @returns {number}
+   */
+  get size() {
+    let count = 0;
+    return this.tree_walk(this.root, () => count++), count;
+  }
+  /**
+   * Returns array of sorted keys in the ascending order
+   * @returns {Array}
+   */
+  get keys() {
+    let res = [];
+    return this.tree_walk(this.root, (node) => res.push(
+      node.item.key.output ? node.item.key.output() : node.item.key
+    )), res;
+  }
+  /**
+   * Return array of values in the ascending keys order
+   * @returns {Array}
+   */
+  get values() {
+    let res = [];
+    return this.tree_walk(this.root, (node) => res.push(node.item.value)), res;
+  }
+  /**
+   * Returns array of items (<key,value> pairs) in the ascended keys order
+   * @returns {Array}
+   */
+  get items() {
+    let res = [];
+    return this.tree_walk(this.root, (node) => res.push({
+      key: node.item.key.output ? node.item.key.output() : node.item.key,
+      value: node.item.value
+    })), res;
+  }
+  /**
+   * Returns true if tree is empty
+   * @returns {boolean}
+   */
+  isEmpty() {
+    return this.root == null || this.root === this.nil_node;
+  }
+  /**
+   * Clear tree
+   */
+  clear() {
+    this.root = null;
+  }
+  /**
+   * Insert new item into interval tree
+   * @param {Interval} key - interval object or array of two numbers [low, high]
+   * @param {any} value - value representing any object (optional)
+   * @returns {Node} returns reference to inserted node as an object {key:interval, value: value}
+   */
+  insert(key, value = key) {
+    if (key === void 0) return;
+    let insert_node = new Node(key, value, this.nil_node, this.nil_node, null, RB_TREE_COLOR_RED);
+    return this.tree_insert(insert_node), this.recalc_max(insert_node), insert_node;
+  }
+  /**
+   * Returns true if item {key,value} exist in the tree
+   * @param {Interval} key - interval correspondent to keys stored in the tree
+   * @param {any} value - value object to be checked
+   * @returns {boolean} true if item {key, value} exist in the tree, false otherwise
+   */
+  exist(key, value = key) {
+    let search_node = new Node(key, value);
+    return !!this.tree_search(this.root, search_node);
+  }
+  /**
+   * Remove entry {key, value} from the tree
+   * @param {Interval} key - interval correspondent to keys stored in the tree
+   * @param {any} value - value object
+   * @returns {boolean} true if item {key, value} deleted, false if not found
+   */
+  remove(key, value = key) {
+    let search_node = new Node(key, value), delete_node = this.tree_search(this.root, search_node);
+    return delete_node && this.tree_delete(delete_node), delete_node;
+  }
+  /**
+   * Returns array of entry values which keys intersect with given interval <br/>
+   * If no values stored in the tree, returns array of keys which intersect given interval
+   * @param {Interval} interval - search interval, or tuple [low, high]
+   * @param outputMapperFn(value,key) - optional function that maps (value, key) to custom output
+   * @returns {Array}
+   */
+  search(interval, outputMapperFn = (value, key) => value === key ? key.output() : value) {
+    let search_node = new Node(interval), resp_nodes = [];
+    return this.tree_search_interval(this.root, search_node, resp_nodes), resp_nodes.map((node) => outputMapperFn(node.item.value, node.item.key));
+  }
+  /**
+   * Returns true if intersection between given and any interval stored in the tree found
+   * @param {Interval} interval - search interval or tuple [low, high]
+   * @returns {boolean}
+   */
+  intersect_any(interval) {
+    let search_node = new Node(interval);
+    return this.tree_find_any_interval(this.root, search_node);
+  }
+  /**
+   * Tree visitor. For each node implement a callback function. <br/>
+   * Method calls a callback function with two parameters (key, value)
+   * @param visitor(key,value) - function to be called for each tree item
+   */
+  forEach(visitor) {
+    this.tree_walk(this.root, (node) => visitor(node.item.key, node.item.value));
+  }
+  /**
+   * Value Mapper. Walk through every node and map node value to another value
+   * @param callback(value,key) - function to be called for each tree item
+   */
+  map(callback) {
+    const tree = new _IntervalTree();
+    return this.tree_walk(this.root, (node) => tree.insert(node.item.key, callback(node.item.value, node.item.key))), tree;
+  }
+  /**
+   * @param {Interval} interval - optional if the iterator is intended to start from the beginning
+   * @param outputMapperFn(value,key) - optional function that maps (value, key) to custom output
+   * @returns {Iterator}
+   */
+  *iterate(interval, outputMapperFn = (value, key) => value === key ? key.output() : value) {
+    let node;
+    for (interval ? node = this.tree_search_nearest_forward(this.root, new Node(interval)) : this.root && (node = this.local_minimum(this.root)); node; )
+      yield outputMapperFn(node.item.value, node.item.key), node = this.tree_successor(node);
+  }
+  recalc_max(node) {
+    let node_current = node;
+    for (; node_current.parent != null; )
+      node_current.parent.update_max(), node_current = node_current.parent;
+  }
+  tree_insert(insert_node) {
+    let current_node = this.root, parent_node = null;
+    if (this.root == null || this.root === this.nil_node)
+      this.root = insert_node;
+    else {
+      for (; current_node !== this.nil_node; )
+        parent_node = current_node, insert_node.less_than(current_node) ? current_node = current_node.left : current_node = current_node.right;
+      insert_node.parent = parent_node, insert_node.less_than(parent_node) ? parent_node.left = insert_node : parent_node.right = insert_node;
+    }
+    this.insert_fixup(insert_node);
+  }
+  // After insertion insert_node may have red-colored parent, and this is a single possible violation
+  // Go upwords to the root and re-color until violation will be resolved
+  insert_fixup(insert_node) {
+    let current_node, uncle_node;
+    for (current_node = insert_node; current_node !== this.root && current_node.parent.color === RB_TREE_COLOR_RED; )
+      current_node.parent === current_node.parent.parent.left ? (uncle_node = current_node.parent.parent.right, uncle_node.color === RB_TREE_COLOR_RED ? (current_node.parent.color = RB_TREE_COLOR_BLACK, uncle_node.color = RB_TREE_COLOR_BLACK, current_node.parent.parent.color = RB_TREE_COLOR_RED, current_node = current_node.parent.parent) : (current_node === current_node.parent.right && (current_node = current_node.parent, this.rotate_left(current_node)), current_node.parent.color = RB_TREE_COLOR_BLACK, current_node.parent.parent.color = RB_TREE_COLOR_RED, this.rotate_right(current_node.parent.parent))) : (uncle_node = current_node.parent.parent.left, uncle_node.color === RB_TREE_COLOR_RED ? (current_node.parent.color = RB_TREE_COLOR_BLACK, uncle_node.color = RB_TREE_COLOR_BLACK, current_node.parent.parent.color = RB_TREE_COLOR_RED, current_node = current_node.parent.parent) : (current_node === current_node.parent.left && (current_node = current_node.parent, this.rotate_right(current_node)), current_node.parent.color = RB_TREE_COLOR_BLACK, current_node.parent.parent.color = RB_TREE_COLOR_RED, this.rotate_left(current_node.parent.parent)));
+    this.root.color = RB_TREE_COLOR_BLACK;
+  }
+  tree_delete(delete_node) {
+    let cut_node, fix_node;
+    delete_node.left === this.nil_node || delete_node.right === this.nil_node ? cut_node = delete_node : cut_node = this.tree_successor(delete_node), cut_node.left !== this.nil_node ? fix_node = cut_node.left : fix_node = cut_node.right, fix_node.parent = cut_node.parent, cut_node === this.root ? this.root = fix_node : (cut_node === cut_node.parent.left ? cut_node.parent.left = fix_node : cut_node.parent.right = fix_node, cut_node.parent.update_max()), this.recalc_max(fix_node), cut_node !== delete_node && (delete_node.copy_data(cut_node), delete_node.update_max(), this.recalc_max(delete_node)), /*fix_node != this.nil_node && */
+    cut_node.color === RB_TREE_COLOR_BLACK && this.delete_fixup(fix_node);
+  }
+  delete_fixup(fix_node) {
+    let current_node = fix_node, brother_node;
+    for (; current_node !== this.root && current_node.parent != null && current_node.color === RB_TREE_COLOR_BLACK; )
+      current_node === current_node.parent.left ? (brother_node = current_node.parent.right, brother_node.color === RB_TREE_COLOR_RED && (brother_node.color = RB_TREE_COLOR_BLACK, current_node.parent.color = RB_TREE_COLOR_RED, this.rotate_left(current_node.parent), brother_node = current_node.parent.right), brother_node.left.color === RB_TREE_COLOR_BLACK && brother_node.right.color === RB_TREE_COLOR_BLACK ? (brother_node.color = RB_TREE_COLOR_RED, current_node = current_node.parent) : (brother_node.right.color === RB_TREE_COLOR_BLACK && (brother_node.color = RB_TREE_COLOR_RED, brother_node.left.color = RB_TREE_COLOR_BLACK, this.rotate_right(brother_node), brother_node = current_node.parent.right), brother_node.color = current_node.parent.color, current_node.parent.color = RB_TREE_COLOR_BLACK, brother_node.right.color = RB_TREE_COLOR_BLACK, this.rotate_left(current_node.parent), current_node = this.root)) : (brother_node = current_node.parent.left, brother_node.color === RB_TREE_COLOR_RED && (brother_node.color = RB_TREE_COLOR_BLACK, current_node.parent.color = RB_TREE_COLOR_RED, this.rotate_right(current_node.parent), brother_node = current_node.parent.left), brother_node.left.color === RB_TREE_COLOR_BLACK && brother_node.right.color === RB_TREE_COLOR_BLACK ? (brother_node.color = RB_TREE_COLOR_RED, current_node = current_node.parent) : (brother_node.left.color === RB_TREE_COLOR_BLACK && (brother_node.color = RB_TREE_COLOR_RED, brother_node.right.color = RB_TREE_COLOR_BLACK, this.rotate_left(brother_node), brother_node = current_node.parent.left), brother_node.color = current_node.parent.color, current_node.parent.color = RB_TREE_COLOR_BLACK, brother_node.left.color = RB_TREE_COLOR_BLACK, this.rotate_right(current_node.parent), current_node = this.root));
+    current_node.color = RB_TREE_COLOR_BLACK;
+  }
+  tree_search(node, search_node) {
+    if (!(node == null || node === this.nil_node))
+      return search_node.equal_to(node) ? node : search_node.less_than(node) ? this.tree_search(node.left, search_node) : this.tree_search(node.right, search_node);
+  }
+  tree_search_nearest_forward(node, search_node) {
+    let best, curr = node;
+    for (; curr && curr !== this.nil_node; )
+      curr.less_than(search_node) ? curr.intersect(search_node) ? (best = curr, curr = curr.left) : curr = curr.right : ((!best || curr.less_than(best)) && (best = curr), curr = curr.left);
+    return best || null;
+  }
+  // Original search_interval method; container res support push() insertion
+  // Search all intervals intersecting given one
+  tree_search_interval(node, search_node, res) {
+    node != null && node !== this.nil_node && (node.left !== this.nil_node && !node.not_intersect_left_subtree(search_node) && this.tree_search_interval(node.left, search_node, res), node.intersect(search_node) && res.push(node), node.right !== this.nil_node && !node.not_intersect_right_subtree(search_node) && this.tree_search_interval(node.right, search_node, res));
+  }
+  tree_find_any_interval(node, search_node) {
+    let found = !1;
+    return node != null && node !== this.nil_node && (node.left !== this.nil_node && !node.not_intersect_left_subtree(search_node) && (found = this.tree_find_any_interval(node.left, search_node)), found || (found = node.intersect(search_node)), !found && node.right !== this.nil_node && !node.not_intersect_right_subtree(search_node) && (found = this.tree_find_any_interval(node.right, search_node))), found;
+  }
+  local_minimum(node) {
+    let node_min = node;
+    for (; node_min.left != null && node_min.left !== this.nil_node; )
+      node_min = node_min.left;
+    return node_min;
+  }
+  // not in use
+  local_maximum(node) {
+    let node_max = node;
+    for (; node_max.right != null && node_max.right !== this.nil_node; )
+      node_max = node_max.right;
+    return node_max;
+  }
+  tree_successor(node) {
+    let node_successor, current_node, parent_node;
+    if (node.right !== this.nil_node)
+      node_successor = this.local_minimum(node.right);
+    else {
+      for (current_node = node, parent_node = node.parent; parent_node != null && parent_node.right === current_node; )
+        current_node = parent_node, parent_node = parent_node.parent;
+      node_successor = parent_node;
+    }
+    return node_successor;
+  }
+  //           |            right-rotate(T,y)       |
+  //           y            ---------------.       x
+  //          / \                                  / \
+  //         x   c          left-rotate(T,x)      a   y
+  //        / \             <---------------         / \
+  //       a   b                                    b   c
+  rotate_left(x) {
+    let y = x.right;
+    x.right = y.left, y.left !== this.nil_node && (y.left.parent = x), y.parent = x.parent, x === this.root ? this.root = y : x === x.parent.left ? x.parent.left = y : x.parent.right = y, y.left = x, x.parent = y, x != null && x !== this.nil_node && x.update_max(), y = x.parent, y != null && y !== this.nil_node && y.update_max();
+  }
+  rotate_right(y) {
+    let x = y.left;
+    y.left = x.right, x.right !== this.nil_node && (x.right.parent = y), x.parent = y.parent, y === this.root ? this.root = x : y === y.parent.left ? y.parent.left = x : y.parent.right = x, x.right = y, y.parent = x, y !== null && y !== this.nil_node && y.update_max(), x = y.parent, x != null && x !== this.nil_node && x.update_max();
+  }
+  tree_walk(node, action) {
+    node != null && node !== this.nil_node && (this.tree_walk(node.left, action), action(node), this.tree_walk(node.right, action));
+  }
+  /* Return true if all red nodes have exactly two black child nodes */
+  testRedBlackProperty() {
+    let res = !0;
+    return this.tree_walk(this.root, function(node) {
+      node.color === RB_TREE_COLOR_RED && (node.left.color === RB_TREE_COLOR_BLACK && node.right.color === RB_TREE_COLOR_BLACK || (res = !1));
+    }), res;
+  }
+  /* Throw error if not every path from root to bottom has same black height */
+  testBlackHeightProperty(node) {
+    let height = 0, heightLeft = 0, heightRight = 0;
+    if (node.color === RB_TREE_COLOR_BLACK && height++, node.left !== this.nil_node ? heightLeft = this.testBlackHeightProperty(node.left) : heightLeft = 1, node.right !== this.nil_node ? heightRight = this.testBlackHeightProperty(node.right) : heightRight = 1, heightLeft !== heightRight)
+      throw new Error("Red-black height property violated");
+    return height += heightLeft, height;
+  }
+};
+__name(_IntervalTree, "IntervalTree");
+let IntervalTree = _IntervalTree;
+const _RuleMatrix = class _RuleMatrix {
+  constructor(value, _unitId, _subUnitId, _univerInstanceService, _disableTree = !1) {
+    __publicField(this, "_map");
+    __publicField(this, "_tree", /* @__PURE__ */ new Map());
+    __publicField(this, "_dirty", !0);
+    __publicField(this, "_buildTree", /* @__PURE__ */ __name(() => {
+      if (!this._dirty || this._disableTree)
+        return;
+      const map = /* @__PURE__ */ new Map();
+      this._map.forEach((ranges, ruleId) => {
+        ranges.forEach((range) => {
+          for (let col = range.startColumn; col <= range.endColumn; col++) {
+            let items = map.get(col);
+            items || (items = [], map.set(col, items)), items.push({
+              startRow: range.startRow,
+              endRow: range.endRow,
+              ruleId
+            });
+          }
+        });
+      });
+      const treeMap = /* @__PURE__ */ new Map();
+      map.forEach((items, col) => {
+        const tree = new IntervalTree();
+        items.forEach((item) => {
+          tree.insert([item.startRow, item.endRow], item.ruleId);
+        }), treeMap.set(col, tree);
+      }), this._tree = treeMap, this._dirty = !1;
+    }, "_buildTree"));
+    __publicField(this, "_debonceBuildTree", debounce(this._buildTree, 0));
+    this._unitId = _unitId, this._subUnitId = _subUnitId, this._univerInstanceService = _univerInstanceService, this._disableTree = _disableTree, this._map = value, this._buildTree();
+  }
+  get _worksheet() {
+    var _a7;
+    return (_a7 = this._univerInstanceService.getUnit(this._unitId, UniverInstanceType.UNIVER_SHEET)) == null ? void 0 : _a7.getSheetBySheetId(this._subUnitId);
+  }
+  addRule(rule) {
+    if (!this._worksheet)
+      return;
+    const ruleId = rule.uid, ranges = rule.ranges.map((range) => Range.transformRange(range, this._worksheet));
+    this._map.forEach((value, key) => {
+      const newRanges = Rectangle.subtractMulti(value, ranges);
+      newRanges.length === 0 ? this._map.delete(key) : this._map.set(key, newRanges);
+    }), this._dirty = !0, this._map.set(ruleId, ranges), this._debonceBuildTree();
+  }
+  removeRange(_ranges) {
+    if (!this._worksheet)
+      return;
+    const ranges = _ranges.map((range) => Range.transformRange(range, this._worksheet));
+    this._map.forEach((value, key) => {
+      const newRanges = Rectangle.subtractMulti(value, ranges);
+      newRanges.length === 0 ? this._map.delete(key) : this._map.set(key, newRanges);
+    }), this._dirty = !0, this._debonceBuildTree();
+  }
+  removeRule(rule) {
+    this._map.delete(rule.uid), this._dirty = !0, this._debonceBuildTree();
+  }
+  updateRange(ruleId, _newRanges) {
+    if (!this._worksheet)
+      return;
+    this._map.delete(ruleId);
+    const ranges = _newRanges.map((range) => Range.transformRange(range, this._worksheet));
+    this._map.forEach((value, key) => {
+      const newRanges = Rectangle.subtractMulti(value, ranges);
+      newRanges.length === 0 ? this._map.delete(key) : this._map.set(key, newRanges);
+    }), this._map.set(ruleId, ranges), this._dirty = !0, this._debonceBuildTree();
+  }
+  addRangeRules(rules) {
+    rules.forEach(({ id: ruleId, ranges }) => {
+      if (!ranges.length)
+        return;
+      let current = this._map.get(ruleId);
+      current ? (this._map.set(ruleId, Rectangle.mergeRanges([...current, ...ranges])), current = this._map.get(ruleId)) : (current = ranges, this._map.set(ruleId, current)), this._map.forEach((value, key) => {
+        if (key === ruleId)
+          return;
+        const newRanges = Rectangle.subtractMulti(value, ranges);
+        newRanges.length === 0 ? this._map.delete(key) : this._map.set(key, newRanges);
+      });
+    }), this._dirty = !0, this._debonceBuildTree();
+  }
+  diff(rules) {
+    const mutations = [];
+    let deleteIndex = 0;
+    return rules.forEach((rule, index) => {
+      var _a7;
+      const newRanges = (_a7 = this._map.get(rule.uid)) != null ? _a7 : [], oldRanges = rule.ranges;
+      newRanges.length !== 0 && (newRanges.length !== oldRanges.length || newRanges.some((range, i) => !Rectangle.equals(range, oldRanges[i]))) && mutations.push({
+        type: "update",
+        ruleId: rule.uid,
+        oldRanges,
+        newRanges: Rectangle.sort(newRanges),
+        rule
+      }), newRanges.length === 0 && (mutations.push({
+        type: "delete",
+        rule,
+        index: index - deleteIndex
+      }), deleteIndex++);
+    }), mutations;
+  }
+  diffWithAddition(rules, additionRules) {
+    const mutations = [];
+    let deleteIndex = 0;
+    return rules.forEach((rule, index) => {
+      var _a7;
+      const newRanges = (_a7 = this._map.get(rule.uid)) != null ? _a7 : [], oldRanges = rule.ranges;
+      newRanges.length !== 0 && (newRanges.length !== oldRanges.length || newRanges.some((range, i) => !Rectangle.equals(range, oldRanges[i]))) && mutations.push({
+        type: "update",
+        ruleId: rule.uid,
+        oldRanges,
+        newRanges: Rectangle.sort(newRanges),
+        rule
+      }), newRanges.length === 0 && (mutations.push({
+        type: "delete",
+        rule,
+        index: index - deleteIndex
+      }), deleteIndex++);
+    }), Array.from(additionRules).forEach((rule) => {
+      var _a7;
+      const newRanges = (_a7 = this._map.get(rule.uid)) != null ? _a7 : [];
+      mutations.push({
+        type: "add",
+        rule: {
+          ...rule,
+          ranges: Rectangle.sort(newRanges)
+        }
+      });
+    }), mutations;
+  }
+  clone() {
+    return new _RuleMatrix(
+      new Map(Tools.deepClone(Array.from(this._map.entries()))),
+      this._unitId,
+      this._subUnitId,
+      this._univerInstanceService,
+      // disable tree on cloned matrix, cause there is no need to search
+      !0
+    );
+  }
+  getValue(row, col) {
+    this._dirty && this._buildTree();
+    const tree = this._tree.get(col);
+    if (!tree)
+      return;
+    const result = tree.search([row, row]);
+    return result.length > 0 ? result[0] : void 0;
+  }
+};
+__name(_RuleMatrix, "RuleMatrix");
+let RuleMatrix = _RuleMatrix;
+var __defProp$1 = Object.defineProperty, __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor, __decorateClass$1 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$1(target, key, result), result;
+}, "__decorateClass$1"), __decorateParam$1 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$1"), _a5;
+let SheetDataValidationModel = (_a5 = class extends Disposable {
+  constructor(_dataValidationModel, _univerInstanceService, _dataValidatorRegistryService, _dataValidationCacheService, _dataValidationFormulaService, _dataValidationCustomFormulaService, _commandService) {
+    super();
+    __publicField(this, "_ruleMatrixMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_validStatusChange$", new Subject());
+    __publicField(this, "_ruleChange$", new Subject());
+    __publicField(this, "ruleChange$", this._ruleChange$.asObservable());
+    __publicField(this, "validStatusChange$", this._validStatusChange$.asObservable());
+    this._dataValidationModel = _dataValidationModel, this._univerInstanceService = _univerInstanceService, this._dataValidatorRegistryService = _dataValidatorRegistryService, this._dataValidationCacheService = _dataValidationCacheService, this._dataValidationFormulaService = _dataValidationFormulaService, this._dataValidationCustomFormulaService = _dataValidationCustomFormulaService, this._commandService = _commandService, this._initRuleUpdateListener(), this.disposeWithMe(() => {
+      this._ruleChange$.complete(), this._validStatusChange$.complete();
+    }), this._initUniverInstanceListener();
+  }
+  _initUniverInstanceListener() {
+    this.disposeWithMe(
+      this._univerInstanceService.unitDisposed$.subscribe((unit) => {
+        this._ruleMatrixMap.delete(unit.getUnitId());
+      })
+    ), this.disposeWithMe(
+      this._commandService.onCommandExecuted((command) => {
+        if (command.id === RemoveSheetMutation.id) {
+          const { unitId, subUnitId } = command.params, subUnitMap = this._ruleMatrixMap.get(unitId);
+          subUnitMap && subUnitMap.delete(subUnitId);
+        }
+      })
+    );
+  }
+  _initRuleUpdateListener() {
+    const allRules = this._dataValidationModel.getAll();
+    for (const [unitId, subUnitMap] of allRules)
+      for (const [subUnitId, rules] of subUnitMap)
+        for (const rule of rules)
+          this._addRule(unitId, subUnitId, rule), this._ruleChange$.next({
+            type: "add",
+            unitId,
+            subUnitId,
+            rule,
+            source: "patched"
+          });
+    this.disposeWithMe(
+      this._dataValidationModel.ruleChange$.subscribe((ruleChange) => {
+        switch (ruleChange.type) {
+          case "add":
+            this._addRule(ruleChange.unitId, ruleChange.subUnitId, ruleChange.rule);
+            break;
+          case "update":
+            this._updateRule(ruleChange.unitId, ruleChange.subUnitId, ruleChange.rule.uid, ruleChange.oldRule, ruleChange.updatePayload);
+            break;
+          case "remove":
+            this._removeRule(ruleChange.unitId, ruleChange.subUnitId, ruleChange.rule);
+            break;
+        }
+        this._ruleChange$.next(ruleChange);
+      })
+    );
+  }
+  _ensureRuleMatrix(unitId, subUnitId) {
+    let unitMap = this._ruleMatrixMap.get(unitId);
+    unitMap || (unitMap = /* @__PURE__ */ new Map(), this._ruleMatrixMap.set(unitId, unitMap));
+    let matrix = unitMap.get(subUnitId);
+    return matrix || (matrix = new RuleMatrix(/* @__PURE__ */ new Map(), unitId, subUnitId, this._univerInstanceService), unitMap.set(subUnitId, matrix)), matrix;
+  }
+  _addRuleSideEffect(unitId, subUnitId, rule) {
+    this._ensureRuleMatrix(unitId, subUnitId).addRule(rule), this._dataValidationCacheService.addRule(unitId, subUnitId, rule), this._dataValidationFormulaService.addRule(unitId, subUnitId, rule.uid, rule.formula1, rule.formula2), rule.type === DataValidationType.CUSTOM && this._dataValidationCustomFormulaService.addRule(unitId, subUnitId, rule);
+  }
+  _addRule(unitId, subUnitId, rule) {
+    (Array.isArray(rule) ? rule : [rule]).forEach((item) => {
+      this._addRuleSideEffect(unitId, subUnitId, item);
+    });
+  }
+  _updateRule(unitId, subUnitId, ruleId, oldRule, payload) {
+    const ruleMatrix = this._ensureRuleMatrix(unitId, subUnitId);
+    payload.type === UpdateRuleType.RANGE ? (ruleMatrix.updateRange(ruleId, payload.payload), this._dataValidationCacheService.updateRuleRanges(unitId, subUnitId, ruleId, payload.payload, oldRule.ranges), oldRule.type === DataValidationType.CUSTOM && this._dataValidationCustomFormulaService.updateRuleRanges(unitId, subUnitId, ruleId, oldRule.ranges, payload.payload)) : payload.type === UpdateRuleType.SETTING && (this._dataValidationCacheService.markRangeDirty(unitId, subUnitId, oldRule.ranges), this._dataValidationFormulaService.updateRuleFormulaText(unitId, subUnitId, ruleId, payload.payload.formula1, payload.payload.formula2), oldRule.type === DataValidationType.CUSTOM ? this._dataValidationCustomFormulaService.updateRuleFormula(unitId, subUnitId, ruleId, oldRule.ranges, payload.payload.formula1) : payload.payload.type === DataValidationType.CUSTOM && this._dataValidationCustomFormulaService.addRule(unitId, subUnitId, {
+      ...oldRule,
+      ...payload.payload
+    }));
+  }
+  _removeRule(unitId, subUnitId, oldRule) {
+    this._ensureRuleMatrix(unitId, subUnitId).removeRule(oldRule), this._dataValidationCacheService.removeRule(unitId, subUnitId, oldRule), oldRule.type === DataValidationType.CUSTOM && this._dataValidationCustomFormulaService.deleteByRuleId(unitId, subUnitId, oldRule.uid);
+  }
+  getValidator(type) {
+    return this._dataValidatorRegistryService.getValidatorItem(type);
+  }
+  getRuleIdByLocation(unitId, subUnitId, row, col) {
+    return this._ensureRuleMatrix(unitId, subUnitId).getValue(row, col);
+  }
+  getRuleByLocation(unitId, subUnitId, row, col) {
+    const ruleId = this.getRuleIdByLocation(unitId, subUnitId, row, col);
+    if (ruleId)
+      return this._dataValidationModel.getRuleById(unitId, subUnitId, ruleId);
+  }
+  validator(rule, pos, _onCompete) {
+    const { col, row, unitId, subUnitId, worksheet } = pos, ruleId = rule.uid, formula1 = rule.formula1, formula2 = rule.formula2, onCompete = /* @__PURE__ */ __name((status, changed) => {
+      _onCompete && _onCompete(status, changed), changed && this._validStatusChange$.next({
+        unitId,
+        subUnitId,
+        ruleId: rule.uid,
+        status,
+        row,
+        col
+      });
+    }, "onCompete"), cell = worksheet.getCellValueOnly(row, col), validator = this.getValidator(rule.type), cellRaw = worksheet.getCellRaw(row, col), cellValue = getCellValueOrigin(cellRaw), interceptValue = getCellValueOrigin(cell);
+    if (validator) {
+      const cache = this._dataValidationCacheService.ensureCache(unitId, subUnitId), current = cache.getValue(row, col);
+      return !current || current.value !== cellValue || current.interceptValue !== interceptValue || current.ruleId !== ruleId || current.formula1 !== formula1 || current.formula2 !== formula2 ? (cache.setValue(row, col, {
+        value: cellValue,
+        interceptValue,
+        status: DataValidationStatus.VALIDATING,
+        ruleId,
+        formula1: formula1 || "",
+        formula2: formula2 || ""
+      }), validator.validator(
+        {
+          value: cellValue,
+          unitId,
+          subUnitId,
+          row,
+          column: col,
+          worksheet: pos.worksheet,
+          workbook: pos.workbook,
+          interceptValue: getCellValueOrigin(cell),
+          t: cellRaw == null ? void 0 : cellRaw.t
+        },
+        rule
+      ).then((status) => {
+        const realStatus = status ? DataValidationStatus.VALID : DataValidationStatus.INVALID;
+        cache.setValue(row, col, {
+          value: cellValue,
+          status: realStatus,
+          ruleId,
+          interceptValue,
+          formula1: formula1 || "",
+          formula2: formula2 || ""
+        }), onCompete(realStatus, !0);
+      }), DataValidationStatus.VALIDATING) : (onCompete(current.status, !1), current.status);
+    } else
+      return onCompete(DataValidationStatus.VALID, !1), DataValidationStatus.VALID;
+  }
+  getRuleErrorMsg(unitId, subUnitId, ruleId) {
+    const rule = this._dataValidationModel.getRuleById(unitId, subUnitId, ruleId);
+    if (!rule)
+      return "";
+    const validator = this._dataValidatorRegistryService.getValidatorItem(rule.type);
+    return rule.error ? rule.error : validator ? validator.getRuleFinalError(rule) : "";
+  }
+  getRuleObjectMatrix(unitId, subUnitId) {
+    return this._ensureRuleMatrix(unitId, subUnitId);
+  }
+  getRuleById(unitId, subUnitId, ruleId) {
+    return this._dataValidationModel.getRuleById(unitId, subUnitId, ruleId);
+  }
+  getRuleIndex(unitId, subUnitId, ruleId) {
+    return this._dataValidationModel.getRuleIndex(unitId, subUnitId, ruleId);
+  }
+  getRules(unitId, subUnitId) {
+    return [...this._dataValidationModel.getRules(unitId, subUnitId)];
+  }
+  getUnitRules(unitId) {
+    return this._dataValidationModel.getUnitRules(unitId);
+  }
+  deleteUnitRules(unitId) {
+    return this._dataValidationModel.deleteUnitRules(unitId);
+  }
+  getSubUnitIds(unitId) {
+    return this._dataValidationModel.getSubUnitIds(unitId);
+  }
+  getAll() {
+    return this._dataValidationModel.getAll();
+  }
+}, __name(_a5, "SheetDataValidationModel"), _a5);
+SheetDataValidationModel = __decorateClass$1([
+  __decorateParam$1(0, Inject(DataValidationModel)),
+  __decorateParam$1(1, IUniverInstanceService),
+  __decorateParam$1(2, Inject(DataValidatorRegistryService)),
+  __decorateParam$1(3, Inject(DataValidationCacheService)),
+  __decorateParam$1(4, Inject(DataValidationFormulaService)),
+  __decorateParam$1(5, Inject(DataValidationCustomFormulaService)),
+  __decorateParam$1(6, ICommandService)
+], SheetDataValidationModel);
+function getFormulaResult(result) {
+  var _a7, _b;
+  return (_b = (_a7 = result == null ? void 0 : result[0]) == null ? void 0 : _a7[0]) == null ? void 0 : _b.v;
+}
+__name(getFormulaResult, "getFormulaResult");
+function getFormulaCellData(result) {
+  var _a7;
+  return (_a7 = result == null ? void 0 : result[0]) == null ? void 0 : _a7[0];
+}
+__name(getFormulaCellData, "getFormulaCellData");
+function isLegalFormulaResult(res) {
+  return !ERROR_TYPE_SET.has(res);
+}
+__name(isLegalFormulaResult, "isLegalFormulaResult");
+const CHECKBOX_FORMULA_1 = 1, CHECKBOX_FORMULA_2 = 0;
+function getFailMessage(formula, localeService) {
+  return Tools.isBlank(formula) ? localeService.t("dataValidation.validFail.value") : isFormulaString(formula) ? localeService.t("dataValidation.validFail.primitive") : "";
+}
+__name(getFailMessage, "getFailMessage");
+const transformCheckboxValue = /* @__PURE__ */ __name((value) => Tools.isDefine(value) && String(value).toLowerCase() === "true" ? "1" : String(value).toLowerCase() === "false" ? "0" : value, "transformCheckboxValue"), _CheckboxValidator = class _CheckboxValidator extends BaseDataValidator {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "id", DataValidationType.CHECKBOX);
+    __publicField(this, "title", "dataValidation.checkbox.title");
+    __publicField(this, "operators", []);
+    __publicField(this, "scopes", ["sheet"]);
+    __publicField(this, "_formulaService", this.injector.get(DataValidationFormulaService));
+    __publicField(this, "skipDefaultFontRender", /* @__PURE__ */ __name((rule, cellValue, pos) => {
+      const { formula1, formula2 } = this.parseFormulaSync(rule, pos.unitId, pos.subUnitId), valueStr = `${cellValue != null ? cellValue : ""}`;
+      return !valueStr || valueStr === `${formula1}` || valueStr === `${formula2}`;
+    }, "skipDefaultFontRender"));
+  }
+  validatorFormula(rule, unitId, subUnitId) {
+    const { formula1, formula2 } = rule, isEqual = formula1 === formula2;
+    if (Tools.isBlank(formula1) && Tools.isBlank(formula2))
+      return {
+        success: !0
+      };
+    if (isEqual)
+      return {
+        success: !1,
+        formula1: this.localeService.t("dataValidation.validFail.checkboxEqual"),
+        formula2: this.localeService.t("dataValidation.validFail.checkboxEqual")
+      };
+    const error1 = getFailMessage(formula1, this.localeService), error2 = getFailMessage(formula2, this.localeService);
+    return {
+      success: !error1 && !error2,
+      formula1: error1,
+      formula2: error2
+    };
+  }
+  async parseFormula(rule, unitId, subUnitId) {
+    var _a7, _b;
+    const { formula1 = CHECKBOX_FORMULA_1, formula2 = CHECKBOX_FORMULA_2 } = rule, results = await this._formulaService.getRuleFormulaResult(unitId, subUnitId, rule.uid), originFormula1 = isFormulaString(formula1) ? getFormulaResult((_a7 = results == null ? void 0 : results[0]) == null ? void 0 : _a7.result) : formula1, originFormula2 = isFormulaString(formula2) ? getFormulaResult((_b = results == null ? void 0 : results[1]) == null ? void 0 : _b.result) : formula2, isFormulaValid = isLegalFormulaResult(String(originFormula1)) && isLegalFormulaResult(String(originFormula2));
+    return {
+      formula1: transformCheckboxValue(originFormula1),
+      formula2: transformCheckboxValue(originFormula2),
+      originFormula1,
+      originFormula2,
+      isFormulaValid
+    };
+  }
+  getExtraStyle(rule, value) {
+    return {
+      tb: WrapStrategy.CLIP
+    };
+  }
+  parseFormulaSync(rule, unitId, subUnitId) {
+    var _a7, _b;
+    const { formula1 = CHECKBOX_FORMULA_1, formula2 = CHECKBOX_FORMULA_2 } = rule, results = this._formulaService.getRuleFormulaResultSync(unitId, subUnitId, rule.uid), originFormula1 = isFormulaString(formula1) ? getFormulaResult((_a7 = results == null ? void 0 : results[0]) == null ? void 0 : _a7.result) : formula1, originFormula2 = isFormulaString(formula2) ? getFormulaResult((_b = results == null ? void 0 : results[1]) == null ? void 0 : _b.result) : formula2;
+    return {
+      formula1: transformCheckboxValue(originFormula1),
+      formula2: transformCheckboxValue(originFormula2),
+      originFormula1,
+      originFormula2
+    };
+  }
+  async isValidType(cellInfo, formula, rule) {
+    const { value, unitId, subUnitId } = cellInfo, { formula1, formula2, originFormula1, originFormula2 } = await this.parseFormula(rule, unitId, subUnitId);
+    return !Tools.isDefine(formula1) || !Tools.isDefine(formula2) ? !0 : Tools.isDefine(value) && (String(value) === String(formula1) || String(value) === String(formula2) || String(value) === String(originFormula1 != null ? originFormula1 : "") || String(value) === String(originFormula2 != null ? originFormula2 : ""));
+  }
+  generateRuleErrorMessage(rule) {
+    return this.localeService.t("dataValidation.checkbox.error");
+  }
+};
+__name(_CheckboxValidator, "CheckboxValidator");
+let CheckboxValidator = _CheckboxValidator;
+var commonjsGlobal = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x.default : x;
+}
+__name(getDefaultExportFromCjs, "getDefaultExportFromCjs");
+var dayjs_min = { exports: {} };
+(function(module, exports) {
+  (function(t, e) {
+    module.exports = e();
+  })(commonjsGlobal, function() {
+    var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: /* @__PURE__ */ __name(function(t2) {
+      var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
+      return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
+    }, "ordinal") }, m = /* @__PURE__ */ __name(function(t2, e2, n2) {
+      var r2 = String(t2);
+      return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
+    }, "m"), v = { s: m, z: /* @__PURE__ */ __name(function(t2) {
+      var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
+      return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
+    }, "z"), m: /* @__PURE__ */ __name(function t2(e2, n2) {
+      if (e2.date() < n2.date()) return -t2(n2, e2);
+      var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c);
+      return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
+    }, "t"), a: /* @__PURE__ */ __name(function(t2) {
+      return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
+    }, "a"), p: /* @__PURE__ */ __name(function(t2) {
+      return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
+    }, "p"), u: /* @__PURE__ */ __name(function(t2) {
+      return t2 === void 0;
+    }, "u") }, g = "en", D = {};
+    D[g] = M;
+    var p = "$isDayjsObject", S = /* @__PURE__ */ __name(function(t2) {
+      return t2 instanceof _ || !(!t2 || !t2[p]);
+    }, "S"), w = /* @__PURE__ */ __name(function t2(e2, n2, r2) {
+      var i2;
+      if (!e2) return g;
+      if (typeof e2 == "string") {
+        var s2 = e2.toLowerCase();
+        D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
+        var u2 = e2.split("-");
+        if (!i2 && u2.length > 1) return t2(u2[0]);
+      } else {
+        var a2 = e2.name;
+        D[a2] = e2, i2 = a2;
+      }
+      return !r2 && i2 && (g = i2), i2 || !r2 && g;
+    }, "t"), O = /* @__PURE__ */ __name(function(t2, e2) {
+      if (S(t2)) return t2.clone();
+      var n2 = typeof e2 == "object" ? e2 : {};
+      return n2.date = t2, n2.args = arguments, new _(n2);
+    }, "O"), b = v;
+    b.l = w, b.i = S, b.w = function(t2, e2) {
+      return O(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
+    };
+    var _ = function() {
+      function M2(t2) {
+        this.$L = w(t2.locale, null, !0), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = !0;
+      }
+      __name(M2, "M");
+      var m2 = M2.prototype;
+      return m2.parse = function(t2) {
+        this.$d = function(t3) {
+          var e2 = t3.date, n2 = t3.utc;
+          if (e2 === null) return /* @__PURE__ */ new Date(NaN);
+          if (b.u(e2)) return /* @__PURE__ */ new Date();
+          if (e2 instanceof Date) return new Date(e2);
+          if (typeof e2 == "string" && !/Z$/i.test(e2)) {
+            var r2 = e2.match($);
+            if (r2) {
+              var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
+              return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
+            }
+          }
+          return new Date(e2);
+        }(t2), this.init();
+      }, m2.init = function() {
+        var t2 = this.$d;
+        this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
+      }, m2.$utils = function() {
+        return b;
+      }, m2.isValid = function() {
+        return this.$d.toString() !== l;
+      }, m2.isSame = function(t2, e2) {
+        var n2 = O(t2);
+        return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
+      }, m2.isAfter = function(t2, e2) {
+        return O(t2) < this.startOf(e2);
+      }, m2.isBefore = function(t2, e2) {
+        return this.endOf(e2) < O(t2);
+      }, m2.$g = function(t2, e2, n2) {
+        return b.u(t2) ? this[e2] : this.set(n2, t2);
+      }, m2.unix = function() {
+        return Math.floor(this.valueOf() / 1e3);
+      }, m2.valueOf = function() {
+        return this.$d.getTime();
+      }, m2.startOf = function(t2, e2) {
+        var n2 = this, r2 = !!b.u(e2) || e2, f2 = b.p(t2), l2 = /* @__PURE__ */ __name(function(t3, e3) {
+          var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
+          return r2 ? i2 : i2.endOf(a);
+        }, "l"), $2 = /* @__PURE__ */ __name(function(t3, e3) {
+          return b.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
+        }, "$"), y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
+        switch (f2) {
+          case h:
+            return r2 ? l2(1, 0) : l2(31, 11);
+          case c:
+            return r2 ? l2(1, M3) : l2(0, M3 + 1);
+          case o:
+            var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
+            return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
+          case a:
+          case d:
+            return $2(v2 + "Hours", 0);
+          case u:
+            return $2(v2 + "Minutes", 1);
+          case s:
+            return $2(v2 + "Seconds", 2);
+          case i:
+            return $2(v2 + "Milliseconds", 3);
+          default:
+            return this.clone();
+        }
+      }, m2.endOf = function(t2) {
+        return this.startOf(t2, !1);
+      }, m2.$set = function(t2, e2) {
+        var n2, o2 = b.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+        if (o2 === c || o2 === h) {
+          var y2 = this.clone().set(d, 1);
+          y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
+        } else l2 && this.$d[l2]($2);
+        return this.init(), this;
+      }, m2.set = function(t2, e2) {
+        return this.clone().$set(t2, e2);
+      }, m2.get = function(t2) {
+        return this[b.p(t2)]();
+      }, m2.add = function(r2, f2) {
+        var d2, l2 = this;
+        r2 = Number(r2);
+        var $2 = b.p(f2), y2 = /* @__PURE__ */ __name(function(t2) {
+          var e2 = O(l2);
+          return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+        }, "y");
+        if ($2 === c) return this.set(c, this.$M + r2);
+        if ($2 === h) return this.set(h, this.$y + r2);
+        if ($2 === a) return y2(1);
+        if ($2 === o) return y2(7);
+        var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
+        return b.w(m3, this);
+      }, m2.subtract = function(t2, e2) {
+        return this.add(-1 * t2, e2);
+      }, m2.format = function(t2) {
+        var e2 = this, n2 = this.$locale();
+        if (!this.isValid()) return n2.invalidDate || l;
+        var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = /* @__PURE__ */ __name(function(t3, n3, i3, s3) {
+          return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+        }, "h"), d2 = /* @__PURE__ */ __name(function(t3) {
+          return b.s(s2 % 12 || 12, t3, "0");
+        }, "d"), $2 = f2 || function(t3, e3, n3) {
+          var r3 = t3 < 12 ? "AM" : "PM";
+          return n3 ? r3.toLowerCase() : r3;
+        };
+        return r2.replace(y, function(t3, r3) {
+          return r3 || function(t4) {
+            switch (t4) {
+              case "YY":
+                return String(e2.$y).slice(-2);
+              case "YYYY":
+                return b.s(e2.$y, 4, "0");
+              case "M":
+                return a2 + 1;
+              case "MM":
+                return b.s(a2 + 1, 2, "0");
+              case "MMM":
+                return h2(n2.monthsShort, a2, c2, 3);
+              case "MMMM":
+                return h2(c2, a2);
+              case "D":
+                return e2.$D;
+              case "DD":
+                return b.s(e2.$D, 2, "0");
+              case "d":
+                return String(e2.$W);
+              case "dd":
+                return h2(n2.weekdaysMin, e2.$W, o2, 2);
+              case "ddd":
+                return h2(n2.weekdaysShort, e2.$W, o2, 3);
+              case "dddd":
+                return o2[e2.$W];
+              case "H":
+                return String(s2);
+              case "HH":
+                return b.s(s2, 2, "0");
+              case "h":
+                return d2(1);
+              case "hh":
+                return d2(2);
+              case "a":
+                return $2(s2, u2, !0);
+              case "A":
+                return $2(s2, u2, !1);
+              case "m":
+                return String(u2);
+              case "mm":
+                return b.s(u2, 2, "0");
+              case "s":
+                return String(e2.$s);
+              case "ss":
+                return b.s(e2.$s, 2, "0");
+              case "SSS":
+                return b.s(e2.$ms, 3, "0");
+              case "Z":
+                return i2;
+            }
+            return null;
+          }(t3) || i2.replace(":", "");
+        });
+      }, m2.utcOffset = function() {
+        return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+      }, m2.diff = function(r2, d2, l2) {
+        var $2, y2 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = /* @__PURE__ */ __name(function() {
+          return b.m(y2, m3);
+        }, "D");
+        switch (M3) {
+          case h:
+            $2 = D2() / 12;
+            break;
+          case c:
+            $2 = D2();
+            break;
+          case f:
+            $2 = D2() / 3;
+            break;
+          case o:
+            $2 = (g2 - v2) / 6048e5;
+            break;
+          case a:
+            $2 = (g2 - v2) / 864e5;
+            break;
+          case u:
+            $2 = g2 / n;
+            break;
+          case s:
+            $2 = g2 / e;
+            break;
+          case i:
+            $2 = g2 / t;
+            break;
+          default:
+            $2 = g2;
+        }
+        return l2 ? $2 : b.a($2);
+      }, m2.daysInMonth = function() {
+        return this.endOf(c).$D;
+      }, m2.$locale = function() {
+        return D[this.$L];
+      }, m2.locale = function(t2, e2) {
+        if (!t2) return this.$L;
+        var n2 = this.clone(), r2 = w(t2, e2, !0);
+        return r2 && (n2.$L = r2), n2;
+      }, m2.clone = function() {
+        return b.w(this.$d, this);
+      }, m2.toDate = function() {
+        return new Date(this.valueOf());
+      }, m2.toJSON = function() {
+        return this.isValid() ? this.toISOString() : null;
+      }, m2.toISOString = function() {
+        return this.$d.toISOString();
+      }, m2.toString = function() {
+        return this.$d.toUTCString();
+      }, M2;
+    }(), k = _.prototype;
+    return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach(function(t2) {
+      k[t2[1]] = function(e2) {
+        return this.$g(e2, t2[0], t2[1]);
+      };
+    }), O.extend = function(t2, e2) {
+      return t2.$i || (t2(e2, _, O), t2.$i = !0), O;
+    }, O.locale = w, O.isDayjs = S, O.unix = function(t2) {
+      return O(1e3 * t2);
+    }, O.en = D[g], O.Ls = D, O.p = {}, O;
+  });
+})(dayjs_min);
+var dayjs_minExports = dayjs_min.exports;
+const dayjs = /* @__PURE__ */ getDefaultExportFromCjs(dayjs_minExports), DateOperatorNameMap = {
+  [DataValidationOperator.BETWEEN]: "dataValidation.date.operators.between",
+  [DataValidationOperator.EQUAL]: "dataValidation.date.operators.equal",
+  [DataValidationOperator.GREATER_THAN]: "dataValidation.date.operators.greaterThan",
+  [DataValidationOperator.GREATER_THAN_OR_EQUAL]: "dataValidation.date.operators.greaterThanOrEqual",
+  [DataValidationOperator.LESS_THAN]: "dataValidation.date.operators.lessThan",
+  [DataValidationOperator.LESS_THAN_OR_EQUAL]: "dataValidation.date.operators.lessThanOrEqual",
+  [DataValidationOperator.NOT_BETWEEN]: "dataValidation.date.operators.notBetween",
+  [DataValidationOperator.NOT_EQUAL]: "dataValidation.date.operators.notEqual"
+};
+DataValidationOperator.BETWEEN + "", DataValidationOperator.EQUAL + "", DataValidationOperator.GREATER_THAN + "", DataValidationOperator.GREATER_THAN_OR_EQUAL + "", DataValidationOperator.LESS_THAN + "", DataValidationOperator.LESS_THAN_OR_EQUAL + "", DataValidationOperator.NOT_BETWEEN + "", DataValidationOperator.NOT_EQUAL + "";
+const DateOperatorTitleMap = {
+  [DataValidationOperator.BETWEEN]: "dataValidation.date.ruleName.between",
+  [DataValidationOperator.EQUAL]: "dataValidation.date.ruleName.equal",
+  [DataValidationOperator.GREATER_THAN]: "dataValidation.date.ruleName.greaterThan",
+  [DataValidationOperator.GREATER_THAN_OR_EQUAL]: "dataValidation.date.ruleName.greaterThanOrEqual",
+  [DataValidationOperator.LESS_THAN]: "dataValidation.date.ruleName.lessThan",
+  [DataValidationOperator.LESS_THAN_OR_EQUAL]: "dataValidation.date.ruleName.lessThanOrEqual",
+  [DataValidationOperator.NOT_BETWEEN]: "dataValidation.date.ruleName.notBetween",
+  [DataValidationOperator.NOT_EQUAL]: "dataValidation.date.ruleName.notEqual"
+}, DateOperatorErrorTitleMap = {
+  [DataValidationOperator.BETWEEN]: "dataValidation.date.errorMsg.between",
+  [DataValidationOperator.EQUAL]: "dataValidation.date.errorMsg.equal",
+  [DataValidationOperator.GREATER_THAN]: "dataValidation.date.errorMsg.greaterThan",
+  [DataValidationOperator.GREATER_THAN_OR_EQUAL]: "dataValidation.date.errorMsg.greaterThanOrEqual",
+  [DataValidationOperator.LESS_THAN]: "dataValidation.date.errorMsg.lessThan",
+  [DataValidationOperator.LESS_THAN_OR_EQUAL]: "dataValidation.date.errorMsg.lessThanOrEqual",
+  [DataValidationOperator.NOT_BETWEEN]: "dataValidation.date.errorMsg.notBetween",
+  [DataValidationOperator.NOT_EQUAL]: "dataValidation.date.errorMsg.notEqual"
+}, TWO_FORMULA_OPERATOR_COUNT = [
+  DataValidationOperator.BETWEEN,
+  DataValidationOperator.NOT_BETWEEN
+];
+function isBlankCell(cellData) {
+  var _a7, _b;
+  return cellData ? cellData.p ? !((_b = (_a7 = cellData.p.body) == null ? void 0 : _a7.dataStream) != null ? _b : "").slice(0, -2).trim() : Tools.isBlank(cellData.v) : !0;
+}
+__name(isBlankCell, "isBlankCell");
+function getDataValidationDiffMutations(unitId, subUnitId, diffs, accessor, source = "command", fillDefaultValue = !0) {
+  const lexerTreeBuilder = accessor.get(LexerTreeBuilder), redoMutations = [], undoMutations = [], sheetDataValidationModel = accessor.get(SheetDataValidationModel), univerInstanceService = accessor.get(IUniverInstanceService), target = getSheetCommandTarget(univerInstanceService, { unitId, subUnitId });
+  if (!target)
+    return {
+      redoMutations,
+      undoMutations
+    };
+  const { worksheet } = target, redoMatrix = new ObjectMatrix();
+  function setRangesDefaultValue(ranges, defaultValue) {
+    fillDefaultValue && ranges.forEach((range) => {
+      Range.foreach(range, (row, column) => {
+        const cellData = worksheet.getCellRaw(row, column), value = getStringCellValue(cellData);
+        (isBlankCell(cellData) || value === defaultValue) && redoMatrix.setValue(row, column, {
+          v: defaultValue,
+          p: null
+        });
+      });
+    });
+  }
+  __name(setRangesDefaultValue, "setRangesDefaultValue"), diffs.forEach((diff) => {
+    switch (diff.type) {
+      case "delete":
+        redoMutations.push({
+          id: RemoveDataValidationMutation.id,
+          params: {
+            unitId,
+            subUnitId,
+            ruleId: diff.rule.uid,
+            source
+          }
+        }), undoMutations.unshift({
+          id: AddDataValidationMutation.id,
+          params: {
+            unitId,
+            subUnitId,
+            rule: diff.rule,
+            index: diff.index,
+            source
+          }
+        });
+        break;
+      case "update": {
+        if (redoMutations.push({
+          id: UpdateDataValidationMutation.id,
+          params: {
+            unitId,
+            subUnitId,
+            ruleId: diff.ruleId,
+            payload: {
+              type: UpdateRuleType.RANGE,
+              payload: diff.newRanges
+            },
+            source
+          }
+        }), undoMutations.unshift({
+          id: UpdateDataValidationMutation.id,
+          params: {
+            unitId,
+            subUnitId,
+            ruleId: diff.ruleId,
+            payload: {
+              type: UpdateRuleType.RANGE,
+              payload: diff.oldRanges
+            },
+            source
+          }
+        }), diff.rule.type === DataValidationType.CUSTOM) {
+          const originRow = diff.oldRanges[0].startRow, originColumn = diff.oldRanges[0].startColumn, newRow = diff.newRanges[0].startRow, newColumn = diff.newRanges[0].startColumn, rowDiff = newRow - originRow, columnDiff = newColumn - originColumn, newFormula = lexerTreeBuilder.moveFormulaRefOffset(diff.rule.formula1, columnDiff, rowDiff);
+          newFormula !== diff.rule.formula1 && (redoMutations.push({
+            id: UpdateDataValidationMutation.id,
+            params: {
+              unitId,
+              subUnitId,
+              ruleId: diff.ruleId,
+              payload: {
+                type: UpdateRuleType.SETTING,
+                payload: {
+                  ...getRuleSetting(diff.rule),
+                  formula1: newFormula
+                }
+              }
+            }
+          }), undoMutations.unshift({
+            id: UpdateDataValidationMutation.id,
+            params: {
+              unitId,
+              subUnitId,
+              ruleId: diff.ruleId,
+              payload: {
+                type: UpdateRuleType.SETTING,
+                payload: getRuleSetting(diff.rule)
+              }
+            }
+          }));
+        }
+        const rule = sheetDataValidationModel.getRuleById(unitId, subUnitId, diff.ruleId);
+        if (rule && rule.type === DataValidationType.CHECKBOX) {
+          const formula = sheetDataValidationModel.getValidator(DataValidationType.CHECKBOX).parseFormulaSync(rule, unitId, subUnitId);
+          setRangesDefaultValue(diff.newRanges, formula.formula2);
+        }
+        break;
+      }
+      case "add": {
+        if (redoMutations.push({
+          id: AddDataValidationMutation.id,
+          params: {
+            unitId,
+            subUnitId,
+            rule: diff.rule,
+            source
+          }
+        }), undoMutations.unshift({
+          id: RemoveDataValidationMutation.id,
+          params: {
+            unitId,
+            subUnitId,
+            ruleId: diff.rule.uid,
+            source
+          }
+        }), diff.rule.type === DataValidationType.CHECKBOX) {
+          const formula = sheetDataValidationModel.getValidator(DataValidationType.CHECKBOX).parseFormulaSync(diff.rule, unitId, subUnitId);
+          setRangesDefaultValue(diff.rule.ranges, formula.originFormula2);
+        }
+        break;
+      }
+    }
+  });
+  const redoSetRangeValues = {
+    id: SetRangeValuesMutation.id,
+    params: {
+      unitId,
+      subUnitId,
+      cellValue: redoMatrix.getData()
+    }
+  }, undoSetRangeValues = {
+    id: SetRangeValuesMutation.id,
+    params: SetRangeValuesUndoMutationFactory(accessor, redoSetRangeValues.params)
+  };
+  return redoMutations.push(redoSetRangeValues), undoMutations.push(undoSetRangeValues), {
+    redoMutations,
+    undoMutations
+  };
+}
+__name(getDataValidationDiffMutations, "getDataValidationDiffMutations");
+const UpdateSheetDataValidationRangeCommand = {
+  type: CommandType.COMMAND,
+  id: "sheet.command.updateDataValidationRuleRange",
+  handler(accessor, params) {
+    if (!params)
+      return !1;
+    const { unitId, subUnitId, ranges, ruleId } = params, sheetDataValidationModel = accessor.get(SheetDataValidationModel), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService);
+    if (!sheetDataValidationModel.getRuleById(unitId, subUnitId, ruleId))
+      return !1;
+    const matrix = sheetDataValidationModel.getRuleObjectMatrix(unitId, subUnitId).clone();
+    matrix.updateRange(ruleId, ranges);
+    const diffs = matrix.diff(sheetDataValidationModel.getRules(unitId, subUnitId)), { redoMutations, undoMutations } = getDataValidationDiffMutations(unitId, subUnitId, diffs, accessor);
+    return undoRedoService.pushUndoRedo({
+      undoMutations,
+      redoMutations,
+      unitID: unitId
+    }), sequenceExecute(redoMutations, commandService), !0;
+  }
+}, AddSheetDataValidationCommand = {
+  type: CommandType.COMMAND,
+  id: "sheet.command.addDataValidation",
+  handler(accessor, params) {
+    if (!params)
+      return !1;
+    const { unitId, subUnitId, rule } = params, sheetDataValidationModel = accessor.get(SheetDataValidationModel), commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), matrix = sheetDataValidationModel.getRuleObjectMatrix(unitId, subUnitId).clone();
+    matrix.addRule(rule);
+    const diffs = matrix.diff(sheetDataValidationModel.getRules(unitId, subUnitId)), mutationParams = {
+      unitId,
+      subUnitId,
+      rule
+    }, { redoMutations, undoMutations } = getDataValidationDiffMutations(unitId, subUnitId, diffs, accessor);
+    return redoMutations.push({
+      id: AddDataValidationMutation.id,
+      params: mutationParams
+    }), undoMutations.unshift({
+      id: RemoveDataValidationMutation.id,
+      params: {
+        unitId,
+        subUnitId,
+        ruleId: rule.uid
+      }
+    }), undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      redoMutations,
+      undoMutations
+    }), sequenceExecute(redoMutations, commandService), !0;
+  }
+}, UpdateSheetDataValidationSettingCommand = {
+  type: CommandType.COMMAND,
+  id: "sheets.command.update-data-validation-setting",
+  // eslint-disable-next-line max-lines-per-function
+  handler(accessor, params) {
+    if (!params)
+      return !1;
+    const commandService = accessor.get(ICommandService), redoUndoService = accessor.get(IUndoRedoService), sheetDataValidationModel = accessor.get(SheetDataValidationModel), dataValidatorRegistryService = accessor.get(DataValidatorRegistryService), { unitId, subUnitId, ruleId, setting } = params, validator = dataValidatorRegistryService.getValidatorItem(setting.type);
+    if (!validator)
+      return !1;
+    const rule = sheetDataValidationModel.getRuleById(unitId, subUnitId, ruleId);
+    if (!rule)
+      return !1;
+    const newRule = { ...rule, ...setting };
+    if (!validator.validatorFormula(newRule, unitId, subUnitId).success)
+      return !1;
+    const mutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
+      payload: {
+        type: UpdateRuleType.SETTING,
+        payload: {
+          ...setting,
+          ...validator.normalizeFormula(newRule, unitId, subUnitId)
+        }
+      }
+    }, redoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: mutationParams
+    }], undoMutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
+      payload: {
+        type: UpdateRuleType.SETTING,
+        payload: getRuleSetting(rule)
+      }
+    }, undoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: undoMutationParams
+    }];
+    if (setting.type === DataValidationType.CHECKBOX) {
+      const ranges = rule.ranges, univerInstanceService = accessor.get(IUniverInstanceService), target = getSheetCommandTarget(univerInstanceService, { unitId, subUnitId });
+      if (target) {
+        const redoMatrix = new ObjectMatrix(), { worksheet } = target, { formula2: oldFormula2 = CHECKBOX_FORMULA_2, formula1: oldFormula1 = CHECKBOX_FORMULA_1 } = rule, { formula2 = CHECKBOX_FORMULA_2, formula1 = CHECKBOX_FORMULA_1 } = setting;
+        ranges.forEach((range) => {
+          Range.foreach(range, (row, column) => {
+            const cellData = worksheet.getCellRaw(row, column), value = getStringCellValue(cellData);
+            isBlankCell(cellData) || value === String(oldFormula2) ? redoMatrix.setValue(row, column, {
+              v: formula2,
+              p: null
+            }) : value === String(oldFormula1) && redoMatrix.setValue(row, column, {
+              v: formula1,
+              p: null
+            });
+          });
+        });
+        const redoSetRangeValues = {
+          id: SetRangeValuesMutation.id,
+          params: {
+            unitId,
+            subUnitId,
+            cellValue: redoMatrix.getData()
+          }
+        }, undoSetRangeValues = {
+          id: SetRangeValuesMutation.id,
+          params: SetRangeValuesUndoMutationFactory(accessor, redoSetRangeValues.params)
+        };
+        redoMutations.push(redoSetRangeValues), undoMutations.push(undoSetRangeValues);
+      }
+    }
+    return sequenceExecute(redoMutations, commandService).result ? (redoUndoService.pushUndoRedo({
+      unitID: unitId,
+      redoMutations,
+      undoMutations
+    }), !0) : !1;
+  }
+}, UpdateSheetDataValidationOptionsCommand = {
+  type: CommandType.COMMAND,
+  id: "sheets.command.update-data-validation-options",
+  handler(accessor, params) {
+    if (!params)
+      return !1;
+    const commandService = accessor.get(ICommandService), redoUndoService = accessor.get(IUndoRedoService), sheetDataValidationModel = accessor.get(SheetDataValidationModel), { unitId, subUnitId, ruleId, options } = params, rule = sheetDataValidationModel.getRuleById(unitId, subUnitId, ruleId);
+    if (!rule)
+      return !1;
+    const mutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
+      payload: {
+        type: UpdateRuleType.OPTIONS,
+        payload: options
+      }
+    }, redoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: mutationParams
+    }], undoMutationParams = {
+      unitId,
+      subUnitId,
+      ruleId,
+      payload: {
+        type: UpdateRuleType.OPTIONS,
+        payload: getRuleOptions(rule)
+      }
+    }, undoMutations = [{
+      id: UpdateDataValidationMutation.id,
+      params: undoMutationParams
+    }];
+    return redoUndoService.pushUndoRedo({
+      unitID: unitId,
+      redoMutations,
+      undoMutations
+    }), commandService.executeCommand(UpdateDataValidationMutation.id, mutationParams), !0;
+  }
+}, ClearRangeDataValidationCommand = {
+  type: CommandType.COMMAND,
+  id: "sheets.command.clear-range-data-validation",
+  handler(accessor, params) {
+    if (!params)
+      return !1;
+    const { unitId, subUnitId, ranges } = params, commandService = accessor.get(ICommandService), univerInstanceService = accessor.get(IUniverInstanceService), target = getSheetCommandTarget(univerInstanceService, { unitId, subUnitId }), sheetDataValidationModel = accessor.get(SheetDataValidationModel);
+    if (!target) return !1;
+    const undoRedoService = accessor.get(IUndoRedoService), matrix = sheetDataValidationModel.getRuleObjectMatrix(unitId, subUnitId).clone();
+    matrix.removeRange(ranges);
+    const diffs = matrix.diff(sheetDataValidationModel.getRules(unitId, subUnitId)), { redoMutations, undoMutations } = getDataValidationDiffMutations(unitId, subUnitId, diffs, accessor);
+    return undoRedoService.pushUndoRedo({
+      unitID: unitId,
+      redoMutations,
+      undoMutations
+    }), sequenceExecute(redoMutations, commandService).result;
+  }
+}, RemoveSheetAllDataValidationCommand = {
+  type: CommandType.COMMAND,
+  id: "sheet.command.remove-all-data-validation",
+  handler(accessor, params) {
+    if (!params)
+      return !1;
+    const { unitId, subUnitId } = params, commandService = accessor.get(ICommandService), sheetDataValidationModel = accessor.get(SheetDataValidationModel), undoRedoService = accessor.get(IUndoRedoService), currentRules = [...sheetDataValidationModel.getRules(unitId, subUnitId)], redoParams = {
+      unitId,
+      subUnitId,
+      ruleId: currentRules.map((rule) => rule.uid)
+    }, redoMutations = [{
+      id: RemoveDataValidationMutation.id,
+      params: redoParams
+    }], undoMutations = [{
+      id: AddDataValidationMutation.id,
+      params: {
+        unitId,
+        subUnitId,
+        rule: currentRules
+      }
+    }];
+    return undoRedoService.pushUndoRedo({
+      redoMutations,
+      undoMutations,
+      unitID: unitId
+    }), commandService.executeCommand(RemoveDataValidationMutation.id, redoParams), !0;
+  }
+}, removeDataValidationUndoFactory = /* @__PURE__ */ __name((accessor, redoParams) => {
+  const sheetDataValidationModel = accessor.get(SheetDataValidationModel), { unitId, subUnitId, ruleId, source } = redoParams;
+  if (Array.isArray(ruleId)) {
+    const rules = ruleId.map((id) => sheetDataValidationModel.getRuleById(unitId, subUnitId, id)).filter(Boolean);
+    return [{
+      id: AddDataValidationMutation.id,
+      params: {
+        unitId,
+        subUnitId,
+        rule: rules,
+        source
+      }
+    }];
+  }
+  return [{
+    id: AddDataValidationMutation.id,
+    params: {
+      unitId,
+      subUnitId,
+      rule: {
+        ...sheetDataValidationModel.getRuleById(unitId, subUnitId, ruleId)
+      },
+      index: sheetDataValidationModel.getRuleIndex(unitId, subUnitId, ruleId)
+    }
+  }];
+}, "removeDataValidationUndoFactory"), RemoveSheetDataValidationCommand = {
+  type: CommandType.COMMAND,
+  id: "sheet.command.remove-data-validation-rule",
+  handler(accessor, params) {
+    if (!params)
+      return !1;
+    const { unitId, subUnitId, ruleId } = params, commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), sheetDataValidationModel = accessor.get(SheetDataValidationModel), redoMutations = [{
+      id: RemoveDataValidationMutation.id,
+      params
+    }], undoMutations = [{
+      id: AddDataValidationMutation.id,
+      params: {
+        unitId,
+        subUnitId,
+        rule: {
+          ...sheetDataValidationModel.getRuleById(unitId, subUnitId, ruleId)
+        },
+        index: sheetDataValidationModel.getRuleIndex(unitId, subUnitId, ruleId)
+      }
+    }];
+    return undoRedoService.pushUndoRedo({
+      undoMutations,
+      redoMutations,
+      unitID: params.unitId
+    }), commandService.executeCommand(RemoveDataValidationMutation.id, params), !0;
+  }
+};
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam"), _a6;
+let SheetsDataValidationValidatorService = (_a6 = class extends Disposable {
+  constructor(_univerInstanceService, _sheetDataValidationModel, _dataValidationCacheService, _lifecycleService) {
+    super(), this._univerInstanceService = _univerInstanceService, this._sheetDataValidationModel = _sheetDataValidationModel, this._dataValidationCacheService = _dataValidationCacheService, this._lifecycleService = _lifecycleService, this._initRecalculate();
+  }
+  _initRecalculate() {
+    const handleDirtyRanges = /* @__PURE__ */ __name((ranges) => {
+      if (ranges.length === 0)
+        return;
+      const workbook = this._univerInstanceService.getCurrentUnitForType(UniverInstanceType.UNIVER_SHEET), worksheet = workbook == null ? void 0 : workbook.getActiveSheet(), map = {};
+      ranges.flat().forEach((range) => {
+        map[range.unitId] || (map[range.unitId] = {}), map[range.unitId][range.subUnitId] || (map[range.unitId][range.subUnitId] = []);
+        const workbook2 = this._univerInstanceService.getUnit(range.unitId, UniverInstanceType.UNIVER_SHEET), worksheet2 = workbook2 == null ? void 0 : workbook2.getSheetBySheetId(range.subUnitId);
+        worksheet2 && map[range.unitId][range.subUnitId].push(...range.ranges.map((range2) => Range.transformRange(range2, worksheet2)));
+      }), Object.entries(map).forEach(([unitId, subUnitMap]) => {
+        Object.entries(subUnitMap).forEach(([subUnitId, ranges2]) => {
+          (workbook == null ? void 0 : workbook.getUnitId()) === unitId && (worksheet == null ? void 0 : worksheet.getSheetId()) === subUnitId ? this.validatorRanges(unitId, subUnitId, ranges2) : requestIdleCallback(() => {
+            this.validatorRanges(unitId, subUnitId, ranges2);
+          });
+        });
+      });
+    }, "handleDirtyRanges");
+    this.disposeWithMe(this._dataValidationCacheService.dirtyRanges$.pipe(bufferWhen(() => this._lifecycleService.lifecycle$.pipe(filter((stage) => stage === LifecycleStages.Rendered)))).subscribe(handleDirtyRanges)), this.disposeWithMe(this._dataValidationCacheService.dirtyRanges$.pipe(filter(() => this._lifecycleService.stage >= LifecycleStages.Rendered), bufferDebounceTime(20)).subscribe(handleDirtyRanges));
+  }
+  async validatorCell(unitId, subUnitId, row, col) {
+    const workbook = this._univerInstanceService.getUnit(unitId, UniverInstanceType.UNIVER_SHEET);
+    if (!workbook)
+      throw new Error(`cannot find current workbook, unitId: ${unitId}`);
+    const worksheet = workbook.getSheetBySheetId(subUnitId);
+    if (!worksheet)
+      throw new Error(`cannot find current worksheet, sheetId: ${subUnitId}`);
+    if (!Tools.isDefine(row) || !Tools.isDefine(col))
+      throw new Error(`row or col is not defined, row: ${row}, col: ${col}`);
+    const rule = this._sheetDataValidationModel.getRuleByLocation(unitId, subUnitId, row, col);
+    return rule ? new Promise((resolve) => {
+      this._sheetDataValidationModel.validator(rule, { unitId, subUnitId, row, col, worksheet, workbook }, (status) => {
+        resolve(status);
+      });
+    }) : DataValidationStatus.VALID;
+  }
+  validatorRanges(unitId, subUnitId, ranges) {
+    return Promise.all(ranges.map((range) => {
+      const promises = [];
+      return Range.foreach(range, (row, col) => {
+        promises.push(this.validatorCell(unitId, subUnitId, row, col));
+      }), promises;
+    }));
+  }
+  async validatorWorksheet(unitId, subUnitId) {
+    const rules = this._sheetDataValidationModel.getRules(unitId, subUnitId);
+    return await Promise.all(rules.map((rule) => Promise.all(rule.ranges.map((range) => {
+      const promises = [];
+      return Range.foreach(range, (row, col) => {
+        promises.push(this.validatorCell(unitId, subUnitId, row, col));
+      }), promises;
+    })))), this._dataValidationCacheService.ensureCache(unitId, subUnitId);
+  }
+  async validatorWorkbook(unitId) {
+    const sheetIds = this._sheetDataValidationModel.getSubUnitIds(unitId), results = await Promise.all(sheetIds.map((id) => this.validatorWorksheet(unitId, id))), map = {};
+    return results.forEach((result, i) => {
+      map[sheetIds[i]] = result;
+    }), map;
+  }
+  getDataValidations(unitId, subUnitId, ranges) {
+    const ruleMatrix = this._sheetDataValidationModel.getRuleObjectMatrix(unitId, subUnitId), ruleIdSet = /* @__PURE__ */ new Set();
+    return ranges.forEach((range) => {
+      Range.foreach(range, (row, col) => {
+        const ruleId = ruleMatrix.getValue(row, col);
+        ruleId && ruleIdSet.add(ruleId);
+      });
+    }), Array.from(ruleIdSet).map((id) => this._sheetDataValidationModel.getRuleById(unitId, subUnitId, id)).filter(Boolean);
+  }
+  getDataValidation(unitId, subUnitId, ranges) {
+    return this.getDataValidations(unitId, subUnitId, ranges)[0];
+  }
+}, __name(_a6, "SheetsDataValidationValidatorService"), _a6);
+SheetsDataValidationValidatorService = __decorateClass([
+  __decorateParam(0, IUniverInstanceService),
+  __decorateParam(1, Inject(SheetDataValidationModel)),
+  __decorateParam(2, Inject(DataValidationCacheService)),
+  __decorateParam(3, Inject(LifecycleService))
+], SheetsDataValidationValidatorService);
+export {
+  AddSheetDataValidationCommand as A,
+  CheckboxValidator as C,
+  DataValidationFormulaService as D,
+  RemoveSheetDataValidationCommand as R,
+  SheetDataValidationModel as S,
+  TWO_FORMULA_OPERATOR_COUNT as T,
+  UpdateSheetDataValidationRangeCommand as U,
+  DateOperatorNameMap as a,
+  DateOperatorTitleMap as b,
+  DateOperatorErrorTitleMap as c,
+  dayjs as d,
+  getCellValueOrigin as e,
+  DataValidationCustomFormulaService as f,
+  getFormulaResult as g,
+  getFormulaCellData as h,
+  isLegalFormulaResult as i,
+  getDataValidationDiffMutations as j,
+  DataValidationCacheService as k,
+  SheetsDataValidationValidatorService as l,
+  UpdateSheetDataValidationSettingCommand as m,
+  UpdateSheetDataValidationOptionsCommand as n,
+  RemoveSheetAllDataValidationCommand as o,
+  ClearRangeDataValidationCommand as p,
+  CHECKBOX_FORMULA_1 as q,
+  removeDataValidationUndoFactory as r,
+  CHECKBOX_FORMULA_2 as s,
+  transformCheckboxValue as t
+};