@odoo/o-spreadsheet 18.1.0-alpha.4 → 18.1.0-alpha.5

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.1.0-alpha.4
- * @date 2024-11-13T15:06:47.769Z
- * @hash e1ad985
+ * @version 18.1.0-alpha.5
+ * @date 2024-11-22T14:22:50.899Z
+ * @hash e13bd67
  */
 
 (function (exports, owl) {
@@ -129,7 +129,6 @@
   const HEADER_BORDER_COLOR = "#C0C0C0";
   const CELL_BORDER_COLOR = "#E2E3E3";
   const BACKGROUND_CHART_COLOR = "#FFFFFF";
-  const BORDER_CHART_COLOR = "#FFFFFF";
   const DISABLED_TEXT_COLOR = "#CACACA";
   const DEFAULT_COLOR_SCALE_MIDPOINT_COLOR = 0xb6d7a8;
   const LINK_COLOR = "#017E84";
@@ -3235,7 +3234,6 @@
   (function (ClipboardMIMEType) {
       ClipboardMIMEType["PlainText"] = "text/plain";
       ClipboardMIMEType["Html"] = "text/html";
-      ClipboardMIMEType["OSpreadsheet"] = "web application/o-spreadsheet";
   })(ClipboardMIMEType || (ClipboardMIMEType = {}));
 
   function isSheetDependent(cmd) {
@@ -4345,7 +4343,9 @@
               return reverseSearch ? numberOfValues - i - 1 : i;
           }
       }
-      return reverseSearch ? numberOfValues - closestMatchIndex - 1 : closestMatchIndex;
+      return reverseSearch && closestMatchIndex !== -1
+          ? numberOfValues - closestMatchIndex - 1
+          : closestMatchIndex;
   }
   /**
    * Normalize a value.
@@ -4399,47 +4399,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) {
@@ -5501,6 +5537,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";
+      }
+      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;
@@ -6148,6 +6371,22 @@
       const width = content[0].length, height = content.length;
       return target.map((t) => splitZoneForPaste(t, width, height)).flat();
   }
+  function parseOSClipboardContent(content) {
+      if (!content[ClipboardMIMEType.Html]) {
+          return {
+              text: content[ClipboardMIMEType.PlainText],
+          };
+      }
+      const htmlDocument = new DOMParser().parseFromString(content[ClipboardMIMEType.Html], "text/html");
+      const oSheetClipboardData = htmlDocument
+          .querySelector("div")
+          ?.getAttribute("data-osheet-clipboard");
+      const spreadsheetContent = oSheetClipboardData && JSON.parse(oSheetClipboardData);
+      return {
+          text: content[ClipboardMIMEType.PlainText],
+          data: spreadsheetContent,
+      };
+  }
 
   class ClipboardHandler {
       getters;
@@ -6169,7 +6408,7 @@
       getPasteTarget(sheetId, target, content, options) {
           return { zones: [], sheetId };
       }
-      convertOSClipboardData(data) {
+      convertTextToClipboardData(data) {
           return;
       }
   }
@@ -8012,7 +8251,7 @@
               this.dispatch("CLEAR_CELL", target);
           }
       }
-      convertOSClipboardData(text) {
+      convertTextToClipboardData(text) {
           const locale = this.getters.getLocale();
           const copiedData = {
               cells: [],
@@ -8120,6 +8359,7 @@
 
   class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
       uuidGenerator = new UuidGenerator();
+      queuedChanges = {};
       copy(data) {
           if (!data.zones.length) {
               return;
@@ -8141,6 +8381,7 @@
           return { cfRules };
       }
       paste(target, clippedContent, options) {
+          this.queuedChanges = {};
           if (options.pasteOption === "asValue") {
               return;
           }
@@ -8152,6 +8393,7 @@
           else {
               this.pasteFromCut(sheetId, zones, clippedContent);
           }
+          this.executeQueuedChanges();
       }
       pasteFromCut(sheetId, target, content) {
           const selection = target[0];
@@ -8191,34 +8433,56 @@
        * Add or remove cells to a given conditional formatting rule.
        */
       adaptCFRules(sheetId, cf, toAdd, toRemove) {
-          const newRangesXc = this.getters.getAdaptedCfRanges(sheetId, cf, toAdd, toRemove);
-          if (!newRangesXc) {
-              return;
+          if (!this.queuedChanges[sheetId]) {
+              this.queuedChanges[sheetId] = [];
           }
-          if (newRangesXc.length === 0) {
-              this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
-              return;
+          const queuedChange = this.queuedChanges[sheetId].find((queued) => queued.cf.id === cf.id);
+          if (!queuedChange) {
+              this.queuedChanges[sheetId].push({ toAdd, toRemove, cf });
+          }
+          else {
+              queuedChange.toAdd.push(...toAdd);
+              queuedChange.toRemove.push(...toRemove);
+          }
+      }
+      executeQueuedChanges() {
+          for (const sheetId in this.queuedChanges) {
+              for (const { toAdd, toRemove, cf } of this.queuedChanges[sheetId]) {
+                  const newRangesXc = this.getters.getAdaptedCfRanges(sheetId, cf, toAdd, toRemove);
+                  if (!newRangesXc) {
+                      continue;
+                  }
+                  if (newRangesXc.length === 0) {
+                      this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
+                      continue;
+                  }
+                  this.dispatch("ADD_CONDITIONAL_FORMAT", {
+                      cf: {
+                          id: cf.id,
+                          rule: cf.rule,
+                          stopIfTrue: cf.stopIfTrue,
+                      },
+                      ranges: newRangesXc,
+                      sheetId,
+                  });
+              }
           }
-          this.dispatch("ADD_CONDITIONAL_FORMAT", {
-              cf: {
-                  id: cf.id,
-                  rule: cf.rule,
-                  stopIfTrue: cf.stopIfTrue,
-              },
-              ranges: newRangesXc,
-              sheetId,
-          });
       }
       getCFToCopyTo(targetSheetId, originCF) {
-          const cfInTarget = this.getters
+          let targetCF = this.getters
               .getConditionalFormats(targetSheetId)
               .find((cf) => cf.stopIfTrue === originCF.stopIfTrue && deepEquals(cf.rule, originCF.rule));
-          return cfInTarget ? cfInTarget : { ...originCF, id: this.uuidGenerator.uuidv4(), ranges: [] };
+          const queuedCfs = this.queuedChanges[targetSheetId];
+          if (!targetCF && queuedCfs) {
+              targetCF = queuedCfs.find((queued) => queued.cf.stopIfTrue === originCF.stopIfTrue && deepEquals(queued.cf.rule, originCF.rule))?.cf;
+          }
+          return targetCF || { ...originCF, id: this.uuidGenerator.uuidv4(), ranges: [] };
       }
   }
 
   class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
       uuidGenerator = new UuidGenerator();
+      queuedChanges = {};
       copy(data) {
           const { rowsIndexes, columnsIndexes } = data;
           const sheetId = data.sheetId;
@@ -8235,6 +8499,7 @@
           return { dvRules };
       }
       paste(target, clippedContent, options) {
+          this.queuedChanges = {};
           if (options.pasteOption) {
               return;
           }
@@ -8246,6 +8511,7 @@
           else {
               this.pasteFromCut(sheetId, zones, clippedContent);
           }
+          this.executeQueuedChanges();
       }
       pasteFromCut(sheetId, target, content) {
           const selection = target[0];
@@ -8292,29 +8558,55 @@
           }
       }
       getDataValidationRuleToCopyTo(targetSheetId, originRule, newId = true) {
-          const ruleInTargetSheet = this.getters
+          let targetRule = this.getters
               .getDataValidationRules(targetSheetId)
               .find((rule) => deepEquals(originRule.criterion, rule.criterion) &&
               originRule.isBlocking === rule.isBlocking);
-          return ruleInTargetSheet
-              ? ruleInTargetSheet
-              : { ...originRule, id: newId ? this.uuidGenerator.uuidv4() : originRule.id, ranges: [] };
+          const queuedRules = this.queuedChanges[targetSheetId];
+          if (!targetRule && queuedRules) {
+              targetRule = queuedRules.find((queued) => deepEquals(originRule.criterion, queued.rule.criterion) &&
+                  originRule.isBlocking === queued.rule.isBlocking)?.rule;
+          }
+          return (targetRule || {
+              ...originRule,
+              id: newId ? this.uuidGenerator.uuidv4() : originRule.id,
+              ranges: [],
+          });
       }
       /**
        * Add or remove XCs to a given data validation rule.
        */
       adaptDataValidationRule(sheetId, rule, toAdd, toRemove) {
-          const dvZones = rule.ranges.map((range) => range.zone);
-          const newDvZones = recomputeZones([...dvZones, ...toAdd], toRemove);
-          if (newDvZones.length === 0) {
-              this.dispatch("REMOVE_DATA_VALIDATION_RULE", { sheetId, id: rule.id });
-              return;
+          if (!this.queuedChanges[sheetId]) {
+              this.queuedChanges[sheetId] = [];
+          }
+          const queuedChange = this.queuedChanges[sheetId].find((queued) => queued.rule.id === rule.id);
+          if (!queuedChange) {
+              this.queuedChanges[sheetId].push({ toAdd, toRemove, rule });
+          }
+          else {
+              queuedChange.toAdd.push(...toAdd);
+              queuedChange.toRemove.push(...toRemove);
+          }
+      }
+      executeQueuedChanges() {
+          for (const sheetId in this.queuedChanges) {
+              for (const { toAdd, toRemove, rule: dv } of this.queuedChanges[sheetId]) {
+                  // Remove the zones first in case the same position is in toAdd and toRemove
+                  const dvZones = dv.ranges.map((range) => range.zone);
+                  const withRemovedZones = recomputeZones(dvZones, toRemove);
+                  const newDvZones = recomputeZones([...withRemovedZones, ...toAdd], []);
+                  if (newDvZones.length === 0) {
+                      this.dispatch("REMOVE_DATA_VALIDATION_RULE", { sheetId, id: dv.id });
+                      continue;
+                  }
+                  this.dispatch("ADD_DATA_VALIDATION_RULE", {
+                      rule: dv,
+                      ranges: newDvZones.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
+                      sheetId,
+                  });
+              }
           }
-          this.dispatch("ADD_DATA_VALIDATION_RULE", {
-              rule,
-              ranges: newDvZones.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
-              sheetId,
-          });
       }
   }
 
@@ -10285,6 +10577,10 @@ stores.inject(MyMetaStore, storeInstance);
           description,
           type: types,
       };
+      const acceptErrors = types.includes("ANY") || types.includes("RANGE");
+      if (acceptErrors) {
+          result.acceptErrors = true;
+      }
       if (isOptional) {
           result.optional = true;
       }
@@ -12347,8 +12643,8 @@ stores.inject(MyMetaStore, storeInstance);
   const COUNT = {
       description: _t("The number of numeric values in dataset."),
       args: [
-          arg("value1 (number, range<number>)", _t("The first value or range to consider when counting.")),
-          arg("value2 (number, range<number>, repeating)", _t("Additional values or ranges to consider when counting.")),
+          arg("value1 (number, any, range<number>)", _t("The first value or range to consider when counting.")),
+          arg("value2 (number, any, range<number>, repeating)", _t("Additional values or ranges to consider when counting.")),
       ],
       compute: function (...values) {
           return countNumbers(values, this.locale);
@@ -12737,6 +13033,7 @@ stores.inject(MyMetaStore, storeInstance);
       },
       isExported: true,
   };
+  // CORREL
   // In GSheet, CORREL is just an alias to PEARSON
   const CORREL = PEARSON;
   // -----------------------------------------------------------------------------
@@ -13347,7 +13644,7 @@ stores.inject(MyMetaStore, storeInstance);
   }
   const databaseArgs = [
       arg("database (range)", _t("The array or range containing the data to consider, structured in such a way that the first row contains the labels for each column's values.")),
-      arg("field (any)", _t("Indicates which column in database contains the values to be extracted and operated on.")),
+      arg("field (number, string)", _t("Indicates which column in database contains the values to be extracted and operated on.")),
       arg("criteria (range)", _t("An array or range containing zero or more criteria to filter the database values by before operating.")),
   ];
   // -----------------------------------------------------------------------------
@@ -17729,7 +18026,7 @@ stores.inject(MyMetaStore, storeInstance);
       args: [
           arg("condition1 (boolean)", _t("The first condition to be evaluated. This can be a boolean, a number, an array, or a reference to any of those.")),
           arg("value1 (any)", _t("The returned value if condition1 is TRUE.")),
-          arg("condition2 (boolean, repeating)", _t("Additional conditions to be evaluated if the previous ones are FALSE.")),
+          arg("condition2 (boolean, any, repeating)", _t("Additional conditions to be evaluated if the previous ones are FALSE.")),
           arg("value2 (any, repeating)", _t("Additional values to be returned if their corresponding conditions are TRUE.")),
       ],
       compute: function (...values) {
@@ -17968,7 +18265,7 @@ stores.inject(MyMetaStore, storeInstance);
   const HLOOKUP = {
       description: _t("Horizontal lookup"),
       args: [
-          arg("search_key (any)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
+          arg("search_key (string, number, boolean)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
           arg("range (range)", _t("The range to consider for the search. The first row in the range is searched for the key specified in search_key.")),
           arg("index (number)", _t("The row index of the value to be returned, where the first row in range is numbered 1.")),
           arg(`is_sorted (boolean, default=${DEFAULT_IS_SORTED})`, _t("Indicates whether the row to be searched (the first row of the specified range) is sorted, in which case the closest match for search_key will be returned.")),
@@ -17976,9 +18273,6 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (searchKey, range, index, isSorted = { value: DEFAULT_IS_SORTED }) {
           const _index = Math.trunc(toNumber(index?.value, this.locale));
           assert(() => 1 <= _index && _index <= range[0].length, _t("[[FUNCTION_NAME]] evaluates to an out of bounds range."));
-          if (searchKey && isEvaluationError(searchKey.value)) {
-              return searchKey;
-          }
           const getValueFromRange = (range, index) => range[index][0].value;
           const _isSorted = toBoolean(isSorted.value);
           const colIndex = _isSorted
@@ -18075,7 +18369,7 @@ stores.inject(MyMetaStore, storeInstance);
   const LOOKUP = {
       description: _t("Look up a value."),
       args: [
-          arg("search_key (any)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
+          arg("search_key (string, number, boolean)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
           arg("search_array (range)", _t("One method of using this function is to provide a single sorted row or column search_array to look through for the search_key with a second argument result_range. The other way is to combine these two arguments into one search_array where the first row or column is searched and a value is returned from the last row or column in the array. If search_key is not found, a non-exact match may be returned.")),
           arg("result_range (range, optional)", _t("The range from which to return a result. The value returned corresponds to the location where search_key is found in search_range. This range must be only a single row or column and should not be used if using the search_result_array method.")),
       ],
@@ -18115,7 +18409,7 @@ stores.inject(MyMetaStore, storeInstance);
   const MATCH = {
       description: _t("Position of item in range that matches value."),
       args: [
-          arg("search_key (any)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
+          arg("search_key (string, number, boolean)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
           arg("range (any, range)", _t("The one-dimensional array to be searched.")),
           arg(`search_type (number, default=${DEFAULT_SEARCH_TYPE})`, _t("The search method. 1 (default) finds the largest value less than or equal to search_key when range is sorted in ascending order. 0 finds the exact value when range is unsorted. -1 finds the smallest value greater than or equal to search_key when range is sorted in descending order.")),
       ],
@@ -18190,7 +18484,7 @@ stores.inject(MyMetaStore, storeInstance);
   const VLOOKUP = {
       description: _t("Vertical lookup."),
       args: [
-          arg("search_key (any)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
+          arg("search_key (string, number, boolean)", _t("The value to search for. For example, 42, 'Cats', or I24.")),
           arg("range (any, range)", _t("The range to consider for the search. The first column in the range is searched for the key specified in search_key.")),
           arg("index (number)", _t("The column index of the value to be returned, where the first column in range is numbered 1.")),
           arg(`is_sorted (boolean, default=${DEFAULT_IS_SORTED})`, _t("Indicates whether the column to be searched (the first column of the specified range) is sorted, in which case the closest match for search_key will be returned.")),
@@ -18198,9 +18492,6 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (searchKey, range, index, isSorted = { value: DEFAULT_IS_SORTED }) {
           const _index = Math.trunc(toNumber(index?.value, this.locale));
           assert(() => 1 <= _index && _index <= range.length, _t("[[FUNCTION_NAME]] evaluates to an out of bounds range."));
-          if (searchKey && isEvaluationError(searchKey.value)) {
-              return searchKey;
-          }
           const getValueFromRange = (range, index) => range[0][index].value;
           const _isSorted = toBoolean(isSorted.value);
           const rowIndex = _isSorted
@@ -18226,7 +18517,7 @@ stores.inject(MyMetaStore, storeInstance);
   const XLOOKUP = {
       description: _t("Search a range for a match and return the corresponding item from a second range."),
       args: [
-          arg("search_key (any)", _t("The value to search for.")),
+          arg("search_key (string,number,boolean)", _t("The value to search for.")),
           arg("lookup_range (any, range)", _t("The range to consider for the search. Should be a single column or a single row.")),
           arg("return_range (any, range)", _t("The range containing the return value. Should have the same dimensions as lookup_range.")),
           arg("if_not_found (any, optional)", _t("If a valid match is not found, return this value.")),
@@ -18251,9 +18542,6 @@ stores.inject(MyMetaStore, storeInstance);
           assert(() => lookupDirection === "col"
               ? returnRange[0].length === lookupRange[0].length
               : returnRange.length === lookupRange.length, _t("return_range should have the same dimensions as lookup_range."));
-          if (searchKey && isEvaluationError(searchKey.value)) {
-              return [[searchKey]];
-          }
           const getElement = lookupDirection === "col"
               ? (range, index) => range[0][index].value
               : (range, index) => range[index][0].value;
@@ -18278,13 +18566,14 @@ stores.inject(MyMetaStore, storeInstance);
   //--------------------------------------------------------------------------
   // Pivot functions
   //--------------------------------------------------------------------------
+  // PIVOT.VALUE
   const PIVOT_VALUE = {
       description: _t("Get the value from a pivot."),
       args: [
-          arg("pivot_id (string)", _t("ID of the pivot.")),
+          arg("pivot_id (number,string)", _t("ID of the pivot.")),
           arg("measure_name (string)", _t("Name of the measure.")),
           arg("domain_field_name (string,optional,repeating)", _t("Field name.")),
-          arg("domain_value (string,optional,repeating)", _t("Value.")),
+          arg("domain_value (number,string,boolean,optional,repeating)", _t("Value.")),
       ],
       compute: function (formulaId, measureName, ...domainArgs) {
           const _pivotFormulaId = toString(formulaId);
@@ -18311,12 +18600,13 @@ stores.inject(MyMetaStore, storeInstance);
           return pivot.getPivotCellValueAndFormat(_measure, domain);
       },
   };
+  // PIVOT.HEADER
   const PIVOT_HEADER = {
       description: _t("Get the header of a pivot."),
       args: [
-          arg("pivot_id (string)", _t("ID of the pivot.")),
+          arg("pivot_id (number,string)", _t("ID of the pivot.")),
           arg("domain_field_name (string,optional,repeating)", _t("Field name.")),
-          arg("domain_value (string,optional,repeating)", _t("Value.")),
+          arg("domain_value (number,string,value,optional,repeating)", _t("Value.")),
       ],
       compute: function (pivotId, ...domainArgs) {
           const _pivotFormulaId = toString(pivotId);
@@ -18563,8 +18853,8 @@ stores.inject(MyMetaStore, storeInstance);
   const EQ = {
       description: _t("Equal."),
       args: [
-          arg("value1 (any)", _t("The first value.")),
-          arg("value2 (any)", _t("The value to test against value1 for equality.")),
+          arg("value1 (string, number, boolean)", _t("The first value.")),
+          arg("value2 (string, number, boolean)", _t("The value to test against value1 for equality.")),
       ],
       compute: function (value1, value2) {
           if (isEvaluationError(value1?.value)) {
@@ -18615,8 +18905,8 @@ stores.inject(MyMetaStore, storeInstance);
   const GT = {
       description: _t("Strictly greater than."),
       args: [
-          arg("value1 (any)", _t("The value to test as being greater than value2.")),
-          arg("value2 (any)", _t("The second value.")),
+          arg("value1 (number, string, boolean)", _t("The value to test as being greater than value2.")),
+          arg("value2 (number, string, boolean)", _t("The second value.")),
       ],
       compute: function (value1, value2) {
           return applyRelationalOperator(value1, value2, (v1, v2) => {
@@ -18630,8 +18920,8 @@ stores.inject(MyMetaStore, storeInstance);
   const GTE = {
       description: _t("Greater than or equal to."),
       args: [
-          arg("value1 (any)", _t("The value to test as being greater than or equal to value2.")),
-          arg("value2 (any)", _t("The second value.")),
+          arg("value1 (number, string, boolean)", _t("The value to test as being greater than or equal to value2.")),
+          arg("value2 (number, string, boolean)", _t("The second value.")),
       ],
       compute: function (value1, value2) {
           return applyRelationalOperator(value1, value2, (v1, v2) => {
@@ -18645,8 +18935,8 @@ stores.inject(MyMetaStore, storeInstance);
   const LT = {
       description: _t("Less than."),
       args: [
-          arg("value1 (any)", _t("The value to test as being less than value2.")),
-          arg("value2 (any)", _t("The second value.")),
+          arg("value1 (number, string, boolean)", _t("The value to test as being less than value2.")),
+          arg("value2 (number, string, boolean)", _t("The second value.")),
       ],
       compute: function (value1, value2) {
           const result = GTE.compute.bind(this)(value1, value2);
@@ -18662,8 +18952,8 @@ stores.inject(MyMetaStore, storeInstance);
   const LTE = {
       description: _t("Less than or equal to."),
       args: [
-          arg("value1 (any)", _t("The value to test as being less than or equal to value2.")),
-          arg("value2 (any)", _t("The second value.")),
+          arg("value1 (number, string, boolean)", _t("The value to test as being less than or equal to value2.")),
+          arg("value2 (number, string, boolean)", _t("The second value.")),
       ],
       compute: function (value1, value2) {
           const result = GT.compute.bind(this)(value1, value2);
@@ -18711,8 +19001,8 @@ stores.inject(MyMetaStore, storeInstance);
   const NE = {
       description: _t("Not equal."),
       args: [
-          arg("value1 (any)", _t("The first value.")),
-          arg("value2 (any)", _t("The value to test against value1 for inequality.")),
+          arg("value1 (string, number, boolean)", _t("The first value.")),
+          arg("value2 (string, number, boolean)", _t("The value to test against value1 for inequality.")),
       ],
       compute: function (value1, value2) {
           const result = EQ.compute.bind(this)(value1, value2);
@@ -19630,6 +19920,16 @@ stores.inject(MyMetaStore, storeInstance);
           });
       }
       function errorHandlingCompute(...args) {
+          for (let i = 0; i < args.length; i++) {
+              const arg = args[i];
+              const argDefinition = descr.args[descr.getArgToFocus(i + 1) - 1];
+              // Early exit if the argument is an error and the function does not accept errors
+              // We only check scalar arguments, not matrix arguments for performance reasons.
+              // Casting helpers are responsible for handling errors in matrix arguments.
+              if (!argDefinition.acceptErrors && !isMatrix(arg) && isEvaluationError(arg?.value)) {
+                  return arg;
+              }
+          }
           try {
               return computeFunctionToObject.apply(this, args);
           }
@@ -19638,6 +19938,9 @@ stores.inject(MyMetaStore, storeInstance);
           }
       }
       function computeFunctionToObject(...args) {
+          if (this.debug) {
+              debugger;
+          }
           const result = descr.compute.apply(this, args);
           if (!isMatrix(result)) {
               if (typeof result === "object" && result !== null && "value" in result) {
@@ -20747,6 +21050,7 @@ stores.inject(MyMetaStore, storeInstance);
               }
               if (ast.debug) {
                   code.append("debugger;");
+                  code.append(`ctx["debug"] = true;`);
               }
               switch (ast.type) {
                   case "BOOLEAN":
@@ -21345,217 +21649,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";
-      }
-      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.
@@ -22920,6 +23013,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();
@@ -23298,6 +23395,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
@@ -24079,6 +24195,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;
@@ -24188,6 +24318,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)
    *
@@ -24308,6 +24544,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
@@ -25587,6 +25824,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) => {
@@ -25954,6 +26226,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),
@@ -26025,6 +26298,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();
@@ -27332,6 +27608,7 @@ stores.inject(MyMetaStore, storeInstance);
           rows: {},
           merges: [],
           conditionalFormats: [],
+          dataValidationRules: [],
           figures: [],
           tables: [],
           isVisible: true,
@@ -27406,17 +27683,15 @@ stores.inject(MyMetaStore, storeInstance);
           });
       }
       catch (error) {
-          const parsedSpreadsheetContent = clipboardContent[ClipboardMIMEType.OSpreadsheet]
-              ? JSON.parse(clipboardContent[ClipboardMIMEType.OSpreadsheet])
-              : {};
-          if (parsedSpreadsheetContent.version && parsedSpreadsheetContent.version !== CURRENT_VERSION) {
+          const parsedSpreadsheetContent = clipboardContent.data;
+          if (parsedSpreadsheetContent?.version !== CURRENT_VERSION) {
               env.raiseError(_t("An unexpected error occurred while pasting content.\
           This is probably due to a spreadsheet version mismatch."));
           }
           result = env.model.dispatch("PASTE_FROM_OS_CLIPBOARD", {
               target,
               clipboardContent: {
-                  [ClipboardMIMEType.PlainText]: clipboardContent[ClipboardMIMEType.PlainText],
+                  text: clipboardContent.text,
               },
               pasteOption,
           });
@@ -27541,6 +27816,13 @@ stores.inject(MyMetaStore, storeInstance);
           numberValue: _t("The value must be a number"),
           dateValue: _t("The value must be a date"),
           validRange: _t("The value must be a valid range"),
+          validFormula: _t("The formula must be valid"),
+      },
+      Errors: {
+          ["InvalidRange" /* CommandResult.InvalidRange */]: _t("The range is invalid."),
+          ["InvalidDataValidationCriterionValue" /* CommandResult.InvalidDataValidationCriterionValue */]: _t("One or more of the provided criteria values are invalid. Please review and correct them."),
+          ["InvalidNumberOfCriterionValues" /* CommandResult.InvalidNumberOfCriterionValues */]: _t("One or more of the provided criteria values are missing."),
+          Unexpected: _t("The rule is invalid for an unknown reason."),
       },
   };
   const TableTerms = {
@@ -27751,7 +28033,7 @@ stores.inject(MyMetaStore, storeInstance);
           labels.length > dataSetsValues[0].data.length) {
           labels.shift();
       }
-      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+      ({ labels, dataSetsValues } = filterInvalidDataPoints(labels, dataSetsValues));
       if (definition.aggregated) {
           ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
       }
@@ -27806,7 +28088,7 @@ stores.inject(MyMetaStore, storeInstance);
           labels.length > dataSetsValues[0].data.length) {
           labels.shift();
       }
-      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+      ({ labels, dataSetsValues } = filterInvalidDataPoints(labels, dataSetsValues));
       if (axisType === "time") {
           ({ labels, dataSetsValues } = fixEmptyLabelsForDateCharts(labels, dataSetsValues));
       }
@@ -27823,7 +28105,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (definition.cumulative) {
               let accumulator = 0;
               data = data.map((value) => {
-                  if (!isNaN(value)) {
+                  if (!isNaN(parseFloat(value))) {
                       accumulator += parseFloat(value);
                       return accumulator;
                   }
@@ -27856,11 +28138,11 @@ stores.inject(MyMetaStore, storeInstance);
           labels.length > dataSetsValues[0].data.length) {
           labels.shift();
       }
-      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+      ({ labels, dataSetsValues } = filterInvalidDataPoints(labels, dataSetsValues));
       if (definition.aggregated) {
           ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
       }
-      ({ dataSetsValues, labels } = filterNegativeValues(labels, dataSetsValues));
+      ({ dataSetsValues, labels } = keepOnlyPositiveValues(labels, dataSetsValues));
       const dataSetFormat = getChartDatasetFormat(getters, dataSets, "left");
       return {
           dataSetsValues,
@@ -27878,7 +28160,7 @@ stores.inject(MyMetaStore, storeInstance);
           labels.length > dataSetsValues[0].data.length) {
           labels.shift();
       }
-      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+      ({ labels, dataSetsValues } = filterInvalidDataPoints(labels, dataSetsValues));
       if (definition.aggregated) {
           ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
       }
@@ -28057,26 +28339,16 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return isInstalled;
   }
-  function filterNegativeValues(labels, datasets) {
-      const dataPointsIndexes = labels.reduce((indexes, label, i) => {
-          const shouldKeep = datasets.some((dataset) => {
-              const dataPoint = dataset.data[i];
-              return typeof dataPoint !== "number" || dataPoint >= 0;
-          });
-          if (shouldKeep) {
-              indexes.push(i);
-          }
-          return indexes;
-      }, []);
-      const filteredLabels = dataPointsIndexes.map((i) => labels[i] || "");
-      const filteredDatasets = datasets.map((dataset) => ({
-          ...dataset,
-          data: dataPointsIndexes.map((i) => {
-              const dataPoint = dataset.data[i];
-              return typeof dataPoint !== "number" || dataPoint >= 0 ? dataPoint : 0;
-          }),
-      }));
-      return { labels: filteredLabels, dataSetsValues: filteredDatasets };
+  function keepOnlyPositiveValues(labels, datasets) {
+      const numberOfDataPoints = Math.max(labels.length, ...datasets.map((dataset) => dataset.data?.length || 0));
+      const filteredIndexes = range(0, numberOfDataPoints).filter((i) => datasets.some((ds) => typeof ds.data[i] === "number" && ds.data[i] > 0));
+      return {
+          labels: filteredIndexes.map((i) => labels[i] || ""),
+          dataSetsValues: datasets.map((ds) => ({
+              ...ds,
+              data: filteredIndexes.map((i) => typeof ds.data[i] === "number" && ds.data[i] > 0 ? ds.data[i] : null),
+          })),
+      };
   }
   function fixEmptyLabelsForDateCharts(labels, dataSetsValues) {
       if (labels.length === 0 || labels.every((label) => !label)) {
@@ -28109,18 +28381,23 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return [];
   }
-  function filterEmptyDataPoints(labels, datasets) {
+  /**
+   * Filter the data points that:
+   * - have neither a label nor a value
+   * - have no label and a non-numeric value
+   */
+  function filterInvalidDataPoints(labels, datasets) {
       const numberOfDataPoints = Math.max(labels.length, ...datasets.map((dataset) => dataset.data?.length || 0));
       const dataPointsIndexes = range(0, numberOfDataPoints).filter((dataPointIndex) => {
           const label = labels[dataPointIndex];
           const values = datasets.map((dataset) => dataset.data?.[dataPointIndex]);
-          return label || values.some((value) => value === 0 || Boolean(value));
+          return label || values.some((value) => typeof value === "number");
       });
       return {
           labels: dataPointsIndexes.map((i) => labels[i] || ""),
           dataSetsValues: datasets.map((dataset) => ({
               ...dataset,
-              data: dataPointsIndexes.map((i) => dataset.data[i]),
+              data: dataPointsIndexes.map((i) => typeof dataset.data[i] === "number" ? dataset.data[i] : null),
           })),
       };
   }
@@ -28263,8 +28540,8 @@ stores.inject(MyMetaStore, storeInstance);
           const dataset = {
               label,
               data,
-              borderColor: BORDER_CHART_COLOR,
-              borderWidth: 1,
+              borderColor: definition.background || BACKGROUND_CHART_COLOR,
+              borderWidth: definition.stacked ? 1 : 0,
               backgroundColor,
               yAxisID: definition.horizontal ? "y" : definition.dataSets?.[index].yAxisId || "y",
               xAxisID: "x",
@@ -32936,13 +33213,11 @@ stores.inject(MyMetaStore, storeInstance);
       const osClipboard = await env.clipboard.read();
       switch (osClipboard.status) {
           case "ok":
-              const htmlDocument = new DOMParser().parseFromString(osClipboard.content[ClipboardMIMEType.Html] ?? "<div></div>", "text/html");
-              const osClipboardSpreadsheetContent = osClipboard.content[ClipboardMIMEType.OSpreadsheet] || "{}";
-              const clipboardId = JSON.parse(osClipboardSpreadsheetContent).clipboardId ??
-                  htmlDocument.querySelector("div")?.getAttribute("data-clipboard-id");
+              const clipboardContent = parseOSClipboardContent(osClipboard.content);
+              const clipboardId = clipboardContent.data?.clipboardId;
               const target = env.model.getters.getSelectedZones();
               if (env.model.getters.getClipboardId() !== clipboardId) {
-                  interactivePasteFromOS(env, target, osClipboard.content, pasteOption);
+                  interactivePasteFromOS(env, target, clipboardContent, pasteOption);
               }
               else {
                   interactivePaste(env, target, pasteOption);
@@ -36162,7 +36437,7 @@ stores.inject(MyMetaStore, storeInstance);
       flex-grow: 0;
     }
 
-    /** Make the character a bit bigger
+    /* Make the character a bit bigger
     compared to its neighbor INPUT box  */
     .o-remove-selection {
       font-size: calc(100% + 4px);
@@ -36767,7 +37042,7 @@ stores.inject(MyMetaStore, storeInstance);
   css /* scss */ `
   .o-color-picker {
     padding: ${PICKER_PADDING}px 0;
-    /** FIXME: this is useless, overiden by the popover container */
+    /* FIXME: this is useless, overiden by the popover container */
     box-shadow: 1px 2px 5px 2px rgba(51, 51, 51, 0.15);
     background-color: white;
     line-height: 1.2;
@@ -36910,7 +37185,7 @@ stores.inject(MyMetaStore, storeInstance);
           margin-right: 2px;
         }
         .o-wrong-color {
-          /** FIXME bootstrap class instead? */
+          /* FIXME bootstrap class instead? */
           outline-color: red;
           border-color: red;
           &:focus {
@@ -38954,10 +39229,10 @@ stores.inject(MyMetaStore, storeInstance);
     }
 
     .fa-stack {
-      // reset stack size which is doubled by default
-      width: 1em;
-      height: 1em;
-      line-height: 1em;
+      /* reset stack size which is doubled by default */
+      width: ${CLOSE_ICON_RADIUS * 2}px;
+      height: ${CLOSE_ICON_RADIUS * 2}px;
+      line-height: ${CLOSE_ICON_RADIUS * 2}px;
     }
 
     .force-open-assistant {
@@ -38974,7 +39249,7 @@ stores.inject(MyMetaStore, storeInstance);
       margin: 1px 4px;
 
       .o-semi-bold {
-        /** FIXME: to remove in favor of Bootstrap
+        /* FIXME: to remove in favor of Bootstrap
         * 'fw-semibold' when we upgrade to Bootstrap 5.2
         */
         font-weight: 600 !important;
@@ -40210,7 +40485,7 @@ stores.inject(MyMetaStore, storeInstance);
         .o-threshold-value {
           flex-grow: 1;
           flex-basis: 60%;
-          min-width: 0px; // input overflows in Firefox otherwise
+          min-width: 0px; /* input overflows in Firefox otherwise */
         }
         .o-threshold-value input:disabled {
           background-color: #edebed;
@@ -41029,7 +41304,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]);
       },
   });
@@ -41054,7 +41329,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]);
       },
   });
@@ -41079,7 +41354,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]);
       },
   });
@@ -41104,7 +41379,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]);
       },
   });
@@ -41129,7 +41404,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]);
       },
   });
@@ -41155,7 +41430,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]);
       },
   });
@@ -41181,7 +41456,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]);
       },
   });
@@ -41464,19 +41739,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 {
@@ -41558,6 +41820,7 @@ stores.inject(MyMetaStore, storeInstance);
           focused: false,
           onBlur: () => { },
       };
+      static components = { StandaloneComposer: StandaloneComposer };
       inputRef = owl.useRef("input");
       setup() {
           owl.useEffect(() => {
@@ -41569,10 +41832,6 @@ stores.inject(MyMetaStore, storeInstance);
       state = owl.useState({
           shouldDisplayError: !!this.props.value, // Don't display error if user inputted nothing yet
       });
-      onValueChanged(ev) {
-          this.state.shouldDisplayError = true;
-          this.props.onValueChanged(ev.target.value);
-      }
       get placeholder() {
           const evaluator = dataValidationEvaluatorRegistry.get(this.props.criterionType);
           if (evaluator.allowedValues === "onlyFormulas") {
@@ -41583,6 +41842,27 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return _t("Value or formula");
       }
+      get allowedValues() {
+          const evaluator = dataValidationEvaluatorRegistry.get(this.props.criterionType);
+          return evaluator.allowedValues ?? "any";
+      }
+      onInputValueChanged(ev) {
+          this.state.shouldDisplayError = true;
+          this.props.onValueChanged(ev.target.value);
+      }
+      onChangeComposerValue(str) {
+          this.state.shouldDisplayError = true;
+          this.props.onValueChanged(str);
+      }
+      getDataValidationRuleInputComposerProps() {
+          return {
+              onConfirm: (str) => this.onChangeComposerValue(str),
+              composerContent: this.props.value,
+              placeholder: this.placeholder,
+              class: "o-sidePanel-composer",
+              defaultRangeSheetId: this.env.model.getters.getActiveSheetId(),
+          };
+      }
       get errorMessage() {
           if (!this.state.shouldDisplayError) {
               return undefined;
@@ -41918,13 +42198,13 @@ stores.inject(MyMetaStore, storeInstance);
 
   class DataValidationEditor extends owl.Component {
       static template = "o-spreadsheet-DataValidationEditor";
-      static components = { SelectionInput, SelectMenu, Section };
+      static components = { SelectionInput, SelectMenu, Section, ValidationMessages };
       static props = {
           rule: { type: Object, optional: true },
           onExit: Function,
           onCloseSidePanel: { type: Function, optional: true },
       };
-      state = owl.useState({ rule: this.defaultDataValidationRule });
+      state = owl.useState({ rule: this.defaultDataValidationRule, errors: [] });
       setup() {
           if (this.props.rule) {
               const sheetId = this.env.model.getters.getActiveSheetId();
@@ -41949,15 +42229,15 @@ stores.inject(MyMetaStore, storeInstance);
           this.state.rule.isBlocking = isBlocking === "true";
       }
       onSave() {
-          if (!this.canSave) {
-              return;
+          if (this.state.rule) {
+              const result = this.env.model.dispatch("ADD_DATA_VALIDATION_RULE", this.dispatchPayload);
+              if (!result.isSuccessful) {
+                  this.state.errors = result.reasons;
+              }
+              else {
+                  this.props.onExit();
+              }
           }
-          this.env.model.dispatch("ADD_DATA_VALIDATION_RULE", this.dispatchPayload);
-          this.props.onExit();
-      }
-      get canSave() {
-          return this.env.model.canDispatch("ADD_DATA_VALIDATION_RULE", this.dispatchPayload)
-              .isSuccessful;
       }
       get dispatchPayload() {
           const rule = { ...this.state.rule, ranges: undefined };
@@ -41998,6 +42278,9 @@ stores.inject(MyMetaStore, storeInstance);
       get criterionComponent() {
           return dataValidationPanelCriteriaRegistry.get(this.state.rule.criterion.type).component;
       }
+      get errorMessages() {
+          return this.state.errors.map((error) => DVTerms.Errors[error] || DVTerms.Errors.Unexpected);
+      }
   }
 
   css /* scss */ `
@@ -42009,7 +42292,7 @@ stores.inject(MyMetaStore, storeInstance);
       border-bottom: 1px solid ${FIGURE_BORDER_COLOR};
 
       .o-dv-container {
-        min-width: 0; // otherwise flex won't shrink correctly
+        min-width: 0; /* otherwise flex won't shrink correctly */
       }
 
       .o-dv-preview-description {
@@ -45027,6 +45310,9 @@ stores.inject(MyMetaStore, storeInstance);
           PivotLayoutConfigurator,
           Section,
       };
+      setup() {
+          useHighlights(this);
+      }
       get sidePanelEditor() {
           const pivot = this.env.model.getters.getPivotCoreDefinition(this.props.pivotId);
           if (!pivot) {
@@ -45034,6 +45320,9 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return pivotSidePanelRegistry.get(pivot.type).editor;
       }
+      get highlights() {
+          return getPivotHighlights(this.env.model.getters, this.props.pivotId);
+      }
   }
 
   css /* scss */ `
@@ -45703,7 +45992,7 @@ stores.inject(MyMetaStore, storeInstance);
 
   css /* scss */ `
   .o-table-style-popover {
-    /** 7 tables preview + padding by line */
+    /* 7 tables preview + padding by line */
     width: calc((66px + 4px * 2) * 7 + 1.5rem * 2);
     background: #fff;
     font-size: 14px;
@@ -47255,7 +47544,7 @@ stores.inject(MyMetaStore, storeInstance);
     box-sizing: border-box !important;
     accent-color: #808080;
     margin: ${MARGIN}px;
-    /** required to prevent the checkbox position to be sensible to the font-size (affects Firefox) */
+    /* required to prevent the checkbox position to be sensible to the font-size (affects Firefox) */
     position: absolute;
   }
 `;
@@ -47602,7 +47891,7 @@ stores.inject(MyMetaStore, storeInstance);
     }
   }
   .o-figure-container {
-    -webkit-user-select: none; // safari
+    -webkit-user-select: none; /* safari */
     user-select: none;
   }
 `;
@@ -50675,25 +50964,20 @@ stores.inject(MyMetaStore, storeInstance);
           if (!clipboardData) {
               return;
           }
-          const clipboardDataTextContent = clipboardData?.getData(ClipboardMIMEType.PlainText);
-          const clipboardDataHtmlContent = clipboardData?.getData(ClipboardMIMEType.Html);
-          const htmlDocument = new DOMParser().parseFromString(clipboardDataHtmlContent ?? "<div></div>", "text/html");
-          const osClipboardSpreadsheetContent = clipboardData.getData(ClipboardMIMEType.OSpreadsheet) || "{}";
+          const osClipboard = {
+              content: {
+                  [ClipboardMIMEType.PlainText]: clipboardData?.getData(ClipboardMIMEType.PlainText),
+                  [ClipboardMIMEType.Html]: clipboardData?.getData(ClipboardMIMEType.Html),
+              },
+          };
           const target = this.env.model.getters.getSelectedZones();
           const isCutOperation = this.env.model.getters.isCutOperation();
-          const clipboardId = JSON.parse(osClipboardSpreadsheetContent).clipboardId ??
-              htmlDocument.querySelector("div")?.getAttribute("data-clipboard-id");
+          const clipboardContent = parseOSClipboardContent(osClipboard.content);
+          const clipboardId = clipboardContent.data?.clipboardId;
           if (this.env.model.getters.getClipboardId() === clipboardId) {
               interactivePaste(this.env, target);
           }
           else {
-              const clipboardContent = {
-                  [ClipboardMIMEType.PlainText]: clipboardDataTextContent,
-                  [ClipboardMIMEType.Html]: clipboardDataHtmlContent,
-              };
-              if (osClipboardSpreadsheetContent !== "{}") {
-                  clipboardContent[ClipboardMIMEType.OSpreadsheet] = osClipboardSpreadsheetContent;
-              }
               interactivePasteFromOS(this.env, target, clipboardContent);
           }
           if (isCutOperation) {
@@ -52513,8 +52797,9 @@ stores.inject(MyMetaStore, storeInstance);
           if (replaceIndex > -1) {
               currentRanges = rules[replaceIndex].ranges.map(toUnboundedZone);
           }
-          currentRanges = currentRanges.concat(toAdd);
-          return recomputeZones(currentRanges, toRemove).map((zone) => this.getters.getRangeDataFromZone(sheetId, zone));
+          // Remove the zones first in case the same position is in toAdd and toRemove
+          const withRemovedZones = recomputeZones(currentRanges, toRemove);
+          return recomputeZones([...toAdd, ...withRemovedZones], []).map((zone) => this.getters.getRangeDataFromZone(sheetId, zone));
       }
       // ---------------------------------------------------------------------------
       // Private
@@ -52825,7 +53110,7 @@ stores.inject(MyMetaStore, storeInstance);
       allowDispatch(cmd) {
           switch (cmd.type) {
               case "ADD_DATA_VALIDATION_RULE":
-                  return this.checkValidations(cmd, this.chainValidations(this.checkEmptyRange, this.checkCriterionTypeIsValid, this.checkCriterionHasValidNumberOfValues, this.checkCriterionValuesAreValid));
+                  return this.checkValidations(cmd, this.chainValidations(this.checkEmptyRange, this.checkValidRange, this.checkCriterionTypeIsValid, this.checkCriterionHasValidNumberOfValues, this.checkCriterionValuesAreValid));
               case "REMOVE_DATA_VALIDATION_RULE":
                   if (!this.rules[cmd.sheetId].find((rule) => rule.id === cmd.id)) {
                       return "UnknownDataValidationRule" /* CommandResult.UnknownDataValidationRule */;
@@ -52984,6 +53269,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 */
@@ -53002,21 +53301,28 @@ stores.inject(MyMetaStore, storeInstance);
       checkCriterionValuesAreValid(cmd) {
           const criterion = cmd.rule.criterion;
           const evaluator = dataValidationEvaluatorRegistry.get(criterion.type);
-          if (criterion.values.some((value) => {
-              if (value.startsWith("=")) {
-                  return evaluator.allowedValues === "onlyLiterals";
-              }
-              else if (evaluator.allowedValues === "onlyFormulas") {
+          const isInvalid = (value) => {
+              if (evaluator.allowedValues === "onlyFormulas" && !value.startsWith("=")) {
                   return true;
               }
-              else {
-                  return !evaluator.isCriterionValueValid(value);
+              if (value.startsWith("=")) {
+                  return evaluator.allowedValues === "onlyLiterals" || compile(value).isBadExpression;
               }
-          })) {
+              return !evaluator.isCriterionValueValid(value);
+          };
+          if (criterion.values.some(isInvalid)) {
               return "InvalidDataValidationCriterionValue" /* CommandResult.InvalidDataValidationCriterionValue */;
           }
           return "Success" /* CommandResult.Success */;
       }
+      checkValidRange(cmd) {
+          const ranges = cmd.ranges.map((range) => this.getters.getRangeFromRangeData(range));
+          const stringRanges = ranges.map((range) => this.getters.getRangeString(range, cmd.sheetId));
+          if (stringRanges.some((xc) => !this.getters.isRangeValid(xc))) {
+              return "InvalidRange" /* CommandResult.InvalidRange */;
+          }
+          return "Success" /* CommandResult.Success */;
+      }
   }
 
   class FigurePlugin extends CorePlugin {
@@ -54751,6 +55057,7 @@ stores.inject(MyMetaStore, storeInstance);
                   formats: {},
                   borders: {},
                   conditionalFormats: [],
+                  dataValidationRules: [],
                   figures: [],
                   tables: [],
                   areGridLinesVisible: sheet.areGridLinesVisible === undefined ? true : sheet.areGridLinesVisible,
@@ -58120,6 +58427,9 @@ stores.inject(MyMetaStore, storeInstance);
               }
               for (let i = 0; i < positions.length; ++i) {
                   const position = positions[i];
+                  if (this.nextPositionsToUpdate.has(position)) {
+                      continue;
+                  }
                   const evaluatedCell = this.computeCell(position);
                   if (evaluatedCell !== EMPTY_CELL) {
                       this.evaluatedCells.set(position, evaluatedCell);
@@ -58127,6 +58437,9 @@ stores.inject(MyMetaStore, storeInstance);
               }
               onIterationEndEvaluationRegistry.getAll().forEach((callback) => callback(this.getters));
           }
+          if (currentIteration >= MAX_ITERATION) {
+              console.warn("Maximum iteration reached while evaluating cells");
+          }
       }
       computeCell(position) {
           const evaluation = this.evaluatedCells.get(position);
@@ -58161,7 +58474,6 @@ stores.inject(MyMetaStore, storeInstance);
           }
           finally {
               this.cellsBeingComputed.delete(cellId);
-              this.nextPositionsToUpdate.delete(position);
           }
       }
       computeAndSave(position) {
@@ -58197,6 +58509,7 @@ stores.inject(MyMetaStore, storeInstance);
       invalidatePositionsDependingOnSpread(sheetId, resultZone) {
           // the result matrix is split in 2 zones to exclude the array formula position
           const invalidatedPositions = this.formulaDependencies().getCellsDependingOn(excludeTopLeft(resultZone).map((zone) => ({ sheetId, zone })));
+          invalidatedPositions.delete({ sheetId, col: resultZone.left, row: resultZone.top });
           this.nextPositionsToUpdate.addMany(invalidatedPositions);
       }
       assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
@@ -59320,25 +59633,11 @@ stores.inject(MyMetaStore, storeInstance);
           }
           switch (cmd.type) {
               case "ADD_DATA_VALIDATION_RULE":
-                  const ranges = cmd.ranges.map((range) => this.getters.getRangeFromRangeData(range));
-                  if (cmd.rule.criterion.type === "isBoolean") {
-                      this.setContentToBooleanCells({ ...cmd.rule, ranges });
-                  }
-                  delete this.validationResults[cmd.sheetId];
-                  break;
               case "REMOVE_DATA_VALIDATION_RULE":
                   delete this.validationResults[cmd.sheetId];
                   break;
           }
       }
-      setContentToBooleanCells(rule) {
-          for (const position of getCellPositionsInRanges(rule.ranges)) {
-              const evaluatedCell = this.getters.getEvaluatedCell(position);
-              if (evaluatedCell.type !== CellValueType.boolean) {
-                  this.dispatch("UPDATE_CELL", { ...position, content: "FALSE" });
-              }
-          }
-      }
       isDataValidationInvalid(cellPosition) {
           return !this.getValidationResultForCell(cellPosition).isValid;
       }
@@ -59354,9 +59653,10 @@ stores.inject(MyMetaStore, storeInstance);
       getDataValidationInvalidCriterionValueMessage(criterionType, value) {
           const evaluator = dataValidationEvaluatorRegistry.get(criterionType);
           if (value.startsWith("=")) {
-              return evaluator.allowedValues === "onlyLiterals"
-                  ? _t("The value must not be a formula")
-                  : undefined;
+              if (evaluator.allowedValues === "onlyLiterals") {
+                  return _t("The value must not be a formula");
+              }
+              return this.isValidFormula(value) ? undefined : DVTerms.CriterionError.validFormula;
           }
           else if (evaluator.allowedValues === "onlyFormulas") {
               return _t("The value must be a formula");
@@ -59382,6 +59682,9 @@ stores.inject(MyMetaStore, storeInstance);
           const error = this.getRuleErrorForCellValue(cellValue, cellPosition, rule);
           return error ? { error, rule, isValid: false } : VALID_RESULT;
       }
+      isValidFormula(value) {
+          return !compile(value).isBadExpression;
+      }
       getValidationResultForCell(cellPosition) {
           const { col, row, sheetId } = cellPosition;
           if (!this.validationResults[sheetId]) {
@@ -61817,7 +62120,7 @@ stores.inject(MyMetaStore, storeInstance);
        * Notify the server that the user client left the collaborative session
        */
       async leave(data) {
-          if (Object.keys(this.clients).length === 1 && this.processedRevisions.size) {
+          if (data && Object.keys(this.clients).length === 1 && this.processedRevisions.size) {
               await this.snapshot(data());
           }
           delete this.clients[this.clientId];
@@ -63369,6 +63672,42 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class DataValidationInsertionPlugin extends UIPlugin {
+      handle(cmd) {
+          switch (cmd.type) {
+              case "ADD_DATA_VALIDATION_RULE":
+                  if (cmd.rule.criterion.type === "isBoolean") {
+                      const ranges = cmd.ranges.map((range) => this.getters.getRangeFromRangeData(range));
+                      for (const position of getCellPositionsInRanges(ranges)) {
+                          const cell = this.getters.getCell(position);
+                          const evaluatedCell = this.getters.getEvaluatedCell(position);
+                          if (!cell?.content) {
+                              this.dispatch("UPDATE_CELL", { ...position, content: "FALSE" });
+                              // In this case, a cell has been updated in the core plugin but
+                              // not yet evaluated. This can occur after a paste operation.
+                          }
+                          else if (cell?.content && evaluatedCell.type === CellValueType.empty) {
+                              let value;
+                              if (cell.content.startsWith("=")) {
+                                  const result = this.getters.evaluateFormula(position.sheetId, cell.content);
+                                  value = (isMatrix(result) ? result[0][0] : result)?.toString();
+                              }
+                              else {
+                                  value = cell.content;
+                              }
+                              if (!value || !isBoolean(value)) {
+                                  this.dispatch("UPDATE_CELL", { ...position, content: "FALSE" });
+                              }
+                          }
+                          else if (evaluatedCell.type !== CellValueType.boolean) {
+                              this.dispatch("UPDATE_CELL", { ...position, content: "FALSE" });
+                          }
+                      }
+                  }
+          }
+      }
+  }
+
   const genericRepeatsTransforms = [
       repeatSheetDependantCommand,
       repeatTargetDependantCommand,
@@ -64022,7 +64361,7 @@ stores.inject(MyMetaStore, storeInstance);
                   const zones = this.getters.getSelectedZones();
                   return this.isCutAllowedOn(zones);
               case "PASTE_FROM_OS_CLIPBOARD": {
-                  const copiedData = this.convertOSClipboardData(cmd.clipboardContent[ClipboardMIMEType.PlainText] ?? "");
+                  const copiedData = this.convertTextToClipboardData(cmd.clipboardContent.text ?? "");
                   const pasteOption = cmd.pasteOption;
                   return this.isPasteAllowed(cmd.target, copiedData, { pasteOption, isCutOperation: false });
               }
@@ -64075,12 +64414,9 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
               case "PASTE_FROM_OS_CLIPBOARD": {
                   this._isCutOperation = false;
-                  if (cmd.clipboardContent[ClipboardMIMEType.OSpreadsheet]) {
-                      this.copiedData = JSON.parse(cmd.clipboardContent[ClipboardMIMEType.OSpreadsheet]);
-                  }
-                  else {
-                      this.copiedData = this.convertOSClipboardData(cmd.clipboardContent[ClipboardMIMEType.PlainText] ?? "");
-                  }
+                  this.copiedData =
+                      cmd.clipboardContent.data ||
+                          this.convertTextToClipboardData(cmd.clipboardContent.text ?? "");
                   const pasteOption = cmd.pasteOption;
                   this.paste(cmd.target, this.copiedData, {
                       pasteOption,
@@ -64211,11 +64547,11 @@ stores.inject(MyMetaStore, storeInstance);
                   }
           }
       }
-      convertOSClipboardData(clipboardData) {
+      convertTextToClipboardData(clipboardData) {
           const handlers = this.selectClipboardHandlers({ figureId: true }).concat(this.selectClipboardHandlers({}));
           let copiedData = {};
           for (const { handlerName, handler } of handlers) {
-              const data = handler.convertOSClipboardData(clipboardData);
+              const data = handler.convertTextToClipboardData(clipboardData);
               copiedData[handlerName] = data;
               const minimalKeys = ["sheetId", "cells", "zones", "figureId"];
               for (const key of minimalKeys) {
@@ -64384,21 +64720,20 @@ stores.inject(MyMetaStore, storeInstance);
           return {
               [ClipboardMIMEType.PlainText]: this.getPlainTextContent(),
               [ClipboardMIMEType.Html]: this.getHTMLContent(),
-              [ClipboardMIMEType.OSpreadsheet]: this.getSerializedGridData(),
           };
       }
-      getSerializedGridData() {
+      getSheetData() {
           const data = {
               version: CURRENT_VERSION,
               clipboardId: this.clipboardId,
           };
           if (this.copiedData && "figureId" in this.copiedData) {
-              return JSON.stringify(data);
+              return data;
           }
-          return JSON.stringify({
+          return {
               ...data,
               ...this.copiedData,
-          });
+          };
       }
       getPlainTextContent() {
           if (!this.copiedData?.cells) {
@@ -64415,31 +64750,36 @@ stores.inject(MyMetaStore, storeInstance);
               .join("\n") || "\t");
       }
       getHTMLContent() {
-          if (!this.copiedData?.cells) {
-              return `<div data-clipboard-id="${this.clipboardId}">\t</div>`;
+          let innerHTML = "";
+          const cells = this.copiedData?.cells;
+          if (!cells) {
+              innerHTML = "\t";
           }
-          const cells = this.copiedData.cells;
-          if (cells.length === 1 && cells[0].length === 1) {
-              return `<div data-clipboard-id="${this.clipboardId}">${this.getters.getCellText(cells[0][0].position)}</div>`;
+          else if (cells.length === 1 && cells[0].length === 1) {
+              innerHTML = `${this.getters.getCellText(cells[0][0].position)}`;
           }
-          if (!cells[0][0]) {
+          else if (!cells[0][0]) {
               return "";
           }
-          let htmlTable = `<div data-clipboard-id="${this.clipboardId}"><table border="1" style="border-collapse:collapse">`;
-          for (const row of cells) {
-              htmlTable += "<tr>";
-              for (const cell of row) {
-                  if (!cell) {
-                      continue;
+          else {
+              let htmlTable = `<table border="1" style="border-collapse:collapse">`;
+              for (const row of cells) {
+                  htmlTable += "<tr>";
+                  for (const cell of row) {
+                      if (!cell) {
+                          continue;
+                      }
+                      const cssStyle = cssPropertiesToCss(cellStyleToCss(this.getters.getCellComputedStyle(cell.position)));
+                      const cellText = this.getters.getCellText(cell.position);
+                      htmlTable += `<td style="${cssStyle}">` + xmlEscape(cellText) + "</td>";
                   }
-                  const cssStyle = cssPropertiesToCss(cellStyleToCss(this.getters.getCellComputedStyle(cell.position)));
-                  const cellText = this.getters.getCellText(cell.position);
-                  htmlTable += `<td style="${cssStyle}">` + xmlEscape(cellText) + "</td>";
+                  htmlTable += "</tr>";
               }
-              htmlTable += "</tr>";
+              htmlTable += "</table>";
+              innerHTML = htmlTable;
           }
-          htmlTable += "</table></div>";
-          return htmlTable;
+          const serializedData = JSON.stringify(this.getSheetData());
+          return `<div data-osheet-clipboard='${xmlEscape(serializedData)}'>${innerHTML}</div>`;
       }
       isCutOperation() {
           return this._isCutOperation ?? false;
@@ -66419,7 +66759,8 @@ stores.inject(MyMetaStore, storeInstance);
       .add("history", HistoryPlugin)
       .add("data_cleanup", DataCleanupPlugin)
       .add("table_autofill", TableAutofillPlugin)
-      .add("table_ui_resize", TableResizeUI);
+      .add("table_ui_resize", TableResizeUI)
+      .add("datavalidation_insert", DataValidationInsertionPlugin);
   // Plugins which have a state, but which should not be shared in collaborative
   const statefulUIPluginRegistry = new Registry()
       .add("selection", GridSelectionPlugin)
@@ -67645,7 +67986,7 @@ stores.inject(MyMetaStore, storeInstance);
 
   .o-header-group-main-pane {
     &.o-group-rows {
-      margin-top: -2px; // Counteract o-header-group-frozen-pane-border offset
+      margin-top: -2px; /* Counteract o-header-group-frozen-pane-border offset */
     }
     &.o-group-columns {
       margin-left: -2px;
@@ -68678,10 +69019,6 @@ stores.inject(MyMetaStore, storeInstance);
               [ClipboardMIMEType.PlainText]: this.getBlob(content, ClipboardMIMEType.PlainText),
               [ClipboardMIMEType.Html]: this.getBlob(content, ClipboardMIMEType.Html),
           };
-          const spreadsheetData = content[ClipboardMIMEType.OSpreadsheet];
-          if (spreadsheetData) {
-              clipboardItemData[ClipboardMIMEType.OSpreadsheet] = this.getBlob(content, ClipboardMIMEType.OSpreadsheet);
-          }
           return [new ClipboardItem(clipboardItemData)];
       }
       getBlob(clipboardContent, type) {
@@ -68723,7 +69060,7 @@ stores.inject(MyMetaStore, storeInstance);
     *:before,
     *:after {
       box-sizing: content-box;
-      /** rtl not supported ATM */
+      /* rtl not supported ATM */
       direction: ltr;
     }
     .o-separator {
@@ -71628,6 +71965,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],
@@ -72412,6 +72867,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}
@@ -72735,7 +73191,8 @@ stores.inject(MyMetaStore, storeInstance);
           this.session.join(this.config.client);
       }
       async leaveSession() {
-          await this.session.leave(lazy(() => this.exportData()));
+          const snapshot = this.getters.isReadonly() ? undefined : lazy(() => this.exportData());
+          await this.session.leave(snapshot);
       }
       setupUiPlugin(Plugin) {
           const plugin = new Plugin(this.uiPluginConfig);
@@ -73337,9 +73794,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.1.0-alpha.4";
-  __info__.date = "2024-11-13T15:06:47.769Z";
-  __info__.hash = "e1ad985";
+  __info__.version = "18.1.0-alpha.5";
+  __info__.date = "2024-11-22T14:22:50.899Z";
+  __info__.hash = "e13bd67";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);