@odoo/o-spreadsheet 18.4.0-alpha.1 → 18.4.0-alpha.2

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.4.0-alpha.1
- * @date 2025-05-02T12:34:49.374Z
- * @hash 50d42e1
+ * @version 18.4.0-alpha.2
+ * @date 2025-05-12T05:28:06.109Z
+ * @hash a11158e
  */
 
 import { useEnv, useSubEnv, onWillUnmount, useComponent, status, Component, useRef, onMounted, useEffect, App, blockDom, useState, onPatched, useExternalListener, onWillUpdateProps, onWillPatch, xml, onWillStart, useChildSubEnv, markRaw, toRaw } from '@odoo/owl';
@@ -63,12 +63,25 @@ function createAction(item) {
 class Registry {
     content = {};
     /**
-     * Add an item to the registry
+     * Add an item to the registry, you can only add if there is no item
+     * already present in the registery with the given key
      *
      * Note that this also returns the registry, so another add method call can
      * be chained
      */
     add(key, value) {
+        if (key in this.content) {
+            throw new Error(`${key} is already present in this registry!`);
+        }
+        return this.replace(key, value);
+    }
+    /**
+     * Replace (or add) an item to the registry
+     *
+     * Note that this also returns the registry, so another add method call can
+     * be chained
+     */
+    replace(key, value) {
         this.content[key] = value;
         return this;
     }
@@ -3546,6 +3559,7 @@ const readonlyAllowedCommands = new Set([
     "EVALUATE_CHARTS",
     "SET_FORMULA_VISIBILITY",
     "UPDATE_FILTER",
+    "UPDATE_CHART",
 ]);
 const coreTypes = new Set([
     /** CELLS */
@@ -3901,14 +3915,14 @@ class SplillBlockedError extends EvaluationError {
         super(message, CellErrorType.SpilledBlocked);
     }
 }
+class DivisionByZeroError extends EvaluationError {
+    constructor(message = _t("Division by zero")) {
+        super(message, CellErrorType.DivisionByZero);
+    }
+}
 
 // HELPERS
 const SORT_TYPES_ORDER = ["number", "string", "boolean", "undefined"];
-function assert(condition, message, value) {
-    if (!condition()) {
-        throw new EvaluationError(message, value);
-    }
-}
 function inferFormat(data) {
     if (data === undefined) {
         return undefined;
@@ -3987,12 +4001,6 @@ function toInteger(value, locale) {
 function strictToInteger(value, locale) {
     return Math.trunc(strictToNumber(value, locale));
 }
-function assertNumberGreaterThanOrEqualToOne(value) {
-    assert(() => value >= 1, _t("The function [[FUNCTION_NAME]] expects a number value to be greater than or equal to 1, but receives %s.", value.toString()));
-}
-function assertNotZero(value) {
-    assert(() => value !== 0, _t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."), CellErrorType.DivisionByZero);
-}
 function toString(data) {
     const value = toValue(data);
     switch (typeof value) {
@@ -6531,6 +6539,25 @@ function moveHeaderIndexesOnHeaderDeletion(deletedHeaders, headers) {
     })
         .filter(isDefined);
 }
+function getNextSheetName(existingNames, baseName = "Sheet") {
+    let i = 1;
+    let name = `${baseName}${i}`;
+    while (existingNames.includes(name)) {
+        name = `${baseName}${i}`;
+        i++;
+    }
+    return name;
+}
+function getDuplicateSheetName(nameToDuplicate, existingNames) {
+    let i = 1;
+    const baseName = _t("Copy of %s", nameToDuplicate);
+    let name = baseName.toString();
+    while (existingNames.includes(name)) {
+        name = `${baseName} (${i})`;
+        i++;
+    }
+    return name;
+}
 
 function computeTextLinesHeight(textLineHeight, numberOfLines = 1) {
     return numberOfLines * (textLineHeight + MIN_CELL_TEXT_MARGIN) - MIN_CELL_TEXT_MARGIN;
@@ -7573,6 +7600,37 @@ function countUnique(args) {
     return reduceAny(args, (acc, a) => (isDataNonEmpty(a) ? acc.add(a?.value) : acc), new Set()).size;
 }
 
+function assert(condition, message) {
+    if (!condition) {
+        throw new EvaluationError(message);
+    }
+}
+function assertNotZero(value, message = _t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error.")) {
+    if (value === 0) {
+        throw new DivisionByZeroError(message);
+    }
+}
+function isSingleColOrRow(arg) {
+    return arg.length === 1 || arg[0].length === 1;
+}
+function areSameDimensions(...args) {
+    if (args.every(isMatrix)) {
+        const cols = args[0].length;
+        const rows = args[0][0].length;
+        for (const arg of args) {
+            if (arg.length !== cols || arg[0].length !== rows) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return !args.some((arg) => Array.isArray(arg) && (arg.length !== 1 || arg[0].length !== 1));
+}
+function isSquareMatrix(arg) {
+    return arg.length === arg[0].length;
+}
+const expectNumberGreaterThanOrEqualToOne = (value) => _t("The function [[FUNCTION_NAME]] expects a number value to be greater than or equal to 1, but receives %s.", value);
+
 function getUnitMatrix(n) {
     const matrix = Array(n);
     for (let i = 0; i < n; i++) {
@@ -7701,7 +7759,7 @@ function toScalar(matrix) {
 
 function assertSameNumberOfElements(...args) {
     const dims = args[0].length;
-    args.forEach((arg, i) => assert(() => arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
+    args.forEach((arg, i) => assert(arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
 }
 function average(values, locale) {
     let count = 0;
@@ -7865,7 +7923,7 @@ function fullLinearRegression(X, Y, computeIntercept = true, verbose = false) {
 */
 function polynomialRegression(flatY, flatX, order, intercept) {
     assertSameNumberOfElements(flatX, flatY);
-    assert(() => order >= 1, _t("Function [[FUNCTION_NAME]] A regression of order less than 1 cannot be possible."));
+    assert(order >= 1, _t("Function [[FUNCTION_NAME]] A regression of order less than 1 cannot be possible."));
     const yMatrix = [flatY];
     const xMatrix = flatX.map((x) => range(0, order).map((i) => Math.pow(x, order - i)));
     if (intercept) {
@@ -8273,6 +8331,24 @@ const monthNumberAdapter = {
         return `${normalizedValue}`;
     },
 };
+/**
+ * normalizes month number + year
+ */
+const monthAdapter = {
+    normalizeFunctionValue(value) {
+        const date = toNumber(value, DEFAULT_LOCALE);
+        return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/yyyy" });
+    },
+    toValueAndFormat(normalizedValue) {
+        return {
+            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            format: "mmmm yyyy",
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `"${normalizedValue}"`;
+    },
+};
 /**
  * normalizes quarter number
  */
@@ -8408,6 +8484,7 @@ pivotTimeAdapterRegistry
     .add("day_of_month", nullHandlerDecorator(dayOfMonthAdapter))
     .add("iso_week_number", nullHandlerDecorator(isoWeekNumberAdapter))
     .add("month_number", nullHandlerDecorator(monthNumberAdapter))
+    .add("month", nullHandlerDecorator(monthAdapter))
     .add("quarter_number", nullHandlerDecorator(quarterNumberAdapter))
     .add("day_of_week", nullHandlerDecorator(dayOfWeekAdapter))
     .add("hour_number", nullHandlerDecorator(hourNumberAdapter))
@@ -8588,10 +8665,7 @@ function toNormalizedPivotValue(dimension, groupValue) {
     return normalizer(groupValueString, dimension.granularity);
 }
 function normalizeDateTime(value, granularity) {
-    if (!granularity) {
-        throw new Error("Missing granularity");
-    }
-    return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
+    return pivotTimeAdapter(granularity ?? "month").normalizeFunctionValue(value);
 }
 function toFunctionPivotValue(value, dimension) {
     if (value === null) {
@@ -8603,10 +8677,7 @@ function toFunctionPivotValue(value, dimension) {
     return pivotToFunctionValueRegistry.get(dimension.type)(value, dimension.granularity);
 }
 function toFunctionValueDateTime(value, granularity) {
-    if (!granularity) {
-        throw new Error("Missing granularity");
-    }
-    return pivotTimeAdapter(granularity).toFunctionValue(value);
+    return pivotTimeAdapter(granularity ?? "month").toFunctionValue(value);
 }
 const pivotNormalizationValueRegistry = new Registry();
 pivotNormalizationValueRegistry
@@ -10080,20 +10151,24 @@ function getElementMargins(el) {
 }
 
 const chartJsExtensionRegistry = new Registry();
-/** Return window.Chart, making sure all our extensions are loaded in ChartJS */
-function getChartJSConstructor() {
-    if (window.Chart && !window.Chart?.registry.plugins.get("chartShowValuesPlugin")) {
-        const extensions = chartJsExtensionRegistry.getAll();
-        for (const extension of extensions) {
-            if (typeof extension === "function") {
-                extension(window.Chart);
-            }
-            else {
-                window.Chart.register(extension);
-            }
-        }
+function areChartJSExtensionsLoaded() {
+    return !!window.Chart.registry.plugins.get("chartShowValuesPlugin");
+}
+function registerChartJSExtensions() {
+    if (!window.Chart || areChartJSExtensionsLoaded()) {
+        return;
+    }
+    for (const registryItem of chartJsExtensionRegistry.getAll()) {
+        registryItem.register(window.Chart);
+    }
+}
+function unregisterChartJsExtensions() {
+    if (!window.Chart) {
+        return;
+    }
+    for (const registryItem of chartJsExtensionRegistry.getAll()) {
+        registryItem.unregister(window.Chart);
     }
-    return window.Chart;
 }
 
 function getFunnelChartController() {
@@ -11716,13 +11791,35 @@ css /* scss */ `
     }
   }
 `;
-chartJsExtensionRegistry.add("chartShowValuesPlugin", chartShowValuesPlugin);
-chartJsExtensionRegistry.add("waterfallLinesPlugin", waterfallLinesPlugin);
-chartJsExtensionRegistry.add("funnelController", (Chart) => Chart.register(getFunnelChartController()));
-chartJsExtensionRegistry.add("funnelElement", (Chart) => Chart.register(getFunnelChartElement()));
-chartJsExtensionRegistry.add("funnelTooltipPositioner", (Chart) => (Chart.Tooltip.positioners.funnelTooltipPositioner = funnelTooltipPositioner));
-chartJsExtensionRegistry.add("sunburstLabelsPlugin", sunburstLabelsPlugin);
-chartJsExtensionRegistry.add("sunburstHoverPlugin", sunburstHoverPlugin);
+chartJsExtensionRegistry.add("chartShowValuesPlugin", {
+    register: (Chart) => Chart.register(chartShowValuesPlugin),
+    unregister: (Chart) => Chart.unregister(chartShowValuesPlugin),
+});
+chartJsExtensionRegistry.add("waterfallLinesPlugin", {
+    register: (Chart) => Chart.register(waterfallLinesPlugin),
+    unregister: (Chart) => Chart.unregister(waterfallLinesPlugin),
+});
+chartJsExtensionRegistry.add("funnelController", {
+    register: (Chart) => Chart.register(getFunnelChartController()),
+    unregister: (Chart) => Chart.unregister(getFunnelChartController()),
+});
+chartJsExtensionRegistry.add("funnelElement", {
+    register: (Chart) => Chart.register(getFunnelChartElement()),
+    unregister: (Chart) => Chart.unregister(getFunnelChartElement()),
+});
+chartJsExtensionRegistry.add("funnelTooltipPositioner", {
+    register: (Chart) => (Chart.Tooltip.positioners.funnelTooltipPositioner = funnelTooltipPositioner),
+    // @ts-expect-error
+    unregister: (Chart) => (Chart.Tooltip.positioners.funnelTooltipPositioner = undefined),
+});
+chartJsExtensionRegistry.add("sunburstLabelsPlugin", {
+    register: (Chart) => Chart.register(sunburstLabelsPlugin),
+    unregister: (Chart) => Chart.unregister(sunburstLabelsPlugin),
+});
+chartJsExtensionRegistry.add("sunburstHoverPlugin", {
+    register: (Chart) => Chart.register(sunburstHoverPlugin),
+    unregister: (Chart) => Chart.unregister(sunburstHoverPlugin),
+});
 class ChartJsComponent extends Component {
     static template = "o-spreadsheet-ChartJsComponent";
     static props = {
@@ -11774,8 +11871,7 @@ class ChartJsComponent extends Component {
     createChart(chartData) {
         const canvas = this.canvas.el;
         const ctx = canvas.getContext("2d");
-        const Chart = getChartJSConstructor();
-        this.chart = new Chart(ctx, chartData);
+        this.chart = new window.Chart(ctx, chartData);
     }
     updateChartJs(chartData) {
         if (chartData.data && chartData.data.datasets) {
@@ -12401,6 +12497,230 @@ class ScorecardChart extends Component {
     }
 }
 
+const macRegex = /Mac/i;
+const MODIFIER_KEYS = ["Shift", "Control", "Alt", "Meta"];
+/**
+ * Return true if the event was triggered from
+ * a child element.
+ */
+function isChildEvent(parent, ev) {
+    if (!parent)
+        return false;
+    return !!ev.target && parent.contains(ev.target);
+}
+function gridOverlayPosition() {
+    const spreadsheetElement = document.querySelector(".o-grid-overlay");
+    if (spreadsheetElement) {
+        const { top, left } = spreadsheetElement.getBoundingClientRect();
+        return { top, left };
+    }
+    throw new Error("Can't find spreadsheet position");
+}
+function getBoundingRectAsPOJO(el) {
+    const rect = el.getBoundingClientRect();
+    return {
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+    };
+}
+/**
+ * Iterate over all the children of `el` in the dom tree starting at `el`, depth first.
+ */
+function* iterateChildren(el) {
+    yield el;
+    if (el.hasChildNodes()) {
+        for (const child of el.childNodes) {
+            yield* iterateChildren(child);
+        }
+    }
+}
+function getOpenedMenus() {
+    return Array.from(document.querySelectorAll(".o-spreadsheet .o-menu"));
+}
+function getCurrentSelection(el) {
+    const { startElement, endElement, startSelectionOffset, endSelectionOffset } = getStartAndEndSelection(el);
+    const startSizeBefore = findSelectionIndex(el, startElement, startSelectionOffset);
+    const endSizeBefore = findSelectionIndex(el, endElement, endSelectionOffset);
+    return {
+        start: startSizeBefore,
+        end: endSizeBefore,
+    };
+}
+function getStartAndEndSelection(el) {
+    const selection = document.getSelection();
+    return {
+        startElement: selection.anchorNode || el,
+        startSelectionOffset: selection.anchorOffset,
+        endElement: selection.focusNode || el,
+        endSelectionOffset: selection.focusOffset,
+    };
+}
+/**
+ * Computes the text 'index' inside this.el based on the currently selected node and its offset.
+ * The selected node is either a Text node or an Element node.
+ *
+ * case 1 -Text node:
+ * the offset is the number of characters from the start of the node. We have to add this offset to the
+ * content length of all previous nodes.
+ *
+ * case 2 - Element node:
+ * the offset is the number of child nodes before the selected node. We have to add the content length of
+ * all the nodes prior to the selected node as well as the content of the child node before the offset.
+ *
+ * See the MDN documentation for more details.
+ * https://developer.mozilla.org/en-US/docs/Web/API/Range/startOffset
+ * https://developer.mozilla.org/en-US/docs/Web/API/Range/endOffset
+ *
+ */
+function findSelectionIndex(el, nodeToFind, nodeOffset) {
+    let usedCharacters = 0;
+    const it = iterateChildren(el);
+    let current = it.next();
+    let isFirstParagraph = true;
+    while (!current.done && current.value !== nodeToFind) {
+        if (!current.value.hasChildNodes()) {
+            if (current.value.textContent) {
+                usedCharacters += current.value.textContent.length;
+            }
+        }
+        // One new paragraph = one new line character, except for the first paragraph
+        if (current.value.nodeName === "P" ||
+            (current.value.nodeName === "DIV" && current.value !== el) // On paste, the HTML may contain <div> instead of <p>
+        ) {
+            if (isFirstParagraph) {
+                isFirstParagraph = false;
+            }
+            else {
+                usedCharacters++;
+            }
+        }
+        current = it.next();
+    }
+    if (current.value !== nodeToFind) {
+        /** This situation can happen if the code is called while the selection is not currently on the element.
+         * In this case, we return 0 because we don't know the size of the text before the selection.
+         *
+         * A known occurrence is triggered since the introduction of commit d4663158 (PR #2038).
+         */
+        return 0;
+    }
+    else {
+        if (!current.value.hasChildNodes()) {
+            usedCharacters += nodeOffset;
+        }
+        else {
+            const children = [...current.value.childNodes].slice(0, nodeOffset);
+            usedCharacters += children.reduce((acc, child, index) => {
+                if (child.textContent !== null) {
+                    // need to account for paragraph nodes that implicitly add a new line
+                    // except for the last paragraph
+                    let chars = child.textContent.length;
+                    if (child.nodeName === "P" && index !== children.length - 1) {
+                        chars++;
+                    }
+                    return acc + chars;
+                }
+                else {
+                    return acc;
+                }
+            }, 0);
+        }
+    }
+    if (nodeToFind.nodeName === "P" && !isFirstParagraph && nodeToFind.textContent === "") {
+        usedCharacters++;
+    }
+    return usedCharacters;
+}
+const letterRegex = /^[a-zA-Z]$/;
+/**
+ * Transform a keyboard event into a shortcut string that represent this event. The letters keys will be uppercased.
+ *
+ * @argument ev - The keyboard event to transform
+ * @argument mode - Use either ev.key of ev.code to get the string shortcut
+ *
+ * @example
+ * event : { ctrlKey: true, key: "a" } => "Ctrl+A"
+ * event : { shift: true, alt: true, key: "Home" } => "Alt+Shift+Home"
+ */
+function keyboardEventToShortcutString(ev, mode = "key") {
+    let keyDownString = "";
+    if (!MODIFIER_KEYS.includes(ev.key)) {
+        if (isCtrlKey(ev))
+            keyDownString += "Ctrl+";
+        if (ev.altKey)
+            keyDownString += "Alt+";
+        if (ev.shiftKey)
+            keyDownString += "Shift+";
+    }
+    const key = mode === "key" ? ev.key : ev.code;
+    keyDownString += letterRegex.test(key) ? key.toUpperCase() : key;
+    return keyDownString;
+}
+function isMacOS() {
+    return Boolean(macRegex.test(navigator.userAgent));
+}
+/**
+ * @param {KeyboardEvent | MouseEvent} ev
+ * @returns Returns true if the event was triggered with the "ctrl" modifier pressed.
+ * On Mac, this is the "meta" or "command" key.
+ */
+function isCtrlKey(ev) {
+    return isMacOS() ? ev.metaKey : ev.ctrlKey;
+}
+/**
+ * @param {MouseEvent} ev - The mouse event.
+ * @returns {boolean} Returns true if the event was triggered by a middle-click
+ * or a Ctrl + Click (Cmd + Click on Mac).
+ */
+function isMiddleClickOrCtrlClick(ev) {
+    return ev.button === 1 || (isCtrlKey(ev) && ev.button === 0);
+}
+async function convertImageToPng(imageUrl) {
+    return new Promise((resolve, reject) => {
+        const image = new Image();
+        image.addEventListener("load", () => {
+            const canvas = document.createElement("canvas");
+            canvas.width = image.width;
+            canvas.height = image.height;
+            const ctx = canvas.getContext("2d");
+            ctx?.drawImage(image, 0, 0);
+            canvas.toBlob(resolve, "image/png");
+        });
+        image.addEventListener("error", reject);
+        image.src = imageUrl;
+    });
+}
+function downloadFile(dataUrl, fileName) {
+    const a = document.createElement("a");
+    a.href = dataUrl;
+    a.download = fileName;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+}
+/**
+ * Detects if the current browser is Firefox
+ */
+function isBrowserFirefox() {
+    return /Firefox/i.test(navigator.userAgent);
+}
+
+/**
+ * Convert a JS color hexadecimal to an excel compatible color.
+ *
+ * In Excel the color don't start with a '#' and the format is AARRGGBB instead of RRGGBBAA
+ */
+function toXlsxHexColor(color) {
+    color = toHex(color).replace("#", "");
+    // alpha channel goes first
+    if (color.length === 8) {
+        return color.slice(6) + color.slice(0, 6);
+    }
+    return color;
+}
+
 const GAUGE_PADDING_SIDE = 30;
 const GAUGE_PADDING_TOP = 10;
 const GAUGE_PADDING_BOTTOM = 20;
@@ -12740,38 +13060,6 @@ function getRectangleTangentToCircle(angle, radius, circleCenterX, circleCenterY
     return { bottomLeft, bottomRight, topRight, topLeft };
 }
 
-class GaugeChartComponent extends Component {
-    static template = "o-spreadsheet-GaugeChartComponent";
-    canvas = useRef("chartContainer");
-    get runtime() {
-        return this.env.model.getters.getChartRuntime(this.props.figureUI.id);
-    }
-    setup() {
-        useEffect(() => drawGaugeChart(this.canvas.el, this.runtime), () => {
-            const canvas = this.canvas.el;
-            const rect = canvas.getBoundingClientRect();
-            return [rect.width, rect.height, this.runtime, this.canvas.el, window.devicePixelRatio];
-        });
-    }
-}
-GaugeChartComponent.props = {
-    figureUI: Object,
-};
-
-/**
- * Convert a JS color hexadecimal to an excel compatible color.
- *
- * In Excel the color don't start with a '#' and the format is AARRGGBB instead of RRGGBBAA
- */
-function toXlsxHexColor(color) {
-    color = toHex(color).replace("#", "");
-    // alpha channel goes first
-    if (color.length === 8) {
-        return color.slice(6) + color.slice(0, 6);
-    }
-    return color;
-}
-
 const CHART_COMMON_OPTIONS = {
     // https://www.chartjs.org/docs/latest/general/responsive.html
     responsive: true, // will resize when its container is resized
@@ -12785,6 +13073,7 @@ const CHART_COMMON_OPTIONS = {
         },
     },
     animation: false,
+    events: ["mousemove", "mouseout", "click", "touchstart", "touchmove", "mouseup"],
 };
 function chartToImageUrl(runtime, figure, type) {
     // wrap the canvas in a div with a fixed size because chart.js would
@@ -12834,8 +13123,7 @@ async function chartToImageFile(runtime, figure, type) {
     if ("chartJsConfig" in runtime) {
         const config = deepCopy(runtime.chartJsConfig);
         config.plugins = [backgroundColorChartJSPlugin];
-        const Chart = getChartJSConstructor();
-        const chart = new Chart(canvas, config);
+        const chart = new window.Chart(canvas, config);
         chartBlob = await new Promise((resolve) => canvas.toBlob(resolve, "image/png"));
         chart.destroy();
     }
@@ -13236,10 +13524,11 @@ function getBarChartData(definition, dataSets, labelRange, getters) {
         axisFormats,
         labels,
         locale: getters.getLocale(),
+        topPadding: getTopPaddingForDashboard(definition, getters),
     };
 }
 function getPyramidChartData(definition, dataSets, labelRange, getters) {
-    const barChartData = getBarChartData(definition, dataSets, labelRange, getters);
+    const barChartData = getBarChartData(definition, dataSets.slice(0, 2), labelRange, getters);
     const barDataset = barChartData.dataSetsValues.filter((ds) => !ds.hidden);
     const pyramidDatasetValues = [];
     if (barDataset[0]) {
@@ -13295,6 +13584,7 @@ function getLineChartData(definition, dataSets, labelRange, getters) {
         locale: getters.getLocale(),
         trendDataSetsValues,
         axisType,
+        topPadding: getTopPaddingForDashboard(definition, getters),
     };
 }
 function getPieChartData(definition, dataSets, labelRange, getters) {
@@ -13315,6 +13605,7 @@ function getPieChartData(definition, dataSets, labelRange, getters) {
         axisFormats: { y: dataSetFormat },
         labels,
         locale: getters.getLocale(),
+        topPadding: getTopPaddingForDashboard(definition, getters),
     };
 }
 function getRadarChartData(definition, dataSets, labelRange, getters) {
@@ -13338,7 +13629,8 @@ function getRadarChartData(definition, dataSets, labelRange, getters) {
         locale: getters.getLocale(),
     };
 }
-function getGeoChartData(definition, dataSets, labelRange, getters) {
+function getGeoChartData(definition, fullDataSets, labelRange, getters) {
+    const dataSets = fullDataSets.slice(0, 1);
     const labelValues = getChartLabelValues(getters, dataSets, labelRange);
     let labels = labelValues.formattedValues;
     if (shouldRemoveFirstLabel(labelRange, dataSets[0], definition.dataSetsHaveTitle || false)) {
@@ -13587,11 +13879,10 @@ function canBeLinearChart(definition, dataSets, labelRange, getters) {
 }
 let missingTimeAdapterAlreadyWarned = false;
 function isLuxonTimeAdapterInstalled() {
-    const Chart = getChartJSConstructor();
-    if (!Chart) {
+    if (!window.Chart) {
         return false;
     }
-    const adapter = new Chart._adapters._date({});
+    const adapter = new window.Chart._adapters._date({});
     // @ts-ignore
     const isInstalled = adapter._id === "luxon";
     if (!isInstalled && !missingTimeAdapterAlreadyWarned) {
@@ -13894,13 +14185,18 @@ function makeDatasetsCumulative(datasets, order) {
         return { ...dataset, data };
     });
 }
+function getTopPaddingForDashboard(definition, getters) {
+    const { title, legendPosition } = definition;
+    const hasTitleOrLegendTop = (title && title.text) || legendPosition === "top";
+    return getters.isDashboard() && !hasTitleOrLegendTop ? 30 : 0;
+}
 
-function getChartLayout(definition) {
+function getChartLayout(definition, args) {
     return {
         padding: {
             left: CHART_PADDING$1,
             right: CHART_PADDING$1,
-            top: CHART_PADDING_TOP,
+            top: Math.max(CHART_PADDING_TOP, args.topPadding || 0),
             bottom: CHART_PADDING_BOTTOM,
         },
     };
@@ -14089,6 +14385,9 @@ const INTERACTIVE_LEGEND_CONFIG = {
         target.style.cursor = "default";
     },
     onClick: (event, legendItem, legend) => {
+        if (event.type !== "click") {
+            return;
+        }
         const index = legendItem.datasetIndex;
         if (!legend.legendItems || index === undefined) {
             return;
@@ -14917,6 +15216,7 @@ var CHART_RUNTIME_HELPERS = /*#__PURE__*/Object.freeze({
   getSunburstChartLegend: getSunburstChartLegend,
   getSunburstChartTooltip: getSunburstChartTooltip,
   getSunburstShowValues: getSunburstShowValues,
+  getTopPaddingForDashboard: getTopPaddingForDashboard,
   getTreeMapChartDatasets: getTreeMapChartDatasets,
   getTreeMapChartTooltip: getTreeMapChartTooltip,
   getTrendDatasetForBarChart: getTrendDatasetForBarChart,
@@ -15066,7 +15366,7 @@ function createBarChartRuntime(chart, getters) {
         options: {
             ...CHART_COMMON_OPTIONS,
             indexAxis: chart.horizontal ? "y" : "x",
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getBarChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -15079,6 +15379,24 @@ function createBarChartRuntime(chart, getters) {
     return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
 }
 
+class GaugeChartComponent extends Component {
+    static template = "o-spreadsheet-GaugeChartComponent";
+    canvas = useRef("chartContainer");
+    get runtime() {
+        return this.env.model.getters.getChartRuntime(this.props.figureUI.id);
+    }
+    setup() {
+        useEffect(() => drawGaugeChart(this.canvas.el, this.runtime), () => {
+            const canvas = this.canvas.el;
+            const rect = canvas.getBoundingClientRect();
+            return [rect.width, rect.height, this.runtime, this.canvas.el, window.devicePixelRatio];
+        });
+    }
+}
+GaugeChartComponent.props = {
+    figureUI: Object,
+};
+
 class ComboChart extends AbstractChart {
     dataSets;
     labelRange;
@@ -15218,7 +15536,7 @@ function createComboChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getBarChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -15362,7 +15680,7 @@ function createFunnelChartRuntime(chart, getters) {
         options: {
             ...CHART_COMMON_OPTIONS,
             indexAxis: "y",
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getFunnelChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -15766,7 +16084,7 @@ function createGeoChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getGeoChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -15924,7 +16242,7 @@ function createLineChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getLineChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -15950,6 +16268,7 @@ class PieChart extends AbstractChart {
     dataSetsHaveTitle;
     isDoughnut;
     showValues;
+    pieHolePercentage;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -15960,6 +16279,7 @@ class PieChart extends AbstractChart {
         this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
         this.isDoughnut = definition.isDoughnut;
         this.showValues = definition.showValues;
+        this.pieHolePercentage = definition.pieHolePercentage;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -16011,6 +16331,7 @@ class PieChart extends AbstractChart {
             aggregated: this.aggregated,
             isDoughnut: this.isDoughnut,
             showValues: this.showValues,
+            pieHolePercentage: this.pieHolePercentage,
         };
     }
     duplicateInDuplicatedSheet(newSheetId) {
@@ -16056,7 +16377,10 @@ function createPieChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            cutout: chart.isDoughnut && definition.pieHolePercentage !== undefined
+                ? definition.pieHolePercentage + "%"
+                : undefined,
+            layout: getChartLayout(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
                 legend: getPieChartLegend(definition, chartData),
@@ -16083,7 +16407,7 @@ class PyramidChart extends AbstractChart {
     showValues;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
-        this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle).slice(0, 2);
+        this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
         this.labelRange = createValidRange(getters, sheetId, definition.labelRange);
         this.background = definition.background;
         this.legendPosition = definition.legendPosition;
@@ -16193,7 +16517,7 @@ function createPyramidChartRuntime(chart, getters) {
         options: {
             ...CHART_COMMON_OPTIONS,
             indexAxis: "y",
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getPyramidChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -16342,7 +16666,7 @@ function createRadarChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getRadarChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -16495,7 +16819,7 @@ function createScatterChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getScatterChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -16522,6 +16846,7 @@ class SunburstChart extends AbstractChart {
     showLabels;
     valuesDesign;
     groupColors;
+    pieHolePercentage;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -16533,6 +16858,7 @@ class SunburstChart extends AbstractChart {
         this.showLabels = definition.showLabels;
         this.valuesDesign = definition.valuesDesign;
         this.groupColors = definition.groupColors;
+        this.pieHolePercentage = definition.pieHolePercentage;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -16595,6 +16921,7 @@ class SunburstChart extends AbstractChart {
             showLabels: this.showLabels,
             valuesDesign: this.valuesDesign,
             groupColors: this.groupColors,
+            pieHolePercentage: this.pieHolePercentage,
         };
     }
     duplicateInDuplicatedSheet(newSheetId) {
@@ -16628,9 +16955,9 @@ function createSunburstChartRuntime(chart, getters) {
             datasets: getSunburstChartDatasets(definition, chartData),
         },
         options: {
-            cutout: "25%",
+            cutout: chart.pieHolePercentage === undefined ? "25%" : `${chart.pieHolePercentage}%`,
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
                 legend: getSunburstChartLegend(definition),
@@ -16778,7 +17105,7 @@ function createTreeMapChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
                 legend: { display: false },
@@ -16934,7 +17261,7 @@ function createWaterfallChartRuntime(chart, getters) {
         },
         options: {
             ...CHART_COMMON_OPTIONS,
-            layout: getChartLayout(),
+            layout: getChartLayout(definition, chartData),
             scales: getWaterfallChartScales(definition, chartData),
             plugins: {
                 title: getChartTitle(definition),
@@ -17033,6 +17360,7 @@ chartRegistry.add("pyramid", {
     transformDefinition: PyramidChart.transformDefinition,
     getChartDefinitionFromContextCreation: PyramidChart.getDefinitionFromContextCreation,
     sequence: 80,
+    dataSeriesLimit: 2,
 });
 chartRegistry.add("radar", {
     match: (type) => type === "radar",
@@ -17051,6 +17379,7 @@ chartRegistry.add("geo", {
     transformDefinition: GeoChart.transformDefinition,
     getChartDefinitionFromContextCreation: GeoChart.getDefinitionFromContextCreation,
     sequence: 90,
+    dataSeriesLimit: 1,
 });
 chartRegistry.add("funnel", {
     match: (type) => type === "funnel",
@@ -17060,6 +17389,7 @@ chartRegistry.add("funnel", {
     transformDefinition: FunnelChart.transformDefinition,
     getChartDefinitionFromContextCreation: FunnelChart.getDefinitionFromContextCreation,
     sequence: 100,
+    dataSeriesLimit: 1,
 });
 chartRegistry.add("sunburst", {
     match: (type) => type === "sunburst",
@@ -17286,268 +17616,6 @@ chartSubtypeRegistry
     preview: "o-spreadsheet-ChartPreview.TREE_MAP_CHART",
 });
 
-// -----------------------------------------------------------------------------
-// STYLE
-// -----------------------------------------------------------------------------
-css /* scss */ `
-  .o-chart-container {
-    width: 100%;
-    height: 100%;
-    position: relative;
-  }
-`;
-class ChartFigure extends Component {
-    static template = "o-spreadsheet-ChartFigure";
-    static props = {
-        figureUI: Object,
-        onFigureDeleted: Function,
-    };
-    static components = {};
-    onDoubleClick() {
-        this.env.model.dispatch("SELECT_FIGURE", { figureId: this.props.figureUI.id });
-        this.env.openSidePanel("ChartPanel");
-    }
-    get chartType() {
-        return this.env.model.getters.getChartType(this.props.figureUI.id);
-    }
-    get chartComponent() {
-        const type = this.chartType;
-        const component = chartComponentRegistry.get(type);
-        if (!component) {
-            throw new Error(`Component is not defined for type ${type}`);
-        }
-        return component;
-    }
-}
-
-class ImageFigure extends Component {
-    static template = "o-spreadsheet-ImageFigure";
-    static props = {
-        figureUI: Object,
-        onFigureDeleted: Function,
-    };
-    static components = {};
-    // ---------------------------------------------------------------------------
-    // Getters
-    // ---------------------------------------------------------------------------
-    get figureId() {
-        return this.props.figureUI.id;
-    }
-    get getImagePath() {
-        return this.env.model.getters.getImagePath(this.figureId);
-    }
-}
-
-const macRegex = /Mac/i;
-const MODIFIER_KEYS = ["Shift", "Control", "Alt", "Meta"];
-/**
- * Return true if the event was triggered from
- * a child element.
- */
-function isChildEvent(parent, ev) {
-    if (!parent)
-        return false;
-    return !!ev.target && parent.contains(ev.target);
-}
-function gridOverlayPosition() {
-    const spreadsheetElement = document.querySelector(".o-grid-overlay");
-    if (spreadsheetElement) {
-        const { top, left } = spreadsheetElement.getBoundingClientRect();
-        return { top, left };
-    }
-    throw new Error("Can't find spreadsheet position");
-}
-function getBoundingRectAsPOJO(el) {
-    const rect = el.getBoundingClientRect();
-    return {
-        x: rect.x,
-        y: rect.y,
-        width: rect.width,
-        height: rect.height,
-    };
-}
-/**
- * Iterate over all the children of `el` in the dom tree starting at `el`, depth first.
- */
-function* iterateChildren(el) {
-    yield el;
-    if (el.hasChildNodes()) {
-        for (const child of el.childNodes) {
-            yield* iterateChildren(child);
-        }
-    }
-}
-function getOpenedMenus() {
-    return Array.from(document.querySelectorAll(".o-spreadsheet .o-menu"));
-}
-function getCurrentSelection(el) {
-    const { startElement, endElement, startSelectionOffset, endSelectionOffset } = getStartAndEndSelection(el);
-    const startSizeBefore = findSelectionIndex(el, startElement, startSelectionOffset);
-    const endSizeBefore = findSelectionIndex(el, endElement, endSelectionOffset);
-    return {
-        start: startSizeBefore,
-        end: endSizeBefore,
-    };
-}
-function getStartAndEndSelection(el) {
-    const selection = document.getSelection();
-    return {
-        startElement: selection.anchorNode || el,
-        startSelectionOffset: selection.anchorOffset,
-        endElement: selection.focusNode || el,
-        endSelectionOffset: selection.focusOffset,
-    };
-}
-/**
- * Computes the text 'index' inside this.el based on the currently selected node and its offset.
- * The selected node is either a Text node or an Element node.
- *
- * case 1 -Text node:
- * the offset is the number of characters from the start of the node. We have to add this offset to the
- * content length of all previous nodes.
- *
- * case 2 - Element node:
- * the offset is the number of child nodes before the selected node. We have to add the content length of
- * all the nodes prior to the selected node as well as the content of the child node before the offset.
- *
- * See the MDN documentation for more details.
- * https://developer.mozilla.org/en-US/docs/Web/API/Range/startOffset
- * https://developer.mozilla.org/en-US/docs/Web/API/Range/endOffset
- *
- */
-function findSelectionIndex(el, nodeToFind, nodeOffset) {
-    let usedCharacters = 0;
-    const it = iterateChildren(el);
-    let current = it.next();
-    let isFirstParagraph = true;
-    while (!current.done && current.value !== nodeToFind) {
-        if (!current.value.hasChildNodes()) {
-            if (current.value.textContent) {
-                usedCharacters += current.value.textContent.length;
-            }
-        }
-        // One new paragraph = one new line character, except for the first paragraph
-        if (current.value.nodeName === "P" ||
-            (current.value.nodeName === "DIV" && current.value !== el) // On paste, the HTML may contain <div> instead of <p>
-        ) {
-            if (isFirstParagraph) {
-                isFirstParagraph = false;
-            }
-            else {
-                usedCharacters++;
-            }
-        }
-        current = it.next();
-    }
-    if (current.value !== nodeToFind) {
-        /** This situation can happen if the code is called while the selection is not currently on the element.
-         * In this case, we return 0 because we don't know the size of the text before the selection.
-         *
-         * A known occurrence is triggered since the introduction of commit d4663158 (PR #2038).
-         */
-        return 0;
-    }
-    else {
-        if (!current.value.hasChildNodes()) {
-            usedCharacters += nodeOffset;
-        }
-        else {
-            const children = [...current.value.childNodes].slice(0, nodeOffset);
-            usedCharacters += children.reduce((acc, child, index) => {
-                if (child.textContent !== null) {
-                    // need to account for paragraph nodes that implicitly add a new line
-                    // except for the last paragraph
-                    let chars = child.textContent.length;
-                    if (child.nodeName === "P" && index !== children.length - 1) {
-                        chars++;
-                    }
-                    return acc + chars;
-                }
-                else {
-                    return acc;
-                }
-            }, 0);
-        }
-    }
-    if (nodeToFind.nodeName === "P" && !isFirstParagraph && nodeToFind.textContent === "") {
-        usedCharacters++;
-    }
-    return usedCharacters;
-}
-const letterRegex = /^[a-zA-Z]$/;
-/**
- * Transform a keyboard event into a shortcut string that represent this event. The letters keys will be uppercased.
- *
- * @argument ev - The keyboard event to transform
- * @argument mode - Use either ev.key of ev.code to get the string shortcut
- *
- * @example
- * event : { ctrlKey: true, key: "a" } => "Ctrl+A"
- * event : { shift: true, alt: true, key: "Home" } => "Alt+Shift+Home"
- */
-function keyboardEventToShortcutString(ev, mode = "key") {
-    let keyDownString = "";
-    if (!MODIFIER_KEYS.includes(ev.key)) {
-        if (isCtrlKey(ev))
-            keyDownString += "Ctrl+";
-        if (ev.altKey)
-            keyDownString += "Alt+";
-        if (ev.shiftKey)
-            keyDownString += "Shift+";
-    }
-    const key = mode === "key" ? ev.key : ev.code;
-    keyDownString += letterRegex.test(key) ? key.toUpperCase() : key;
-    return keyDownString;
-}
-function isMacOS() {
-    return Boolean(macRegex.test(navigator.userAgent));
-}
-/**
- * @param {KeyboardEvent | MouseEvent} ev
- * @returns Returns true if the event was triggered with the "ctrl" modifier pressed.
- * On Mac, this is the "meta" or "command" key.
- */
-function isCtrlKey(ev) {
-    return isMacOS() ? ev.metaKey : ev.ctrlKey;
-}
-/**
- * @param {MouseEvent} ev - The mouse event.
- * @returns {boolean} Returns true if the event was triggered by a middle-click
- * or a Ctrl + Click (Cmd + Click on Mac).
- */
-function isMiddleClickOrCtrlClick(ev) {
-    return ev.button === 1 || (isCtrlKey(ev) && ev.button === 0);
-}
-async function convertImageToPng(imageUrl) {
-    return new Promise((resolve, reject) => {
-        const image = new Image();
-        image.addEventListener("load", () => {
-            const canvas = document.createElement("canvas");
-            canvas.width = image.width;
-            canvas.height = image.height;
-            const ctx = canvas.getContext("2d");
-            ctx?.drawImage(image, 0, 0);
-            canvas.toBlob(resolve, "image/png");
-        });
-        image.addEventListener("error", reject);
-        image.src = imageUrl;
-    });
-}
-function downloadFile(dataUrl, fileName) {
-    const a = document.createElement("a");
-    a.href = dataUrl;
-    a.download = fileName;
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-}
-/**
- * Detects if the current browser is Firefox
- */
-function isBrowserFirefox() {
-    return /Firefox/i.test(navigator.userAgent);
-}
-
 /**
  * Create a function used to create a Chart based on the definition
  */
@@ -17980,20 +18048,7 @@ function escapeQueryNameSpaces(query) {
     return query.replaceAll(/([a-zA-Z0-9]+):([a-zA-Z0-9]+)/g, "NAMESPACE" + "$1" + "NAMESPACE" + "$2");
 }
 
-const figureRegistry = new Registry();
-figureRegistry.add("chart", {
-    Component: ChartFigure,
-    SidePanelComponent: "ChartPanel",
-    menuBuilder: getChartMenu,
-});
-figureRegistry.add("image", {
-    Component: ImageFigure,
-    keepRatio: true,
-    minFigSize: 20,
-    borderWidth: 0,
-    menuBuilder: getImageMenuRegistry,
-});
-function getChartMenu(figureId, onFigureDeleted, env) {
+function getChartMenuActions(figureId, onFigureDeleted, env) {
     const menuItemSpecs = [
         {
             id: "edit",
@@ -18024,7 +18079,9 @@ function getChartMenu(figureId, onFigureDeleted, env) {
                     "text/html": innerHTML,
                     "image/png": blob,
                 });
+                env.notifyUser({ sticky: false, type: "success", text: _t("Chart copied to clipboard") });
             },
+            isReadonlyAllowed: true,
         },
         {
             id: "download",
@@ -18039,14 +18096,15 @@ function getChartMenu(figureId, onFigureDeleted, env) {
                 const url = chartToImageUrl(runtime, figure, chartType);
                 downloadFile(url, "chart");
             },
+            isReadonlyAllowed: true,
         },
         getDeleteMenuItem(figureId, onFigureDeleted, env),
     ];
-    return createActions(menuItemSpecs);
+    return createActions(menuItemSpecs).filter((action) => env.model.getters.isReadonly() ? action.isReadonlyAllowed : true);
 }
-function getImageMenuRegistry(figureId, onFigureDeleted, env) {
+function getImageMenuActions(figureId, onFigureDeleted, env) {
     const menuItemSpecs = [
-        getCopyMenuItem(figureId, env),
+        getCopyMenuItem(figureId, env, _t("Image copied to clipboard")),
         getCutMenuItem(figureId, env),
         {
             id: "reset_size",
@@ -18093,7 +18151,7 @@ function getImageMenuRegistry(figureId, onFigureDeleted, env) {
     ];
     return createActions(menuItemSpecs);
 }
-function getCopyMenuItem(figureId, env) {
+function getCopyMenuItem(figureId, env, copiedNotificationMessage) {
     return {
         id: "copy",
         name: _t("Copy"),
@@ -18104,6 +18162,9 @@ function getCopyMenuItem(figureId, env) {
             env.model.dispatch("COPY");
             const osClipboardContent = await env.model.getters.getClipboardTextAndImageContent();
             await env.clipboard.write(osClipboardContent);
+            if (copiedNotificationMessage) {
+                env.notifyUser({ sticky: false, type: "success", text: copiedNotificationMessage });
+            }
         },
         icon: "o-spreadsheet-Icon.CLIPBOARD",
     };
@@ -18772,6 +18833,153 @@ class Menu extends Component {
     }
 }
 
+class ChartDashboardMenu extends Component {
+    static template = "spreadsheet.ChartDashboardMenu";
+    static components = { Menu };
+    static props = { figureUI: Object };
+    originalChartDefinition;
+    menuState = useState({ isOpen: false, anchorRect: null, menuItems: [] });
+    setup() {
+        super.setup();
+        this.originalChartDefinition = this.env.model.getters.getChartDefinition(this.props.figureUI.id);
+        onWillUpdateProps(({ figureUI }) => {
+            if (figureUI.id !== this.props.figureUI.id) {
+                this.originalChartDefinition = this.env.model.getters.getChartDefinition(figureUI.id);
+            }
+        });
+    }
+    getAvailableTypes() {
+        const definition = this.env.model.getters.getChartDefinition(this.props.figureUI.id);
+        if (!["line", "bar", "pie"].includes(definition.type)) {
+            return [];
+        }
+        return ["column", "line", "pie"].map((type) => {
+            const item = chartSubtypeRegistry.get(type);
+            return {
+                ...item,
+                icon: this.getIconClasses(item.chartType),
+            };
+        });
+    }
+    getIconClasses(type) {
+        if (type.includes("bar")) {
+            return "fa fa-bar-chart";
+        }
+        if (type.includes("line")) {
+            return "fa fa-line-chart";
+        }
+        if (type.includes("pie")) {
+            return "fa fa-pie-chart";
+        }
+        return "";
+    }
+    onTypeChange(type) {
+        const figureId = this.props.figureUI.id;
+        const currentDefinition = this.env.model.getters.getChartDefinition(figureId);
+        if (currentDefinition.type === type) {
+            return;
+        }
+        let definition;
+        if (this.originalChartDefinition.type === type) {
+            definition = this.originalChartDefinition;
+        }
+        else {
+            const newChartInfo = chartSubtypeRegistry.get(type);
+            const ChartClass = chartRegistry.get(newChartInfo.chartType);
+            const chartCreationContext = this.env.model.getters.getContextCreationChart(figureId);
+            if (!chartCreationContext)
+                return;
+            definition = {
+                ...ChartClass.getChartDefinitionFromContextCreation(chartCreationContext),
+                ...newChartInfo.subtypeDefinition,
+            };
+        }
+        this.env.model.dispatch("UPDATE_CHART", {
+            definition,
+            figureId,
+            sheetId: this.env.model.getters.getActiveSheetId(),
+        });
+    }
+    get selectedChartType() {
+        return this.env.model.getters.getChartDefinition(this.props.figureUI.id).type;
+    }
+    get backgroundColor() {
+        const color = this.env.model.getters.getChartDefinition(this.props.figureUI.id).background;
+        return "background-color: " + (color || BACKGROUND_CHART_COLOR);
+    }
+    openContextMenu(ev) {
+        this.menuState.isOpen = true;
+        this.menuState.anchorRect = { x: ev.clientX, y: ev.clientY, width: 0, height: 0 };
+        this.menuState.menuItems = getChartMenuActions(this.props.figureUI.id, () => { }, this.env);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// STYLE
+// -----------------------------------------------------------------------------
+css /* scss */ `
+  .o-chart-container {
+    width: 100%;
+    height: 100%;
+    position: relative;
+  }
+`;
+class ChartFigure extends Component {
+    static template = "o-spreadsheet-ChartFigure";
+    static props = {
+        figureUI: Object,
+        onFigureDeleted: Function,
+    };
+    static components = { ChartDashboardMenu };
+    onDoubleClick() {
+        this.env.model.dispatch("SELECT_FIGURE", { figureId: this.props.figureUI.id });
+        this.env.openSidePanel("ChartPanel");
+    }
+    get chartType() {
+        return this.env.model.getters.getChartType(this.props.figureUI.id);
+    }
+    get chartComponent() {
+        const type = this.chartType;
+        const component = chartComponentRegistry.get(type);
+        if (!component) {
+            throw new Error(`Component is not defined for type ${type}`);
+        }
+        return component;
+    }
+}
+
+class ImageFigure extends Component {
+    static template = "o-spreadsheet-ImageFigure";
+    static props = {
+        figureUI: Object,
+        onFigureDeleted: Function,
+    };
+    static components = {};
+    // ---------------------------------------------------------------------------
+    // Getters
+    // ---------------------------------------------------------------------------
+    get figureId() {
+        return this.props.figureUI.id;
+    }
+    get getImagePath() {
+        return this.env.model.getters.getImagePath(this.figureId);
+    }
+}
+
+const figureRegistry = new Registry();
+figureRegistry.add("chart", {
+    Component: ChartFigure,
+    SidePanelComponent: "ChartPanel",
+    menuBuilder: getChartMenuActions,
+});
+figureRegistry.add("image", {
+    Component: ImageFigure,
+    keepRatio: true,
+    minFigSize: 20,
+    borderWidth: 0,
+    menuBuilder: getImageMenuActions,
+});
+
 // -----------------------------------------------------------------------------
 // STYLE
 // -----------------------------------------------------------------------------
@@ -19764,10 +19972,13 @@ const duplicateSheet = {
     name: _t("Duplicate"),
     execute: (env) => {
         const sheetIdFrom = env.model.getters.getActiveSheetId();
+        const sheetNameFrom = env.model.getters.getSheetName(sheetIdFrom);
         const sheetIdTo = env.model.uuidGenerator.smallUuid();
+        const sheetNameTo = env.model.getters.getDuplicateSheetName(sheetNameFrom);
         env.model.dispatch("DUPLICATE_SHEET", {
             sheetId: sheetIdFrom,
             sheetIdTo,
+            sheetNameTo,
         });
         env.model.dispatch("ACTIVATE_SHEET", { sheetIdFrom, sheetIdTo });
     },
@@ -19827,7 +20038,7 @@ class MenuItemRegistry extends Registry {
     /**
      * @override
      */
-    add(key, value) {
+    replace(key, value) {
         if (value.id === undefined) {
             value.id = key;
         }
@@ -19839,7 +20050,13 @@ class MenuItemRegistry extends Registry {
      * @param path Path of items to add this subitem
      * @param value Subitem to add
      */
-    addChild(key, path, value, options = { force: false }) {
+    addChild(key, path, value) {
+        return this._replaceChild(key, path, value, { force: false });
+    }
+    replaceChild(key, path, value) {
+        return this._replaceChild(key, path, value, { force: true });
+    }
+    _replaceChild(key, path, value, options = { force: true }) {
         if (typeof value !== "function" && value.id === undefined) {
             value.id = key;
         }
@@ -24887,6 +25104,7 @@ function repairInitialMessages(data, initialMessages) {
     initialMessages = dropCommands(initialMessages, "SET_DECIMAL");
     initialMessages = fixChartDefinitions(data, initialMessages);
     initialMessages = fixFigureOffset(data, initialMessages);
+    initialMessages = fixTranslatedDuplicateSheetName(data, initialMessages);
     return initialMessages;
 }
 /**
@@ -25019,6 +25237,42 @@ function fixFigureOffset(data, messages) {
     }
     return messages;
 }
+function fixTranslatedDuplicateSheetName(data, initialMessages) {
+    const sheetNames = {};
+    for (const sheet of data.sheets || []) {
+        sheetNames[sheet.id] = sheet.name;
+    }
+    const messages = [];
+    for (const message of initialMessages) {
+        if (message.type === "REMOTE_REVISION") {
+            const commands = [];
+            for (const cmd of message.commands) {
+                switch (cmd.type) {
+                    case "DUPLICATE_SHEET":
+                        cmd.sheetNameTo =
+                            cmd.sheetNameTo ??
+                                getDuplicateSheetName(sheetNames[cmd.sheetId], Object.values(sheetNames));
+                        break;
+                    case "CREATE_SHEET":
+                        sheetNames[cmd.sheetId] = cmd.name || getNextSheetName(Object.values(sheetNames));
+                        break;
+                    case "RENAME_SHEET":
+                        sheetNames[cmd.sheetId] = cmd.newName || getNextSheetName(Object.values(sheetNames));
+                        break;
+                }
+                commands.push(cmd);
+            }
+            messages.push({
+                ...message,
+                commands,
+            });
+        }
+        else {
+            messages.push(message);
+        }
+    }
+    return initialMessages;
+}
 // -----------------------------------------------------------------------------
 // Helpers
 // -----------------------------------------------------------------------------
@@ -26872,29 +27126,6 @@ function validateArguments(descr) {
     }
 }
 
-function assertSingleColOrRow(errorStr, arg) {
-    assert(() => arg.length === 1 || arg[0].length === 1, errorStr);
-}
-function assertSameDimensions(errorStr, ...args) {
-    if (args.every(isMatrix)) {
-        const cols = args[0].length;
-        const rows = args[0][0].length;
-        for (const arg of args) {
-            assert(() => arg.length === cols && arg[0].length === rows, errorStr);
-        }
-        return;
-    }
-    if (args.some((arg) => Array.isArray(arg) && (arg.length !== 1 || arg[0].length !== 1))) {
-        throw new EvaluationError(errorStr);
-    }
-}
-function assertPositive(errorStr, arg) {
-    assert(() => arg > 0, errorStr);
-}
-function assertSquareMatrix(errorStr, arg) {
-    assert(() => arg.length === arg[0].length, errorStr);
-}
-
 // -----------------------------------------------------------------------------
 // ARRAY_CONSTRAIN
 // -----------------------------------------------------------------------------
@@ -26909,8 +27140,12 @@ const ARRAY_CONSTRAIN = {
         const _array = toMatrix(array);
         const _rowsArg = toInteger(rows?.value, this.locale);
         const _columnsArg = toInteger(columns?.value, this.locale);
-        assertPositive(_t("The rows argument (%s) must be strictly positive.", _rowsArg.toString()), _rowsArg);
-        assertPositive(_t("The columns argument (%s) must be strictly positive.", _rowsArg.toString()), _columnsArg);
+        if (_rowsArg <= 0) {
+            return new EvaluationError(_t("The rows argument (%s) must be strictly positive.", _rowsArg.toString()));
+        }
+        if (_columnsArg <= 0) {
+            return new EvaluationError(_t("The columns argument (%s) must be strictly positive.", _columnsArg.toString()));
+        }
         const _nbRows = Math.min(_rowsArg, _array[0].length);
         const _nbColumns = Math.min(_columnsArg, _array.length);
         return generateMatrix(_nbColumns, _nbRows, (col, row) => _array[col][row]);
@@ -26931,7 +27166,9 @@ const CHOOSECOLS = {
         const _array = toMatrix(array);
         const _columns = flattenRowFirst(columns, (item) => toInteger(item?.value, this.locale));
         const argOutOfRange = _columns.filter((col) => col === 0 || _array.length < Math.abs(col));
-        assert(() => argOutOfRange.length === 0, _t("The columns arguments must be between -%s and %s (got %s), excluding 0.", _array.length.toString(), _array.length.toString(), argOutOfRange.join(",")));
+        if (argOutOfRange.length !== 0) {
+            return new EvaluationError(_t("The columns arguments must be between -%s and %s (got %s), excluding 0.", _array.length.toString(), _array.length.toString(), argOutOfRange.join(",")));
+        }
         const result = Array(_columns.length);
         for (let col = 0; col < _columns.length; col++) {
             if (_columns[col] > 0) {
@@ -26960,7 +27197,9 @@ const CHOOSEROWS = {
         const _rows = flattenRowFirst(rows, (item) => toInteger(item?.value, this.locale));
         const _nbColumns = _array.length;
         const argOutOfRange = _rows.filter((row) => row === 0 || _array[0].length < Math.abs(row));
-        assert(() => argOutOfRange.length === 0, _t("The rows arguments must be between -%s and %s (got %s), excluding 0.", _array[0].length.toString(), _array[0].length.toString(), argOutOfRange.join(",")));
+        if (argOutOfRange.length !== 0) {
+            return new EvaluationError(_t("The rows arguments must be between -%s and %s (got %s), excluding 0.", _array[0].length.toString(), _array[0].length.toString(), argOutOfRange.join(",")));
+        }
         return generateMatrix(_nbColumns, _rows.length, (col, row) => {
             if (_rows[row] > 0) {
                 return _array[col][_rows[row] - 1]; // -1 because columns arguments are 1-indexed
@@ -26986,8 +27225,12 @@ const EXPAND = {
         const _array = toMatrix(arg);
         const _nbRows = toInteger(rows?.value, this.locale);
         const _nbColumns = columns !== undefined ? toInteger(columns.value, this.locale) : _array.length;
-        assert(() => _nbRows >= _array[0].length, _t("The rows arguments (%s) must be greater or equal than the number of rows of the array.", _nbRows.toString()));
-        assert(() => _nbColumns >= _array.length, _t("The columns arguments (%s) must be greater or equal than the number of columns of the array.", _nbColumns.toString()));
+        if (_nbRows < _array[0].length) {
+            return new EvaluationError(_t("The rows arguments (%s) must be greater or equal than the number of rows of the array.", _nbRows.toString()));
+        }
+        if (_nbColumns < _array.length) {
+            return new EvaluationError(_t("The columns arguments (%s) must be greater or equal than the number of columns of the array.", _nbColumns.toString()));
+        }
         return generateMatrix(_nbColumns, _nbRows, (col, row) => col >= _array.length || row >= _array[col].length ? padWith : _array[col][row]);
     },
     isExported: true,
@@ -27090,7 +27333,9 @@ const MDETERM = {
     ],
     compute: function (matrix) {
         const _matrix = toNumberMatrix(matrix, "square_matrix");
-        assertSquareMatrix(_t("The argument square_matrix must have the same number of columns and rows."), _matrix);
+        if (!isSquareMatrix(_matrix)) {
+            return new EvaluationError(_t("The argument square_matrix must have the same number of columns and rows."));
+        }
         return invertMatrix(_matrix).determinant;
     },
     isExported: true,
@@ -27105,7 +27350,9 @@ const MINVERSE = {
     ],
     compute: function (matrix) {
         const _matrix = toNumberMatrix(matrix, "square_matrix");
-        assertSquareMatrix(_t("The argument square_matrix must have the same number of columns and rows."), _matrix);
+        if (!isSquareMatrix(_matrix)) {
+            return new EvaluationError(_t("The argument square_matrix must have the same number of columns and rows."));
+        }
         const { inverted } = invertMatrix(_matrix);
         if (!inverted) {
             return new EvaluationError(_t("The matrix is not invertible."));
@@ -27126,8 +27373,10 @@ const MMULT = {
     compute: function (matrix1, matrix2) {
         const _matrix1 = toNumberMatrix(matrix1, "matrix1");
         const _matrix2 = toNumberMatrix(matrix2, "matrix2");
-        assert(() => _matrix1.length === _matrix2[0].length, _t("In [[FUNCTION_NAME]], the number of columns of the first matrix (%s) must be equal to the \
-        number of rows of the second matrix (%s).", _matrix1.length.toString(), _matrix2[0].length.toString()));
+        if (_matrix1.length !== _matrix2[0].length) {
+            return new EvaluationError(_t("In [[FUNCTION_NAME]], the number of columns of the first matrix (%s) must be equal to the \
+          number of rows of the second matrix (%s).", _matrix1.length.toString(), _matrix2[0].length.toString()));
+        }
         return multiplyMatrices(_matrix1, _matrix2);
     },
     isExported: true,
@@ -27142,7 +27391,9 @@ const SUMPRODUCT = {
         arg("range2 (number, range<number>, repeating)", _t("The other range whose entries will be multiplied with corresponding entries in the other ranges.")),
     ],
     compute: function (...args) {
-        assertSameDimensions(_t("All the ranges must have the same dimensions."), ...args);
+        if (!areSameDimensions(...args)) {
+            return new EvaluationError(_t("All the ranges must have the same dimensions."));
+        }
         const _args = args.map(toMatrix);
         let result = 0;
         for (let col = 0; col < _args[0].length; col++) {
@@ -27170,7 +27421,9 @@ const SUMPRODUCT = {
  * Ignore the pairs X,Y where one of the value isn't a number. Throw an error if no pair of numbers is found.
  */
 function getSumXAndY(arrayX, arrayY, cb) {
-    assertSameDimensions("The arguments array_x and array_y must have the same dimensions.", arrayX, arrayY);
+    if (!areSameDimensions(arrayX, arrayY)) {
+        return new EvaluationError(_t("The arguments array_x and array_y must have the same dimensions."));
+    }
     const _arrayX = toMatrix(arrayX);
     const _arrayY = toMatrix(arrayY);
     let validPairFound = false;
@@ -27352,7 +27605,9 @@ const WRAPCOLS = {
     compute: function (range, wrapCount, padWith = { value: 0 }) {
         const _array = toMatrix(range);
         const nbRows = toInteger(wrapCount?.value, this.locale);
-        assertSingleColOrRow(_t("Argument range must be a single row or column."), _array);
+        if (!isSingleColOrRow(_array)) {
+            return new EvaluationError(_t("Argument range must be a single row or column."));
+        }
         const array = _array.flat();
         const nbColumns = Math.ceil(array.length / nbRows);
         return generateMatrix(nbColumns, nbRows, (col, row) => {
@@ -27376,7 +27631,9 @@ const WRAPROWS = {
     compute: function (range, wrapCount, padWith = { value: 0 }) {
         const _array = toMatrix(range);
         const nbColumns = toInteger(wrapCount?.value, this.locale);
-        assertSingleColOrRow(_t("Argument range must be a single row or column."), _array);
+        if (!isSingleColOrRow(_array)) {
+            return new EvaluationError(_t("Argument range must be a single row or column."));
+        }
         const array = _array.flat();
         const nbRows = Math.ceil(array.length / nbColumns);
         return generateMatrix(nbColumns, nbRows, (col, row) => {
@@ -27459,7 +27716,9 @@ const ACOS = {
     ],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assert(() => Math.abs(_value) <= 1, _t("The value (%s) must be between -1 and 1 inclusive.", _value.toString()));
+        if (Math.abs(_value) > 1) {
+            return new EvaluationError(_t("The value (%s) must be between -1 and 1 inclusive.", _value));
+        }
         return Math.acos(_value);
     },
     isExported: true,
@@ -27474,7 +27733,9 @@ const ACOSH = {
     ],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assert(() => _value >= 1, _t("The value (%s) must be greater than or equal to 1.", _value.toString()));
+        if (_value < 1) {
+            return new EvaluationError(_t("The value (%s) must be greater than or equal to 1.", _value));
+        }
         return Math.acosh(_value);
     },
     isExported: true,
@@ -27505,7 +27766,9 @@ const ACOTH = {
     ],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assert(() => Math.abs(_value) > 1, _t("The value (%s) cannot be between -1 and 1 inclusive.", _value.toString()));
+        if (Math.abs(_value) <= 1) {
+            return new EvaluationError(_t("The value (%s) cannot be between -1 and 1 inclusive.", _value));
+        }
         return Math.log((_value + 1) / (_value - 1)) / 2;
     },
     isExported: true,
@@ -27520,7 +27783,9 @@ const ASIN = {
     ],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assert(() => Math.abs(_value) <= 1, _t("The value (%s) must be between -1 and 1 inclusive.", _value.toString()));
+        if (Math.abs(_value) > 1) {
+            return new EvaluationError(_t("The value (%s) must be between -1 and 1 inclusive.", _value));
+        }
         return Math.asin(_value);
     },
     isExported: true,
@@ -27561,7 +27826,9 @@ const ATAN2 = {
     compute: function (x, y) {
         const _x = toNumber(x, this.locale);
         const _y = toNumber(y, this.locale);
-        assert(() => _x !== 0 || _y !== 0, _t("Function [[FUNCTION_NAME]] caused a divide by zero error."), CellErrorType.DivisionByZero);
+        if (_x === 0 && _y === 0) {
+            return new DivisionByZeroError(_t("Function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return Math.atan2(_y, _x);
     },
     isExported: true,
@@ -27576,7 +27843,9 @@ const ATANH = {
     ],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assert(() => Math.abs(_value) < 1, _t("The value (%s) must be between -1 and 1 exclusive.", _value.toString()));
+        if (Math.abs(_value) >= 1) {
+            return new EvaluationError(_t("The value (%s) must be between -1 and 1 exclusive.", _value));
+        }
         return Math.atanh(_value);
     },
     isExported: true,
@@ -27593,7 +27862,9 @@ const CEILING = {
     compute: function (value, factor = { value: DEFAULT_FACTOR }) {
         const _value = toNumber(value, this.locale);
         const _factor = toNumber(factor, this.locale);
-        assert(() => _factor >= 0 || _value <= 0, _t("The factor (%s) must be positive when the value (%s) is positive.", _factor.toString(), _value.toString()));
+        if (_factor < 0 && _value > 0) {
+            return new EvaluationError(_t("The factor (%s) must be positive when the value (%s) is positive.", _factor, _value));
+        }
         return {
             value: _factor ? Math.ceil(_value / _factor) * _factor : 0,
             format: value?.format,
@@ -27684,7 +27955,9 @@ const COT = {
     args: [arg("angle (number)", _t("The angle to find the cotangent of, in radians."))],
     compute: function (angle) {
         const _angle = toNumber(angle, this.locale);
-        assertNotZero(_angle);
+        if (_angle === 0) {
+            return new DivisionByZeroError(_t("Function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return 1 / Math.tan(_angle);
     },
     isExported: true,
@@ -27697,7 +27970,9 @@ const COTH = {
     args: [arg("value (number)", _t("Any real value to calculate the hyperbolic cotangent of."))],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assertNotZero(_value);
+        if (_value === 0) {
+            return new DivisionByZeroError(_t("Function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return 1 / Math.tanh(_value);
     },
     isExported: true,
@@ -27809,7 +28084,9 @@ const CSC = {
     args: [arg("angle (number)", _t("The angle to find the cosecant of, in radians."))],
     compute: function (angle) {
         const _angle = toNumber(angle, this.locale);
-        assertNotZero(_angle);
+        if (_angle === 0) {
+            return new DivisionByZeroError(_t("Function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return 1 / Math.sin(_angle);
     },
     isExported: true,
@@ -27822,7 +28099,9 @@ const CSCH = {
     args: [arg("value (number)", _t("Any real value to calculate the hyperbolic cosecant of."))],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assertNotZero(_value);
+        if (_value === 0) {
+            return new DivisionByZeroError(_t("Function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return 1 / Math.sinh(_value);
     },
     isExported: true,
@@ -27839,7 +28118,9 @@ const DECIMAL = {
     compute: function (value, base) {
         let _base = toNumber(base, this.locale);
         _base = Math.floor(_base);
-        assert(() => 2 <= _base && _base <= 36, _t("The base (%s) must be between 2 and 36 inclusive.", _base.toString()));
+        if (2 > _base || _base > 36) {
+            return new EvaluationError(_t("The base (%s) must be between 2 and 36 inclusive.", _base));
+        }
         const _value = toString(value);
         if (_value === "") {
             return 0;
@@ -27849,9 +28130,13 @@ const DECIMAL = {
          * Return error if 'value' is positive.
          * Remove '-?' in the next regex to catch this error.
          */
-        assert(() => DECIMAL_REPRESENTATION.test(_value), _t("The value (%s) must be a valid base %s representation.", _value, _base.toString()));
+        if (!DECIMAL_REPRESENTATION.test(_value)) {
+            return new EvaluationError(_t("The value (%s) must be a valid base %s representation.", _value, _base));
+        }
         const deci = parseInt(_value, _base);
-        assert(() => !isNaN(deci), _t("The value (%s) must be a valid base %s representation.", _value, _base.toString()));
+        if (isNaN(deci)) {
+            return new EvaluationError(_t("The value (%s) must be a valid base %s representation.", _value, _base));
+        }
         return deci;
     },
     isExported: true,
@@ -27890,7 +28175,9 @@ const FLOOR = {
     compute: function (value, factor = { value: DEFAULT_FACTOR }) {
         const _value = toNumber(value, this.locale);
         const _factor = toNumber(factor, this.locale);
-        assert(() => _factor >= 0 || _value <= 0, _t("The factor (%s) must be positive when the value (%s) is positive.", _factor.toString(), _value.toString()));
+        if (_factor < 0 && _value > 0) {
+            return new EvaluationError(_t("The factor (%s) must be positive when the value (%s) is positive.", _factor, _value));
+        }
         return {
             value: _factor ? Math.floor(_value / _factor) * _factor : 0,
             format: value?.format,
@@ -28002,7 +28289,9 @@ const LN = {
     args: [arg("value (number)", _t("The value for which to calculate the logarithm, base e."))],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assert(() => _value > 0, _t("The value (%s) must be strictly positive.", _value.toString()));
+        if (_value <= 0) {
+            return new EvaluationError(_t("The value (%s) must be strictly positive.", _value));
+        }
         return Math.log(_value);
     },
     isExported: true,
@@ -28019,9 +28308,15 @@ const LOG = {
     compute: function (value, base = { value: 10 }) {
         const _value = toNumber(value, this.locale);
         const _base = toNumber(base, this.locale);
-        assert(() => _value > 0, _t("The value (%s) must be strictly positive.", _value.toString()));
-        assert(() => _base > 0, _t("The base (%s) must be strictly positive.", _base.toString()));
-        assert(() => _base !== 1, _t("The base must be different from 1."));
+        if (_value <= 0) {
+            return new EvaluationError(_t("The value (%s) must be strictly positive.", _value));
+        }
+        if (_base <= 0) {
+            return new EvaluationError(_t("The base (%s) must be strictly positive.", _base));
+        }
+        if (_base === 1) {
+            return new EvaluationError(_t("The base must be different from 1."));
+        }
         return Math.log10(_value) / Math.log10(_base);
     },
     isExported: true,
@@ -28030,7 +28325,7 @@ const LOG = {
 // MOD
 // -----------------------------------------------------------------------------
 function mod(dividend, divisor) {
-    assert(() => divisor !== 0, _t("The divisor must be different from 0."), CellErrorType.DivisionByZero);
+    assertNotZero(divisor, _t("The divisor must be different from 0."));
     const modulus = dividend % divisor;
     // -42 % 10 = -2 but we want 8, so need the code below
     if ((modulus > 0 && divisor < 0) || (modulus < 0 && divisor > 0)) {
@@ -28064,7 +28359,9 @@ const MUNIT = {
     ],
     compute: function (n) {
         const _n = toInteger(n, this.locale);
-        assertPositive(_t("The argument dimension must be positive"), _n);
+        if (_n < 1) {
+            return new EvaluationError(_t("The argument dimension must be positive"));
+        }
         return getUnitMatrix(_n);
     },
     isExported: true,
@@ -28109,7 +28406,9 @@ const POWER = {
     compute: function (base, exponent) {
         const _base = toNumber(base, this.locale);
         const _exponent = toNumber(exponent, this.locale);
-        assert(() => _base >= 0 || Number.isInteger(_exponent), _t("The exponent (%s) must be an integer when the base is negative.", _exponent.toString()));
+        if (_base < 0 && !Number.isInteger(_exponent)) {
+            return new EvaluationError(_t("The exponent (%s) must be an integer when the base is negative.", _exponent));
+        }
         return { value: Math.pow(_base, _exponent), format: base?.format };
     },
     isExported: true,
@@ -28182,11 +28481,19 @@ const RANDARRAY = {
         const _min = toNumber(min, this.locale);
         const _max = toNumber(max, this.locale);
         const _whole_number = toBoolean(wholeNumber);
-        assertPositive(_t("The number of columns (%s) must be positive.", _cols.toString()), _cols);
-        assertPositive(_t("The number of rows (%s) must be positive.", _rows.toString()), _rows);
-        assert(() => _min <= _max, _t("The maximum (%s) must be greater than or equal to the minimum (%s).", _max.toString(), _min.toString()));
+        if (_cols < 1) {
+            return new EvaluationError(_t("The number of columns (%s) must be positive.", _cols));
+        }
+        if (_rows < 1) {
+            return new EvaluationError(_t("The number of rows (%s) must be positive.", _rows));
+        }
+        if (_min > _max) {
+            return new EvaluationError(_t("The maximum (%s) must be greater than or equal to the minimum (%s).", _max, _min));
+        }
         if (_whole_number) {
-            assert(() => Number.isInteger(_min) && Number.isInteger(_max), _t("The maximum (%s) and minimum (%s) must be integers when whole_number is TRUE.", _max.toString(), _min.toString()));
+            if (!Number.isInteger(_min) || !Number.isInteger(_max)) {
+                return new EvaluationError(_t("The maximum (%s) and minimum (%s) must be integers when whole_number is TRUE.", _max.toString(), _min.toString()));
+            }
         }
         const result = Array(_cols);
         for (let col = 0; col < _cols; col++) {
@@ -28222,7 +28529,9 @@ const RANDBETWEEN = {
         if (!Number.isInteger(_high)) {
             _high = Math.floor(_high);
         }
-        assert(() => _low <= _high, _t("The high (%s) must be greater than or equal to the low (%s).", _high.toString(), _low.toString()));
+        if (_low > _high) {
+            return new EvaluationError(_t("The high (%s) must be greater than or equal to the low (%s).", _high, _low));
+        }
         return {
             value: _low + Math.ceil((_high - _low + 1) * Math.random()) - 1,
             format: low?.format,
@@ -28358,8 +28667,12 @@ const SEQUENCE = {
         const _step = toNumber(step, this.locale);
         const _rows = toInteger(rows, this.locale);
         const _columns = toInteger(columns, this.locale);
-        assertPositive(_t("The number of columns (%s) must be positive.", _columns), _columns);
-        assertPositive(_t("The number of rows (%s) must be positive.", _rows), _rows);
+        if (_columns < 1) {
+            return new EvaluationError(_t("The number of columns (%s) must be positive.", _columns));
+        }
+        if (_rows < 1) {
+            return new EvaluationError(_t("The number of rows (%s) must be positive.", _rows));
+        }
         return generateMatrix(_columns, _rows, (col, row) => {
             return {
                 value: _start + row * _columns * _step + col * _step,
@@ -28398,7 +28711,9 @@ const SQRT = {
     args: [arg("value (number)", _t("The number for which to calculate the positive square root."))],
     compute: function (value) {
         const _value = toNumber(value, this.locale);
-        assert(() => _value >= 0, _t("The value (%s) must be positive or null.", _value.toString()));
+        if (_value < 0) {
+            return new EvaluationError(_t("The value (%s) must be positive or null.", _value));
+        }
         return { value: Math.sqrt(_value), format: value?.format };
     },
     isExported: true,
@@ -28606,7 +28921,7 @@ function filterAndFlatData(dataY, dataX) {
         _flatDataX.push(x);
         lenX += 1;
     });
-    assert(() => lenY === lenX, _t("[[FUNCTION_NAME]] has mismatched argument count %s vs %s.", lenY, lenX));
+    assert(lenY === lenX, _t("[[FUNCTION_NAME]] has mismatched argument count %s vs %s.", lenY, lenX));
     const flatDataX = [];
     const flatDataY = [];
     for (let i = 0; i < lenY; i++) {
@@ -28623,7 +28938,10 @@ function filterAndFlatData(dataY, dataX) {
 function covariance(dataY, dataX, isSample) {
     const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
     const count = flatDataY.length;
-    assert(() => count !== 0 && (!isSample || count !== 1), _t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."), CellErrorType.DivisionByZero);
+    assertNotZero(count);
+    if (isSample) {
+        assertNotZero(count - 1);
+    }
     let sumY = 0;
     let sumX = 0;
     for (let i = 0; i < count; i++) {
@@ -28645,14 +28963,17 @@ function variance(args, isSample, textAs0, locale) {
         count += 1;
         return acc + a;
     }, 0, locale);
-    assert(() => count !== 0 && (!isSample || count !== 1), _t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."), CellErrorType.DivisionByZero);
+    assertNotZero(count);
+    if (isSample) {
+        assertNotZero(count - 1);
+    }
     const average = sum / count;
     return (reduceFunction(args, (acc, a) => acc + Math.pow(a - average, 2), 0, locale) /
         (count - (isSample ? 1 : 0)));
 }
 function centile(data, percent, isInclusive, locale) {
     const _percent = toNumber(percent, locale);
-    assert(() => (isInclusive ? 0 <= _percent && _percent <= 1 : 0 < _percent && _percent < 1), _t("Function [[FUNCTION_NAME]] parameter 2 value is out of range."));
+    assert(isInclusive ? 0 <= _percent && _percent <= 1 : 0 < _percent && _percent < 1, _t("Function [[FUNCTION_NAME]] parameter 2 value is out of range."));
     const sortedArray = [];
     let index;
     let count = 0;
@@ -28664,10 +28985,10 @@ function centile(data, percent, isInclusive, locale) {
             count++;
         }
     });
-    assert(() => count !== 0, _t("[[FUNCTION_NAME]] has no valid input data."));
+    assert(count !== 0, _t("[[FUNCTION_NAME]] has no valid input data."));
     if (!isInclusive) {
         // 2nd argument must be between 1/(n+1) and n/(n+1) with n the number of data
-        assert(() => 1 / (count + 1) <= _percent && _percent <= count / (count + 1), _t("Function [[FUNCTION_NAME]] parameter 2 value is out of range."));
+        assert(1 / (count + 1) <= _percent && _percent <= count / (count + 1), _t("Function [[FUNCTION_NAME]] parameter 2 value is out of range."));
     }
     return percentile(sortedArray, _percent, isInclusive);
 }
@@ -28686,7 +29007,9 @@ const AVEDEV = {
             count += 1;
             return acc + a;
         }, 0, this.locale);
-        assertNotZero(count);
+        if (count === 0) {
+            return new DivisionByZeroError(_t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         const average = sum / count;
         return reduceNumbers(values, (acc, a) => acc + Math.abs(average - a), 0, this.locale) / count;
     },
@@ -28728,7 +29051,9 @@ const AVERAGE_WEIGHTED = {
         for (let n = 0; n < args.length - 1; n += 2) {
             const argN = args[n];
             const argN1 = args[n + 1];
-            assertSameDimensions(rangeError, argN, argN1);
+            if (!areSameDimensions(argN, argN1)) {
+                return new EvaluationError(rangeError);
+            }
             if (isMatrix(argN)) {
                 for (let i = 0; i < argN.length; i++) {
                     for (let j = 0; j < argN[0].length; j++) {
@@ -28737,12 +29062,16 @@ const AVERAGE_WEIGHTED = {
                         const valueIsNumber = typeof value === "number";
                         const weightIsNumber = typeof weight === "number";
                         if (valueIsNumber && weightIsNumber) {
-                            assert(() => weight >= 0, negativeWeightError);
+                            if (weight < 0) {
+                                return new EvaluationError(negativeWeightError);
+                            }
                             sum += value * weight;
                             count += weight;
                             continue;
                         }
-                        assert(() => valueIsNumber === weightIsNumber, _t("[[FUNCTION_NAME]] expects number values."));
+                        if (valueIsNumber !== weightIsNumber) {
+                            return new EvaluationError(_t("[[FUNCTION_NAME]] expects number values."));
+                        }
                     }
                 }
             }
@@ -28750,13 +29079,17 @@ const AVERAGE_WEIGHTED = {
                 const value = toNumber(argN, this.locale);
                 const weight = isMatrix(argN1) ? argN1?.[0][0].value : toNumber(argN1, this.locale);
                 if (typeof weight === "number") {
-                    assert(() => weight >= 0, negativeWeightError);
+                    if (weight < 0) {
+                        return new EvaluationError(negativeWeightError);
+                    }
                     sum += value * weight;
                     count += weight;
                 }
             }
         }
-        assertNotZero(count);
+        if (count === 0) {
+            return new DivisionByZeroError(_t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return { value: sum / count, format: inferFormat(args[0]) };
     },
 };
@@ -28775,7 +29108,9 @@ const AVERAGEA = {
             count += 1;
             return acc + a;
         }, 0, this.locale);
-        assertNotZero(count);
+        if (count === 0) {
+            return new DivisionByZeroError(_t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return {
             value: sum / count,
             format: inferFormat(args[0]),
@@ -28804,7 +29139,9 @@ const AVERAGEIF = {
                 sum += value;
             }
         }, this.locale);
-        assertNotZero(count);
+        if (count === 0) {
+            return new DivisionByZeroError(_t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return sum / count;
     },
     isExported: true,
@@ -28832,7 +29169,9 @@ const AVERAGEIFS = {
                 sum += value;
             }
         }, this.locale);
-        assertNotZero(count);
+        if (count === 0) {
+            return new DivisionByZeroError(_t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."));
+        }
         return sum / count;
     },
     isExported: true,
@@ -28982,8 +29321,12 @@ const LARGE = {
             }
         });
         const result = largests.shift();
-        assert(() => result !== undefined, _t("[[FUNCTION_NAME]] has no valid input data."));
-        assert(() => count >= _n, _t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
+        if (result === undefined) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+        }
+        if (count < _n) {
+            return new EvaluationError(_t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
+        }
         return result;
     },
     isExported: true,
@@ -29463,8 +29806,12 @@ const SMALL = {
             }
         });
         const result = largests.pop();
-        assert(() => result !== undefined, _t("[[FUNCTION_NAME]] has no valid input data."));
-        assert(() => count >= _n, _t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
+        if (result === undefined) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+        }
+        if (count < _n) {
+            return new EvaluationError(_t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
+        }
         return result;
     },
     isExported: true,
@@ -29891,7 +30238,9 @@ const DGET = {
     args: databaseArgs,
     compute: function (database, field, criteria) {
         const cells = getMatchingCells(database, field, criteria, this.locale);
-        assert(() => cells.length === 1, _t("More than one match found in DGET evaluation."));
+        if (cells.length !== 1) {
+            return new EvaluationError(_t("More than one match found in DGET evaluation."));
+        }
         return cells[0];
     },
     isExported: true,
@@ -30035,14 +30384,18 @@ const DATE = {
         const _month = Math.trunc(toNumber(month, this.locale));
         const _day = Math.trunc(toNumber(day, this.locale));
         // For years less than 0 or greater than 10000, return #ERROR.
-        assert(() => 0 <= _year && _year <= 9999, _t("The year (%s) must be between 0 and 9999 inclusive.", _year.toString()));
+        if (_year < 0 || _year > 9999) {
+            return new EvaluationError(_t("The year (%s) must be between 0 and 9999 inclusive.", _year.toString()));
+        }
         // Between 0 and 1899, we add that value to 1900 to calculate the year
         if (_year < 1900) {
             _year += 1900;
         }
         const jsDate = new DateTime(_year, _month - 1, _day);
         const result = jsDateToRoundNumber(jsDate);
-        assert(() => result >= 0, _t("The function [[FUNCTION_NAME]] result must be greater than or equal 01/01/1900."));
+        if (result < 0) {
+            return new EvaluationError(_t("The function [[FUNCTION_NAME]] result must be greater than or equal 01/01/1900."));
+        }
         return {
             value: result,
             format: this.locale.dateFormat,
@@ -30062,12 +30415,16 @@ const DATEDIF = {
     ],
     compute: function (startDate, endDate, unit) {
         const _unit = toString(unit).toUpperCase();
-        assert(() => Object.values(TIME_UNIT).includes(_unit), expectStringSetError(Object.values(TIME_UNIT), toString(unit)));
+        if (!Object.values(TIME_UNIT).includes(_unit)) {
+            return new EvaluationError(expectStringSetError(Object.values(TIME_UNIT), toString(unit)));
+        }
         const _startDate = Math.trunc(toNumber(startDate, this.locale));
         const _endDate = Math.trunc(toNumber(endDate, this.locale));
         const jsStartDate = numberToJsDate(_startDate);
         const jsEndDate = numberToJsDate(_endDate);
-        assert(() => _endDate >= _startDate, _t("start_date (%s) should be on or before end_date (%s).", jsStartDate.toLocaleDateString(), jsEndDate.toLocaleDateString()));
+        if (_endDate < _startDate) {
+            return new EvaluationError(_t("start_date (%s) should be on or before end_date (%s).", jsStartDate.toLocaleDateString(), jsEndDate.toLocaleDateString()));
+        }
         switch (_unit) {
             case TIME_UNIT.WHOLE_YEARS:
                 return getTimeDifferenceInWholeYears(jsStartDate, jsEndDate);
@@ -30115,7 +30472,9 @@ const DATEVALUE = {
     compute: function (dateString) {
         const _dateString = toString(dateString);
         const internalDate = parseDateTime(_dateString, this.locale);
-        assert(() => internalDate !== null, _t("The date_string (%s) cannot be parsed to date/time.", _dateString.toString()));
+        if (internalDate === null) {
+            return new EvaluationError(_t("The date_string (%s) cannot be parsed to date/time.", _dateString.toString()));
+        }
         return Math.trunc(internalDate.value);
     },
     isExported: true,
@@ -30359,17 +30718,7 @@ function weekendToDayNumber(data) {
     const weekend = data?.value;
     // case "string"
     if (typeof weekend === "string") {
-        assert(() => {
-            if (weekend.length !== 7) {
-                return false;
-            }
-            for (const day of weekend) {
-                if (day !== "0" && day !== "1") {
-                    return false;
-                }
-            }
-            return true;
-        }, _t('When weekend is a string (%s) it must be composed of "0" or "1".', weekend));
+        assert(weekend.length === 7 && [...weekend].every((c) => c === "0" || c === "1"), _t('When weekend is a string (%s) it must be composed of "0" or "1".', weekend));
         const result = [];
         for (let i = 0; i < 7; i++) {
             if (weekend[i] === "1") {
@@ -30380,7 +30729,7 @@ function weekendToDayNumber(data) {
     }
     //case "number"
     if (typeof weekend === "number") {
-        assert(() => (1 <= weekend && weekend <= 7) || (11 <= weekend && weekend <= 17), _t("The weekend (%s) must be a string or a number in the range 1-7 or 11-17.", weekend.toString()));
+        assert((1 <= weekend && weekend <= 7) || (11 <= weekend && weekend <= 17), _t("The weekend (%s) must be a string or a number in the range 1-7 or 11-17.", weekend.toString()));
         // case 1 <= weekend <= 7
         if (weekend <= 7) {
             // 1 = Saturday/Sunday are weekends
@@ -30481,7 +30830,9 @@ const TIME = {
         _hour += Math.floor(_minute / 60);
         _minute = (_minute % 60) + (_minute < 0 ? 60 : 0);
         _hour %= 24;
-        assert(() => _hour >= 0, _t("The function [[FUNCTION_NAME]] result cannot be negative"));
+        if (_hour < 0) {
+            return new EvaluationError(_t("The function [[FUNCTION_NAME]] result cannot be negative"));
+        }
         return {
             value: _hour / 24 + _minute / (24 * 60) + _second / (24 * 60 * 60),
             format: this.locale.timeFormat,
@@ -30498,7 +30849,9 @@ const TIMEVALUE = {
     compute: function (timeString) {
         const _timeString = toString(timeString);
         const internalDate = parseDateTime(_timeString, this.locale);
-        assert(() => internalDate !== null, _t("The time_string (%s) cannot be parsed to date/time.", _timeString));
+        if (internalDate === null) {
+            return new EvaluationError(_t("The time_string (%s) cannot be parsed to date/time.", _timeString));
+        }
         const result = internalDate.value - Math.trunc(internalDate.value);
         return result < 0 ? 1 + result : result;
     },
@@ -30533,7 +30886,9 @@ const WEEKDAY = {
         const _date = toJsDate(date, this.locale);
         const _type = Math.round(toNumber(type, this.locale));
         const m = _date.getDay();
-        assert(() => [1, 2, 3].includes(_type), _t("The type (%s) must be 1, 2 or 3.", _type.toString()));
+        if (![1, 2, 3].includes(_type)) {
+            return new EvaluationError(_t("The type (%s) must be 1, 2 or 3.", _type));
+        }
         if (_type === 1)
             return m + 1;
         if (_type === 2)
@@ -30554,7 +30909,9 @@ const WEEKNUM = {
     compute: function (date, type = { value: DEFAULT_TYPE }) {
         const _date = toJsDate(date, this.locale);
         const _type = Math.round(toNumber(type, this.locale));
-        assert(() => _type === 1 || _type === 2 || (11 <= _type && _type <= 17) || _type === 21, _t("The type (%s) is out of range.", _type.toString()));
+        if (![1, 2, 11, 12, 13, 14, 15, 16, 17, 21].includes(_type)) {
+            return new EvaluationError(_t("The type (%s) is out of range.", _type.toString()));
+        }
         if (_type === 21) {
             return ISOWEEKNUM.compute.bind(this)(date);
         }
@@ -30610,8 +30967,8 @@ const WORKDAY_INTL = {
     compute: function (startDate, numDays, weekend = { value: DEFAULT_WEEKEND }, holidays) {
         const _startDate = toJsDate(startDate, this.locale);
         const _numDays = Math.trunc(toNumber(numDays, this.locale));
-        if (typeof weekend.value === "string") {
-            assert(() => weekend.value !== "1111111", _t("The weekend must be different from '1111111'."));
+        if (weekend.value === "1111111") {
+            return new EvaluationError(_t("The weekend must be different from '1111111'."));
         }
         const daysWeekend = weekendToDayNumber(weekend);
         const timesHoliday = new Set();
@@ -30666,9 +31023,15 @@ const YEARFRAC = {
         const _startDate = Math.trunc(toNumber(startDate, this.locale));
         const _endDate = Math.trunc(toNumber(endDate, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assert(() => _startDate >= 0, _t("The start_date (%s) must be positive or null.", _startDate.toString()));
-        assert(() => _endDate >= 0, _t("The end_date (%s) must be positive or null.", _endDate.toString()));
-        assert(() => 0 <= _dayCountConvention && _dayCountConvention <= 4, _t("The day_count_convention (%s) must be between 0 and 4 inclusive.", _dayCountConvention.toString()));
+        if (_startDate < 0) {
+            return new EvaluationError(_t("The start_date (%s) must be positive or null.", _startDate));
+        }
+        if (_endDate < 0) {
+            return new EvaluationError(_t("The end_date (%s) must be positive or null.", _endDate));
+        }
+        if (0 > _dayCountConvention || _dayCountConvention > 4) {
+            return new EvaluationError(_t("The day_count_convention (%s) must be between 0 and 4 inclusive.", _dayCountConvention));
+        }
         return getYearFrac(_startDate, _endDate, _dayCountConvention);
     },
 };
@@ -30833,7 +31196,7 @@ var engineering = /*#__PURE__*/Object.freeze({
 
 function sortMatrix(matrix, locale, ...criteria) {
     for (const [i, value] of criteria.entries()) {
-        assert(() => value !== undefined, _t("Value for parameter %d is missing, while the function [[FUNCTION_NAME]] expect a number or a range.", i + 1));
+        assert(value !== undefined, _t("Value for parameter %d is missing, while the function [[FUNCTION_NAME]] expect a number or a range.", i + 1));
     }
     const sortingOrders = [];
     const sortColumns = [];
@@ -30842,7 +31205,7 @@ function sortMatrix(matrix, locale, ...criteria) {
         sortingOrders.push(toBoolean(toScalar(criteria[i + 1])?.value) ? "asc" : "desc");
         const sortColumn = criteria[i];
         if (isMatrix(sortColumn) && (sortColumn.length > 1 || sortColumn[0].length > 1)) {
-            assert(() => sortColumn.length === 1 && sortColumn[0].length === nRows, _t("Wrong size for %s. Expected a range of size 1x%s. Got %sx%s.", `sort_column${i + 1}`, nRows, sortColumn.length, sortColumn[0].length));
+            assert(sortColumn.length === 1 && sortColumn[0].length === nRows, _t("Wrong size for %s. Expected a range of size 1x%s. Got %sx%s.", `sort_column${i + 1}`, nRows, sortColumn.length, sortColumn[0].length));
             sortColumns.push(sortColumn.flat().map((c) => c.value));
         }
         else {
@@ -30907,12 +31270,20 @@ const FILTER = {
     compute: function (range, ...conditions) {
         let _array = toMatrix(range);
         const _conditionsMatrices = conditions.map((cond) => matrixMap(toMatrix(cond), (data) => data.value));
-        _conditionsMatrices.map((c) => assertSingleColOrRow(_t("The arguments condition must be a single column or row."), c));
-        assertSameDimensions(_t("The arguments conditions must have the same dimensions."), ...conditions);
+        for (const c of _conditionsMatrices) {
+            if (!isSingleColOrRow(c)) {
+                return new EvaluationError(_t("The arguments condition must be a single column or row."));
+            }
+        }
+        if (!areSameDimensions(...conditions)) {
+            return new EvaluationError(_t("The arguments conditions must have the same dimensions."));
+        }
         const _conditions = _conditionsMatrices.map((c) => c.flat());
         const mode = _conditionsMatrices[0].length === 1 ? "row" : "col";
         _array = mode === "row" ? transposeMatrix(_array) : _array;
-        assert(() => _conditions.every((cond) => cond.length === _array.length), _t("FILTER has mismatched sizes on the range and conditions."));
+        if (_conditions.some((cond) => cond.length !== _array.length)) {
+            return new EvaluationError(_t("FILTER has mismatched sizes on the range and conditions."));
+        }
         const result = [];
         for (let i = 0; i < _array.length; i++) {
             const row = _array[i];
@@ -30963,8 +31334,12 @@ const SORTN = {
         const sortingCriteria = displayTiesMode_sortingCriteria.length % 2 === 0
             ? displayTiesMode_sortingCriteria
             : displayTiesMode_sortingCriteria.slice(1);
-        assert(() => _n >= 0, _t("Wrong value of 'n'. Expected a positive number. Got %s.", _n));
-        assert(() => _displayTiesMode >= 0 && _displayTiesMode <= 3, _t("Wrong value of 'display_ties_mode'. Expected a positive number between 0 and 3. Got %s.", _displayTiesMode));
+        if (_n < 0) {
+            return new EvaluationError(_t("Wrong value of 'n'. Expected a positive number. Got %s.", _n));
+        }
+        if (_displayTiesMode < 0 || _displayTiesMode > 3) {
+            return new EvaluationError(_t("Wrong value of 'display_ties_mode'. Expected a positive number between 0 and 3. Got %s.", _displayTiesMode));
+        }
         const sortedData = sortMatrix(transposeMatrix(range), this.locale, ...sortingCriteria);
         const sameRows = (i, j) => JSON.stringify(sortedData[i].map((c) => c.value)) ===
             JSON.stringify(sortedData[j].map((c) => c.value));
@@ -31069,127 +31444,83 @@ var filter = /*#__PURE__*/Object.freeze({
   UNIQUE: UNIQUE
 });
 
-/** Assert maturity date > settlement date */
-function assertMaturityAndSettlementDatesAreValid(settlement, maturity) {
-    assert(() => settlement < maturity, _t("The maturity (%s) must be strictly greater than the settlement (%s).", maturity.toString(), settlement.toString()));
-}
-/** Assert settlement date > issue date */
-function assertSettlementAndIssueDatesAreValid(settlement, issue) {
-    assert(() => issue < settlement, _t("The settlement date (%s) must be strictly greater than the issue date (%s).", settlement.toString(), issue.toString()));
-}
-/** Assert coupon frequency is in [1, 2, 4] */
-function assertCouponFrequencyIsValid(frequency) {
-    assert(() => [1, 2, 4].includes(frequency), _t("The frequency (%s) must be one of %s", frequency.toString(), [1, 2, 4].toString()));
-}
-/** Assert dayCountConvention is between 0 and 4 */
-function assertDayCountConventionIsValid(dayCountConvention) {
-    assert(() => 0 <= dayCountConvention && dayCountConvention <= 4, _t("The day_count_convention (%s) must be between 0 and 4 inclusive.", dayCountConvention.toString()));
-}
-function assertRedemptionStrictlyPositive(redemption) {
-    assert(() => redemption > 0, _t("The redemption (%s) must be strictly positive.", redemption.toString()));
-}
-function assertPriceStrictlyPositive(price) {
-    assert(() => price > 0, _t("The price (%s) must be strictly positive.", price.toString()));
-}
-function assertNumberOfPeriodsStrictlyPositive(nPeriods) {
-    assert(() => nPeriods > 0, _t("The number_of_periods (%s) must be greater than 0.", nPeriods.toString()));
-}
-function assertRateStrictlyPositive(rate) {
-    assert(() => rate > 0, _t("The rate (%s) must be strictly positive.", rate.toString()));
-}
-function assertLifeStrictlyPositive(life) {
-    assert(() => life > 0, _t("The life (%s) must be strictly positive.", life.toString()));
-}
-function assertCostStrictlyPositive(cost) {
-    assert(() => cost > 0, _t("The cost (%s) must be strictly positive.", cost.toString()));
-}
-function assertPurchaseDatePositiveOrZero(purchaseDate) {
-    assert(() => purchaseDate >= 0, _t("The purchase_date (%s) must be positive or null.", purchaseDate.toString()));
-}
-function assertIssuePositiveOrZero(issue) {
-    assert(() => issue >= 0, _t("The issue (%s) must be positive or null.", issue.toString()));
-}
-function assertCostPositiveOrZero(cost) {
-    assert(() => cost >= 0, _t("The cost (%s) must be positive or null.", cost.toString()));
-}
-function assertPeriodStrictlyPositive(period) {
-    assert(() => period > 0, _t("The period (%s) must be strictly positive.", period.toString()));
-}
-function assertPeriodPositiveOrZero(period) {
-    assert(() => period >= 0, _t("The period (%s) must be positive or null.", period.toString()));
-}
-function assertSalvagePositiveOrZero(salvage) {
-    assert(() => salvage >= 0, _t("The salvage (%s) must be positive or null.", salvage.toString()));
-}
-function assertSalvageSmallerOrEqualThanCost(salvage, cost) {
-    assert(() => salvage <= cost, _t("The salvage (%s) must be smaller or equal than the cost (%s).", salvage.toString(), cost.toString()));
-}
-function assertPresentValueStrictlyPositive(pv) {
-    assert(() => pv > 0, _t("The present value (%s) must be strictly positive.", pv.toString()));
-}
-function assertPeriodSmallerOrEqualToLife(period, life) {
-    assert(() => period <= life, _t("The period (%s) must be less than or equal life (%s).", period.toString(), life.toString()));
-}
-function assertInvestmentStrictlyPositive(investment) {
-    assert(() => investment > 0, _t("The investment (%s) must be strictly positive.", investment.toString()));
-}
-function assertDiscountStrictlyPositive(discount) {
-    assert(() => discount > 0, _t("The discount (%s) must be strictly positive.", discount.toString()));
+const expectCashFlowsAndDatesHaveSameDimension = _t("The cashflow_amounts and cashflow_dates ranges must have the same dimensions.");
+const expectCashFlowsHavePositiveAndNegativesValues = _t("There must be both positive and negative values in cashflow_amounts.");
+const expectCostPositiveOrZero = (cost) => _t("The cost (%s) must be positive or null.", cost);
+const expectCostStrictlyPositive = (cost) => _t("The cost (%s) must be strictly positive.", cost);
+const expectCouponFrequencyIsValid = (frequency) => _t("The frequency (%s) must be one of %s", frequency, [1, 2, 4].toString());
+const expectDayCountConventionIsValid = (dayCountConvention) => _t("The day_count_convention (%s) must be between 0 and 4 inclusive.", dayCountConvention);
+const expectDeprecationFactorStrictlyPositive = (factor) => _t("The depreciation factor (%s) must be strictly positive.", factor);
+const expectDiscountDifferentFromMinusOne = (discount) => _t("The discount (%s) must be different from -1.", discount);
+const expectDiscountStrictlyPositive = (discount) => _t("The discount (%s) must be strictly positive.", discount);
+const expectDiscountStrictlySmallerThanOne = (discount) => _t("The discount (%s) must be smaller than 1.", discount);
+const expectEffectiveRateStrictlyPositive = (effectiveRate) => _t("The effective_rate (%s) must be strictly positive.", effectiveRate);
+const expectEndPeriodPositiveOrZero = (endPeriod) => _t("The end_period (%s) must be positive or null.", endPeriod);
+const expectEndPeriodSmallerOrEqualToLife = (end, life) => _t("The end_period (%(end)s) must be smaller or equal to the life (%(life)s).", { end, life });
+const expectEveryDateGreaterThanFirstDateOfCashFlowDates = (firstDate) => _t("All the dates should be greater or equal to the first date in cashflow_dates (%s).", firstDate);
+const expectFirstPeriodSmallerOrEqualLastPeriod = (first, last) => _t("The first_period (%(first)s) must be smaller or equal to the last_period (%(last)s).", {
+    first,
+    last,
+});
+const expectFirstPeriodStrictlyPositive = (period) => _t("The first_period (%s) must be strictly positive.", period);
+const expectFutureValueStrictlyPositive = (pv) => _t("The future_value (%s) must be strictly positive.", pv);
+const expectInvestmentStrictlyPositive = (investment) => _t("The investment (%s) must be strictly positive.", investment);
+const expectIssuePositiveOrZero = (issue) => _t("The issue (%s) must be positive or null.", issue);
+const expectLastPeriodSmallerOrEqualNumberOfPeriods = (last, nPeriods) => _t("The last_period (%(last)s) must be smaller or equal to the number_of_periods (%(nPeriods)s).", { last, nPeriods });
+const expectLastPeriodStrictlyPositive = (period) => _t("The last_period (%s) must be strictly positive.", period);
+const expectLifeStrictlyPositive = (life) => _t("The life (%s) must be strictly positive.", life);
+const expectMaturityStrictlyGreaterThanSettlement = (settlement, maturity) => _t("The maturity (%(maturity)s) must be strictly greater than the settlement (%(settlement)s).", {
+    maturity,
+    settlement,
+});
+const expectMonthBetweenOneAndTwelve = (month) => _t("The month (%s) must be between 1 and 12 inclusive.", month);
+const expectNominalRateStrictlyPositive = (nominalRate) => _t("The nominal_rate (%s) must be strictly positive.", nominalRate);
+const expectNumberOfPeriodDifferentFromZero = (nPeriods) => _t("The number_of_periods (%s) must be different from zero.", nPeriods);
+const expectNumberOfPeriodsStrictlyPositive = (nPeriods) => _t("The number_of_periods (%s) must be strictly positive.", nPeriods);
+const expectPeriodBetweenOneAndNumberOfPeriods = (nPeriods) => _t("The period must be between 1 and number_of_periods (%s)", nPeriods);
+const expectPeriodLessOrEqualToLifeLimit = (period, lifeLimit) => _t("The period (%(period)s) must be less than or equal to %(lifeLimit)s.", { period, lifeLimit });
+const expectPeriodPositiveOrZero = (period) => _t("The period (%s) must be positive or null.", period);
+const expectPeriodsByYearStrictlyPositive = (periodsByYear) => _t("The periods_by_year (%s) must be strictly positive.", periodsByYear);
+const expectPeriodSmallerOrEqualToLife = (period, life) => _t("The period (%(period)s) must be less than or equal life (%(life)s).", { period, life });
+const expectPeriodStrictlyPositive = (period) => _t("The period (%s) must be strictly positive.", period);
+const expectPresentValueStrictlyPositive = (pv) => _t("The present_value (%s) must be strictly positive.", pv);
+const expectPriceStrictlyPositive = (price) => _t("The price (%s) must be strictly positive.", price);
+const expectPurchaseDateBeforeFirstPeriodEnd = (purchaseDate, firstPeriodEnd) => _t("The purchase_date (%(purchaseDate)s) must be before the first_period_end (%(firstPeriodEnd)s).", { purchaseDate, firstPeriodEnd });
+const expectPurchaseDatePositiveOrZero = (purchaseDate) => _t("The purchase_date (%s) must be positive or null.", purchaseDate);
+const expectRateGuessStrictlyGreaterThanMinusOne = (guess) => _t("The rate_guess (%s) must be strictly greater than -1.", guess);
+const expectRatePositiveOrZero = (rate) => _t("The rate (%s) must be positive or null.", rate);
+const expectRateStrictlyPositive = (rate) => _t("The rate (%s) must be strictly positive.", rate);
+const expectRedemptionStrictlyPositive = (redemption) => _t("The redemption (%s) must be strictly positive.", redemption);
+const expectSalvagePositiveOrZero = (salvage) => _t("The salvage (%s) must be positive or null.", salvage);
+const expectSalvageSmallerOrEqualThanCost = (salvage, cost) => _t("The salvage (%(salvage)s) must be smaller or equal than the cost (%(cost)s).", {
+    salvage,
+    cost,
+});
+const expectSettlementGreaterOrEqualToIssue = (settlement, issue) => _t("The settlement date (%(settlement)s) must be greater or equal to the issue date (%(issue)s).", { settlement, issue });
+const expectSettlementLessThanOneYearBeforeMaturity = (settlement, maturity) => _t("The settlement date (%(settlement)s) must at most one year after the maturity date (%(maturity)s).", { settlement, maturity });
+const expectSettlementStrictlyGreaterThanIssue = (settlement, issue) => _t("The settlement date (%(settlement)s) must be strictly greater than the issue date (%(issue)s).", { settlement, issue });
+const expectStartPeriodPositiveOrZero = (startPeriod) => _t("The start_period (%s) must be positive or null.", startPeriod);
+const expectStartPeriodSmallerOrEqualEndPeriod = (start, end) => _t("The start_period (%(start)s) must be smaller or equal to the end_period (%(end)s).", {
+    start,
+    end,
+});
+const expectUnitStrictlyPositive = (unit) => _t("The unit (%s) must be strictly positive.", unit);
+const expectYieldPositiveOrZero = (yeld) => _t("The yield (%s) must be positive or null.", yeld);
+function havePositiveAndNegativeValues(arrayNumbers) {
+    return arrayNumbers.some((val) => val > 0) && arrayNumbers.some((val) => val < 0);
 }
-function assertDiscountStrictlySmallerThanOne(discount) {
-    assert(() => discount < 1, _t("The discount (%s) must be smaller than 1.", discount.toString()));
+function isInvalidDayCountConvention(dayCountConvention) {
+    return ![0, 1, 2, 3, 4].includes(dayCountConvention);
 }
-function assertDeprecationFactorStrictlyPositive(factor) {
-    assert(() => factor > 0, _t("The depreciation factor (%s) must be strictly positive.", factor.toString()));
+function isInvalidFrequency(frequency) {
+    return ![1, 2, 4].includes(frequency);
 }
-function assertSettlementLessThanOneYearBeforeMaturity(settlement, maturity, locale) {
+function isSettlementLessThanOneYearBeforeMaturity(settlement, maturity, locale) {
     const startDate = toJsDate(settlement, locale);
     const endDate = toJsDate(maturity, locale);
     const startDatePlusOneYear = toJsDate(settlement, locale);
     startDatePlusOneYear.setFullYear(startDate.getFullYear() + 1);
-    assert(() => endDate.getTime() <= startDatePlusOneYear.getTime(), _t("The settlement date (%s) must at most one year after the maturity date (%s).", settlement.toString(), maturity.toString()));
-}
-/**
- * Check if the given periods are valid. This will assert :
- *
- * - 0 < numberOfPeriods
- * - 0 < firstPeriod <= lastPeriod
- * - 0 < lastPeriod <= numberOfPeriods
- *
- */
-function assertFirstAndLastPeriodsAreValid(firstPeriod, lastPeriod, numberOfPeriods) {
-    assertNumberOfPeriodsStrictlyPositive(numberOfPeriods);
-    assert(() => firstPeriod > 0, _t("The first_period (%s) must be strictly positive.", firstPeriod.toString()));
-    assert(() => lastPeriod > 0, _t("The last_period (%s) must be strictly positive.", lastPeriod.toString()));
-    assert(() => firstPeriod <= lastPeriod, _t("The first_period (%s) must be smaller or equal to the last_period (%s).", firstPeriod.toString(), lastPeriod.toString()));
-    assert(() => lastPeriod <= numberOfPeriods, _t("The last_period (%s) must be smaller or equal to the number_of_periods (%s).", firstPeriod.toString(), numberOfPeriods.toString()));
-}
-/**
- * Check if the given periods are valid. This will assert :
- *
- * - 0 < life
- * - 0 <= startPeriod <= endPeriod
- * - 0 <= endPeriod <= life
- *
- */
-function assertStartAndEndPeriodAreValid(startPeriod, endPeriod, life) {
-    assertLifeStrictlyPositive(life);
-    assert(() => startPeriod >= 0, _t("The start_period (%s) must be greater or equal than 0.", startPeriod.toString()));
-    assert(() => endPeriod >= 0, _t("The end_period (%s) must be greater or equal than 0.", endPeriod.toString()));
-    assert(() => startPeriod <= endPeriod, _t("The start_period (%s) must be smaller or equal to the end_period (%s).", startPeriod.toString(), endPeriod.toString()));
-    assert(() => endPeriod <= life, _t("The end_period (%s) must be smaller or equal to the life (%s).", startPeriod.toString(), life.toString()));
-}
-function assertRateGuessStrictlyGreaterThanMinusOne(guess) {
-    assert(() => guess > -1, _t("The rate_guess (%s) must be strictly greater than -1.", guess.toString()));
-}
-function assertCashFlowsAndDatesHaveSameDimension(cashFlows, dates) {
-    assert(() => cashFlows.length === dates.length && cashFlows[0].length === dates[0].length, _t("The cashflow_amounts and cashflow_dates ranges must have the same dimensions."));
-}
-function assertCashFlowsHavePositiveAndNegativesValues(cashFlow) {
-    assert(() => cashFlow.some((val) => val > 0) && cashFlow.some((val) => val < 0), _t("There must be both positive and negative values in cashflow_amounts."));
-}
-function assertEveryDateGreaterThanFirstDateOfCashFlowDates(dates) {
-    assert(() => dates.every((date) => date >= dates[0]), _t("All the dates should be greater or equal to the first date in cashflow_dates (%s).", dates[0].toString()));
+    return endDate.getTime() <= startDatePlusOneYear.getTime();
 }
 
 const DEFAULT_DAY_COUNT_CONVENTION = 0;
@@ -31224,7 +31555,7 @@ function newtonMethod(func, derivFunc, startValue, maxIterations, epsMax = 1e-10
     do {
         y = func(x);
         if (isNaN(y)) {
-            assert(() => count < maxIterations && nanFallback !== undefined, _t("Function [[FUNCTION_NAME]] didn't find any result."));
+            assert(count < maxIterations && nanFallback !== undefined, _t("Function [[FUNCTION_NAME]] didn't find any result."));
             count++;
             x = nanFallback(previousFallback);
             previousFallback = x;
@@ -31234,7 +31565,7 @@ function newtonMethod(func, derivFunc, startValue, maxIterations, epsMax = 1e-10
         xDelta = Math.abs(newX - x);
         x = newX;
         yEqual0 = xDelta < epsMax || Math.abs(y) < epsMax;
-        assert(() => count < maxIterations, _t("Function [[FUNCTION_NAME]] didn't find any result."));
+        assert(count < maxIterations, _t("Function [[FUNCTION_NAME]] didn't find any result."));
         count++;
     } while (!yEqual0);
     return x;
@@ -31257,11 +31588,21 @@ const ACCRINTM = {
         const _redemption = toNumber(redemption, this.locale);
         const _rate = toNumber(rate, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertIssuePositiveOrZero(start);
-        assertSettlementAndIssueDatesAreValid(end, start);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assertRedemptionStrictlyPositive(_redemption);
-        assertRateStrictlyPositive(_rate);
+        if (start < 0) {
+            return new EvaluationError(expectIssuePositiveOrZero(start));
+        }
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_redemption <= 0) {
+            return new EvaluationError(expectRedemptionStrictlyPositive(_redemption));
+        }
+        if (_rate <= 0) {
+            return new EvaluationError(expectRateStrictlyPositive(_rate));
+        }
         const yearFrac = getYearFrac(start, end, _dayCountConvention);
         return _redemption * _rate * yearFrac;
     },
@@ -31290,14 +31631,30 @@ const AMORLINC = {
         const _period = toNumber(period, this.locale);
         const _rate = toNumber(rate, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertCostStrictlyPositive(_cost);
-        assertPurchaseDatePositiveOrZero(_purchaseDate);
-        assertSalvagePositiveOrZero(_salvage);
-        assertSalvageSmallerOrEqualThanCost(_salvage, _cost);
-        assertPeriodPositiveOrZero(_period);
-        assertRateStrictlyPositive(_rate);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assert(() => _purchaseDate <= _firstPeriodEnd, _t("The purchase_date (%s) must be before the first_period_end (%s).", _purchaseDate.toString(), _firstPeriodEnd.toString()));
+        if (_cost <= 0) {
+            return new EvaluationError(expectCostStrictlyPositive(_cost));
+        }
+        if (_purchaseDate < 0) {
+            return new EvaluationError(expectPurchaseDatePositiveOrZero(_purchaseDate));
+        }
+        if (_salvage < 0) {
+            return new EvaluationError(expectSalvagePositiveOrZero(_salvage));
+        }
+        if (_salvage > _cost) {
+            return new EvaluationError(expectSalvageSmallerOrEqualThanCost(_salvage, _cost));
+        }
+        if (_period < 0) {
+            return new EvaluationError(expectPeriodPositiveOrZero(_period));
+        }
+        if (_rate <= 0) {
+            return new EvaluationError(expectRateStrictlyPositive(_rate));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_purchaseDate > _firstPeriodEnd) {
+            return new EvaluationError(expectPurchaseDateBeforeFirstPeriodEnd(_purchaseDate, _firstPeriodEnd));
+        }
         /**
          * https://wiki.documentfoundation.org/Documentation/Calc_Functions/AMORLINC
          *
@@ -31335,14 +31692,20 @@ const COUPDAYS = {
         const end = Math.trunc(toNumber(maturity, this.locale));
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
         // https://wiki.documentfoundation.org/Documentation/Calc_Functions/COUPDAYS
         if (_dayCountConvention === 1) {
             const before = COUPPCD.compute.bind(this)(settlement, maturity, frequency, dayCountConvention).value;
             const after = COUPNCD.compute.bind(this)(settlement, maturity, frequency, dayCountConvention).value;
-            return after - before;
+            return toNumber(after, this.locale) - toNumber(before, this.locale);
         }
         const daysInYear = _dayCountConvention === 3 ? 365 : 360;
         return daysInYear / _frequency;
@@ -31361,19 +31724,26 @@ const COUPDAYBS = {
         const end = Math.trunc(toNumber(maturity, this.locale));
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
         const couponBeforeStart = COUPPCD.compute.bind(this)(settlement, maturity, frequency, dayCountConvention).value;
+        const _couponBeforeStart = toNumber(couponBeforeStart, this.locale);
         if ([1, 2, 3].includes(_dayCountConvention)) {
-            return start - couponBeforeStart;
+            return start - _couponBeforeStart;
         }
         if (_dayCountConvention === 4) {
-            const yearFrac = getYearFrac(couponBeforeStart, start, _dayCountConvention);
+            const yearFrac = getYearFrac(_couponBeforeStart, start, _dayCountConvention);
             return Math.round(yearFrac * 360);
         }
         const startDate = toJsDate(start, this.locale);
-        const dateCouponBeforeStart = toJsDate(couponBeforeStart, this.locale);
+        const dateCouponBeforeStart = toJsDate(_couponBeforeStart, this.locale);
         const y1 = dateCouponBeforeStart.getFullYear();
         const y2 = startDate.getFullYear();
         const m1 = dateCouponBeforeStart.getMonth() + 1; // +1 because months in js start at 0 and it's confusing
@@ -31417,20 +31787,27 @@ const COUPDAYSNC = {
         const end = Math.trunc(toNumber(maturity, this.locale));
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
         const couponAfterStart = COUPNCD.compute.bind(this)(settlement, maturity, frequency, dayCountConvention).value;
+        const _couponAfterStart = toNumber(couponAfterStart, this.locale);
         if ([1, 2, 3].includes(_dayCountConvention)) {
-            return couponAfterStart - start;
+            return _couponAfterStart - start;
         }
         if (_dayCountConvention === 4) {
-            const yearFrac = getYearFrac(start, couponAfterStart, _dayCountConvention);
+            const yearFrac = getYearFrac(start, _couponAfterStart, _dayCountConvention);
             return Math.round(yearFrac * 360);
         }
         const coupDayBs = COUPDAYBS.compute.bind(this)(settlement, maturity, frequency, dayCountConvention);
         const coupDays = COUPDAYS.compute.bind(this)(settlement, maturity, frequency, dayCountConvention);
-        return coupDays - coupDayBs;
+        return toNumber(coupDays, this.locale) - toNumber(coupDayBs, this.locale);
     },
     isExported: true,
 };
@@ -31446,12 +31823,18 @@ const COUPNCD = {
         const end = Math.trunc(toNumber(maturity, this.locale));
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
         const monthsPerPeriod = 12 / _frequency;
         const coupNum = COUPNUM.compute.bind(this)(settlement, maturity, frequency, dayCountConvention);
-        const date = addMonthsToDate(toJsDate(end, this.locale), -(coupNum - 1) * monthsPerPeriod, true);
+        const date = addMonthsToDate(toJsDate(end, this.locale), -(toNumber(coupNum, this.locale) - 1) * monthsPerPeriod, true);
         return {
             value: jsDateToRoundNumber(date),
             format: this.locale.dateFormat,
@@ -31471,9 +31854,15 @@ const COUPNUM = {
         const end = Math.trunc(toNumber(maturity, this.locale));
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
         let num = 1;
         let currentDate = end;
         const monthsPerPeriod = 12 / _frequency;
@@ -31497,9 +31886,15 @@ const COUPPCD = {
         const end = Math.trunc(toNumber(maturity, this.locale));
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
         const monthsPerPeriod = 12 / _frequency;
         const coupNum = COUPNUM.compute.bind(this)(settlement, maturity, frequency, dayCountConvention);
         const date = addMonthsToDate(toJsDate(end, this.locale), -coupNum * monthsPerPeriod, true);
@@ -31530,9 +31925,27 @@ const CUMIPMT = {
         const pv = toNumber(presentValue, this.locale);
         const n = toNumber(numberOfPeriods, this.locale);
         const type = toBoolean(endOrBeginning) ? 1 : 0;
-        assertFirstAndLastPeriodsAreValid(first, last, n);
-        assertRateStrictlyPositive(r);
-        assertPresentValueStrictlyPositive(pv);
+        if (n <= 0) {
+            return new EvaluationError(expectNumberOfPeriodsStrictlyPositive(n));
+        }
+        if (first <= 0) {
+            return new EvaluationError(expectFirstPeriodStrictlyPositive(first));
+        }
+        if (last <= 0) {
+            return new EvaluationError(expectLastPeriodStrictlyPositive(last));
+        }
+        if (first > last) {
+            return new EvaluationError(expectFirstPeriodSmallerOrEqualLastPeriod(first, last));
+        }
+        if (last > n) {
+            return new EvaluationError(expectLastPeriodSmallerOrEqualNumberOfPeriods(last, n));
+        }
+        if (r <= 0) {
+            return new EvaluationError(expectRateStrictlyPositive(r));
+        }
+        if (pv <= 0) {
+            return new EvaluationError(expectPresentValueStrictlyPositive(pv));
+        }
         let cumSum = 0;
         for (let i = first; i <= last; i++) {
             cumSum += impt(r, i, n, pv, 0, type);
@@ -31561,9 +31974,27 @@ const CUMPRINC = {
         const pv = toNumber(presentValue, this.locale);
         const n = toNumber(numberOfPeriods, this.locale);
         const type = toBoolean(endOrBeginning) ? 1 : 0;
-        assertFirstAndLastPeriodsAreValid(first, last, n);
-        assertRateStrictlyPositive(r);
-        assertPresentValueStrictlyPositive(pv);
+        if (n <= 0) {
+            return new EvaluationError(expectNumberOfPeriodsStrictlyPositive(n));
+        }
+        if (first <= 0) {
+            return new EvaluationError(expectFirstPeriodStrictlyPositive(first));
+        }
+        if (last <= 0) {
+            return new EvaluationError(expectLastPeriodStrictlyPositive(last));
+        }
+        if (first > last) {
+            return new EvaluationError(expectFirstPeriodSmallerOrEqualLastPeriod(first, last));
+        }
+        if (last > n) {
+            return new EvaluationError(expectLastPeriodSmallerOrEqualNumberOfPeriods(last, n));
+        }
+        if (r <= 0) {
+            return new EvaluationError(expectRateStrictlyPositive(r));
+        }
+        if (pv <= 0) {
+            return new EvaluationError(expectPresentValueStrictlyPositive(pv));
+        }
         let cumSum = 0;
         for (let i = first; i <= last; i++) {
             cumSum += ppmt(r, i, n, pv, 0, type);
@@ -31592,12 +32023,24 @@ const DB = {
         const _period = Math.trunc(toNumber(period, this.locale));
         const _month = args.length ? Math.trunc(toNumber(args[0], this.locale)) : 12;
         const lifeLimit = _life + (_month === 12 ? 0 : 1);
-        assertCostPositiveOrZero(_cost);
-        assertSalvagePositiveOrZero(_salvage);
-        assertPeriodStrictlyPositive(_period);
-        assertLifeStrictlyPositive(_life);
-        assert(() => 1 <= _month && _month <= 12, _t("The month (%s) must be between 1 and 12 inclusive.", _month.toString()));
-        assert(() => _period <= lifeLimit, _t("The period (%s) must be less than or equal to %s.", _period.toString(), lifeLimit.toString()));
+        if (_cost < 0) {
+            return new EvaluationError(expectCostPositiveOrZero(_cost));
+        }
+        if (_salvage < 0) {
+            return new EvaluationError(expectSalvagePositiveOrZero(_salvage));
+        }
+        if (_period <= 0) {
+            return new EvaluationError(expectPeriodStrictlyPositive(_period));
+        }
+        if (_life <= 0) {
+            return new EvaluationError(expectLifeStrictlyPositive(_life));
+        }
+        if (1 > _month || _month > 12) {
+            return new EvaluationError(expectMonthBetweenOneAndTwelve(_month));
+        }
+        if (_period > lifeLimit) {
+            return new EvaluationError(expectPeriodLessOrEqualToLifeLimit(_period, lifeLimit));
+        }
         const monthPart = _month / 12;
         let rate = 1 - Math.pow(_salvage / _cost, 1 / _life);
         // round to 3 decimal places
@@ -31622,27 +32065,7 @@ const DB = {
 // DDB
 // -----------------------------------------------------------------------------
 const DEFAULT_DDB_DEPRECIATION_FACTOR = 2;
-function ddb(cost, salvage, life, period, factor) {
-    assertCostPositiveOrZero(cost);
-    assertSalvagePositiveOrZero(salvage);
-    assertPeriodStrictlyPositive(period);
-    assertLifeStrictlyPositive(life);
-    assertPeriodSmallerOrEqualToLife(period, life);
-    assertDeprecationFactorStrictlyPositive(factor);
-    if (cost === 0 || salvage >= cost)
-        return 0;
-    const deprecFactor = factor / life;
-    if (deprecFactor > 1) {
-        return period === 1 ? cost - salvage : 0;
-    }
-    if (period <= 1) {
-        return cost * deprecFactor;
-    }
-    const previousCost = cost * Math.pow(1 - deprecFactor, period - 1);
-    const nextCost = cost * Math.pow(1 - deprecFactor, period);
-    const deprec = nextCost < salvage ? previousCost - salvage : previousCost - nextCost;
-    return Math.max(deprec, 0);
-}
+const DEFAULT_DDB_FORMAT = "#,##0.00";
 const DDB = {
     description: _t("Depreciation via double-declining balance method."),
     args: [
@@ -31658,9 +32081,43 @@ const DDB = {
         const _life = toNumber(life, this.locale);
         const _period = toNumber(period, this.locale);
         const _factor = toNumber(factor, this.locale);
+        if (_cost < 0) {
+            return new EvaluationError(expectCostPositiveOrZero(_cost));
+        }
+        if (_salvage < 0) {
+            return new EvaluationError(expectSalvagePositiveOrZero(_salvage));
+        }
+        if (_period <= 0) {
+            return new EvaluationError(expectPeriodStrictlyPositive(_period));
+        }
+        if (_life <= 0) {
+            return new EvaluationError(expectLifeStrictlyPositive(_life));
+        }
+        if (_period > _life) {
+            return new EvaluationError(expectPeriodSmallerOrEqualToLife(_period, _life));
+        }
+        if (_factor <= 0) {
+            return new EvaluationError(expectDeprecationFactorStrictlyPositive(_factor));
+        }
+        if (_cost === 0 || _salvage >= _cost) {
+            return { value: 0, format: DEFAULT_DDB_FORMAT };
+        }
+        const deprecFactor = _factor / _life;
+        if (deprecFactor > 1) {
+            return { value: _period === 1 ? _cost - _salvage : 0, format: DEFAULT_DDB_FORMAT };
+        }
+        if (_period <= 1) {
+            return {
+                value: _cost * deprecFactor,
+                format: DEFAULT_DDB_FORMAT,
+            };
+        }
+        const previousCost = _cost * Math.pow(1 - deprecFactor, _period - 1);
+        const nextCost = _cost * Math.pow(1 - deprecFactor, _period);
+        const deprec = nextCost < _salvage ? previousCost - _salvage : previousCost - nextCost;
         return {
-            value: ddb(_cost, _salvage, _life, _period, _factor),
-            format: "#,##0.00",
+            value: Math.max(deprec, 0),
+            format: DEFAULT_DDB_FORMAT,
         };
     },
     isExported: true,
@@ -31684,10 +32141,18 @@ const DISC = {
         const _price = toNumber(price, this.locale);
         const _redemption = toNumber(redemption, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assertPriceStrictlyPositive(_price);
-        assertRedemptionStrictlyPositive(_redemption);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_price <= 0) {
+            return new EvaluationError(expectPriceStrictlyPositive(_price));
+        }
+        if (_redemption <= 0) {
+            return new EvaluationError(expectRedemptionStrictlyPositive(_redemption));
+        }
         /**
          * https://support.microsoft.com/en-us/office/disc-function-71fce9f3-3f05-4acf-a5a3-eac6ef4daa53
          *
@@ -31715,7 +32180,9 @@ const DOLLARDE = {
     compute: function (fractionalPrice, unit) {
         const price = toNumber(fractionalPrice, this.locale);
         const _unit = Math.trunc(toNumber(unit, this.locale));
-        assert(() => _unit > 0, _t("The unit (%s) must be strictly positive.", _unit.toString()));
+        if (_unit <= 0) {
+            return new EvaluationError(expectUnitStrictlyPositive(_unit));
+        }
         const truncatedPrice = Math.trunc(price);
         const priceFractionalPart = price - truncatedPrice;
         const frac = 10 ** Math.ceil(Math.log10(_unit)) / _unit;
@@ -31735,7 +32202,9 @@ const DOLLARFR = {
     compute: function (decimalPrice, unit) {
         const price = toNumber(decimalPrice, this.locale);
         const _unit = Math.trunc(toNumber(unit, this.locale));
-        assert(() => _unit > 0, _t("The unit (%s) must be strictly positive.", _unit.toString()));
+        if (_unit <= 0) {
+            return new EvaluationError(expectUnitStrictlyPositive(_unit));
+        }
         const truncatedPrice = Math.trunc(price);
         const priceFractionalPart = price - truncatedPrice;
         const frac = _unit / 10 ** Math.ceil(Math.log10(_unit));
@@ -31763,11 +32232,21 @@ const DURATION = {
         const _yield = toNumber(securityYield, this.locale);
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assert(() => _rate >= 0, _t("The rate (%s) must be positive or null.", _rate.toString()));
-        assert(() => _yield >= 0, _t("The yield (%s) must be positive or null.", _yield.toString()));
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_rate < 0) {
+            return new EvaluationError(expectRatePositiveOrZero(_rate));
+        }
+        if (_yield < 0) {
+            return new EvaluationError(expectYieldPositiveOrZero(_yield));
+        }
         const years = getYearFrac(start, end, _dayCountConvention);
         const timeFirstYear = years - Math.trunc(years) || 1 / _frequency;
         const nbrCoupons = Math.ceil(years * _frequency);
@@ -31799,8 +32278,12 @@ const EFFECT = {
     compute: function (nominal_rate, periods_per_year) {
         const nominal = toNumber(nominal_rate, this.locale);
         const periods = Math.trunc(toNumber(periods_per_year, this.locale));
-        assert(() => nominal > 0, _t("The nominal rate (%s) must be strictly greater than 0.", nominal.toString()));
-        assert(() => periods > 0, _t("The number of periods by year (%s) must strictly greater than 0.", periods.toString()));
+        if (nominal <= 0) {
+            return new EvaluationError(expectNominalRateStrictlyPositive(nominal));
+        }
+        if (periods <= 0) {
+            return new EvaluationError(expectPeriodsByYearStrictlyPositive(periods));
+        }
         // https://en.wikipedia.org/wiki/Nominal_interest_rate#Nominal_versus_effective_interest_rate
         return Math.pow(1 + nominal / periods, periods) - 1;
     },
@@ -31874,10 +32357,18 @@ const INTRATE = {
         const _redemption = toNumber(redemption, this.locale);
         const _investment = toNumber(investment, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertInvestmentStrictlyPositive(_investment);
-        assertRedemptionStrictlyPositive(_redemption);
-        assertDayCountConventionIsValid(_dayCountConvention);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (_investment <= 0) {
+            return new EvaluationError(expectInvestmentStrictlyPositive(_investment));
+        }
+        if (_redemption <= 0) {
+            return new EvaluationError(expectRedemptionStrictlyPositive(_redemption));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
         /**
          * https://wiki.documentfoundation.org/Documentation/Calc_Functions/INTRATE
          *
@@ -31932,7 +32423,9 @@ const IRR = {
     ],
     compute: function (cashFlowAmounts, rateGuess = { value: DEFAULT_RATE_GUESS }) {
         const _rateGuess = toNumber(rateGuess, this.locale);
-        assertRateGuessStrictlyGreaterThanMinusOne(_rateGuess);
+        if (_rateGuess <= -1) {
+            return new EvaluationError(expectRateGuessStrictlyGreaterThanMinusOne(_rateGuess));
+        }
         // check that values contains at least one positive value and one negative value
         // and extract number present in the cashFlowAmount argument
         let positive = false;
@@ -31945,7 +32438,9 @@ const IRR = {
                 negative = true;
             amounts.push(amount);
         }, this.locale);
-        assert(() => positive && negative, _t("The cashflow_amounts must include negative and positive values."));
+        if (!positive || !negative) {
+            return new EvaluationError(expectCashFlowsHavePositiveAndNegativesValues);
+        }
         const firstAmount = amounts.shift();
         // The result of IRR is the rate at which the NPV() function will return zero with the given values.
         // This algorithm uses the Newton's method on the NPV function to determine the result
@@ -31996,7 +32491,9 @@ const ISPMT = {
         const period = toNumber(currentPeriod, this.locale);
         const nOfPeriods = toNumber(numberOfPeriods, this.locale);
         const investment = toNumber(presentValue, this.locale);
-        assert(() => nOfPeriods !== 0, _t("The number of periods must be different than 0.", nOfPeriods.toString()));
+        if (nOfPeriods === 0) {
+            return new EvaluationError(expectNumberOfPeriodDifferentFromZero(nOfPeriods));
+        }
         const currentInvestment = investment - investment * (period / nOfPeriods);
         return -1 * currentInvestment * interestRate;
     },
@@ -32019,7 +32516,7 @@ const MDURATION = {
         const duration = DURATION.compute.bind(this)(settlement, maturity, rate, securityYield, frequency, dayCountConvention);
         const y = toNumber(securityYield, this.locale);
         const k = Math.trunc(toNumber(frequency, this.locale));
-        return duration / (1 + y / k);
+        return toNumber(duration, this.locale) / (1 + y / k);
     },
     isExported: true,
 };
@@ -32069,7 +32566,9 @@ const MIRR = {
                 pv += amount / (fRate + 1) ** i;
             }
         }
-        assert(() => pv !== 0 && fv !== 0, _t("There must be both positive and negative values in cashflow_amounts."));
+        if (pv === 0 || fv === 0) {
+            return new EvaluationError(expectCashFlowsHavePositiveAndNegativesValues);
+        }
         const exponent = 1 / (n - 1);
         return (-fv / pv) ** exponent - 1;
     },
@@ -32087,8 +32586,12 @@ const NOMINAL = {
     compute: function (effective_rate, periods_per_year) {
         const effective = toNumber(effective_rate, this.locale);
         const periods = Math.trunc(toNumber(periods_per_year, this.locale));
-        assert(() => effective > 0, _t("The effective rate (%s) must must strictly greater than 0.", effective.toString()));
-        assert(() => periods > 0, _t("The number of periods by year (%s) must strictly greater than 0.", periods.toString()));
+        if (effective <= 0) {
+            return new EvaluationError(expectEffectiveRateStrictlyPositive(effective));
+        }
+        if (periods <= 0) {
+            return new EvaluationError(expectPeriodsByYearStrictlyPositive(periods));
+        }
         // https://en.wikipedia.org/wiki/Nominal_interest_rate#Nominal_versus_effective_interest_rate
         return (Math.pow(effective + 1, 1 / periods) - 1) * periods;
     },
@@ -32156,7 +32659,9 @@ const NPV = {
     // to do: replace by dollar format
     compute: function (discount, ...values) {
         const _discount = toNumber(discount, this.locale);
-        assert(() => _discount !== -1, _t("The discount (%s) must be different from -1.", _discount.toString()));
+        if (_discount === -1) {
+            return new EvaluationError(expectDiscountDifferentFromMinusOne(_discount));
+        }
         return {
             value: npvResult(_discount, 0, values, this.locale),
             format: "#,##0.00",
@@ -32178,9 +32683,15 @@ const PDURATION = {
         const _rate = toNumber(rate, this.locale);
         const _presentValue = toNumber(presentValue, this.locale);
         const _futureValue = toNumber(futureValue, this.locale);
-        assertRateStrictlyPositive(_rate);
-        assert(() => _presentValue > 0, _t("The present_value (%s) must be strictly positive.", _presentValue.toString()));
-        assert(() => _futureValue > 0, _t("The future_value (%s) must be strictly positive.", _futureValue.toString()));
+        if (_rate <= 0) {
+            return new EvaluationError(expectRateStrictlyPositive(_rate));
+        }
+        if (_presentValue <= 0) {
+            return new EvaluationError(expectPresentValueStrictlyPositive(_presentValue));
+        }
+        if (_futureValue <= 0) {
+            return new EvaluationError(expectFutureValueStrictlyPositive(_futureValue));
+        }
         return (Math.log(_futureValue) - Math.log(_presentValue)) / Math.log(1 + _rate);
     },
     isExported: true,
@@ -32189,7 +32700,9 @@ const PDURATION = {
 // PMT
 // -----------------------------------------------------------------------------
 function pmt(r, n, pv, fv, t) {
-    assertNumberOfPeriodsStrictlyPositive(n);
+    if (n <= 0) {
+        throw new EvaluationError(expectNumberOfPeriodsStrictlyPositive(n));
+    }
     /**
      * https://wiki.documentfoundation.org/Documentation/Calc_Functions/PMT
      *
@@ -32227,8 +32740,12 @@ const PMT = {
 // PPMT
 // -----------------------------------------------------------------------------
 function ppmt(r, per, n, pValue, fValue, t) {
-    assertNumberOfPeriodsStrictlyPositive(n);
-    assert(() => per > 0 && per <= n, _t("The period must be between 1 and number_of_periods (%s)", n));
+    if (n <= 0) {
+        throw new EvaluationError(expectNumberOfPeriodsStrictlyPositive(n));
+    }
+    if (per <= 0 || per > n) {
+        throw new EvaluationError(expectPeriodBetweenOneAndNumberOfPeriods(n));
+    }
     const payment = pmt(r, n, pValue, fValue, t);
     if (t === 1 && per === 1)
         return payment;
@@ -32316,12 +32833,24 @@ const PRICE = {
         const _redemption = toNumber(redemption, this.locale);
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assert(() => _rate >= 0, _t("The rate (%s) must be positive or null.", _rate.toString()));
-        assert(() => _yield >= 0, _t("The yield (%s) must be positive or null.", _yield.toString()));
-        assertRedemptionStrictlyPositive(_redemption);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_rate < 0) {
+            return new EvaluationError(expectRatePositiveOrZero(_rate));
+        }
+        if (_yield < 0) {
+            return new EvaluationError(expectYieldPositiveOrZero(_yield));
+        }
+        if (_redemption <= 0) {
+            return new EvaluationError(expectRedemptionStrictlyPositive(_redemption));
+        }
         const years = getYearFrac(_settlement, _maturity, _dayCountConvention);
         const nbrRealCoupons = years * _frequency;
         const nbrFullCoupons = Math.ceil(nbrRealCoupons);
@@ -32361,10 +32890,18 @@ const PRICEDISC = {
         const _discount = toNumber(discount, this.locale);
         const _redemption = toNumber(redemption, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assertDiscountStrictlyPositive(_discount);
-        assertRedemptionStrictlyPositive(_redemption);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_discount <= 0) {
+            return new EvaluationError(expectDiscountStrictlyPositive(_discount));
+        }
+        if (_redemption <= 0) {
+            return new EvaluationError(expectRedemptionStrictlyPositive(_redemption));
+        }
         /**
          * https://support.microsoft.com/en-us/office/pricedisc-function-d06ad7c1-380e-4be7-9fd9-75e3079acfd3
          *
@@ -32399,11 +32936,21 @@ const PRICEMAT = {
         const _rate = toNumber(rate, this.locale);
         const _yield = toNumber(securityYield, this.locale);
         const _dayCount = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertSettlementAndIssueDatesAreValid(_settlement, _issue);
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertDayCountConventionIsValid(_dayCount);
-        assert(() => _rate >= 0, _t("The rate (%s) must be positive or null.", _rate.toString()));
-        assert(() => _yield >= 0, _t("The yield (%s) must be positive or null.", _yield.toString()));
+        if (_settlement <= _issue) {
+            return new EvaluationError(expectSettlementStrictlyGreaterThanIssue(_settlement, _issue));
+        }
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidDayCountConvention(_dayCount)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCount));
+        }
+        if (_rate < 0) {
+            return new EvaluationError(expectRatePositiveOrZero(_rate));
+        }
+        if (_yield < 0) {
+            return new EvaluationError(expectYieldPositiveOrZero(_yield));
+        }
         /**
          * https://support.microsoft.com/en-us/office/pricemat-function-52c3b4da-bc7e-476a-989f-a95f675cae77
          *
@@ -32461,9 +33008,15 @@ const RATE = {
         const guess = toNumber(rateGuess, this.locale) || RATE_GUESS_DEFAULT;
         let fv = toNumber(futureValue, this.locale);
         let pv = toNumber(presentValue, this.locale);
-        assertNumberOfPeriodsStrictlyPositive(n);
-        assert(() => [payment, pv, fv].some((val) => val > 0) && [payment, pv, fv].some((val) => val < 0), _t("There must be both positive and negative values in [payment_amount, present_value, future_value].", n.toString()));
-        assertRateGuessStrictlyGreaterThanMinusOne(guess);
+        if (n <= 0) {
+            return new EvaluationError(expectNumberOfPeriodsStrictlyPositive(n));
+        }
+        if (!havePositiveAndNegativeValues([payment, pv, fv])) {
+            return new EvaluationError(_t("There must be both positive and negative values in [payment_amount, present_value, future_value]."));
+        }
+        if (guess <= -1) {
+            return new EvaluationError(expectRateGuessStrictlyGreaterThanMinusOne(guess));
+        }
         fv -= payment * type;
         pv += payment * type;
         // https://github.com/apache/openoffice/blob/trunk/main/sc/source/core/tool/interpr2.cxx
@@ -32506,10 +33059,18 @@ const RECEIVED = {
         const _investment = toNumber(investment, this.locale);
         const _discount = toNumber(discount, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assertInvestmentStrictlyPositive(_investment);
-        assertDiscountStrictlyPositive(_discount);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_investment <= 0) {
+            return new EvaluationError(expectInvestmentStrictlyPositive(_investment));
+        }
+        if (_discount <= 0) {
+            return new EvaluationError(expectDiscountStrictlyPositive(_discount));
+        }
         /**
          * https://support.microsoft.com/en-us/office/received-function-7a3f8b93-6611-4f81-8576-828312c9b5e5
          *
@@ -32540,7 +33101,9 @@ const RRI = {
         const n = toNumber(numberOfPeriods, this.locale);
         const pv = toNumber(presentValue, this.locale);
         const fv = toNumber(futureValue, this.locale);
-        assertNumberOfPeriodsStrictlyPositive(n);
+        if (n <= 0) {
+            return new EvaluationError(expectNumberOfPeriodsStrictlyPositive(n));
+        }
         /**
          * https://support.microsoft.com/en-us/office/rri-function-6f5822d8-7ef1-4233-944c-79e8172930f4
          *
@@ -32589,9 +33152,15 @@ const SYD = {
         const _salvage = toNumber(salvage, this.locale);
         const _life = toNumber(life, this.locale);
         const _period = toNumber(period, this.locale);
-        assertPeriodStrictlyPositive(_period);
-        assertLifeStrictlyPositive(_life);
-        assertPeriodSmallerOrEqualToLife(_period, _life);
+        if (_period <= 0) {
+            return new EvaluationError(expectPeriodStrictlyPositive(_period));
+        }
+        if (_life <= 0) {
+            return new EvaluationError(expectLifeStrictlyPositive(_life));
+        }
+        if (_period > _life) {
+            return new EvaluationError(expectPeriodSmallerOrEqualToLife(_period, _life));
+        }
         /**
          * This deprecation method use the sum of digits of the periods of the life as the deprecation factor.
          * For example for a life = 5, we have a deprecation factor or 1 + 2 + 3 + 4 + 5 = 15 = life * (life + 1) / 2 = F.
@@ -32636,10 +33205,18 @@ const TBILLPRICE = {
         const start = Math.trunc(toNumber(settlement, this.locale));
         const end = Math.trunc(toNumber(maturity, this.locale));
         const disc = toNumber(discount, this.locale);
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertSettlementLessThanOneYearBeforeMaturity(start, end, this.locale);
-        assertDiscountStrictlyPositive(disc);
-        assertDiscountStrictlySmallerThanOne(disc);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (!isSettlementLessThanOneYearBeforeMaturity(start, end, this.locale)) {
+            return new EvaluationError(expectSettlementLessThanOneYearBeforeMaturity(start, end));
+        }
+        if (disc <= 0) {
+            return new EvaluationError(expectDiscountStrictlyPositive(disc));
+        }
+        if (disc >= 1) {
+            return new EvaluationError(expectDiscountStrictlySmallerThanOne(disc));
+        }
         return tBillPrice(start, end, disc);
     },
     isExported: true,
@@ -32658,10 +33235,18 @@ const TBILLEQ = {
         const start = Math.trunc(toNumber(settlement, this.locale));
         const end = Math.trunc(toNumber(maturity, this.locale));
         const disc = toNumber(discount, this.locale);
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertSettlementLessThanOneYearBeforeMaturity(start, end, this.locale);
-        assertDiscountStrictlyPositive(disc);
-        assertDiscountStrictlySmallerThanOne(disc);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (!isSettlementLessThanOneYearBeforeMaturity(start, end, this.locale)) {
+            return new EvaluationError(expectSettlementLessThanOneYearBeforeMaturity(start, end));
+        }
+        if (disc <= 0) {
+            return new EvaluationError(expectDiscountStrictlyPositive(disc));
+        }
+        if (disc >= 1) {
+            return new EvaluationError(expectDiscountStrictlySmallerThanOne(disc));
+        }
         /**
          * https://support.microsoft.com/en-us/office/tbilleq-function-2ab72d90-9b4d-4efe-9fc2-0f81f2c19c8c
          *
@@ -32715,9 +33300,15 @@ const TBILLYIELD = {
         const start = Math.trunc(toNumber(settlement, this.locale));
         const end = Math.trunc(toNumber(maturity, this.locale));
         const p = toNumber(price, this.locale);
-        assertMaturityAndSettlementDatesAreValid(start, end);
-        assertSettlementLessThanOneYearBeforeMaturity(start, end, this.locale);
-        assertPriceStrictlyPositive(p);
+        if (start >= end) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(start, end));
+        }
+        if (!isSettlementLessThanOneYearBeforeMaturity(start, end, this.locale)) {
+            return new EvaluationError(expectSettlementLessThanOneYearBeforeMaturity(start, end));
+        }
+        if (p <= 0) {
+            return new EvaluationError(expectPriceStrictlyPositive(p));
+        }
         /**
          * https://support.microsoft.com/en-us/office/tbillyield-function-6d381232-f4b0-4cd5-8e97-45b9c03468ba
          *
@@ -32763,10 +33354,30 @@ const VDB = {
         const _endPeriod = Math.trunc(toNumber(endPeriod, this.locale));
         const _factor = toNumber(factor, this.locale);
         const _noSwitch = toBoolean(noSwitch);
-        assertCostPositiveOrZero(_cost);
-        assertSalvagePositiveOrZero(_salvage);
-        assertStartAndEndPeriodAreValid(_startPeriod, _endPeriod, _life);
-        assertDeprecationFactorStrictlyPositive(_factor);
+        if (_cost < 0) {
+            return new EvaluationError(expectCostPositiveOrZero(_cost));
+        }
+        if (_salvage < 0) {
+            return new EvaluationError(expectSalvagePositiveOrZero(_salvage));
+        }
+        if (_life <= 0) {
+            return new EvaluationError(expectLifeStrictlyPositive(_life));
+        }
+        if (_startPeriod < 0) {
+            return new EvaluationError(expectStartPeriodPositiveOrZero(_startPeriod));
+        }
+        if (_endPeriod < 0) {
+            return new EvaluationError(expectEndPeriodPositiveOrZero(_endPeriod));
+        }
+        if (_startPeriod > _endPeriod) {
+            return new EvaluationError(expectStartPeriodSmallerOrEqualEndPeriod(_startPeriod, _endPeriod));
+        }
+        if (_endPeriod > _life) {
+            return new EvaluationError(expectEndPeriodSmallerOrEqualToLife(_endPeriod, _life));
+        }
+        if (_factor <= 0) {
+            return new EvaluationError(expectDeprecationFactorStrictlyPositive(_factor));
+        }
         if (_cost === 0)
             return 0;
         if (_salvage >= _cost) {
@@ -32816,12 +33427,20 @@ const XIRR = {
     ],
     compute: function (cashflowAmounts, cashflowDates, rateGuess = { value: RATE_GUESS_DEFAULT }) {
         const guess = toNumber(rateGuess, this.locale);
+        if (!areSameDimensions(cashflowAmounts, cashflowDates)) {
+            return new EvaluationError(expectCashFlowsAndDatesHaveSameDimension);
+        }
         const _cashFlows = cashflowAmounts.flat().map((val) => toNumber(val, this.locale));
         const _dates = cashflowDates.flat().map((val) => toNumber(val, this.locale));
-        assertCashFlowsAndDatesHaveSameDimension(cashflowAmounts, cashflowDates);
-        assertCashFlowsHavePositiveAndNegativesValues(_cashFlows);
-        assertEveryDateGreaterThanFirstDateOfCashFlowDates(_dates);
-        assertRateGuessStrictlyGreaterThanMinusOne(guess);
+        if (!havePositiveAndNegativeValues(_cashFlows)) {
+            return new EvaluationError(expectCashFlowsHavePositiveAndNegativesValues);
+        }
+        if (_dates.some((date) => date < _dates[0])) {
+            return new EvaluationError(expectEveryDateGreaterThanFirstDateOfCashFlowDates(_dates[0]));
+        }
+        if (guess <= -1) {
+            return new EvaluationError(expectRateGuessStrictlyGreaterThanMinusOne(guess));
+        }
         const map = new Map();
         for (const i of range(0, _dates.length)) {
             const date = _dates[i];
@@ -32886,20 +33505,21 @@ const XNPV = {
     ],
     compute: function (discount, cashflowAmounts, cashflowDates) {
         const rate = toNumber(discount, this.locale);
-        const _cashFlows = isMatrix(cashflowAmounts)
-            ? cashflowAmounts.flat().map((data) => strictToNumber(data, this.locale))
-            : [strictToNumber(cashflowAmounts, this.locale)];
-        const _dates = isMatrix(cashflowDates)
-            ? cashflowDates.flat().map((data) => strictToNumber(data, this.locale))
-            : [strictToNumber(cashflowDates, this.locale)];
-        if (isMatrix(cashflowDates) && isMatrix(cashflowAmounts)) {
-            assertCashFlowsAndDatesHaveSameDimension(cashflowAmounts, cashflowDates);
+        if (!areSameDimensions(cashflowAmounts, cashflowDates)) {
+            return new EvaluationError(expectCashFlowsAndDatesHaveSameDimension);
         }
-        else {
-            assert(() => _cashFlows.length === _dates.length, _t("There must be the same number of values in cashflow_amounts and cashflow_dates."));
+        const _cashFlows = toMatrix(cashflowAmounts)
+            .flat()
+            .map((val) => strictToNumber(val, this.locale));
+        const _dates = toMatrix(cashflowDates)
+            .flat()
+            .map((val) => strictToNumber(val, this.locale));
+        if (_dates.some((date) => date < _dates[0])) {
+            return new EvaluationError(expectEveryDateGreaterThanFirstDateOfCashFlowDates(_dates[0]));
+        }
+        if (rate <= 0) {
+            return new EvaluationError(expectRateStrictlyPositive(rate));
         }
-        assertEveryDateGreaterThanFirstDateOfCashFlowDates(_dates);
-        assertRateStrictlyPositive(rate);
         if (_cashFlows.length === 1)
             return _cashFlows[0];
         // aggregate values of the same date
@@ -32959,12 +33579,24 @@ const YIELD = {
         const _redemption = toNumber(redemption, this.locale);
         const _frequency = Math.trunc(toNumber(frequency, this.locale));
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertCouponFrequencyIsValid(_frequency);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assert(() => _rate >= 0, _t("The rate (%s) must be positive or null.", _rate.toString()));
-        assertPriceStrictlyPositive(_price);
-        assertRedemptionStrictlyPositive(_redemption);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidFrequency(_frequency)) {
+            return new EvaluationError(expectCouponFrequencyIsValid(_frequency));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_rate < 0) {
+            return new EvaluationError(expectRatePositiveOrZero(_rate));
+        }
+        if (_price <= 0) {
+            return new EvaluationError(expectPriceStrictlyPositive(_price));
+        }
+        if (_redemption <= 0) {
+            return new EvaluationError(expectRedemptionStrictlyPositive(_redemption));
+        }
         const years = getYearFrac(_settlement, _maturity, _dayCountConvention);
         const nbrRealCoupons = years * _frequency;
         const nbrFullCoupons = Math.ceil(nbrRealCoupons);
@@ -33031,10 +33663,18 @@ const YIELDDISC = {
         const _price = toNumber(price, this.locale);
         const _redemption = toNumber(redemption, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assertPriceStrictlyPositive(_price);
-        assertRedemptionStrictlyPositive(_redemption);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_price <= 0) {
+            return new EvaluationError(expectPriceStrictlyPositive(_price));
+        }
+        if (_redemption <= 0) {
+            return new EvaluationError(expectRedemptionStrictlyPositive(_redemption));
+        }
         /**
          * https://wiki.documentfoundation.org/Documentation/Calc_Functions/YIELDDISC
          *
@@ -33068,11 +33708,21 @@ const YIELDMAT = {
         const _rate = toNumber(rate, this.locale);
         const _price = toNumber(price, this.locale);
         const _dayCountConvention = Math.trunc(toNumber(dayCountConvention, this.locale));
-        assertMaturityAndSettlementDatesAreValid(_settlement, _maturity);
-        assertDayCountConventionIsValid(_dayCountConvention);
-        assert(() => _settlement >= _issue, _t("The settlement (%s) must be greater than or equal to the issue (%s).", _settlement.toString(), _issue.toString()));
-        assert(() => _rate >= 0, _t("The rate (%s) must be positive or null.", _rate.toString()));
-        assertPriceStrictlyPositive(_price);
+        if (_settlement >= _maturity) {
+            return new EvaluationError(expectMaturityStrictlyGreaterThanSettlement(_settlement, _maturity));
+        }
+        if (isInvalidDayCountConvention(_dayCountConvention)) {
+            return new EvaluationError(expectDayCountConventionIsValid(_dayCountConvention));
+        }
+        if (_settlement < _issue) {
+            return new EvaluationError(expectSettlementGreaterOrEqualToIssue(_settlement, _issue));
+        }
+        if (_rate < 0) {
+            return new EvaluationError(expectRatePositiveOrZero(_rate));
+        }
+        if (_price <= 0) {
+            return new EvaluationError(expectPriceStrictlyPositive(_price));
+        }
         const issueToMaturity = getYearFrac(_issue, _maturity, _dayCountConvention);
         const issueToSettlement = getYearFrac(_issue, _settlement, _dayCountConvention);
         const settlementToMaturity = getYearFrac(_settlement, _maturity, _dayCountConvention);
@@ -33806,7 +34456,9 @@ const CELL = {
     ],
     compute: function (info, reference) {
         const _info = toString(info).toLowerCase();
-        assert(() => CELL_INFO_TYPES.includes(_info), _t("The info_type should be one of %s.", CELL_INFO_TYPES.join(", ")));
+        if (!CELL_INFO_TYPES.includes(_info)) {
+            return new EvaluationError(_t("The info_type should be one of %s.", CELL_INFO_TYPES.join(", ")));
+        }
         const sheetId = this.__originSheetId;
         const _reference = toString(reference);
         const topLeftReference = _reference.includes(":") ? _reference.split(":")[0] : _reference;
@@ -33975,7 +34627,9 @@ const AND = {
     ],
     compute: function (...logicalExpressions) {
         const { result, foundBoolean } = boolAnd(logicalExpressions);
-        assert(() => foundBoolean, _t("[[FUNCTION_NAME]] has no valid input data."));
+        if (!foundBoolean) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+        }
         return result;
     },
     isExported: true,
@@ -34007,7 +34661,7 @@ const IF = {
             return { value: "" };
         }
         if (result.value === null) {
-            result.value = "";
+            return { ...result, value: "" };
         }
         return result;
     },
@@ -34028,7 +34682,7 @@ const IFERROR = {
             return { value: "" };
         }
         if (result.value === null) {
-            result.value = "";
+            return { ...result, value: "" };
         }
         return result;
     },
@@ -34049,7 +34703,7 @@ const IFNA = {
             return { value: "" };
         }
         if (result.value === null) {
-            result.value = "";
+            return { ...result, value: "" };
         }
         return result;
     },
@@ -34067,7 +34721,9 @@ const IFS = {
         arg("value2 (any, repeating)", _t("Additional values to be returned if their corresponding conditions are TRUE.")),
     ],
     compute: function (...values) {
-        assert(() => values.length % 2 === 0, _t("Wrong number of arguments. Expected an even number of arguments."));
+        if (values.length % 2 !== 0) {
+            return new EvaluationError(_t("Wrong number of arguments. Expected an even number of arguments."));
+        }
         for (let n = 0; n < values.length - 1; n += 2) {
             if (toBoolean(values[n]?.value)) {
                 const result = values[n + 1];
@@ -34075,7 +34731,7 @@ const IFS = {
                     return { value: "" };
                 }
                 if (result.value === null) {
-                    result.value = "";
+                    return { ...result, value: "" };
                 }
                 return result;
             }
@@ -34108,7 +34764,9 @@ const OR = {
     ],
     compute: function (...logicalExpressions) {
         const { result, foundBoolean } = boolOr(logicalExpressions);
-        assert(() => foundBoolean, _t("[[FUNCTION_NAME]] has no valid input data."));
+        if (!foundBoolean) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+        }
         return result;
     },
     isExported: true,
@@ -34169,7 +34827,9 @@ const XOR = {
             acc = acc ? !arg : arg;
             return true; // no stop condition
         });
-        assert(() => foundBoolean, _t("[[FUNCTION_NAME]] has no valid input data."));
+        if (!foundBoolean) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+        }
         return acc;
     },
     isExported: true,
@@ -34222,6 +34882,11 @@ function addPivotDependencies(evalContext, coreDefinition, forMeasures) {
         if (range === undefined || range.invalidXc || range.invalidSheetName) {
             throw new InvalidReferenceError();
         }
+        if (evalContext.__originCellPosition &&
+            range.sheetId === evalContext.__originSheetId &&
+            isZoneInside(positionToZone(evalContext.__originCellPosition), zone)) {
+            throw new CircularDependencyError();
+        }
         dependencies.push(range);
     }
     for (const measure of forMeasures) {
@@ -34259,10 +34924,16 @@ const ADDRESS = {
     compute: function (row, column, absoluteRelativeMode = { value: DEFAULT_ABSOLUTE_RELATIVE_MODE }, useA1Notation = { value: true }, sheet) {
         const rowNumber = strictToInteger(row, this.locale);
         const colNumber = strictToInteger(column, this.locale);
-        assertNumberGreaterThanOrEqualToOne(rowNumber);
-        assertNumberGreaterThanOrEqualToOne(colNumber);
+        if (rowNumber < 1) {
+            return new EvaluationError(expectNumberGreaterThanOrEqualToOne(rowNumber));
+        }
+        if (colNumber < 1) {
+            return new EvaluationError(expectNumberGreaterThanOrEqualToOne(colNumber));
+        }
         const _absoluteRelativeMode = strictToInteger(absoluteRelativeMode, this.locale);
-        assert(() => [1, 2, 3, 4].includes(_absoluteRelativeMode), expectNumberRangeError(1, 4, _absoluteRelativeMode));
+        if (![1, 2, 3, 4].includes(_absoluteRelativeMode)) {
+            return new EvaluationError(expectNumberRangeError(1, 4, _absoluteRelativeMode));
+        }
         const _useA1Notation = toBoolean(useA1Notation);
         let cellReference;
         if (_useA1Notation) {
@@ -34299,7 +34970,9 @@ const COLUMN = {
         const column = cellReference === undefined
             ? this.__originCellPosition?.col
             : toZone(cellReference.value).left;
-        assert(() => column !== undefined, "In this context, the function [[FUNCTION_NAME]] needs to have a cell or range in parameter.");
+        if (column === undefined) {
+            return new EvaluationError(_t("In this context, the function [[FUNCTION_NAME]] needs to have a cell or range in parameter."));
+        }
         return column + 1;
     },
     isExported: true,
@@ -34333,7 +35006,9 @@ const HLOOKUP = {
     compute: function (searchKey, range, index, isSorted = { value: DEFAULT_IS_SORTED }) {
         const _index = Math.trunc(toNumber(index?.value, this.locale));
         const _range = toMatrix(range);
-        assert(() => 1 <= _index && _index <= _range[0].length, _t("[[FUNCTION_NAME]] evaluates to an out of bounds range."));
+        if (1 > _index || _index > _range[0].length) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] evaluates to an out of bounds range."));
+        }
         const getValueFromRange = (range, index) => range[index][0].value;
         const _isSorted = toBoolean(isSorted.value);
         const colIndex = _isSorted
@@ -34361,10 +35036,12 @@ const INDEX = {
         const _reference = toMatrix(reference);
         const _row = toNumber(row.value, this.locale);
         const _column = toNumber(column.value, this.locale);
-        assert(() => _column >= 0 &&
-            _column - 1 < _reference.length &&
-            _row >= 0 &&
-            _row - 1 < _reference[0].length, _t("Index out of range."));
+        if (_column < 0 ||
+            _column - 1 >= _reference.length ||
+            _row < 0 ||
+            _row - 1 >= _reference[0].length) {
+            return new EvaluationError(_t("Index out of range."));
+        }
         if (_row === 0 && _column === 0) {
             return _reference;
         }
@@ -34455,12 +35132,18 @@ const LOOKUP = {
         }
         nbCol = _resultRange.length;
         nbRow = _resultRange[0].length;
-        assert(() => nbCol === 1 || nbRow === 1, _t("The result_range must be a single row or a single column."));
+        if (nbCol !== 1 && nbRow !== 1) {
+            return new EvaluationError(_t("The result_range must be a single row or a single column."));
+        }
         if (nbCol > 1) {
-            assert(() => index <= nbCol - 1, _t("[[FUNCTION_NAME]] evaluates to an out of range row value %s.", (index + 1).toString()));
+            if (index > nbCol - 1) {
+                return new EvaluationError(_t("[[FUNCTION_NAME]] evaluates to an out of range row value %s.", index + 1));
+            }
             return _resultRange[index][0];
         }
-        assert(() => index <= nbRow - 1, _t("[[FUNCTION_NAME]] evaluates to an out of range column value %s.", (index + 1).toString()));
+        if (index > nbRow - 1) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] evaluates to an out of range column value %s.", index + 1));
+        }
         return _resultRange[0][index];
     },
     isExported: true,
@@ -34481,7 +35164,9 @@ const MATCH = {
         const _range = toMatrix(range);
         const nbCol = _range.length;
         const nbRow = _range[0].length;
-        assert(() => nbCol === 1 || nbRow === 1, _t("The range must be a single row or a single column."));
+        if (nbCol !== 1 && nbRow !== 1) {
+            return new EvaluationError(_t("The range must be a single row or a single column."));
+        }
         let index = -1;
         const getElement = nbCol === 1
             ? (_range, index) => _range[0][index].value
@@ -34522,7 +35207,9 @@ const ROW = {
         const row = cellReference === undefined
             ? this.__originCellPosition?.row
             : toZone(cellReference.value).top;
-        assert(() => row !== undefined, "In this context, the function [[FUNCTION_NAME]] needs to have a cell or range in parameter.");
+        if (row === undefined) {
+            return new EvaluationError(_t("In this context, the function [[FUNCTION_NAME]] needs to have a cell or range in parameter."));
+        }
         return row + 1;
     },
     isExported: true,
@@ -34556,7 +35243,9 @@ const VLOOKUP = {
     compute: function (searchKey, range, index, isSorted = { value: DEFAULT_IS_SORTED }) {
         const _index = Math.trunc(toNumber(index?.value, this.locale));
         const _range = toMatrix(range);
-        assert(() => 1 <= _index && _index <= _range.length, _t("[[FUNCTION_NAME]] evaluates to an out of bounds range."));
+        if (1 > _index || _index > _range.length) {
+            return new EvaluationError(_t("[[FUNCTION_NAME]] evaluates to an out of bounds range."));
+        }
         const getValueFromRange = (range, index) => range[0][index].value;
         const _isSorted = toBoolean(isSorted.value);
         const rowIndex = _isSorted
@@ -34601,14 +35290,24 @@ const XLOOKUP = {
         const _searchMode = Math.trunc(toNumber(searchMode.value, this.locale));
         const _lookupRange = toMatrix(lookupRange);
         const _returnRange = toMatrix(returnRange);
-        assert(() => _lookupRange.length === 1 || _lookupRange[0].length === 1, _t("lookup_range should be either a single row or single column."));
-        assert(() => [-1, 1, -2, 2].includes(_searchMode), _t("search_mode should be a value in [-1, 1, -2, 2]."));
-        assert(() => [-1, 0, 1, 2].includes(_matchMode), _t("match_mode should be a value in [-1, 0, 1, 2]."));
+        if (_lookupRange.length !== 1 && _lookupRange[0].length !== 1) {
+            return new EvaluationError(_t("lookup_range should be either a single row or single column."));
+        }
+        if (![1, -1, 2, -2].includes(_searchMode)) {
+            return new EvaluationError(_t("search_mode should be a value in [-1, 1, -2, 2]."));
+        }
+        if (![-1, 0, 1, 2].includes(_matchMode)) {
+            return new EvaluationError(_t("match_mode should be a value in [-1, 0, 1, 2]."));
+        }
         const lookupDirection = _lookupRange.length === 1 ? "col" : "row";
-        assert(() => !(_matchMode === 2 && [-2, 2].includes(_searchMode)), _t("the search and match mode combination is not supported for XLOOKUP evaluation."));
-        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 (_matchMode === 2 && [-2, 2].includes(_searchMode)) {
+            return new EvaluationError(_t("The search and match mode combination is not supported for XLOOKUP evaluation."));
+        }
+        if (lookupDirection === "col"
+            ? _returnRange[0].length !== _lookupRange[0].length
+            : _returnRange.length !== _lookupRange.length) {
+            return new EvaluationError(_t("return_range should have the same dimensions as lookup_range."));
+        }
         const getElement = lookupDirection === "col"
             ? (range, index) => range[0][index].value
             : (range, index) => range[index][0].value;
@@ -34800,12 +35499,16 @@ const OFFSET = {
         let offsetWidth = zone.right - zone.left + 1;
         if (height) {
             const _height = toNumber(height, this.locale);
-            assertPositive(_t("Height value is %(_height)s. It should be greater than or equal to 1.", { _height }), _height);
+            if (_height < 1) {
+                return new EvaluationError(_t("Height value is %(_height)s. It should be greater than or equal to 1.", { _height }));
+            }
             offsetHeight = _height;
         }
         if (width) {
             const _width = toNumber(width, this.locale);
-            assertPositive(_t("Width value is %(_width)s. It should be greater than or equal to 1.", { _width }), _width);
+            if (_width < 1) {
+                return new EvaluationError(_t("Width value is %(_width)s. It should be greater than or equal to 1.", { _width }));
+            }
             offsetWidth = _width;
         }
         const { sheetName } = splitReference(_cellReference);
@@ -34903,7 +35606,9 @@ const DIVIDE = {
     ],
     compute: function (dividend, divisor) {
         const _divisor = toNumber(divisor, this.locale);
-        assert(() => _divisor !== 0, _t("The divisor must be different from zero."), CellErrorType.DivisionByZero);
+        if (_divisor === 0) {
+            return new DivisionByZeroError(_t("The divisor must be different from zero."));
+        }
         return {
             value: toNumber(dividend, this.locale) / _divisor,
             format: dividend?.format || divisor?.format,
@@ -35474,7 +36179,9 @@ const CHAR = {
     ],
     compute: function (tableNumber) {
         const _tableNumber = Math.trunc(toNumber(tableNumber, this.locale));
-        assert(() => _tableNumber >= 1, _t("The table_number (%s) is out of range.", _tableNumber.toString()));
+        if (_tableNumber < 1) {
+            return new EvaluationError(_t("The table_number (%s) is out of range.", _tableNumber));
+        }
         return String.fromCharCode(_tableNumber);
     },
     isExported: true,
@@ -35539,10 +36246,16 @@ const FIND = {
         const _searchFor = toString(searchFor);
         const _textToSearch = toString(textToSearch);
         const _startingAt = toNumber(startingAt, this.locale);
-        assert(() => _textToSearch !== "", _t("The text_to_search must be non-empty."));
-        assert(() => _startingAt >= 1, _t("The starting_at (%s) must be greater than or equal to 1.", _startingAt.toString()));
+        if (_textToSearch === "") {
+            return new EvaluationError(_t("The text_to_search must be non-empty."));
+        }
+        if (_startingAt < 1) {
+            return new EvaluationError(_t("The starting_at (%s) must be greater than or equal to 1.", _startingAt));
+        }
         const result = _textToSearch.indexOf(_searchFor, _startingAt - 1);
-        assert(() => result >= 0, _t("In [[FUNCTION_NAME]] evaluation, cannot find '%s' within '%s'.", _searchFor.toString(), _textToSearch));
+        if (result === -1) {
+            return new EvaluationError(_t("In [[FUNCTION_NAME]] evaluation, cannot find '%s' within '%s'.", _searchFor, _textToSearch));
+        }
         return result + 1;
     },
     isExported: true,
@@ -35573,7 +36286,9 @@ const LEFT = {
     ],
     compute: function (text, ...args) {
         const _numberOfCharacters = args.length ? toNumber(args[0], this.locale) : 1;
-        assert(() => _numberOfCharacters >= 0, _t("The number_of_characters (%s) must be positive or null.", _numberOfCharacters.toString()));
+        if (_numberOfCharacters < 0) {
+            return new EvaluationError(_t("The number_of_characters (%s) must be positive or null.", _numberOfCharacters));
+        }
         return toString(text).substring(0, _numberOfCharacters);
     },
     isExported: true,
@@ -35614,8 +36329,12 @@ const MID = {
         const _text = toString(text);
         const _starting_at = toNumber(starting_at, this.locale);
         const _extract_length = toNumber(extract_length, this.locale);
-        assert(() => _starting_at >= 1, _t("The starting_at argument (%s) must be positive greater than one.", _starting_at.toString()));
-        assert(() => _extract_length >= 0, _t("The extract_length argument (%s) must be positive or null.", _extract_length.toString()));
+        if (_starting_at < 1) {
+            return new EvaluationError(_t("The starting_at argument (%s) must be positive greater than one.", _starting_at.toString()));
+        }
+        if (_extract_length < 0) {
+            return new EvaluationError(_t("The extract_length argument (%s) must be positive or null.", _extract_length));
+        }
         return _text.slice(_starting_at - 1, _starting_at + _extract_length - 1);
     },
     isExported: true,
@@ -35649,7 +36368,9 @@ const REPLACE = {
     ],
     compute: function (text, position, length, newText) {
         const _position = toNumber(position, this.locale);
-        assert(() => _position >= 1, _t("The position (%s) must be greater than or equal to 1.", _position.toString()));
+        if (_position < 1) {
+            return new EvaluationError(_t("The position (%s) must be greater than or equal to 1.", _position));
+        }
         const _text = toString(text);
         const _length = toNumber(length, this.locale);
         const _newText = toString(newText);
@@ -35668,7 +36389,9 @@ const RIGHT = {
     ],
     compute: function (text, ...args) {
         const _numberOfCharacters = args.length ? toNumber(args[0], this.locale) : 1;
-        assert(() => _numberOfCharacters >= 0, _t("The number_of_characters (%s) must be positive or null.", _numberOfCharacters.toString()));
+        if (_numberOfCharacters < 0) {
+            return new EvaluationError(_t("The number_of_characters (%s) must be positive or null.", _numberOfCharacters));
+        }
         const _text = toString(text);
         const stringLength = _text.length;
         return _text.substring(stringLength - _numberOfCharacters, stringLength);
@@ -35731,7 +36454,9 @@ const SPLIT = {
         const _delimiter = escapeRegExp(toString(delimiter));
         const _splitByEach = toBoolean(splitByEach);
         const _removeEmptyText = toBoolean(removeEmptyText);
-        assert(() => _delimiter.length > 0, _t("The _delimiter (%s) must be not be empty.", _delimiter));
+        if (_delimiter.length <= 0) {
+            return new EvaluationError(_t("The delimiter (%s) must be not be empty.", _delimiter));
+        }
         const regex = _splitByEach ? new RegExp(`[${_delimiter}]`, "g") : new RegExp(_delimiter, "g");
         let result = _text.split(regex);
         if (_removeEmptyText) {
@@ -35754,7 +36479,9 @@ const SUBSTITUTE = {
     ],
     compute: function (textToSearch, searchFor, replaceWith, occurrenceNumber) {
         const _occurrenceNumber = toNumber(occurrenceNumber, this.locale);
-        assert(() => _occurrenceNumber >= 0, _t("The occurrenceNumber (%s) must be positive or null.", _occurrenceNumber.toString()));
+        if (_occurrenceNumber < 0) {
+            return new EvaluationError(_t("The occurrenceNumber (%s) must be positive or null.", _occurrenceNumber));
+        }
         const _textToSearch = toString(textToSearch);
         const _searchFor = toString(searchFor);
         if (_searchFor === "") {
@@ -35914,6 +36641,13 @@ const functionNameRegex = /^[A-Z0-9\_\.]+$/;
 class FunctionRegistry extends Registry {
     mapping = {};
     add(name, addDescr) {
+        name = name.toUpperCase();
+        if (name in this.content) {
+            throw new Error(`${name} is already present in this registry!`);
+        }
+        return this.replace(name, addDescr);
+    }
+    replace(name, addDescr) {
         name = name.toUpperCase();
         if (!functionNameRegex.test(name)) {
             throw new Error(_t("Invalid function name %s. Function names can exclusively contain alphanumerical values separated by dots (.) or underscore (_)", name));
@@ -35921,7 +36655,7 @@ class FunctionRegistry extends Registry {
         const descr = addMetaInfoFromArg(name, addDescr);
         validateArguments(descr);
         this.mapping[name] = createComputeFunction(descr);
-        super.add(name, descr);
+        super.replace(name, descr);
         return this;
     }
 }
@@ -40435,6 +41169,13 @@ class Composer extends Component {
     openAssistant() {
         this.assistant.forcedClosed = false;
     }
+    onWheel(event) {
+        // detect if scrollbar is available
+        if (this.composerRef.el &&
+            this.composerRef.el.scrollHeight > this.composerRef.el.clientHeight) {
+            event.stopPropagation();
+        }
+    }
     // ---------------------------------------------------------------------------
     // Private
     // ---------------------------------------------------------------------------
@@ -40714,6 +41455,8 @@ class GridComposer extends Component {
     }
     get composerProps() {
         const { width, height } = this.env.model.getters.getSheetViewDimensionWithHeaders();
+        // Remove the wrapper border width
+        const maxHeight = this.props.gridDims.height - this.rect.y - 2 * COMPOSER_BORDER_WIDTH;
         return {
             rect: { ...this.rect },
             delimitation: {
@@ -40731,6 +41474,7 @@ class GridComposer extends Component {
             }),
             onInputContextMenu: this.props.onInputContextMenu,
             composerStore: this.composerStore,
+            inputStyle: `max-height: ${maxHeight}px;`,
         };
     }
     get containerStyle() {
@@ -44310,6 +45054,7 @@ class SelectionInputStore extends SpreadsheetStore {
     initialRanges;
     inputHasSingleRange;
     colors;
+    disabledRanges;
     mutators = [
         "resetWithRanges",
         "focusById",
@@ -44320,17 +45065,19 @@ class SelectionInputStore extends SpreadsheetStore {
         "reset",
         "confirm",
         "updateColors",
+        "updateDisabledRanges",
     ];
     ranges = [];
     focusedRangeIndex = null;
     inputSheetId;
     focusStore = this.get(FocusStore);
     highlightStore = this.get(HighlightStore);
-    constructor(get, initialRanges = [], inputHasSingleRange = false, colors = []) {
+    constructor(get, initialRanges = [], inputHasSingleRange = false, colors = [], disabledRanges = []) {
         super(get);
         this.initialRanges = initialRanges;
         this.inputHasSingleRange = inputHasSingleRange;
         this.colors = colors;
+        this.disabledRanges = disabledRanges;
         if (inputHasSingleRange && initialRanges.length > 1) {
             throw new Error("Input with a single range cannot be instantiated with several range references.");
         }
@@ -44447,6 +45194,9 @@ class SelectionInputStore extends SpreadsheetStore {
             color: colorGenerator.next(),
         }));
     }
+    updateDisabledRanges(disabledRanges) {
+        this.disabledRanges = disabledRanges;
+    }
     confirm() {
         for (const range of this.selectionInputs) {
             if (range.xc === "") {
@@ -44488,6 +45238,7 @@ class SelectionInputStore extends SpreadsheetStore {
                 : null,
             isFocused: this.hasMainFocus && this.focusedRangeIndex === index,
             isValidRange: input.xc === "" || this.getters.isRangeValid(input.xc),
+            disabled: this.disabledRanges?.[index],
         }));
     }
     get isResettable() {
@@ -44652,7 +45403,7 @@ css /* scss */ `
       input.o-invalid {
         background-color: ${ALERT_DANGER_BG};
       }
-      .error-icon {
+      .input-icon {
         right: 7px;
         top: 4px;
       }
@@ -44660,6 +45411,9 @@ css /* scss */ `
         cursor: move;
       }
     }
+    .o-disabled-ranges {
+      color: #888 !important;
+    }
     .o-button {
       flex-grow: 0;
     }
@@ -44692,6 +45446,8 @@ class SelectionInput extends Component {
         onSelectionReordered: { type: Function, optional: true },
         onSelectionRemoved: { type: Function, optional: true },
         colors: { type: Array, optional: true, default: [] },
+        disabledRanges: { type: Array, optional: true, default: [] },
+        disabledRangeTitle: { type: String, optional: true },
     };
     state = useState({
         isMissing: false,
@@ -44716,9 +45472,12 @@ class SelectionInput extends Component {
     get isResettable() {
         return this.store.isResettable;
     }
+    get hasDisabledRanges() {
+        return this.store.disabledRanges.some(Boolean);
+    }
     setup() {
         useEffect(() => this.focusedInput.el?.focus(), () => [this.focusedInput.el]);
-        this.store = useLocalStore(SelectionInputStore, this.props.ranges, this.props.hasSingleRange || false, this.props.colors);
+        this.store = useLocalStore(SelectionInputStore, this.props.ranges, this.props.hasSingleRange || false, this.props.colors, this.props.disabledRanges);
         onWillUpdateProps((nextProps) => {
             if (nextProps.ranges.join() !== this.store.selectionInputValues.join()) {
                 this.triggerChange();
@@ -44731,6 +45490,10 @@ class SelectionInput extends Component {
                 nextProps.colors?.join() !== this.store.colors.join()) {
                 this.store.updateColors(nextProps.colors || []);
             }
+            if (!deepEquals(nextProps.disabledRanges, this.props.disabledRanges) &&
+                !deepEquals(nextProps.disabledRanges, this.store.disabledRanges)) {
+                this.store.updateDisabledRanges(nextProps.disabledRanges || []);
+            }
         });
     }
     startDragAndDrop(rangeId, event) {
@@ -44846,10 +45609,14 @@ class ChartDataSeries extends Component {
         onSelectionRemoved: { type: Function, optional: true },
         onSelectionConfirmed: Function,
         title: { type: String, optional: true },
+        maxNumberOfUsedRanges: { type: Number, optional: true },
     };
     get ranges() {
         return this.props.ranges.map((r) => r.dataRange);
     }
+    get disabledRanges() {
+        return this.props.ranges.map((r, i) => this.props.maxNumberOfUsedRanges ? i >= this.props.maxNumberOfUsedRanges : false);
+    }
     get colors() {
         return this.props.ranges.map((r) => r.backgroundColor);
     }
@@ -44914,7 +45681,7 @@ class GenericChartConfigPanel extends Component {
         const cancelledReasons = [
             ...(this.state.datasetDispatchResult?.reasons || []),
             ...(this.state.labelsDispatchResult?.reasons || []),
-        ];
+        ].filter((reason) => reason !== "NoChanges" /* CommandResult.NoChanges */);
         return cancelledReasons.map((error) => ChartTerms.Errors[error] || ChartTerms.Errors.Unexpected);
     }
     get isDatasetInvalid() {
@@ -45036,6 +45803,9 @@ class GenericChartConfigPanel extends Component {
         }
         return undefined;
     }
+    get maxNumberOfUsedRanges() {
+        return chartRegistry.get(this.props.definition.type).dataSeriesLimit;
+    }
 }
 
 class BarConfigPanel extends GenericChartConfigPanel {
@@ -47194,13 +47964,10 @@ class GeoChartConfigPanel extends GenericChartConfigPanel {
     static template = "o-spreadsheet-GeoChartConfigPanel";
     static components = { ...GenericChartConfigPanel.components, GeoChartRegionSelectSection };
     get dataRanges() {
-        return this.getDataSeriesRanges().slice(0, 1);
+        return this.getDataSeriesRanges();
     }
-    onDataSeriesConfirmed() {
-        this.dataSets = spreadRange(this.env.model.getters, this.dataSets).slice(0, 1);
-        this.state.datasetDispatchResult = this.props.updateChart(this.props.figureId, {
-            dataSets: this.dataSets,
-        });
+    get disabledRanges() {
+        return this.props.definition.dataSets.map((ds, i) => i > 0);
     }
     getLabelRangeOptions() {
         return [
@@ -47327,6 +48094,19 @@ class LineConfigPanel extends GenericChartConfigPanel {
     }
 }
 
+class PieHoleSize extends Component {
+    static template = "o-spreadsheet.PieHoleSize";
+    static components = { Section };
+    static props = { onValueChange: Function, value: Number };
+    // Very short debounce to prevent up/down arrow on number input to spam the onChange
+    debouncedOnChange = debounce(this.onChange.bind(this), 100);
+    onChange(value) {
+        if (!isNaN(Number(value))) {
+            this.props.onValueChange(clip(Number(value), 0, 95));
+        }
+    }
+}
+
 class PieChartDesignPanel extends Component {
     static template = "o-spreadsheet-PieChartDesignPanel";
     static components = {
@@ -47334,6 +48114,7 @@ class PieChartDesignPanel extends Component {
         Section,
         Checkbox,
         ChartLegend,
+        PieHoleSize,
     };
     static props = {
         figureId: String,
@@ -47341,6 +48122,12 @@ class PieChartDesignPanel extends Component {
         updateChart: Function,
         canUpdateChart: { type: Function, optional: true },
     };
+    onPieHoleSizeChange(pieHolePercentage) {
+        this.props.updateChart(this.props.figureId, {
+            ...this.props.definition,
+            pieHolePercentage,
+        });
+    }
 }
 
 class RadarChartDesignPanel extends Component {
@@ -47509,6 +48296,7 @@ class SunburstChartDesignPanel extends Component {
         TextStyler,
         RoundColorPicker,
         ChartLegend,
+        PieHoleSize,
     };
     static props = {
         figureId: String,
@@ -47534,6 +48322,12 @@ class SunburstChartDesignPanel extends Component {
         colors[index] = color;
         this.props.updateChart(this.props.figureId, { groupColors: colors });
     }
+    onPieHoleSizeChange(pieHolePercentage) {
+        this.props.updateChart(this.props.figureId, {
+            ...this.props.definition,
+            pieHolePercentage,
+        });
+    }
 }
 
 class TreeMapCategoryColors extends Component {
@@ -51958,8 +52752,8 @@ function compareDimensionValues(dimension, a, b) {
 
 const NULL_SYMBOL = Symbol("NULL");
 function createDate(dimension, value, locale) {
-    const granularity = dimension.granularity;
-    if (!granularity || !(granularity in MAP_VALUE_DIMENSION_DATE)) {
+    const granularity = dimension.granularity || "month";
+    if (!(granularity in MAP_VALUE_DIMENSION_DATE)) {
         throw new Error(`Unknown date granularity: ${granularity}`);
     }
     const keyInMap = typeof value === "number" || typeof value === "string" ? value : NULL_SYMBOL;
@@ -51978,6 +52772,9 @@ function createDate(dimension, value, locale) {
                 case "month_number":
                     number = date.getMonth() + 1;
                     break;
+                case "month":
+                    number = Math.floor(toNumber(value, locale));
+                    break;
                 case "iso_week_number":
                     number = date.getIsoWeek();
                     break;
@@ -52071,6 +52868,10 @@ const MAP_VALUE_DIMENSION_DATE = {
         set: new Set(),
         values: {},
     },
+    month: {
+        set: new Set(),
+        values: {},
+    },
     iso_week_number: {
         set: new Set(),
         values: {},
@@ -52281,7 +53082,7 @@ class SpreadsheetPivot {
         const cells = this.filterDataEntriesFromDomain(this.dataEntries, domain);
         const finalCell = cells[0]?.[dimension.nameWithGranularity];
         if (dimension.type === "datetime") {
-            const adapter = pivotTimeAdapter(dimension.granularity);
+            const adapter = pivotTimeAdapter((dimension.granularity || "month"));
             return adapter.toValueAndFormat(lastNode.value, this.getters.getLocale());
         }
         if (!finalCell) {
@@ -52399,7 +53200,7 @@ class SpreadsheetPivot {
         if (nonEmptyCells.length === 0) {
             return "integer";
         }
-        if (nonEmptyCells.every((cell) => cell.format && isDateTimeFormat(cell.format))) {
+        if (nonEmptyCells.every((cell) => cell.type === CellValueType.number && cell.format && isDateTimeFormat(cell.format))) {
             return "datetime";
         }
         if (nonEmptyCells.every((cell) => cell.type === CellValueType.boolean)) {
@@ -52492,7 +53293,7 @@ class SpreadsheetPivot {
             for (const entry of dataEntries) {
                 for (const dimension of dateDimensions) {
                     const value = createDate(dimension, entry[dimension.fieldName]?.value || null, this.getters.getLocale());
-                    const adapter = pivotTimeAdapter(dimension.granularity);
+                    const adapter = pivotTimeAdapter((dimension.granularity || "month"));
                     const { format, value: valueToFormat } = adapter.toValueAndFormat(value, locale);
                     entry[dimension.nameWithGranularity] = {
                         value,
@@ -52512,6 +53313,7 @@ const dateGranularities = [
     "year",
     "quarter_number",
     "month_number",
+    "month",
     "iso_week_number",
     "day_of_month",
     "day",
@@ -52762,7 +53564,7 @@ class PivotSidePanelStore extends SpreadsheetStore {
                 : this.datetimeGranularities);
         }
         for (const field of dateFields) {
-            granularitiesPerFields[field.fieldName].delete(field.granularity);
+            granularitiesPerFields[field.fieldName].delete(field.granularity || "month");
         }
         return granularitiesPerFields;
     }
@@ -55998,7 +56800,7 @@ class ChartPlugin extends CorePlugin {
             case "CREATE_CHART":
                 return this.checkValidations(cmd, this.chainValidations(this.validateChartDefinition, this.checkChartDuplicate));
             case "UPDATE_CHART":
-                return this.checkValidations(cmd, this.chainValidations(this.validateChartDefinition, this.checkChartExists));
+                return this.checkValidations(cmd, this.chainValidations(this.validateChartDefinition, this.checkChartExists, this.checkChartChanged));
             default:
                 return "Success" /* CommandResult.Success */;
         }
@@ -56152,10 +56954,15 @@ class ChartPlugin extends CorePlugin {
             : "Success" /* CommandResult.Success */;
     }
     checkChartExists(cmd) {
-        return this.getters.getFigureSheetId(cmd.figureId)
+        return this.isChartDefined(cmd.figureId)
             ? "Success" /* CommandResult.Success */
             : "ChartDoesNotExist" /* CommandResult.ChartDoesNotExist */;
     }
+    checkChartChanged(cmd) {
+        return deepEquals(this.getChartDefinition(cmd.figureId), cmd.definition)
+            ? "NoChanges" /* CommandResult.NoChanges */
+            : "Success" /* CommandResult.Success */;
+    }
 }
 
 // -----------------------------------------------------------------------------
@@ -58414,6 +59221,7 @@ class SheetPlugin extends CorePlugin {
         "getCommandZones",
         "getUnboundedZone",
         "checkElementsIncludeAllNonFrozenHeaders",
+        "getDuplicateSheetName",
     ];
     sheetIdsMapName = {};
     orderedSheetIds = [];
@@ -58438,7 +59246,11 @@ class SheetPlugin extends CorePlugin {
                 return this.checkValidations(cmd, this.checkSheetName, this.checkSheetPosition);
             }
             case "DUPLICATE_SHEET": {
-                return this.sheets[cmd.sheetIdTo] ? "DuplicatedSheetId" /* CommandResult.DuplicatedSheetId */ : "Success" /* CommandResult.Success */;
+                if (this.sheets[cmd.sheetIdTo])
+                    return "DuplicatedSheetId" /* CommandResult.DuplicatedSheetId */;
+                if (this.orderedSheetIds.map(this.getSheetName.bind(this)).includes(cmd.sheetNameTo))
+                    return "DuplicatedSheetName" /* CommandResult.DuplicatedSheetName */;
+                return "Success" /* CommandResult.Success */;
             }
             case "MOVE_SHEET":
                 try {
@@ -58515,7 +59327,7 @@ class SheetPlugin extends CorePlugin {
                 this.showSheet(cmd.sheetId);
                 break;
             case "DUPLICATE_SHEET":
-                this.duplicateSheet(cmd.sheetId, cmd.sheetIdTo);
+                this.duplicateSheet(cmd.sheetId, cmd.sheetIdTo, cmd.sheetNameTo);
                 break;
             case "DELETE_SHEET":
                 this.deleteSheet(this.sheets[cmd.sheetId]);
@@ -58722,10 +59534,7 @@ class SheetPlugin extends CorePlugin {
     }
     getNextSheetName(baseName = "Sheet") {
         const names = this.orderedSheetIds.map(this.getSheetName.bind(this));
-        return getUniqueText(baseName, names, {
-            compute: (name, i) => `${name}${i}`,
-            computeFirstOne: true,
-        });
+        return getNextSheetName(names, baseName);
     }
     getSheetSize(sheetId) {
         return {
@@ -58972,9 +59781,8 @@ class SheetPlugin extends CorePlugin {
     showSheet(sheetId) {
         this.history.update("sheets", sheetId, "isVisible", true);
     }
-    duplicateSheet(fromId, toId) {
+    duplicateSheet(fromId, toId, toName) {
         const sheet = this.getSheet(fromId);
-        const toName = this.getDuplicateSheetName(sheet.name);
         const newSheet = deepCopy(sheet);
         newSheet.id = toId;
         newSheet.name = toName;
@@ -59007,8 +59815,7 @@ class SheetPlugin extends CorePlugin {
     }
     getDuplicateSheetName(sheetName) {
         const names = this.orderedSheetIds.map(this.getSheetName.bind(this));
-        const baseName = _t("Copy of %s", sheetName);
-        return getUniqueText(baseName.toString(), names);
+        return getDuplicateSheetName(sheetName, names);
     }
     deleteSheet(sheet) {
         const name = sheet.name;
@@ -61812,8 +62619,8 @@ class SpreadingRelation {
 const EMPTY_ARRAY = [];
 
 const MAX_ITERATION = 30;
-const ERROR_CYCLE_CELL = createEvaluatedCell(new CircularDependencyError());
-const EMPTY_CELL = createEvaluatedCell({ value: null });
+const ERROR_CYCLE_CELL = Object.freeze(createEvaluatedCell(new CircularDependencyError()));
+const EMPTY_CELL = Object.freeze(createEvaluatedCell({ value: null }));
 class Evaluator {
     context;
     getters;
@@ -65661,6 +66468,10 @@ class SpecificRangeTransformRegistry extends Registry {
         super.add(cmdType, fn);
         return this;
     }
+    replace(cmdType, fn) {
+        super.replace(cmdType, fn);
+        return this;
+    }
     get(cmdType) {
         return this.content[cmdType];
     }
@@ -68240,7 +69051,6 @@ repeatCommandTransformRegistry.add("CREATE_CHART", repeatCreateChartCommand);
 repeatCommandTransformRegistry.add("CREATE_IMAGE", repeatCreateImageCommand);
 repeatCommandTransformRegistry.add("GROUP_HEADERS", repeatGroupHeadersCommand);
 repeatCommandTransformRegistry.add("UNGROUP_HEADERS", repeatGroupHeadersCommand);
-repeatCommandTransformRegistry.add("UNGROUP_HEADERS", repeatGroupHeadersCommand);
 repeatCommandTransformRegistry.add("UNFOLD_HEADER_GROUPS_IN_ZONE", repeatZoneDependantCommand);
 repeatCommandTransformRegistry.add("FOLD_HEADER_GROUPS_IN_ZONE", repeatZoneDependantCommand);
 const repeatLocalCommandTransformRegistry = new Registry();
@@ -72543,9 +73353,9 @@ topbarMenuRegistry
 class TopBarComponentRegistry extends Registry {
     mapping = {};
     uuidGenerator = new UuidGenerator();
-    add(name, value) {
+    replace(name, value) {
         const component = { ...value, id: this.uuidGenerator.uuidv4() };
-        return super.add(name, component);
+        return super.replace(name, component);
     }
     getAllOrdered() {
         return this.getAll().sort((a, b) => a.sequence - b.sequence);
@@ -74109,6 +74919,9 @@ class TopBarToolStore {
 class ToolBarRegistry {
     content = {};
     add(key) {
+        if (key in this.content) {
+            throw new Error(`${key} is already present in this registry!`);
+        }
         this.content[key] = [];
         return this;
     }
@@ -75469,11 +76282,13 @@ class Spreadsheet extends Component {
             this.checkViewportSize();
             stores.on("store-updated", this, render);
             resizeObserver.observe(this.spreadsheetRef.el);
+            registerChartJSExtensions();
         });
         onWillUnmount(() => {
             this.unbindModelEvents();
             stores.off("store-updated", this);
             resizeObserver.disconnect();
+            unregisterChartJsExtensions();
         });
         onPatched(() => {
             this.checkViewportSize();
@@ -79976,6 +80791,7 @@ const components = {
     SidePanelCollapsible,
     RadioSelection,
     GeoChartRegionSelectSection,
+    ChartDashboardMenu,
 };
 const hooks = {
     useDragAndDropListItems,
@@ -80020,6 +80836,6 @@ const chartHelpers = { ...CHART_HELPERS, ...CHART_RUNTIME_HELPERS };
 export { AbstractCellClipboardHandler, AbstractChart, AbstractFigureClipboardHandler, CellErrorType, CommandResult, CorePlugin, CoreViewPlugin, 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, invalidateChartEvaluationCommands, invalidateDependenciesCommands, invalidateEvaluationCommands, iterateAstNodes, links, load, parse, parseTokens, readonlyAllowedCommands, registries, setDefaultSheetViewSize, setTranslationMethod, stores, tokenColors, tokenize };
 
 
-__info__.version = "18.4.0-alpha.1";
-__info__.date = "2025-05-02T12:34:49.374Z";
-__info__.hash = "50d42e1";
+__info__.version = "18.4.0-alpha.2";
+__info__.date = "2025-05-12T05:28:06.109Z";
+__info__.hash = "a11158e";