@odoo/o-spreadsheet 18.2.12 → 18.2.14

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.2.12
- * @date 2025-05-13T17:52:23.989Z
- * @hash ba2ba9b
+ * @version 18.2.14
+ * @date 2025-05-26T12:35:51.528Z
+ * @hash db90fca
  */
 
 (function (exports, owl) {
@@ -1618,18 +1618,53 @@
       let result = 0;
       const l = letters.length;
       for (let i = 0; i < l; i++) {
-          const charCode = letters.charCodeAt(i);
-          const colIndex = charCode >= 65 && charCode <= 90 ? charCode - 64 : charCode - 96;
+          const colIndex = charToNumber(letters[i]);
           result = result * 26 + colIndex;
       }
       return result - 1;
   }
+  function charToNumber(char) {
+      const charCode = char.charCodeAt(0);
+      return charCode >= 65 && charCode <= 90 ? charCode - 64 : charCode - 96;
+  }
   function isCharALetter(char) {
       return (char >= "A" && char <= "Z") || (char >= "a" && char <= "z");
   }
   function isCharADigit(char) {
       return char >= "0" && char <= "9";
   }
+  // we limit the max column to 3 letters and max row to 7 digits for performance reasons
+  const MAX_COL = lettersToNumber("ZZZ");
+  const MAX_ROW = 9999998;
+  function consumeSpaces(chars) {
+      while (chars.current === " ") {
+          chars.advanceBy(1);
+      }
+  }
+  function consumeLetters(chars) {
+      if (chars.current === "$")
+          chars.advanceBy(1);
+      if (!chars.current || !isCharALetter(chars.current)) {
+          return -1;
+      }
+      let colCoordinate = 0;
+      while (chars.current && isCharALetter(chars.current)) {
+          colCoordinate = colCoordinate * 26 + charToNumber(chars.shift());
+      }
+      return colCoordinate;
+  }
+  function consumeDigits(chars) {
+      if (chars.current === "$")
+          chars.advanceBy(1);
+      if (!chars.current || !isCharADigit(chars.current)) {
+          return -1;
+      }
+      let num = 0;
+      while (chars.current && isCharADigit(chars.current)) {
+          num = num * 10 + Number(chars.shift());
+      }
+      return num;
+  }
   /**
    * Convert a "XC" coordinate to cartesian coordinates.
    *
@@ -1640,33 +1675,17 @@
    * Note: it also accepts lowercase coordinates, but not fixed references
    */
   function toCartesian(xc) {
-      xc = xc.trim();
-      let letterPart = "";
-      let numberPart = "";
-      let i = 0;
-      // Process letter part
-      if (xc[i] === "$")
-          i++;
-      while (i < xc.length && isCharALetter(xc[i])) {
-          letterPart += xc[i++];
-      }
-      if (letterPart.length === 0 || letterPart.length > 3) {
-          // limit to max 3 letters for performance reasons
+      const chars = new TokenizingChars(xc);
+      consumeSpaces(chars);
+      const letterPart = consumeLetters(chars);
+      if (letterPart === -1 || !chars.current) {
           throw new Error(`Invalid cell description: ${xc}`);
       }
-      // Process number part
-      if (xc[i] === "$")
-          i++;
-      while (i < xc.length && isCharADigit(xc[i])) {
-          numberPart += xc[i++];
-      }
-      if (i !== xc.length || numberPart.length === 0 || numberPart.length > 7) {
-          // limit to max 7 numbers for performance reasons
-          throw new Error(`Invalid cell description: ${xc}`);
-      }
-      const col = lettersToNumber(letterPart);
-      const row = Number(numberPart) - 1;
-      if (isNaN(row)) {
+      const num = consumeDigits(chars);
+      consumeSpaces(chars);
+      const col = letterPart - 1;
+      const row = num - 1;
+      if (!chars.isOver() || col > MAX_COL || row > MAX_ROW) {
           throw new Error(`Invalid cell description: ${xc}`);
       }
       return { col, row };
@@ -2078,67 +2097,6 @@
       }
   }
 
-  /** Reference of a cell (eg. A1, $B$5) */
-  const cellReference = new RegExp(/\$?([A-Z]{1,3})\$?([0-9]{1,7})/, "i");
-  // Same as above, but matches the exact string (nothing before or after)
-  const singleCellReference = new RegExp(/^\$?([A-Z]{1,3})\$?([0-9]{1,7})$/, "i");
-  /** Reference of a column header (eg. A, AB, $A) */
-  const colHeader = new RegExp(/^\$?([A-Z]{1,3})+$/, "i");
-  /** Reference of a row header (eg. 1, $1) */
-  const rowHeader = new RegExp(/^\$?([0-9]{1,7})+$/, "i");
-  /** Reference of a column (eg. A, $CA, Sheet1!B) */
-  const colReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([A-Z]{1,3})$/, "i");
-  /** Reference of a row (eg. 1, 59, Sheet1!9) */
-  const rowReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([0-9]{1,7})$/, "i");
-  /** Reference of a normal range or a full row range (eg. A1:B1, 1:$5, $A2:5) */
-  const fullRowXc = /(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*:\s*(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*/i;
-  /** Reference of a normal range or a column row range (eg. A1:B1, A:$B, $A1:C) */
-  const fullColXc = /\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*:\s*\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*/i;
-  /** Reference of a cell or a range, it can be a bounded range, a full row or a full column */
-  const rangeReference = new RegExp(/^\s*('.+'!|[^']+!)?/.source +
-      "(" +
-      [cellReference.source, fullRowXc.source, fullColXc.source].join("|") +
-      ")" +
-      /$/.source, "i");
-  /**
-   * Return true if the given xc is the reference of a column (e.g. A or AC or Sheet1!A)
-   */
-  function isColReference(xc) {
-      return colReference.test(xc);
-  }
-  /**
-   * Return true if the given xc is the reference of a column (e.g. 1 or Sheet1!1)
-   */
-  function isRowReference(xc) {
-      return rowReference.test(xc);
-  }
-  function isColHeader(str) {
-      return colHeader.test(str);
-  }
-  function isRowHeader(str) {
-      return rowHeader.test(str);
-  }
-  /**
-   * Return true if the given xc is the reference of a single cell,
-   * without any specified sheet (e.g. A1)
-   */
-  function isSingleCellReference(xc) {
-      return singleCellReference.test(xc);
-  }
-  function splitReference(ref) {
-      if (!ref.includes("!")) {
-          return { xc: ref };
-      }
-      const parts = ref.split("!");
-      const xc = parts.pop();
-      const sheetName = getUnquotedSheetName(parts.join("!")) || undefined;
-      return { sheetName, xc };
-  }
-  /** Return a reference SheetName!xc from the given arguments */
-  function getFullReference(sheetName, xc) {
-      return sheetName !== undefined ? `${getCanonicalSymbolName(sheetName)}!${xc}` : xc;
-  }
-
   /**
    * Convert from a cartesian reference to a Zone
    * The range boundaries will be kept in the same order as the
@@ -2156,63 +2114,55 @@
    *
    */
   function toZoneWithoutBoundaryChanges(xc) {
-      if (xc.includes("!")) {
-          xc = xc.split("!").at(-1);
-      }
-      if (xc.includes("$")) {
-          xc = xc.replaceAll("$", "");
-      }
-      let firstRangePart = "";
-      let secondRangePart;
-      if (xc.includes(":")) {
-          [firstRangePart, secondRangePart] = xc.split(":");
-          firstRangePart = firstRangePart.trim();
-          secondRangePart = secondRangePart.trim();
-      }
-      else {
-          firstRangePart = xc.trim();
-      }
+      const chars = new TokenizingChars(xc);
+      consumeSpaces(chars);
+      const sheetSeparatorIndex = xc.indexOf("!");
+      if (sheetSeparatorIndex !== -1) {
+          chars.advanceBy(sheetSeparatorIndex + 1);
+      }
+      const leftLetters = consumeLetters(chars);
+      const leftNumbers = consumeDigits(chars);
       let top, bottom, left, right;
       let fullCol = false;
       let fullRow = false;
       let hasHeader = false;
-      if (isColReference(firstRangePart)) {
-          left = right = lettersToNumber(firstRangePart);
+      if (leftNumbers === -1) {
+          left = right = leftLetters - 1;
           top = bottom = 0;
           fullCol = true;
       }
-      else if (isRowReference(firstRangePart)) {
-          top = bottom = parseInt(firstRangePart, 10) - 1;
+      else if (leftLetters === -1) {
+          top = bottom = leftNumbers - 1;
           left = right = 0;
           fullRow = true;
       }
       else {
-          const c = toCartesian(firstRangePart);
-          left = right = c.col;
-          top = bottom = c.row;
+          left = right = leftLetters - 1;
+          top = bottom = leftNumbers - 1;
           hasHeader = true;
       }
-      if (secondRangePart) {
-          if (isColReference(secondRangePart)) {
-              right = lettersToNumber(secondRangePart);
+      consumeSpaces(chars);
+      if (chars.current === ":") {
+          chars.advanceBy(1);
+          consumeSpaces(chars);
+          const rightLetters = consumeLetters(chars);
+          const rightNumbers = consumeDigits(chars);
+          if (rightNumbers === -1) {
+              right = rightLetters - 1;
               fullCol = true;
           }
-          else if (isRowReference(secondRangePart)) {
-              bottom = parseInt(secondRangePart, 10) - 1;
+          else if (rightLetters === -1) {
+              bottom = rightNumbers - 1;
               fullRow = true;
           }
           else {
-              const c = toCartesian(secondRangePart);
-              right = c.col;
-              bottom = c.row;
+              right = rightLetters - 1;
+              bottom = rightNumbers - 1;
               top = fullCol ? bottom : top;
               left = fullRow ? right : left;
               hasHeader = true;
           }
       }
-      if (fullCol && fullRow) {
-          throw new Error("Wrong zone xc. The zone cannot be at the same time a full column and a full row");
-      }
       const zone = {
           top,
           left,
@@ -2241,7 +2191,16 @@
    */
   function toUnboundedZone(xc) {
       const zone = toZoneWithoutBoundaryChanges(xc);
-      return reorderZone(zone);
+      const orderedZone = reorderZone(zone);
+      const bottom = orderedZone.bottom;
+      const right = orderedZone.right;
+      if ((bottom !== undefined && bottom > MAX_ROW) || (right !== undefined && right > MAX_COL)) {
+          throw new Error(`Range string out of bounds: ${xc}`); // limit the size of the zone for performance
+      }
+      if (bottom === undefined && right === undefined) {
+          throw new Error("Wrong zone xc. The zone cannot be at the same time a full column and a full row");
+      }
+      return orderedZone;
   }
   /**
    * Convert from a cartesian reference to a Zone.
@@ -4191,6 +4150,113 @@
       }
       return generateMatrix(matrix[0].length, matrix.length, (i, j) => matrix[j][i]);
   }
+  /**
+   * Enables a formula function to accept matrix or vector inputs instead of simple value, computing results across multiple dimensions.
+   *
+   * ```
+   *                    /         |‾                 ‾| \        |‾                                                    ‾|
+   *                   |          | [A]               |  |       | compute(A, D, E), compute(A, D, F), compute(A, D, G) |
+   * applyVectorization| compute, | [B], D, [E, F, G] |  |  <=>  | compute(B, D, E), compute(B, D, F), compute(B, D, G) |
+   *                   |          | [C]               |  |       | compute(C, D, E), compute(C, D, F), compute(C, D, G) |
+   *                    \         |_                 _| /        |_                                                    _|
+   * ```
+   *
+   * By default, all arguments are vectorized. To control which arguments are vectorized,
+   * pass an `acceptToVectorize` boolean array of the same length as `args`:
+   * - `true`  enables vectorization for that argument
+   * - `false` disables vectorization for that argument
+   *
+   * For example, with `[true, true, false]` on previous example you get:
+   *
+   * ```
+   * |‾                        ‾|
+   * | compute(A, D, [E, F, G]) |
+   * | compute(B, D, [E, F, G]) |
+   * | compute(C, D, [E, F, G]) |
+   * |_                        _|
+   * ```
+   *
+   * @remarks
+   * This helper is automatically applied (by default) to **all** `compute` functions
+   * across the various spreadsheet formula modules:
+   * - If an argument is declared **scalar** (not `"range"`), it is vectorized.
+   * - If **all** arguments are declared **ranges**, no vectorization occurs.
+   *   - e.g. `SUM(A1:B2)` returns a 1×1 sum over the range.
+   *   - e.g. `COS(A1:B2)` over `A1:B2` returns a 2×2 element-wise result.
+   * - For special behaviors (e.g. the `IF` function), you may declare all arguments
+   *   as ranges and invoke this helper directly within your `compute` implementation.
+   */
+  function applyVectorization(formula, args, acceptToVectorize = undefined) {
+      let countVectorizedCol = 1;
+      let countVectorizedRow = 1;
+      let vectorizedColLimit = Infinity;
+      let vectorizedRowLimit = Infinity;
+      let vectorArgsType = undefined;
+      for (let i = 0; i < args.length; i++) {
+          const arg = args[i];
+          if (isMatrix(arg) && (acceptToVectorize === undefined || acceptToVectorize[i])) {
+              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";
+                      countVectorizedCol = Math.max(countVectorizedCol, nColumns);
+                      countVectorizedRow = Math.max(countVectorizedRow, nRows);
+                      vectorizedColLimit = Math.min(vectorizedColLimit, nColumns);
+                      vectorizedRowLimit = Math.min(vectorizedRowLimit, nRows);
+                  }
+                  else if (nColumns !== 1) {
+                      vectorArgsType[i] = "horizontal";
+                      countVectorizedCol = Math.max(countVectorizedCol, nColumns);
+                      vectorizedColLimit = Math.min(vectorizedColLimit, nColumns);
+                  }
+                  else if (nRows !== 1) {
+                      vectorArgsType[i] = "vertical";
+                      countVectorizedRow = Math.max(countVectorizedRow, nRows);
+                      vectorizedRowLimit = Math.min(vectorizedRowLimit, nRows);
+                  }
+              }
+              else {
+                  args[i] = arg[0][0];
+              }
+          }
+      }
+      if (countVectorizedCol === 1 && countVectorizedRow === 1) {
+          // either this function is not vectorized or it ends up with a 1x1 dimension
+          return formula(...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(countVectorizedCol, countVectorizedRow, (col, row) => {
+          if (col > vectorizedColLimit - 1 || row > vectorizedRowLimit - 1) {
+              return new NotAvailableError(_t("Array arguments to [[FUNCTION_NAME]] are of different size."));
+          }
+          const singleCellComputeResult = formula(...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;
+      });
+  }
   // -----------------------------------------------------------------------------
   // CONDITIONAL EXPLORE FUNCTIONS
   // -----------------------------------------------------------------------------
@@ -5975,6 +6041,67 @@
       return MIN_DELAY + (MAX_DELAY - MIN_DELAY) * Math.exp(-ACCELERATION * (value - 1));
   }
 
+  /** Reference of a cell (eg. A1, $B$5) */
+  const cellReference = new RegExp(/\$?([A-Z]{1,3})\$?([0-9]{1,7})/, "i");
+  // Same as above, but matches the exact string (nothing before or after)
+  const singleCellReference = new RegExp(/^\$?([A-Z]{1,3})\$?([0-9]{1,7})$/, "i");
+  /** Reference of a column header (eg. A, AB, $A) */
+  const colHeader = new RegExp(/^\$?([A-Z]{1,3})+$/, "i");
+  /** Reference of a row header (eg. 1, $1) */
+  const rowHeader = new RegExp(/^\$?([0-9]{1,7})+$/, "i");
+  /** Reference of a column (eg. A, $CA, Sheet1!B) */
+  const colReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([A-Z]{1,3})$/, "i");
+  /** Reference of a row (eg. 1, 59, Sheet1!9) */
+  const rowReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([0-9]{1,7})$/, "i");
+  /** Reference of a normal range or a full row range (eg. A1:B1, 1:$5, $A2:5) */
+  const fullRowXc = /(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*:\s*(\$?[A-Z]{1,3})?\$?[0-9]{1,7}\s*/i;
+  /** Reference of a normal range or a column row range (eg. A1:B1, A:$B, $A1:C) */
+  const fullColXc = /\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*:\s*\$?[A-Z]{1,3}(\$?[0-9]{1,7})?\s*/i;
+  /** Reference of a cell or a range, it can be a bounded range, a full row or a full column */
+  const rangeReference = new RegExp(/^\s*('.+'!|[^']+!)?/.source +
+      "(" +
+      [cellReference.source, fullRowXc.source, fullColXc.source].join("|") +
+      ")" +
+      /$/.source, "i");
+  /**
+   * Return true if the given xc is the reference of a column (e.g. A or AC or Sheet1!A)
+   */
+  function isColReference(xc) {
+      return colReference.test(xc);
+  }
+  /**
+   * Return true if the given xc is the reference of a column (e.g. 1 or Sheet1!1)
+   */
+  function isRowReference(xc) {
+      return rowReference.test(xc);
+  }
+  function isColHeader(str) {
+      return colHeader.test(str);
+  }
+  function isRowHeader(str) {
+      return rowHeader.test(str);
+  }
+  /**
+   * Return true if the given xc is the reference of a single cell,
+   * without any specified sheet (e.g. A1)
+   */
+  function isSingleCellReference(xc) {
+      return singleCellReference.test(xc);
+  }
+  function splitReference(ref) {
+      if (!ref.includes("!")) {
+          return { xc: ref };
+      }
+      const parts = ref.split("!");
+      const xc = parts.pop();
+      const sheetName = getUnquotedSheetName(parts.join("!")) || undefined;
+      return { sheetName, xc };
+  }
+  /** Return a reference SheetName!xc from the given arguments */
+  function getFullReference(sheetName, xc) {
+      return sheetName !== undefined ? `${getCanonicalSymbolName(sheetName)}!${xc}` : xc;
+  }
+
   class RangeImpl {
       getSheetSize;
       _zone;
@@ -7421,14 +7548,20 @@
   /**
    * Return the input if it's a scalar or the first element of the input if it's a matrix.
    */
-  function toScalar(matrix) {
-      if (!isMatrix(matrix)) {
-          return matrix;
+  function toScalar(arg) {
+      if (!isMatrix(arg)) {
+          return arg;
       }
-      if (matrix.length !== 1 || matrix[0].length !== 1) {
+      if (!isSingleElementMatrix(arg)) {
           throw new EvaluationError(_t("The value should be a scalar or a 1x1 matrix"));
       }
-      return matrix[0][0];
+      return arg[0][0];
+  }
+  function isSingleElementMatrix(matrix) {
+      return matrix.length === 1 && matrix[0].length === 1;
+  }
+  function isMultipleElementMatrix(arg) {
+      return isMatrix(arg) && !isSingleElementMatrix(arg);
   }
 
   function assertSameNumberOfElements(...args) {
@@ -15436,7 +15569,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return mode === "row" ? transposeMatrix(result) : result;
       },
-      isExported: true,
+      isExported: false,
   };
   // -----------------------------------------------------------------------------
   // SORT
@@ -18567,16 +18700,23 @@ stores.inject(MyMetaStore, storeInstance);
   const IF = {
       description: _t("Returns value depending on logical expression."),
       args: [
-          arg("logical_expression (boolean)", _t("An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE.")),
-          arg("value_if_true (any)", _t("The value the function returns if logical_expression is TRUE.")),
-          arg("value_if_false (any, default=FALSE)", _t("The value the function returns if logical_expression is FALSE.")),
+          arg("logical_expression (boolean, range<boolean>)", _t("An expression or reference to a cell containing an expression that represents some logical value, i.e. TRUE or FALSE.")),
+          arg("value_if_true (any, range)", _t("The value the function returns if logical_expression is TRUE.")),
+          arg("value_if_false (any, range, default=FALSE)", _t("The value the function returns if logical_expression is FALSE.")),
       ],
       compute: function (logicalExpression, valueIfTrue, valueIfFalse) {
-          const result = toBoolean(logicalExpression?.value) ? valueIfTrue : valueIfFalse;
+          if (isMultipleElementMatrix(logicalExpression)) {
+              return applyVectorization(IF.compute, [logicalExpression, valueIfTrue, valueIfFalse]);
+          }
+          let result = toBoolean(toScalar(logicalExpression)) ? valueIfTrue : valueIfFalse;
+          // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+          if (!isMultipleElementMatrix(result)) {
+              result = toScalar(result);
+          }
           if (result === undefined) {
               return { value: "" };
           }
-          if (result.value === null) {
+          if (!isMatrix(result) && result.value === null) {
               return { ...result, value: "" };
           }
           return result;
@@ -18589,15 +18729,22 @@ stores.inject(MyMetaStore, storeInstance);
   const IFERROR = {
       description: _t("Value if it is not an error, otherwise 2nd argument."),
       args: [
-          arg("value (any)", _t("The value to return if value itself is not an error.")),
-          arg(`value_if_error (any, default="empty")`, _t("The value the function returns if value is an error.")),
+          arg("value (any, range)", _t("The value to return if value itself is not an error.")),
+          arg(`value_if_error (any, range, default="empty")`, _t("The value the function returns if value is an error.")),
       ],
-      compute: function (value, valueIfError = { value: "" }) {
-          const result = isEvaluationError(value?.value) ? valueIfError : value;
+      compute: function (value, valueIfError) {
+          if (isMultipleElementMatrix(value)) {
+              return applyVectorization(IFERROR.compute, [value, valueIfError]);
+          }
+          let result = isEvaluationError(toScalar(value)?.value) ? valueIfError : value;
+          // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+          if (!isMultipleElementMatrix(result)) {
+              result = toScalar(result);
+          }
           if (result === undefined) {
               return { value: "" };
           }
-          if (result.value === null) {
+          if (!isMatrix(result) && result.value === null) {
               return { ...result, value: "" };
           }
           return result;
@@ -18610,15 +18757,22 @@ stores.inject(MyMetaStore, storeInstance);
   const IFNA = {
       description: _t("Value if it is not an #N/A error, otherwise 2nd argument."),
       args: [
-          arg("value (any)", _t("The value to return if value itself is not #N/A an error.")),
-          arg(`value_if_error (any, default="empty")`, _t("The value the function returns if value is an #N/A error.")),
+          arg("value (any, range)", _t("The value to return if value itself is not #N/A an error.")),
+          arg(`value_if_error (any, range, default="empty")`, _t("The value the function returns if value is an #N/A error.")),
       ],
-      compute: function (value, valueIfError = { value: "" }) {
-          const result = value?.value === CellErrorType.NotAvailable ? valueIfError : value;
+      compute: function (value, valueIfError) {
+          if (isMultipleElementMatrix(value)) {
+              return applyVectorization(IFNA.compute, [value, valueIfError]);
+          }
+          let result = toScalar(value)?.value === CellErrorType.NotAvailable ? valueIfError : value;
+          // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+          if (!isMultipleElementMatrix(result)) {
+              result = toScalar(result);
+          }
           if (result === undefined) {
               return { value: "" };
           }
-          if (result.value === null) {
+          if (!isMatrix(result) && result.value === null) {
               return { ...result, value: "" };
           }
           return result;
@@ -18631,23 +18785,31 @@ stores.inject(MyMetaStore, storeInstance);
   const IFS = {
       description: _t("Returns a value depending on multiple logical expressions."),
       args: [
-          arg("condition1 (boolean)", _t("The first condition to be evaluated. This can be a boolean, a number, an array, or a reference to any of those.")),
-          arg("value1 (any)", _t("The returned value if condition1 is TRUE.")),
-          arg("condition2 (boolean, any, repeating)", _t("Additional conditions to be evaluated if the previous ones are FALSE.")),
-          arg("value2 (any, repeating)", _t("Additional values to be returned if their corresponding conditions are TRUE.")),
+          arg("condition1 (boolean, range<boolean>)", _t("The first condition to be evaluated. This can be a boolean, a number, an array, or a reference to any of those.")),
+          arg("value1 (any, range)", _t("The returned value if condition1 is TRUE.")),
+          arg("condition2 (boolean, any, range, repeating)", _t("Additional conditions to be evaluated if the previous ones are FALSE.")),
+          arg("value2 (any, range, repeating)", _t("Additional values to be returned if their corresponding conditions are TRUE.")),
       ],
       compute: function (...values) {
           assert(() => values.length % 2 === 0, _t("Wrong number of arguments. Expected an even number of arguments."));
-          for (let n = 0; n < values.length - 1; n += 2) {
-              if (toBoolean(values[n]?.value)) {
-                  const result = values[n + 1];
-                  if (result === undefined) {
+          while (values.length > 0) {
+              if (isMultipleElementMatrix(values[0])) {
+                  return applyVectorization(IFS.compute, values);
+              }
+              const condition = toBoolean(toScalar(values.shift()));
+              let valueIfTrue = values.shift();
+              if (condition) {
+                  // useful for interpreting empty cell references as empty strings. But must be removed to make empty cell references equal to zero
+                  if (!isMultipleElementMatrix(valueIfTrue)) {
+                      valueIfTrue = toScalar(valueIfTrue);
+                  }
+                  if (valueIfTrue === undefined) {
                       return { value: "" };
                   }
-                  if (result.value === null) {
-                      return { ...result, value: "" };
+                  if (!isMatrix(valueIfTrue) && valueIfTrue.value === null) {
+                      return { ...valueIfTrue, value: "" };
                   }
-                  return result;
+                  return valueIfTrue;
               }
           }
           return new EvaluationError(_t("No match."));
@@ -20309,7 +20471,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return transposeMatrix([result]);
       },
-      isExported: true,
+      isExported: false,
   };
   // -----------------------------------------------------------------------------
   // SUBSTITUTE
@@ -20502,86 +20664,21 @@ stores.inject(MyMetaStore, storeInstance);
           functionRegistry.add(name, { isExported: false, ...addDescr });
       }
   }
-  const notAvailableError = new NotAvailableError(_t("Array arguments to [[FUNCTION_NAME]] are of different size."));
+  //------------------------------------------------------------------------------
+  // CREATE COMPUTE FUNCTION
+  //------------------------------------------------------------------------------
   function createComputeFunction(descr, functionName) {
       function vectorizedCompute(...args) {
-          let countVectorizableCol = 1;
-          let countVectorizableRow = 1;
-          let vectorizableColLimit = Infinity;
-          let vectorizableRowLimit = Infinity;
-          let vectorArgsType = undefined;
-          //#region Compute vectorisation limits
+          const acceptToVectorize = [];
           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 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];
-                  }
-              }
               if (!isMatrix(arg) && argDefinition.acceptMatrixOnly) {
                   throw new BadExpressionError(_t("Function %s expects the parameter '%s' to be reference to a cell or range.", functionName, (i + 1).toString()));
               }
+              acceptToVectorize.push(!argDefinition.acceptMatrix);
           }
-          //#endregion
-          if (countVectorizableCol === 1 && countVectorizableRow === 1) {
-              // either this function is not vectorized or it ends up with a 1x1 dimension
-              return errorHandlingCompute.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 = errorHandlingCompute.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 applyVectorization(errorHandlingCompute.bind(this), args, acceptToVectorize);
       }
       function errorHandlingCompute(...args) {
           for (let i = 0; i < args.length; i++) {
@@ -21426,7 +21523,7 @@ stores.inject(MyMetaStore, storeInstance);
                   proposals &&
                   !["ARG_SEPARATOR", "LEFT_PAREN", "OPERATOR"].includes(tokenAtCursor.type)) {
                   const filteredProposals = fuzzyLookup(searchTerm, proposals, (p) => p.fuzzySearchKey || p.text);
-                  if (!exactMatch || filteredProposals.length > 1) {
+                  if (!exactMatch || filteredProposals.length) {
                       proposals = filteredProposals;
                   }
               }
@@ -41158,12 +41255,13 @@ stores.inject(MyMetaStore, storeInstance);
           return res;
       }
       getComposerContent() {
+          let content = this._currentContent;
           if (this.editionMode === "inactive") {
               // References in the content might not be linked to the current active sheet
               // We here force the sheet name prefix for all references that are not in
               // the current active sheet
               const defaultRangeSheetId = this.args().defaultRangeSheetId;
-              return rangeTokenize(this.args().content)
+              content = rangeTokenize(this.args().content)
                   .map((token) => {
                   if (token.type === "REFERENCE") {
                       const range = this.getters.getRangeFromSheetXC(defaultRangeSheetId, token.value);
@@ -41173,7 +41271,7 @@ stores.inject(MyMetaStore, storeInstance);
               })
                   .join("");
           }
-          return this._currentContent;
+          return localizeContent(content, this.getters.getLocale());
       }
       stopEdition() {
           this._stopEdition();
@@ -45448,6 +45546,9 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return undefined;
       }
+      get isCalculatedMeasureInvalid() {
+          return this.env.model.getters.getMeasureCompiledFormula(this.props.measure).isBadExpression;
+      }
   }
 
   css /* scss */ `
@@ -46458,7 +46559,9 @@ stores.inject(MyMetaStore, storeInstance);
           return dimension.order === "asc" ? -1 : 1;
       }
       if (dimension.type === "integer" || dimension.type === "datetime") {
-          return dimension.order === "asc" ? Number(a) - Number(b) : Number(b) - Number(a);
+          return dimension.order === "asc"
+              ? toNumber(a, DEFAULT_LOCALE) - toNumber(b, DEFAULT_LOCALE)
+              : toNumber(b, DEFAULT_LOCALE) - toNumber(a, DEFAULT_LOCALE);
       }
       return dimension.order === "asc" ? a.localeCompare(b) : b.localeCompare(a);
   }
@@ -49221,8 +49324,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (!spreader) {
               return undefined;
           }
-          const cell = this.getters.getCell(spreader);
-          return cell?.content;
+          return this.getters.getCellText(spreader, { showFormula: true });
       }
       get currentEditedCell() {
           return {
@@ -52143,6 +52245,7 @@ stores.inject(MyMetaStore, storeInstance);
   const friction = 0.95;
   const verticalScrollFactor = 1;
   const horizontalScrollFactor = 1;
+  const resetTimeoutDuration = 100;
   function useTouchScroll(ref, updateScroll, canMoveUp) {
       let lastX = 0;
       let lastY = 0;
@@ -52150,6 +52253,7 @@ stores.inject(MyMetaStore, storeInstance);
       let velocityY = 0;
       let isMouseDown = false;
       let lastTime = 0;
+      let resetTimeout = null;
       useRefListener(ref, "touchstart", onTouchStart, { capture: false });
       useRefListener(ref, "touchmove", onTouchMove, { capture: false });
       useRefListener(ref, "touchend", onTouchEnd, { capture: false });
@@ -52162,6 +52266,10 @@ stores.inject(MyMetaStore, storeInstance);
       function onTouchMove(event) {
           if (!isMouseDown)
               return;
+          if (resetTimeout) {
+              clearTimeout(resetTimeout);
+              resetTimeout = null;
+          }
           const currentTime = Date.now();
           const { clientX, clientY } = event.touches[0];
           let deltaX = lastX - clientX;
@@ -52178,6 +52286,10 @@ stores.inject(MyMetaStore, storeInstance);
               }
               event.stopPropagation();
           }
+          resetTimeout = setTimeout(() => {
+              velocityX = 0;
+              velocityY = 0;
+          }, resetTimeoutDuration);
           updateScroll(deltaX * horizontalScrollFactor, deltaY * verticalScrollFactor);
       }
       function onTouchEnd(ev) {
@@ -60950,10 +61062,9 @@ stores.inject(MyMetaStore, storeInstance);
           return this.evaluatedCells.keysForSheet(sheetId);
       }
       getArrayFormulaSpreadingOn(position) {
-          const hasArrayFormulaResult = this.getEvaluatedCell(position).type !== CellValueType.empty &&
-              !this.getters.getCell(position)?.isFormula;
-          if (!hasArrayFormulaResult) {
-              return this.spreadingRelations.isArrayFormula(position) ? position : undefined;
+          const isEmpty = this.getEvaluatedCell(position).type === CellValueType.empty;
+          if (isEmpty) {
+              return undefined;
           }
           const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(position.sheetId, positionToZone(position));
           return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
@@ -76803,9 +76914,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.2.12";
-  __info__.date = "2025-05-13T17:52:23.989Z";
-  __info__.hash = "ba2ba9b";
+  __info__.version = "18.2.14";
+  __info__.date = "2025-05-26T12:35:51.528Z";
+  __info__.hash = "db90fca";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);