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

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.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
  */
 
 (function (exports, owl) {
@@ -64,12 +64,25 @@
   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;
       }
@@ -3547,6 +3560,7 @@
       "EVALUATE_CHARTS",
       "SET_FORMULA_VISIBILITY",
       "UPDATE_FILTER",
+      "UPDATE_CHART",
   ]);
   const coreTypes = new Set([
       /** CELLS */
@@ -3902,14 +3916,14 @@
           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;
@@ -3988,12 +4002,6 @@
   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) {
@@ -6532,6 +6540,25 @@
       })
           .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;
@@ -7574,6 +7601,37 @@
       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++) {
@@ -7702,7 +7760,7 @@
 
   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;
@@ -7866,7 +7924,7 @@
   */
   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) {
@@ -8274,6 +8332,24 @@
           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
    */
@@ -8409,6 +8485,7 @@
       .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))
@@ -8589,10 +8666,7 @@
       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) {
@@ -8604,10 +8678,7 @@
       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
@@ -10081,20 +10152,24 @@ stores.inject(MyMetaStore, storeInstance);
   }
 
   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() {
@@ -11717,13 +11792,35 @@ stores.inject(MyMetaStore, storeInstance);
     }
   }
 `;
-  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 owl.Component {
       static template = "o-spreadsheet-ChartJsComponent";
       static props = {
@@ -11775,8 +11872,7 @@ stores.inject(MyMetaStore, storeInstance);
       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) {
@@ -12402,6 +12498,230 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  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;
@@ -12741,38 +13061,6 @@ stores.inject(MyMetaStore, storeInstance);
       return { bottomLeft, bottomRight, topRight, topLeft };
   }
 
-  class GaugeChartComponent extends owl.Component {
-      static template = "o-spreadsheet-GaugeChartComponent";
-      canvas = owl.useRef("chartContainer");
-      get runtime() {
-          return this.env.model.getters.getChartRuntime(this.props.figureUI.id);
-      }
-      setup() {
-          owl.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
@@ -12786,6 +13074,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
       },
       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
@@ -12835,8 +13124,7 @@ stores.inject(MyMetaStore, storeInstance);
       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();
       }
@@ -13237,10 +13525,11 @@ stores.inject(MyMetaStore, storeInstance);
           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]) {
@@ -13296,6 +13585,7 @@ stores.inject(MyMetaStore, storeInstance);
           locale: getters.getLocale(),
           trendDataSetsValues,
           axisType,
+          topPadding: getTopPaddingForDashboard(definition, getters),
       };
   }
   function getPieChartData(definition, dataSets, labelRange, getters) {
@@ -13316,6 +13606,7 @@ stores.inject(MyMetaStore, storeInstance);
           axisFormats: { y: dataSetFormat },
           labels,
           locale: getters.getLocale(),
+          topPadding: getTopPaddingForDashboard(definition, getters),
       };
   }
   function getRadarChartData(definition, dataSets, labelRange, getters) {
@@ -13339,7 +13630,8 @@ stores.inject(MyMetaStore, storeInstance);
           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)) {
@@ -13588,11 +13880,10 @@ stores.inject(MyMetaStore, storeInstance);
   }
   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) {
@@ -13895,13 +14186,18 @@ stores.inject(MyMetaStore, storeInstance);
           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,
           },
       };
@@ -14090,6 +14386,9 @@ stores.inject(MyMetaStore, storeInstance);
           target.style.cursor = "default";
       },
       onClick: (event, legendItem, legend) => {
+          if (event.type !== "click") {
+              return;
+          }
           const index = legendItem.datasetIndex;
           if (!legend.legendItems || index === undefined) {
               return;
@@ -14918,6 +15217,7 @@ stores.inject(MyMetaStore, storeInstance);
     getSunburstChartLegend: getSunburstChartLegend,
     getSunburstChartTooltip: getSunburstChartTooltip,
     getSunburstShowValues: getSunburstShowValues,
+    getTopPaddingForDashboard: getTopPaddingForDashboard,
     getTreeMapChartDatasets: getTreeMapChartDatasets,
     getTreeMapChartTooltip: getTreeMapChartTooltip,
     getTrendDatasetForBarChart: getTrendDatasetForBarChart,
@@ -15067,7 +15367,7 @@ stores.inject(MyMetaStore, storeInstance);
           options: {
               ...CHART_COMMON_OPTIONS,
               indexAxis: chart.horizontal ? "y" : "x",
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getBarChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -15080,6 +15380,24 @@ stores.inject(MyMetaStore, storeInstance);
       return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
   }
 
+  class GaugeChartComponent extends owl.Component {
+      static template = "o-spreadsheet-GaugeChartComponent";
+      canvas = owl.useRef("chartContainer");
+      get runtime() {
+          return this.env.model.getters.getChartRuntime(this.props.figureUI.id);
+      }
+      setup() {
+          owl.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;
@@ -15219,7 +15537,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getBarChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -15363,7 +15681,7 @@ stores.inject(MyMetaStore, storeInstance);
           options: {
               ...CHART_COMMON_OPTIONS,
               indexAxis: "y",
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getFunnelChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -15767,7 +16085,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getGeoChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -15925,7 +16243,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getLineChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -15951,6 +16269,7 @@ stores.inject(MyMetaStore, storeInstance);
       dataSetsHaveTitle;
       isDoughnut;
       showValues;
+      pieHolePercentage;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -15961,6 +16280,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
           this.isDoughnut = definition.isDoughnut;
           this.showValues = definition.showValues;
+          this.pieHolePercentage = definition.pieHolePercentage;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -16012,6 +16332,7 @@ stores.inject(MyMetaStore, storeInstance);
               aggregated: this.aggregated,
               isDoughnut: this.isDoughnut,
               showValues: this.showValues,
+              pieHolePercentage: this.pieHolePercentage,
           };
       }
       duplicateInDuplicatedSheet(newSheetId) {
@@ -16057,7 +16378,10 @@ stores.inject(MyMetaStore, storeInstance);
           },
           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),
@@ -16084,7 +16408,7 @@ stores.inject(MyMetaStore, storeInstance);
       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;
@@ -16194,7 +16518,7 @@ stores.inject(MyMetaStore, storeInstance);
           options: {
               ...CHART_COMMON_OPTIONS,
               indexAxis: "y",
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getPyramidChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -16343,7 +16667,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getRadarChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -16496,7 +16820,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getScatterChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -16523,6 +16847,7 @@ stores.inject(MyMetaStore, storeInstance);
       showLabels;
       valuesDesign;
       groupColors;
+      pieHolePercentage;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -16534,6 +16859,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.showLabels = definition.showLabels;
           this.valuesDesign = definition.valuesDesign;
           this.groupColors = definition.groupColors;
+          this.pieHolePercentage = definition.pieHolePercentage;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -16596,6 +16922,7 @@ stores.inject(MyMetaStore, storeInstance);
               showLabels: this.showLabels,
               valuesDesign: this.valuesDesign,
               groupColors: this.groupColors,
+              pieHolePercentage: this.pieHolePercentage,
           };
       }
       duplicateInDuplicatedSheet(newSheetId) {
@@ -16629,9 +16956,9 @@ stores.inject(MyMetaStore, storeInstance);
               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),
@@ -16779,7 +17106,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
                   legend: { display: false },
@@ -16935,7 +17262,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getChartLayout(),
+              layout: getChartLayout(definition, chartData),
               scales: getWaterfallChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -17034,6 +17361,7 @@ stores.inject(MyMetaStore, storeInstance);
       transformDefinition: PyramidChart.transformDefinition,
       getChartDefinitionFromContextCreation: PyramidChart.getDefinitionFromContextCreation,
       sequence: 80,
+      dataSeriesLimit: 2,
   });
   chartRegistry.add("radar", {
       match: (type) => type === "radar",
@@ -17052,6 +17380,7 @@ stores.inject(MyMetaStore, storeInstance);
       transformDefinition: GeoChart.transformDefinition,
       getChartDefinitionFromContextCreation: GeoChart.getDefinitionFromContextCreation,
       sequence: 90,
+      dataSeriesLimit: 1,
   });
   chartRegistry.add("funnel", {
       match: (type) => type === "funnel",
@@ -17061,6 +17390,7 @@ stores.inject(MyMetaStore, storeInstance);
       transformDefinition: FunnelChart.transformDefinition,
       getChartDefinitionFromContextCreation: FunnelChart.getDefinitionFromContextCreation,
       sequence: 100,
+      dataSeriesLimit: 1,
   });
   chartRegistry.add("sunburst", {
       match: (type) => type === "sunburst",
@@ -17287,268 +17617,6 @@ stores.inject(MyMetaStore, storeInstance);
       preview: "o-spreadsheet-ChartPreview.TREE_MAP_CHART",
   });
 
-  // -----------------------------------------------------------------------------
-  // STYLE
-  // -----------------------------------------------------------------------------
-  css /* scss */ `
-  .o-chart-container {
-    width: 100%;
-    height: 100%;
-    position: relative;
-  }
-`;
-  class ChartFigure extends owl.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 owl.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
    */
@@ -17981,20 +18049,7 @@ stores.inject(MyMetaStore, storeInstance);
       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",
@@ -18025,7 +18080,9 @@ stores.inject(MyMetaStore, storeInstance);
                       "text/html": innerHTML,
                       "image/png": blob,
                   });
+                  env.notifyUser({ sticky: false, type: "success", text: _t("Chart copied to clipboard") });
               },
+              isReadonlyAllowed: true,
           },
           {
               id: "download",
@@ -18040,14 +18097,15 @@ stores.inject(MyMetaStore, storeInstance);
                   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",
@@ -18094,7 +18152,7 @@ stores.inject(MyMetaStore, storeInstance);
       ];
       return createActions(menuItemSpecs);
   }
-  function getCopyMenuItem(figureId, env) {
+  function getCopyMenuItem(figureId, env, copiedNotificationMessage) {
       return {
           id: "copy",
           name: _t("Copy"),
@@ -18105,6 +18163,9 @@ stores.inject(MyMetaStore, storeInstance);
               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",
       };
@@ -18773,6 +18834,153 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class ChartDashboardMenu extends owl.Component {
+      static template = "spreadsheet.ChartDashboardMenu";
+      static components = { Menu };
+      static props = { figureUI: Object };
+      originalChartDefinition;
+      menuState = owl.useState({ isOpen: false, anchorRect: null, menuItems: [] });
+      setup() {
+          super.setup();
+          this.originalChartDefinition = this.env.model.getters.getChartDefinition(this.props.figureUI.id);
+          owl.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 owl.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 owl.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
   // -----------------------------------------------------------------------------
@@ -19765,10 +19973,13 @@ stores.inject(MyMetaStore, storeInstance);
       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 });
       },
@@ -19828,7 +20039,7 @@ stores.inject(MyMetaStore, storeInstance);
       /**
        * @override
        */
-      add(key, value) {
+      replace(key, value) {
           if (value.id === undefined) {
               value.id = key;
           }
@@ -19840,7 +20051,13 @@ stores.inject(MyMetaStore, storeInstance);
        * @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;
           }
@@ -24888,6 +25105,7 @@ stores.inject(MyMetaStore, storeInstance);
       initialMessages = dropCommands(initialMessages, "SET_DECIMAL");
       initialMessages = fixChartDefinitions(data, initialMessages);
       initialMessages = fixFigureOffset(data, initialMessages);
+      initialMessages = fixTranslatedDuplicateSheetName(data, initialMessages);
       return initialMessages;
   }
   /**
@@ -25020,6 +25238,42 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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
   // -----------------------------------------------------------------------------
@@ -26873,29 +27127,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  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
   // -----------------------------------------------------------------------------
@@ -26910,8 +27141,12 @@ stores.inject(MyMetaStore, storeInstance);
           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]);
@@ -26932,7 +27167,9 @@ stores.inject(MyMetaStore, storeInstance);
           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) {
@@ -26961,7 +27198,9 @@ stores.inject(MyMetaStore, storeInstance);
           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
@@ -26987,8 +27226,12 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -27091,7 +27334,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -27106,7 +27351,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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."));
@@ -27127,8 +27374,10 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -27143,7 +27392,9 @@ stores.inject(MyMetaStore, storeInstance);
           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++) {
@@ -27171,7 +27422,9 @@ stores.inject(MyMetaStore, storeInstance);
    * 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;
@@ -27353,7 +27606,9 @@ stores.inject(MyMetaStore, storeInstance);
       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) => {
@@ -27377,7 +27632,9 @@ stores.inject(MyMetaStore, storeInstance);
       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) => {
@@ -27460,7 +27717,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -27475,7 +27734,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -27506,7 +27767,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -27521,7 +27784,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -27562,7 +27827,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -27577,7 +27844,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -27594,7 +27863,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -27685,7 +27956,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -27698,7 +27971,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -27810,7 +28085,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -27823,7 +28100,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -27840,7 +28119,9 @@ stores.inject(MyMetaStore, storeInstance);
       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;
@@ -27850,9 +28131,13 @@ stores.inject(MyMetaStore, storeInstance);
            * 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,
@@ -27891,7 +28176,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -28003,7 +28290,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -28020,9 +28309,15 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -28031,7 +28326,7 @@ stores.inject(MyMetaStore, storeInstance);
   // 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)) {
@@ -28065,7 +28360,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -28110,7 +28407,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -28183,11 +28482,19 @@ stores.inject(MyMetaStore, storeInstance);
           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++) {
@@ -28223,7 +28530,9 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -28359,8 +28668,12 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -28399,7 +28712,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -28607,7 +28922,7 @@ stores.inject(MyMetaStore, storeInstance);
           _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++) {
@@ -28624,7 +28939,10 @@ stores.inject(MyMetaStore, storeInstance);
   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++) {
@@ -28646,14 +28964,17 @@ stores.inject(MyMetaStore, storeInstance);
           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;
@@ -28665,10 +28986,10 @@ stores.inject(MyMetaStore, storeInstance);
               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);
   }
@@ -28687,7 +29008,9 @@ stores.inject(MyMetaStore, storeInstance);
               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;
       },
@@ -28729,7 +29052,9 @@ stores.inject(MyMetaStore, storeInstance);
           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++) {
@@ -28738,12 +29063,16 @@ stores.inject(MyMetaStore, storeInstance);
                           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."));
+                          }
                       }
                   }
               }
@@ -28751,13 +29080,17 @@ stores.inject(MyMetaStore, storeInstance);
                   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]) };
       },
   };
@@ -28776,7 +29109,9 @@ stores.inject(MyMetaStore, storeInstance);
               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]),
@@ -28805,7 +29140,9 @@ stores.inject(MyMetaStore, storeInstance);
                   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,
@@ -28833,7 +29170,9 @@ stores.inject(MyMetaStore, storeInstance);
                   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,
@@ -28983,8 +29322,12 @@ stores.inject(MyMetaStore, storeInstance);
               }
           });
           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,
@@ -29464,8 +29807,12 @@ stores.inject(MyMetaStore, storeInstance);
               }
           });
           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,
@@ -29892,7 +30239,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -30036,14 +30385,18 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -30063,12 +30416,16 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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);
@@ -30116,7 +30473,9 @@ stores.inject(MyMetaStore, storeInstance);
       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,
@@ -30360,17 +30719,7 @@ stores.inject(MyMetaStore, storeInstance);
       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") {
@@ -30381,7 +30730,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       //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
@@ -30482,7 +30831,9 @@ stores.inject(MyMetaStore, storeInstance);
           _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,
@@ -30499,7 +30850,9 @@ stores.inject(MyMetaStore, storeInstance);
       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;
       },
@@ -30534,7 +30887,9 @@ stores.inject(MyMetaStore, storeInstance);
           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)
@@ -30555,7 +30910,9 @@ stores.inject(MyMetaStore, storeInstance);
       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);
           }
@@ -30611,8 +30968,8 @@ stores.inject(MyMetaStore, storeInstance);
       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();
@@ -30667,9 +31024,15 @@ stores.inject(MyMetaStore, storeInstance);
           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);
       },
   };
@@ -30834,7 +31197,7 @@ stores.inject(MyMetaStore, storeInstance);
 
   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 = [];
@@ -30843,7 +31206,7 @@ stores.inject(MyMetaStore, storeInstance);
           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 {
@@ -30908,12 +31271,20 @@ stores.inject(MyMetaStore, storeInstance);
       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];
@@ -30964,8 +31335,12 @@ stores.inject(MyMetaStore, storeInstance);
           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));
@@ -31070,127 +31445,83 @@ stores.inject(MyMetaStore, storeInstance);
     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;
@@ -31225,7 +31556,7 @@ stores.inject(MyMetaStore, storeInstance);
       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;
@@ -31235,7 +31566,7 @@ stores.inject(MyMetaStore, storeInstance);
           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;
@@ -31258,11 +31589,21 @@ stores.inject(MyMetaStore, storeInstance);
           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;
       },
@@ -31291,14 +31632,30 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -31336,14 +31693,20 @@ stores.inject(MyMetaStore, storeInstance);
           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;
@@ -31362,19 +31725,26 @@ stores.inject(MyMetaStore, storeInstance);
           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
@@ -31418,20 +31788,27 @@ stores.inject(MyMetaStore, storeInstance);
           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,
   };
@@ -31447,12 +31824,18 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -31472,9 +31855,15 @@ stores.inject(MyMetaStore, storeInstance);
           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;
@@ -31498,9 +31887,15 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -31531,9 +31926,27 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -31562,9 +31975,27 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -31593,12 +32024,24 @@ stores.inject(MyMetaStore, storeInstance);
           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
@@ -31623,27 +32066,7 @@ stores.inject(MyMetaStore, storeInstance);
   // 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: [
@@ -31659,9 +32082,43 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -31685,10 +32142,18 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -31716,7 +32181,9 @@ stores.inject(MyMetaStore, storeInstance);
       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;
@@ -31736,7 +32203,9 @@ stores.inject(MyMetaStore, storeInstance);
       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));
@@ -31764,11 +32233,21 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -31800,8 +32279,12 @@ stores.inject(MyMetaStore, storeInstance);
       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;
       },
@@ -31875,10 +32358,18 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -31933,7 +32424,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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;
@@ -31946,7 +32439,9 @@ stores.inject(MyMetaStore, storeInstance);
                   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
@@ -31997,7 +32492,9 @@ stores.inject(MyMetaStore, storeInstance);
           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;
       },
@@ -32020,7 +32517,7 @@ stores.inject(MyMetaStore, storeInstance);
           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,
   };
@@ -32070,7 +32567,9 @@ stores.inject(MyMetaStore, storeInstance);
                   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;
       },
@@ -32088,8 +32587,12 @@ stores.inject(MyMetaStore, storeInstance);
       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;
       },
@@ -32157,7 +32660,9 @@ stores.inject(MyMetaStore, storeInstance);
       // 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",
@@ -32179,9 +32684,15 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -32190,7 +32701,9 @@ stores.inject(MyMetaStore, storeInstance);
   // 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
        *
@@ -32228,8 +32741,12 @@ stores.inject(MyMetaStore, storeInstance);
   // 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;
@@ -32317,12 +32834,24 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -32362,10 +32891,18 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -32400,11 +32937,21 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -32462,9 +33009,15 @@ stores.inject(MyMetaStore, storeInstance);
           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
@@ -32507,10 +33060,18 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -32541,7 +33102,9 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -32590,9 +33153,15 @@ stores.inject(MyMetaStore, storeInstance);
           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.
@@ -32637,10 +33206,18 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -32659,10 +33236,18 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -32716,9 +33301,15 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -32764,10 +33355,30 @@ stores.inject(MyMetaStore, storeInstance);
           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) {
@@ -32817,12 +33428,20 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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];
@@ -32887,20 +33506,21 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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
@@ -32960,12 +33580,24 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -33032,10 +33664,18 @@ stores.inject(MyMetaStore, storeInstance);
           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
            *
@@ -33069,11 +33709,21 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -33807,7 +34457,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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;
@@ -33976,7 +34628,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -34008,7 +34662,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -34029,7 +34683,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -34050,7 +34704,7 @@ stores.inject(MyMetaStore, storeInstance);
               return { value: "" };
           }
           if (result.value === null) {
-              result.value = "";
+              return { ...result, value: "" };
           }
           return result;
       },
@@ -34068,7 +34722,9 @@ stores.inject(MyMetaStore, storeInstance);
           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];
@@ -34076,7 +34732,7 @@ stores.inject(MyMetaStore, storeInstance);
                       return { value: "" };
                   }
                   if (result.value === null) {
-                      result.value = "";
+                      return { ...result, value: "" };
                   }
                   return result;
               }
@@ -34109,7 +34765,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -34170,7 +34828,9 @@ stores.inject(MyMetaStore, storeInstance);
               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,
@@ -34223,6 +34883,11 @@ stores.inject(MyMetaStore, storeInstance);
           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) {
@@ -34260,10 +34925,16 @@ stores.inject(MyMetaStore, storeInstance);
       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) {
@@ -34300,7 +34971,9 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -34334,7 +35007,9 @@ stores.inject(MyMetaStore, storeInstance);
       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
@@ -34362,10 +35037,12 @@ stores.inject(MyMetaStore, storeInstance);
           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;
           }
@@ -34456,12 +35133,18 @@ stores.inject(MyMetaStore, storeInstance);
           }
           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,
@@ -34482,7 +35165,9 @@ stores.inject(MyMetaStore, storeInstance);
           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
@@ -34523,7 +35208,9 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -34557,7 +35244,9 @@ stores.inject(MyMetaStore, storeInstance);
       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
@@ -34602,14 +35291,24 @@ stores.inject(MyMetaStore, storeInstance);
           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;
@@ -34801,12 +35500,16 @@ stores.inject(MyMetaStore, storeInstance);
           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);
@@ -34904,7 +35607,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -35475,7 +36180,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -35540,10 +36247,16 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -35574,7 +36287,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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,
@@ -35615,8 +36330,12 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -35650,7 +36369,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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);
@@ -35669,7 +36390,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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);
@@ -35732,7 +36455,9 @@ stores.inject(MyMetaStore, storeInstance);
           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) {
@@ -35755,7 +36480,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       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 === "") {
@@ -35915,6 +36642,13 @@ stores.inject(MyMetaStore, storeInstance);
   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));
@@ -35922,7 +36656,7 @@ stores.inject(MyMetaStore, storeInstance);
           const descr = addMetaInfoFromArg(name, addDescr);
           validateArguments(descr);
           this.mapping[name] = createComputeFunction(descr);
-          super.add(name, descr);
+          super.replace(name, descr);
           return this;
       }
   }
@@ -40436,6 +41170,13 @@ stores.inject(MyMetaStore, storeInstance);
       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
       // ---------------------------------------------------------------------------
@@ -40715,6 +41456,8 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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: {
@@ -40732,6 +41475,7 @@ stores.inject(MyMetaStore, storeInstance);
               }),
               onInputContextMenu: this.props.onInputContextMenu,
               composerStore: this.composerStore,
+              inputStyle: `max-height: ${maxHeight}px;`,
           };
       }
       get containerStyle() {
@@ -44311,6 +45055,7 @@ stores.inject(MyMetaStore, storeInstance);
       initialRanges;
       inputHasSingleRange;
       colors;
+      disabledRanges;
       mutators = [
           "resetWithRanges",
           "focusById",
@@ -44321,17 +45066,19 @@ stores.inject(MyMetaStore, storeInstance);
           "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.");
           }
@@ -44448,6 +45195,9 @@ stores.inject(MyMetaStore, storeInstance);
               color: colorGenerator.next(),
           }));
       }
+      updateDisabledRanges(disabledRanges) {
+          this.disabledRanges = disabledRanges;
+      }
       confirm() {
           for (const range of this.selectionInputs) {
               if (range.xc === "") {
@@ -44489,6 +45239,7 @@ stores.inject(MyMetaStore, storeInstance);
                   : null,
               isFocused: this.hasMainFocus && this.focusedRangeIndex === index,
               isValidRange: input.xc === "" || this.getters.isRangeValid(input.xc),
+              disabled: this.disabledRanges?.[index],
           }));
       }
       get isResettable() {
@@ -44653,7 +45404,7 @@ stores.inject(MyMetaStore, storeInstance);
       input.o-invalid {
         background-color: ${ALERT_DANGER_BG};
       }
-      .error-icon {
+      .input-icon {
         right: 7px;
         top: 4px;
       }
@@ -44661,6 +45412,9 @@ stores.inject(MyMetaStore, storeInstance);
         cursor: move;
       }
     }
+    .o-disabled-ranges {
+      color: #888 !important;
+    }
     .o-button {
       flex-grow: 0;
     }
@@ -44693,6 +45447,8 @@ stores.inject(MyMetaStore, storeInstance);
           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 = owl.useState({
           isMissing: false,
@@ -44717,9 +45473,12 @@ stores.inject(MyMetaStore, storeInstance);
       get isResettable() {
           return this.store.isResettable;
       }
+      get hasDisabledRanges() {
+          return this.store.disabledRanges.some(Boolean);
+      }
       setup() {
           owl.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);
           owl.onWillUpdateProps((nextProps) => {
               if (nextProps.ranges.join() !== this.store.selectionInputValues.join()) {
                   this.triggerChange();
@@ -44732,6 +45491,10 @@ stores.inject(MyMetaStore, storeInstance);
                   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) {
@@ -44847,10 +45610,14 @@ stores.inject(MyMetaStore, storeInstance);
           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);
       }
@@ -44915,7 +45682,7 @@ stores.inject(MyMetaStore, storeInstance);
           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() {
@@ -45037,6 +45804,9 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return undefined;
       }
+      get maxNumberOfUsedRanges() {
+          return chartRegistry.get(this.props.definition.type).dataSeriesLimit;
+      }
   }
 
   class BarConfigPanel extends GenericChartConfigPanel {
@@ -47195,13 +47965,10 @@ stores.inject(MyMetaStore, storeInstance);
       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 [
@@ -47328,6 +48095,19 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class PieHoleSize extends owl.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 owl.Component {
       static template = "o-spreadsheet-PieChartDesignPanel";
       static components = {
@@ -47335,6 +48115,7 @@ stores.inject(MyMetaStore, storeInstance);
           Section,
           Checkbox,
           ChartLegend,
+          PieHoleSize,
       };
       static props = {
           figureId: String,
@@ -47342,6 +48123,12 @@ stores.inject(MyMetaStore, storeInstance);
           updateChart: Function,
           canUpdateChart: { type: Function, optional: true },
       };
+      onPieHoleSizeChange(pieHolePercentage) {
+          this.props.updateChart(this.props.figureId, {
+              ...this.props.definition,
+              pieHolePercentage,
+          });
+      }
   }
 
   class RadarChartDesignPanel extends owl.Component {
@@ -47510,6 +48297,7 @@ stores.inject(MyMetaStore, storeInstance);
           TextStyler,
           RoundColorPicker,
           ChartLegend,
+          PieHoleSize,
       };
       static props = {
           figureId: String,
@@ -47535,6 +48323,12 @@ stores.inject(MyMetaStore, storeInstance);
           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 owl.Component {
@@ -51959,8 +52753,8 @@ stores.inject(MyMetaStore, storeInstance);
 
   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;
@@ -51979,6 +52773,9 @@ stores.inject(MyMetaStore, storeInstance);
                   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;
@@ -52072,6 +52869,10 @@ stores.inject(MyMetaStore, storeInstance);
           set: new Set(),
           values: {},
       },
+      month: {
+          set: new Set(),
+          values: {},
+      },
       iso_week_number: {
           set: new Set(),
           values: {},
@@ -52282,7 +53083,7 @@ stores.inject(MyMetaStore, storeInstance);
           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) {
@@ -52400,7 +53201,7 @@ stores.inject(MyMetaStore, storeInstance);
           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)) {
@@ -52493,7 +53294,7 @@ stores.inject(MyMetaStore, storeInstance);
               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,
@@ -52513,6 +53314,7 @@ stores.inject(MyMetaStore, storeInstance);
       "year",
       "quarter_number",
       "month_number",
+      "month",
       "iso_week_number",
       "day_of_month",
       "day",
@@ -52763,7 +53565,7 @@ stores.inject(MyMetaStore, storeInstance);
                   : this.datetimeGranularities);
           }
           for (const field of dateFields) {
-              granularitiesPerFields[field.fieldName].delete(field.granularity);
+              granularitiesPerFields[field.fieldName].delete(field.granularity || "month");
           }
           return granularitiesPerFields;
       }
@@ -55999,7 +56801,7 @@ stores.inject(MyMetaStore, storeInstance);
               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 */;
           }
@@ -56153,10 +56955,15 @@ stores.inject(MyMetaStore, storeInstance);
               : "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 */;
+      }
   }
 
   // -----------------------------------------------------------------------------
@@ -58415,6 +59222,7 @@ stores.inject(MyMetaStore, storeInstance);
           "getCommandZones",
           "getUnboundedZone",
           "checkElementsIncludeAllNonFrozenHeaders",
+          "getDuplicateSheetName",
       ];
       sheetIdsMapName = {};
       orderedSheetIds = [];
@@ -58439,7 +59247,11 @@ stores.inject(MyMetaStore, storeInstance);
                   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 {
@@ -58516,7 +59328,7 @@ stores.inject(MyMetaStore, storeInstance);
                   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]);
@@ -58723,10 +59535,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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 {
@@ -58973,9 +59782,8 @@ stores.inject(MyMetaStore, storeInstance);
       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;
@@ -59008,8 +59816,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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;
@@ -61813,8 +62620,8 @@ stores.inject(MyMetaStore, storeInstance);
   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;
@@ -65662,6 +66469,10 @@ stores.inject(MyMetaStore, storeInstance);
           super.add(cmdType, fn);
           return this;
       }
+      replace(cmdType, fn) {
+          super.replace(cmdType, fn);
+          return this;
+      }
       get(cmdType) {
           return this.content[cmdType];
       }
@@ -68241,7 +69052,6 @@ stores.inject(MyMetaStore, storeInstance);
   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();
@@ -72544,9 +73354,9 @@ stores.inject(MyMetaStore, storeInstance);
   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);
@@ -74110,6 +74920,9 @@ stores.inject(MyMetaStore, storeInstance);
   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;
       }
@@ -75470,11 +76283,13 @@ stores.inject(MyMetaStore, storeInstance);
               this.checkViewportSize();
               stores.on("store-updated", this, render);
               resizeObserver.observe(this.spreadsheetRef.el);
+              registerChartJSExtensions();
           });
           owl.onWillUnmount(() => {
               this.unbindModelEvents();
               stores.off("store-updated", this);
               resizeObserver.disconnect();
+              unregisterChartJsExtensions();
           });
           owl.onPatched(() => {
               this.checkViewportSize();
@@ -79977,6 +80792,7 @@ stores.inject(MyMetaStore, storeInstance);
       SidePanelCollapsible,
       RadioSelection,
       GeoChartRegionSelectSection,
+      ChartDashboardMenu,
   };
   const hooks = {
       useDragAndDropListItems,
@@ -80067,9 +80883,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = 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";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);