@odoo/o-spreadsheet 18.0.9 → 18.0.11

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.0.9
- * @date 2025-01-14T11:33:47.429Z
- * @hash 0c5220e
+ * @version 18.0.11
+ * @date 2025-01-27T10:08:13.567Z
+ * @hash e8c6bd1
  */
 
 (function (exports, owl) {
@@ -4210,15 +4210,18 @@
       let currentIndex;
       let currentVal;
       let currentType;
+      const getValue = sortOrder === "desc"
+          ? (i) => normalizeValue(getValueInData(data, rangeLength - i - 1))
+          : (i) => normalizeValue(getValueInData(data, i));
       while (indexRight - indexLeft >= 0) {
           indexMedian = Math.floor((indexLeft + indexRight) / 2);
           currentIndex = indexMedian;
-          currentVal = normalizeValue(getValueInData(data, currentIndex));
+          currentVal = getValue(currentIndex);
           currentType = typeof currentVal;
           // 1 - linear search to find value with the same type
           while (indexLeft < currentIndex && targetType !== currentType) {
               currentIndex--;
-              currentVal = normalizeValue(getValueInData(data, currentIndex));
+              currentVal = getValue(currentIndex);
               currentType = typeof currentVal;
           }
           if (currentType !== targetType || currentVal === undefined || currentVal === null) {
@@ -4234,8 +4237,7 @@
               if (matchVal === undefined ||
                   matchVal === null ||
                   matchVal < currentVal ||
-                  (matchVal === currentVal && sortOrder === "asc" && matchValIndex < currentIndex) ||
-                  (matchVal === currentVal && sortOrder === "desc" && matchValIndex > currentIndex)) {
+                  (matchVal === currentVal && matchValIndex < currentIndex)) {
                   matchVal = currentVal;
                   matchValIndex = currentIndex;
               }
@@ -4243,15 +4245,13 @@
           else if (mode === "nextGreater" && currentVal >= _target) {
               if (matchVal === undefined ||
                   matchVal > currentVal ||
-                  (matchVal === currentVal && sortOrder === "asc" && matchValIndex < currentIndex) ||
-                  (matchVal === currentVal && sortOrder === "desc" && matchValIndex > currentIndex)) {
+                  (matchVal === currentVal && matchValIndex < currentIndex)) {
                   matchVal = currentVal;
                   matchValIndex = currentIndex;
               }
           }
           // 3 - give new indexes for the Binary search
-          if ((sortOrder === "asc" && currentVal > _target) ||
-              (sortOrder === "desc" && currentVal <= _target)) {
+          if (currentVal > _target || (mode === "strict" && currentVal === _target)) {
               indexRight = currentIndex - 1;
           }
           else {
@@ -4259,7 +4259,10 @@
           }
       }
       // note that valMinIndex could be 0
-      return matchValIndex !== undefined ? matchValIndex : -1;
+      if (matchValIndex === undefined) {
+          return -1;
+      }
+      return sortOrder === "desc" ? rangeLength - matchValIndex - 1 : matchValIndex;
   }
   /**
    * Perform a linear search and return the index of the match.
@@ -4391,47 +4394,83 @@
       return true;
   }
 
-  function toCriterionDateNumber(dateValue) {
-      const today = DateTime.now();
-      switch (dateValue) {
-          case "today":
-              return jsDateToNumber(today);
-          case "yesterday":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 1)));
-          case "tomorrow":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() + 1)));
-          case "lastWeek":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 7)));
-          case "lastMonth":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setMonth(today.getMonth() - 1)));
-          case "lastYear":
-              return jsDateToNumber(DateTime.fromTimestamp(today.setFullYear(today.getFullYear() - 1)));
-      }
+  /**
+   * Add the `https` prefix to the url if it's missing
+   */
+  function withHttps(url) {
+      return !/^https?:\/\//i.test(url) ? `https://${url}` : url;
   }
-  /** Get all the dates values of a criterion converted to numbers, converting date values such as "today" to actual dates  */
-  function getDateNumberCriterionValues(criterion, locale) {
-      if ("dateValue" in criterion && criterion.dateValue !== "exactDate") {
-          return [toCriterionDateNumber(criterion.dateValue)];
-      }
-      return criterion.values.map((value) => valueToDateNumber(value, locale));
+  const urlRegistry = new Registry();
+  function createWebLink(url, label) {
+      url = withHttps(url);
+      return {
+          url,
+          label: label || url,
+          isExternal: true,
+          isUrlEditable: true,
+      };
   }
-  /** Convert the criterion values to numbers. Return undefined values if they cannot be converted to numbers. */
-  function getCriterionValuesAsNumber(criterion, locale) {
-      return criterion.values.map((value) => tryToNumber(value, locale));
+  urlRegistry.add("sheet_URL", {
+      match: (url) => isSheetUrl(url),
+      createLink: (url, label) => {
+          return {
+              label,
+              url,
+              isExternal: false,
+              isUrlEditable: false,
+          };
+      },
+      urlRepresentation(url, getters) {
+          const sheetId = parseSheetUrl(url);
+          return getters.tryGetSheetName(sheetId) || _t("Invalid sheet");
+      },
+      open(url, env) {
+          const sheetId = parseSheetUrl(url);
+          const result = env.model.dispatch("ACTIVATE_SHEET", {
+              sheetIdFrom: env.model.getters.getActiveSheetId(),
+              sheetIdTo: sheetId,
+          });
+          if (result.isCancelledBecause("SheetIsHidden" /* CommandResult.SheetIsHidden */)) {
+              env.notifyUser({
+                  type: "warning",
+                  sticky: false,
+                  text: _t("Cannot open the link because the linked sheet is hidden."),
+              });
+          }
+      },
+      sequence: 0,
+  });
+  const WebUrlSpec = {
+      createLink: createWebLink,
+      match: (url) => isWebLink(url),
+      open: (url) => window.open(url, "_blank"),
+      urlRepresentation: (url) => url,
+      sequence: 0,
+  };
+  function findMatchingSpec(url) {
+      return (urlRegistry
+          .getAll()
+          .sort((a, b) => a.sequence - b.sequence)
+          .find((urlType) => urlType.match(url)) || WebUrlSpec);
   }
-
-  const MAX_DELAY = 140;
-  const MIN_DELAY = 20;
-  const ACCELERATION = 0.035;
-  /**
-   * Decreasing exponential function used to determine the "speed" of edge-scrolling
-   * as the timeout delay.
-   *
-   * Returns a timeout delay in milliseconds.
-   */
-  function scrollDelay(value) {
-      // decreasing exponential from MAX_DELAY to MIN_DELAY
-      return MIN_DELAY + (MAX_DELAY - MIN_DELAY) * Math.exp(-ACCELERATION * (value - 1));
+  function urlRepresentation(link, getters) {
+      return findMatchingSpec(link.url).urlRepresentation(link.url, getters);
+  }
+  function openLink(link, env) {
+      findMatchingSpec(link.url).open(link.url, env);
+  }
+  function detectLink(value) {
+      if (typeof value !== "string") {
+          return undefined;
+      }
+      if (isMarkdownLink(value)) {
+          const { label, url } = parseMarkdownLink(value);
+          return findMatchingSpec(url).createLink(url, label);
+      }
+      else if (isWebLink(value)) {
+          return createWebLink(value);
+      }
+      return undefined;
   }
 
   function tokenizeFormat(str) {
@@ -5493,6 +5532,193 @@
       }
   }
 
+  function evaluateLiteral(literalCell, localeFormat) {
+      const value = isTextFormat(localeFormat.format) ? literalCell.content : literalCell.parsedValue;
+      const functionResult = { value, format: localeFormat.format };
+      return createEvaluatedCell(functionResult, localeFormat.locale);
+  }
+  function parseLiteral(content, locale) {
+      if (content.startsWith("=")) {
+          throw new Error(`Cannot parse "${content}" because it's not a literal value. It's a formula`);
+      }
+      if (content === "") {
+          return null;
+      }
+      if (isNumber(content, DEFAULT_LOCALE)) {
+          return parseNumber(content, DEFAULT_LOCALE);
+      }
+      const internalDate = parseDateTime(content, locale);
+      if (internalDate) {
+          return internalDate.value;
+      }
+      if (isBoolean(content)) {
+          return content.toUpperCase() === "TRUE" ? true : false;
+      }
+      return content;
+  }
+  function createEvaluatedCell(functionResult, locale = DEFAULT_LOCALE, cell) {
+      const link = detectLink(functionResult.value);
+      if (!link) {
+          return _createEvaluatedCell(functionResult, locale, cell);
+      }
+      const value = parseLiteral(link.label, locale);
+      const format = functionResult.format ||
+          (typeof value === "number"
+              ? detectDateFormat(link.label, locale) || detectNumberFormat(link.label)
+              : undefined);
+      const linkPayload = {
+          value,
+          format,
+      };
+      return {
+          ..._createEvaluatedCell(linkPayload, locale, cell),
+          link,
+      };
+  }
+  function _createEvaluatedCell(functionResult, locale, cell) {
+      let { value, format, message } = functionResult;
+      format = cell?.format || format;
+      const formattedValue = formatValue(value, { format, locale });
+      if (isEvaluationError(value)) {
+          return errorCell(value, message);
+      }
+      if (isTextFormat(format)) {
+          // TO DO:
+          // with the next line, the value of the cell is transformed depending on the format.
+          // This shouldn't happen, by doing this, the formulas handling numbers are not able
+          // to interpret the value as a number.
+          return textCell(toString(value), format, formattedValue);
+      }
+      if (value === null) {
+          return emptyCell(format);
+      }
+      if (typeof value === "number") {
+          if (isDateTimeFormat(format || "")) {
+              return dateTimeCell(value, format, formattedValue);
+          }
+          return numberCell(value, format, formattedValue);
+      }
+      if (typeof value === "boolean") {
+          return booleanCell(value, format, formattedValue);
+      }
+      return textCell(value, format, formattedValue);
+  }
+  function textCell(value, format, formattedValue) {
+      return {
+          value,
+          format,
+          formattedValue,
+          type: CellValueType.text,
+          isAutoSummable: true,
+          defaultAlign: "left",
+      };
+  }
+  function numberCell(value, format, formattedValue) {
+      return {
+          value: value || 0, // necessary to avoid "-0" and NaN values,
+          format,
+          formattedValue,
+          type: CellValueType.number,
+          isAutoSummable: true,
+          defaultAlign: "right",
+      };
+  }
+  const emptyCell = memoize(function emptyCell(format) {
+      return {
+          value: null,
+          format,
+          formattedValue: "",
+          type: CellValueType.empty,
+          isAutoSummable: true,
+          defaultAlign: "left",
+      };
+  });
+  function dateTimeCell(value, format, formattedValue) {
+      return {
+          value,
+          format,
+          formattedValue,
+          type: CellValueType.number,
+          isAutoSummable: false,
+          defaultAlign: "right",
+      };
+  }
+  function booleanCell(value, format, formattedValue) {
+      return {
+          value,
+          format,
+          formattedValue,
+          type: CellValueType.boolean,
+          isAutoSummable: false,
+          defaultAlign: "center",
+      };
+  }
+  function errorCell(value, message) {
+      return {
+          value,
+          formattedValue: value,
+          message,
+          type: CellValueType.error,
+          isAutoSummable: false,
+          defaultAlign: "center",
+      };
+  }
+
+  function toCriterionDateNumber(dateValue) {
+      const today = DateTime.now();
+      switch (dateValue) {
+          case "today":
+              return jsDateToNumber(today);
+          case "yesterday":
+              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 1)));
+          case "tomorrow":
+              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() + 1)));
+          case "lastWeek":
+              return jsDateToNumber(DateTime.fromTimestamp(today.setDate(today.getDate() - 7)));
+          case "lastMonth":
+              return jsDateToNumber(DateTime.fromTimestamp(today.setMonth(today.getMonth() - 1)));
+          case "lastYear":
+              return jsDateToNumber(DateTime.fromTimestamp(today.setFullYear(today.getFullYear() - 1)));
+      }
+  }
+  /** Get all the dates values of a criterion converted to numbers, converting date values such as "today" to actual dates  */
+  function getDateNumberCriterionValues(criterion, locale) {
+      if ("dateValue" in criterion && criterion.dateValue !== "exactDate") {
+          return [toCriterionDateNumber(criterion.dateValue)];
+      }
+      return criterion.values.map((value) => valueToDateNumber(value, locale));
+  }
+  /** Convert the criterion values to numbers. Return undefined values if they cannot be converted to numbers. */
+  function getCriterionValuesAsNumber(criterion, locale) {
+      return criterion.values.map((value) => tryToNumber(value, locale));
+  }
+  function getDateCriterionFormattedValues(values, locale) {
+      return values.map((valueStr) => {
+          if (valueStr.startsWith("=")) {
+              return valueStr;
+          }
+          const value = parseLiteral(valueStr, locale);
+          if (typeof value === "number") {
+              return formatValue(value, { format: locale.dateFormat, locale });
+          }
+          return "";
+      });
+  }
+
+  const MAX_DELAY = 140;
+  const MIN_DELAY = 20;
+  const ACCELERATION = 0.035;
+  /**
+   * Decreasing exponential function used to determine the "speed" of edge-scrolling
+   * as the timeout delay.
+   *
+   * Returns a timeout delay in milliseconds.
+   */
+  function scrollDelay(value) {
+      // decreasing exponential from MAX_DELAY to MIN_DELAY
+      return MIN_DELAY + (MAX_DELAY - MIN_DELAY) * Math.exp(-ACCELERATION * (value - 1));
+  }
+
   class RangeImpl {
       getSheetSize;
       _zone;
@@ -22094,217 +22320,6 @@ stores.inject(MyMetaStore, storeInstance);
       },
   });
 
-  /**
-   * Add the `https` prefix to the url if it's missing
-   */
-  function withHttps(url) {
-      return !/^https?:\/\//i.test(url) ? `https://${url}` : url;
-  }
-  const urlRegistry = new Registry();
-  function createWebLink(url, label) {
-      url = withHttps(url);
-      return {
-          url,
-          label: label || url,
-          isExternal: true,
-          isUrlEditable: true,
-      };
-  }
-  urlRegistry.add("sheet_URL", {
-      match: (url) => isSheetUrl(url),
-      createLink: (url, label) => {
-          return {
-              label,
-              url,
-              isExternal: false,
-              isUrlEditable: false,
-          };
-      },
-      urlRepresentation(url, getters) {
-          const sheetId = parseSheetUrl(url);
-          return getters.tryGetSheetName(sheetId) || _t("Invalid sheet");
-      },
-      open(url, env) {
-          const sheetId = parseSheetUrl(url);
-          const result = env.model.dispatch("ACTIVATE_SHEET", {
-              sheetIdFrom: env.model.getters.getActiveSheetId(),
-              sheetIdTo: sheetId,
-          });
-          if (result.isCancelledBecause("SheetIsHidden" /* CommandResult.SheetIsHidden */)) {
-              env.notifyUser({
-                  type: "warning",
-                  sticky: false,
-                  text: _t("Cannot open the link because the linked sheet is hidden."),
-              });
-          }
-      },
-      sequence: 0,
-  });
-  const WebUrlSpec = {
-      createLink: createWebLink,
-      match: (url) => isWebLink(url),
-      open: (url) => window.open(url, "_blank"),
-      urlRepresentation: (url) => url,
-      sequence: 0,
-  };
-  function findMatchingSpec(url) {
-      return (urlRegistry
-          .getAll()
-          .sort((a, b) => a.sequence - b.sequence)
-          .find((urlType) => urlType.match(url)) || WebUrlSpec);
-  }
-  function urlRepresentation(link, getters) {
-      return findMatchingSpec(link.url).urlRepresentation(link.url, getters);
-  }
-  function openLink(link, env) {
-      findMatchingSpec(link.url).open(link.url, env);
-  }
-  function detectLink(value) {
-      if (typeof value !== "string") {
-          return undefined;
-      }
-      if (isMarkdownLink(value)) {
-          const { label, url } = parseMarkdownLink(value);
-          return findMatchingSpec(url).createLink(url, label);
-      }
-      else if (isWebLink(value)) {
-          return createWebLink(value);
-      }
-      return undefined;
-  }
-
-  function evaluateLiteral(literalCell, localeFormat) {
-      const value = isTextFormat(localeFormat.format) ? literalCell.content : literalCell.parsedValue;
-      const functionResult = { value, format: localeFormat.format };
-      return createEvaluatedCell(functionResult, localeFormat.locale);
-  }
-  function parseLiteral(content, locale) {
-      if (content.startsWith("=")) {
-          throw new Error(`Cannot parse "${content}" because it's not a literal value. It's a formula`);
-      }
-      if (content === "") {
-          return null;
-      }
-      if (isNumber(content, DEFAULT_LOCALE)) {
-          return parseNumber(content, DEFAULT_LOCALE);
-      }
-      const internalDate = parseDateTime(content, locale);
-      if (internalDate) {
-          return internalDate.value;
-      }
-      if (isBoolean(content)) {
-          return content.toUpperCase() === "TRUE" ? true : false;
-      }
-      return content;
-  }
-  function createEvaluatedCell(functionResult, locale = DEFAULT_LOCALE, cell) {
-      const link = detectLink(functionResult.value);
-      if (!link) {
-          return _createEvaluatedCell(functionResult, locale, cell);
-      }
-      const value = parseLiteral(link.label, locale);
-      const format = functionResult.format ||
-          (typeof value === "number"
-              ? detectDateFormat(link.label, locale) || detectNumberFormat(link.label)
-              : undefined);
-      const linkPayload = {
-          value,
-          format,
-      };
-      return {
-          ..._createEvaluatedCell(linkPayload, locale, cell),
-          link,
-      };
-  }
-  function _createEvaluatedCell(functionResult, locale, cell) {
-      let { value, format, message } = functionResult;
-      format = cell?.format || format;
-      const formattedValue = formatValue(value, { format, locale });
-      if (isEvaluationError(value)) {
-          return errorCell(value, message);
-      }
-      if (isTextFormat(format)) {
-          // TO DO:
-          // with the next line, the value of the cell is transformed depending on the format.
-          // This shouldn't happen, by doing this, the formulas handling numbers are not able
-          // to interpret the value as a number.
-          return textCell(toString(value), format, formattedValue);
-      }
-      if (value === null) {
-          return emptyCell(format);
-      }
-      if (typeof value === "number") {
-          if (isDateTimeFormat(format || "")) {
-              return dateTimeCell(value, format, formattedValue);
-          }
-          return numberCell(value, format, formattedValue);
-      }
-      if (typeof value === "boolean") {
-          return booleanCell(value, format, formattedValue);
-      }
-      return textCell(value, format, formattedValue);
-  }
-  function textCell(value, format, formattedValue) {
-      return {
-          value,
-          format,
-          formattedValue,
-          type: CellValueType.text,
-          isAutoSummable: true,
-          defaultAlign: "left",
-      };
-  }
-  function numberCell(value, format, formattedValue) {
-      return {
-          value: value || 0, // necessary to avoid "-0" and NaN values,
-          format,
-          formattedValue,
-          type: CellValueType.number,
-          isAutoSummable: true,
-          defaultAlign: "right",
-      };
-  }
-  const emptyCell = memoize(function emptyCell(format) {
-      return {
-          value: null,
-          format,
-          formattedValue: "",
-          type: CellValueType.empty,
-          isAutoSummable: true,
-          defaultAlign: "left",
-      };
-  });
-  function dateTimeCell(value, format, formattedValue) {
-      return {
-          value,
-          format,
-          formattedValue,
-          type: CellValueType.number,
-          isAutoSummable: false,
-          defaultAlign: "right",
-      };
-  }
-  function booleanCell(value, format, formattedValue) {
-      return {
-          value,
-          format,
-          formattedValue,
-          type: CellValueType.boolean,
-          isAutoSummable: false,
-          defaultAlign: "center",
-      };
-  }
-  function errorCell(value, message) {
-      return {
-          value,
-          formattedValue: value,
-          message,
-          type: CellValueType.error,
-          isAutoSummable: false,
-          defaultAlign: "center",
-      };
-  }
-
   /**
    * An AutofillModifierImplementation is used to describe how to handle a
    * AutofillModifier.
@@ -23450,6 +23465,10 @@ stores.inject(MyMetaStore, storeInstance);
       WarningTypes["CfIconSetEmptyIconNotSupported"] = "IconSets with empty icons";
       WarningTypes["BadlyFormattedHyperlink"] = "Badly formatted hyperlink";
       WarningTypes["NumFmtIdNotSupported"] = "Number format";
+      WarningTypes["TimeDataValidationNotSupported"] = "Time data validation rules";
+      WarningTypes["TextLengthDataValidationNotSupported"] = "Text length data validation rules";
+      WarningTypes["WholeNumberDataValidationNotSupported"] = "Whole number data validation rules";
+      WarningTypes["NotEqualDateDataValidationNotSupported"] = "Not equal date data validation rules";
   })(WarningTypes || (WarningTypes = {}));
   class XLSXImportWarningManager {
       _parsingWarnings = new Set();
@@ -23828,6 +23847,25 @@ stores.inject(MyMetaStore, storeInstance);
       webp: "image/webp",
       jpg: "image/jpeg",
   };
+  const XLSX_DV_DECIMAL_OPERATOR_MAPPING = {
+      between: "isBetween",
+      notBetween: "isNotBetween",
+      equal: "isEqual",
+      notEqual: "isNotEqual",
+      greaterThan: "isGreaterThan",
+      greaterThanOrEqual: "isGreaterOrEqualTo",
+      lessThan: "isLessThan",
+      lessThanOrEqual: "isLessOrEqualTo",
+  };
+  const XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING = {
+      between: "dateIsBetween",
+      notBetween: "dateIsNotBetween",
+      equal: "dateIs",
+      greaterThan: "dateIsAfter",
+      greaterThanOrEqual: "dateIsOnOrAfter",
+      lessThan: "dateIsBefore",
+      lessThanOrEqual: "dateIsOnOrBefore",
+  };
 
   /**
    * Most of the functions could stay private, but are exported for testing purposes
@@ -24597,6 +24635,20 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return position / HEIGHT_FACTOR;
   }
+  /**
+   * Convert the o-spreadsheet data validation decimal
+   * criterion type to the corresponding excel operator.
+   */
+  function convertDecimalCriterionTypeToExcelOperator(operator) {
+      return Object.keys(XLSX_DV_DECIMAL_OPERATOR_MAPPING).find((key) => XLSX_DV_DECIMAL_OPERATOR_MAPPING[key] === operator);
+  }
+  /**
+   * Convert the o-spreadsheet data validation date
+   * criterion type to the corresponding excel operator.
+   */
+  function convertDateCriterionTypeToExcelOperator(operator) {
+      return Object.keys(XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING).find((key) => XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING[key] === operator);
+  }
 
   function convertFigures(sheetData) {
       let id = 1;
@@ -24706,6 +24758,112 @@ stores.inject(MyMetaStore, storeInstance);
       };
   }
 
+  function convertDataValidationRules(xlsxDataValidations, warningManager) {
+      const dvRules = [];
+      let dvId = 1;
+      for (const dv of xlsxDataValidations) {
+          if (!dv) {
+              continue;
+          }
+          switch (dv.type) {
+              case "time":
+                  warningManager.generateNotSupportedWarning(WarningTypes.TimeDataValidationNotSupported);
+                  break;
+              case "textLength":
+                  warningManager.generateNotSupportedWarning(WarningTypes.TextLengthDataValidationNotSupported);
+                  break;
+              case "whole":
+                  warningManager.generateNotSupportedWarning(WarningTypes.WholeNumberDataValidationNotSupported);
+                  break;
+              case "decimal":
+                  const decimalRule = convertDecimalRule(dvId++, dv);
+                  dvRules.push(decimalRule);
+                  break;
+              case "list":
+                  const listRule = convertListrule(dvId++, dv);
+                  dvRules.push(listRule);
+                  break;
+              case "date":
+                  if (dv.operator === "notEqual") {
+                      warningManager.generateNotSupportedWarning(WarningTypes.NotEqualDateDataValidationNotSupported);
+                      break;
+                  }
+                  const dateRule = convertDateRule(dvId++, dv);
+                  dvRules.push(dateRule);
+                  break;
+              case "custom":
+                  const customRule = convertCustomRule(dvId++, dv);
+                  dvRules.push(customRule);
+                  break;
+          }
+      }
+      return dvRules;
+  }
+  function convertDecimalRule(id, dv) {
+      const values = [dv.formula1.toString()];
+      if (dv.formula2) {
+          values.push(dv.formula2.toString());
+      }
+      return {
+          id: id.toString(),
+          ranges: dv.sqref,
+          isBlocking: dv.errorStyle !== "warning",
+          criterion: {
+              type: XLSX_DV_DECIMAL_OPERATOR_MAPPING[dv.operator],
+              values,
+          },
+      };
+  }
+  function convertListrule(id, dv) {
+      const formula1 = dv.formula1.toString();
+      const isRangeRule = rangeReference.test(formula1);
+      return {
+          id: id.toString(),
+          ranges: dv.sqref,
+          isBlocking: dv.errorStyle !== "warning",
+          criterion: {
+              type: isRangeRule ? "isValueInRange" : "isValueInList",
+              values: isRangeRule ? [formula1] : formula1.replaceAll('"', "").split(","),
+              displayStyle: "arrow",
+          },
+      };
+  }
+  function convertDateRule(id, dv) {
+      let criterion;
+      const values = [dv.formula1.toString()];
+      if (dv.formula2) {
+          values.push(dv.formula2.toString());
+          criterion = {
+              type: XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING[dv.operator],
+              values: getDateCriterionFormattedValues(values, DEFAULT_LOCALE),
+          };
+      }
+      else {
+          criterion = {
+              type: XLSX_DV_DATE_OPERATOR_TO_DV_TYPE_MAPPING[dv.operator],
+              values: getDateCriterionFormattedValues(values, DEFAULT_LOCALE),
+              dateValue: "exactDate",
+          };
+      }
+      return {
+          id: id.toString(),
+          ranges: dv.sqref,
+          isBlocking: dv.errorStyle !== "warning",
+          criterion: criterion,
+      };
+  }
+  function convertCustomRule(id, dv) {
+      return {
+          id: id.toString(),
+          ranges: dv.sqref,
+          isBlocking: dv.errorStyle !== "warning",
+          criterion: {
+              type: "customFormula",
+              values: [`=${dv.formula1.toString()}`],
+          },
+      };
+  }
+
   /**
    * Match external reference (ex. '[1]Sheet 3'!$B$4)
    *
@@ -24826,6 +24984,7 @@ stores.inject(MyMetaStore, storeInstance);
               cols: convertCols(sheet, sheetDims[0], colHeaderGroups),
               rows: convertRows(sheet, sheetDims[1], rowHeaderGroups),
               conditionalFormats: convertConditionalFormats(sheet.cfs, data.dxfs, warningManager),
+              dataValidationRules: convertDataValidationRules(sheet.dataValidations, warningManager),
               figures: convertFigures(sheet),
               isVisible: sheet.isVisible,
               panes: sheetOptions
@@ -26106,6 +26265,41 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class XlsxDataValidationExtractor extends XlsxBaseExtractor {
+      theme;
+      constructor(sheetFile, xlsxStructure, warningManager, theme) {
+          super(sheetFile, xlsxStructure, warningManager);
+          this.theme = theme;
+      }
+      extractDataValidations() {
+          const dataValidations = this.mapOnElements({ parent: this.rootFile.file.xml, query: "worksheet > dataValidations > dataValidation" }, (dvElement) => {
+              return {
+                  type: this.extractAttr(dvElement, "type", { required: true }).asString(),
+                  operator: this.extractAttr(dvElement, "operator", {
+                      default: "between",
+                  })?.asString(),
+                  sqref: this.extractAttr(dvElement, "sqref", { required: true }).asString().split(" "),
+                  errorStyle: this.extractAttr(dvElement, "errorStyle")?.asString(),
+                  formula1: this.extractDataValidationFormula(dvElement, 1)[0],
+                  formula2: this.extractDataValidationFormula(dvElement, 2)[0],
+                  showErrorMessage: this.extractAttr(dvElement, "showErrorMessage")?.asBool(),
+                  errorTitle: this.extractAttr(dvElement, "errorTitle")?.asString(),
+                  error: this.extractAttr(dvElement, "error")?.asString(),
+                  showInputMessage: this.extractAttr(dvElement, "showInputMessage")?.asBool(),
+                  promptTitle: this.extractAttr(dvElement, "promptTitle")?.asString(),
+                  prompt: this.extractAttr(dvElement, "prompt")?.asString(),
+                  allowBlank: this.extractAttr(dvElement, "allowBlank")?.asBool(),
+              };
+          });
+          return dataValidations;
+      }
+      extractDataValidationFormula(dvElement, index) {
+          return this.mapOnElements({ parent: dvElement, query: `formula${index}` }, (cfFormulaElements) => {
+              return this.extractTextContent(cfFormulaElements, { required: true });
+          });
+      }
+  }
+
   class XlsxChartExtractor extends XlsxBaseExtractor {
       extractChart() {
           return this.mapOnElements({ parent: this.rootFile.file.xml, query: "c:chartSpace" }, (rootChartElement) => {
@@ -26473,6 +26667,7 @@ stores.inject(MyMetaStore, storeInstance);
                   sharedFormulas: this.extractSharedFormulas(sheetElement),
                   merges: this.extractMerges(sheetElement),
                   cfs: this.extractConditionalFormats(),
+                  dataValidations: this.extractDataValidations(),
                   figures: this.extractFigures(sheetElement),
                   hyperlinks: this.extractHyperLinks(sheetElement),
                   tables: this.extractTables(sheetElement),
@@ -26544,6 +26739,9 @@ stores.inject(MyMetaStore, storeInstance);
       extractConditionalFormats() {
           return new XlsxCfExtractor(this.rootFile, this.xlsxFileStructure, this.warningManager, this.theme).extractConditionalFormattings();
       }
+      extractDataValidations() {
+          return new XlsxDataValidationExtractor(this.rootFile, this.xlsxFileStructure, this.warningManager, this.theme).extractDataValidations();
+      }
       extractFigures(worksheet) {
           const figures = this.mapOnElements({ parent: worksheet, query: "drawing" }, (drawingElement) => {
               const drawingId = this.extractAttr(drawingElement, "r:id", { required: true })?.asString();
@@ -27824,6 +28022,7 @@ stores.inject(MyMetaStore, storeInstance);
           rows: {},
           merges: [],
           conditionalFormats: [],
+          dataValidationRules: [],
           figures: [],
           tables: [],
           isVisible: true,
@@ -31387,6 +31586,10 @@ stores.inject(MyMetaStore, storeInstance);
               this.currentDisplayValue = newDisplay;
               if (!anchor)
                   return;
+              el.style.top = "";
+              el.style.left = "";
+              el.style["max-height"] = "";
+              el.style["max-width"] = "";
               const propsMaxSize = { width: this.props.maxWidth, height: this.props.maxHeight };
               let elDims = {
                   width: el.getBoundingClientRect().width,
@@ -40247,7 +40450,7 @@ stores.inject(MyMetaStore, storeInstance);
       name: _t("Date is"),
       getPreview: (criterion, getters) => {
           return criterion.dateValue === "exactDate"
-              ? _t("Date is %s", getDateCriterionFormattedValues(criterion, getters)[0])
+              ? _t("Date is %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
               : _t("Date is %s", DVTerms.DateIs[criterion.dateValue]);
       },
   });
@@ -40272,7 +40475,7 @@ stores.inject(MyMetaStore, storeInstance);
       name: _t("Date is before"),
       getPreview: (criterion, getters) => {
           return criterion.dateValue === "exactDate"
-              ? _t("Date is before %s", getDateCriterionFormattedValues(criterion, getters)[0])
+              ? _t("Date is before %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
               : _t("Date is before %s", DVTerms.DateIsBefore[criterion.dateValue]);
       },
   });
@@ -40297,7 +40500,7 @@ stores.inject(MyMetaStore, storeInstance);
       name: _t("Date is on or before"),
       getPreview: (criterion, getters) => {
           return criterion.dateValue === "exactDate"
-              ? _t("Date is on or before %s", getDateCriterionFormattedValues(criterion, getters)[0])
+              ? _t("Date is on or before %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
               : _t("Date is on or before %s", DVTerms.DateIsBefore[criterion.dateValue]);
       },
   });
@@ -40322,7 +40525,7 @@ stores.inject(MyMetaStore, storeInstance);
       name: _t("Date is after"),
       getPreview: (criterion, getters) => {
           return criterion.dateValue === "exactDate"
-              ? _t("Date is after %s", getDateCriterionFormattedValues(criterion, getters)[0])
+              ? _t("Date is after %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
               : _t("Date is after %s", DVTerms.DateIsBefore[criterion.dateValue]);
       },
   });
@@ -40347,7 +40550,7 @@ stores.inject(MyMetaStore, storeInstance);
       name: _t("Date is on or after"),
       getPreview: (criterion, getters) => {
           return criterion.dateValue === "exactDate"
-              ? _t("Date is on or after %s", getDateCriterionFormattedValues(criterion, getters)[0])
+              ? _t("Date is on or after %s", getDateCriterionFormattedValues(criterion.values, getters.getLocale())[0])
               : _t("Date is on or after %s", DVTerms.DateIsBefore[criterion.dateValue]);
       },
   });
@@ -40373,7 +40576,7 @@ stores.inject(MyMetaStore, storeInstance);
       numberOfValues: () => 2,
       name: _t("Date is between"),
       getPreview: (criterion, getters) => {
-          const values = getDateCriterionFormattedValues(criterion, getters);
+          const values = getDateCriterionFormattedValues(criterion.values, getters.getLocale());
           return _t("Date is between %s and %s", values[0], values[1]);
       },
   });
@@ -40399,7 +40602,7 @@ stores.inject(MyMetaStore, storeInstance);
       numberOfValues: () => 2,
       name: _t("Date is not between"),
       getPreview: (criterion, getters) => {
-          const values = getDateCriterionFormattedValues(criterion, getters);
+          const values = getDateCriterionFormattedValues(criterion.values, getters.getLocale());
           return _t("Date is not between %s and %s", values[0], values[1]);
       },
   });
@@ -40682,19 +40885,6 @@ stores.inject(MyMetaStore, storeInstance);
       const valueAsNumber = tryToNumber(value, DEFAULT_LOCALE);
       return valueAsNumber !== undefined;
   }
-  function getDateCriterionFormattedValues(criterion, getters) {
-      const locale = getters.getLocale();
-      return criterion.values.map((valueStr) => {
-          if (valueStr.startsWith("=")) {
-              return valueStr;
-          }
-          const value = parseLiteral(valueStr, locale);
-          if (typeof value === "number") {
-              return formatValue(value, { format: locale.dateFormat, locale });
-          }
-          return "";
-      });
-  }
 
   /** This component looks like a select input, but on click it opens a Menu with the items given as props instead of a dropdown */
   class SelectMenu extends owl.Component {
@@ -46397,7 +46587,7 @@ stores.inject(MyMetaStore, storeInstance);
               return;
           }
           const sheetId = this.env.model.getters.getActiveSheetId();
-          const zone = this.env.model.getters.getSelectedZone();
+          const zone = positionToZone(this.env.model.getters.getSelection().anchor.cell);
           const rect = this.env.model.getters.getVisibleRect(zone);
           if (!deepEquals(rect, this.rect) || sheetId !== this.composerStore.currentEditedCell.sheetId) {
               this.isCellReferenceVisible = true;
@@ -48231,13 +48421,23 @@ stores.inject(MyMetaStore, storeInstance);
       drawLayer(renderingContext, layer) {
           switch (layer) {
               case "Background":
-                  const boxes = this.getGridBoxes();
-                  this.drawBackground(renderingContext, boxes);
-                  this.drawOverflowingCellBackground(renderingContext, boxes);
-                  this.drawCellBackground(renderingContext, boxes);
-                  this.drawBorders(renderingContext, boxes);
-                  this.drawTexts(renderingContext, boxes);
-                  this.drawIcon(renderingContext, boxes);
+                  this.drawGlobalBackground(renderingContext);
+                  for (const zone of this.getters.getAllActiveViewportsZones()) {
+                      const { ctx } = renderingContext;
+                      ctx.save();
+                      ctx.beginPath();
+                      const rect = this.getters.getVisibleRect(zone);
+                      ctx.rect(rect.x, rect.y, rect.width, rect.height);
+                      ctx.clip();
+                      const boxes = this.getGridBoxes(zone);
+                      this.drawBackground(renderingContext, boxes);
+                      this.drawOverflowingCellBackground(renderingContext, boxes);
+                      this.drawCellBackground(renderingContext, boxes);
+                      this.drawBorders(renderingContext, boxes);
+                      this.drawTexts(renderingContext, boxes);
+                      this.drawIcon(renderingContext, boxes);
+                      ctx.restore();
+                  }
                   this.drawFrozenPanes(renderingContext);
                   break;
               case "Headers":
@@ -48248,12 +48448,15 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
           }
       }
-      drawBackground(renderingContext, boxes) {
-          const { ctx, thinLineWidth } = renderingContext;
+      drawGlobalBackground(renderingContext) {
+          const { ctx } = renderingContext;
           const { width, height } = this.getters.getSheetViewDimensionWithHeaders();
           // white background
           ctx.fillStyle = "#ffffff";
           ctx.fillRect(0, 0, width + CANVAS_SHIFT, height + CANVAS_SHIFT);
+      }
+      drawBackground(renderingContext, boxes) {
+          const { ctx, thinLineWidth } = renderingContext;
           const areGridLinesVisible = !this.getters.isDashboard() &&
               this.getters.getGridLinesVisibility(this.getters.getActiveSheetId());
           const inset = areGridLinesVisible ? 0.1 * thinLineWidth : 0;
@@ -48684,7 +48887,7 @@ stores.inject(MyMetaStore, storeInstance);
           const position = { sheetId, col, row };
           const cell = this.getters.getEvaluatedCell(position);
           const showFormula = this.getters.shouldShowFormulas();
-          const { x, y, width, height } = this.getters.getVisibleRect(zone);
+          const { x, y, width, height } = this.getters.getRect(zone);
           const { verticalAlign } = this.getters.getCellStyle(position);
           const box = {
               x,
@@ -48802,12 +49005,16 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return box;
       }
-      getGridBoxes() {
+      getGridBoxes(zone) {
           const boxes = [];
-          const visibleCols = this.getters.getSheetViewVisibleCols();
+          const visibleCols = this.getters
+              .getSheetViewVisibleCols()
+              .filter((col) => col >= zone.left && col <= zone.right);
           const left = visibleCols[0];
           const right = visibleCols[visibleCols.length - 1];
-          const visibleRows = this.getters.getSheetViewVisibleRows();
+          const visibleRows = this.getters
+              .getSheetViewVisibleRows()
+              .filter((row) => row >= zone.top && row <= zone.bottom);
           const top = visibleRows[0];
           const bottom = visibleRows[visibleRows.length - 1];
           const viewport = { left, right, top, bottom };
@@ -52291,6 +52498,20 @@ stores.inject(MyMetaStore, storeInstance);
               }
           }
       }
+      exportForExcel(data) {
+          if (!data.sheets) {
+              return;
+          }
+          for (const sheet of data.sheets) {
+              sheet.dataValidationRules = [];
+              for (const rule of this.rules[sheet.id]) {
+                  sheet.dataValidationRules.push({
+                      ...rule,
+                      ranges: rule.ranges.map((range) => this.getters.getRangeString(range, sheet.id, { useFixedReference: true })),
+                  });
+              }
+          }
+      }
       checkCriterionTypeIsValid(cmd) {
           return dataValidationEvaluatorRegistry.contains(cmd.rule.criterion.type)
               ? "Success" /* CommandResult.Success */
@@ -54058,6 +54279,7 @@ stores.inject(MyMetaStore, storeInstance);
                   formats: {},
                   borders: {},
                   conditionalFormats: [],
+                  dataValidationRules: [],
                   figures: [],
                   tables: [],
                   areGridLinesVisible: sheet.areGridLinesVisible === undefined ? true : sheet.areGridLinesVisible,
@@ -61248,9 +61470,6 @@ stores.inject(MyMetaStore, storeInstance);
               }
           }
           this.acknowledge(message);
-          if (message.type === "REMOTE_REVISION" && message.clientId === this.clientId) {
-              return;
-          }
           this.trigger("collaborative-event-received");
       }
       onClientMoved(message) {
@@ -64544,8 +64763,12 @@ stores.inject(MyMetaStore, storeInstance);
               },
           ];
           handler.paste({ zones: pasteTarget, sheetId }, data, { isCutOperation: true });
+          const selection = pasteTarget[0];
+          const col = selection.left;
+          const row = selection.top;
+          this.setSelectionMixin({ zone: selection, cell: { col, row } }, [selection]);
           const toRemove = isBasedBefore ? cmd.elements.map((el) => el + thickness) : cmd.elements;
-          let currentIndex = cmd.base;
+          let currentIndex = isBasedBefore ? cmd.base : cmd.base + 1;
           for (const element of toRemove) {
               const size = this.getters.getHeaderSize(cmd.sheetId, cmd.dimension, element);
               this.dispatch("RESIZE_COLUMNS_ROWS", {
@@ -64828,22 +65051,33 @@ stores.inject(MyMetaStore, storeInstance);
       }
       /**
        *
-       * @param zone
-       * @returns Computes the absolute coordinate of a given zone inside the viewport
+       * Computes the visible coordinates & dimensions of a given zone inside the viewport
+       *
        */
-      getRect(zone) {
+      getVisibleRect(zone) {
           const targetZone = intersection(zone, this);
           if (targetZone) {
               const x = this.getters.getColRowOffset("COL", this.left, targetZone.left) + this.offsetCorrectionX;
               const y = this.getters.getColRowOffset("ROW", this.top, targetZone.top) + this.offsetCorrectionY;
               const width = Math.min(this.getters.getColRowOffset("COL", targetZone.left, targetZone.right + 1), this.viewportWidth);
               const height = Math.min(this.getters.getColRowOffset("ROW", targetZone.top, targetZone.bottom + 1), this.viewportHeight);
-              return {
-                  x,
-                  y,
-                  width,
-                  height,
-              };
+              return { x, y, width, height };
+          }
+          return undefined;
+      }
+      /**
+       *
+       * @returns Computes the absolute coordinates & dimensions of a given zone inside the viewport
+       *
+       */
+      getFullRect(zone) {
+          const targetZone = intersection(zone, this);
+          if (targetZone) {
+              const x = this.getters.getColRowOffset("COL", this.left, zone.left) + this.offsetCorrectionX;
+              const y = this.getters.getColRowOffset("ROW", this.top, zone.top) + this.offsetCorrectionY;
+              const width = this.getters.getColRowOffset("COL", zone.left, zone.right + 1);
+              const height = this.getters.getColRowOffset("ROW", zone.top, zone.bottom + 1);
+              return { x, y, width, height };
           }
           return undefined;
       }
@@ -65013,6 +65247,8 @@ stores.inject(MyMetaStore, storeInstance);
           "isPositionVisible",
           "getColDimensionsInViewport",
           "getRowDimensionsInViewport",
+          "getAllActiveViewportsZones",
+          "getRect",
       ];
       viewports = {};
       /**
@@ -65399,16 +65635,27 @@ stores.inject(MyMetaStore, storeInstance);
       getVisibleRectWithoutHeaders(zone) {
           const sheetId = this.getters.getActiveSheetId();
           const viewportRects = this.getSubViewports(sheetId)
-              .map((viewport) => viewport.getRect(zone))
+              .map((viewport) => viewport.getVisibleRect(zone))
               .filter(isDefined);
           if (viewportRects.length === 0) {
               return { x: 0, y: 0, width: 0, height: 0 };
           }
-          const x = Math.min(...viewportRects.map((rect) => rect.x));
-          const y = Math.min(...viewportRects.map((rect) => rect.y));
-          const width = Math.max(...viewportRects.map((rect) => rect.x + rect.width)) - x;
-          const height = Math.max(...viewportRects.map((rect) => rect.y + rect.height)) - y;
-          return { x, y, width, height };
+          return this.recomposeRect(viewportRects);
+      }
+      /**
+       * Computes the actual size and position (:Rect) of the zone on the canvas
+       * regardless of the viewport dimensions.
+       */
+      getRect(zone) {
+          const sheetId = this.getters.getActiveSheetId();
+          const viewportRects = this.getSubViewports(sheetId)
+              .map((viewport) => viewport.getFullRect(zone))
+              .filter(isDefined);
+          if (viewportRects.length === 0) {
+              return { x: 0, y: 0, width: 0, height: 0 };
+          }
+          const rect = this.recomposeRect(viewportRects);
+          return { ...rect, x: rect.x + this.gridOffsetX, y: rect.y + this.gridOffsetY };
       }
       /**
        * Returns the position of the MainViewport relatively to the start of the grid (without headers)
@@ -65452,6 +65699,10 @@ stores.inject(MyMetaStore, storeInstance);
               end: start + (isRowHidden ? 0 : size),
           };
       }
+      getAllActiveViewportsZones() {
+          const sheetId = this.getters.getActiveSheetId();
+          return this.getSubViewports(sheetId);
+      }
       // ---------------------------------------------------------------------------
       // Private
       // ---------------------------------------------------------------------------
@@ -65642,6 +65893,13 @@ stores.inject(MyMetaStore, storeInstance);
           const height = this.sheetViewHeight + this.gridOffsetY;
           return { xRatio: offsetCorrectionX / width, yRatio: offsetCorrectionY / height };
       }
+      recomposeRect(viewportRects) {
+          const x = Math.min(...viewportRects.map((rect) => rect.x));
+          const y = Math.min(...viewportRects.map((rect) => rect.y));
+          const width = Math.max(...viewportRects.map((rect) => rect.x + rect.width)) - x;
+          const height = Math.max(...viewportRects.map((rect) => rect.y + rect.height)) - y;
+          return { x, y, width, height };
+      }
   }
 
   class HeaderPositionsUIPlugin extends UIPlugin {
@@ -70947,6 +71205,124 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  function addDataValidationRules(dataValidationRules) {
+      const dvRulesCount = dataValidationRules.length;
+      if (dvRulesCount === 0) {
+          return [];
+      }
+      const dvNodes = [new XMLString(`<dataValidations count="${dvRulesCount}">`)];
+      for (const dvRule of dataValidationRules) {
+          switch (dvRule.criterion.type) {
+              case "dateIs":
+              case "dateIsBefore":
+              case "dateIsOnOrBefore":
+              case "dateIsAfter":
+              case "dateIsOnOrAfter":
+              case "dateIsBetween":
+              case "dateIsNotBetween":
+                  dvNodes.push(addDateRule(dvRule));
+                  break;
+              case "isEqual":
+              case "isNotEqual":
+              case "isGreaterThan":
+              case "isGreaterOrEqualTo":
+              case "isLessThan":
+              case "isLessOrEqualTo":
+              case "isBetween":
+              case "isNotBetween":
+                  dvNodes.push(addDecimalRule(dvRule));
+                  break;
+              case "isValueInRange":
+              case "isValueInList":
+                  dvNodes.push(addListRule(dvRule));
+                  break;
+              case "customFormula":
+                  dvNodes.push(addCustomFormulaRule(dvRule));
+                  break;
+              default:
+                  console.warn(`Data validation ${dvRule.criterion.type} is not supported in xlsx.`);
+                  break;
+          }
+      }
+      dvNodes.push(new XMLString("</dataValidations>"));
+      return dvNodes;
+  }
+  function addDateRule(dvRule) {
+      const rule = dvRule.criterion;
+      const formula1 = adaptFormulaToExcel(rule.values[0]);
+      const formula2 = rule.values[1] ? adaptFormulaToExcel(rule.values[1]) : undefined;
+      const operator = convertDateCriterionTypeToExcelOperator(dvRule.criterion.type);
+      const attributes = commonDataValidationAttributes(dvRule);
+      attributes.push(["type", "date"], ["operator", operator]);
+      if (formula2) {
+          return escapeXml /*xml*/ `
+      <dataValidation ${formatAttributes(attributes)}>
+        <formula1>${toNumber(formula1, DEFAULT_LOCALE)}</formula1>
+        <formula2>${toNumber(formula2, DEFAULT_LOCALE)}</formula2>
+      </dataValidation>
+    `;
+      }
+      return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${toNumber(formula1, DEFAULT_LOCALE)}</formula1>
+    </dataValidation>
+  `;
+  }
+  function addDecimalRule(dvRule) {
+      const rule = dvRule.criterion;
+      const formula1 = adaptFormulaToExcel(rule.values[0]);
+      const formula2 = rule.values[1] ? adaptFormulaToExcel(rule.values[1]) : undefined;
+      const operator = convertDecimalCriterionTypeToExcelOperator(dvRule.criterion.type);
+      const attributes = commonDataValidationAttributes(dvRule);
+      attributes.push(["type", "decimal"], ["operator", operator]);
+      if (formula2) {
+          return escapeXml /*xml*/ `
+      <dataValidation ${formatAttributes(attributes)}>
+        <formula1>${formula1}</formula1>
+        <formula2>${formula2}</formula2>
+      </dataValidation>
+    `;
+      }
+      return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${formula1}</formula1>
+    </dataValidation>
+  `;
+  }
+  function addListRule(dvRule) {
+      const rule = dvRule.criterion;
+      const formula1 = dvRule.criterion.type === "isValueInRange"
+          ? adaptFormulaToExcel(rule.values[0])
+          : `"${rule.values.join(",")}"`;
+      const attributes = commonDataValidationAttributes(dvRule);
+      attributes.push(["type", "list"]);
+      return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${formula1}</formula1>
+    </dataValidation>
+  `;
+  }
+  function addCustomFormulaRule(dvRule) {
+      const rule = dvRule.criterion;
+      const formula1 = adaptFormulaToExcel(rule.values[0]);
+      const attributes = commonDataValidationAttributes(dvRule);
+      attributes.push(["type", "custom"]);
+      return escapeXml /*xml*/ `
+    <dataValidation ${formatAttributes(attributes)}>
+      <formula1>${formula1}</formula1>
+    </dataValidation>
+  `;
+  }
+  function commonDataValidationAttributes(dvRule) {
+      return [
+          ["allowBlank", "1"],
+          ["showInputMessage", "1"],
+          ["showErrorMessage", "1"],
+          ["errorStyle", !dvRule.isBlocking ? "warning" : ""],
+          ["sqref", dvRule.ranges.join(" ")],
+      ];
+  }
+
   function createDrawing(drawingRelIds, sheet, figures) {
       const namespaces = [
           ["xmlns:xdr", NAMESPACE.drawing],
@@ -71725,6 +72101,7 @@ stores.inject(MyMetaStore, storeInstance);
         ${addRows(construct, data, sheet)}
         ${addMerges(sheet.merges)}
         ${joinXmlNodes(addConditionalFormatting(construct.dxfs, sheet.conditionalFormats))}
+        ${joinXmlNodes(addDataValidationRules(sheet.dataValidationRules))}
         ${addHyperlinks(construct, data, sheetIndex)}
         ${drawingNode}
         ${tablesNode}
@@ -72676,9 +73053,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.0.9";
-  __info__.date = "2025-01-14T11:33:47.429Z";
-  __info__.hash = "0c5220e";
+  __info__.version = "18.0.11";
+  __info__.date = "2025-01-27T10:08:13.567Z";
+  __info__.hash = "e8c6bd1";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);