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

package/dist/o-spreadsheet.cjs.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
  */
 
 'use strict';
@@ -592,7 +592,7 @@ function getAddHeaderStartIndex(position, base) {
 /**
  * Compares two objects.
  */
-function deepEquals(o1, o2, ignoreFunctions) {
+function deepEquals(o1, o2) {
     if (o1 === o2)
         return true;
     if ((o1 && !o2) || (o2 && !o1))
@@ -608,17 +608,13 @@ function deepEquals(o1, o2, ignoreFunctions) {
         }
     }
     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;
         }
@@ -1156,31 +1152,15 @@ function numberToLetters(n) {
         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");
@@ -1199,37 +1179,27 @@ function isCharADigit(char) {
  */
 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);
@@ -1831,7 +1801,7 @@ const getFormulaNumberRegex = memoize(function getFormulaNumberRegex(decimalSepa
 });
 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)
@@ -1864,7 +1834,7 @@ function isNumber(value, locale) {
     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
@@ -2667,11 +2637,11 @@ function generateMatrix(nColumns, nRows, callback) {
     }
     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;
@@ -2771,6 +2741,9 @@ function getPredicate(descr, locale) {
  * 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) {
@@ -2794,9 +2767,9 @@ const wildcardToRegExp = memoize(function wildcardToRegExp(operand) {
     }
     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 === "=") {
@@ -5888,19 +5861,22 @@ class TokenizingChars {
 }
 
 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;
@@ -5998,7 +5974,10 @@ function canonicalizeNumberLiteral(content, locale) {
     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.
@@ -6295,24 +6274,6 @@ const dayOfMonthAdapter = {
         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
  */
@@ -6334,25 +6295,6 @@ const isoWeekNumberAdapter = {
         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
  */
@@ -6374,25 +6316,6 @@ const monthNumberAdapter = {
         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
  */
@@ -6406,7 +6329,7 @@ const quarterNumberAdapter = {
     },
     toValueAndFormat(normalizedValue) {
         return {
-            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            value: _t("Q%(quarter_number)s", { quarter_number: normalizedValue }),
             format: "0",
         };
     },
@@ -6456,15 +6379,11 @@ function nullHandlerDecorator(adapter) {
 }
 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"),
@@ -6540,11 +6459,10 @@ function getMaxObjectId(o) {
 }
 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"),
@@ -6695,7 +6613,7 @@ class CellClipboardHandler extends AbstractCellClipboardHandler {
                 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);
@@ -7500,6 +7418,146 @@ function transformRangeData(range, executed) {
     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 = ["%"];
@@ -7648,7 +7706,7 @@ function parseExpression(tokens, parent_priority = 0) {
  * 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");
@@ -7784,146 +7842,6 @@ function rightOperandToFormula(operationAST) {
     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
@@ -8154,8 +8072,8 @@ function detectLink(value) {
 
 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("=")) {
@@ -8176,13 +8094,13 @@ function parseLiteral(content, locale) {
     }
     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);
@@ -8195,8 +8113,8 @@ function createEvaluatedCell(fPayload, locale = DEFAULT_LOCALE, cell) {
         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)) {
@@ -8484,9 +8402,11 @@ const ChartTerms = {
     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)
@@ -10328,162 +10248,6 @@ class ComposerFocusStore extends SpreadsheetStore {
     }
 }
 
-/** 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)
@@ -10806,6 +10570,238 @@ function getDefinedAxis(definition) {
     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 "";
@@ -18844,7 +18840,7 @@ const INDEX = {
     isExported: true,
 };
 // -----------------------------------------------------------------------------
-// INDEX
+// INDIRECT
 // -----------------------------------------------------------------------------
 const INDIRECT = {
     description: _t("Returns the content of a cell, specified by a string."),
@@ -19182,7 +19178,7 @@ const PIVOT = {
         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) {
@@ -19239,6 +19235,79 @@ const PIVOT = {
         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,
@@ -19250,6 +19319,7 @@ var lookup = /*#__PURE__*/Object.freeze({
   INDIRECT: INDIRECT,
   LOOKUP: LOOKUP,
   MATCH: MATCH,
+  OFFSET: OFFSET,
   PIVOT: PIVOT,
   PIVOT_HEADER: PIVOT_HEADER,
   PIVOT_VALUE: PIVOT_VALUE,
@@ -19532,6 +19602,320 @@ var operators = /*#__PURE__*/Object.freeze({
   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;
@@ -19949,6 +20333,7 @@ const categories = [
     { 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 {
@@ -19960,41 +20345,127 @@ class FunctionRegistry extends Registry {
         }
         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)
@@ -20013,42 +20484,16 @@ function hasStringValue(obj) {
     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", {
@@ -21497,6 +21942,7 @@ function indentCode(code) {
 
 const functions$1 = functionRegistry.content;
 const OPERATOR_MAP = {
+    // export for test
     "=": "EQ",
     "+": "ADD",
     "-": "MINUS",
@@ -21511,6 +21957,7 @@ const OPERATOR_MAP = {
     "&": "CONCATENATE",
 };
 const UNARY_OPERATOR_MAP = {
+    // export for test
     "-": "UMINUS",
     "+": "UPLUS",
     "%": "UNARY.PERCENT",
@@ -21581,7 +22028,7 @@ function compileTokens(tokens) {
         }
         /**
          * 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
@@ -22799,8 +23246,7 @@ function truncateLabel(label) {
 /**
  * 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
@@ -22949,14 +23395,17 @@ function getChartDatasetValues(getters, dataSets) {
     }
     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
@@ -22973,7 +23422,6 @@ function chartToImage(runtime, figure, type) {
     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();
@@ -23023,6 +23471,7 @@ class BarChart extends AbstractChart {
     dataSetDesign;
     axesDesign;
     horizontal;
+    showValues;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -23035,6 +23484,7 @@ class BarChart extends AbstractChart {
         this.dataSetDesign = definition.dataSets;
         this.axesDesign = definition.axesDesign;
         this.horizontal = definition.horizontal;
+        this.showValues = definition.showValues;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -23054,6 +23504,7 @@ class BarChart extends AbstractChart {
             type: "bar",
             labelRange: context.auxiliaryRange || undefined,
             axesDesign: context.axesDesign,
+            showValues: context.showValues,
         };
     }
     getContextCreation() {
@@ -23107,6 +23558,7 @@ class BarChart extends AbstractChart {
             aggregated: this.aggregated,
             axesDesign: this.axesDesign,
             horizontal: this.horizontal,
+            showValues: this.showValues,
         };
     }
     getDefinitionForExcel() {
@@ -23156,22 +23608,23 @@ function getBarConfiguration(chart, labels, localeFormat) {
         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;
@@ -23204,6 +23657,12 @@ function getBarConfiguration(chart, labels, localeFormat) {
             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) {
@@ -23251,467 +23710,6 @@ function createBarChartRuntime(chart, getters) {
     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,
@@ -23894,13 +23892,11 @@ function canBeLinearChart(labelRange, getters) {
 }
 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;
@@ -23917,9 +23913,7 @@ function getLineOrScatterConfiguration(chart, labels, options) {
             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;
                 }
@@ -23946,151 +23940,628 @@ function getLineOrScatterConfiguration(chart, labels, options) {
             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;
@@ -24105,6 +24576,8 @@ class LineChart extends AbstractChart {
     cumulative;
     dataSetDesign;
     axesDesign;
+    fillArea;
+    showValues;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(this.getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24118,6 +24591,8 @@ class LineChart extends AbstractChart {
         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);
@@ -24139,6 +24614,8 @@ class LineChart extends AbstractChart {
             aggregated: context.aggregated ?? false,
             cumulative: context.cumulative ?? false,
             axesDesign: context.axesDesign,
+            fillArea: context.fillArea,
+            showValues: context.showValues,
         };
     }
     getDefinition() {
@@ -24167,6 +24644,8 @@ class LineChart extends AbstractChart {
             aggregated: this.aggregated,
             cumulative: this.cumulative,
             axesDesign: this.axesDesign,
+            fillArea: this.fillArea,
+            showValues: this.showValues,
         };
     }
     getContextCreation() {
@@ -24222,10 +24701,6 @@ class LineChart extends AbstractChart {
         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;
@@ -24236,6 +24711,7 @@ class PieChart extends AbstractChart {
     aggregated;
     dataSetsHaveTitle;
     isDoughnut;
+    showValues;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24245,6 +24721,7 @@ class PieChart extends AbstractChart {
         this.aggregated = definition.aggregated;
         this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
         this.isDoughnut = definition.isDoughnut;
+        this.showValues = definition.showValues;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24263,6 +24740,7 @@ class PieChart extends AbstractChart {
             labelRange: context.auxiliaryRange || undefined,
             aggregated: context.aggregated ?? false,
             isDoughnut: false,
+            showValues: context.showValues,
         };
     }
     getDefinition() {
@@ -24294,6 +24772,7 @@ class PieChart extends AbstractChart {
             title: this.title,
             aggregated: this.aggregated,
             isDoughnut: this.isDoughnut,
+            showValues: this.showValues,
         };
     }
     copyForSheetId(sheetId) {
@@ -24361,6 +24840,7 @@ function getPieConfiguration(chart, labels, localeFormat) {
         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) {
@@ -24446,6 +24926,7 @@ class PyramidChart extends AbstractChart {
     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);
@@ -24456,6 +24937,7 @@ class PyramidChart extends AbstractChart {
         this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
         this.dataSetDesign = definition.dataSets;
         this.axesDesign = definition.axesDesign;
+        this.showValues = definition.showValues;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24476,6 +24958,7 @@ class PyramidChart extends AbstractChart {
             axesDesign: context.axesDesign,
             horizontal: true,
             stacked: true,
+            showValues: context.showValues,
         };
     }
     getContextCreation() {
@@ -24529,6 +25012,7 @@ class PyramidChart extends AbstractChart {
             axesDesign: this.axesDesign,
             horizontal: true,
             stacked: true,
+            showValues: this.showValues,
         };
     }
     getDefinitionForExcel() {
@@ -24563,6 +25047,8 @@ function createPyramidChartRuntime(chart, getters) {
         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 };
 }
 
@@ -24577,6 +25063,7 @@ class ScatterChart extends AbstractChart {
     dataSetsHaveTitle;
     dataSetDesign;
     axesDesign;
+    showValues;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(this.getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24588,6 +25075,7 @@ class ScatterChart extends AbstractChart {
         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);
@@ -24607,6 +25095,7 @@ class ScatterChart extends AbstractChart {
             labelRange: context.auxiliaryRange || undefined,
             aggregated: context.aggregated ?? false,
             axesDesign: context.axesDesign,
+            showValues: context.showValues,
         };
     }
     getDefinition() {
@@ -24633,6 +25122,7 @@ class ScatterChart extends AbstractChart {
             labelsAsText: this.labelsAsText,
             aggregated: this.aggregated,
             axesDesign: this.axesDesign,
+            showValues: this.showValues,
         };
     }
     getContextCreation() {
@@ -24733,6 +25223,7 @@ class WaterfallChart extends AbstractChart {
     subTotalValuesColor;
     dataSetDesign;
     axesDesign;
+    showValues;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24750,6 +25241,7 @@ class WaterfallChart extends AbstractChart {
         this.firstValueAsSubtotal = definition.firstValueAsSubtotal;
         this.dataSetDesign = definition.dataSets;
         this.axesDesign = definition.axesDesign;
+        this.showValues = definition.showValues;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24772,6 +25264,7 @@ class WaterfallChart extends AbstractChart {
             showConnectorLines: context.showConnectorLines ?? true,
             firstValueAsSubtotal: context.firstValueAsSubtotal ?? false,
             axesDesign: context.axesDesign,
+            showValues: context.showValues,
         };
     }
     getContextCreation() {
@@ -24830,6 +25323,7 @@ class WaterfallChart extends AbstractChart {
             subTotalValuesColor: this.subTotalValuesColor,
             firstValueAsSubtotal: this.firstValueAsSubtotal,
             axesDesign: this.axesDesign,
+            showValues: this.showValues,
         };
     }
     getDefinitionForExcel() {
@@ -24927,6 +25421,10 @@ function getWaterfallConfiguration(chart, labels, dataSeriesLabels, localeFormat
         },
     };
     config.options.plugins.waterfallLinesPlugin = { showConnectorLines: chart.showConnectorLines };
+    config.options.plugins.chartShowValuesPlugin = {
+        showValues: chart.showValues,
+        background: chart.background,
+    };
     return config;
 }
 function createWaterfallChartRuntime(chart, getters) {
@@ -25019,7 +25517,7 @@ chartRegistry.add("combo", {
 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,
@@ -25093,27 +25591,46 @@ const chartCategories = {
     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", {
@@ -25537,7 +26054,7 @@ class MenuItemRegistry extends Registry {
      * @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;
         }
@@ -25559,6 +26076,19 @@ class MenuItemRegistry extends Registry {
         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;
     }
@@ -27851,6 +28381,23 @@ const CREATE_PIVOT = (env) => {
         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
 //------------------------------------------------------------------------------
@@ -28715,12 +29262,21 @@ const splitToColumns = {
     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,
@@ -30201,7 +30757,8 @@ topbarMenuRegistry
                 : undefined,
         };
     });
-});
+})
+    .addChild("reinsert_pivot", ["data"], reinsertPivotMenu);
 
 class OTRegistry extends Registry {
     /**
@@ -31686,7 +32243,7 @@ class ChartTitle extends owl.Component {
     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 },
@@ -31695,6 +32252,9 @@ class ChartTitle extends owl.Component {
         updateColor: { type: Function, optional: true },
         style: { type: Object, optional: true },
     };
+    static defaultProps = {
+        title: "",
+    };
     openedEl = null;
     setup() {
         owl.useExternalListener(window, "click", this.onExternalClick);
@@ -31890,6 +32450,7 @@ class ChartWithAxisDesignPanel extends owl.Component {
         Section,
         AxisDesignEditor,
         RoundColorPicker,
+        Checkbox,
     };
     static props = {
         figureId: String,
@@ -31982,6 +32543,12 @@ class ChartWithAxisDesignPanel extends owl.Component {
         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 {
@@ -32131,6 +32698,10 @@ class LineConfigPanel extends GenericChartConfigPanel {
         }
         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) {
@@ -32170,6 +32741,7 @@ class PieChartDesignPanel extends owl.Component {
     static components = {
         GeneralDesignEditor,
         Section,
+        Checkbox,
     };
     static props = {
         figureId: String,
@@ -32182,6 +32754,9 @@ class PieChartDesignPanel extends owl.Component {
             legendPosition: ev.target.value,
         });
     }
+    get showValuesLabel() {
+        return ChartTerms.ShowValues;
+    }
 }
 
 class ScatterConfigPanel extends GenericChartConfigPanel {
@@ -32376,6 +32951,12 @@ class WaterfallChartDesignPanel extends owl.Component {
             verticalAxisPosition: ev.target.value,
         });
     }
+    get showValuesLabel() {
+        return ChartTerms.ShowValues;
+    }
+    updateShowValues(showValues) {
+        this.props.updateChart(this.props.figureId, { showValues });
+    }
 }
 
 const chartSidePanelComponentRegistry = new Registry();
@@ -32636,6 +33217,11 @@ class ChartPanel extends owl.Component {
     }
 }
 
+/**
+ * Registry to draw icons on cells
+ */
+const iconsOnCellRegistry = new Registry();
+
 css /* scss */ `
   .o-spreadsheet {
     .o-icon {
@@ -32671,49 +33257,47 @@ const FROWN = '<svg class="o-cf-icon frown" width="10" height="10" focusable="fa
 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 = {
@@ -32733,6 +33317,12 @@ const ICON_SETS = {
         bad: "dotBad",
     },
 };
+iconsOnCellRegistry.add("conditional_formatting", (getters, position) => {
+    const icon = getters.getConditionalIcon(position);
+    if (icon) {
+        return ICONS[icon].img;
+    }
+});
 
 css /* scss */ `
   .o-icon-picker {
@@ -33081,21 +33671,25 @@ function useHoveredElement(ref) {
 
 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 */ `
@@ -34567,6 +35161,8 @@ class FindAndReplaceStore extends SpreadsheetStore {
     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;
@@ -34576,7 +35172,7 @@ class FindAndReplaceStore extends SpreadsheetStore {
         matchCase: false,
         exactMatch: false,
         searchFormulas: false,
-        searchScope: "allSheets",
+        searchScope: "activeSheet",
         specificRange: undefined,
     };
     updateSearchContent = debounce(this._updateSearchContent.bind(this), 200);
@@ -34643,6 +35239,11 @@ class FindAndReplaceStore extends SpreadsheetStore {
                 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() {
@@ -34824,12 +35425,36 @@ class FindAndReplaceStore extends SpreadsheetStore {
             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);
@@ -35506,9 +36131,11 @@ class PivotTitleSection extends owl.Component {
     }
     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";
@@ -36043,7 +36670,7 @@ function createDate(dimension, value, locale) {
         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":
@@ -36071,7 +36698,7 @@ function createDate(dimension, value, locale) {
  * 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 }
  *   },
@@ -36098,7 +36725,7 @@ function createDate(dimension, value, locale) {
  * }
  */
 const MAP_VALUE_DIMENSION_DATE = {
-    year_number: {
+    year: {
         set: new Set(),
         values: {},
     },
@@ -36483,7 +37110,7 @@ pivotRegistry.add("SPREADSHEET", {
     externalData: false,
     onIterationEndEvaluation: (pivot) => pivot.markAsDirtyForEvaluation(),
     granularities: [
-        "year_number",
+        "year",
         "quarter_number",
         "month_number",
         "iso_week_number",
@@ -36893,7 +37520,13 @@ class SettingsPanel extends owl.Component {
     }
     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() {
@@ -37952,6 +38585,9 @@ class TopBarComponentRegistry extends Registry {
         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();
 
@@ -40840,21 +41476,22 @@ class GridRenderer {
             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;
@@ -40873,7 +41510,7 @@ class GridRenderer {
         };
         /** ClipRect */
         const isOverflowing = contentWidth > width || fontSizePX > height;
-        if (cfIcon || box.hasIcon) {
+        if (iconSrc || box.hasIcon) {
             box.clipRect = {
                 x: box.x + iconBoxWidth,
                 y: box.y,
@@ -40984,6 +41621,11 @@ class GridRenderer {
         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);
@@ -42056,6 +42698,7 @@ class Grid extends owl.Component {
             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();
@@ -42322,6 +42965,8 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
     "BITOR",
     "BITRSHIFT",
     "BITXOR",
+    "BYCOL",
+    "BYROW",
     "CEILING.MATH",
     "CEILING.PRECISE",
     "CHISQ.DIST",
@@ -42329,6 +42974,8 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
     "CHISQ.INV",
     "CHISQ.INV.RT",
     "CHISQ.TEST",
+    "CHOOSECOLS",
+    "CHOOSEROWS",
     "COMBINA",
     "CONCAT",
     "CONFIDENCE.NORM",
@@ -42341,14 +42988,17 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
     "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",
@@ -42363,6 +43013,7 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
     "GAMMA.INV",
     "GAMMALN.PRECISE",
     "GAUSS",
+    "HSTACK",
     "HYPGEOM.DIST",
     "IFNA",
     "IFS",
@@ -42375,9 +43026,14 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
     "IMSINH",
     "IMTAN",
     "ISFORMULA",
+    "ISOMITTED",
     "ISOWEEKNUM",
+    "LAMBDA",
+    "LET",
     "LOGNORM.DIST",
     "LOGNORM.INV",
+    "MAKEARRAY",
+    "MAP",
     "MAXIFS",
     "MINIFS",
     "MODE.MULT",
@@ -42397,17 +43053,26 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
     "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",
@@ -42417,13 +43082,24 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
     "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",
 ];
@@ -45607,7 +46283,7 @@ function getRelationFile(file, xmls) {
     return relsFile;
 }
 
-const EXCEL_IMPORT_VERSION = 16;
+const EXCEL_IMPORT_VERSION = 17;
 class XlsxReader {
     warningManager;
     xmls;
@@ -45739,7 +46415,7 @@ function normalizeV9(formula) {
  * 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
@@ -46686,6 +47362,21 @@ class BordersPlugin extends CorePlugin {
             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
      */
@@ -46735,7 +47426,7 @@ class BordersPlugin extends CorePlugin {
                 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) => {
@@ -49061,10 +49752,12 @@ class MergePlugin extends CorePlugin {
         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)
@@ -52932,7 +53625,13 @@ class FormulaDependencyGraph {
         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) {
@@ -52948,7 +53647,16 @@ class FormulaDependencyGraph {
                 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;
     }
 }
@@ -53079,7 +53787,7 @@ class PositionSet {
         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();
@@ -53423,6 +54131,7 @@ class Evaluator {
         }
         finally {
             this.cellsBeingComputed.delete(cellId);
+            this.nextPositionsToUpdate.delete(position);
         }
     }
     computeAndSave(position) {
@@ -53449,8 +54158,33 @@ class Evaluator {
         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);
@@ -53481,14 +54215,15 @@ class Evaluator {
     }
     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 ||
@@ -53498,17 +54233,16 @@ class Evaluator {
             }
             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)) {
@@ -53563,12 +54297,12 @@ function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
  * 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(() => {
@@ -55043,7 +55777,7 @@ class PivotUIPlugin extends UIPlugin {
     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);
@@ -55054,12 +55788,12 @@ class PivotUIPlugin extends UIPlugin {
     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;
@@ -55075,7 +55809,7 @@ class PivotUIPlugin extends UIPlugin {
                 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 };
     }
@@ -55098,7 +55832,7 @@ class PivotUIPlugin extends UIPlugin {
             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;
         }
@@ -57136,6 +57870,12 @@ class InsertPivotPlugin extends UIPlugin {
             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) {
@@ -57161,7 +57901,7 @@ class InsertPivotPlugin extends UIPlugin {
         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", {
@@ -57175,6 +57915,92 @@ class InsertPivotPlugin extends UIPlugin {
             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 {
@@ -57355,6 +58181,7 @@ class SheetUIPlugin extends UIPlugin {
     static getters = [
         "doesCellHaveGridIcon",
         "getCellWidth",
+        "getCellIconSrc",
         "getTextWidth",
         "getCellText",
         "getCellMultiLineText",
@@ -57405,7 +58232,7 @@ class SheetUIPlugin extends UIPlugin {
             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);
         }
@@ -57422,6 +58249,16 @@ class SheetUIPlugin extends UIPlugin {
         }
         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);
     }
@@ -61197,7 +62034,7 @@ class BottomBarSheet extends owl.Component {
             this.DOMFocusableElementStore.focus();
         }
     }
-    onClickSheetName(ev) {
+    onMouseEventSheetName(ev) {
         if (this.state.isEditing)
             ev.stopPropagation();
     }
@@ -62925,7 +63762,7 @@ class TopBar extends owl.Component {
     }
     get topbarComponents() {
         return topbarComponentRegistry
-            .getAll()
+            .getAllOrdered()
             .filter((item) => !item.isVisible || item.isVisible(this.env));
     }
     onExternalClick(ev) {
@@ -67338,6 +68175,7 @@ const registries = {
     linkMenuRegistry,
     functionRegistry,
     featurePluginRegistry,
+    iconsOnCellRegistry,
     statefulUIPluginRegistry,
     coreViewsPluginRegistry,
     corePluginRegistry,
@@ -67555,6 +68393,6 @@ exports.tokenColors = tokenColors;
 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";