@odoo/o-spreadsheet 17.4.0-alpha.8 → 17.4.0

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 17.4.0-alpha.8
- * @date 2024-06-24T19:51:16.144Z
- * @hash ccd30df
+ * @version 17.4.0
+ * @date 2024-07-12T04:41:51.675Z
+ * @hash f8e8543
  */
 
 (function (exports, owl) {
@@ -591,7 +591,7 @@
   /**
    * Compares two objects.
    */
-  function deepEquals(o1, o2, ignoreFunctions) {
+  function deepEquals(o1, o2) {
       if (o1 === o2)
           return true;
       if ((o1 && !o2) || (o2 && !o1))
@@ -607,17 +607,13 @@
           }
       }
       for (const key in o1) {
-          const typeOfO1Key = typeof o1[key];
-          if (typeOfO1Key !== typeof o2[key])
+          if (typeof o1[key] !== typeof o2[key])
               return false;
-          if (typeOfO1Key === "object") {
-              if (!deepEquals(o1[key], o2[key], ignoreFunctions))
+          if (typeof o1[key] === "object") {
+              if (!deepEquals(o1[key], o2[key]))
                   return false;
           }
           else {
-              if (ignoreFunctions && typeOfO1Key === "function") {
-                  continue;
-              }
               if (o1[key] !== o2[key])
                   return false;
           }
@@ -1155,31 +1151,15 @@
           return numberToLetters(Math.floor(n / 26) - 1) + numberToLetters(n % 26);
       }
   }
-  const LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  const LETTERS_NUMBER_MAPPING = {};
-  for (const letter of LETTERS) {
-      const colIndex = letter.charCodeAt(0) - 64;
-      LETTERS_NUMBER_MAPPING[letter] = colIndex;
-      LETTERS_NUMBER_MAPPING[letter.toLowerCase()] = colIndex;
-  }
-  /**
-   * Convert a string (describing a column) to its number value.
-   *
-   * Examples:
-   *     'A' => 0
-   *     'Z' => 25
-   *     'AA' => 26
-   */
   function lettersToNumber(letters) {
-      let result = -1;
+      let result = 0;
       const l = letters.length;
-      let pow = 1;
-      for (let i = l - 1; i >= 0; i--) {
-          const charCode = LETTERS_NUMBER_MAPPING[letters[i]];
-          result += charCode * pow;
-          pow *= 26;
+      for (let i = 0; i < l; i++) {
+          const charCode = letters.charCodeAt(i);
+          const colIndex = charCode >= 65 && charCode <= 90 ? charCode - 64 : charCode - 96;
+          result = result * 26 + colIndex;
       }
-      return result;
+      return result - 1;
   }
   function isCharALetter(char) {
       return (char >= "A" && char <= "Z") || (char >= "a" && char <= "z");
@@ -1198,37 +1178,27 @@
    */
   function toCartesian(xc) {
       xc = xc.trim();
-      let numberPartStart = undefined;
-      // Note: looping by hand is uglier but ~2x faster than using a regex to match number/letter parts
-      for (let i = 0; i < xc.length; i++) {
-          const char = xc[i];
-          // as long as we haven't found the number part, keep advancing
-          if (!numberPartStart) {
-              if ((char === "$" && i === 0) || isCharALetter(char)) {
-                  continue;
-              }
-              numberPartStart = i;
-          }
-          // Number part
-          if (!isCharADigit(char)) {
-              if (char === "$" && i === numberPartStart) {
-                  continue;
-              }
-              throw new Error(`Invalid cell description: ${xc}`);
-          }
+      let letterPart = "";
+      let numberPart = "";
+      let i = 0;
+      // Process letter part
+      if (xc[i] === "$")
+          i++;
+      while (i < xc.length && isCharALetter(xc[i])) {
+          letterPart += xc[i++];
       }
-      if (!numberPartStart || numberPartStart === xc.length) {
+      if (letterPart.length === 0 || letterPart.length > 3) {
+          // limit to max 3 letters for performance reasons
           throw new Error(`Invalid cell description: ${xc}`);
       }
-      const letterPart = xc[0] === "$" ? xc.slice(1, numberPartStart) : xc.slice(0, numberPartStart);
-      const numberPart = xc[numberPartStart] === "$" ? xc.slice(numberPartStart + 1) : xc.slice(numberPartStart);
-      // limit to max 3 letters and 7 numbers to avoid
-      // gigantic numbers that would be a performance killer
-      // down the road
-      if (letterPart.length < 1 ||
-          letterPart.length > 3 ||
-          numberPart.length < 1 ||
-          numberPart.length > 7) {
+      // Process number part
+      if (xc[i] === "$")
+          i++;
+      while (i < xc.length && isCharADigit(xc[i])) {
+          numberPart += xc[i++];
+      }
+      if (i !== xc.length || numberPart.length === 0 || numberPart.length > 7) {
+          // limit to max 7 numbers for performance reasons
           throw new Error(`Invalid cell description: ${xc}`);
       }
       const col = lettersToNumber(letterPart);
@@ -1830,7 +1800,7 @@
   });
   const getNumberRegex = memoize(function getNumberRegex(locale) {
       const decimalSeparator = escapeRegExp(locale.decimalSeparator);
-      const thousandsSeparator = escapeRegExp(locale.thousandsSeparator);
+      const thousandsSeparator = escapeRegExp(locale.thousandsSeparator || "");
       const pIntegerAndDecimals = `(?:\\d+(?:${thousandsSeparator}\\d{3,})*(?:${decimalSeparator}\\d*)?)`; // pattern that match integer number with or without decimal digits
       const pOnlyDecimals = `(?:${decimalSeparator}\\d+)`; // pattern that match only expression with decimal digits
       const pScientificFormat = "(?:e(?:\\+|-)?\\d+)?"; // pattern that match scientific format between zero and one time (should be placed before pPercentFormat)
@@ -1863,7 +1833,7 @@
       return getNumberRegex(locale).test(value.trim());
   }
   const getInvaluableSymbolsRegexp = memoize(function getInvaluableSymbolsRegexp(locale) {
-      return new RegExp(`[\$€${escapeRegExp(locale.thousandsSeparator)}]`, "g");
+      return new RegExp(`[\$€${escapeRegExp(locale.thousandsSeparator || "")}]`, "g");
   });
   /**
    * Convert a string into a number. It assumes that the string actually represents
@@ -2666,11 +2636,11 @@
       }
       return returned;
   }
-  function matrixMap(matrix, fn) {
+  function matrixMap(matrix, callback) {
       if (matrix.length === 0) {
           return [];
       }
-      return generateMatrix(matrix.length, matrix[0].length, (col, row) => fn(matrix[col][row]));
+      return generateMatrix(matrix.length, matrix[0].length, (col, row) => callback(matrix[col][row]));
   }
   function matrixForEach(matrix, fn) {
       const numberOfCols = matrix.length;
@@ -2770,6 +2740,9 @@
    * If the character is a special regular expression character, it is escaped with "\\".
    */
   const wildcardToRegExp = memoize(function wildcardToRegExp(operand) {
+      if (operand === "*") {
+          return /.+/;
+      }
       let exp = "";
       let predecessor = "";
       for (let char of operand) {
@@ -2793,9 +2766,9 @@
       }
       return new RegExp("^" + exp + "$", "i");
   });
-  function evaluatePredicate(value, criterion) {
+  function evaluatePredicate(value = "", criterion) {
       const { operator, operand } = criterion;
-      if (value === undefined || operand === undefined || value === null || operand === null) {
+      if (operand === undefined || value === null || operand === null) {
           return false;
       }
       if (typeof operand === "number" && operator === "=") {
@@ -5887,19 +5860,22 @@
   }
 
   function isValidLocale(locale) {
-      if (!(locale &&
-          typeof locale === "object" &&
-          typeof locale.name === "string" &&
-          typeof locale.code === "string" &&
-          typeof locale.thousandsSeparator === "string" &&
-          typeof locale.decimalSeparator === "string" &&
-          typeof locale.dateFormat === "string" &&
-          typeof locale.timeFormat === "string" &&
-          typeof locale.formulaArgSeparator === "string")) {
+      if (!locale ||
+          typeof locale !== "object" ||
+          !(!locale.thousandsSeparator || typeof locale.thousandsSeparator === "string")) {
           return false;
       }
-      if (!Object.values(locale).every((v) => v)) {
-          return false;
+      for (const property of [
+          "code",
+          "name",
+          "decimalSeparator",
+          "dateFormat",
+          "timeFormat",
+          "formulaArgSeparator",
+      ]) {
+          if (!locale[property] || typeof locale[property] !== "string") {
+              return false;
+          }
       }
       if (locale.formulaArgSeparator === locale.decimalSeparator) {
           return false;
@@ -5997,7 +5973,10 @@
       if (locale.decimalSeparator === "." || !isNumber(content, locale)) {
           return content;
       }
-      return content.replace(locale.thousandsSeparator, "").replace(locale.decimalSeparator, ".");
+      if (locale.thousandsSeparator) {
+          content = content.replaceAll(locale.thousandsSeparator, "");
+      }
+      return content.replace(locale.decimalSeparator, ".");
   }
   /**
    * Change a content string from the given locale to its canonical form (en_US locale). Also convert date string.
@@ -6294,24 +6273,6 @@
           return `${normalizedValue}`;
       },
   };
-  /**
-   * Normalized value: "2/2023" for week 2 of 2023
-   */
-  const weekAdapter = {
-      normalizeFunctionValue(value) {
-          const [week, year] = toString(value).split("/");
-          return `${Number(week)}/${Number(year)}`;
-      },
-      toValueAndFormat(normalizedValue, locale) {
-          const [week, year] = normalizedValue.split("/");
-          return {
-              value: _t("W%(week)s %(year)s", { week, year }),
-          };
-      },
-      toFunctionValue(normalizedValue) {
-          return `"${normalizedValue}"`;
-      },
-  };
   /**
    * normalizes iso week number
    */
@@ -6333,25 +6294,6 @@
           return `${normalizedValue}`;
       },
   };
-  /**
-   * normalized month value is a string formatted as "MM/yyyy" (luxon format)
-   * e.g. "01/2020" for January 2020
-   */
-  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 month number
    */
@@ -6373,25 +6315,6 @@
           return `${normalizedValue}`;
       },
   };
-  /**
-   * normalized quarter value is "quarter/year"
-   * e.g. "1/2020" for Q1 2020
-   */
-  const quarterAdapter = {
-      normalizeFunctionValue(value) {
-          const [quarter, year] = toString(value).split("/");
-          return `${quarter}/${year}`;
-      },
-      toValueAndFormat(normalizedValue) {
-          const [quarter, year] = normalizedValue.split("/");
-          return {
-              value: _t("Q%(quarter)s %(year)s", { quarter, year }),
-          };
-      },
-      toFunctionValue(normalizedValue) {
-          return `"${normalizedValue}"`;
-      },
-  };
   /**
    * normalizes quarter number
    */
@@ -6405,7 +6328,7 @@
       },
       toValueAndFormat(normalizedValue) {
           return {
-              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              value: _t("Q%(quarter_number)s", { quarter_number: normalizedValue }),
               format: "0",
           };
       },
@@ -6455,15 +6378,11 @@
   }
   pivotTimeAdapterRegistry
       .add("day", nullHandlerDecorator(dayAdapter))
-      .add("week", nullHandlerDecorator(weekAdapter))
-      .add("month", nullHandlerDecorator(monthAdapter))
-      .add("quarter", nullHandlerDecorator(quarterAdapter))
       .add("year", nullHandlerDecorator(yearAdapter))
       .add("day_of_month", nullHandlerDecorator(dayOfMonthAdapter))
       .add("iso_week_number", nullHandlerDecorator(isoWeekNumberAdapter))
       .add("month_number", nullHandlerDecorator(monthNumberAdapter))
-      .add("quarter_number", nullHandlerDecorator(quarterNumberAdapter))
-      .add("year_number", nullHandlerDecorator(yearAdapter));
+      .add("quarter_number", nullHandlerDecorator(quarterNumberAdapter));
 
   const AGGREGATOR_NAMES = {
       count: _t("Count"),
@@ -6539,11 +6458,10 @@
   }
   const ALL_PERIODS = {
       year: _t("Year"),
-      quarter: _t("Quarter"),
-      month: _t("Month"),
-      week: _t("Week"),
+      quarter: _t("Quarter & Year"),
+      month: _t("Month & Year"),
+      week: _t("Week & Year"),
       day: _t("Day"),
-      year_number: _t("Year"),
       quarter_number: _t("Quarter"),
       month_number: _t("Month"),
       iso_week_number: _t("Week"),
@@ -6694,7 +6612,7 @@
                   const pivotId = this.getters.getPivotIdFromPosition(position);
                   const spreader = this.getters.getArrayFormulaSpreadingOn(position);
                   if (pivotId) {
-                      if (!deepEquals(spreader, position) || !isCopyingOneCell) {
+                      if (spreader && (!deepEquals(spreader, position) || !isCopyingOneCell)) {
                           const pivotCell = this.getters.getPivotCellFromPosition(position);
                           const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
                           const pivotFormula = createPivotFormula(formulaPivotId, pivotCell);
@@ -7499,6 +7417,146 @@
       return undefined;
   }
 
+  var State;
+  (function (State) {
+      /**
+       * Initial state.
+       * Expecting any reference for the left part of a range
+       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
+       */
+      State[State["LeftRef"] = 0] = "LeftRef";
+      /**
+       * Expecting any reference for the right part of a range
+       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
+       */
+      State[State["RightRef"] = 1] = "RightRef";
+      /**
+       * Expecting the separator without any constraint on the right part
+       */
+      State[State["Separator"] = 2] = "Separator";
+      /**
+       * Expecting the separator for a full column range
+       */
+      State[State["FullColumnSeparator"] = 3] = "FullColumnSeparator";
+      /**
+       * Expecting the separator for a full row range
+       */
+      State[State["FullRowSeparator"] = 4] = "FullRowSeparator";
+      /**
+       * Expecting the right part of a full column range
+       * e.g. "1", "A1"
+       */
+      State[State["RightColumnRef"] = 5] = "RightColumnRef";
+      /**
+       * Expecting the right part of a full row range
+       * e.g. "A", "A1"
+       */
+      State[State["RightRowRef"] = 6] = "RightRowRef";
+      /**
+       * Final state. A range has been matched
+       */
+      State[State["Found"] = 7] = "Found";
+  })(State || (State = {}));
+  const goTo = (state, guard = () => true) => [
+      {
+          goTo: state,
+          guard,
+      },
+  ];
+  const goToMulti = (state, guard = () => true) => ({
+      goTo: state,
+      guard,
+  });
+  const machine = {
+      [State.LeftRef]: {
+          REFERENCE: goTo(State.Separator),
+          NUMBER: goTo(State.FullRowSeparator),
+          SYMBOL: [
+              goToMulti(State.FullColumnSeparator, (token) => isColReference(token.value)),
+              goToMulti(State.FullRowSeparator, (token) => isRowReference(token.value)),
+          ],
+      },
+      [State.FullColumnSeparator]: {
+          SPACE: goTo(State.FullColumnSeparator),
+          OPERATOR: goTo(State.RightColumnRef, (token) => token.value === ":"),
+      },
+      [State.FullRowSeparator]: {
+          SPACE: goTo(State.FullRowSeparator),
+          OPERATOR: goTo(State.RightRowRef, (token) => token.value === ":"),
+      },
+      [State.Separator]: {
+          SPACE: goTo(State.Separator),
+          OPERATOR: goTo(State.RightRef, (token) => token.value === ":"),
+      },
+      [State.RightRef]: {
+          SPACE: goTo(State.RightRef),
+          NUMBER: goTo(State.Found),
+          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value) || isRowHeader(token.value)),
+      },
+      [State.RightColumnRef]: {
+          SPACE: goTo(State.RightColumnRef),
+          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value)),
+          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+      },
+      [State.RightRowRef]: {
+          SPACE: goTo(State.RightRowRef),
+          NUMBER: goTo(State.Found),
+          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+          SYMBOL: goTo(State.Found, (token) => isRowHeader(token.value)),
+      },
+      [State.Found]: {},
+  };
+  /**
+   * Check if the list of tokens starts with a sequence of tokens representing
+   * a range.
+   * If a range is found, the sequence is removed from the list and is returned
+   * as a single token.
+   */
+  function matchReference(tokens) {
+      let head = 0;
+      let transitions = machine[State.LeftRef];
+      let matchedTokens = "";
+      while (transitions !== undefined) {
+          const token = tokens[head++];
+          if (!token) {
+              return null;
+          }
+          const transition = transitions[token.type]?.find((transition) => transition.guard(token));
+          const nextState = transition ? transition.goTo : undefined;
+          switch (nextState) {
+              case undefined:
+                  return null;
+              case State.Found:
+                  matchedTokens += token.value;
+                  tokens.splice(0, head);
+                  return {
+                      type: "REFERENCE",
+                      value: matchedTokens,
+                  };
+              default:
+                  transitions = machine[nextState];
+                  matchedTokens += token.value;
+                  break;
+          }
+      }
+      return null;
+  }
+  /**
+   * Take the result of the tokenizer and transform it to be usable in the
+   * manipulations of range
+   *
+   * @param formula
+   */
+  function rangeTokenize(formula, locale = DEFAULT_LOCALE) {
+      const tokens = tokenize(formula, locale);
+      const result = [];
+      while (tokens.length) {
+          result.push(matchReference(tokens) || tokens.shift());
+      }
+      return result;
+  }
+
   const functionRegex = /[a-zA-Z0-9\_]+(\.[a-zA-Z0-9\_]+)*/;
   const UNARY_OPERATORS_PREFIX = ["-", "+"];
   const UNARY_OPERATORS_POSTFIX = ["%"];
@@ -7647,7 +7705,7 @@
    * Parse an expression (as a string) into an AST.
    */
   function parse(str) {
-      return parseTokens(tokenize(str));
+      return parseTokens(rangeTokenize(str));
   }
   function parseTokens(tokens) {
       tokens = tokens.filter((x) => x.type !== "SPACE");
@@ -7783,146 +7841,6 @@
       return needParenthesis ? `(${astToFormula(rightOperation)})` : astToFormula(rightOperation);
   }
 
-  var State;
-  (function (State) {
-      /**
-       * Initial state.
-       * Expecting any reference for the left part of a range
-       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
-       */
-      State[State["LeftRef"] = 0] = "LeftRef";
-      /**
-       * Expecting any reference for the right part of a range
-       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
-       */
-      State[State["RightRef"] = 1] = "RightRef";
-      /**
-       * Expecting the separator without any constraint on the right part
-       */
-      State[State["Separator"] = 2] = "Separator";
-      /**
-       * Expecting the separator for a full column range
-       */
-      State[State["FullColumnSeparator"] = 3] = "FullColumnSeparator";
-      /**
-       * Expecting the separator for a full row range
-       */
-      State[State["FullRowSeparator"] = 4] = "FullRowSeparator";
-      /**
-       * Expecting the right part of a full column range
-       * e.g. "1", "A1"
-       */
-      State[State["RightColumnRef"] = 5] = "RightColumnRef";
-      /**
-       * Expecting the right part of a full row range
-       * e.g. "A", "A1"
-       */
-      State[State["RightRowRef"] = 6] = "RightRowRef";
-      /**
-       * Final state. A range has been matched
-       */
-      State[State["Found"] = 7] = "Found";
-  })(State || (State = {}));
-  const goTo = (state, guard = () => true) => [
-      {
-          goTo: state,
-          guard,
-      },
-  ];
-  const goToMulti = (state, guard = () => true) => ({
-      goTo: state,
-      guard,
-  });
-  const machine = {
-      [State.LeftRef]: {
-          REFERENCE: goTo(State.Separator),
-          NUMBER: goTo(State.FullRowSeparator),
-          SYMBOL: [
-              goToMulti(State.FullColumnSeparator, (token) => isColReference(token.value)),
-              goToMulti(State.FullRowSeparator, (token) => isRowReference(token.value)),
-          ],
-      },
-      [State.FullColumnSeparator]: {
-          SPACE: goTo(State.FullColumnSeparator),
-          OPERATOR: goTo(State.RightColumnRef, (token) => token.value === ":"),
-      },
-      [State.FullRowSeparator]: {
-          SPACE: goTo(State.FullRowSeparator),
-          OPERATOR: goTo(State.RightRowRef, (token) => token.value === ":"),
-      },
-      [State.Separator]: {
-          SPACE: goTo(State.Separator),
-          OPERATOR: goTo(State.RightRef, (token) => token.value === ":"),
-      },
-      [State.RightRef]: {
-          SPACE: goTo(State.RightRef),
-          NUMBER: goTo(State.Found),
-          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value) || isRowHeader(token.value)),
-      },
-      [State.RightColumnRef]: {
-          SPACE: goTo(State.RightColumnRef),
-          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value)),
-          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-      },
-      [State.RightRowRef]: {
-          SPACE: goTo(State.RightRowRef),
-          NUMBER: goTo(State.Found),
-          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-          SYMBOL: goTo(State.Found, (token) => isRowHeader(token.value)),
-      },
-      [State.Found]: {},
-  };
-  /**
-   * Check if the list of tokens starts with a sequence of tokens representing
-   * a range.
-   * If a range is found, the sequence is removed from the list and is returned
-   * as a single token.
-   */
-  function matchReference(tokens) {
-      let head = 0;
-      let transitions = machine[State.LeftRef];
-      let matchedTokens = "";
-      while (transitions !== undefined) {
-          const token = tokens[head++];
-          if (!token) {
-              return null;
-          }
-          const transition = transitions[token.type]?.find((transition) => transition.guard(token));
-          const nextState = transition ? transition.goTo : undefined;
-          switch (nextState) {
-              case undefined:
-                  return null;
-              case State.Found:
-                  matchedTokens += token.value;
-                  tokens.splice(0, head);
-                  return {
-                      type: "REFERENCE",
-                      value: matchedTokens,
-                  };
-              default:
-                  transitions = machine[nextState];
-                  matchedTokens += token.value;
-                  break;
-          }
-      }
-      return null;
-  }
-  /**
-   * Take the result of the tokenizer and transform it to be usable in the
-   * manipulations of range
-   *
-   * @param formula
-   */
-  function rangeTokenize(formula, locale = DEFAULT_LOCALE) {
-      const tokens = tokenize(formula, locale);
-      const result = [];
-      while (tokens.length) {
-          result.push(matchReference(tokens) || tokens.shift());
-      }
-      return result;
-  }
-
   /**
    * Add the following information on tokens:
    * - length
@@ -8153,8 +8071,8 @@
 
   function evaluateLiteral(literalCell, localeFormat) {
       const value = localeFormat.format === PLAIN_TEXT_FORMAT ? literalCell.content : literalCell.parsedValue;
-      const fPayload = { value, format: localeFormat.format };
-      return createEvaluatedCell(fPayload, localeFormat.locale);
+      const functionResult = { value, format: localeFormat.format };
+      return createEvaluatedCell(functionResult, localeFormat.locale);
   }
   function parseLiteral(content, locale) {
       if (content.startsWith("=")) {
@@ -8175,13 +8093,13 @@
       }
       return content;
   }
-  function createEvaluatedCell(fPayload, locale = DEFAULT_LOCALE, cell) {
-      const link = detectLink(fPayload.value);
+  function createEvaluatedCell(functionResult, locale = DEFAULT_LOCALE, cell) {
+      const link = detectLink(functionResult.value);
       if (!link) {
-          return _createEvaluatedCell(fPayload, locale, cell);
+          return _createEvaluatedCell(functionResult, locale, cell);
       }
       const value = parseLiteral(link.label, locale);
-      const format = fPayload.format ||
+      const format = functionResult.format ||
           (typeof value === "number"
               ? detectDateFormat(link.label, locale) || detectNumberFormat(link.label)
               : undefined);
@@ -8194,8 +8112,8 @@
           link,
       };
   }
-  function _createEvaluatedCell(fPayload, locale, cell) {
-      let { value, format, message } = fPayload;
+  function _createEvaluatedCell(functionResult, locale, cell) {
+      let { value, format, message } = functionResult;
       format = cell?.format || format;
       const formattedValue = formatValue(value, { format, locale });
       if (isEvaluationError(value)) {
@@ -8483,9 +8401,11 @@
       BackgroundColor: _t("Background color"),
       StackedBarChart: _t("Stacked bar chart"),
       StackedLineChart: _t("Stacked line chart"),
+      StackedAreaChart: _t("Stacked area chart"),
       CumulativeData: _t("Cumulative data"),
       TreatLabelsAsText: _t("Treat labels as text"),
       AggregatedChart: _t("Aggregate"),
+      ShowValues: _t("Show values"),
       Errors: {
           Unexpected: _t("The chart definition is invalid for an unknown reason"),
           // BASIC CHART ERRORS (LINE | BAR | PIE)
@@ -10327,162 +10247,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  /** This is a chartJS plugin that will draw connector lines between the bars of a Waterfall chart */
-  const waterfallLinesPlugin = {
-      id: "waterfallLinesPlugin",
-      beforeDraw(chart, args, options) {
-          if (!options.showConnectorLines) {
-              return;
-          }
-          // Note: private properties are not in the typing of chartJS (and some of the existing types are missing properties)
-          // so we don't type anything in this file
-          const drawData = chart._metasets?.[0]?.data;
-          if (!drawData) {
-              return;
-          }
-          const ctx = chart.ctx;
-          ctx.save();
-          ctx.setLineDash([3, 2]);
-          for (let i = 0; i < drawData.length; i++) {
-              const bar = drawData[i];
-              if (bar.height === 0) {
-                  continue;
-              }
-              const nextBar = getNextNonEmptyBar(drawData, i);
-              if (!nextBar) {
-                  break;
-              }
-              const rect = getBarElementRect(bar);
-              const nextBarRect = getBarElementRect(nextBar);
-              const rawBarValues = bar.$context.raw;
-              const value = rawBarValues[1] - rawBarValues[0];
-              const lineY = Math.round(value < 0 ? rect.bottom - 1 : rect.top);
-              const lineStart = Math.round(rect.right);
-              const lineEnd = Math.round(nextBarRect.left);
-              ctx.strokeStyle = "#999";
-              ctx.beginPath();
-              ctx.moveTo(lineStart + 1, lineY + 0.5);
-              ctx.lineTo(lineEnd, lineY + 0.5);
-              ctx.stroke();
-          }
-          ctx.restore();
-      },
-  };
-  function getBarElementRect(bar) {
-      const flipped = bar.base < bar.y; // Bar are flipped for negative values in the dataset
-      return {
-          left: bar.x - bar.width / 2,
-          right: bar.x + bar.width / 2,
-          bottom: flipped ? bar.base + bar.height : bar.y + bar.height,
-          top: flipped ? bar.base : bar.y,
-      };
-  }
-  function getNextNonEmptyBar(bars, startIndex) {
-      return bars.find((bar, i) => i > startIndex && bar.height !== 0);
-  }
-
-  // @ts-ignore
-  window.Chart?.register(waterfallLinesPlugin);
-  class ChartJsComponent extends owl.Component {
-      static template = "o-spreadsheet-ChartJsComponent";
-      static props = {
-          figure: Object,
-      };
-      canvas = owl.useRef("graphContainer");
-      chart;
-      currentRuntime;
-      get background() {
-          return this.chartRuntime.background;
-      }
-      get canvasStyle() {
-          return `background-color: ${this.background}`;
-      }
-      get chartRuntime() {
-          const runtime = this.env.model.getters.getChartRuntime(this.props.figure.id);
-          if (!("chartJsConfig" in runtime)) {
-              throw new Error("Unsupported chart runtime");
-          }
-          return runtime;
-      }
-      setup() {
-          owl.onMounted(() => {
-              const runtime = this.chartRuntime;
-              this.currentRuntime = runtime;
-              // Note: chartJS modify the runtime in place, so it's important to give it a copy
-              this.createChart(deepCopy(runtime.chartJsConfig));
-          });
-          owl.onWillUnmount(() => this.chart?.destroy());
-          owl.useEffect(() => {
-              const runtime = this.chartRuntime;
-              if (!deepEquals(runtime, this.currentRuntime, "ignoreFunctions")) {
-                  if (runtime.chartJsConfig.type !== this.currentRuntime.chartJsConfig.type) {
-                      this.chart?.destroy();
-                      this.createChart(deepCopy(runtime.chartJsConfig));
-                  }
-                  else {
-                      this.updateChartJs(deepCopy(runtime));
-                  }
-                  this.currentRuntime = runtime;
-              }
-          });
-      }
-      createChart(chartData) {
-          const canvas = this.canvas.el;
-          const ctx = canvas.getContext("2d");
-          // @ts-ignore
-          this.chart = new window.Chart(ctx, chartData);
-      }
-      updateChartJs(chartRuntime) {
-          const chartData = chartRuntime.chartJsConfig;
-          if (chartData.data && chartData.data.datasets) {
-              this.chart.data = chartData.data;
-              if (chartData.options?.plugins?.title) {
-                  this.chart.config.options.plugins.title = chartData.options.plugins.title;
-              }
-          }
-          else {
-              this.chart.data.datasets = [];
-          }
-          this.chart.config.options = chartData.options;
-          this.chart.update();
-      }
-  }
-
-  /**
-   * AbstractChart is the class from which every Chart should inherit.
-   * The role of this class is to maintain the state of each chart.
-   */
-  class AbstractChart {
-      sheetId;
-      title;
-      getters;
-      constructor(definition, sheetId, getters) {
-          this.title = definition.title;
-          this.sheetId = sheetId;
-          this.getters = getters;
-      }
-      /**
-       * Validate the chart definition given as arguments. This function will be
-       * called from allowDispatch function
-       */
-      static validateChartDefinition(validator, definition) {
-          throw new Error("This method should be implemented by sub class");
-      }
-      /**
-       * Get a new chart definition transformed with the executed command. This
-       * functions will be called during operational transform process
-       */
-      static transformDefinition(definition, executed) {
-          throw new Error("This method should be implemented by sub class");
-      }
-      /**
-       * Get an empty definition based on the given context
-       */
-      static getDefinitionFromContextCreation(context) {
-          throw new Error("This method should be implemented by sub class");
-      }
-  }
-
   /**
    * This file contains helpers that are common to different charts (mainly
    * line, bar and pie charts)
@@ -10805,6 +10569,238 @@ stores.inject(MyMetaStore, storeInstance);
       return { useLeftAxis, useRightAxis };
   }
 
+  /** This is a chartJS plugin that will draw the values of each data next to the point/bar/pie slice */
+  const chartShowValuesPlugin = {
+      id: "chartShowValuesPlugin",
+      afterDatasetsDraw(chart, args, options) {
+          if (!options.showValues) {
+              return;
+          }
+          const drawData = chart._metasets?.[0]?.data;
+          if (!drawData) {
+              return;
+          }
+          const ctx = chart.ctx;
+          ctx.save();
+          ctx.textAlign = "center";
+          ctx.textBaseline = "middle";
+          ctx.fillStyle = chartFontColor(options.background);
+          ctx.strokeStyle = chartFontColor(ctx.fillStyle);
+          chart._metasets.forEach(function (dataset) {
+              switch (dataset.type) {
+                  case "doughnut":
+                  case "pie": {
+                      for (let i = 0; i < dataset._parsed.length; i++) {
+                          const bar = dataset.data[i];
+                          const { startAngle, endAngle, innerRadius, outerRadius } = bar;
+                          const midAngle = (startAngle + endAngle) / 2;
+                          const midRadius = (innerRadius + outerRadius) / 2;
+                          const x = bar.x + midRadius * Math.cos(midAngle);
+                          const y = bar.y + midRadius * Math.sin(midAngle) + 7;
+                          ctx.fillStyle = chartFontColor(bar.options.backgroundColor);
+                          ctx.strokeStyle = chartFontColor(ctx.fillStyle);
+                          const value = options.callback(dataset._parsed[i]);
+                          ctx.strokeText(value, x, y);
+                          ctx.fillText(value, x, y);
+                      }
+                      break;
+                  }
+                  case "bar":
+                  case "line": {
+                      const yOffset = dataset.type === "bar" && !options.horizontal ? 0 : 3;
+                      for (let i = 0; i < dataset._parsed.length; i++) {
+                          const point = dataset.data[i];
+                          const value = options.horizontal ? dataset._parsed[i].x : dataset._parsed[i].y;
+                          const displayedValue = options.callback(value - 0);
+                          let xPosition = 0, yPosition = 0;
+                          if (options.horizontal) {
+                              yPosition = point.y;
+                              if (value < 0) {
+                                  ctx.textAlign = "right";
+                                  xPosition = point.x - yOffset;
+                              }
+                              else {
+                                  ctx.textAlign = "left";
+                                  xPosition = point.x + yOffset;
+                              }
+                          }
+                          else {
+                              xPosition = point.x;
+                              if (value < 0) {
+                                  ctx.textBaseline = "top";
+                                  yPosition = point.y + yOffset;
+                              }
+                              else {
+                                  ctx.textBaseline = "bottom";
+                                  yPosition = point.y - yOffset;
+                              }
+                          }
+                          ctx.strokeText(displayedValue, xPosition, yPosition);
+                          ctx.fillText(displayedValue, xPosition, yPosition);
+                      }
+                      break;
+                  }
+              }
+          });
+          ctx.restore();
+      },
+  };
+
+  /** This is a chartJS plugin that will draw connector lines between the bars of a Waterfall chart */
+  const waterfallLinesPlugin = {
+      id: "waterfallLinesPlugin",
+      beforeDraw(chart, args, options) {
+          if (!options.showConnectorLines) {
+              return;
+          }
+          // Note: private properties are not in the typing of chartJS (and some of the existing types are missing properties)
+          // so we don't type anything in this file
+          const drawData = chart._metasets?.[0]?.data;
+          if (!drawData) {
+              return;
+          }
+          const ctx = chart.ctx;
+          ctx.save();
+          ctx.setLineDash([3, 2]);
+          for (let i = 0; i < drawData.length; i++) {
+              const bar = drawData[i];
+              if (bar.height === 0) {
+                  continue;
+              }
+              const nextBar = getNextNonEmptyBar(drawData, i);
+              if (!nextBar) {
+                  break;
+              }
+              const rect = getBarElementRect(bar);
+              const nextBarRect = getBarElementRect(nextBar);
+              const rawBarValues = bar.$context.raw;
+              const value = rawBarValues[1] - rawBarValues[0];
+              const lineY = Math.round(value < 0 ? rect.bottom - 1 : rect.top);
+              const lineStart = Math.round(rect.right);
+              const lineEnd = Math.round(nextBarRect.left);
+              ctx.strokeStyle = "#999";
+              ctx.beginPath();
+              ctx.moveTo(lineStart + 1, lineY + 0.5);
+              ctx.lineTo(lineEnd, lineY + 0.5);
+              ctx.stroke();
+          }
+          ctx.restore();
+      },
+  };
+  function getBarElementRect(bar) {
+      const flipped = bar.base < bar.y; // Bar are flipped for negative values in the dataset
+      return {
+          left: bar.x - bar.width / 2,
+          right: bar.x + bar.width / 2,
+          bottom: flipped ? bar.base + bar.height : bar.y + bar.height,
+          top: flipped ? bar.base : bar.y,
+      };
+  }
+  function getNextNonEmptyBar(bars, startIndex) {
+      return bars.find((bar, i) => i > startIndex && bar.height !== 0);
+  }
+
+  window.Chart?.register(waterfallLinesPlugin);
+  window.Chart?.register(chartShowValuesPlugin);
+  class ChartJsComponent extends owl.Component {
+      static template = "o-spreadsheet-ChartJsComponent";
+      static props = {
+          figure: Object,
+      };
+      canvas = owl.useRef("graphContainer");
+      chart;
+      currentRuntime;
+      get background() {
+          return this.chartRuntime.background;
+      }
+      get canvasStyle() {
+          return `background-color: ${this.background}`;
+      }
+      get chartRuntime() {
+          const runtime = this.env.model.getters.getChartRuntime(this.props.figure.id);
+          if (!("chartJsConfig" in runtime)) {
+              throw new Error("Unsupported chart runtime");
+          }
+          return runtime;
+      }
+      setup() {
+          owl.onMounted(() => {
+              const runtime = this.chartRuntime;
+              this.currentRuntime = runtime;
+              // Note: chartJS modify the runtime in place, so it's important to give it a copy
+              this.createChart(deepCopy(runtime.chartJsConfig));
+          });
+          owl.onWillUnmount(() => this.chart?.destroy());
+          owl.useEffect(() => {
+              const runtime = this.chartRuntime;
+              if (runtime !== this.currentRuntime) {
+                  if (runtime.chartJsConfig.type !== this.currentRuntime.chartJsConfig.type) {
+                      this.chart?.destroy();
+                      this.createChart(deepCopy(runtime.chartJsConfig));
+                  }
+                  else {
+                      this.updateChartJs(deepCopy(runtime));
+                  }
+                  this.currentRuntime = runtime;
+              }
+          });
+      }
+      createChart(chartData) {
+          const canvas = this.canvas.el;
+          const ctx = canvas.getContext("2d");
+          this.chart = new window.Chart(ctx, chartData);
+      }
+      updateChartJs(chartRuntime) {
+          const chartData = chartRuntime.chartJsConfig;
+          if (chartData.data && chartData.data.datasets) {
+              this.chart.data = chartData.data;
+              if (chartData.options?.plugins?.title) {
+                  this.chart.config.options.plugins.title = chartData.options.plugins.title;
+              }
+          }
+          else {
+              this.chart.data.datasets = [];
+          }
+          this.chart.config.options = chartData.options;
+          this.chart.update();
+      }
+  }
+
+  /**
+   * AbstractChart is the class from which every Chart should inherit.
+   * The role of this class is to maintain the state of each chart.
+   */
+  class AbstractChart {
+      sheetId;
+      title;
+      getters;
+      constructor(definition, sheetId, getters) {
+          this.title = definition.title;
+          this.sheetId = sheetId;
+          this.getters = getters;
+      }
+      /**
+       * Validate the chart definition given as arguments. This function will be
+       * called from allowDispatch function
+       */
+      static validateChartDefinition(validator, definition) {
+          throw new Error("This method should be implemented by sub class");
+      }
+      /**
+       * Get a new chart definition transformed with the executed command. This
+       * functions will be called during operational transform process
+       */
+      static transformDefinition(definition, executed) {
+          throw new Error("This method should be implemented by sub class");
+      }
+      /**
+       * Get an empty definition based on the given context
+       */
+      static getDefinitionFromContextCreation(context) {
+          throw new Error("This method should be implemented by sub class");
+      }
+  }
+
   function getBaselineText(baseline, keyValue, baselineMode, humanize, locale) {
       if (!baseline) {
           return "";
@@ -18843,7 +18839,7 @@ stores.inject(MyMetaStore, storeInstance);
       isExported: true,
   };
   // -----------------------------------------------------------------------------
-  // INDEX
+  // INDIRECT
   // -----------------------------------------------------------------------------
   const INDIRECT = {
       description: _t("Returns the content of a cell, specified by a string."),
@@ -19181,7 +19177,7 @@ stores.inject(MyMetaStore, storeInstance);
           arg("include_column_titles (boolean, default=TRUE)", _t("Whether to include the column titles or not.")),
           arg("column_count (number, optional)", _t("number of columns")),
       ],
-      compute: function (pivotFormulaId, rowCount = { value: Number.MAX_VALUE }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
+      compute: function (pivotFormulaId, rowCount = { value: 10000 }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
           const _pivotFormulaId = toString(pivotFormulaId);
           const _rowCount = toNumber(rowCount, this.locale);
           if (_rowCount < 0) {
@@ -19238,6 +19234,79 @@ stores.inject(MyMetaStore, storeInstance);
           return result;
       },
   };
+  //--------------------------------------------------------------------------
+  // OFFSET
+  //--------------------------------------------------------------------------
+  const OFFSET = {
+      description: _t("Returns a range reference shifted by a specified number of rows and columns from a starting cell reference."),
+      args: [
+          arg("cell_reference (meta)", _t("The starting point from which to count the offset rows and columns.")),
+          arg("offset_rows (number)", _t("The number of rows to offset by.")),
+          arg("offset_columns (number)", _t("The number of columns to offset by.")),
+          arg("height (number, default='height of cell_reference')", _t("The number of rows of the range to return starting at the offset target.")),
+          arg("width (number, default='width of cell_reference')", _t("The number of columns of the range to return starting at the offset target.")),
+      ],
+      compute: function (cellReference, offsetRows, offsetColumns, height, width) {
+          if (isEvaluationError(cellReference?.value)) {
+              return cellReference;
+          }
+          const _cellReference = cellReference?.value;
+          if (!_cellReference) {
+              throw new Error("In this context, the function OFFSET needs to have a cell or range in parameter.");
+          }
+          const zone = toZone(_cellReference);
+          let offsetHeight = zone.bottom - zone.top + 1;
+          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);
+              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);
+              offsetWidth = _width;
+          }
+          const { sheetName } = splitReference(_cellReference);
+          const sheetId = (sheetName && this.getters.getSheetIdByName(sheetName)) || this.getters.getActiveSheetId();
+          const _offsetRows = toNumber(offsetRows, this.locale);
+          const _offsetColumns = toNumber(offsetColumns, this.locale);
+          let originPosition;
+          const __originCellXC = this.__originCellXC?.();
+          if (__originCellXC) {
+              const cellZone = toZone(__originCellXC);
+              originPosition = {
+                  sheetId: this.__originSheetId,
+                  col: cellZone.left,
+                  row: cellZone.top,
+              };
+              this.updateDependencies?.(originPosition);
+          }
+          const startingCol = zone.left + _offsetColumns;
+          const startingRow = zone.top + _offsetRows;
+          if (startingCol < 0 || startingRow < 0) {
+              return new InvalidReferenceError(_t("OFFSET evaluates to an out of bounds range."));
+          }
+          const dependencyZone = {
+              left: startingCol,
+              top: startingRow,
+              right: startingCol + offsetWidth - 1,
+              bottom: startingRow + offsetHeight - 1,
+          };
+          const range = this.getters.getRangeFromZone(this.__originSheetId, dependencyZone);
+          if (range.invalidXc || range.invalidSheetName) {
+              return new InvalidReferenceError();
+          }
+          if (originPosition) {
+              this.addDependencies?.(originPosition, [range]);
+          }
+          return generateMatrix(offsetWidth, offsetHeight, (col, row) => this.getters.getEvaluatedCell({
+              sheetId,
+              col: startingCol + col,
+              row: startingRow + row,
+          }));
+      },
+  };
 
   var lookup = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -19249,6 +19318,7 @@ stores.inject(MyMetaStore, storeInstance);
     INDIRECT: INDIRECT,
     LOOKUP: LOOKUP,
     MATCH: MATCH,
+    OFFSET: OFFSET,
     PIVOT: PIVOT,
     PIVOT_HEADER: PIVOT_HEADER,
     PIVOT_VALUE: PIVOT_VALUE,
@@ -19531,6 +19601,320 @@ stores.inject(MyMetaStore, storeInstance);
     UPLUS: UPLUS
   });
 
+  const transformFromFactor = (factor) => ({
+      transform: (x) => x * factor,
+      inverseTransform: (x) => x / factor,
+  });
+  const standard = { transform: (x) => x, inverseTransform: (x) => x };
+  const ANG2M = 1e-10;
+  const IN2M = 0.0254;
+  const PICAPT2M = IN2M / 72;
+  const FT2M = 0.3048;
+  const YD2M = 0.9144;
+  const MI2M = 1609.34;
+  const NMI2M = 1852;
+  const LY2M = 9.46073047258e15;
+  const UNITS = {
+      // WEIGHT UNITs : Standard = gramme
+      g: { ...standard, category: "weight" },
+      u: { ...transformFromFactor(1.66053e-24), category: "weight" },
+      grain: { ...transformFromFactor(0.0647989), category: "weight" },
+      ozm: { ...transformFromFactor(28.3495), category: "weight" },
+      lbm: { ...transformFromFactor(453.592), category: "weight" },
+      stone: { ...transformFromFactor(6350.29), category: "weight" },
+      sg: { ...transformFromFactor(14593.90294), category: "weight" },
+      cwt: { ...transformFromFactor(45359.237), category: "weight" },
+      uk_cwt: { ...transformFromFactor(50802.3), category: "weight" },
+      ton: { ...transformFromFactor(907184.74), category: "weight" },
+      uk_ton: { ...transformFromFactor(1016046.9), category: "weight" },
+      // DISTANCE UNITS : Standard = meter
+      m: { ...standard, category: "distance" },
+      km: { ...transformFromFactor(1000), category: "distance" },
+      ang: { ...transformFromFactor(ANG2M), category: "distance" },
+      Picapt: { ...transformFromFactor(PICAPT2M), category: "distance" },
+      pica: { ...transformFromFactor(IN2M / 6), category: "distance" },
+      in: { ...transformFromFactor(IN2M), category: "distance" },
+      ft: { ...transformFromFactor(FT2M), category: "distance" },
+      yd: { ...transformFromFactor(YD2M), category: "distance" },
+      ell: { ...transformFromFactor(1.143), category: "distance" },
+      mi: { ...transformFromFactor(MI2M), category: "distance" },
+      survey_mi: { ...transformFromFactor(1609.34), category: "distance" },
+      Nmi: { ...transformFromFactor(NMI2M), category: "distance" },
+      ly: { ...transformFromFactor(LY2M), category: "distance" },
+      parsec: { ...transformFromFactor(3.0856775814914e16), category: "distance" },
+      // TIME UNITS : Standard = second
+      sec: { ...standard, category: "time" },
+      min: { ...transformFromFactor(60), category: "time" },
+      hr: { ...transformFromFactor(3600), category: "time" },
+      day: { ...transformFromFactor(86400), category: "time" },
+      yr: { ...transformFromFactor(31556952), category: "time" },
+      // PRESSURE UNITS : Standard = Pascal
+      Pa: { ...standard, category: "pressure" },
+      bar: { ...transformFromFactor(100000), category: "pressure" },
+      mmHg: { ...transformFromFactor(133.322), category: "pressure" },
+      Torr: { ...transformFromFactor(133.322), category: "pressure" },
+      psi: { ...transformFromFactor(6894.76), category: "pressure" },
+      atm: { ...transformFromFactor(101325), category: "pressure" },
+      // FORCE UNITS : Standard = Newton
+      N: { ...standard, category: "force" },
+      dyn: { ...transformFromFactor(1e-5), category: "force" },
+      pond: { ...transformFromFactor(0.00980665), category: "force" },
+      lbf: { ...transformFromFactor(4.44822), category: "force" },
+      // ENERGY UNITS : Standard = Joule
+      J: { ...standard, category: "energy" },
+      eV: { ...transformFromFactor(1.60218e-19), category: "energy" },
+      e: { ...transformFromFactor(1e-7), category: "energy" },
+      flb: { ...transformFromFactor(1.3558179483), category: "energy" },
+      c: { ...transformFromFactor(4.184), category: "energy" },
+      cal: { ...transformFromFactor(4.1868), category: "energy" },
+      BTU: { ...transformFromFactor(1055.06), category: "energy" },
+      Wh: { ...transformFromFactor(3600), category: "energy" },
+      HPh: { ...transformFromFactor(2684520), category: "energy" },
+      // POWER UNITS : Standard = Watt
+      W: { ...standard, category: "power" },
+      PS: { ...transformFromFactor(735.499), category: "power" },
+      HP: { ...transformFromFactor(745.7), category: "power" },
+      // MAGNETISM UNITS : Standard = Tesla
+      T: { ...standard, category: "magnetism" },
+      ga: { ...transformFromFactor(1e-4), category: "magnetism" },
+      // TEMPERATURE UNITS : Standard = Kelvin
+      K: { ...standard, category: "temperature" },
+      C: {
+          transform: (T) => T + 273.15,
+          inverseTransform: (T) => T - 273.15,
+          category: "temperature",
+      },
+      F: {
+          transform: (T) => ((T - 32) * 5) / 9 + 273.15,
+          inverseTransform: (T) => ((T - 273.15) * 9) / 5 + 32,
+          category: "temperature",
+      },
+      Rank: { ...transformFromFactor(5 / 9), category: "temperature" },
+      Reau: {
+          transform: (T) => T * 1.25 + 273.15,
+          inverseTransform: (T) => (T - 273.15) / 1.25,
+          category: "temperature",
+      },
+      // VOLUME UNITS : Standard = cubic meter
+      "m^3": { ...standard, category: "volume", order: 3 },
+      "ang^3": { ...transformFromFactor(Math.pow(ANG2M, 3)), category: "volume", order: 3 },
+      "Picapt^3": { ...transformFromFactor(Math.pow(PICAPT2M, 3)), category: "volume", order: 3 },
+      tsp: { ...transformFromFactor(4.92892e-6), category: "volume" },
+      tspm: { ...transformFromFactor(5e-6), category: "volume" },
+      tbs: { ...transformFromFactor(1.4786764825785619e-5), category: "volume" },
+      "in^3": { ...transformFromFactor(Math.pow(IN2M, 3)), category: "volume", order: 3 },
+      oz: { ...transformFromFactor(2.95735295625e-5), category: "volume" },
+      cup: { ...transformFromFactor(0.000237), category: "volume" },
+      pt: { ...transformFromFactor(0.0004731765), category: "volume" },
+      uk_pt: { ...transformFromFactor(0.000568261), category: "volume" },
+      qt: { ...transformFromFactor(0.0009463529), category: "volume" },
+      l: { ...transformFromFactor(1e-3), category: "volume" },
+      uk_qt: { ...transformFromFactor(0.0011365225), category: "volume" },
+      gal: { ...transformFromFactor(0.0037854118), category: "volume" },
+      uk_gal: { ...transformFromFactor(0.00454609), category: "volume" },
+      "ft^3": { ...transformFromFactor(Math.pow(FT2M, 3)), category: "volume", order: 3 },
+      bushel: { ...transformFromFactor(0.0352390704), category: "volume" },
+      barrel: { ...transformFromFactor(0.158987295), category: "volume" },
+      "yd^3": { ...transformFromFactor(Math.pow(YD2M, 3)), category: "volume", order: 3 },
+      MTON: { ...transformFromFactor(1.13267386368), category: "volume" },
+      GRT: { ...transformFromFactor(2.83168), category: "volume" },
+      "mi^3": { ...transformFromFactor(Math.pow(MI2M, 3)), category: "volume", order: 3 },
+      "Nmi^3": { ...transformFromFactor(Math.pow(NMI2M, 3)), category: "volume", order: 3 },
+      "ly^3": { ...transformFromFactor(Math.pow(LY2M, 3)), category: "volume", order: 3 },
+      // AREA UNITS : Standard = square meter
+      "m^2": { ...standard, category: "area", order: 2 },
+      "ang^2": { ...transformFromFactor(Math.pow(ANG2M, 2)), category: "area", order: 2 },
+      "Picapt^2": { ...transformFromFactor(Math.pow(PICAPT2M, 2)), category: "area", order: 2 },
+      "in^2": { ...transformFromFactor(Math.pow(IN2M, 2)), category: "area", order: 2 },
+      "ft^2": { ...transformFromFactor(Math.pow(FT2M, 2)), category: "area", order: 2 },
+      "yd^2": { ...transformFromFactor(Math.pow(YD2M, 2)), category: "area", order: 2 },
+      ar: { ...transformFromFactor(100), category: "area" },
+      Morgen: { ...transformFromFactor(2500), category: "area" },
+      uk_acre: { ...transformFromFactor(4046.8564224), category: "area" },
+      us_acre: { ...transformFromFactor(4046.8726098743), category: "area" },
+      ha: { ...transformFromFactor(1e4), category: "area" },
+      "mi^2": { ...transformFromFactor(Math.pow(MI2M, 2)), category: "area", order: 2 },
+      "Nmi^2": { ...transformFromFactor(Math.pow(NMI2M, 2)), category: "area", order: 2 },
+      "ly^2": { ...transformFromFactor(Math.pow(LY2M, 2)), category: "area", order: 2 },
+      // INFORMATION UNITS : Standard = bit
+      bit: { ...standard, category: "information" },
+      byte: { ...transformFromFactor(8), category: "information" },
+      // SPEED UNITS : Standard = m/s
+      "m/s": { ...standard, category: "speed" },
+      "m/hr": { ...transformFromFactor(1 / 3600), category: "speed" },
+      "km/hr": { ...transformFromFactor(1 / 3.6), category: "speed" },
+      mph: { ...transformFromFactor(0.44704), category: "speed" },
+      kn: { ...transformFromFactor(0.5144444444), category: "speed" },
+      admkn: { ...transformFromFactor(0.5147733333), category: "speed" },
+  };
+  const UNITS_ALIASES = {
+      shweight: "cwt",
+      lcwt: "uk_cwt",
+      hweight: "uk_cwt",
+      LTON: "uk_ton",
+      brton: "uk_ton",
+      pc: "parsec",
+      Pica: "Picapt",
+      d: "day",
+      mn: "min",
+      s: "sec",
+      p: "Pa",
+      at: "atm",
+      dy: "dyn",
+      ev: "eV",
+      hh: "HPh",
+      wh: "Wh",
+      btu: "BTU",
+      h: "HP",
+      cel: "C",
+      fah: "F",
+      kel: "K",
+      us_pt: "pt",
+      L: "l",
+      lt: "l",
+      ang3: "ang^3",
+      ft3: "ft^3",
+      in3: "in^3",
+      ly3: "ly^3",
+      m3: "m^3",
+      mi3: "mi^3",
+      yd3: "yd^3",
+      Nmi3: "Nmi^3",
+      Picapt3: "Picapt^3",
+      "Pica^3": "Picapt^3",
+      Pica3: "Picapt^3",
+      regton: "GRT",
+      ang2: "ang^2",
+      ft2: "ft^2",
+      in2: "in^2",
+      ly2: "ly^2",
+      m2: "m^2",
+      mi2: "mi^2",
+      Nmi2: "Nmi^2",
+      Picapt2: "Picapt^2",
+      "Pica^2": "Picapt^2",
+      Pica2: "Picapt^2",
+      yd2: "yd^2",
+      "m/h": "m/hr",
+      "m/sec": "m/s",
+  };
+  const UNIT_PREFIXES = {
+      "": 1,
+      Y: 1e24,
+      Z: 1e21,
+      E: 1e18,
+      P: 1e15,
+      T: 1e12,
+      G: 1e9,
+      M: 1e6,
+      k: 1e3,
+      h: 1e2,
+      da: 1e1,
+      e: 1e1,
+      d: 1e-1,
+      c: 1e-2,
+      m: 1e-3,
+      u: 1e-6,
+      n: 1e-9,
+      p: 1e-12,
+      f: 1e-15,
+      a: 1e-18,
+      z: 1e-21,
+      y: 1e-21,
+      Yi: Math.pow(2, 80),
+      Zi: Math.pow(2, 70),
+      Ei: Math.pow(2, 60),
+      Pi: Math.pow(2, 50),
+      Ti: Math.pow(2, 40),
+      Gi: Math.pow(2, 30),
+      Mi: Math.pow(2, 20),
+      ki: Math.pow(2, 10),
+  };
+  const TRANSLATED_CATEGORIES = {
+      weight: _t("Weight"),
+      distance: _t("Distance"),
+      time: _t("Time"),
+      pressure: _t("Pressure"),
+      force: _t("Force"),
+      energy: _t("Energy"),
+      power: _t("Power"),
+      magnetism: _t("Magnetism"),
+      temperature: _t("Temperature"),
+      volume: _t("Volume"),
+      area: _t("Area"),
+      information: _t("Information"),
+      speed: _t("Speed"),
+  };
+  function getTranslatedCategory(key) {
+      return TRANSLATED_CATEGORIES[key] ?? "";
+  }
+  function getTransformation(key) {
+      for (const [prefix, value] of Object.entries(UNIT_PREFIXES)) {
+          if (prefix && !key.startsWith(prefix))
+              continue;
+          const _key = key.slice(prefix.length);
+          let conversion = UNITS[_key];
+          if (!conversion && UNITS_ALIASES[_key]) {
+              conversion = UNITS[UNITS_ALIASES[_key]];
+          }
+          if (conversion) {
+              return {
+                  ...conversion,
+                  factor: conversion.order ? Math.pow(value, conversion.order) : value,
+              };
+          }
+      }
+      return;
+  }
+
+  // -----------------------------------------------------------------------------
+  // CONVERT
+  // -----------------------------------------------------------------------------
+  const CONVERT = {
+      description: _t("Converts a numeric value to a different unit of measure."),
+      args: [
+          arg("value (number)", _t("the numeric value in start_unit to convert to end_unit")),
+          arg("start_unit (string)", _t("The starting unit, the unit currently assigned to value")),
+          arg("end_unit (string)", _t("The unit of measure into which to convert value")),
+      ],
+      compute: function (value, startUnit, endUnit) {
+          const _value = toNumber(value, this.locale);
+          const _startUnit = toString(startUnit);
+          const _endUnit = toString(endUnit);
+          const startConversion = getTransformation(_startUnit);
+          const endConversion = getTransformation(_endUnit);
+          if (!startConversion) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Invalid units of measure ('%s')", _startUnit),
+              };
+          }
+          if (!endConversion) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Invalid units of measure ('%s')", _endUnit),
+              };
+          }
+          if (startConversion.category !== endConversion.category) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Incompatible units of measure ('%s' vs '%s')", getTranslatedCategory(startConversion.category), getTranslatedCategory(endConversion.category)),
+              };
+          }
+          return {
+              value: endConversion.inverseTransform(startConversion.factor * startConversion.transform(_value)) /
+                  endConversion.factor,
+              format: value?.format,
+          };
+      },
+      isExported: true,
+  };
+
+  var parser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CONVERT: CONVERT
+  });
+
   const DEFAULT_STARTING_AT = 1;
   /** Regex matching all the words in a string */
   const wordRegex = /[A-Za-zÀ-ÖØ-öø-ÿ]+/g;
@@ -19948,6 +20332,7 @@ stores.inject(MyMetaStore, storeInstance);
       { name: _t("Text"), functions: text },
       { name: _t("Engineering"), functions: engineering },
       { name: _t("Web"), functions: web },
+      { name: _t("Parser"), functions: parser },
   ];
   const functionNameRegex = /^[A-Z0-9\_\.]+$/;
   class FunctionRegistry extends Registry {
@@ -19959,41 +20344,127 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const descr = addMetaInfoFromArg(addDescr);
           validateArguments(descr.args);
-          this.mapping[name] = addErrorHandling(addResultHandling(addInputHandling(descr), name), name);
+          this.mapping[name] = createComputeFunction(descr, name);
           super.add(name, descr);
           return this;
       }
   }
-  function addInputHandling(descr) {
-      function computeWithInputHandling(...args) {
+  const functionRegistry = new FunctionRegistry();
+  for (let category of categories) {
+      const fns = category.functions;
+      for (let name in fns) {
+          const addDescr = fns[name];
+          addDescr.category = addDescr.category || category.name;
+          name = name.replace(/_/g, ".");
+          functionRegistry.add(name, { isExported: false, ...addDescr });
+      }
+  }
+  const notAvailableError = new NotAvailableError(_t("Array arguments to [[FUNCTION_NAME]] are of different size."));
+  function createComputeFunction(descr, functionName) {
+      function runtimeCompute(...args) {
+          try {
+              return vectorizedCompute.apply(this, args);
+          }
+          catch (e) {
+              return handleError(e, functionName);
+          }
+      }
+      function vectorizedCompute(...args) {
+          let countVectorizableCol = 1;
+          let countVectorizableRow = 1;
+          let vectorizableColLimit = Infinity;
+          let vectorizableRowLimit = Infinity;
+          let vectorArgsType = undefined;
+          //#region Compute vectorisation limits
           for (let i = 0; i < args.length; i++) {
               const argDefinition = descr.args[descr.getArgToFocus(i + 1) - 1];
               const arg = args[i];
               if (isMatrix(arg) && !argDefinition.acceptMatrix) {
-                  if (arg.length !== 1 || arg[0].length !== 1) {
-                      throw new EvaluationError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be a single value or a single cell reference, not a range.", argDefinition.name));
+                  // if argDefinition does not accept a matrix but arg is still a matrix
+                  // --> triggers the arguments vectorization
+                  const nColumns = arg.length;
+                  const nRows = arg[0].length;
+                  if (nColumns !== 1 || nRows !== 1) {
+                      vectorArgsType ??= new Array(args.length);
+                      if (nColumns !== 1 && nRows !== 1) {
+                          vectorArgsType[i] = "matrix";
+                          countVectorizableCol = Math.max(countVectorizableCol, nColumns);
+                          countVectorizableRow = Math.max(countVectorizableRow, nRows);
+                          vectorizableColLimit = Math.min(vectorizableColLimit, nColumns);
+                          vectorizableRowLimit = Math.min(vectorizableRowLimit, nRows);
+                      }
+                      else if (nColumns !== 1) {
+                          vectorArgsType[i] = "horizontal";
+                          countVectorizableCol = Math.max(countVectorizableCol, nColumns);
+                          vectorizableColLimit = Math.min(vectorizableColLimit, nColumns);
+                      }
+                      else if (nRows !== 1) {
+                          vectorArgsType[i] = "vertical";
+                          countVectorizableRow = Math.max(countVectorizableRow, nRows);
+                          vectorizableRowLimit = Math.min(vectorizableRowLimit, nRows);
+                      }
+                  }
+                  else {
+                      args[i] = arg[0][0];
                   }
-                  args[i] = arg[0][0];
               }
               if (!isMatrix(arg) && argDefinition.acceptMatrixOnly) {
                   throw new BadExpressionError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be reference to a cell or range.", (i + 1).toString()));
               }
           }
-          return descr.compute.apply(this, args);
+          //#endregion
+          if (countVectorizableCol === 1 && countVectorizableRow === 1) {
+              // either this function is not vectorized or it ends up with a 1x1 dimension
+              return computeFunctionToObject.apply(this, args);
+          }
+          const getArgOffset = (i, j) => args.map((arg, index) => {
+              switch (vectorArgsType?.[index]) {
+                  case "matrix":
+                      return arg[i][j];
+                  case "horizontal":
+                      return arg[i][0];
+                  case "vertical":
+                      return arg[0][j];
+                  case undefined:
+                      return arg;
+              }
+          });
+          return generateMatrix(countVectorizableCol, countVectorizableRow, (col, row) => {
+              if (col > vectorizableColLimit - 1 || row > vectorizableRowLimit - 1) {
+                  return notAvailableError;
+              }
+              const singleCellComputeResult = computeFunctionToObject.apply(this, getArgOffset(col, row));
+              // In the case where the user tries to vectorize arguments of an array formula, we will get an
+              // array for every combination of the vectorized arguments, which will lead to a 3D matrix and
+              // we won't be able to return the values.
+              // In this case, we keep the first element of each spreading part, just as Excel does, and
+              // create an array with these parts.
+              // For exemple, we have MUNIT(x) that return an unitary matrix of x*x. If we use it with a
+              // range, like MUNIT(A1:A2), we will get two unitary matrices (one for the value in A1 and one
+              // for the value in A2). In this case, we will simply take the first value of each matrix and
+              // return the array [First value of MUNIT(A1), First value of MUNIT(A2)].
+              return isMatrix(singleCellComputeResult)
+                  ? singleCellComputeResult[0][0]
+                  : singleCellComputeResult;
+          });
       }
-      return computeWithInputHandling;
-  }
-  function addErrorHandling(compute, functionName) {
-      return function (...args) {
-          try {
-              return compute.apply(this, args);
+      function computeFunctionToObject(...args) {
+          const result = descr.compute.apply(this, args);
+          if (!isMatrix(result)) {
+              if (typeof result === "object" && result !== null && "value" in result) {
+                  replaceFunctionNamePlaceholder(result, functionName);
+                  return result;
+              }
+              return { value: result };
           }
-          catch (e) {
-              return handleError(e, functionName);
+          if (typeof result[0][0] === "object" && result[0][0] !== null && "value" in result[0][0]) {
+              matrixForEach(result, (result) => replaceFunctionNamePlaceholder(result, functionName));
+              return result;
           }
-      };
+          return matrixMap(result, (row) => ({ value: row }));
+      }
+      return runtimeCompute;
   }
-  const implementationErrorMessage = _t("An unexpected error occurred. Submit a support ticket at odoo.com/help.");
   function handleError(e, functionName) {
       // the error could be an user error (instance of EvaluationError)
       // or a javascript error (instance of Error)
@@ -20012,42 +20483,16 @@ stores.inject(MyMetaStore, storeInstance);
       return (obj?.value !== undefined &&
           typeof obj.value === "string");
   }
-  function hasStringMessage(obj) {
-      return (obj?.message !== undefined &&
-          typeof obj.message === "string");
-  }
-  function addResultHandling(compute, functionName) {
-      return function computeWithResultHandling(...args) {
-          const result = compute.apply(this, args);
-          if (!isMatrix(result)) {
-              if (typeof result === "object" && result !== null && "value" in result) {
-                  replaceFunctionNamePlaceholder(result, functionName);
-                  return result;
-              }
-              return { value: result };
-          }
-          if (typeof result[0][0] === "object" && result[0][0] !== null && "value" in result[0][0]) {
-              matrixForEach(result, (result) => replaceFunctionNamePlaceholder(result, functionName));
-              return result;
-          }
-          return matrixMap(result, (row) => ({ value: row }));
-      };
-  }
-  function replaceFunctionNamePlaceholder(fPayload, functionName) {
+  function replaceFunctionNamePlaceholder(functionResult, functionName) {
       // for performance reasons: change in place and only if needed
-      if (fPayload.message?.includes("[[FUNCTION_NAME]]")) {
-          fPayload.message = fPayload.message.replace("[[FUNCTION_NAME]]", functionName);
+      if (functionResult.message?.includes("[[FUNCTION_NAME]]")) {
+          functionResult.message = functionResult.message.replace("[[FUNCTION_NAME]]", functionName);
       }
   }
-  const functionRegistry = new FunctionRegistry();
-  for (let category of categories) {
-      const fns = category.functions;
-      for (let name in fns) {
-          const addDescr = fns[name];
-          addDescr.category = addDescr.category || category.name;
-          name = name.replace(/_/g, ".");
-          functionRegistry.add(name, { isExported: false, ...addDescr });
-      }
+  const implementationErrorMessage = _t("An unexpected error occurred. Submit a support ticket at odoo.com/help.");
+  function hasStringMessage(obj) {
+      return (obj?.message !== undefined &&
+          typeof obj.message === "string");
   }
 
   autoCompleteProviders.add("functions", {
@@ -21496,6 +21941,7 @@ stores.inject(MyMetaStore, storeInstance);
 
   const functions$1 = functionRegistry.content;
   const OPERATOR_MAP = {
+      // export for test
       "=": "EQ",
       "+": "ADD",
       "-": "MINUS",
@@ -21510,6 +21956,7 @@ stores.inject(MyMetaStore, storeInstance);
       "&": "CONCATENATE",
   };
   const UNARY_OPERATOR_MAP = {
+      // export for test
       "-": "UMINUS",
       "+": "UPLUS",
       "%": "UNARY.PERCENT",
@@ -21580,7 +22027,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           /**
            * This function compiles all the information extracted by the parser into an
-           * executable code for the evaluation of the cells content. It uses a cash to
+           * executable code for the evaluation of the cells content. It uses a cache to
            * not reevaluate identical code structures.
            *
            * The function is sensitive to parameter “isMeta”. This
@@ -22798,8 +23245,7 @@ stores.inject(MyMetaStore, storeInstance);
   /**
    * Get a default chart js configuration
    */
-  function getDefaultChartJsRuntime(chart, labels, fontColor, args) {
-      const { format, locale, truncateLabels, horizontalChart } = args;
+  function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale, truncateLabels = true, horizontalChart, }) {
       const chartTitle = chart.title.text ? chart.title : { ...chart.title, content: "" };
       const options = {
           // https://www.chartjs.org/docs/latest/general/responsive.html
@@ -22948,14 +23394,17 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return datasetValues;
   }
-  /** See https://www.chartjs.org/docs/latest/charts/area.html#filling-modes */
-  function getFillingMode(index) {
-      if (index === 0) {
+  /**
+   * If the chart is a stacked area chart, we want to fill until the next dataset.
+   * If the chart is a simple area chart, we want to fill until the origin (bottom axis).
+   *
+   * See https://www.chartjs.org/docs/latest/charts/area.html#filling-modes
+   */
+  function getFillingMode(index, stackedChart) {
+      if (!stackedChart) {
           return "origin";
       }
-      else {
-          return index - 1;
-      }
+      return index === 0 ? "origin" : "-1";
   }
   function chartToImage(runtime, figure, type) {
       // wrap the canvas in a div with a fixed size because chart.js would
@@ -22972,7 +23421,6 @@ stores.inject(MyMetaStore, storeInstance);
       if ("chartJsConfig" in runtime) {
           const config = deepCopy(runtime.chartJsConfig);
           config.plugins = [backgroundColorChartJSPlugin];
-          // @ts-ignore
           const chart = new window.Chart(canvas, config);
           const imgContent = chart.toBase64Image();
           chart.destroy();
@@ -23022,6 +23470,7 @@ stores.inject(MyMetaStore, storeInstance);
       dataSetDesign;
       axesDesign;
       horizontal;
+      showValues;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -23034,6 +23483,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.dataSetDesign = definition.dataSets;
           this.axesDesign = definition.axesDesign;
           this.horizontal = definition.horizontal;
+          this.showValues = definition.showValues;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -23053,6 +23503,7 @@ stores.inject(MyMetaStore, storeInstance);
               type: "bar",
               labelRange: context.auxiliaryRange || undefined,
               axesDesign: context.axesDesign,
+              showValues: context.showValues,
           };
       }
       getContextCreation() {
@@ -23106,6 +23557,7 @@ stores.inject(MyMetaStore, storeInstance);
               aggregated: this.aggregated,
               axesDesign: this.axesDesign,
               horizontal: this.horizontal,
+              showValues: this.showValues,
           };
       }
       getDefinitionForExcel() {
@@ -23155,22 +23607,23 @@ stores.inject(MyMetaStore, storeInstance);
           padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
       };
       config.options.indexAxis = chart.horizontal ? "y" : "x";
+      const formatCallback = (value) => {
+          value = Number(value);
+          if (isNaN(value))
+              return value;
+          const { locale, format } = localeFormat;
+          return formatValue(value, {
+              locale,
+              format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
+          });
+      };
       config.options.scales = {};
       const labelsAxis = { ticks: { padding: 5, color: fontColor } };
       const valuesAxis = {
           beginAtZero: true, // the origin of the y axis is always zero
           ticks: {
               color: fontColor,
-              callback: (value) => {
-                  value = Number(value);
-                  if (isNaN(value))
-                      return value;
-                  const { locale, format } = localeFormat;
-                  return formatValue(value, {
-                      locale,
-                      format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
-                  });
-              },
+              callback: formatCallback,
           },
       };
       const xAxis = chart.horizontal ? valuesAxis : labelsAxis;
@@ -23203,6 +23656,12 @@ stores.inject(MyMetaStore, storeInstance);
               config.options.scales.y1.stacked = true;
           }
       }
+      config.options.plugins.chartShowValuesPlugin = {
+          showValues: chart.showValues,
+          background: chart.background,
+          horizontal: chart.horizontal,
+          callback: formatCallback,
+      };
       return config;
   }
   function createBarChartRuntime(chart, getters) {
@@ -23250,467 +23709,6 @@ stores.inject(MyMetaStore, storeInstance);
       return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
   }
 
-  class ComboChart extends AbstractChart {
-      dataSets;
-      labelRange;
-      background;
-      legendPosition;
-      aggregated;
-      dataSetsHaveTitle;
-      dataSetDesign;
-      axesDesign;
-      type = "combo";
-      constructor(definition, sheetId, getters) {
-          super(definition, sheetId, getters);
-          this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
-          this.labelRange = createValidRange(getters, sheetId, definition.labelRange);
-          this.background = definition.background;
-          this.legendPosition = definition.legendPosition;
-          this.aggregated = definition.aggregated;
-          this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
-          this.dataSetDesign = definition.dataSets;
-          this.axesDesign = definition.axesDesign;
-      }
-      static transformDefinition(definition, executed) {
-          return transformChartDefinitionWithDataSetsWithZone(definition, executed);
-      }
-      static validateChartDefinition(validator, definition) {
-          return validator.checkValidations(definition, checkDataset, checkLabelRange);
-      }
-      getContextCreation() {
-          const range = [];
-          for (const [i, dataSet] of this.dataSets.entries()) {
-              range.push({
-                  ...this.dataSetDesign?.[i],
-                  dataRange: this.getters.getRangeString(dataSet.dataRange, this.sheetId),
-              });
-          }
-          return {
-              ...this,
-              range,
-              auxiliaryRange: this.labelRange
-                  ? this.getters.getRangeString(this.labelRange, this.sheetId)
-                  : undefined,
-          };
-      }
-      getDefinition() {
-          return this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange);
-      }
-      getDefinitionWithSpecificDataSets(dataSets, labelRange, targetSheetId) {
-          const ranges = [];
-          for (const [i, dataSet] of dataSets.entries()) {
-              ranges.push({
-                  ...this.dataSetDesign?.[i],
-                  dataRange: this.getters.getRangeString(dataSet.dataRange, targetSheetId || this.sheetId),
-              });
-          }
-          return {
-              type: "combo",
-              dataSetsHaveTitle: dataSets.length ? Boolean(dataSets[0].labelCell) : false,
-              background: this.background,
-              dataSets: ranges,
-              legendPosition: this.legendPosition,
-              labelRange: labelRange
-                  ? this.getters.getRangeString(labelRange, targetSheetId || this.sheetId)
-                  : undefined,
-              title: this.title,
-              aggregated: this.aggregated,
-              axesDesign: this.axesDesign,
-          };
-      }
-      getDefinitionForExcel() {
-          // Excel does not support aggregating labels
-          if (this.aggregated) {
-              return undefined;
-          }
-          const dataSets = this.dataSets
-              .map((ds) => toExcelDataset(this.getters, ds))
-              .filter((ds) => ds.range !== "" && ds.range !== CellErrorType.InvalidReference);
-          const labelRange = toExcelLabelRange(this.getters, this.labelRange, shouldRemoveFirstLabel(this.labelRange, this.dataSets[0], this.dataSetsHaveTitle));
-          const definition = this.getDefinition();
-          return {
-              ...definition,
-              backgroundColor: toXlsxHexColor(this.background || BACKGROUND_CHART_COLOR),
-              fontColor: toXlsxHexColor(chartFontColor(this.background)),
-              dataSets,
-              labelRange,
-              verticalAxis: getDefinedAxis(definition),
-          };
-      }
-      updateRanges(applyChange) {
-          const { dataSets, labelRange, isStale } = updateChartRangesWithDataSets(this.getters, applyChange, this.dataSets, this.labelRange);
-          if (!isStale) {
-              return this;
-          }
-          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange);
-          return new ComboChart(definition, this.sheetId, this.getters);
-      }
-      static getDefinitionFromContextCreation(context) {
-          return {
-              background: context.background,
-              dataSets: context.range ?? [],
-              dataSetsHaveTitle: context.dataSetsHaveTitle ?? false,
-              aggregated: context.aggregated,
-              legendPosition: context.legendPosition ?? "top",
-              title: context.title || { text: "" },
-              labelRange: context.auxiliaryRange || undefined,
-              type: "combo",
-              axesDesign: context.axesDesign,
-          };
-      }
-      copyForSheetId(sheetId) {
-          const dataSets = copyDataSetsWithNewSheetId(this.sheetId, sheetId, this.dataSets);
-          const labelRange = copyLabelRangeWithNewSheetId(this.sheetId, sheetId, this.labelRange);
-          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange, sheetId);
-          return new ComboChart(definition, sheetId, this.getters);
-      }
-      copyInSheetId(sheetId) {
-          const definition = this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange, sheetId);
-          return new ComboChart(definition, sheetId, this.getters);
-      }
-  }
-  function createComboChartRuntime(chart, getters) {
-      const mainDataSetFormat = chart.dataSets.length
-          ? getChartDatasetFormat(getters, [chart.dataSets[0]])
-          : undefined;
-      const lineDataSetsFormat = getChartDatasetFormat(getters, chart.dataSets.slice(1));
-      const locale = getters.getLocale();
-      const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
-      let labels = labelValues.formattedValues;
-      let dataSetsValues = getChartDatasetValues(getters, chart.dataSets);
-      if (chart.dataSetsHaveTitle &&
-          dataSetsValues[0] &&
-          labels.length > dataSetsValues[0].data.length) {
-          labels.shift();
-      }
-      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
-      if (chart.aggregated) {
-          ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
-      }
-      const localeFormat = { format: mainDataSetFormat, locale };
-      const fontColor = chartFontColor(chart.background);
-      const config = getDefaultChartJsRuntime(chart, labels, fontColor, localeFormat);
-      const legend = {
-          labels: { color: fontColor },
-          reverse: true,
-      };
-      if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
-          legend.display = false;
-      }
-      else {
-          legend.position = chart.legendPosition;
-      }
-      config.options.plugins.legend = { ...config.options.plugins?.legend, ...legend };
-      config.options.layout = {
-          padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
-      };
-      config.options.scales = {
-          x: {
-              ticks: {
-                  padding: 5,
-                  color: fontColor,
-              },
-              title: getChartAxisTitleRuntime(chart.axesDesign?.x),
-          },
-      };
-      const formatCallback = (format) => {
-          return (value) => {
-              value = Number(value);
-              if (isNaN(value))
-                  return value;
-              const { locale } = localeFormat;
-              return formatValue(value, {
-                  locale,
-                  format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
-              });
-          };
-      };
-      const leftVerticalAxis = {
-          beginAtZero: true, // the origin of the y axis is always zero
-          ticks: {
-              color: fontColor,
-              callback: formatCallback(mainDataSetFormat),
-          },
-      };
-      const rightVerticalAxis = {
-          beginAtZero: true, // the origin of the y axis is always zero
-          ticks: {
-              color: fontColor,
-              callback: formatCallback(lineDataSetsFormat),
-          },
-      };
-      const definition = chart.getDefinition();
-      const { useLeftAxis, useRightAxis } = getDefinedAxis(definition);
-      if (useLeftAxis) {
-          config.options.scales.y = {
-              ...leftVerticalAxis,
-              position: "left",
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y),
-          };
-      }
-      if (useRightAxis) {
-          config.options.scales.y1 = {
-              ...rightVerticalAxis,
-              position: "right",
-              grid: {
-                  display: false,
-              },
-              title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
-          };
-      }
-      const colors = new ColorGenerator();
-      for (let [index, { label, data }] of dataSetsValues.entries()) {
-          const design = definition.dataSets[index];
-          const color = colors.next();
-          const dataset = {
-              label: design?.label ?? label,
-              data,
-              borderColor: design?.backgroundColor ?? color,
-              backgroundColor: design.backgroundColor ?? color,
-              yAxisID: design?.yAxisId ?? "y",
-              type: index === 0 ? "bar" : "line",
-              order: -index,
-          };
-          config.data.datasets.push(dataset);
-      }
-      return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
-  }
-
-  function isDataRangeValid(definition) {
-      return definition.dataRange && !rangeReference.test(definition.dataRange)
-          ? "InvalidGaugeDataRange" /* CommandResult.InvalidGaugeDataRange */
-          : "Success" /* CommandResult.Success */;
-  }
-  function checkRangeLimits(check, batchValidations) {
-      return batchValidations((definition) => {
-          if (definition.sectionRule) {
-              return check(definition.sectionRule.rangeMin, "rangeMin");
-          }
-          return "Success" /* CommandResult.Success */;
-      }, (definition) => {
-          if (definition.sectionRule) {
-              return check(definition.sectionRule.rangeMax, "rangeMax");
-          }
-          return "Success" /* CommandResult.Success */;
-      });
-  }
-  function checkInflectionPointsValue(check, batchValidations) {
-      return batchValidations((definition) => {
-          if (definition.sectionRule) {
-              return check(definition.sectionRule.lowerInflectionPoint.value, "lowerInflectionPointValue");
-          }
-          return "Success" /* CommandResult.Success */;
-      }, (definition) => {
-          if (definition.sectionRule) {
-              return check(definition.sectionRule.upperInflectionPoint.value, "upperInflectionPointValue");
-          }
-          return "Success" /* CommandResult.Success */;
-      });
-  }
-  function checkRangeMinBiggerThanRangeMax(definition) {
-      if (definition.sectionRule) {
-          if (Number(definition.sectionRule.rangeMin) >= Number(definition.sectionRule.rangeMax)) {
-              return "GaugeRangeMinBiggerThanRangeMax" /* CommandResult.GaugeRangeMinBiggerThanRangeMax */;
-          }
-      }
-      return "Success" /* CommandResult.Success */;
-  }
-  function checkEmpty(value, valueName) {
-      if (value === "") {
-          switch (valueName) {
-              case "rangeMin":
-                  return "EmptyGaugeRangeMin" /* CommandResult.EmptyGaugeRangeMin */;
-              case "rangeMax":
-                  return "EmptyGaugeRangeMax" /* CommandResult.EmptyGaugeRangeMax */;
-          }
-      }
-      return "Success" /* CommandResult.Success */;
-  }
-  function checkNaN(value, valueName) {
-      if (isNaN(value)) {
-          switch (valueName) {
-              case "rangeMin":
-                  return "GaugeRangeMinNaN" /* CommandResult.GaugeRangeMinNaN */;
-              case "rangeMax":
-                  return "GaugeRangeMaxNaN" /* CommandResult.GaugeRangeMaxNaN */;
-              case "lowerInflectionPointValue":
-                  return "GaugeLowerInflectionPointNaN" /* CommandResult.GaugeLowerInflectionPointNaN */;
-              case "upperInflectionPointValue":
-                  return "GaugeUpperInflectionPointNaN" /* CommandResult.GaugeUpperInflectionPointNaN */;
-          }
-      }
-      return "Success" /* CommandResult.Success */;
-  }
-  class GaugeChart extends AbstractChart {
-      dataRange;
-      sectionRule;
-      background;
-      type = "gauge";
-      constructor(definition, sheetId, getters) {
-          super(definition, sheetId, getters);
-          this.dataRange = createValidRange(this.getters, this.sheetId, definition.dataRange);
-          this.sectionRule = definition.sectionRule;
-          this.background = definition.background;
-      }
-      static validateChartDefinition(validator, definition) {
-          return validator.checkValidations(definition, isDataRangeValid, validator.chainValidations(checkRangeLimits(checkEmpty, validator.batchValidations), checkRangeLimits(checkNaN, validator.batchValidations), checkRangeMinBiggerThanRangeMax), validator.chainValidations(checkInflectionPointsValue(checkNaN, validator.batchValidations)));
-      }
-      static transformDefinition(definition, executed) {
-          let dataRangeZone;
-          if (definition.dataRange) {
-              dataRangeZone = transformZone(toUnboundedZone(definition.dataRange), executed);
-          }
-          return {
-              ...definition,
-              dataRange: dataRangeZone ? zoneToXc(dataRangeZone) : undefined,
-          };
-      }
-      static getDefinitionFromContextCreation(context) {
-          return {
-              background: context.background,
-              title: context.title || { text: "" },
-              type: "gauge",
-              dataRange: context.range ? context.range[0].dataRange : undefined,
-              sectionRule: {
-                  colors: {
-                      lowerColor: DEFAULT_GAUGE_LOWER_COLOR,
-                      middleColor: DEFAULT_GAUGE_MIDDLE_COLOR,
-                      upperColor: DEFAULT_GAUGE_UPPER_COLOR,
-                  },
-                  rangeMin: "0",
-                  rangeMax: "100",
-                  lowerInflectionPoint: {
-                      type: "percentage",
-                      value: "15",
-                  },
-                  upperInflectionPoint: {
-                      type: "percentage",
-                      value: "40",
-                  },
-              },
-          };
-      }
-      copyForSheetId(sheetId) {
-          const dataRange = copyLabelRangeWithNewSheetId(this.sheetId, sheetId, this.dataRange);
-          const definition = this.getDefinitionWithSpecificRanges(dataRange, sheetId);
-          return new GaugeChart(definition, sheetId, this.getters);
-      }
-      copyInSheetId(sheetId) {
-          const definition = this.getDefinitionWithSpecificRanges(this.dataRange, sheetId);
-          return new GaugeChart(definition, sheetId, this.getters);
-      }
-      getDefinition() {
-          return this.getDefinitionWithSpecificRanges(this.dataRange);
-      }
-      getDefinitionWithSpecificRanges(dataRange, targetSheetId) {
-          return {
-              background: this.background,
-              sectionRule: this.sectionRule,
-              title: this.title,
-              type: "gauge",
-              dataRange: dataRange
-                  ? this.getters.getRangeString(dataRange, targetSheetId || this.sheetId)
-                  : undefined,
-          };
-      }
-      getDefinitionForExcel() {
-          // This kind of graph is not exportable in Excel
-          return undefined;
-      }
-      getContextCreation() {
-          return {
-              ...this,
-              range: this.dataRange
-                  ? [{ dataRange: this.getters.getRangeString(this.dataRange, this.sheetId) }]
-                  : undefined,
-          };
-      }
-      updateRanges(applyChange) {
-          const range = adaptChartRange(this.dataRange, applyChange);
-          if (this.dataRange === range) {
-              return this;
-          }
-          const definition = this.getDefinitionWithSpecificRanges(range);
-          return new GaugeChart(definition, this.sheetId, this.getters);
-      }
-  }
-  function createGaugeChartRuntime(chart, getters) {
-      const locale = getters.getLocale();
-      const chartColors = chart.sectionRule.colors;
-      let gaugeValue = undefined;
-      let formattedValue = undefined;
-      let format = undefined;
-      const dataRange = chart.dataRange;
-      if (dataRange !== undefined) {
-          const cell = getters.getEvaluatedCell({
-              sheetId: dataRange.sheetId,
-              col: dataRange.zone.left,
-              row: dataRange.zone.top,
-          });
-          if (cell.type === CellValueType.number) {
-              gaugeValue = cell.value;
-              formattedValue = cell.formattedValue;
-              format = cell.format;
-          }
-      }
-      const minValue = Number(chart.sectionRule.rangeMin);
-      const maxValue = Number(chart.sectionRule.rangeMax);
-      const lowerPoint = chart.sectionRule.lowerInflectionPoint;
-      const upperPoint = chart.sectionRule.upperInflectionPoint;
-      const lowerPointValue = getSectionThresholdValue(lowerPoint, minValue, maxValue);
-      const upperPointValue = getSectionThresholdValue(upperPoint, minValue, maxValue);
-      const inflectionValues = [];
-      const colors = [];
-      if (lowerPointValue !== undefined) {
-          inflectionValues.push({
-              value: lowerPointValue,
-              label: formatValue(lowerPointValue, { locale, format }),
-          });
-          colors.push(chartColors.lowerColor);
-      }
-      if (upperPointValue !== undefined && upperPointValue !== lowerPointValue) {
-          inflectionValues.push({
-              value: upperPointValue,
-              label: formatValue(upperPointValue, { locale, format }),
-          });
-          colors.push(chartColors.middleColor);
-      }
-      if (upperPointValue !== undefined &&
-          lowerPointValue !== undefined &&
-          lowerPointValue > upperPointValue) {
-          inflectionValues.reverse();
-          colors.reverse();
-      }
-      colors.push(chartColors.upperColor);
-      return {
-          background: getters.getStyleOfSingleCellChart(chart.background, dataRange).background,
-          title: chart.title ?? { text: "" },
-          minValue: {
-              value: minValue,
-              label: formatValue(minValue, { locale, format }),
-          },
-          maxValue: {
-              value: maxValue,
-              label: formatValue(maxValue, { locale, format }),
-          },
-          gaugeValue: gaugeValue !== undefined && formattedValue
-              ? { value: gaugeValue, label: formattedValue }
-              : undefined,
-          inflectionValues,
-          colors,
-      };
-  }
-  function getSectionThresholdValue(threshold, minValue, maxValue) {
-      if (threshold.value === "" || isNaN(Number(threshold.value))) {
-          return undefined;
-      }
-      const numberValue = Number(threshold.value);
-      const value = threshold.type === "number"
-          ? numberValue
-          : minValue + ((maxValue - minValue) * numberValue) / 100;
-      return clip(value, minValue, maxValue);
-  }
-
   const UNIT_LENGTH = {
       second: 1000,
       minute: 1000 * 60,
@@ -23893,13 +23891,11 @@ stores.inject(MyMetaStore, storeInstance);
   }
   let missingTimeAdapterAlreadyWarned = false;
   function isLuxonTimeAdapterInstalled() {
-      // @ts-ignore
       if (!window.Chart) {
           return false;
       }
       // @ts-ignore
       const adapter = new window.Chart._adapters._date({});
-      // @ts-ignore
       const isInstalled = adapter._id === "luxon";
       if (!isInstalled && !missingTimeAdapterAlreadyWarned) {
           missingTimeAdapterAlreadyWarned = true;
@@ -23916,9 +23912,7 @@ stores.inject(MyMetaStore, storeInstance);
               generateLabels(chart) {
                   // color the legend labels with the dataset color, without any transparency
                   const { data } = chart;
-                  /** @ts-ignore */
-                  const labels = window.Chart.defaults.plugins.legend.labels
-                      .generateLabels(chart);
+                  const labels = window.Chart.defaults.plugins.legend.labels.generateLabels(chart);
                   for (const [index, label] of labels.entries()) {
                       label.fillStyle = data.datasets[index].borderColor;
                   }
@@ -23945,151 +23939,628 @@ stores.inject(MyMetaStore, storeInstance);
               title: getChartAxisTitleRuntime(chart.axesDesign?.x),
           },
       };
-      const yAxis = {
+      const formatCallback = (value) => {
+          value = Number(value);
+          if (isNaN(value))
+              return value;
+          const { locale, format } = options;
+          return formatValue(value, {
+              locale,
+              format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
+          });
+      };
+      const yAxis = {
+          beginAtZero: true, // the origin of the y axis is always zero
+          ticks: {
+              color: fontColor,
+              callback: formatCallback,
+          },
+      };
+      const { useLeftAxis, useRightAxis } = getDefinedAxis(chart.getDefinition());
+      if (useLeftAxis) {
+          config.options.scales.y = {
+              ...yAxis,
+              position: "left",
+              title: getChartAxisTitleRuntime(chart.axesDesign?.y),
+          };
+      }
+      if (useRightAxis) {
+          config.options.scales.y1 = {
+              ...yAxis,
+              position: "right",
+              title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
+          };
+      }
+      if ("stacked" in chart && chart.stacked) {
+          if (useLeftAxis) {
+              // @ts-ignore chart.js type is broken
+              config.options.scales.y.stacked = true;
+          }
+          if (useRightAxis) {
+              // @ts-ignore chart.js type is broken
+              config.options.scales.y1.stacked = true;
+          }
+      }
+      config.options.plugins.chartShowValuesPlugin = {
+          showValues: chart.showValues,
+          background: chart.background,
+          callback: formatCallback,
+      };
+      return config;
+  }
+  function createLineOrScatterChartRuntime(chart, getters) {
+      const axisType = getChartAxisType(chart, getters);
+      const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
+      let labels = axisType === "linear" ? labelValues.values : labelValues.formattedValues;
+      let dataSetsValues = getChartDatasetValues(getters, chart.dataSets);
+      if (chart.dataSetsHaveTitle &&
+          dataSetsValues[0] &&
+          labels.length > dataSetsValues[0].data.length) {
+          labels.shift();
+      }
+      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+      if (axisType === "time") {
+          ({ labels, dataSetsValues } = fixEmptyLabelsForDateCharts(labels, dataSetsValues));
+      }
+      if (chart.aggregated) {
+          ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
+      }
+      const locale = getters.getLocale();
+      const truncateLabels = axisType === "category";
+      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
+      const options = { format: dataSetFormat, locale, truncateLabels };
+      const config = getLineOrScatterConfiguration(chart, labels, options);
+      const labelFormat = getChartLabelFormat(getters, chart.labelRange);
+      if (axisType === "time") {
+          const axis = {
+              type: "time",
+              time: getChartTimeOptions(labels, labelFormat, locale),
+          };
+          Object.assign(config.options.scales.x, axis);
+          config.options.scales.x.ticks.maxTicksLimit = 15;
+      }
+      else if (axisType === "linear") {
+          config.options.scales.x.type = "linear";
+          config.options.scales.x.ticks.callback = (value) => formatValue(value, { format: labelFormat, locale });
+          config.options.plugins.tooltip.callbacks.title = (tooltipItem) => {
+              return formatValue(tooltipItem[0].parsed.x || tooltipItem[0].label, {
+                  locale,
+                  format: labelFormat,
+              });
+          };
+      }
+      const areaChart = "fillArea" in chart ? chart.fillArea : false;
+      const stackedChart = "stacked" in chart ? chart.stacked : false;
+      const cumulative = "cumulative" in chart ? chart.cumulative : false;
+      const colors = new ColorGenerator();
+      const definition = chart.getDefinition();
+      for (let [index, { label, data }] of dataSetsValues.entries()) {
+          const color = colors.next();
+          let backgroundRGBA = colorToRGBA(color);
+          if (areaChart) {
+              backgroundRGBA.a = LINE_FILL_TRANSPARENCY;
+          }
+          if (cumulative) {
+              let accumulator = 0;
+              data = data.map((value) => {
+                  if (!isNaN(value)) {
+                      accumulator += parseFloat(value);
+                      return accumulator;
+                  }
+                  return value;
+              });
+          }
+          if (["linear", "time"].includes(axisType)) {
+              // Replace empty string labels by undefined to make sure chartJS doesn't decide that "" is the same as 0
+              data = data.map((y, index) => ({ x: labels[index] || undefined, y }));
+          }
+          const backgroundColor = rgbaToHex(backgroundRGBA);
+          const dataset = {
+              label,
+              data,
+              tension: 0, // 0 -> render straight lines, which is much faster
+              borderColor: color,
+              backgroundColor,
+              pointBackgroundColor: color,
+              fill: areaChart ? getFillingMode(index, stackedChart) : false,
+          };
+          config.data.datasets.push(dataset);
+      }
+      for (const [index, dataset] of config.data.datasets.entries()) {
+          if (definition.dataSets?.[index]?.backgroundColor) {
+              const color = definition.dataSets[index].backgroundColor;
+              dataset.backgroundColor = color;
+              dataset.borderColor = color;
+              //@ts-ignore
+              dataset.pointBackgroundColor = color;
+          }
+          if (definition.dataSets?.[index]?.label) {
+              const label = definition.dataSets[index].label;
+              dataset.label = label;
+          }
+          if (definition.dataSets?.[index]?.yAxisId) {
+              dataset["yAxisID"] = definition.dataSets[index].yAxisId;
+          }
+      }
+      return {
+          chartJsConfig: config,
+          background: chart.background || BACKGROUND_CHART_COLOR,
+          dataSetsValues,
+          labelValues,
+          dataSetFormat,
+          labelFormat,
+      };
+  }
+
+  class ComboChart extends AbstractChart {
+      dataSets;
+      labelRange;
+      background;
+      legendPosition;
+      aggregated;
+      dataSetsHaveTitle;
+      dataSetDesign;
+      axesDesign;
+      type = "combo";
+      showValues;
+      constructor(definition, sheetId, getters) {
+          super(definition, sheetId, getters);
+          this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
+          this.labelRange = createValidRange(getters, sheetId, definition.labelRange);
+          this.background = definition.background;
+          this.legendPosition = definition.legendPosition;
+          this.aggregated = definition.aggregated;
+          this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
+          this.dataSetDesign = definition.dataSets;
+          this.axesDesign = definition.axesDesign;
+          this.showValues = definition.showValues;
+      }
+      static transformDefinition(definition, executed) {
+          return transformChartDefinitionWithDataSetsWithZone(definition, executed);
+      }
+      static validateChartDefinition(validator, definition) {
+          return validator.checkValidations(definition, checkDataset, checkLabelRange);
+      }
+      getContextCreation() {
+          const range = [];
+          for (const [i, dataSet] of this.dataSets.entries()) {
+              range.push({
+                  ...this.dataSetDesign?.[i],
+                  dataRange: this.getters.getRangeString(dataSet.dataRange, this.sheetId),
+              });
+          }
+          return {
+              ...this,
+              range,
+              auxiliaryRange: this.labelRange
+                  ? this.getters.getRangeString(this.labelRange, this.sheetId)
+                  : undefined,
+          };
+      }
+      getDefinition() {
+          return this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange);
+      }
+      getDefinitionWithSpecificDataSets(dataSets, labelRange, targetSheetId) {
+          const ranges = [];
+          for (const [i, dataSet] of dataSets.entries()) {
+              ranges.push({
+                  ...this.dataSetDesign?.[i],
+                  dataRange: this.getters.getRangeString(dataSet.dataRange, targetSheetId || this.sheetId),
+              });
+          }
+          return {
+              type: "combo",
+              dataSetsHaveTitle: dataSets.length ? Boolean(dataSets[0].labelCell) : false,
+              background: this.background,
+              dataSets: ranges,
+              legendPosition: this.legendPosition,
+              labelRange: labelRange
+                  ? this.getters.getRangeString(labelRange, targetSheetId || this.sheetId)
+                  : undefined,
+              title: this.title,
+              aggregated: this.aggregated,
+              axesDesign: this.axesDesign,
+              showValues: this.showValues,
+          };
+      }
+      getDefinitionForExcel() {
+          // Excel does not support aggregating labels
+          if (this.aggregated) {
+              return undefined;
+          }
+          const dataSets = this.dataSets
+              .map((ds) => toExcelDataset(this.getters, ds))
+              .filter((ds) => ds.range !== "" && ds.range !== CellErrorType.InvalidReference);
+          const labelRange = toExcelLabelRange(this.getters, this.labelRange, shouldRemoveFirstLabel(this.labelRange, this.dataSets[0], this.dataSetsHaveTitle));
+          const definition = this.getDefinition();
+          return {
+              ...definition,
+              backgroundColor: toXlsxHexColor(this.background || BACKGROUND_CHART_COLOR),
+              fontColor: toXlsxHexColor(chartFontColor(this.background)),
+              dataSets,
+              labelRange,
+              verticalAxis: getDefinedAxis(definition),
+          };
+      }
+      updateRanges(applyChange) {
+          const { dataSets, labelRange, isStale } = updateChartRangesWithDataSets(this.getters, applyChange, this.dataSets, this.labelRange);
+          if (!isStale) {
+              return this;
+          }
+          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange);
+          return new ComboChart(definition, this.sheetId, this.getters);
+      }
+      static getDefinitionFromContextCreation(context) {
+          return {
+              background: context.background,
+              dataSets: context.range ?? [],
+              dataSetsHaveTitle: context.dataSetsHaveTitle ?? false,
+              aggregated: context.aggregated,
+              legendPosition: context.legendPosition ?? "top",
+              title: context.title || { text: "" },
+              labelRange: context.auxiliaryRange || undefined,
+              type: "combo",
+              axesDesign: context.axesDesign,
+              showValues: context.showValues,
+          };
+      }
+      copyForSheetId(sheetId) {
+          const dataSets = copyDataSetsWithNewSheetId(this.sheetId, sheetId, this.dataSets);
+          const labelRange = copyLabelRangeWithNewSheetId(this.sheetId, sheetId, this.labelRange);
+          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange, sheetId);
+          return new ComboChart(definition, sheetId, this.getters);
+      }
+      copyInSheetId(sheetId) {
+          const definition = this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange, sheetId);
+          return new ComboChart(definition, sheetId, this.getters);
+      }
+  }
+  function createComboChartRuntime(chart, getters) {
+      const mainDataSetFormat = chart.dataSets.length
+          ? getChartDatasetFormat(getters, [chart.dataSets[0]])
+          : undefined;
+      const lineDataSetsFormat = getChartDatasetFormat(getters, chart.dataSets.slice(1));
+      const locale = getters.getLocale();
+      const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
+      let labels = labelValues.formattedValues;
+      let dataSetsValues = getChartDatasetValues(getters, chart.dataSets);
+      if (chart.dataSetsHaveTitle &&
+          dataSetsValues[0] &&
+          labels.length > dataSetsValues[0].data.length) {
+          labels.shift();
+      }
+      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+      if (chart.aggregated) {
+          ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
+      }
+      const localeFormat = { format: mainDataSetFormat, locale };
+      const fontColor = chartFontColor(chart.background);
+      const config = getDefaultChartJsRuntime(chart, labels, fontColor, localeFormat);
+      const legend = {
+          labels: { color: fontColor },
+          reverse: true,
+      };
+      if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
+          legend.display = false;
+      }
+      else {
+          legend.position = chart.legendPosition;
+      }
+      config.options.plugins.legend = { ...config.options.plugins?.legend, ...legend };
+      config.options.layout = {
+          padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
+      };
+      config.options.scales = {
+          x: {
+              ticks: {
+                  padding: 5,
+                  color: fontColor,
+              },
+              title: getChartAxisTitleRuntime(chart.axesDesign?.x),
+          },
+      };
+      const formatCallback = (format) => {
+          return (value) => {
+              value = Number(value);
+              if (isNaN(value))
+                  return value;
+              const { locale } = localeFormat;
+              return formatValue(value, {
+                  locale,
+                  format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
+              });
+          };
+      };
+      const leftVerticalAxis = {
+          beginAtZero: true, // the origin of the y axis is always zero
+          ticks: {
+              color: fontColor,
+              callback: formatCallback(mainDataSetFormat),
+          },
+      };
+      const rightVerticalAxis = {
           beginAtZero: true, // the origin of the y axis is always zero
           ticks: {
               color: fontColor,
-              callback: (value) => {
-                  value = Number(value);
-                  if (isNaN(value))
-                      return value;
-                  const { locale, format } = options;
-                  return formatValue(value, {
-                      locale,
-                      format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
-                  });
-              },
+              callback: formatCallback(lineDataSetsFormat),
           },
       };
-      const { useLeftAxis, useRightAxis } = getDefinedAxis(chart.getDefinition());
+      const definition = chart.getDefinition();
+      const { useLeftAxis, useRightAxis } = getDefinedAxis(definition);
       if (useLeftAxis) {
           config.options.scales.y = {
-              ...yAxis,
+              ...leftVerticalAxis,
               position: "left",
               title: getChartAxisTitleRuntime(chart.axesDesign?.y),
           };
       }
       if (useRightAxis) {
           config.options.scales.y1 = {
-              ...yAxis,
+              ...rightVerticalAxis,
               position: "right",
+              grid: {
+                  display: false,
+              },
               title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
           };
       }
-      if ("stacked" in chart && chart.stacked) {
-          if (useLeftAxis) {
-              // @ts-ignore chart.js type is broken
-              config.options.scales.y.stacked = true;
+      config.options.plugins.chartShowValuesPlugin = {
+          showValues: chart.showValues,
+          background: chart.background,
+          callback: formatCallback(mainDataSetFormat),
+      };
+      const colors = new ColorGenerator();
+      for (let [index, { label, data }] of dataSetsValues.entries()) {
+          const design = definition.dataSets[index];
+          const color = colors.next();
+          const dataset = {
+              label: design?.label ?? label,
+              data,
+              borderColor: design?.backgroundColor ?? color,
+              backgroundColor: design.backgroundColor ?? color,
+              yAxisID: design?.yAxisId ?? "y",
+              type: index === 0 ? "bar" : "line",
+              order: -index,
+          };
+          config.data.datasets.push(dataset);
+      }
+      return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
+  }
+
+  function isDataRangeValid(definition) {
+      return definition.dataRange && !rangeReference.test(definition.dataRange)
+          ? "InvalidGaugeDataRange" /* CommandResult.InvalidGaugeDataRange */
+          : "Success" /* CommandResult.Success */;
+  }
+  function checkRangeLimits(check, batchValidations) {
+      return batchValidations((definition) => {
+          if (definition.sectionRule) {
+              return check(definition.sectionRule.rangeMin, "rangeMin");
           }
-          if (useRightAxis) {
-              // @ts-ignore chart.js type is broken
-              config.options.scales.y1.stacked = true;
+          return "Success" /* CommandResult.Success */;
+      }, (definition) => {
+          if (definition.sectionRule) {
+              return check(definition.sectionRule.rangeMax, "rangeMax");
+          }
+          return "Success" /* CommandResult.Success */;
+      });
+  }
+  function checkInflectionPointsValue(check, batchValidations) {
+      return batchValidations((definition) => {
+          if (definition.sectionRule) {
+              return check(definition.sectionRule.lowerInflectionPoint.value, "lowerInflectionPointValue");
+          }
+          return "Success" /* CommandResult.Success */;
+      }, (definition) => {
+          if (definition.sectionRule) {
+              return check(definition.sectionRule.upperInflectionPoint.value, "upperInflectionPointValue");
+          }
+          return "Success" /* CommandResult.Success */;
+      });
+  }
+  function checkRangeMinBiggerThanRangeMax(definition) {
+      if (definition.sectionRule) {
+          if (Number(definition.sectionRule.rangeMin) >= Number(definition.sectionRule.rangeMax)) {
+              return "GaugeRangeMinBiggerThanRangeMax" /* CommandResult.GaugeRangeMinBiggerThanRangeMax */;
           }
       }
-      return config;
+      return "Success" /* CommandResult.Success */;
   }
-  function createLineOrScatterChartRuntime(chart, getters) {
-      const axisType = getChartAxisType(chart, getters);
-      const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
-      let labels = axisType === "linear" ? labelValues.values : labelValues.formattedValues;
-      let dataSetsValues = getChartDatasetValues(getters, chart.dataSets);
-      if (chart.dataSetsHaveTitle &&
-          dataSetsValues[0] &&
-          labels.length > dataSetsValues[0].data.length) {
-          labels.shift();
+  function checkEmpty(value, valueName) {
+      if (value === "") {
+          switch (valueName) {
+              case "rangeMin":
+                  return "EmptyGaugeRangeMin" /* CommandResult.EmptyGaugeRangeMin */;
+              case "rangeMax":
+                  return "EmptyGaugeRangeMax" /* CommandResult.EmptyGaugeRangeMax */;
+          }
       }
-      ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
-      if (axisType === "time") {
-          ({ labels, dataSetsValues } = fixEmptyLabelsForDateCharts(labels, dataSetsValues));
+      return "Success" /* CommandResult.Success */;
+  }
+  function checkNaN(value, valueName) {
+      if (isNaN(value)) {
+          switch (valueName) {
+              case "rangeMin":
+                  return "GaugeRangeMinNaN" /* CommandResult.GaugeRangeMinNaN */;
+              case "rangeMax":
+                  return "GaugeRangeMaxNaN" /* CommandResult.GaugeRangeMaxNaN */;
+              case "lowerInflectionPointValue":
+                  return "GaugeLowerInflectionPointNaN" /* CommandResult.GaugeLowerInflectionPointNaN */;
+              case "upperInflectionPointValue":
+                  return "GaugeUpperInflectionPointNaN" /* CommandResult.GaugeUpperInflectionPointNaN */;
+          }
       }
-      if (chart.aggregated) {
-          ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
+      return "Success" /* CommandResult.Success */;
+  }
+  class GaugeChart extends AbstractChart {
+      dataRange;
+      sectionRule;
+      background;
+      type = "gauge";
+      constructor(definition, sheetId, getters) {
+          super(definition, sheetId, getters);
+          this.dataRange = createValidRange(this.getters, this.sheetId, definition.dataRange);
+          this.sectionRule = definition.sectionRule;
+          this.background = definition.background;
       }
-      const locale = getters.getLocale();
-      const truncateLabels = axisType === "category";
-      const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
-      const options = { format: dataSetFormat, locale, truncateLabels };
-      const config = getLineOrScatterConfiguration(chart, labels, options);
-      const labelFormat = getChartLabelFormat(getters, chart.labelRange);
-      if (axisType === "time") {
-          const axis = {
-              type: "time",
-              time: getChartTimeOptions(labels, labelFormat, locale),
+      static validateChartDefinition(validator, definition) {
+          return validator.checkValidations(definition, isDataRangeValid, validator.chainValidations(checkRangeLimits(checkEmpty, validator.batchValidations), checkRangeLimits(checkNaN, validator.batchValidations), checkRangeMinBiggerThanRangeMax), validator.chainValidations(checkInflectionPointsValue(checkNaN, validator.batchValidations)));
+      }
+      static transformDefinition(definition, executed) {
+          let dataRangeZone;
+          if (definition.dataRange) {
+              dataRangeZone = transformZone(toUnboundedZone(definition.dataRange), executed);
+          }
+          return {
+              ...definition,
+              dataRange: dataRangeZone ? zoneToXc(dataRangeZone) : undefined,
           };
-          Object.assign(config.options.scales.x, axis);
-          config.options.scales.x.ticks.maxTicksLimit = 15;
       }
-      else if (axisType === "linear") {
-          config.options.scales.x.type = "linear";
-          config.options.scales.x.ticks.callback = (value) => formatValue(value, { format: labelFormat, locale });
-          config.options.plugins.tooltip.callbacks.title = (tooltipItem) => {
-              return formatValue(tooltipItem[0].parsed.x || tooltipItem[0].label, {
-                  locale,
-                  format: labelFormat,
-              });
+      static getDefinitionFromContextCreation(context) {
+          return {
+              background: context.background,
+              title: context.title || { text: "" },
+              type: "gauge",
+              dataRange: context.range ? context.range[0].dataRange : undefined,
+              sectionRule: {
+                  colors: {
+                      lowerColor: DEFAULT_GAUGE_LOWER_COLOR,
+                      middleColor: DEFAULT_GAUGE_MIDDLE_COLOR,
+                      upperColor: DEFAULT_GAUGE_UPPER_COLOR,
+                  },
+                  rangeMin: "0",
+                  rangeMax: "100",
+                  lowerInflectionPoint: {
+                      type: "percentage",
+                      value: "15",
+                  },
+                  upperInflectionPoint: {
+                      type: "percentage",
+                      value: "40",
+                  },
+              },
           };
       }
-      const stacked = "stacked" in chart ? chart.stacked : false;
-      const cumulative = "cumulative" in chart ? chart.cumulative : false;
-      const colors = new ColorGenerator();
-      const definition = chart.getDefinition();
-      for (let [index, { label, data }] of dataSetsValues.entries()) {
-          if (["linear", "time"].includes(axisType)) {
-              // Replace empty string labels by undefined to make sure chartJS doesn't decide that "" is the same as 0
-              data = data.map((y, index) => ({ x: labels[index] || undefined, y }));
-          }
-          const color = colors.next();
-          let backgroundRGBA = colorToRGBA(color);
-          if (stacked) {
-              backgroundRGBA.a = LINE_FILL_TRANSPARENCY;
-          }
-          if (cumulative) {
-              let accumulator = 0;
-              data = data.map((value) => {
-                  if (!isNaN(value)) {
-                      accumulator += parseFloat(value);
-                      return accumulator;
-                  }
-                  return value;
-              });
-          }
-          const backgroundColor = rgbaToHex(backgroundRGBA);
-          const dataset = {
-              label,
-              data,
-              tension: 0, // 0 -> render straight lines, which is much faster
-              borderColor: color,
-              backgroundColor,
-              pointBackgroundColor: color,
-              fill: stacked ? getFillingMode(index) : false,
+      copyForSheetId(sheetId) {
+          const dataRange = copyLabelRangeWithNewSheetId(this.sheetId, sheetId, this.dataRange);
+          const definition = this.getDefinitionWithSpecificRanges(dataRange, sheetId);
+          return new GaugeChart(definition, sheetId, this.getters);
+      }
+      copyInSheetId(sheetId) {
+          const definition = this.getDefinitionWithSpecificRanges(this.dataRange, sheetId);
+          return new GaugeChart(definition, sheetId, this.getters);
+      }
+      getDefinition() {
+          return this.getDefinitionWithSpecificRanges(this.dataRange);
+      }
+      getDefinitionWithSpecificRanges(dataRange, targetSheetId) {
+          return {
+              background: this.background,
+              sectionRule: this.sectionRule,
+              title: this.title,
+              type: "gauge",
+              dataRange: dataRange
+                  ? this.getters.getRangeString(dataRange, targetSheetId || this.sheetId)
+                  : undefined,
           };
-          config.data.datasets.push(dataset);
       }
-      for (const [index, dataset] of config.data.datasets.entries()) {
-          if (definition.dataSets?.[index]?.backgroundColor) {
-              const color = definition.dataSets[index].backgroundColor;
-              dataset.backgroundColor = color;
-              dataset.borderColor = color;
-              //@ts-ignore
-              dataset.pointBackgroundColor = color;
-          }
-          if (definition.dataSets?.[index]?.label) {
-              const label = definition.dataSets[index].label;
-              dataset.label = label;
+      getDefinitionForExcel() {
+          // This kind of graph is not exportable in Excel
+          return undefined;
+      }
+      getContextCreation() {
+          return {
+              ...this,
+              range: this.dataRange
+                  ? [{ dataRange: this.getters.getRangeString(this.dataRange, this.sheetId) }]
+                  : undefined,
+          };
+      }
+      updateRanges(applyChange) {
+          const range = adaptChartRange(this.dataRange, applyChange);
+          if (this.dataRange === range) {
+              return this;
           }
-          if (definition.dataSets?.[index]?.yAxisId) {
-              dataset["yAxisID"] = definition.dataSets[index].yAxisId;
+          const definition = this.getDefinitionWithSpecificRanges(range);
+          return new GaugeChart(definition, this.sheetId, this.getters);
+      }
+  }
+  function createGaugeChartRuntime(chart, getters) {
+      const locale = getters.getLocale();
+      const chartColors = chart.sectionRule.colors;
+      let gaugeValue = undefined;
+      let formattedValue = undefined;
+      let format = undefined;
+      const dataRange = chart.dataRange;
+      if (dataRange !== undefined) {
+          const cell = getters.getEvaluatedCell({
+              sheetId: dataRange.sheetId,
+              col: dataRange.zone.left,
+              row: dataRange.zone.top,
+          });
+          if (cell.type === CellValueType.number) {
+              gaugeValue = cell.value;
+              formattedValue = cell.formattedValue;
+              format = cell.format;
           }
       }
+      const minValue = Number(chart.sectionRule.rangeMin);
+      const maxValue = Number(chart.sectionRule.rangeMax);
+      const lowerPoint = chart.sectionRule.lowerInflectionPoint;
+      const upperPoint = chart.sectionRule.upperInflectionPoint;
+      const lowerPointValue = getSectionThresholdValue(lowerPoint, minValue, maxValue);
+      const upperPointValue = getSectionThresholdValue(upperPoint, minValue, maxValue);
+      const inflectionValues = [];
+      const colors = [];
+      if (lowerPointValue !== undefined) {
+          inflectionValues.push({
+              value: lowerPointValue,
+              label: formatValue(lowerPointValue, { locale, format }),
+          });
+          colors.push(chartColors.lowerColor);
+      }
+      if (upperPointValue !== undefined && upperPointValue !== lowerPointValue) {
+          inflectionValues.push({
+              value: upperPointValue,
+              label: formatValue(upperPointValue, { locale, format }),
+          });
+          colors.push(chartColors.middleColor);
+      }
+      if (upperPointValue !== undefined &&
+          lowerPointValue !== undefined &&
+          lowerPointValue > upperPointValue) {
+          inflectionValues.reverse();
+          colors.reverse();
+      }
+      colors.push(chartColors.upperColor);
       return {
-          chartJsConfig: config,
-          background: chart.background || BACKGROUND_CHART_COLOR,
-          dataSetsValues,
-          labelValues,
-          dataSetFormat,
-          labelFormat,
+          background: getters.getStyleOfSingleCellChart(chart.background, dataRange).background,
+          title: chart.title ?? { text: "" },
+          minValue: {
+              value: minValue,
+              label: formatValue(minValue, { locale, format }),
+          },
+          maxValue: {
+              value: maxValue,
+              label: formatValue(maxValue, { locale, format }),
+          },
+          gaugeValue: gaugeValue !== undefined && formattedValue
+              ? { value: gaugeValue, label: formattedValue }
+              : undefined,
+          inflectionValues,
+          colors,
       };
   }
+  function getSectionThresholdValue(threshold, minValue, maxValue) {
+      if (threshold.value === "" || isNaN(Number(threshold.value))) {
+          return undefined;
+      }
+      const numberValue = Number(threshold.value);
+      const value = threshold.type === "number"
+          ? numberValue
+          : minValue + ((maxValue - minValue) * numberValue) / 100;
+      return clip(value, minValue, maxValue);
+  }
 
   class LineChart extends AbstractChart {
       dataSets;
@@ -24104,6 +24575,8 @@ stores.inject(MyMetaStore, storeInstance);
       cumulative;
       dataSetDesign;
       axesDesign;
+      fillArea;
+      showValues;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(this.getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24117,6 +24590,8 @@ stores.inject(MyMetaStore, storeInstance);
           this.cumulative = definition.cumulative;
           this.dataSetDesign = definition.dataSets;
           this.axesDesign = definition.axesDesign;
+          this.fillArea = definition.fillArea;
+          this.showValues = definition.showValues;
       }
       static validateChartDefinition(validator, definition) {
           return validator.checkValidations(definition, checkDataset, checkLabelRange);
@@ -24138,6 +24613,8 @@ stores.inject(MyMetaStore, storeInstance);
               aggregated: context.aggregated ?? false,
               cumulative: context.cumulative ?? false,
               axesDesign: context.axesDesign,
+              fillArea: context.fillArea,
+              showValues: context.showValues,
           };
       }
       getDefinition() {
@@ -24166,6 +24643,8 @@ stores.inject(MyMetaStore, storeInstance);
               aggregated: this.aggregated,
               cumulative: this.cumulative,
               axesDesign: this.axesDesign,
+              fillArea: this.fillArea,
+              showValues: this.showValues,
           };
       }
       getContextCreation() {
@@ -24221,10 +24700,6 @@ stores.inject(MyMetaStore, storeInstance);
           return new LineChart(definition, sheetId, this.getters);
       }
   }
-  function createLineChartRuntime(chart, getters) {
-      const { chartJsConfig, background } = createLineOrScatterChartRuntime(chart, getters);
-      return { chartJsConfig, background };
-  }
 
   class PieChart extends AbstractChart {
       dataSets;
@@ -24235,6 +24710,7 @@ stores.inject(MyMetaStore, storeInstance);
       aggregated;
       dataSetsHaveTitle;
       isDoughnut;
+      showValues;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24244,6 +24720,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.aggregated = definition.aggregated;
           this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
           this.isDoughnut = definition.isDoughnut;
+          this.showValues = definition.showValues;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24262,6 +24739,7 @@ stores.inject(MyMetaStore, storeInstance);
               labelRange: context.auxiliaryRange || undefined,
               aggregated: context.aggregated ?? false,
               isDoughnut: false,
+              showValues: context.showValues,
           };
       }
       getDefinition() {
@@ -24293,6 +24771,7 @@ stores.inject(MyMetaStore, storeInstance);
               title: this.title,
               aggregated: this.aggregated,
               isDoughnut: this.isDoughnut,
+              showValues: this.showValues,
           };
       }
       copyForSheetId(sheetId) {
@@ -24360,6 +24839,7 @@ stores.inject(MyMetaStore, storeInstance);
           const yLabelStr = formatValue(yLabel, { format: toolTipFormat, locale });
           return xLabel ? `${xLabel}: ${yLabelStr} (${percentage}%)` : `${yLabelStr} (${percentage}%)`;
       };
+      config.options.plugins.chartShowValuesPlugin = { showValues: chart.showValues };
       return config;
   }
   function getPieColors(colors, dataSetsValues) {
@@ -24445,6 +24925,7 @@ stores.inject(MyMetaStore, storeInstance);
       axesDesign;
       horizontal = true;
       stacked = true;
+      showValues;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle).slice(0, 2);
@@ -24455,6 +24936,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
           this.dataSetDesign = definition.dataSets;
           this.axesDesign = definition.axesDesign;
+          this.showValues = definition.showValues;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24475,6 +24957,7 @@ stores.inject(MyMetaStore, storeInstance);
               axesDesign: context.axesDesign,
               horizontal: true,
               stacked: true,
+              showValues: context.showValues,
           };
       }
       getContextCreation() {
@@ -24528,6 +25011,7 @@ stores.inject(MyMetaStore, storeInstance);
               axesDesign: this.axesDesign,
               horizontal: true,
               stacked: true,
+              showValues: this.showValues,
           };
       }
       getDefinitionForExcel() {
@@ -24562,6 +25046,8 @@ stores.inject(MyMetaStore, storeInstance);
           const tooltipItem = { ...item, parsed: { y: item.parsed.y, x: Math.abs(item.parsed.x) } };
           return tooltipLabelCallback(tooltipItem);
       };
+      const callback = config.options.plugins.chartShowValuesPlugin.callback;
+      config.options.plugins.chartShowValuesPlugin.callback = (x) => callback(Math.abs(x));
       return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
   }
 
@@ -24576,6 +25062,7 @@ stores.inject(MyMetaStore, storeInstance);
       dataSetsHaveTitle;
       dataSetDesign;
       axesDesign;
+      showValues;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(this.getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24587,6 +25074,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
           this.dataSetDesign = definition.dataSets;
           this.axesDesign = definition.axesDesign;
+          this.showValues = definition.showValues;
       }
       static validateChartDefinition(validator, definition) {
           return validator.checkValidations(definition, checkDataset, checkLabelRange);
@@ -24606,6 +25094,7 @@ stores.inject(MyMetaStore, storeInstance);
               labelRange: context.auxiliaryRange || undefined,
               aggregated: context.aggregated ?? false,
               axesDesign: context.axesDesign,
+              showValues: context.showValues,
           };
       }
       getDefinition() {
@@ -24632,6 +25121,7 @@ stores.inject(MyMetaStore, storeInstance);
               labelsAsText: this.labelsAsText,
               aggregated: this.aggregated,
               axesDesign: this.axesDesign,
+              showValues: this.showValues,
           };
       }
       getContextCreation() {
@@ -24732,6 +25222,7 @@ stores.inject(MyMetaStore, storeInstance);
       subTotalValuesColor;
       dataSetDesign;
       axesDesign;
+      showValues;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24749,6 +25240,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.firstValueAsSubtotal = definition.firstValueAsSubtotal;
           this.dataSetDesign = definition.dataSets;
           this.axesDesign = definition.axesDesign;
+          this.showValues = definition.showValues;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24771,6 +25263,7 @@ stores.inject(MyMetaStore, storeInstance);
               showConnectorLines: context.showConnectorLines ?? true,
               firstValueAsSubtotal: context.firstValueAsSubtotal ?? false,
               axesDesign: context.axesDesign,
+              showValues: context.showValues,
           };
       }
       getContextCreation() {
@@ -24829,6 +25322,7 @@ stores.inject(MyMetaStore, storeInstance);
               subTotalValuesColor: this.subTotalValuesColor,
               firstValueAsSubtotal: this.firstValueAsSubtotal,
               axesDesign: this.axesDesign,
+              showValues: this.showValues,
           };
       }
       getDefinitionForExcel() {
@@ -24926,6 +25420,10 @@ stores.inject(MyMetaStore, storeInstance);
           },
       };
       config.options.plugins.waterfallLinesPlugin = { showConnectorLines: chart.showConnectorLines };
+      config.options.plugins.chartShowValuesPlugin = {
+          showValues: chart.showValues,
+          background: chart.background,
+      };
       return config;
   }
   function createWaterfallChartRuntime(chart, getters) {
@@ -25018,7 +25516,7 @@ stores.inject(MyMetaStore, storeInstance);
   chartRegistry.add("line", {
       match: (type) => type === "line",
       createChart: (definition, sheetId, getters) => new LineChart(definition, sheetId, getters),
-      getChartRuntime: createLineChartRuntime,
+      getChartRuntime: createLineOrScatterChartRuntime,
       validateChartDefinition: LineChart.validateChartDefinition,
       transformDefinition: LineChart.transformDefinition,
       getChartDefinitionFromContextCreation: LineChart.getDefinitionFromContextCreation,
@@ -25092,27 +25590,46 @@ stores.inject(MyMetaStore, storeInstance);
       line: _t("Line"),
       column: _t("Column"),
       bar: _t("Bar"),
+      area: _t("Area"),
       pie: _t("Pie"),
       misc: _t("Miscellaneous"),
   };
   const chartSubtypeRegistry = new Registry();
   chartSubtypeRegistry
       .add("line", {
-      matcher: (definition) => definition.type === "line" && !definition.stacked,
+      matcher: (definition) => definition.type === "line" && !definition.stacked && !definition.fillArea,
       displayName: _t("Line"),
       chartType: "line",
       chartSubtype: "line",
-      subtypeDefinition: { stacked: false },
+      subtypeDefinition: { stacked: false, fillArea: false },
       category: "line",
       preview: "o-spreadsheet-ChartPreview.LINE_CHART",
   })
       .add("stacked_line", {
-      matcher: (definition) => definition.type === "line" && definition.stacked,
+      matcher: (definition) => definition.type === "line" && !definition.fillArea && !!definition.stacked,
       displayName: _t("Stacked Line"),
       chartType: "line",
       chartSubtype: "stacked_line",
-      subtypeDefinition: { stacked: true },
+      subtypeDefinition: { stacked: true, fillArea: false },
       category: "line",
+      preview: "o-spreadsheet-ChartPreview.STACKED_LINE_CHART",
+  })
+      .add("area", {
+      matcher: (definition) => definition.type === "line" && !definition.stacked && !!definition.fillArea,
+      displayName: _t("Area"),
+      chartType: "line",
+      chartSubtype: "area",
+      subtypeDefinition: { stacked: false, fillArea: true },
+      category: "area",
+      preview: "o-spreadsheet-ChartPreview.AREA_CHART",
+  })
+      .add("stacked_area", {
+      matcher: (definition) => definition.type === "line" && definition.stacked && !!definition.fillArea,
+      displayName: _t("Stacked Area"),
+      chartType: "line",
+      chartSubtype: "stacked_area",
+      subtypeDefinition: { stacked: true, fillArea: true },
+      category: "area",
       preview: "o-spreadsheet-ChartPreview.STACKED_AREA_CHART",
   })
       .add("scatter", {
@@ -25536,7 +26053,7 @@ stores.inject(MyMetaStore, storeInstance);
        * @param path Path of items to add this subitem
        * @param value Subitem to add
        */
-      addChild(key, path, value) {
+      addChild(key, path, value, options = { force: false }) {
           if (typeof value !== "function" && value.id === undefined) {
               value.id = key;
           }
@@ -25558,6 +26075,19 @@ stores.inject(MyMetaStore, storeInstance);
           if (!node.children) {
               node.children = [];
           }
+          const children = node.children;
+          if (!children || typeof children === "function") {
+              throw new Error(`${path} is either not a node or it's dynamically computed`);
+          }
+          if ("id" in value) {
+              const valueIndex = children.findIndex((elt) => "id" in elt && elt.id === value.id);
+              if (valueIndex > -1) {
+                  if (!options.force)
+                      throw new Error(`A child with the id "${value.id}" already exists.`);
+                  node.children.splice(valueIndex, 1, value);
+                  return this;
+              }
+          }
           node.children.push(value);
           return this;
       }
@@ -27850,6 +28380,23 @@ stores.inject(MyMetaStore, storeInstance);
           env.openSidePanel("PivotSidePanel", { pivotId });
       }
   };
+  const REINSERT_PIVOT_CHILDREN = (env) => env.model.getters.getPivotIds().map((pivotId, index) => ({
+      id: `reinsert_pivot_${env.model.getters.getPivotFormulaId(pivotId)}`,
+      name: env.model.getters.getPivotDisplayName(pivotId),
+      sequence: index,
+      execute: (env) => {
+          const zone = env.model.getters.getSelectedZone();
+          const table = env.model.getters.getPivot(pivotId).getTableStructure().export();
+          env.model.dispatch("INSERT_PIVOT_WITH_TABLE", {
+              pivotId,
+              table,
+              col: zone.left,
+              row: zone.top,
+              sheetId: env.model.getters.getActiveSheetId(),
+          });
+          env.model.dispatch("REFRESH_PIVOT", { id: pivotId });
+      },
+  }));
   //------------------------------------------------------------------------------
   // Image
   //------------------------------------------------------------------------------
@@ -28714,12 +29261,21 @@ stores.inject(MyMetaStore, storeInstance);
       isEnabled: (env) => env.model.getters.isSingleColSelected(),
       icon: "o-spreadsheet-Icon.SPLIT_TEXT",
   };
+  const reinsertPivotMenu = {
+      id: "reinsert_pivot",
+      name: _t("Re-insert pivot"),
+      sequence: 1020,
+      icon: "o-spreadsheet-Icon.INSERT_PIVOT",
+      children: [REINSERT_PIVOT_CHILDREN],
+      isVisible: (env) => env.model.getters.getPivotIds().length > 0,
+  };
 
   var ACTION_DATA = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createRemoveFilter: createRemoveFilter,
     createRemoveFilterTool: createRemoveFilterTool,
     dataCleanup: dataCleanup,
+    reinsertPivotMenu: reinsertPivotMenu,
     removeDuplicates: removeDuplicates,
     sortAscending: sortAscending,
     sortDescending: sortDescending,
@@ -30200,7 +30756,8 @@ stores.inject(MyMetaStore, storeInstance);
                   : undefined,
           };
       });
-  });
+  })
+      .addChild("reinsert_pivot", ["data"], reinsertPivotMenu);
 
   class OTRegistry extends Registry {
       /**
@@ -31685,7 +32242,7 @@ stores.inject(MyMetaStore, storeInstance);
       static template = "o-spreadsheet.ChartTitle";
       static components = { Section, ColorPickerWidget };
       static props = {
-          title: String,
+          title: { type: String, optional: true },
           updateTitle: Function,
           name: { type: String, optional: true },
           toggleItalic: { type: Function, optional: true },
@@ -31694,6 +32251,9 @@ stores.inject(MyMetaStore, storeInstance);
           updateColor: { type: Function, optional: true },
           style: { type: Object, optional: true },
       };
+      static defaultProps = {
+          title: "",
+      };
       openedEl = null;
       setup() {
           owl.useExternalListener(window, "click", this.onExternalClick);
@@ -31889,6 +32449,7 @@ stores.inject(MyMetaStore, storeInstance);
           Section,
           AxisDesignEditor,
           RoundColorPicker,
+          Checkbox,
       };
       static props = {
           figureId: String,
@@ -31981,6 +32542,12 @@ stores.inject(MyMetaStore, storeInstance);
           const dataSets = this.props.definition.dataSets;
           return dataSets[this.state.index]?.label || this.getDataSeries()[this.state.index];
       }
+      get showValuesLabel() {
+          return ChartTerms.ShowValues;
+      }
+      updateShowValues(showValues) {
+          this.props.updateChart(this.props.figureId, { showValues });
+      }
   }
 
   class GaugeChartConfigPanel extends owl.Component {
@@ -32130,6 +32697,10 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return false;
       }
+      get stackedLabel() {
+          const definition = this.props.definition;
+          return definition.fillArea ? this.chartTerms.StackedAreaChart : this.chartTerms.StackedBarChart;
+      }
       getLabelRangeOptions() {
           const options = super.getLabelRangeOptions();
           if (this.canTreatLabelsAsText) {
@@ -32169,6 +32740,7 @@ stores.inject(MyMetaStore, storeInstance);
       static components = {
           GeneralDesignEditor,
           Section,
+          Checkbox,
       };
       static props = {
           figureId: String,
@@ -32181,6 +32753,9 @@ stores.inject(MyMetaStore, storeInstance);
               legendPosition: ev.target.value,
           });
       }
+      get showValuesLabel() {
+          return ChartTerms.ShowValues;
+      }
   }
 
   class ScatterConfigPanel extends GenericChartConfigPanel {
@@ -32375,6 +32950,12 @@ stores.inject(MyMetaStore, storeInstance);
               verticalAxisPosition: ev.target.value,
           });
       }
+      get showValuesLabel() {
+          return ChartTerms.ShowValues;
+      }
+      updateShowValues(showValues) {
+          this.props.updateChart(this.props.figureId, { showValues });
+      }
   }
 
   const chartSidePanelComponentRegistry = new Registry();
@@ -32635,6 +33216,11 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  /**
+   * Registry to draw icons on cells
+   */
+  const iconsOnCellRegistry = new Registry();
+
   css /* scss */ `
   .o-spreadsheet {
     .o-icon {
@@ -32670,49 +33256,47 @@ stores.inject(MyMetaStore, storeInstance);
   const GREEN_DOT = '<svg class="o-cf-icon green-dot" width="10" height="10" focusable="false" viewBox="0 0 512 512"><path fill="#6AA84F" d="M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8z"></path></svg>';
   const YELLOW_DOT = '<svg class="o-cf-icon yellow-dot" width="10" height="10" focusable="false" viewBox="0 0 512 512"><path fill="#F0AD4E" d="M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8z"></path></svg>';
   const RED_DOT = '<svg class="o-cf-icon red-dot" width="10" height="10" focusable="false" viewBox="0 0 512 512"><path fill="#E06666" d="M256 8C119 8 8 119 8 256s111 248 248 248 248-111 248-248S393 8 256 8z"></path></svg>';
-  function loadIconImage(svg) {
+  function getIconSrc(svg) {
       /** We have to add xmlns, as it's not added by owl in the canvas */
       svg = `<svg xmlns="http://www.w3.org/2000/svg" ${svg.slice(4)}`;
-      const image = new Image();
-      image.src = "data:image/svg+xml; charset=utf8, " + encodeURIComponent(svg);
-      return image;
+      return "data:image/svg+xml; charset=utf8, " + encodeURIComponent(svg);
   }
   const ICONS = {
       arrowGood: {
           template: "ARROW_UP",
-          img: loadIconImage(ARROW_UP),
+          img: getIconSrc(ARROW_UP),
       },
       arrowNeutral: {
           template: "ARROW_RIGHT",
-          img: loadIconImage(ARROW_RIGHT),
+          img: getIconSrc(ARROW_RIGHT),
       },
       arrowBad: {
           template: "ARROW_DOWN",
-          img: loadIconImage(ARROW_DOWN),
+          img: getIconSrc(ARROW_DOWN),
       },
       smileyGood: {
           template: "SMILE",
-          img: loadIconImage(SMILE),
+          img: getIconSrc(SMILE),
       },
       smileyNeutral: {
           template: "MEH",
-          img: loadIconImage(MEH),
+          img: getIconSrc(MEH),
       },
       smileyBad: {
           template: "FROWN",
-          img: loadIconImage(FROWN),
+          img: getIconSrc(FROWN),
       },
       dotGood: {
           template: "GREEN_DOT",
-          img: loadIconImage(GREEN_DOT),
+          img: getIconSrc(GREEN_DOT),
       },
       dotNeutral: {
           template: "YELLOW_DOT",
-          img: loadIconImage(YELLOW_DOT),
+          img: getIconSrc(YELLOW_DOT),
       },
       dotBad: {
           template: "RED_DOT",
-          img: loadIconImage(RED_DOT),
+          img: getIconSrc(RED_DOT),
       },
   };
   const ICON_SETS = {
@@ -32732,6 +33316,12 @@ stores.inject(MyMetaStore, storeInstance);
           bad: "dotBad",
       },
   };
+  iconsOnCellRegistry.add("conditional_formatting", (getters, position) => {
+      const icon = getters.getConditionalIcon(position);
+      if (icon) {
+          return ICONS[icon].img;
+      }
+  });
 
   css /* scss */ `
   .o-icon-picker {
@@ -33080,21 +33670,25 @@ stores.inject(MyMetaStore, storeInstance);
 
   function useHighlightsOnHover(ref, highlightProvider) {
       const hoverState = useHoveredElement(ref);
-      const stores = useStoreProvider();
       useHighlights({
           get highlights() {
               return hoverState.hovered ? highlightProvider.highlights : [];
           },
       });
-      owl.useEffect(() => {
-          stores.trigger("store-updated");
-      }, () => [hoverState.hovered]);
   }
   function useHighlights(highlightProvider) {
+      const stores = useStoreProvider();
       const store = useLocalStore(HighlightStore);
       owl.onMounted(() => {
           store.register(highlightProvider);
       });
+      let currentHighlights = highlightProvider.highlights;
+      owl.useEffect((highlights) => {
+          if (!deepEquals(highlights, currentHighlights)) {
+              currentHighlights = highlights;
+              stores.trigger("store-updated");
+          }
+      }, () => [highlightProvider.highlights]);
   }
 
   css /* scss */ `
@@ -34566,6 +35160,8 @@ stores.inject(MyMetaStore, storeInstance);
       isSearchDirty = false;
       initialShowFormulaState;
       preserveSelectedMatchIndex = false;
+      irreplaceableMatchCount = 0;
+      notificationStore = this.get(NotificationStore);
       // fixme: why do we make selectedMatchIndex on top of a selected
       // property in the matches?
       selectedMatchIndex = null;
@@ -34575,7 +35171,7 @@ stores.inject(MyMetaStore, storeInstance);
           matchCase: false,
           exactMatch: false,
           searchFormulas: false,
-          searchScope: "allSheets",
+          searchScope: "activeSheet",
           specificRange: undefined,
       };
       updateSearchContent = debounce(this._updateSearchContent.bind(this), 200);
@@ -34642,6 +35238,11 @@ stores.inject(MyMetaStore, storeInstance);
                   for (const match of cmd.matches) {
                       this.replaceMatch(match, cmd.searchString, cmd.replaceWith, cmd.searchOptions);
                   }
+                  if (this.irreplaceableMatchCount > 0) {
+                      this.showReplaceWarningMessage(cmd.matches.length, this.irreplaceableMatchCount);
+                  }
+                  this.irreplaceableMatchCount = 0;
+                  break;
           }
       }
       finalize() {
@@ -34823,12 +35424,36 @@ stores.inject(MyMetaStore, storeInstance);
               searchOptions: this.searchOptions,
           });
       }
+      /**
+       * Show a warning message based on the number of matches replaced and irreplaceable.
+       */
+      showReplaceWarningMessage(totalMatches, irreplaceableMatches) {
+          const replaceableMatches = totalMatches - irreplaceableMatches;
+          if (replaceableMatches === 0) {
+              this.notificationStore.notifyUser({
+                  type: "warning",
+                  sticky: false,
+                  text: _t("Match(es) cannot be replaced as they are part of a formula."),
+              });
+          }
+          else {
+              this.notificationStore.notifyUser({
+                  type: "warning",
+                  sticky: false,
+                  text: _t("%(replaceable_count)s match(es) replaced. %(irreplaceable_count)s match(es) cannot be replaced as they are part of a formula.", {
+                      replaceable_count: replaceableMatches,
+                      irreplaceable_count: irreplaceableMatches,
+                  }),
+              });
+          }
+      }
       replaceMatch(selectedMatch, searchString, replaceWith, searchOptions) {
           const cell = this.getters.getCell(selectedMatch);
           if (!cell?.content) {
               return;
           }
           if (cell?.isFormula && !searchOptions.searchFormulas) {
+              this.irreplaceableMatchCount++;
               return;
           }
           const searchRegex = getSearchRegex(searchString, searchOptions);
@@ -35505,9 +36130,11 @@ stores.inject(MyMetaStore, storeInstance);
       }
       duplicatePivot() {
           const newPivotId = this.env.model.uuidGenerator.uuidv4();
-          const result = this.env.model.dispatch("DUPLICATE_PIVOT", {
+          const newSheetId = this.env.model.uuidGenerator.uuidv4();
+          const result = this.env.model.dispatch("DUPLICATE_PIVOT_IN_NEW_SHEET", {
               pivotId: this.props.pivotId,
               newPivotId,
+              newSheetId,
           });
           const text = result.isSuccessful ? _t("Pivot duplicated.") : _t("Pivot duplication failed");
           const type = result.isSuccessful ? "success" : "danger";
@@ -36042,7 +36669,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (typeof value === "number" || typeof value === "string") {
               const date = toJsDate(value, locale);
               switch (granularity) {
-                  case "year_number":
+                  case "year":
                       number = date.getFullYear();
                       break;
                   case "quarter_number":
@@ -36070,7 +36697,7 @@ stores.inject(MyMetaStore, storeInstance);
    * This map is used to cache the different values of a pivot date value
    * 43_831 -> 01/01/2012
    * Example: {
-   *   year_number: {
+   *   year: {
    *     set: { 43_831 },
    *     values: { '43_831': 2012 }
    *   },
@@ -36097,7 +36724,7 @@ stores.inject(MyMetaStore, storeInstance);
    * }
    */
   const MAP_VALUE_DIMENSION_DATE = {
-      year_number: {
+      year: {
           set: new Set(),
           values: {},
       },
@@ -36482,7 +37109,7 @@ stores.inject(MyMetaStore, storeInstance);
       externalData: false,
       onIterationEndEvaluation: (pivot) => pivot.markAsDirtyForEvaluation(),
       granularities: [
-          "year_number",
+          "year",
           "quarter_number",
           "month_number",
           "iso_week_number",
@@ -36892,7 +37519,13 @@ stores.inject(MyMetaStore, storeInstance);
       }
       async loadLocales() {
           this.loadedLocales = (await this.env.loadLocales())
-              .filter(isValidLocale)
+              .filter((locale) => {
+              const isValid = isValidLocale(locale);
+              if (!isValid) {
+                  console.warn(`Invalid locale: ${locale["code"]} ${locale}`);
+              }
+              return isValid;
+          })
               .sort((a, b) => a.name.localeCompare(b.name));
       }
       get numberFormatPreview() {
@@ -37951,6 +38584,9 @@ stores.inject(MyMetaStore, storeInstance);
           const component = { ...value, id: this.uuidGenerator.uuidv4() };
           return super.add(name, component);
       }
+      getAllOrdered() {
+          return this.getAll().sort((a, b) => a.sequence - b.sequence);
+      }
   }
   const topbarComponentRegistry = new TopBarComponentRegistry();
 
@@ -40839,21 +41475,22 @@ stores.inject(MyMetaStore, storeInstance);
               isError: (cell.type === CellValueType.error && !!cell.message) ||
                   this.getters.isDataValidationInvalid(position),
           };
-          if (cell.type === CellValueType.empty || this.getters.isCellValidCheckbox(position)) {
-              return box;
-          }
-          /** Icon CF */
-          const cfIcon = this.getters.getConditionalIcon(position);
+          /** Icon */
+          const iconSrc = this.getters.getCellIconSrc(position);
           const fontSizePX = computeTextFontSizeInPixels(box.style);
-          const iconBoxWidth = cfIcon ? MIN_CF_ICON_MARGIN + fontSizePX : 0;
-          if (cfIcon) {
+          const iconBoxWidth = iconSrc ? MIN_CF_ICON_MARGIN + fontSizePX : 0;
+          if (iconSrc) {
+              const imageHtmlElement = loadIconImage(iconSrc);
               box.image = {
                   type: "icon",
                   size: fontSizePX,
                   clipIcon: { x: box.x, y: box.y, width: Math.min(iconBoxWidth, width), height },
-                  image: ICONS[cfIcon].img,
+                  image: imageHtmlElement,
               };
           }
+          if (cell.type === CellValueType.empty || this.getters.isCellValidCheckbox(position)) {
+              return box;
+          }
           /** Filter Header or data validation icon */
           box.hasIcon = this.getters.doesCellHaveGridIcon(position);
           const headerIconWidth = box.hasIcon ? GRID_ICON_EDGE_LENGTH + GRID_ICON_MARGIN : 0;
@@ -40872,7 +41509,7 @@ stores.inject(MyMetaStore, storeInstance);
           };
           /** ClipRect */
           const isOverflowing = contentWidth > width || fontSizePX > height;
-          if (cfIcon || box.hasIcon) {
+          if (iconSrc || box.hasIcon) {
               box.clipRect = {
                   x: box.x + iconBoxWidth,
                   y: box.y,
@@ -40983,6 +41620,11 @@ stores.inject(MyMetaStore, storeInstance);
           return boxes;
       }
   }
+  const loadIconImage = memoize(function loadIconImage(src) {
+      const image = new Image();
+      image.src = src;
+      return image;
+  });
 
   function useGridDrawing(refName, model, canvasSize) {
       const canvasRef = owl.useRef(refName);
@@ -42055,6 +42697,7 @@ stores.inject(MyMetaStore, storeInstance);
               return;
           }
           if (clipboardData.types.indexOf(ClipboardMIMEType.PlainText) > -1) {
+              ev.preventDefault();
               const content = clipboardData.getData(ClipboardMIMEType.PlainText);
               const target = this.env.model.getters.getSelectedZones();
               const clipboardString = this.env.model.getters.getClipboardTextContent();
@@ -42321,6 +42964,8 @@ stores.inject(MyMetaStore, storeInstance);
       "BITOR",
       "BITRSHIFT",
       "BITXOR",
+      "BYCOL",
+      "BYROW",
       "CEILING.MATH",
       "CEILING.PRECISE",
       "CHISQ.DIST",
@@ -42328,6 +42973,8 @@ stores.inject(MyMetaStore, storeInstance);
       "CHISQ.INV",
       "CHISQ.INV.RT",
       "CHISQ.TEST",
+      "CHOOSECOLS",
+      "CHOOSEROWS",
       "COMBINA",
       "CONCAT",
       "CONFIDENCE.NORM",
@@ -42340,14 +42987,17 @@ stores.inject(MyMetaStore, storeInstance);
       "CSCH",
       "DAYS",
       "DECIMAL",
+      "DROP",
       "ERF.PRECISE",
       "ERFC.PRECISE",
+      "EXPAND",
       "EXPON.DIST",
       "F.DIST",
       "F.DIST.RT",
       "F.INV",
       "F.INV.RT",
       "F.TEST",
+      "FIELDVALUE",
       "FILTERXML",
       "FLOOR.MATH",
       "FLOOR.PRECISE",
@@ -42362,6 +43012,7 @@ stores.inject(MyMetaStore, storeInstance);
       "GAMMA.INV",
       "GAMMALN.PRECISE",
       "GAUSS",
+      "HSTACK",
       "HYPGEOM.DIST",
       "IFNA",
       "IFS",
@@ -42374,9 +43025,14 @@ stores.inject(MyMetaStore, storeInstance);
       "IMSINH",
       "IMTAN",
       "ISFORMULA",
+      "ISOMITTED",
       "ISOWEEKNUM",
+      "LAMBDA",
+      "LET",
       "LOGNORM.DIST",
       "LOGNORM.INV",
+      "MAKEARRAY",
+      "MAP",
       "MAXIFS",
       "MINIFS",
       "MODE.MULT",
@@ -42396,17 +43052,26 @@ stores.inject(MyMetaStore, storeInstance);
       "PERMUTATIONA",
       "PHI",
       "POISSON.DIST",
+      "PQSOURCE",
+      "PYTHON_STR",
+      "PYTHON_TYPE",
+      "PYTHON_TYPENAME",
       "QUARTILE.EXC",
       "QUARTILE.INC",
       "QUERYSTRING",
+      "RANDARRAY",
       "RANK.AVG",
       "RANK.EQ",
+      "REDUCE",
       "RRI",
+      "SCAN",
       "SEC",
       "SECH",
+      "SEQUENCE",
       "SHEET",
       "SHEETS",
       "SKEW.P",
+      "SORTBY",
       "STDEV.P",
       "STDEV.S",
       "SWITCH",
@@ -42416,13 +43081,24 @@ stores.inject(MyMetaStore, storeInstance);
       "T.INV",
       "T.INV.2T",
       "T.TEST",
+      "TAKE",
+      "TEXTAFTER",
+      "TEXTBEFORE",
       "TEXTJOIN",
+      "TEXTSPLIT",
+      "TOCOL",
+      "TOROW",
       "UNICHAR",
       "UNICODE",
+      "UNIQUE",
       "VAR.P",
       "VAR.S",
+      "VSTACK",
       "WEBSERVICE",
       "WEIBULL.DIST",
+      "WRAPCOLS",
+      "WRAPROWS",
+      "XLOOKUP",
       "XOR",
       "Z.TEST",
   ];
@@ -45606,7 +46282,7 @@ stores.inject(MyMetaStore, storeInstance);
       return relsFile;
   }
 
-  const EXCEL_IMPORT_VERSION = 16;
+  const EXCEL_IMPORT_VERSION = 17;
   class XlsxReader {
       warningManager;
       xmls;
@@ -45738,7 +46414,7 @@ stores.inject(MyMetaStore, storeInstance);
    * a breaking change is made in the way the state is handled, and an upgrade
    * function should be defined
    */
-  const CURRENT_VERSION = 16;
+  const CURRENT_VERSION = 17;
   const INITIAL_SHEET_ID = "Sheet1";
   /**
    * This function tries to load anything that could look like a valid
@@ -46685,6 +47361,21 @@ stores.inject(MyMetaStore, storeInstance);
               return [];
           return Object.keys(sheetBorders).map((index) => parseInt(index, 10));
       }
+      /**
+       * Get all the rows which contains at least a border
+       */
+      getRowsWithBorders(sheetId) {
+          const sheetBorders = this.borders[sheetId]?.filter(isDefined);
+          if (!sheetBorders)
+              return [];
+          const rowsWithBorders = new Set();
+          for (const rowBorders of sheetBorders) {
+              for (const rowBorder in rowBorders) {
+                  rowsWithBorders.add(parseInt(rowBorder, 10));
+              }
+          }
+          return Array.from(rowsWithBorders);
+      }
       /**
        * Get the range of all the rows in the sheet
        */
@@ -46734,7 +47425,7 @@ stores.inject(MyMetaStore, storeInstance);
                   destructive: false,
               });
           }
-          this.getRowsRange(sheetId)
+          this.getRowsWithBorders(sheetId)
               .filter((row) => row >= start)
               .sort((a, b) => (delta < 0 ? a - b : b - a)) // start by the end when moving up
               .forEach((row) => {
@@ -49060,10 +49751,12 @@ stores.inject(MyMetaStore, storeInstance);
           if (!sheetMap)
               return [];
           const mergeIds = new Set();
-          for (const { col, row } of positions(zone)) {
-              const mergeId = sheetMap[col]?.[row];
-              if (mergeId) {
-                  mergeIds.add(mergeId);
+          for (let col = zone.left; col <= zone.right; col++) {
+              for (let row = zone.top; row <= zone.bottom; row++) {
+                  const mergeId = sheetMap[col]?.[row];
+                  if (mergeId) {
+                      mergeIds.add(mergeId);
+                  }
               }
           }
           return Array.from(mergeIds)
@@ -52931,7 +53624,13 @@ stores.inject(MyMetaStore, storeInstance);
           const queue = Array.from(ranges).reverse();
           while (queue.length > 0) {
               const range = queue.pop();
-              visited.addMany(positions(range.zone).map((position) => ({ sheetId: range.sheetId, ...position })));
+              const zone = range.zone;
+              const sheetId = range.sheetId;
+              for (let col = zone.left; col <= zone.right; col++) {
+                  for (let row = zone.top; row <= zone.bottom; row++) {
+                      visited.add({ sheetId, col, row });
+                  }
+              }
               const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
               const nextInQueue = {};
               for (const position of impactedPositions) {
@@ -52947,7 +53646,16 @@ stores.inject(MyMetaStore, storeInstance);
                   queue.push(...zones.map((zone) => ({ sheetId, zone })));
               }
           }
-          visited.deleteMany(ranges.flatMap((r) => positions(r.zone).map((position) => ({ sheetId: r.sheetId, ...position }))));
+          // remove initial ranges
+          for (const range of ranges) {
+              const zone = range.zone;
+              const sheetId = range.sheetId;
+              for (let col = zone.left; col <= zone.right; col++) {
+                  for (let row = zone.top; row <= zone.bottom; row++) {
+                      visited.delete({ sheetId, col, row });
+                  }
+              }
+          }
           return visited;
       }
   }
@@ -53078,7 +53786,7 @@ stores.inject(MyMetaStore, storeInstance);
           return this.sheets[position.sheetId].getValue(position) === 1;
       }
       clear() {
-          const insertions = this.insertions;
+          const insertions = [...this];
           this.insertions = [];
           for (const sheetId in this.sheets) {
               this.sheets[sheetId].clear();
@@ -53422,6 +54130,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           finally {
               this.cellsBeingComputed.delete(cellId);
+              this.nextPositionsToUpdate.delete(position);
           }
       }
       computeAndSave(position) {
@@ -53448,8 +54157,33 @@ stores.inject(MyMetaStore, storeInstance);
           forEachSpreadPositionInMatrix(nbColumns, nbRows, 
           // thanks to the isMatrix check above, we know that formulaReturn is MatrixFunctionReturn
           this.spreadValues(formulaPosition, formulaReturn));
+          this.invalidatePositionsDependingOnSpread(formulaPosition, nbColumns, nbRows);
           return createEvaluatedCell(nullValueToZeroValue(formulaReturn[0][0]), this.getters.getLocale(), cellData);
       }
+      invalidatePositionsDependingOnSpread(arrayFormulaPosition, nbColumns, nbRows) {
+          // the result matrix is split in 2 zones to exclude the array formula position
+          const top = arrayFormulaPosition.row;
+          const left = arrayFormulaPosition.col;
+          const bottom = top + nbRows - 1;
+          const leftColumnZone = {
+              top: top + 1,
+              bottom,
+              left,
+              right: left,
+          };
+          const rightPartZone = {
+              top,
+              bottom,
+              left: left + 1,
+              right: left + nbColumns - 1,
+          };
+          const sheetId = arrayFormulaPosition.sheetId;
+          const invalidatedPositions = this.formulaDependencies().getCellsDependingOn([
+              { sheetId, zone: rightPartZone },
+              { sheetId, zone: leftColumnZone },
+          ]);
+          this.nextPositionsToUpdate.addMany(invalidatedPositions);
+      }
       assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
           const numberOfCols = this.getters.getNumberCols(sheetId);
           const numberOfRows = this.getters.getNumberRows(sheetId);
@@ -53480,14 +54214,15 @@ stores.inject(MyMetaStore, storeInstance);
       }
       updateSpreadRelation({ sheetId, col, row, }) {
           const arrayFormulaPosition = { sheetId, col, row };
-          return (i, j) => {
+          const updateSpreadRelation = (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
               this.spreadingRelations.addRelation({ resultPosition: position, arrayFormulaPosition });
           };
+          return updateSpreadRelation;
       }
       checkCollision(formulaPosition) {
           const { sheetId, col, row } = formulaPosition;
-          return (i, j) => {
+          const checkCollision = (i, j) => {
               const position = { sheetId: sheetId, col: i + col, row: j + row };
               const rawCell = this.getters.getCell(position);
               if (rawCell?.content ||
@@ -53497,17 +54232,16 @@ stores.inject(MyMetaStore, storeInstance);
               }
               this.blockedArrayFormulas.delete(formulaPosition);
           };
+          return checkCollision;
       }
       spreadValues({ sheetId, col, row }, matrixResult) {
-          return (i, j) => {
+          const spreadValues = (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
               const cell = this.getters.getCell(position);
               const evaluatedCell = createEvaluatedCell(nullValueToZeroValue(matrixResult[i][j]), this.getters.getLocale(), cell);
               this.evaluatedCells.set(position, evaluatedCell);
-              // check if formula dependencies present in the spread zone
-              // if so, they need to be recomputed
-              this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([position]));
           };
+          return spreadValues;
       }
       invalidateSpreading(position) {
           if (!this.spreadingRelations.isArrayFormula(position)) {
@@ -53562,12 +54296,12 @@ stores.inject(MyMetaStore, storeInstance);
    * rather than appearing empty. This indicates that the
    * cell is the result of a non-empty content.
    */
-  function nullValueToZeroValue(fPayload) {
-      if (fPayload.value === null || fPayload.value === undefined) {
-          // 'fPayload.value === undefined' is supposed to never happen, it's a safety net for javascript use
-          return { ...fPayload, value: 0 };
+  function nullValueToZeroValue(functionResult) {
+      if (functionResult.value === null || functionResult.value === undefined) {
+          // 'functionResult.value === undefined' is supposed to never happen, it's a safety net for javascript use
+          return { ...functionResult, value: 0 };
       }
-      return fPayload;
+      return functionResult;
   }
   function updateEvalContextAndExecute(compiledFormula, compilationParams, sheetId, cellId) {
       compilationParams.evalContext.__originCellXC = lazy(() => {
@@ -55042,7 +55776,7 @@ stores.inject(MyMetaStore, storeInstance);
       getPivotIdFromPosition(position) {
           const cell = this.getters.getCorrespondingFormulaCell(position);
           if (cell && cell.isFormula) {
-              const pivotFunction = this.getFirstPivotFunction(cell.compiledFormula.tokens);
+              const pivotFunction = this.getFirstPivotFunction(position.sheetId, cell.compiledFormula.tokens);
               if (pivotFunction) {
                   const pivotId = pivotFunction.args[0]?.toString();
                   return pivotId && this.getters.getPivotId(pivotId);
@@ -55053,12 +55787,12 @@ stores.inject(MyMetaStore, storeInstance);
       isSpillPivotFormula(position) {
           const cell = this.getters.getCorrespondingFormulaCell(position);
           if (cell && cell.isFormula) {
-              const pivotFunction = this.getFirstPivotFunction(cell.compiledFormula.tokens);
+              const pivotFunction = this.getFirstPivotFunction(position.sheetId, cell.compiledFormula.tokens);
               return pivotFunction?.functionName === "PIVOT";
           }
           return false;
       }
-      getFirstPivotFunction(tokens) {
+      getFirstPivotFunction(sheetId, tokens) {
           const pivotFunction = getFirstPivotFunction(tokens);
           if (!pivotFunction) {
               return undefined;
@@ -55074,7 +55808,7 @@ stores.inject(MyMetaStore, storeInstance);
                   return argAst.value;
               }
               const argsString = astToFormula(argAst);
-              return this.getters.evaluateFormula(this.getters.getActiveSheetId(), argsString);
+              return this.getters.evaluateFormula(sheetId, argsString);
           });
           return { functionName, args: evaluatedArgs };
       }
@@ -55097,7 +55831,7 @@ stores.inject(MyMetaStore, storeInstance);
               return EMPTY_PIVOT_CELL;
           }
           const mainPosition = this.getters.getCellPosition(cell.id);
-          const result = this.getters.getFirstPivotFunction(cell.compiledFormula.tokens);
+          const result = this.getters.getFirstPivotFunction(position.sheetId, cell.compiledFormula.tokens);
           if (!result) {
               return EMPTY_PIVOT_CELL;
           }
@@ -57135,6 +57869,12 @@ stores.inject(MyMetaStore, storeInstance);
               case "INSERT_NEW_PIVOT":
                   this.insertNewPivot(cmd.pivotId, cmd.newSheetId);
                   break;
+              case "DUPLICATE_PIVOT_IN_NEW_SHEET":
+                  this.duplicatePivotInNewSheet(cmd.pivotId, cmd.newPivotId, cmd.newSheetId);
+                  break;
+              case "INSERT_PIVOT_WITH_TABLE":
+                  this.insertPivotWithTable(cmd.sheetId, cmd.col, cmd.row, cmd.pivotId, cmd.table);
+                  break;
           }
       }
       insertNewPivot(pivotId, sheetId) {
@@ -57160,7 +57900,7 @@ stores.inject(MyMetaStore, storeInstance);
           const formulaId = this.getters.getPivotFormulaId(pivotId);
           this.dispatch("CREATE_SHEET", {
               sheetId,
-              name: _t("Pivot #%s", formulaId),
+              name: _t("Pivot #%(formulaId)s", { formulaId }),
               position,
           });
           this.dispatch("ACTIVATE_SHEET", {
@@ -57174,6 +57914,92 @@ stores.inject(MyMetaStore, storeInstance);
               content: `=PIVOT(${formulaId})`,
           });
       }
+      duplicatePivotInNewSheet(pivotId, newPivotId, newSheetId) {
+          this.dispatch("DUPLICATE_PIVOT", {
+              pivotId,
+              newPivotId,
+          });
+          const activeSheetId = this.getters.getActiveSheetId();
+          const position = this.getters.getSheetIds().indexOf(activeSheetId) + 1;
+          const formulaId = this.getters.getPivotFormulaId(newPivotId);
+          const newPivotName = this.getters.getPivotName(newPivotId);
+          this.dispatch("CREATE_SHEET", {
+              sheetId: newSheetId,
+              name: this.getPivotDuplicateSheetName(_t("%(newPivotName)s (Pivot #%(formulaId)s)", {
+                  newPivotName,
+                  formulaId,
+              })),
+              position,
+          });
+          this.dispatch("ACTIVATE_SHEET", { sheetIdFrom: activeSheetId, sheetIdTo: newSheetId });
+          this.dispatch("UPDATE_CELL", {
+              sheetId: newSheetId,
+              col: 0,
+              row: 0,
+              content: `=PIVOT(${formulaId})`,
+          });
+      }
+      getPivotDuplicateSheetName(pivotName) {
+          let i = 1;
+          const names = this.getters.getSheetIds().map((id) => this.getters.getSheetName(id));
+          let name = pivotName;
+          while (names.includes(name)) {
+              name = `${pivotName} (${i})`;
+              i++;
+          }
+          return name;
+      }
+      insertPivotWithTable(sheetId, col, row, pivotId, table) {
+          const { cols, rows, measures, fieldsType } = table;
+          const pivotTable = new SpreadsheetPivotTable(cols, rows, measures, fieldsType || {});
+          this.resizeSheet(sheetId, col, row, pivotTable);
+          const pivotFormulaId = this.getters.getPivotFormulaId(pivotId);
+          this.dispatch("UPDATE_CELL", {
+              sheetId,
+              col,
+              row,
+              content: `=PIVOT("${pivotFormulaId}")`,
+          });
+          const zone = {
+              left: col,
+              right: col,
+              top: row,
+              bottom: row,
+          };
+          const numberOfHeaders = pivotTable.columns.length - 1;
+          this.dispatch("CREATE_TABLE", {
+              tableType: "dynamic",
+              sheetId,
+              ranges: [this.getters.getRangeDataFromZone(sheetId, zone)],
+              config: { ...PIVOT_TABLE_CONFIG, numberOfHeaders },
+          });
+      }
+      resizeSheet(sheetId, col, row, table) {
+          const colLimit = table.getNumberOfDataColumns() + 1; // +1 for the Top-Left
+          const numberCols = this.getters.getNumberCols(sheetId);
+          const deltaCol = numberCols - col;
+          if (deltaCol < colLimit) {
+              this.dispatch("ADD_COLUMNS_ROWS", {
+                  dimension: "COL",
+                  base: numberCols - 1,
+                  sheetId: sheetId,
+                  quantity: colLimit - deltaCol,
+                  position: "after",
+              });
+          }
+          const rowLimit = table.columns.length + table.rows.length;
+          const numberRows = this.getters.getNumberRows(sheetId);
+          const deltaRow = numberRows - row;
+          if (deltaRow < rowLimit) {
+              this.dispatch("ADD_COLUMNS_ROWS", {
+                  dimension: "ROW",
+                  base: numberRows - 1,
+                  sheetId: sheetId,
+                  quantity: rowLimit - deltaRow,
+                  position: "after",
+              });
+          }
+      }
   }
 
   class SortPlugin extends UIPlugin {
@@ -57354,6 +58180,7 @@ stores.inject(MyMetaStore, storeInstance);
       static getters = [
           "doesCellHaveGridIcon",
           "getCellWidth",
+          "getCellIconSrc",
           "getTextWidth",
           "getCellText",
           "getCellMultiLineText",
@@ -57404,7 +58231,7 @@ stores.inject(MyMetaStore, storeInstance);
               const multiLineText = splitTextToWidth(this.ctx, content, style, undefined);
               contentWidth += Math.max(...multiLineText.map((line) => computeTextWidth(this.ctx, line, style)));
           }
-          const icon = this.getters.getConditionalIcon(position);
+          const icon = this.getters.getCellIconSrc(position);
           if (icon) {
               contentWidth += computeIconWidth(style);
           }
@@ -57421,6 +58248,16 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return contentWidth;
       }
+      getCellIconSrc(position) {
+          const callbacks = iconsOnCellRegistry.getAll();
+          for (const callback of callbacks) {
+              const imageSrc = callback(this.getters, position);
+              if (imageSrc) {
+                  return imageSrc;
+              }
+          }
+          return undefined;
+      }
       getTextWidth(text, style) {
           return computeTextWidth(this.ctx, text, style);
       }
@@ -61196,7 +62033,7 @@ stores.inject(MyMetaStore, storeInstance);
               this.DOMFocusableElementStore.focus();
           }
       }
-      onClickSheetName(ev) {
+      onMouseEventSheetName(ev) {
           if (this.state.isEditing)
               ev.stopPropagation();
       }
@@ -62924,7 +63761,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       get topbarComponents() {
           return topbarComponentRegistry
-              .getAll()
+              .getAllOrdered()
               .filter((item) => !item.isVisible || item.isVisible(this.env));
       }
       onExternalClick(ev) {
@@ -67337,6 +68174,7 @@ stores.inject(MyMetaStore, storeInstance);
       linkMenuRegistry,
       functionRegistry,
       featurePluginRegistry,
+      iconsOnCellRegistry,
       statefulUIPluginRegistry,
       coreViewsPluginRegistry,
       corePluginRegistry,
@@ -67554,9 +68392,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.4.0-alpha.8";
-  __info__.date = "2024-06-24T19:51:16.144Z";
-  __info__.hash = "ccd30df";
+  __info__.version = "17.4.0";
+  __info__.date = "2024-07-12T04:41:51.675Z";
+  __info__.hash = "f8e8543";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);