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

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.4.0-alpha.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
  */
 
 (function (exports, owl) {
@@ -591,7 +591,7 @@
   /**
    * Compares two objects.
    */
-  function deepEquals(o1, o2, ignoreFunctions) {
+  function deepEquals(o1, o2) {
       if (o1 === o2)
           return true;
       if ((o1 && !o2) || (o2 && !o1))
@@ -607,17 +607,13 @@
           }
       }
       for (const key in o1) {
-          const typeOfO1Key = typeof o1[key];
-          if (typeOfO1Key !== typeof o2[key])
+          if (typeof o1[key] !== typeof o2[key])
               return false;
-          if (typeOfO1Key === "object") {
-              if (!deepEquals(o1[key], o2[key], ignoreFunctions))
+          if (typeof o1[key] === "object") {
+              if (!deepEquals(o1[key], o2[key]))
                   return false;
           }
           else {
-              if (ignoreFunctions && typeOfO1Key === "function") {
-                  continue;
-              }
               if (o1[key] !== o2[key])
                   return false;
           }
@@ -1804,7 +1800,7 @@
   });
   const getNumberRegex = memoize(function getNumberRegex(locale) {
       const decimalSeparator = escapeRegExp(locale.decimalSeparator);
-      const thousandsSeparator = escapeRegExp(locale.thousandsSeparator);
+      const thousandsSeparator = escapeRegExp(locale.thousandsSeparator || "");
       const pIntegerAndDecimals = `(?:\\d+(?:${thousandsSeparator}\\d{3,})*(?:${decimalSeparator}\\d*)?)`; // pattern that match integer number with or without decimal digits
       const pOnlyDecimals = `(?:${decimalSeparator}\\d+)`; // pattern that match only expression with decimal digits
       const pScientificFormat = "(?:e(?:\\+|-)?\\d+)?"; // pattern that match scientific format between zero and one time (should be placed before pPercentFormat)
@@ -1837,7 +1833,7 @@
       return getNumberRegex(locale).test(value.trim());
   }
   const getInvaluableSymbolsRegexp = memoize(function getInvaluableSymbolsRegexp(locale) {
-      return new RegExp(`[\$€${escapeRegExp(locale.thousandsSeparator)}]`, "g");
+      return new RegExp(`[\$€${escapeRegExp(locale.thousandsSeparator || "")}]`, "g");
   });
   /**
    * Convert a string into a number. It assumes that the string actually represents
@@ -2640,11 +2636,11 @@
       }
       return returned;
   }
-  function matrixMap(matrix, fn) {
+  function matrixMap(matrix, callback) {
       if (matrix.length === 0) {
           return [];
       }
-      return generateMatrix(matrix.length, matrix[0].length, (col, row) => fn(matrix[col][row]));
+      return generateMatrix(matrix.length, matrix[0].length, (col, row) => callback(matrix[col][row]));
   }
   function matrixForEach(matrix, fn) {
       const numberOfCols = matrix.length;
@@ -2744,6 +2740,9 @@
    * If the character is a special regular expression character, it is escaped with "\\".
    */
   const wildcardToRegExp = memoize(function wildcardToRegExp(operand) {
+      if (operand === "*") {
+          return /.+/;
+      }
       let exp = "";
       let predecessor = "";
       for (let char of operand) {
@@ -2767,9 +2766,9 @@
       }
       return new RegExp("^" + exp + "$", "i");
   });
-  function evaluatePredicate(value, criterion) {
+  function evaluatePredicate(value = "", criterion) {
       const { operator, operand } = criterion;
-      if (value === undefined || operand === undefined || value === null || operand === null) {
+      if (operand === undefined || value === null || operand === null) {
           return false;
       }
       if (typeof operand === "number" && operator === "=") {
@@ -5861,19 +5860,22 @@
   }
 
   function isValidLocale(locale) {
-      if (!(locale &&
-          typeof locale === "object" &&
-          typeof locale.name === "string" &&
-          typeof locale.code === "string" &&
-          typeof locale.thousandsSeparator === "string" &&
-          typeof locale.decimalSeparator === "string" &&
-          typeof locale.dateFormat === "string" &&
-          typeof locale.timeFormat === "string" &&
-          typeof locale.formulaArgSeparator === "string")) {
+      if (!locale ||
+          typeof locale !== "object" ||
+          !(!locale.thousandsSeparator || typeof locale.thousandsSeparator === "string")) {
           return false;
       }
-      if (!Object.values(locale).every((v) => v)) {
-          return false;
+      for (const property of [
+          "code",
+          "name",
+          "decimalSeparator",
+          "dateFormat",
+          "timeFormat",
+          "formulaArgSeparator",
+      ]) {
+          if (!locale[property] || typeof locale[property] !== "string") {
+              return false;
+          }
       }
       if (locale.formulaArgSeparator === locale.decimalSeparator) {
           return false;
@@ -5971,7 +5973,10 @@
       if (locale.decimalSeparator === "." || !isNumber(content, locale)) {
           return content;
       }
-      return content.replace(locale.thousandsSeparator, "").replace(locale.decimalSeparator, ".");
+      if (locale.thousandsSeparator) {
+          content = content.replaceAll(locale.thousandsSeparator, "");
+      }
+      return content.replace(locale.decimalSeparator, ".");
   }
   /**
    * Change a content string from the given locale to its canonical form (en_US locale). Also convert date string.
@@ -6323,7 +6328,7 @@
       },
       toValueAndFormat(normalizedValue) {
           return {
-              value: toNumber(normalizedValue, DEFAULT_LOCALE),
+              value: _t("Q%(quarter_number)s", { quarter_number: normalizedValue }),
               format: "0",
           };
       },
@@ -6453,9 +6458,9 @@
   }
   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"),
@@ -6607,7 +6612,7 @@
                   const pivotId = this.getters.getPivotIdFromPosition(position);
                   const spreader = this.getters.getArrayFormulaSpreadingOn(position);
                   if (pivotId) {
-                      if (!deepEquals(spreader, position) || !isCopyingOneCell) {
+                      if (spreader && (!deepEquals(spreader, position) || !isCopyingOneCell)) {
                           const pivotCell = this.getters.getPivotCellFromPosition(position);
                           const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
                           const pivotFormula = createPivotFormula(formulaPivotId, pivotCell);
@@ -7412,6 +7417,146 @@
       return undefined;
   }
 
+  var State;
+  (function (State) {
+      /**
+       * Initial state.
+       * Expecting any reference for the left part of a range
+       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
+       */
+      State[State["LeftRef"] = 0] = "LeftRef";
+      /**
+       * Expecting any reference for the right part of a range
+       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
+       */
+      State[State["RightRef"] = 1] = "RightRef";
+      /**
+       * Expecting the separator without any constraint on the right part
+       */
+      State[State["Separator"] = 2] = "Separator";
+      /**
+       * Expecting the separator for a full column range
+       */
+      State[State["FullColumnSeparator"] = 3] = "FullColumnSeparator";
+      /**
+       * Expecting the separator for a full row range
+       */
+      State[State["FullRowSeparator"] = 4] = "FullRowSeparator";
+      /**
+       * Expecting the right part of a full column range
+       * e.g. "1", "A1"
+       */
+      State[State["RightColumnRef"] = 5] = "RightColumnRef";
+      /**
+       * Expecting the right part of a full row range
+       * e.g. "A", "A1"
+       */
+      State[State["RightRowRef"] = 6] = "RightRowRef";
+      /**
+       * Final state. A range has been matched
+       */
+      State[State["Found"] = 7] = "Found";
+  })(State || (State = {}));
+  const goTo = (state, guard = () => true) => [
+      {
+          goTo: state,
+          guard,
+      },
+  ];
+  const goToMulti = (state, guard = () => true) => ({
+      goTo: state,
+      guard,
+  });
+  const machine = {
+      [State.LeftRef]: {
+          REFERENCE: goTo(State.Separator),
+          NUMBER: goTo(State.FullRowSeparator),
+          SYMBOL: [
+              goToMulti(State.FullColumnSeparator, (token) => isColReference(token.value)),
+              goToMulti(State.FullRowSeparator, (token) => isRowReference(token.value)),
+          ],
+      },
+      [State.FullColumnSeparator]: {
+          SPACE: goTo(State.FullColumnSeparator),
+          OPERATOR: goTo(State.RightColumnRef, (token) => token.value === ":"),
+      },
+      [State.FullRowSeparator]: {
+          SPACE: goTo(State.FullRowSeparator),
+          OPERATOR: goTo(State.RightRowRef, (token) => token.value === ":"),
+      },
+      [State.Separator]: {
+          SPACE: goTo(State.Separator),
+          OPERATOR: goTo(State.RightRef, (token) => token.value === ":"),
+      },
+      [State.RightRef]: {
+          SPACE: goTo(State.RightRef),
+          NUMBER: goTo(State.Found),
+          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value) || isRowHeader(token.value)),
+      },
+      [State.RightColumnRef]: {
+          SPACE: goTo(State.RightColumnRef),
+          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value)),
+          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+      },
+      [State.RightRowRef]: {
+          SPACE: goTo(State.RightRowRef),
+          NUMBER: goTo(State.Found),
+          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+          SYMBOL: goTo(State.Found, (token) => isRowHeader(token.value)),
+      },
+      [State.Found]: {},
+  };
+  /**
+   * Check if the list of tokens starts with a sequence of tokens representing
+   * a range.
+   * If a range is found, the sequence is removed from the list and is returned
+   * as a single token.
+   */
+  function matchReference(tokens) {
+      let head = 0;
+      let transitions = machine[State.LeftRef];
+      let matchedTokens = "";
+      while (transitions !== undefined) {
+          const token = tokens[head++];
+          if (!token) {
+              return null;
+          }
+          const transition = transitions[token.type]?.find((transition) => transition.guard(token));
+          const nextState = transition ? transition.goTo : undefined;
+          switch (nextState) {
+              case undefined:
+                  return null;
+              case State.Found:
+                  matchedTokens += token.value;
+                  tokens.splice(0, head);
+                  return {
+                      type: "REFERENCE",
+                      value: matchedTokens,
+                  };
+              default:
+                  transitions = machine[nextState];
+                  matchedTokens += token.value;
+                  break;
+          }
+      }
+      return null;
+  }
+  /**
+   * Take the result of the tokenizer and transform it to be usable in the
+   * manipulations of range
+   *
+   * @param formula
+   */
+  function rangeTokenize(formula, locale = DEFAULT_LOCALE) {
+      const tokens = tokenize(formula, locale);
+      const result = [];
+      while (tokens.length) {
+          result.push(matchReference(tokens) || tokens.shift());
+      }
+      return result;
+  }
+
   const functionRegex = /[a-zA-Z0-9\_]+(\.[a-zA-Z0-9\_]+)*/;
   const UNARY_OPERATORS_PREFIX = ["-", "+"];
   const UNARY_OPERATORS_POSTFIX = ["%"];
@@ -7560,7 +7705,7 @@
    * Parse an expression (as a string) into an AST.
    */
   function parse(str) {
-      return parseTokens(tokenize(str));
+      return parseTokens(rangeTokenize(str));
   }
   function parseTokens(tokens) {
       tokens = tokens.filter((x) => x.type !== "SPACE");
@@ -7696,146 +7841,6 @@
       return needParenthesis ? `(${astToFormula(rightOperation)})` : astToFormula(rightOperation);
   }
 
-  var State;
-  (function (State) {
-      /**
-       * Initial state.
-       * Expecting any reference for the left part of a range
-       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
-       */
-      State[State["LeftRef"] = 0] = "LeftRef";
-      /**
-       * Expecting any reference for the right part of a range
-       * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
-       */
-      State[State["RightRef"] = 1] = "RightRef";
-      /**
-       * Expecting the separator without any constraint on the right part
-       */
-      State[State["Separator"] = 2] = "Separator";
-      /**
-       * Expecting the separator for a full column range
-       */
-      State[State["FullColumnSeparator"] = 3] = "FullColumnSeparator";
-      /**
-       * Expecting the separator for a full row range
-       */
-      State[State["FullRowSeparator"] = 4] = "FullRowSeparator";
-      /**
-       * Expecting the right part of a full column range
-       * e.g. "1", "A1"
-       */
-      State[State["RightColumnRef"] = 5] = "RightColumnRef";
-      /**
-       * Expecting the right part of a full row range
-       * e.g. "A", "A1"
-       */
-      State[State["RightRowRef"] = 6] = "RightRowRef";
-      /**
-       * Final state. A range has been matched
-       */
-      State[State["Found"] = 7] = "Found";
-  })(State || (State = {}));
-  const goTo = (state, guard = () => true) => [
-      {
-          goTo: state,
-          guard,
-      },
-  ];
-  const goToMulti = (state, guard = () => true) => ({
-      goTo: state,
-      guard,
-  });
-  const machine = {
-      [State.LeftRef]: {
-          REFERENCE: goTo(State.Separator),
-          NUMBER: goTo(State.FullRowSeparator),
-          SYMBOL: [
-              goToMulti(State.FullColumnSeparator, (token) => isColReference(token.value)),
-              goToMulti(State.FullRowSeparator, (token) => isRowReference(token.value)),
-          ],
-      },
-      [State.FullColumnSeparator]: {
-          SPACE: goTo(State.FullColumnSeparator),
-          OPERATOR: goTo(State.RightColumnRef, (token) => token.value === ":"),
-      },
-      [State.FullRowSeparator]: {
-          SPACE: goTo(State.FullRowSeparator),
-          OPERATOR: goTo(State.RightRowRef, (token) => token.value === ":"),
-      },
-      [State.Separator]: {
-          SPACE: goTo(State.Separator),
-          OPERATOR: goTo(State.RightRef, (token) => token.value === ":"),
-      },
-      [State.RightRef]: {
-          SPACE: goTo(State.RightRef),
-          NUMBER: goTo(State.Found),
-          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value) || isRowHeader(token.value)),
-      },
-      [State.RightColumnRef]: {
-          SPACE: goTo(State.RightColumnRef),
-          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value)),
-          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-      },
-      [State.RightRowRef]: {
-          SPACE: goTo(State.RightRowRef),
-          NUMBER: goTo(State.Found),
-          REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-          SYMBOL: goTo(State.Found, (token) => isRowHeader(token.value)),
-      },
-      [State.Found]: {},
-  };
-  /**
-   * Check if the list of tokens starts with a sequence of tokens representing
-   * a range.
-   * If a range is found, the sequence is removed from the list and is returned
-   * as a single token.
-   */
-  function matchReference(tokens) {
-      let head = 0;
-      let transitions = machine[State.LeftRef];
-      let matchedTokens = "";
-      while (transitions !== undefined) {
-          const token = tokens[head++];
-          if (!token) {
-              return null;
-          }
-          const transition = transitions[token.type]?.find((transition) => transition.guard(token));
-          const nextState = transition ? transition.goTo : undefined;
-          switch (nextState) {
-              case undefined:
-                  return null;
-              case State.Found:
-                  matchedTokens += token.value;
-                  tokens.splice(0, head);
-                  return {
-                      type: "REFERENCE",
-                      value: matchedTokens,
-                  };
-              default:
-                  transitions = machine[nextState];
-                  matchedTokens += token.value;
-                  break;
-          }
-      }
-      return null;
-  }
-  /**
-   * Take the result of the tokenizer and transform it to be usable in the
-   * manipulations of range
-   *
-   * @param formula
-   */
-  function rangeTokenize(formula, locale = DEFAULT_LOCALE) {
-      const tokens = tokenize(formula, locale);
-      const result = [];
-      while (tokens.length) {
-          result.push(matchReference(tokens) || tokens.shift());
-      }
-      return result;
-  }
-
   /**
    * Add the following information on tokens:
    * - length
@@ -8066,8 +8071,8 @@
 
   function evaluateLiteral(literalCell, localeFormat) {
       const value = localeFormat.format === PLAIN_TEXT_FORMAT ? literalCell.content : literalCell.parsedValue;
-      const fPayload = { value, format: localeFormat.format };
-      return createEvaluatedCell(fPayload, localeFormat.locale);
+      const functionResult = { value, format: localeFormat.format };
+      return createEvaluatedCell(functionResult, localeFormat.locale);
   }
   function parseLiteral(content, locale) {
       if (content.startsWith("=")) {
@@ -8088,13 +8093,13 @@
       }
       return content;
   }
-  function createEvaluatedCell(fPayload, locale = DEFAULT_LOCALE, cell) {
-      const link = detectLink(fPayload.value);
+  function createEvaluatedCell(functionResult, locale = DEFAULT_LOCALE, cell) {
+      const link = detectLink(functionResult.value);
       if (!link) {
-          return _createEvaluatedCell(fPayload, locale, cell);
+          return _createEvaluatedCell(functionResult, locale, cell);
       }
       const value = parseLiteral(link.label, locale);
-      const format = fPayload.format ||
+      const format = functionResult.format ||
           (typeof value === "number"
               ? detectDateFormat(link.label, locale) || detectNumberFormat(link.label)
               : undefined);
@@ -8107,8 +8112,8 @@
           link,
       };
   }
-  function _createEvaluatedCell(fPayload, locale, cell) {
-      let { value, format, message } = fPayload;
+  function _createEvaluatedCell(functionResult, locale, cell) {
+      let { value, format, message } = functionResult;
       format = cell?.format || format;
       const formattedValue = formatValue(value, { format, locale });
       if (isEvaluationError(value)) {
@@ -10295,7 +10300,6 @@ stores.inject(MyMetaStore, storeInstance);
       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";
@@ -10328,7 +10332,7 @@ stores.inject(MyMetaStore, storeInstance);
           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));
@@ -10343,7 +10347,6 @@ stores.inject(MyMetaStore, storeInstance);
       createChart(chartData) {
           const canvas = this.canvas.el;
           const ctx = canvas.getContext("2d");
-          // @ts-ignore
           this.chart = new window.Chart(ctx, chartData);
       }
       updateChartJs(chartRuntime) {
@@ -19095,7 +19098,7 @@ stores.inject(MyMetaStore, storeInstance);
           arg("include_column_titles (boolean, default=TRUE)", _t("Whether to include the column titles or not.")),
           arg("column_count (number, optional)", _t("number of columns")),
       ],
-      compute: function (pivotFormulaId, rowCount = { value: Number.MAX_VALUE }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
+      compute: function (pivotFormulaId, rowCount = { value: 10000 }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
           const _pivotFormulaId = toString(pivotFormulaId);
           const _rowCount = toNumber(rowCount, this.locale);
           if (_rowCount < 0) {
@@ -19519,6 +19522,320 @@ stores.inject(MyMetaStore, storeInstance);
     UPLUS: UPLUS
   });
 
+  const transformFromFactor = (factor) => ({
+      transform: (x) => x * factor,
+      inverseTransform: (x) => x / factor,
+  });
+  const standard = { transform: (x) => x, inverseTransform: (x) => x };
+  const ANG2M = 1e-10;
+  const IN2M = 0.0254;
+  const PICAPT2M = IN2M / 72;
+  const FT2M = 0.3048;
+  const YD2M = 0.9144;
+  const MI2M = 1609.34;
+  const NMI2M = 1852;
+  const LY2M = 9.46073047258e15;
+  const UNITS = {
+      // WEIGHT UNITs : Standard = gramme
+      g: { ...standard, category: "weight" },
+      u: { ...transformFromFactor(1.66053e-24), category: "weight" },
+      grain: { ...transformFromFactor(0.0647989), category: "weight" },
+      ozm: { ...transformFromFactor(28.3495), category: "weight" },
+      lbm: { ...transformFromFactor(453.592), category: "weight" },
+      stone: { ...transformFromFactor(6350.29), category: "weight" },
+      sg: { ...transformFromFactor(14593.90294), category: "weight" },
+      cwt: { ...transformFromFactor(45359.237), category: "weight" },
+      uk_cwt: { ...transformFromFactor(50802.3), category: "weight" },
+      ton: { ...transformFromFactor(907184.74), category: "weight" },
+      uk_ton: { ...transformFromFactor(1016046.9), category: "weight" },
+      // DISTANCE UNITS : Standard = meter
+      m: { ...standard, category: "distance" },
+      km: { ...transformFromFactor(1000), category: "distance" },
+      ang: { ...transformFromFactor(ANG2M), category: "distance" },
+      Picapt: { ...transformFromFactor(PICAPT2M), category: "distance" },
+      pica: { ...transformFromFactor(IN2M / 6), category: "distance" },
+      in: { ...transformFromFactor(IN2M), category: "distance" },
+      ft: { ...transformFromFactor(FT2M), category: "distance" },
+      yd: { ...transformFromFactor(YD2M), category: "distance" },
+      ell: { ...transformFromFactor(1.143), category: "distance" },
+      mi: { ...transformFromFactor(MI2M), category: "distance" },
+      survey_mi: { ...transformFromFactor(1609.34), category: "distance" },
+      Nmi: { ...transformFromFactor(NMI2M), category: "distance" },
+      ly: { ...transformFromFactor(LY2M), category: "distance" },
+      parsec: { ...transformFromFactor(3.0856775814914e16), category: "distance" },
+      // TIME UNITS : Standard = second
+      sec: { ...standard, category: "time" },
+      min: { ...transformFromFactor(60), category: "time" },
+      hr: { ...transformFromFactor(3600), category: "time" },
+      day: { ...transformFromFactor(86400), category: "time" },
+      yr: { ...transformFromFactor(31556952), category: "time" },
+      // PRESSURE UNITS : Standard = Pascal
+      Pa: { ...standard, category: "pressure" },
+      bar: { ...transformFromFactor(100000), category: "pressure" },
+      mmHg: { ...transformFromFactor(133.322), category: "pressure" },
+      Torr: { ...transformFromFactor(133.322), category: "pressure" },
+      psi: { ...transformFromFactor(6894.76), category: "pressure" },
+      atm: { ...transformFromFactor(101325), category: "pressure" },
+      // FORCE UNITS : Standard = Newton
+      N: { ...standard, category: "force" },
+      dyn: { ...transformFromFactor(1e-5), category: "force" },
+      pond: { ...transformFromFactor(0.00980665), category: "force" },
+      lbf: { ...transformFromFactor(4.44822), category: "force" },
+      // ENERGY UNITS : Standard = Joule
+      J: { ...standard, category: "energy" },
+      eV: { ...transformFromFactor(1.60218e-19), category: "energy" },
+      e: { ...transformFromFactor(1e-7), category: "energy" },
+      flb: { ...transformFromFactor(1.3558179483), category: "energy" },
+      c: { ...transformFromFactor(4.184), category: "energy" },
+      cal: { ...transformFromFactor(4.1868), category: "energy" },
+      BTU: { ...transformFromFactor(1055.06), category: "energy" },
+      Wh: { ...transformFromFactor(3600), category: "energy" },
+      HPh: { ...transformFromFactor(2684520), category: "energy" },
+      // POWER UNITS : Standard = Watt
+      W: { ...standard, category: "power" },
+      PS: { ...transformFromFactor(735.499), category: "power" },
+      HP: { ...transformFromFactor(745.7), category: "power" },
+      // MAGNETISM UNITS : Standard = Tesla
+      T: { ...standard, category: "magnetism" },
+      ga: { ...transformFromFactor(1e-4), category: "magnetism" },
+      // TEMPERATURE UNITS : Standard = Kelvin
+      K: { ...standard, category: "temperature" },
+      C: {
+          transform: (T) => T + 273.15,
+          inverseTransform: (T) => T - 273.15,
+          category: "temperature",
+      },
+      F: {
+          transform: (T) => ((T - 32) * 5) / 9 + 273.15,
+          inverseTransform: (T) => ((T - 273.15) * 9) / 5 + 32,
+          category: "temperature",
+      },
+      Rank: { ...transformFromFactor(5 / 9), category: "temperature" },
+      Reau: {
+          transform: (T) => T * 1.25 + 273.15,
+          inverseTransform: (T) => (T - 273.15) / 1.25,
+          category: "temperature",
+      },
+      // VOLUME UNITS : Standard = cubic meter
+      "m^3": { ...standard, category: "volume", order: 3 },
+      "ang^3": { ...transformFromFactor(Math.pow(ANG2M, 3)), category: "volume", order: 3 },
+      "Picapt^3": { ...transformFromFactor(Math.pow(PICAPT2M, 3)), category: "volume", order: 3 },
+      tsp: { ...transformFromFactor(4.92892e-6), category: "volume" },
+      tspm: { ...transformFromFactor(5e-6), category: "volume" },
+      tbs: { ...transformFromFactor(1.4786764825785619e-5), category: "volume" },
+      "in^3": { ...transformFromFactor(Math.pow(IN2M, 3)), category: "volume", order: 3 },
+      oz: { ...transformFromFactor(2.95735295625e-5), category: "volume" },
+      cup: { ...transformFromFactor(0.000237), category: "volume" },
+      pt: { ...transformFromFactor(0.0004731765), category: "volume" },
+      uk_pt: { ...transformFromFactor(0.000568261), category: "volume" },
+      qt: { ...transformFromFactor(0.0009463529), category: "volume" },
+      l: { ...transformFromFactor(1e-3), category: "volume" },
+      uk_qt: { ...transformFromFactor(0.0011365225), category: "volume" },
+      gal: { ...transformFromFactor(0.0037854118), category: "volume" },
+      uk_gal: { ...transformFromFactor(0.00454609), category: "volume" },
+      "ft^3": { ...transformFromFactor(Math.pow(FT2M, 3)), category: "volume", order: 3 },
+      bushel: { ...transformFromFactor(0.0352390704), category: "volume" },
+      barrel: { ...transformFromFactor(0.158987295), category: "volume" },
+      "yd^3": { ...transformFromFactor(Math.pow(YD2M, 3)), category: "volume", order: 3 },
+      MTON: { ...transformFromFactor(1.13267386368), category: "volume" },
+      GRT: { ...transformFromFactor(2.83168), category: "volume" },
+      "mi^3": { ...transformFromFactor(Math.pow(MI2M, 3)), category: "volume", order: 3 },
+      "Nmi^3": { ...transformFromFactor(Math.pow(NMI2M, 3)), category: "volume", order: 3 },
+      "ly^3": { ...transformFromFactor(Math.pow(LY2M, 3)), category: "volume", order: 3 },
+      // AREA UNITS : Standard = square meter
+      "m^2": { ...standard, category: "area", order: 2 },
+      "ang^2": { ...transformFromFactor(Math.pow(ANG2M, 2)), category: "area", order: 2 },
+      "Picapt^2": { ...transformFromFactor(Math.pow(PICAPT2M, 2)), category: "area", order: 2 },
+      "in^2": { ...transformFromFactor(Math.pow(IN2M, 2)), category: "area", order: 2 },
+      "ft^2": { ...transformFromFactor(Math.pow(FT2M, 2)), category: "area", order: 2 },
+      "yd^2": { ...transformFromFactor(Math.pow(YD2M, 2)), category: "area", order: 2 },
+      ar: { ...transformFromFactor(100), category: "area" },
+      Morgen: { ...transformFromFactor(2500), category: "area" },
+      uk_acre: { ...transformFromFactor(4046.8564224), category: "area" },
+      us_acre: { ...transformFromFactor(4046.8726098743), category: "area" },
+      ha: { ...transformFromFactor(1e4), category: "area" },
+      "mi^2": { ...transformFromFactor(Math.pow(MI2M, 2)), category: "area", order: 2 },
+      "Nmi^2": { ...transformFromFactor(Math.pow(NMI2M, 2)), category: "area", order: 2 },
+      "ly^2": { ...transformFromFactor(Math.pow(LY2M, 2)), category: "area", order: 2 },
+      // INFORMATION UNITS : Standard = bit
+      bit: { ...standard, category: "information" },
+      byte: { ...transformFromFactor(8), category: "information" },
+      // SPEED UNITS : Standard = m/s
+      "m/s": { ...standard, category: "speed" },
+      "m/hr": { ...transformFromFactor(1 / 3600), category: "speed" },
+      "km/hr": { ...transformFromFactor(1 / 3.6), category: "speed" },
+      mph: { ...transformFromFactor(0.44704), category: "speed" },
+      kn: { ...transformFromFactor(0.5144444444), category: "speed" },
+      admkn: { ...transformFromFactor(0.5147733333), category: "speed" },
+  };
+  const UNITS_ALIASES = {
+      shweight: "cwt",
+      lcwt: "uk_cwt",
+      hweight: "uk_cwt",
+      LTON: "uk_ton",
+      brton: "uk_ton",
+      pc: "parsec",
+      Pica: "Picapt",
+      d: "day",
+      mn: "min",
+      s: "sec",
+      p: "Pa",
+      at: "atm",
+      dy: "dyn",
+      ev: "eV",
+      hh: "HPh",
+      wh: "Wh",
+      btu: "BTU",
+      h: "HP",
+      cel: "C",
+      fah: "F",
+      kel: "K",
+      us_pt: "pt",
+      L: "l",
+      lt: "l",
+      ang3: "ang^3",
+      ft3: "ft^3",
+      in3: "in^3",
+      ly3: "ly^3",
+      m3: "m^3",
+      mi3: "mi^3",
+      yd3: "yd^3",
+      Nmi3: "Nmi^3",
+      Picapt3: "Picapt^3",
+      "Pica^3": "Picapt^3",
+      Pica3: "Picapt^3",
+      regton: "GRT",
+      ang2: "ang^2",
+      ft2: "ft^2",
+      in2: "in^2",
+      ly2: "ly^2",
+      m2: "m^2",
+      mi2: "mi^2",
+      Nmi2: "Nmi^2",
+      Picapt2: "Picapt^2",
+      "Pica^2": "Picapt^2",
+      Pica2: "Picapt^2",
+      yd2: "yd^2",
+      "m/h": "m/hr",
+      "m/sec": "m/s",
+  };
+  const UNIT_PREFIXES = {
+      "": 1,
+      Y: 1e24,
+      Z: 1e21,
+      E: 1e18,
+      P: 1e15,
+      T: 1e12,
+      G: 1e9,
+      M: 1e6,
+      k: 1e3,
+      h: 1e2,
+      da: 1e1,
+      e: 1e1,
+      d: 1e-1,
+      c: 1e-2,
+      m: 1e-3,
+      u: 1e-6,
+      n: 1e-9,
+      p: 1e-12,
+      f: 1e-15,
+      a: 1e-18,
+      z: 1e-21,
+      y: 1e-21,
+      Yi: Math.pow(2, 80),
+      Zi: Math.pow(2, 70),
+      Ei: Math.pow(2, 60),
+      Pi: Math.pow(2, 50),
+      Ti: Math.pow(2, 40),
+      Gi: Math.pow(2, 30),
+      Mi: Math.pow(2, 20),
+      ki: Math.pow(2, 10),
+  };
+  const TRANSLATED_CATEGORIES = {
+      weight: _t("Weight"),
+      distance: _t("Distance"),
+      time: _t("Time"),
+      pressure: _t("Pressure"),
+      force: _t("Force"),
+      energy: _t("Energy"),
+      power: _t("Power"),
+      magnetism: _t("Magnetism"),
+      temperature: _t("Temperature"),
+      volume: _t("Volume"),
+      area: _t("Area"),
+      information: _t("Information"),
+      speed: _t("Speed"),
+  };
+  function getTranslatedCategory(key) {
+      return TRANSLATED_CATEGORIES[key] ?? "";
+  }
+  function getTransformation(key) {
+      for (const [prefix, value] of Object.entries(UNIT_PREFIXES)) {
+          if (prefix && !key.startsWith(prefix))
+              continue;
+          const _key = key.slice(prefix.length);
+          let conversion = UNITS[_key];
+          if (!conversion && UNITS_ALIASES[_key]) {
+              conversion = UNITS[UNITS_ALIASES[_key]];
+          }
+          if (conversion) {
+              return {
+                  ...conversion,
+                  factor: conversion.order ? Math.pow(value, conversion.order) : value,
+              };
+          }
+      }
+      return;
+  }
+
+  // -----------------------------------------------------------------------------
+  // CONVERT
+  // -----------------------------------------------------------------------------
+  const CONVERT = {
+      description: _t("Converts a numeric value to a different unit of measure."),
+      args: [
+          arg("value (number)", _t("the numeric value in start_unit to convert to end_unit")),
+          arg("start_unit (string)", _t("The starting unit, the unit currently assigned to value")),
+          arg("end_unit (string)", _t("The unit of measure into which to convert value")),
+      ],
+      compute: function (value, startUnit, endUnit) {
+          const _value = toNumber(value, this.locale);
+          const _startUnit = toString(startUnit);
+          const _endUnit = toString(endUnit);
+          const startConversion = getTransformation(_startUnit);
+          const endConversion = getTransformation(_endUnit);
+          if (!startConversion) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Invalid units of measure ('%s')", _startUnit),
+              };
+          }
+          if (!endConversion) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Invalid units of measure ('%s')", _endUnit),
+              };
+          }
+          if (startConversion.category !== endConversion.category) {
+              return {
+                  value: CellErrorType.GenericError,
+                  message: _t("Incompatible units of measure ('%s' vs '%s')", getTranslatedCategory(startConversion.category), getTranslatedCategory(endConversion.category)),
+              };
+          }
+          return {
+              value: endConversion.inverseTransform(startConversion.factor * startConversion.transform(_value)) /
+                  endConversion.factor,
+              format: value?.format,
+          };
+      },
+      isExported: true,
+  };
+
+  var parser = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CONVERT: CONVERT
+  });
+
   const DEFAULT_STARTING_AT = 1;
   /** Regex matching all the words in a string */
   const wordRegex = /[A-Za-zÀ-ÖØ-öø-ÿ]+/g;
@@ -19936,6 +20253,7 @@ stores.inject(MyMetaStore, storeInstance);
       { name: _t("Text"), functions: text },
       { name: _t("Engineering"), functions: engineering },
       { name: _t("Web"), functions: web },
+      { name: _t("Parser"), functions: parser },
   ];
   const functionNameRegex = /^[A-Z0-9\_\.]+$/;
   class FunctionRegistry extends Registry {
@@ -19947,41 +20265,127 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const descr = addMetaInfoFromArg(addDescr);
           validateArguments(descr.args);
-          this.mapping[name] = addErrorHandling(addResultHandling(addInputHandling(descr), name), name);
+          this.mapping[name] = createComputeFunction(descr, name);
           super.add(name, descr);
           return this;
       }
   }
-  function addInputHandling(descr) {
-      function computeWithInputHandling(...args) {
+  const functionRegistry = new FunctionRegistry();
+  for (let category of categories) {
+      const fns = category.functions;
+      for (let name in fns) {
+          const addDescr = fns[name];
+          addDescr.category = addDescr.category || category.name;
+          name = name.replace(/_/g, ".");
+          functionRegistry.add(name, { isExported: false, ...addDescr });
+      }
+  }
+  const notAvailableError = new NotAvailableError(_t("Array arguments to [[FUNCTION_NAME]] are of different size."));
+  function createComputeFunction(descr, functionName) {
+      function runtimeCompute(...args) {
+          try {
+              return vectorizedCompute.apply(this, args);
+          }
+          catch (e) {
+              return handleError(e, functionName);
+          }
+      }
+      function vectorizedCompute(...args) {
+          let countVectorizableCol = 1;
+          let countVectorizableRow = 1;
+          let vectorizableColLimit = Infinity;
+          let vectorizableRowLimit = Infinity;
+          let vectorArgsType = undefined;
+          //#region Compute vectorisation limits
           for (let i = 0; i < args.length; i++) {
               const argDefinition = descr.args[descr.getArgToFocus(i + 1) - 1];
               const arg = args[i];
               if (isMatrix(arg) && !argDefinition.acceptMatrix) {
-                  if (arg.length !== 1 || arg[0].length !== 1) {
-                      throw new EvaluationError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be a single value or a single cell reference, not a range.", argDefinition.name));
+                  // if argDefinition does not accept a matrix but arg is still a matrix
+                  // --> triggers the arguments vectorization
+                  const nColumns = arg.length;
+                  const nRows = arg[0].length;
+                  if (nColumns !== 1 || nRows !== 1) {
+                      vectorArgsType ??= new Array(args.length);
+                      if (nColumns !== 1 && nRows !== 1) {
+                          vectorArgsType[i] = "matrix";
+                          countVectorizableCol = Math.max(countVectorizableCol, nColumns);
+                          countVectorizableRow = Math.max(countVectorizableRow, nRows);
+                          vectorizableColLimit = Math.min(vectorizableColLimit, nColumns);
+                          vectorizableRowLimit = Math.min(vectorizableRowLimit, nRows);
+                      }
+                      else if (nColumns !== 1) {
+                          vectorArgsType[i] = "horizontal";
+                          countVectorizableCol = Math.max(countVectorizableCol, nColumns);
+                          vectorizableColLimit = Math.min(vectorizableColLimit, nColumns);
+                      }
+                      else if (nRows !== 1) {
+                          vectorArgsType[i] = "vertical";
+                          countVectorizableRow = Math.max(countVectorizableRow, nRows);
+                          vectorizableRowLimit = Math.min(vectorizableRowLimit, nRows);
+                      }
+                  }
+                  else {
+                      args[i] = arg[0][0];
                   }
-                  args[i] = arg[0][0];
               }
               if (!isMatrix(arg) && argDefinition.acceptMatrixOnly) {
                   throw new BadExpressionError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be reference to a cell or range.", (i + 1).toString()));
               }
           }
-          return descr.compute.apply(this, args);
+          //#endregion
+          if (countVectorizableCol === 1 && countVectorizableRow === 1) {
+              // either this function is not vectorized or it ends up with a 1x1 dimension
+              return computeFunctionToObject.apply(this, args);
+          }
+          const getArgOffset = (i, j) => args.map((arg, index) => {
+              switch (vectorArgsType?.[index]) {
+                  case "matrix":
+                      return arg[i][j];
+                  case "horizontal":
+                      return arg[i][0];
+                  case "vertical":
+                      return arg[0][j];
+                  case undefined:
+                      return arg;
+              }
+          });
+          return generateMatrix(countVectorizableCol, countVectorizableRow, (col, row) => {
+              if (col > vectorizableColLimit - 1 || row > vectorizableRowLimit - 1) {
+                  return notAvailableError;
+              }
+              const singleCellComputeResult = computeFunctionToObject.apply(this, getArgOffset(col, row));
+              // In the case where the user tries to vectorize arguments of an array formula, we will get an
+              // array for every combination of the vectorized arguments, which will lead to a 3D matrix and
+              // we won't be able to return the values.
+              // In this case, we keep the first element of each spreading part, just as Excel does, and
+              // create an array with these parts.
+              // For exemple, we have MUNIT(x) that return an unitary matrix of x*x. If we use it with a
+              // range, like MUNIT(A1:A2), we will get two unitary matrices (one for the value in A1 and one
+              // for the value in A2). In this case, we will simply take the first value of each matrix and
+              // return the array [First value of MUNIT(A1), First value of MUNIT(A2)].
+              return isMatrix(singleCellComputeResult)
+                  ? singleCellComputeResult[0][0]
+                  : singleCellComputeResult;
+          });
       }
-      return computeWithInputHandling;
-  }
-  function addErrorHandling(compute, functionName) {
-      return function (...args) {
-          try {
-              return compute.apply(this, args);
+      function computeFunctionToObject(...args) {
+          const result = descr.compute.apply(this, args);
+          if (!isMatrix(result)) {
+              if (typeof result === "object" && result !== null && "value" in result) {
+                  replaceFunctionNamePlaceholder(result, functionName);
+                  return result;
+              }
+              return { value: result };
           }
-          catch (e) {
-              return handleError(e, functionName);
+          if (typeof result[0][0] === "object" && result[0][0] !== null && "value" in result[0][0]) {
+              matrixForEach(result, (result) => replaceFunctionNamePlaceholder(result, functionName));
+              return result;
           }
-      };
+          return matrixMap(result, (row) => ({ value: row }));
+      }
+      return runtimeCompute;
   }
-  const implementationErrorMessage = _t("An unexpected error occurred. Submit a support ticket at odoo.com/help.");
   function handleError(e, functionName) {
       // the error could be an user error (instance of EvaluationError)
       // or a javascript error (instance of Error)
@@ -20000,42 +20404,16 @@ stores.inject(MyMetaStore, storeInstance);
       return (obj?.value !== undefined &&
           typeof obj.value === "string");
   }
-  function hasStringMessage(obj) {
-      return (obj?.message !== undefined &&
-          typeof obj.message === "string");
-  }
-  function addResultHandling(compute, functionName) {
-      return function computeWithResultHandling(...args) {
-          const result = compute.apply(this, args);
-          if (!isMatrix(result)) {
-              if (typeof result === "object" && result !== null && "value" in result) {
-                  replaceFunctionNamePlaceholder(result, functionName);
-                  return result;
-              }
-              return { value: result };
-          }
-          if (typeof result[0][0] === "object" && result[0][0] !== null && "value" in result[0][0]) {
-              matrixForEach(result, (result) => replaceFunctionNamePlaceholder(result, functionName));
-              return result;
-          }
-          return matrixMap(result, (row) => ({ value: row }));
-      };
-  }
-  function replaceFunctionNamePlaceholder(fPayload, functionName) {
+  function replaceFunctionNamePlaceholder(functionResult, functionName) {
       // for performance reasons: change in place and only if needed
-      if (fPayload.message?.includes("[[FUNCTION_NAME]]")) {
-          fPayload.message = fPayload.message.replace("[[FUNCTION_NAME]]", functionName);
+      if (functionResult.message?.includes("[[FUNCTION_NAME]]")) {
+          functionResult.message = functionResult.message.replace("[[FUNCTION_NAME]]", functionName);
       }
   }
-  const functionRegistry = new FunctionRegistry();
-  for (let category of categories) {
-      const fns = category.functions;
-      for (let name in fns) {
-          const addDescr = fns[name];
-          addDescr.category = addDescr.category || category.name;
-          name = name.replace(/_/g, ".");
-          functionRegistry.add(name, { isExported: false, ...addDescr });
-      }
+  const implementationErrorMessage = _t("An unexpected error occurred. Submit a support ticket at odoo.com/help.");
+  function hasStringMessage(obj) {
+      return (obj?.message !== undefined &&
+          typeof obj.message === "string");
   }
 
   autoCompleteProviders.add("functions", {
@@ -21484,6 +21862,7 @@ stores.inject(MyMetaStore, storeInstance);
 
   const functions$1 = functionRegistry.content;
   const OPERATOR_MAP = {
+      // export for test
       "=": "EQ",
       "+": "ADD",
       "-": "MINUS",
@@ -21498,6 +21877,7 @@ stores.inject(MyMetaStore, storeInstance);
       "&": "CONCATENATE",
   };
   const UNARY_OPERATOR_MAP = {
+      // export for test
       "-": "UMINUS",
       "+": "UPLUS",
       "%": "UNARY.PERCENT",
@@ -22786,8 +23166,7 @@ stores.inject(MyMetaStore, storeInstance);
   /**
    * Get a default chart js configuration
    */
-  function getDefaultChartJsRuntime(chart, labels, fontColor, args) {
-      const { format, locale, truncateLabels, horizontalChart } = args;
+  function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale, truncateLabels = true, horizontalChart, }) {
       const chartTitle = chart.title.text ? chart.title : { ...chart.title, content: "" };
       const options = {
           // https://www.chartjs.org/docs/latest/general/responsive.html
@@ -22963,7 +23342,6 @@ stores.inject(MyMetaStore, storeInstance);
       if ("chartJsConfig" in runtime) {
           const config = deepCopy(runtime.chartJsConfig);
           config.plugins = [backgroundColorChartJSPlugin];
-          // @ts-ignore
           const chart = new window.Chart(canvas, config);
           const imgContent = chart.toBase64Image();
           chart.destroy();
@@ -23884,13 +24262,11 @@ stores.inject(MyMetaStore, storeInstance);
   }
   let missingTimeAdapterAlreadyWarned = false;
   function isLuxonTimeAdapterInstalled() {
-      // @ts-ignore
       if (!window.Chart) {
           return false;
       }
       // @ts-ignore
       const adapter = new window.Chart._adapters._date({});
-      // @ts-ignore
       const isInstalled = adapter._id === "luxon";
       if (!isInstalled && !missingTimeAdapterAlreadyWarned) {
           missingTimeAdapterAlreadyWarned = true;
@@ -23907,9 +24283,7 @@ stores.inject(MyMetaStore, storeInstance);
               generateLabels(chart) {
                   // color the legend labels with the dataset color, without any transparency
                   const { data } = chart;
-                  /** @ts-ignore */
-                  const labels = window.Chart.defaults.plugins.legend.labels
-                      .generateLabels(chart);
+                  const labels = window.Chart.defaults.plugins.legend.labels.generateLabels(chart);
                   for (const [index, label] of labels.entries()) {
                       label.fillStyle = data.datasets[index].borderColor;
                   }
@@ -24026,10 +24400,6 @@ stores.inject(MyMetaStore, storeInstance);
       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) {
@@ -24045,6 +24415,10 @@ stores.inject(MyMetaStore, storeInstance);
                   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,
@@ -33151,21 +33525,25 @@ stores.inject(MyMetaStore, storeInstance);
 
   function useHighlightsOnHover(ref, highlightProvider) {
       const hoverState = useHoveredElement(ref);
-      const stores = useStoreProvider();
       useHighlights({
           get highlights() {
               return hoverState.hovered ? highlightProvider.highlights : [];
           },
       });
-      owl.useEffect(() => {
-          stores.trigger("store-updated");
-      }, () => [hoverState.hovered]);
   }
   function useHighlights(highlightProvider) {
+      const stores = useStoreProvider();
       const store = useLocalStore(HighlightStore);
       owl.onMounted(() => {
           store.register(highlightProvider);
       });
+      let currentHighlights = highlightProvider.highlights;
+      owl.useEffect((highlights) => {
+          if (!deepEquals(highlights, currentHighlights)) {
+              currentHighlights = highlights;
+              stores.trigger("store-updated");
+          }
+      }, () => [highlightProvider.highlights]);
   }
 
   css /* scss */ `
@@ -34637,6 +35015,8 @@ stores.inject(MyMetaStore, storeInstance);
       isSearchDirty = false;
       initialShowFormulaState;
       preserveSelectedMatchIndex = false;
+      irreplaceableMatchCount = 0;
+      notificationStore = this.get(NotificationStore);
       // fixme: why do we make selectedMatchIndex on top of a selected
       // property in the matches?
       selectedMatchIndex = null;
@@ -34713,6 +35093,11 @@ stores.inject(MyMetaStore, storeInstance);
                   for (const match of cmd.matches) {
                       this.replaceMatch(match, cmd.searchString, cmd.replaceWith, cmd.searchOptions);
                   }
+                  if (this.irreplaceableMatchCount > 0) {
+                      this.showReplaceWarningMessage(cmd.matches.length, this.irreplaceableMatchCount);
+                  }
+                  this.irreplaceableMatchCount = 0;
+                  break;
           }
       }
       finalize() {
@@ -34894,12 +35279,36 @@ stores.inject(MyMetaStore, storeInstance);
               searchOptions: this.searchOptions,
           });
       }
+      /**
+       * Show a warning message based on the number of matches replaced and irreplaceable.
+       */
+      showReplaceWarningMessage(totalMatches, irreplaceableMatches) {
+          const replaceableMatches = totalMatches - irreplaceableMatches;
+          if (replaceableMatches === 0) {
+              this.notificationStore.notifyUser({
+                  type: "warning",
+                  sticky: false,
+                  text: _t("Match(es) cannot be replaced as they are part of a formula."),
+              });
+          }
+          else {
+              this.notificationStore.notifyUser({
+                  type: "warning",
+                  sticky: false,
+                  text: _t("%(replaceable_count)s match(es) replaced. %(irreplaceable_count)s match(es) cannot be replaced as they are part of a formula.", {
+                      replaceable_count: replaceableMatches,
+                      irreplaceable_count: irreplaceableMatches,
+                  }),
+              });
+          }
+      }
       replaceMatch(selectedMatch, searchString, replaceWith, searchOptions) {
           const cell = this.getters.getCell(selectedMatch);
           if (!cell?.content) {
               return;
           }
           if (cell?.isFormula && !searchOptions.searchFormulas) {
+              this.irreplaceableMatchCount++;
               return;
           }
           const searchRegex = getSearchRegex(searchString, searchOptions);
@@ -36965,7 +37374,13 @@ stores.inject(MyMetaStore, storeInstance);
       }
       async loadLocales() {
           this.loadedLocales = (await this.env.loadLocales())
-              .filter(isValidLocale)
+              .filter((locale) => {
+              const isValid = isValidLocale(locale);
+              if (!isValid) {
+                  console.warn(`Invalid locale: ${locale["code"]} ${locale}`);
+              }
+              return isValid;
+          })
               .sort((a, b) => a.name.localeCompare(b.name));
       }
       get numberFormatPreview() {
@@ -38024,6 +38439,9 @@ stores.inject(MyMetaStore, storeInstance);
           const component = { ...value, id: this.uuidGenerator.uuidv4() };
           return super.add(name, component);
       }
+      getAllOrdered() {
+          return this.getAll().sort((a, b) => a.sequence - b.sequence);
+      }
   }
   const topbarComponentRegistry = new TopBarComponentRegistry();
 
@@ -42134,6 +42552,7 @@ stores.inject(MyMetaStore, storeInstance);
               return;
           }
           if (clipboardData.types.indexOf(ClipboardMIMEType.PlainText) > -1) {
+              ev.preventDefault();
               const content = clipboardData.getData(ClipboardMIMEType.PlainText);
               const target = this.env.model.getters.getSelectedZones();
               const clipboardString = this.env.model.getters.getClipboardTextContent();
@@ -45718,7 +46137,7 @@ stores.inject(MyMetaStore, storeInstance);
       return relsFile;
   }
 
-  const EXCEL_IMPORT_VERSION = 16;
+  const EXCEL_IMPORT_VERSION = 17;
   class XlsxReader {
       warningManager;
       xmls;
@@ -45850,7 +46269,7 @@ stores.inject(MyMetaStore, storeInstance);
    * a breaking change is made in the way the state is handled, and an upgrade
    * function should be defined
    */
-  const CURRENT_VERSION = 16;
+  const CURRENT_VERSION = 17;
   const INITIAL_SHEET_ID = "Sheet1";
   /**
    * This function tries to load anything that could look like a valid
@@ -46797,6 +47216,21 @@ stores.inject(MyMetaStore, storeInstance);
               return [];
           return Object.keys(sheetBorders).map((index) => parseInt(index, 10));
       }
+      /**
+       * Get all the rows which contains at least a border
+       */
+      getRowsWithBorders(sheetId) {
+          const sheetBorders = this.borders[sheetId]?.filter(isDefined);
+          if (!sheetBorders)
+              return [];
+          const rowsWithBorders = new Set();
+          for (const rowBorders of sheetBorders) {
+              for (const rowBorder in rowBorders) {
+                  rowsWithBorders.add(parseInt(rowBorder, 10));
+              }
+          }
+          return Array.from(rowsWithBorders);
+      }
       /**
        * Get the range of all the rows in the sheet
        */
@@ -46846,7 +47280,7 @@ stores.inject(MyMetaStore, storeInstance);
                   destructive: false,
               });
           }
-          this.getRowsRange(sheetId)
+          this.getRowsWithBorders(sheetId)
               .filter((row) => row >= start)
               .sort((a, b) => (delta < 0 ? a - b : b - a)) // start by the end when moving up
               .forEach((row) => {
@@ -49172,10 +49606,12 @@ stores.inject(MyMetaStore, storeInstance);
           if (!sheetMap)
               return [];
           const mergeIds = new Set();
-          for (const { col, row } of positions(zone)) {
-              const mergeId = sheetMap[col]?.[row];
-              if (mergeId) {
-                  mergeIds.add(mergeId);
+          for (let col = zone.left; col <= zone.right; col++) {
+              for (let row = zone.top; row <= zone.bottom; row++) {
+                  const mergeId = sheetMap[col]?.[row];
+                  if (mergeId) {
+                      mergeIds.add(mergeId);
+                  }
               }
           }
           return Array.from(mergeIds)
@@ -53043,7 +53479,13 @@ stores.inject(MyMetaStore, storeInstance);
           const queue = Array.from(ranges).reverse();
           while (queue.length > 0) {
               const range = queue.pop();
-              visited.addMany(positions(range.zone).map((position) => ({ sheetId: range.sheetId, ...position })));
+              const zone = range.zone;
+              const sheetId = range.sheetId;
+              for (let col = zone.left; col <= zone.right; col++) {
+                  for (let row = zone.top; row <= zone.bottom; row++) {
+                      visited.add({ sheetId, col, row });
+                  }
+              }
               const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
               const nextInQueue = {};
               for (const position of impactedPositions) {
@@ -53059,7 +53501,16 @@ stores.inject(MyMetaStore, storeInstance);
                   queue.push(...zones.map((zone) => ({ sheetId, zone })));
               }
           }
-          visited.deleteMany(ranges.flatMap((r) => positions(r.zone).map((position) => ({ sheetId: r.sheetId, ...position }))));
+          // remove initial ranges
+          for (const range of ranges) {
+              const zone = range.zone;
+              const sheetId = range.sheetId;
+              for (let col = zone.left; col <= zone.right; col++) {
+                  for (let row = zone.top; row <= zone.bottom; row++) {
+                      visited.delete({ sheetId, col, row });
+                  }
+              }
+          }
           return visited;
       }
   }
@@ -53190,7 +53641,7 @@ stores.inject(MyMetaStore, storeInstance);
           return this.sheets[position.sheetId].getValue(position) === 1;
       }
       clear() {
-          const insertions = this.insertions;
+          const insertions = [...this];
           this.insertions = [];
           for (const sheetId in this.sheets) {
               this.sheets[sheetId].clear();
@@ -53534,6 +53985,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           finally {
               this.cellsBeingComputed.delete(cellId);
+              this.nextPositionsToUpdate.delete(position);
           }
       }
       computeAndSave(position) {
@@ -53560,8 +54012,33 @@ stores.inject(MyMetaStore, storeInstance);
           forEachSpreadPositionInMatrix(nbColumns, nbRows, 
           // thanks to the isMatrix check above, we know that formulaReturn is MatrixFunctionReturn
           this.spreadValues(formulaPosition, formulaReturn));
+          this.invalidatePositionsDependingOnSpread(formulaPosition, nbColumns, nbRows);
           return createEvaluatedCell(nullValueToZeroValue(formulaReturn[0][0]), this.getters.getLocale(), cellData);
       }
+      invalidatePositionsDependingOnSpread(arrayFormulaPosition, nbColumns, nbRows) {
+          // the result matrix is split in 2 zones to exclude the array formula position
+          const top = arrayFormulaPosition.row;
+          const left = arrayFormulaPosition.col;
+          const bottom = top + nbRows - 1;
+          const leftColumnZone = {
+              top: top + 1,
+              bottom,
+              left,
+              right: left,
+          };
+          const rightPartZone = {
+              top,
+              bottom,
+              left: left + 1,
+              right: left + nbColumns - 1,
+          };
+          const sheetId = arrayFormulaPosition.sheetId;
+          const invalidatedPositions = this.formulaDependencies().getCellsDependingOn([
+              { sheetId, zone: rightPartZone },
+              { sheetId, zone: leftColumnZone },
+          ]);
+          this.nextPositionsToUpdate.addMany(invalidatedPositions);
+      }
       assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
           const numberOfCols = this.getters.getNumberCols(sheetId);
           const numberOfRows = this.getters.getNumberRows(sheetId);
@@ -53592,14 +54069,15 @@ stores.inject(MyMetaStore, storeInstance);
       }
       updateSpreadRelation({ sheetId, col, row, }) {
           const arrayFormulaPosition = { sheetId, col, row };
-          return (i, j) => {
+          const updateSpreadRelation = (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
               this.spreadingRelations.addRelation({ resultPosition: position, arrayFormulaPosition });
           };
+          return updateSpreadRelation;
       }
       checkCollision(formulaPosition) {
           const { sheetId, col, row } = formulaPosition;
-          return (i, j) => {
+          const checkCollision = (i, j) => {
               const position = { sheetId: sheetId, col: i + col, row: j + row };
               const rawCell = this.getters.getCell(position);
               if (rawCell?.content ||
@@ -53609,17 +54087,16 @@ stores.inject(MyMetaStore, storeInstance);
               }
               this.blockedArrayFormulas.delete(formulaPosition);
           };
+          return checkCollision;
       }
       spreadValues({ sheetId, col, row }, matrixResult) {
-          return (i, j) => {
+          const spreadValues = (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
               const cell = this.getters.getCell(position);
               const evaluatedCell = createEvaluatedCell(nullValueToZeroValue(matrixResult[i][j]), this.getters.getLocale(), cell);
               this.evaluatedCells.set(position, evaluatedCell);
-              // check if formula dependencies present in the spread zone
-              // if so, they need to be recomputed
-              this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([position]));
           };
+          return spreadValues;
       }
       invalidateSpreading(position) {
           if (!this.spreadingRelations.isArrayFormula(position)) {
@@ -53674,12 +54151,12 @@ stores.inject(MyMetaStore, storeInstance);
    * rather than appearing empty. This indicates that the
    * cell is the result of a non-empty content.
    */
-  function nullValueToZeroValue(fPayload) {
-      if (fPayload.value === null || fPayload.value === undefined) {
-          // 'fPayload.value === undefined' is supposed to never happen, it's a safety net for javascript use
-          return { ...fPayload, value: 0 };
+  function nullValueToZeroValue(functionResult) {
+      if (functionResult.value === null || functionResult.value === undefined) {
+          // 'functionResult.value === undefined' is supposed to never happen, it's a safety net for javascript use
+          return { ...functionResult, value: 0 };
       }
-      return fPayload;
+      return functionResult;
   }
   function updateEvalContextAndExecute(compiledFormula, compilationParams, sheetId, cellId) {
       compilationParams.evalContext.__originCellXC = lazy(() => {
@@ -63139,7 +63616,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       get topbarComponents() {
           return topbarComponentRegistry
-              .getAll()
+              .getAllOrdered()
               .filter((item) => !item.isVisible || item.isVisible(this.env));
       }
       onExternalClick(ev) {
@@ -67770,9 +68247,9 @@ stores.inject(MyMetaStore, storeInstance);
   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";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);