@odoo/o-spreadsheet 17.4.0-alpha.11 → 17.4.0-alpha.13

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.11
- * @date 2024-07-02T10:38:50.116Z
- * @hash 9fe9477
+ * @version 17.4.0-alpha.13
+ * @date 2024-07-11T06:36:58.556Z
+ * @hash e0f506b
  */
 
 '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;
         }
@@ -1805,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)
@@ -1838,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
@@ -2641,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;
@@ -2745,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) {
@@ -2768,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 === "=") {
@@ -5862,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;
@@ -5972,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.
@@ -6324,7 +6329,7 @@ const quarterNumberAdapter = {
     },
     toValueAndFormat(normalizedValue) {
         return {
-            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            value: _t("Q%(quarter_number)s", { quarter_number: normalizedValue }),
             format: "0",
         };
     },
@@ -6454,9 +6459,9 @@ 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"),
     quarter_number: _t("Quarter"),
     month_number: _t("Month"),
@@ -6608,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);
@@ -7413,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 = ["%"];
@@ -7561,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");
@@ -7697,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
@@ -8067,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("=")) {
@@ -8089,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);
@@ -8108,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)) {
@@ -10296,7 +10301,6 @@ 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";
@@ -10329,7 +10333,7 @@ class ChartJsComponent extends owl.Component {
         owl.onWillUnmount(() => this.chart?.destroy());
         owl.useEffect(() => {
             const runtime = this.chartRuntime;
-            if (!deepEquals(runtime, this.currentRuntime, "ignoreFunctions")) {
+            if (runtime !== this.currentRuntime) {
                 if (runtime.chartJsConfig.type !== this.currentRuntime.chartJsConfig.type) {
                     this.chart?.destroy();
                     this.createChart(deepCopy(runtime.chartJsConfig));
@@ -10344,7 +10348,6 @@ class ChartJsComponent extends owl.Component {
     createChart(chartData) {
         const canvas = this.canvas.el;
         const ctx = canvas.getContext("2d");
-        // @ts-ignore
         this.chart = new window.Chart(ctx, chartData);
     }
     updateChartJs(chartRuntime) {
@@ -19096,7 +19099,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) {
@@ -19520,6 +19523,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;
@@ -19937,6 +20254,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 {
@@ -19948,41 +20266,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)
@@ -20001,42 +20405,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", {
@@ -21485,6 +21863,7 @@ function indentCode(code) {
 
 const functions$1 = functionRegistry.content;
 const OPERATOR_MAP = {
+    // export for test
     "=": "EQ",
     "+": "ADD",
     "-": "MINUS",
@@ -21499,6 +21878,7 @@ const OPERATOR_MAP = {
     "&": "CONCATENATE",
 };
 const UNARY_OPERATOR_MAP = {
+    // export for test
     "-": "UMINUS",
     "+": "UPLUS",
     "%": "UNARY.PERCENT",
@@ -22787,8 +23167,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
@@ -22964,7 +23343,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();
@@ -23885,13 +24263,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;
@@ -23908,9 +24284,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;
                 }
@@ -24027,10 +24401,6 @@ function createLineOrScatterChartRuntime(chart, getters) {
     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 (areaChart) {
@@ -24046,6 +24416,10 @@ function createLineOrScatterChartRuntime(chart, getters) {
                 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,
@@ -33152,21 +33526,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 */ `
@@ -34638,6 +35016,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;
@@ -34714,6 +35094,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() {
@@ -34895,12 +35280,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);
@@ -36966,7 +37375,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() {
@@ -38025,6 +38440,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();
 
@@ -42135,6 +42553,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();
@@ -45719,7 +46138,7 @@ function getRelationFile(file, xmls) {
     return relsFile;
 }
 
-const EXCEL_IMPORT_VERSION = 16;
+const EXCEL_IMPORT_VERSION = 17;
 class XlsxReader {
     warningManager;
     xmls;
@@ -45851,7 +46270,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
@@ -46798,6 +47217,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
      */
@@ -46847,7 +47281,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) => {
@@ -49173,10 +49607,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)
@@ -53044,7 +53480,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) {
@@ -53060,7 +53502,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;
     }
 }
@@ -53191,7 +53642,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();
@@ -53535,6 +53986,7 @@ class Evaluator {
         }
         finally {
             this.cellsBeingComputed.delete(cellId);
+            this.nextPositionsToUpdate.delete(position);
         }
     }
     computeAndSave(position) {
@@ -53561,8 +54013,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);
@@ -53593,14 +54070,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 ||
@@ -53610,17 +54088,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)) {
@@ -53675,12 +54152,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(() => {
@@ -63140,7 +63617,7 @@ class TopBar extends owl.Component {
     }
     get topbarComponents() {
         return topbarComponentRegistry
-            .getAll()
+            .getAllOrdered()
             .filter((item) => !item.isVisible || item.isVisible(this.env));
     }
     onExternalClick(ev) {
@@ -67771,6 +68248,6 @@ exports.tokenColors = tokenColors;
 exports.tokenize = tokenize;
 
 
-__info__.version = "17.4.0-alpha.11";
-__info__.date = "2024-07-02T10:38:50.116Z";
-__info__.hash = "9fe9477";
+__info__.version = "17.4.0-alpha.13";
+__info__.date = "2024-07-11T06:36:58.556Z";
+__info__.hash = "e0f506b";