@odoo/o-spreadsheet 18.1.20 → 18.1.22

package/dist/o-spreadsheet.esm.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.1.20
- * @date 2025-05-13T17:52:28.174Z
- * @hash 3e43a46
+ * @version 18.1.22
+ * @date 2025-05-26T12:35:56.145Z
+ * @hash ff4b0ba
  */
 
 import { useEnv, useSubEnv, onWillUnmount, useComponent, status, Component, useRef, onMounted, useEffect, useState, onPatched, onWillPatch, onWillUpdateProps, useExternalListener, onWillStart, xml, useChildSubEnv, markRaw, toRaw } from '@odoo/owl';
@@ -1606,18 +1606,53 @@ function lettersToNumber(letters) {
     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.
  *
@@ -1628,33 +1663,17 @@ function isCharADigit(char) {
  * 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 };
@@ -2066,67 +2085,6 @@ class LazyTranslatedString extends String {
     }
 }
 
-/** 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
@@ -2144,63 +2102,55 @@ function getFullReference(sheetName, xc) {
  *
  */
 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,
@@ -2229,7 +2179,16 @@ function toZoneWithoutBoundaryChanges(xc) {
  */
 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.
@@ -4181,6 +4140,113 @@ function transposeMatrix(matrix) {
     }
     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
 // -----------------------------------------------------------------------------
@@ -5965,6 +6031,67 @@ function scrollDelay(value) {
     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;
@@ -7411,14 +7538,20 @@ function multiplyMatrices(matrix1, matrix2) {
 /**
  * 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) {
@@ -15262,7 +15395,7 @@ const FILTER = {
         }
         return mode === "row" ? transposeMatrix(result) : result;
     },
-    isExported: true,
+    isExported: false,
 };
 // -----------------------------------------------------------------------------
 // SORT
@@ -18393,16 +18526,23 @@ const FALSE = {
 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;
@@ -18415,15 +18555,22 @@ const IF = {
 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;
@@ -18436,15 +18583,22 @@ const IFERROR = {
 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;
@@ -18457,23 +18611,31 @@ const IFNA = {
 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."));
@@ -20135,7 +20297,7 @@ const SPLIT = {
         }
         return transposeMatrix([result]);
     },
-    isExported: true,
+    isExported: false,
 };
 // -----------------------------------------------------------------------------
 // SUBSTITUTE
@@ -20328,86 +20490,21 @@ for (let category of categories) {
         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++) {
@@ -21252,7 +21349,7 @@ class AbstractComposerStore extends SpreadsheetStore {
                 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;
                 }
             }
@@ -41344,12 +41441,13 @@ class StandaloneComposerStore extends AbstractComposerStore {
         return providersDefinitions;
     }
     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);
@@ -41359,7 +41457,7 @@ class StandaloneComposerStore extends AbstractComposerStore {
             })
                 .join("");
         }
-        return this._currentContent;
+        return localizeContent(content, this.getters.getLocale());
     }
     stopEdition() {
         this._stopEdition();
@@ -45105,6 +45203,9 @@ class PivotMeasureEditor extends Component {
         }
         return undefined;
     }
+    get isCalculatedMeasureInvalid() {
+        return this.env.model.getters.getMeasureCompiledFormula(this.props.measure).isBadExpression;
+    }
 }
 
 css /* scss */ `
@@ -46115,7 +46216,9 @@ function compareDimensionValues(dimension, a, b) {
         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);
 }
@@ -48881,8 +48984,7 @@ class CellComposerStore extends AbstractComposerStore {
         if (!spreader) {
             return undefined;
         }
-        const cell = this.getters.getCell(spreader);
-        return cell?.content;
+        return this.getters.getCellText(spreader, { showFormula: true });
     }
     get currentEditedCell() {
         return {
@@ -51693,6 +51795,7 @@ function useGridDrawing(refName, model, canvasSize) {
 const friction = 0.95;
 const verticalScrollFactor = 1;
 const horizontalScrollFactor = 1;
+const resetTimeoutDuration = 100;
 function useTouchScroll(ref, updateScroll, canMoveUp) {
     let lastX = 0;
     let lastY = 0;
@@ -51700,6 +51803,7 @@ function useTouchScroll(ref, updateScroll, canMoveUp) {
     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 });
@@ -51712,6 +51816,10 @@ function useTouchScroll(ref, updateScroll, canMoveUp) {
     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;
@@ -51728,6 +51836,10 @@ function useTouchScroll(ref, updateScroll, canMoveUp) {
             }
             event.stopPropagation();
         }
+        resetTimeout = setTimeout(() => {
+            velocityX = 0;
+            velocityY = 0;
+        }, resetTimeoutDuration);
         updateScroll(deltaX * horizontalScrollFactor, deltaY * verticalScrollFactor);
     }
     function onTouchEnd(ev) {
@@ -60477,10 +60589,9 @@ class Evaluator {
         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));
@@ -76280,6 +76391,6 @@ const chartHelpers = { ...CHART_HELPERS, ...CHART_RUNTIME_HELPERS };
 export { AbstractCellClipboardHandler, AbstractChart, AbstractFigureClipboardHandler, CellErrorType, CommandResult, CorePlugin, DispatchResult, EvaluationError, Model, PivotRuntimeDefinition, Registry, Revision, SPREADSHEET_DIMENSIONS, Spreadsheet, SpreadsheetPivotTable, UIPlugin, __info__, addFunction, addRenderingLayer, astToFormula, chartHelpers, compile, compileTokens, components, constants, convertAstNodes, coreTypes, findCellInNewZone, functionCache, helpers, hooks, invalidateCFEvaluationCommands, invalidateDependenciesCommands, invalidateEvaluationCommands, iterateAstNodes, links, load, parse, parseTokens, readonlyAllowedCommands, registries, setDefaultSheetViewSize, setTranslationMethod, stores, tokenColors, tokenize };
 
 
-__info__.version = "18.1.20";
-__info__.date = "2025-05-13T17:52:28.174Z";
-__info__.hash = "3e43a46";
+__info__.version = "18.1.22";
+__info__.date = "2025-05-26T12:35:56.145Z";
+__info__.hash = "ff4b0ba";