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

package/dist/o-spreadsheet.esm.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
  */
 
 import { useEnv, useSubEnv, onWillUnmount, useComponent, status, Component, useRef, onMounted, useEffect, useState, onPatched, onWillPatch, onWillUpdateProps, useExternalListener, onWillStart, xml, useChildSubEnv, markRaw, toRaw } from '@odoo/owl';
@@ -128,7 +128,6 @@ const SELECTION_BORDER_COLOR = "#3266ca";
 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";
@@ -3234,7 +3233,6 @@ var ClipboardMIMEType;
 (function (ClipboardMIMEType) {
     ClipboardMIMEType["PlainText"] = "text/plain";
     ClipboardMIMEType["Html"] = "text/html";
-    ClipboardMIMEType["OSpreadsheet"] = "web application/o-spreadsheet";
 })(ClipboardMIMEType || (ClipboardMIMEType = {}));
 
 function isSheetDependent(cmd) {
@@ -4344,7 +4342,9 @@ function linearSearch(data, target, mode, numberOfValues, getValueInData, revers
             return reverseSearch ? numberOfValues - i - 1 : i;
         }
     }
-    return reverseSearch ? numberOfValues - closestMatchIndex - 1 : closestMatchIndex;
+    return reverseSearch && closestMatchIndex !== -1
+        ? numberOfValues - closestMatchIndex - 1
+        : closestMatchIndex;
 }
 /**
  * Normalize a value.
@@ -4398,47 +4398,83 @@ function isDataNonEmpty(data) {
     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) {
@@ -5500,6 +5536,193 @@ function isTextFormat(format) {
     }
 }
 
+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;
@@ -6147,6 +6370,22 @@ function getPasteZones(target, content) {
     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;
@@ -6168,7 +6407,7 @@ class ClipboardHandler {
     getPasteTarget(sheetId, target, content, options) {
         return { zones: [], sheetId };
     }
-    convertOSClipboardData(data) {
+    convertTextToClipboardData(data) {
         return;
     }
 }
@@ -8011,7 +8250,7 @@ class CellClipboardHandler extends AbstractCellClipboardHandler {
             this.dispatch("CLEAR_CELL", target);
         }
     }
-    convertOSClipboardData(text) {
+    convertTextToClipboardData(text) {
         const locale = this.getters.getLocale();
         const copiedData = {
             cells: [],
@@ -8119,6 +8358,7 @@ class ChartClipboardHandler extends AbstractFigureClipboardHandler {
 
 class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
     uuidGenerator = new UuidGenerator();
+    queuedChanges = {};
     copy(data) {
         if (!data.zones.length) {
             return;
@@ -8140,6 +8380,7 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
         return { cfRules };
     }
     paste(target, clippedContent, options) {
+        this.queuedChanges = {};
         if (options.pasteOption === "asValue") {
             return;
         }
@@ -8151,6 +8392,7 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
         else {
             this.pasteFromCut(sheetId, zones, clippedContent);
         }
+        this.executeQueuedChanges();
     }
     pasteFromCut(sheetId, target, content) {
         const selection = target[0];
@@ -8190,34 +8432,56 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
      * 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;
@@ -8234,6 +8498,7 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
         return { dvRules };
     }
     paste(target, clippedContent, options) {
+        this.queuedChanges = {};
         if (options.pasteOption) {
             return;
         }
@@ -8245,6 +8510,7 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
         else {
             this.pasteFromCut(sheetId, zones, clippedContent);
         }
+        this.executeQueuedChanges();
     }
     pasteFromCut(sheetId, target, content) {
         const selection = target[0];
@@ -8291,29 +8557,55 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
         }
     }
     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,
-        });
     }
 }
 
@@ -10284,6 +10576,10 @@ function makeArg(str, description) {
         description,
         type: types,
     };
+    const acceptErrors = types.includes("ANY") || types.includes("RANGE");
+    if (acceptErrors) {
+        result.acceptErrors = true;
+    }
     if (isOptional) {
         result.optional = true;
     }
@@ -12346,8 +12642,8 @@ const AVERAGEIFS = {
 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);
@@ -12736,6 +13032,7 @@ const PEARSON = {
     },
     isExported: true,
 };
+// CORREL
 // In GSheet, CORREL is just an alias to PEARSON
 const CORREL = PEARSON;
 // -----------------------------------------------------------------------------
@@ -13346,7 +13643,7 @@ function getMatchingCells(database, field, criteria, locale) {
 }
 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.")),
 ];
 // -----------------------------------------------------------------------------
@@ -17728,7 +18025,7 @@ const IFS = {
     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) {
@@ -17967,7 +18264,7 @@ const COLUMNS = {
 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.")),
@@ -17975,9 +18272,6 @@ const HLOOKUP = {
     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
@@ -18074,7 +18368,7 @@ const INDIRECT = {
 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.")),
     ],
@@ -18114,7 +18408,7 @@ const DEFAULT_SEARCH_TYPE = 1;
 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.")),
     ],
@@ -18189,7 +18483,7 @@ const ROWS = {
 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.")),
@@ -18197,9 +18491,6 @@ const VLOOKUP = {
     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
@@ -18225,7 +18516,7 @@ const MATCH_MODE = {
 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.")),
@@ -18250,9 +18541,6 @@ const XLOOKUP = {
         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;
@@ -18277,13 +18565,14 @@ const XLOOKUP = {
 //--------------------------------------------------------------------------
 // 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);
@@ -18310,12 +18599,13 @@ const PIVOT_VALUE = {
         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);
@@ -18562,8 +18852,8 @@ const getNeutral = { number: 0, string: "", boolean: false };
 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)) {
@@ -18614,8 +18904,8 @@ function applyRelationalOperator(value1, value2, cb) {
 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) => {
@@ -18629,8 +18919,8 @@ const GT = {
 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) => {
@@ -18644,8 +18934,8 @@ const GTE = {
 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);
@@ -18661,8 +18951,8 @@ const LT = {
 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);
@@ -18710,8 +19000,8 @@ const MULTIPLY = {
 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);
@@ -19629,6 +19919,16 @@ function createComputeFunction(descr, functionName) {
         });
     }
     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);
         }
@@ -19637,6 +19937,9 @@ function createComputeFunction(descr, functionName) {
         }
     }
     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) {
@@ -20746,6 +21049,7 @@ function compileTokensOrThrow(tokens) {
             }
             if (ast.debug) {
                 code.append("debugger;");
+                code.append(`ctx["debug"] = true;`);
             }
             switch (ast.type) {
                 case "BOOLEAN":
@@ -21344,217 +21648,6 @@ autoCompleteProviders.add("sheet_names", {
     },
 });
 
-/**
- * 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.
@@ -22919,6 +23012,10 @@ var WarningTypes;
     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();
@@ -23297,6 +23394,25 @@ const IMAGE_EXTENSION_TO_MIMETYPE_MAPPING = {
     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
@@ -24078,6 +24194,20 @@ function getRowPosition(rowIndex, sheetData) {
     }
     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;
@@ -24187,6 +24317,112 @@ function getPositionFromAnchor(anchor, sheetData) {
     };
 }
 
+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)
  *
@@ -24307,6 +24543,7 @@ function convertSheets(data, warningManager) {
             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
@@ -25586,6 +25823,41 @@ class XlsxCfExtractor extends XlsxBaseExtractor {
     }
 }
 
+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) => {
@@ -25953,6 +26225,7 @@ class XlsxSheetExtractor extends XlsxBaseExtractor {
                 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),
@@ -26024,6 +26297,9 @@ class XlsxSheetExtractor extends XlsxBaseExtractor {
     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();
@@ -27331,6 +27607,7 @@ function createEmptySheet(sheetId, name) {
         rows: {},
         merges: [],
         conditionalFormats: [],
+        dataValidationRules: [],
         figures: [],
         tables: [],
         isVisible: true,
@@ -27405,17 +27682,15 @@ function interactivePasteFromOS(env, target, clipboardContent, pasteOption) {
         });
     }
     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,
         });
@@ -27540,6 +27815,13 @@ const DVTerms = {
         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 = {
@@ -27750,7 +28032,7 @@ function getBarChartData(definition, dataSets, labelRange, getters) {
         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));
     }
@@ -27805,7 +28087,7 @@ function getLineChartData(definition, dataSets, labelRange, getters) {
         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));
     }
@@ -27822,7 +28104,7 @@ function getLineChartData(definition, dataSets, labelRange, getters) {
         if (definition.cumulative) {
             let accumulator = 0;
             data = data.map((value) => {
-                if (!isNaN(value)) {
+                if (!isNaN(parseFloat(value))) {
                     accumulator += parseFloat(value);
                     return accumulator;
                 }
@@ -27855,11 +28137,11 @@ function getPieChartData(definition, dataSets, labelRange, getters) {
         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,
@@ -27877,7 +28159,7 @@ function getRadarChartData(definition, dataSets, labelRange, getters) {
         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));
     }
@@ -28056,26 +28338,16 @@ function isLuxonTimeAdapterInstalled() {
     }
     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)) {
@@ -28108,18 +28380,23 @@ function getData(getters, ds) {
     }
     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),
         })),
     };
 }
@@ -28262,8 +28539,8 @@ function getBarChartDatasets(definition, args) {
         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",
@@ -32935,13 +33212,11 @@ async function paste$1(env, pasteOption) {
     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);
@@ -36161,7 +36436,7 @@ css /* scss */ `
       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);
@@ -36766,7 +37041,7 @@ const CONTAINER_WIDTH = CONTENT_WIDTH + 2 * PICKER_PADDING;
 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;
@@ -36909,7 +37184,7 @@ css /* scss */ `
           margin-right: 2px;
         }
         .o-wrong-color {
-          /** FIXME bootstrap class instead? */
+          /* FIXME bootstrap class instead? */
           outline-color: red;
           border-color: red;
           &:focus {
@@ -38953,10 +39228,10 @@ css /* scss */ `
     }
 
     .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 {
@@ -38973,7 +39248,7 @@ css /* scss */ `
       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;
@@ -40209,7 +40484,7 @@ css /* scss */ `
         .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;
@@ -41028,7 +41303,7 @@ dataValidationEvaluatorRegistry.add("dateIs", {
     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]);
     },
 });
@@ -41053,7 +41328,7 @@ dataValidationEvaluatorRegistry.add("dateIsBefore", {
     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]);
     },
 });
@@ -41078,7 +41353,7 @@ dataValidationEvaluatorRegistry.add("dateIsOnOrBefore", {
     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]);
     },
 });
@@ -41103,7 +41378,7 @@ dataValidationEvaluatorRegistry.add("dateIsAfter", {
     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]);
     },
 });
@@ -41128,7 +41403,7 @@ dataValidationEvaluatorRegistry.add("dateIsOnOrAfter", {
     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]);
     },
 });
@@ -41154,7 +41429,7 @@ dataValidationEvaluatorRegistry.add("dateIsBetween", {
     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]);
     },
 });
@@ -41180,7 +41455,7 @@ dataValidationEvaluatorRegistry.add("dateIsNotBetween", {
     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]);
     },
 });
@@ -41463,19 +41738,6 @@ function checkValueIsNumber(value) {
     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 Component {
@@ -41557,6 +41819,7 @@ class DataValidationInput extends Component {
         focused: false,
         onBlur: () => { },
     };
+    static components = { StandaloneComposer: StandaloneComposer };
     inputRef = useRef("input");
     setup() {
         useEffect(() => {
@@ -41568,10 +41831,6 @@ class DataValidationInput extends Component {
     state = 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") {
@@ -41582,6 +41841,27 @@ class DataValidationInput extends Component {
         }
         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;
@@ -41917,13 +42197,13 @@ function getDataValidationCriterionMenuItems(callback) {
 
 class DataValidationEditor extends 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 = useState({ rule: this.defaultDataValidationRule });
+    state = useState({ rule: this.defaultDataValidationRule, errors: [] });
     setup() {
         if (this.props.rule) {
             const sheetId = this.env.model.getters.getActiveSheetId();
@@ -41948,15 +42228,15 @@ class DataValidationEditor extends Component {
         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 };
@@ -41997,6 +42277,9 @@ class DataValidationEditor extends Component {
     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 */ `
@@ -42008,7 +42291,7 @@ css /* scss */ `
       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 {
@@ -45026,6 +45309,9 @@ class PivotSidePanel extends Component {
         PivotLayoutConfigurator,
         Section,
     };
+    setup() {
+        useHighlights(this);
+    }
     get sidePanelEditor() {
         const pivot = this.env.model.getters.getPivotCoreDefinition(this.props.pivotId);
         if (!pivot) {
@@ -45033,6 +45319,9 @@ class PivotSidePanel extends Component {
         }
         return pivotSidePanelRegistry.get(pivot.type).editor;
     }
+    get highlights() {
+        return getPivotHighlights(this.env.model.getters, this.props.pivotId);
+    }
 }
 
 css /* scss */ `
@@ -45702,7 +45991,7 @@ class TableStylePreview extends Component {
 
 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;
@@ -47254,7 +47543,7 @@ css /* scss */ `
     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;
   }
 `;
@@ -47601,7 +47890,7 @@ css /*SCSS*/ `
     }
   }
   .o-figure-container {
-    -webkit-user-select: none; // safari
+    -webkit-user-select: none; /* safari */
     user-select: none;
   }
 `;
@@ -50674,25 +50963,20 @@ class Grid extends Component {
         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) {
@@ -52512,8 +52796,9 @@ class ConditionalFormatPlugin extends CorePlugin {
         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
@@ -52824,7 +53109,7 @@ class DataValidationPlugin extends CorePlugin {
     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 */;
@@ -52983,6 +53268,20 @@ class DataValidationPlugin extends CorePlugin {
             }
         }
     }
+    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 */
@@ -53001,21 +53300,28 @@ class DataValidationPlugin extends CorePlugin {
     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 {
@@ -54750,6 +55056,7 @@ class SheetPlugin extends CorePlugin {
                 formats: {},
                 borders: {},
                 conditionalFormats: [],
+                dataValidationRules: [],
                 figures: [],
                 tables: [],
                 areGridLinesVisible: sheet.areGridLinesVisible === undefined ? true : sheet.areGridLinesVisible,
@@ -58119,6 +58426,9 @@ class Evaluator {
             }
             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);
@@ -58126,6 +58436,9 @@ class Evaluator {
             }
             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);
@@ -58160,7 +58473,6 @@ class Evaluator {
         }
         finally {
             this.cellsBeingComputed.delete(cellId);
-            this.nextPositionsToUpdate.delete(position);
         }
     }
     computeAndSave(position) {
@@ -58196,6 +58508,7 @@ class Evaluator {
     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) {
@@ -59319,25 +59632,11 @@ class EvaluationDataValidationPlugin extends UIPlugin {
         }
         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;
     }
@@ -59353,9 +59652,10 @@ class EvaluationDataValidationPlugin extends UIPlugin {
     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");
@@ -59381,6 +59681,9 @@ class EvaluationDataValidationPlugin extends UIPlugin {
         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]) {
@@ -61816,7 +62119,7 @@ class Session extends EventBus {
      * 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];
@@ -63368,6 +63671,42 @@ class CellComputedStylePlugin extends UIPlugin {
     }
 }
 
+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,
@@ -64021,7 +64360,7 @@ class ClipboardPlugin extends UIPlugin {
                 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 });
             }
@@ -64074,12 +64413,9 @@ class ClipboardPlugin extends UIPlugin {
                 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,
@@ -64210,11 +64546,11 @@ class ClipboardPlugin extends UIPlugin {
                 }
         }
     }
-    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) {
@@ -64383,21 +64719,20 @@ class ClipboardPlugin extends UIPlugin {
         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) {
@@ -64414,31 +64749,36 @@ class ClipboardPlugin extends UIPlugin {
             .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;
@@ -66418,7 +66758,8 @@ const featurePluginRegistry = new Registry()
     .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)
@@ -67644,7 +67985,7 @@ css /* scss */ `
 
   .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;
@@ -68677,10 +69018,6 @@ class WebClipboardWrapper {
             [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) {
@@ -68722,7 +69059,7 @@ css /* scss */ `
     *:before,
     *:after {
       box-sizing: content-box;
-      /** rtl not supported ATM */
+      /* rtl not supported ATM */
       direction: ltr;
     }
     .o-separator {
@@ -71627,6 +71964,124 @@ function getExcelThresholdType(type, position) {
     }
 }
 
+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],
@@ -72411,6 +72866,7 @@ function createWorksheets(data, construct) {
         ${addRows(construct, data, sheet)}
         ${addMerges(sheet.merges)}
         ${joinXmlNodes(addConditionalFormatting(construct.dxfs, sheet.conditionalFormats))}
+        ${joinXmlNodes(addDataValidationRules(sheet.dataValidationRules))}
         ${addHyperlinks(construct, data, sheetIndex)}
         ${drawingNode}
         ${tablesNode}
@@ -72734,7 +73190,8 @@ class Model extends EventBus {
         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);
@@ -73292,6 +73749,6 @@ const chartHelpers = { ...CHART_HELPERS, ...CHART_RUNTIME_HELPERS };
 export { AbstractCellClipboardHandler, AbstractChart, AbstractFigureClipboardHandler, CellErrorType, CommandResult, CorePlugin, DispatchResult, EvaluationError, Model, PivotRuntimeDefinition, Registry, Revision, SPREADSHEET_DIMENSIONS, Spreadsheet, SpreadsheetPivotTable, UIPlugin, __info__, addFunction, addRenderingLayer, astToFormula, chartHelpers, compile, compileTokens, components, constants, convertAstNodes, coreTypes, findCellInNewZone, functionCache, helpers, hooks, invalidateCFEvaluationCommands, invalidateDependenciesCommands, invalidateEvaluationCommands, iterateAstNodes, links, load, parse, parseTokens, readonlyAllowedCommands, registries, setDefaultSheetViewSize, setTranslationMethod, stores, tokenColors, 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";