@odoo/o-spreadsheet 17.1.0-alpha.3 → 17.1.0-alpha.4

package/dist/o-spreadsheet.cjs.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.1.0-alpha.3
- * @date 2023-11-16T12:04:09.636Z
- * @hash 2ef5b1a
+ * @version 17.1.0-alpha.4
+ * @date 2023-11-24T13:12:24.882Z
+ * @hash 255821b
  */
 
 'use strict';
@@ -229,7 +229,6 @@ const DEFAULT_CELL_HEIGHT = 23;
 const SCROLLBAR_WIDTH = 15;
 const AUTOFILL_EDGE_LENGTH = 8;
 const ICON_EDGE_LENGTH = 18;
-const UNHIDE_ICON_EDGE_LENGTH = 14;
 const MIN_CF_ICON_MARGIN = 4;
 const MIN_CELL_TEXT_MARGIN = 4;
 const CF_ICON_EDGE_LENGTH = 15;
@@ -693,8 +692,7 @@ function removeFalsyAttributes(obj) {
  *
  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes
  */
-const whiteSpaceCharacters = [
-    " ",
+const whiteSpaceSpecialCharacters = [
     "\t",
     "\f",
     "\v",
@@ -709,8 +707,7 @@ const whiteSpaceCharacters = [
     String.fromCharCode(parseInt("3000", 16)),
     String.fromCharCode(parseInt("feff", 16)),
 ];
-const whiteSpaceRegexp = new RegExp(whiteSpaceCharacters.join("|"), "g");
-const newLineRegex = /\r\n|\r|\n/g;
+const whiteSpaceRegexp = new RegExp(whiteSpaceSpecialCharacters.join("|") + "|(\r\n|\r|\n)", "g");
 /**
  * Replace all the special spaces in a string (non-breaking, tabs, ...) by normal spaces, and all the
  * different newlines types by \n.
@@ -718,9 +715,9 @@ const newLineRegex = /\r\n|\r|\n/g;
 function replaceSpecialSpaces(text) {
     if (!text)
         return "";
-    text = text.replace(whiteSpaceRegexp, " ");
-    text = text.replace(newLineRegex, NEWLINE);
-    return text;
+    if (!whiteSpaceRegexp.test(text))
+        return text;
+    return text.replace(whiteSpaceRegexp, (match, newLine) => (newLine ? NEWLINE : " "));
 }
 /**
  * Determine if the numbers are consecutive.
@@ -2062,6 +2059,7 @@ exports.CommandResult = void 0;
     CommandResult["InvalidNumberOfCriterionValues"] = "InvalidNumberOfCriterionValues";
     CommandResult["BlockingValidationRule"] = "BlockingValidationRule";
     CommandResult["InvalidCopyPasteSelection"] = "InvalidCopyPasteSelection";
+    CommandResult["NoChanges"] = "NoChanges";
 })(exports.CommandResult || (exports.CommandResult = {}));
 
 const DEFAULT_LOCALES = [
@@ -2191,12 +2189,12 @@ function toString(value) {
     }
 }
 /** Normalize string by setting it to lowercase and replacing accent letters with plain letters */
-function normalizeString(str) {
+const normalizeString = memoize(function normalizeString(str) {
     return str
         .toLowerCase()
         .normalize("NFD")
         .replace(/[\u0300-\u036f]/g, "");
-}
+});
 const expectBooleanValueError = (value) => _t("The function [[FUNCTION_NAME]] expects a boolean value, but '%s' is a text, and cannot be coerced to a number.", value);
 function toBoolean(value) {
     switch (typeof value) {
@@ -3429,11 +3427,18 @@ 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 ? `${getCanonicalSheetName(sheetName)}!${xc}` : xc;
+}
 
 /**
  * Convert from a cartesian reference to a Zone
@@ -4542,14 +4547,14 @@ function drawDecoratedText(context, text, position, underline = false, strikethr
     switch (context.textBaseline) {
         case "top":
             underlineY += boxHeight - 2 * strokeWidth;
-            strikeY += boxHeight - textHeight;
+            strikeY += boxHeight / 2 - strokeWidth;
             break;
         case "middle":
             underlineY += boxHeight / 2 - strokeWidth;
             break;
         case "alphabetic":
             underlineY += 2 * strokeWidth;
-            strikeY -= textHeight / 2 - strokeWidth / 2;
+            strikeY -= 3 * strokeWidth;
             break;
         case "bottom":
             underlineY = y;
@@ -4612,6 +4617,7 @@ function createAction(item) {
     const children = item.children;
     const description = item.description;
     const icon = item.icon;
+    const secondaryIcon = item.secondaryIcon;
     return {
         id: item.id || uuidGenerator$2.uuidv4(),
         name: typeof name === "function" ? name : () => name,
@@ -4630,6 +4636,7 @@ function createAction(item) {
         isReadonlyAllowed: item.isReadonlyAllowed || false,
         separator: item.separator || false,
         icon: typeof icon === "function" ? icon : () => icon || "",
+        secondaryIcon: typeof secondaryIcon === "function" ? secondaryIcon : () => secondaryIcon || "",
         description: typeof description === "function" ? description : () => description || "",
         textColor: item.textColor,
         sequence: item.sequence || 0,
@@ -6985,11 +6992,9 @@ css /* scss */ `
     padding: ${MENU_VERTICAL_PADDING}px 0px;
     width: ${MENU_WIDTH}px;
     box-sizing: border-box !important;
+    user-select: none;
 
     .o-menu-item {
-      display: flex;
-      justify-content: space-between;
-      align-items: center;
       box-sizing: border-box;
       height: ${MENU_ITEM_HEIGHT}px;
       padding: ${MENU_ITEM_PADDING_VERTICAL}px ${MENU_ITEM_PADDING_HORIZONTAL}px;
@@ -7000,20 +7005,12 @@ css /* scss */ `
         min-width: 40%;
       }
 
-      &.o-menu-root {
-        display: flex;
-        justify-content: space-between;
-      }
-
       .o-menu-item-icon {
         display: inline-block;
         margin: 0px 8px 0px 0px;
         width: ${MENU_ITEM_HEIGHT - 2 * MENU_ITEM_PADDING_VERTICAL}px;
         line-height: ${MENU_ITEM_HEIGHT - 2 * MENU_ITEM_PADDING_VERTICAL}px;
       }
-      .o-menu-item-root {
-        width: 10px;
-      }
 
       &:not(.disabled) {
         &:hover,
@@ -7356,7 +7353,7 @@ function tokenize(str, locale = DEFAULT_LOCALE) {
     return result;
 }
 function tokenizeDebugger(chars) {
-    if (chars.current() === "?") {
+    if (chars.current === "?") {
         chars.shift();
         return { type: "DEBUGGER", value: "?" };
     }
@@ -7367,7 +7364,7 @@ const misc$1 = {
     ")": "RIGHT_PAREN",
 };
 function tokenizeMisc(chars) {
-    if (chars.current() in misc$1) {
+    if (chars.current in misc$1) {
         const value = chars.shift();
         const type = misc$1[value];
         return { type, value };
@@ -7375,7 +7372,7 @@ function tokenizeMisc(chars) {
     return null;
 }
 function tokenizeArgsSeparator(chars, locale) {
-    if (chars.current() === locale.formulaArgSeparator) {
+    if (chars.current === locale.formulaArgSeparator) {
         const value = chars.shift();
         const type = "ARG_SEPARATOR";
         return { type, value };
@@ -7400,14 +7397,13 @@ function tokenizeNumber(chars, locale) {
     return null;
 }
 function tokenizeString(chars) {
-    if (chars.current() === '"') {
+    if (chars.current === '"') {
         const startChar = chars.shift();
         let letters = startChar;
-        while (chars.current() &&
-            (chars.current() !== startChar || letters[letters.length - 1] === "\\")) {
+        while (chars.current && (chars.current !== startChar || letters[letters.length - 1] === "\\")) {
             letters += chars.shift();
         }
-        if (chars.current() === '"') {
+        if (chars.current === '"') {
             letters += chars.shift();
         }
         return {
@@ -7434,14 +7430,14 @@ function tokenizeSymbol(chars) {
     let result = "";
     // there are two main cases to manage: either something which starts with
     // a ', like 'Sheet 2'A2, or a word-like element.
-    if (chars.current() === "'") {
+    if (chars.current === "'") {
         let lastChar = chars.shift();
         result += lastChar;
-        while (chars.current()) {
+        while (chars.current) {
             lastChar = chars.shift();
             result += lastChar;
             if (lastChar === "'") {
-                if (chars.current() && chars.current() === "'") {
+                if (chars.current && chars.current === "'") {
                     lastChar = chars.shift();
                     result += lastChar;
                 }
@@ -7457,7 +7453,7 @@ function tokenizeSymbol(chars) {
             };
         }
     }
-    while (chars.current() && separatorRegexp.test(chars.current())) {
+    while (chars.current && separatorRegexp.test(chars.current)) {
         result += chars.shift();
     }
     if (result.length) {
@@ -7472,14 +7468,14 @@ function tokenizeSymbol(chars) {
 }
 function tokenizeSpace(chars) {
     let length = 0;
-    while (chars.current() === NEWLINE) {
+    while (chars.current === NEWLINE) {
         length++;
         chars.shift();
     }
     if (length) {
         return { type: "SPACE", value: NEWLINE.repeat(length) };
     }
-    while (chars.current() === " ") {
+    while (chars.current === " ") {
         length++;
         chars.shift();
     }
@@ -7498,17 +7494,20 @@ function tokenizeInvalidRange(chars) {
 class TokenizingChars {
     text;
     currentIndex = 0;
+    current;
     constructor(text) {
         this.text = text;
-    }
-    current() {
-        return this.text[this.currentIndex];
+        this.current = text[0];
     }
     shift() {
-        return this.text[this.currentIndex++];
+        const current = this.current;
+        const next = this.text[++this.currentIndex];
+        this.current = next;
+        return current;
     }
     advanceBy(length) {
         this.currentIndex += length;
+        this.current = this.text[this.currentIndex];
     }
     isOver() {
         return this.currentIndex >= this.text.length;
@@ -11312,7 +11311,7 @@ const EXPAND = {
     ) {
         const _array = toMatrix(arg);
         const _nbRows = toInteger(rows?.value, this.locale);
-        const _nbColumns = columns !== undefined ? toInteger(columns.value, this.local) : _array.length;
+        const _nbColumns = columns !== undefined ? toInteger(columns.value, this.locale) : _array.length;
         assert(() => _nbRows >= _array[0].length, _t("The rows arguments (%s) must be greater or equal than the number of rows of the array.", _nbRows.toString()));
         assert(() => _nbColumns >= _array.length, _t("The columns arguments (%s) must be greater or equal than the number of columns of the array.", _nbColumns.toString()));
         return generateMatrix(_nbColumns, _nbRows, (col, row) => col >= _array.length || row >= _array[col].length ? padWith : _array[col][row]);
@@ -11801,6 +11800,10 @@ var misc = /*#__PURE__*/Object.freeze({
   FORMAT_LARGE_NUMBER: FORMAT_LARGE_NUMBER
 });
 
+function sum(values, locale) {
+    return reduceNumbers(values, (acc, a) => acc + a, 0, locale);
+}
+
 const DEFAULT_FACTOR = 1;
 const DEFAULT_MODE = 0;
 const DEFAULT_PLACES = 0;
@@ -12752,7 +12755,7 @@ const SUM = {
         return isMatrix(value1) ? value1[0][0]?.format : value1?.format;
     },
     compute: function (...values) {
-        return reduceNumbers(values, (acc, a) => acc + a, 0, this.locale);
+        return sum(values, this.locale);
     },
     isExported: true,
 };
@@ -12921,6 +12924,44 @@ function assertSameNumberOfElements(...args) {
     const dims = args[0].length;
     args.forEach((arg, i) => assert(() => arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
 }
+function average(values, locale) {
+    let count = 0;
+    const sum = reduceNumbers(values, (acc, a) => {
+        count += 1;
+        return acc + a;
+    }, 0, locale);
+    assert(() => count !== 0, _t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."));
+    return sum / count;
+}
+function countNumbers(values, locale) {
+    let count = 0;
+    for (let n of values) {
+        if (isMatrix(n)) {
+            for (let i of n) {
+                for (let j of i) {
+                    if (typeof j === "number") {
+                        count += 1;
+                    }
+                }
+            }
+        }
+        else if (typeof n !== "string" || isNumber(n, locale) || parseDateTime(n, locale)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function countAny(values) {
+    return reduceAny(values, (acc, a) => (a !== undefined && a !== null ? acc + 1 : acc), 0);
+}
+function max(values, locale) {
+    const result = reduceNumbers(values, (acc, a) => (acc < a ? a : acc), -Infinity, locale);
+    return result === -Infinity ? 0 : result;
+}
+function min(values, locale) {
+    const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity, locale);
+    return result === Infinity ? 0 : result;
+}
 
 function filterAndFlatData(dataY, dataX) {
     const _flatDataY = [];
@@ -13191,13 +13232,7 @@ const AVERAGE = {
         return isMatrix(value1) ? value1[0][0]?.format : value1?.format;
     },
     compute: function (...values) {
-        let count = 0;
-        const sum = reduceNumbers(values, (acc, a) => {
-            count += 1;
-            return acc + a;
-        }, 0, this.locale);
-        assert(() => count !== 0, _t("Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error."));
-        return sum / count;
+        return average(values, this.locale);
     },
     isExported: true,
 };
@@ -13355,24 +13390,7 @@ const COUNT = {
     ],
     returns: ["NUMBER"],
     compute: function (...values) {
-        let count = 0;
-        for (let n of values) {
-            if (isMatrix(n)) {
-                for (let i of n) {
-                    for (let j of i) {
-                        if (typeof j === "number") {
-                            count += 1;
-                        }
-                    }
-                }
-            }
-            else if (typeof n !== "string" ||
-                isNumber(n, this.locale) ||
-                parseDateTime(n, this.locale)) {
-                count += 1;
-            }
-        }
-        return count;
+        return countNumbers(values, this.locale);
     },
     isExported: true,
 };
@@ -13387,7 +13405,7 @@ const COUNTA = {
     ],
     returns: ["NUMBER"],
     compute: function (...values) {
-        return reduceAny(values, (acc, a) => (a !== undefined && a !== null ? acc + 1 : acc), 0);
+        return countAny(values);
     },
     isExported: true,
 };
@@ -13617,8 +13635,7 @@ const MAX = {
         return isMatrix(value1) ? value1[0][0]?.format : value1?.format;
     },
     compute: function (...values) {
-        const result = reduceNumbers(values, (acc, a) => (acc < a ? a : acc), -Infinity, this.locale);
-        return result === -Infinity ? 0 : result;
+        return max(values, this.locale);
     },
     isExported: true,
 };
@@ -13705,8 +13722,7 @@ const MIN = {
         return isMatrix(value1) ? value1[0][0]?.format : value1?.format;
     },
     compute: function (...values) {
-        const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity, this.locale);
-        return result === Infinity ? 0 : result;
+        return min(values, this.locale);
     },
     isExported: true,
 };
@@ -17877,6 +17893,149 @@ var financial = /*#__PURE__*/Object.freeze({
   YIELDMAT: YIELDMAT
 });
 
+/**
+ * Change the reference types inside the given token, if the token represent a range or a cell
+ *
+ * Eg. :
+ *   A1 => $A$1 => A$1 => $A1 => A1
+ *   A1:$B$1 => $A$1:B$1 => A$1:$B1 => $A1:B1 => A1:$B$1
+ */
+function loopThroughReferenceType(token) {
+    if (token.type !== "REFERENCE")
+        return token;
+    const { xc, sheetName } = splitReference(token.value);
+    const [left, right] = xc.split(":");
+    const updatedLeft = getTokenNextReferenceType(left);
+    const updatedRight = right ? `:${getTokenNextReferenceType(right)}` : "";
+    return { ...token, value: getFullReference(sheetName, updatedLeft + updatedRight) };
+}
+/**
+ * Get a new token with a changed type of reference from the given cell token symbol.
+ * Undefined behavior if given a token other than a cell or if the Xc contains a sheet reference
+ *
+ * A1 => $A$1 => A$1 => $A1 => A1
+ */
+function getTokenNextReferenceType(xc) {
+    switch (getReferenceType(xc)) {
+        case "none":
+            xc = setXcToFixedReferenceType(xc, "colrow");
+            break;
+        case "colrow":
+            xc = setXcToFixedReferenceType(xc, "row");
+            break;
+        case "row":
+            xc = setXcToFixedReferenceType(xc, "col");
+            break;
+        case "col":
+            xc = setXcToFixedReferenceType(xc, "none");
+            break;
+    }
+    return xc;
+}
+/**
+ * Returns the given XC with the given reference type. The XC string should not contain a sheet name.
+ */
+function setXcToFixedReferenceType(xc, referenceType) {
+    if (xc.includes("!")) {
+        throw new Error("The given XC should not contain a sheet name");
+    }
+    xc = xc.replace(/\$/g, "");
+    let indexOfNumber;
+    switch (referenceType) {
+        case "col":
+            return "$" + xc;
+        case "row":
+            indexOfNumber = xc.search(/[0-9]/);
+            return xc.slice(0, indexOfNumber) + "$" + xc.slice(indexOfNumber);
+        case "colrow":
+            indexOfNumber = xc.search(/[0-9]/);
+            xc = xc.slice(0, indexOfNumber) + "$" + xc.slice(indexOfNumber);
+            return "$" + xc;
+        case "none":
+            return xc;
+    }
+}
+/**
+ * Return the type of reference used in the given XC of a cell.
+ * Undefined behavior if the XC have a sheet reference
+ */
+function getReferenceType(xcCell) {
+    if (isColAndRowFixed(xcCell)) {
+        return "colrow";
+    }
+    else if (isColFixed(xcCell)) {
+        return "col";
+    }
+    else if (isRowFixed(xcCell)) {
+        return "row";
+    }
+    return "none";
+}
+function isColFixed(xc) {
+    return xc.startsWith("$");
+}
+function isRowFixed(xc) {
+    return xc.includes("$", 1);
+}
+function isColAndRowFixed(xc) {
+    return xc.startsWith("$") && xc.length > 1 && xc.slice(1).includes("$");
+}
+
+// -----------------------------------------------------------------------------
+// CELL
+// -----------------------------------------------------------------------------
+// NOTE: missing from Excel: "color", "filename", "parentheses", "prefix", "protect" and "width"
+const CELL_INFO_TYPES = ["address", "col", "contents", "format", "row", "type"];
+const CELL = {
+    description: _t("Gets information about a cell."),
+    args: [
+        arg("info_type (string)", _t("The type of information requested. Can be one of %s", CELL_INFO_TYPES.join(", "))),
+        arg("reference (meta)", _t("The reference to the cell.")),
+    ],
+    returns: ["ANY"],
+    compute: function (info, reference) {
+        const _info = toString(info).toLowerCase();
+        assert(() => CELL_INFO_TYPES.includes(_info), _t("The info_type should be one of %s.", CELL_INFO_TYPES.join(", ")));
+        const sheetId = this.__originSheetId;
+        const topLeftReference = reference.includes(":") ? reference.split(":")[0] : reference;
+        let { sheetName, xc } = splitReference(topLeftReference);
+        // only put the sheet name if the referenced range is in another sheet than the cell the formula is on
+        sheetName = sheetName === this.getters.getSheetName(sheetId) ? undefined : sheetName;
+        const fixedRef = getFullReference(sheetName, setXcToFixedReferenceType(xc, "colrow"));
+        const range = this.getters.getRangeFromSheetXC(sheetId, fixedRef);
+        switch (_info) {
+            case "address":
+                return this.getters.getRangeString(range, sheetId);
+            case "col":
+                return range.zone.left + 1;
+            case "contents": {
+                const position = { sheetId: range.sheetId, col: range.zone.left, row: range.zone.top };
+                return this.getters.getEvaluatedCell(position).value;
+            }
+            case "format": {
+                const position = { sheetId: range.sheetId, col: range.zone.left, row: range.zone.top };
+                return this.getters.getEvaluatedCell(position).format || "";
+            }
+            case "row":
+                return range.zone.top + 1;
+            case "type": {
+                const position = { sheetId: range.sheetId, col: range.zone.left, row: range.zone.top };
+                const type = this.getters.getEvaluatedCell(position).type;
+                if (type === CellValueType.empty) {
+                    return "b"; // blank
+                }
+                else if (type === CellValueType.text) {
+                    return "l"; // label
+                }
+                else {
+                    return "v"; // value
+                }
+            }
+        }
+        return "";
+    },
+    isExported: true,
+};
 // -----------------------------------------------------------------------------
 // ISERR
 // -----------------------------------------------------------------------------
@@ -18032,6 +18191,7 @@ const NA = {
 
 var info = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  CELL: CELL,
   ISBLANK: ISBLANK,
   ISERR: ISERR,
   ISERROR: ISERROR,
@@ -18323,7 +18483,7 @@ const ADDRESS = {
             cellReference = rowPart + colPart;
         }
         if (sheet !== undefined) {
-            return `${getCanonicalSheetName(toString(sheet))}!${cellReference}`;
+            return getFullReference(toString(sheet), cellReference);
         }
         return cellReference;
     },
@@ -18339,7 +18499,7 @@ const COLUMN = {
     ],
     returns: ["NUMBER"],
     compute: function (cellReference) {
-        const _cellReference = cellReference || this.__originCellXC?.();
+        const _cellReference = cellReference || this.__originCellXC();
         assert(() => !!_cellReference, "In this context, the function [[FUNCTION_NAME]] needs to have a cell or range in parameter.");
         const zone = toZone(_cellReference);
         return zone.left + 1;
@@ -18506,7 +18666,7 @@ const ROW = {
     ],
     returns: ["NUMBER"],
     compute: function (cellReference) {
-        cellReference = cellReference || this.__originCellXC?.();
+        cellReference = cellReference || this.__originCellXC();
         assert(() => !!cellReference, "In this context, the function [[FUNCTION_NAME]] needs to have a cell or range in parameter.");
         const zone = toZone(cellReference);
         return zone.top + 1;
@@ -23858,31 +24018,65 @@ css /* scss */ `
 `;
 class FindAndReplacePanel extends owl.Component {
     static template = "o-spreadsheet-FindAndReplacePanel";
-    state = owl.useState(this.initialState());
+    static components = { SelectionInput };
     debounceTimeoutId;
-    showFormulaState = false;
+    initialShowFormulaState = false;
+    dataRange = "";
     searchInput = owl.useRef("searchInput");
+    replaceInput = owl.useRef("replaceInput");
     get hasSearchResult() {
         return this.env.model.getters.getCurrentSelectedMatchIndex() !== null;
     }
     get pendingSearch() {
         return this.debounceTimeoutId !== undefined;
     }
+    get searchOptions() {
+        return this.env.model.getters.getSearchOptions();
+    }
+    get toSearch() {
+        return this.searchInput.el?.value || "";
+    }
+    get toReplace() {
+        return this.replaceInput.el?.value || "";
+    }
+    get allSheetsMatchesCount() {
+        return _t("%s in all sheets", this.env.model.getters.getAllSheetMatchesCount());
+    }
+    get currentSheetMatchesCount() {
+        return _t("%(matches)s in sheet %(sheetName)s", {
+            matches: this.env.model.getters.getActiveSheetMatchesCount(),
+            sheetName: this.env.model.getters.getSheetName(this.env.model.getters.getActiveSheetId()),
+        });
+    }
+    get specificRangeMatchesCount() {
+        const range = this.searchOptions.specificRange;
+        if (!range) {
+            return "";
+        }
+        const { _sheetId, _zone } = range;
+        return _t("%(matches)s in range %(range)s of sheet %(sheetName)s", {
+            matches: this.env.model.getters.getSpecificRangeMatchesCount().toString(),
+            range: zoneToXc(_zone),
+            sheetName: this.env.model.getters.getSheetName(_sheetId),
+        });
+    }
     setup() {
-        this.showFormulaState = this.env.model.getters.shouldShowFormulas();
+        this.initialShowFormulaState = this.env.model.getters.shouldShowFormulas();
         owl.onMounted(() => this.searchInput.el?.focus());
         owl.onWillUnmount(() => {
             clearTimeout(this.debounceTimeoutId);
             this.env.model.dispatch("CLEAR_SEARCH");
-            this.env.model.dispatch("SET_FORMULA_VISIBILITY", { show: this.showFormulaState });
+            this.env.model.dispatch("SET_FORMULA_VISIBILITY", { show: this.initialShowFormulaState });
         });
         owl.useEffect(() => {
-            this.state.searchOptions.searchFormulas = this.env.model.getters.shouldShowFormulas();
-            this.searchFormulas();
+            const showFormula = this.env.model.getters.shouldShowFormulas();
+            this.updateSearch({ searchFormulas: showFormula });
         }, () => [this.env.model.getters.shouldShowFormulas()]);
     }
-    onInput(ev) {
-        this.state.toSearch = ev.target.value;
+    onFocusSearch() {
+        this.updateDataRange();
+    }
+    onInput() {
         this.debouncedUpdateSearch();
     }
     onKeydownSearch(ev) {
@@ -23899,11 +24093,36 @@ class FindAndReplacePanel extends owl.Component {
             this.replace();
         }
     }
-    searchFormulas() {
+    searchFormulas(ev) {
+        const showFormula = ev.target.checked;
         this.env.model.dispatch("SET_FORMULA_VISIBILITY", {
-            show: this.state.searchOptions.searchFormulas,
+            show: showFormula,
         });
-        this.updateSearch();
+        this.updateSearch({ searchFormulas: showFormula });
+    }
+    searchExactMatch(ev) {
+        const exactMatch = ev.target.checked;
+        this.updateSearch({ exactMatch });
+    }
+    searchMatchCase(ev) {
+        const matchCase = ev.target.checked;
+        this.updateSearch({ matchCase });
+    }
+    changeSearchScope(ev) {
+        const searchScope = ev.target.value;
+        this.updateSearch({ searchScope });
+    }
+    onSearchRangeChanged(ranges) {
+        this.dataRange = ranges[0];
+    }
+    updateDataRange() {
+        if (!this.dataRange) {
+            return;
+        }
+        if (this.searchOptions.searchScope === "specificRange") {
+            const specificRange = this.env.model.getters.getRangeFromSheetXC(this.env.model.getters.getActiveSheetId(), this.dataRange).rangeData;
+            this.updateSearch({ specificRange });
+        }
     }
     onSelectPreviousCell() {
         this.env.model.dispatch("SELECT_SEARCH_PREVIOUS_MATCH");
@@ -23911,10 +24130,14 @@ class FindAndReplacePanel extends owl.Component {
     onSelectNextCell() {
         this.env.model.dispatch("SELECT_SEARCH_NEXT_MATCH");
     }
-    updateSearch() {
+    updateSearch(updateSearchOptions) {
+        const searchOptions = {
+            ...this.env.model.getters.getSearchOptions(),
+            ...updateSearchOptions,
+        };
         this.env.model.dispatch("UPDATE_SEARCH", {
-            toSearch: this.state.toSearch,
-            searchOptions: this.state.searchOptions,
+            toSearch: this.toSearch,
+            searchOptions,
         });
     }
     debouncedUpdateSearch() {
@@ -23926,28 +24149,14 @@ class FindAndReplacePanel extends owl.Component {
     }
     replace() {
         this.env.model.dispatch("REPLACE_SEARCH", {
-            replaceWith: this.state.replaceWith,
+            replaceWith: this.toReplace,
         });
     }
     replaceAll() {
         this.env.model.dispatch("REPLACE_ALL_SEARCH", {
-            replaceWith: this.state.replaceWith,
+            replaceWith: this.toReplace,
         });
     }
-    // ---------------------------------------------------------------------------
-    // Private
-    // ---------------------------------------------------------------------------
-    initialState() {
-        return {
-            toSearch: "",
-            replaceWith: "",
-            searchOptions: {
-                matchCase: false,
-                exactMatch: false,
-                searchFormulas: false,
-            },
-        };
-    }
 }
 FindAndReplacePanel.props = {
     onCloseSidePanel: Function,
@@ -27093,7 +27302,7 @@ class GridComposer extends owl.Component {
     get cellReference() {
         const { col, row, sheetId } = this.env.model.getters.getCurrentEditedCell();
         const prefixSheet = sheetId !== this.env.model.getters.getActiveSheetId();
-        return `${prefixSheet ? getCanonicalSheetName(this.env.model.getters.getSheetName(sheetId)) + "!" : ""}${toXC(col, row)}`;
+        return getFullReference(prefixSheet ? this.env.model.getters.getSheetName(sheetId) : undefined, toXC(col, row));
     }
     get cellReferenceStyle() {
         const { x: left, y: top } = this.rect;
@@ -28536,22 +28745,15 @@ css /* scss */ `
       height: 10000px;
       background-color: ${SELECTION_BORDER_COLOR};
     }
-    .o-unhide {
-      width: ${UNHIDE_ICON_EDGE_LENGTH}px;
-      height: ${UNHIDE_ICON_EDGE_LENGTH}px;
-      position: absolute;
-      overflow: hidden;
-      border-radius: 2px;
-      top: calc(${HEADER_HEIGHT}px / 2 - ${UNHIDE_ICON_EDGE_LENGTH}px / 2);
+    .o-unhide-buttons {
+      width: fit-content;
+      gap: 5px;
+      transform: translate(-50%, 0);
     }
     .o-unhide:hover {
       z-index: ${ComponentsImportance.Grid + 1};
       background-color: lightgrey;
     }
-    .o-unhide > svg {
-      position: relative;
-      top: calc(${UNHIDE_ICON_EDGE_LENGTH}px / 2 - ${ICON_EDGE_LENGTH}px / 2);
-    }
   }
 `;
 AbstractResizer.props = {
@@ -28661,8 +28863,8 @@ class ColResizer extends AbstractResizer {
             dimension: "COL",
         });
     }
-    unhideStyleValue(hiddenIndex) {
-        return this._getDimensionsInViewport(hiddenIndex).start;
+    getUnhideButtonStyle(hiddenIndex) {
+        return cssPropertiesToCss({ left: this._getDimensionsInViewport(hiddenIndex).start + "px" });
     }
 }
 css /* scss */ `
@@ -28708,18 +28910,9 @@ css /* scss */ `
       height: 1px;
       background-color: ${SELECTION_BORDER_COLOR};
     }
-    .o-unhide {
-      width: ${UNHIDE_ICON_EDGE_LENGTH}px;
-      height: ${UNHIDE_ICON_EDGE_LENGTH}px;
-      position: absolute;
-      overflow: hidden;
-      border-radius: 2px;
-      left: calc(${HEADER_WIDTH}px - ${UNHIDE_ICON_EDGE_LENGTH}px - 2px);
-    }
-    .o-unhide > svg {
-      position: relative;
-      left: calc(${UNHIDE_ICON_EDGE_LENGTH}px / 2 - ${ICON_EDGE_LENGTH}px / 2);
-      top: calc(${UNHIDE_ICON_EDGE_LENGTH}px / 2 - ${ICON_EDGE_LENGTH}px / 2);
+    .o-unhide-buttons {
+      height: fit-content;
+      transform: translate(0, -50%);
     }
     .o-unhide:hover {
       z-index: ${ComponentsImportance.Grid + 1};
@@ -28834,8 +29027,8 @@ class RowResizer extends AbstractResizer {
             elements: hiddenElements,
         });
     }
-    unhideStyleValue(hiddenIndex) {
-        return this._getDimensionsInViewport(hiddenIndex).start;
+    getUnhideButtonStyle(hiddenIndex) {
+        return cssPropertiesToCss({ top: this._getDimensionsInViewport(hiddenIndex).start + "px" });
     }
 }
 css /* scss */ `
@@ -29342,7 +29535,6 @@ class Grid extends owl.Component {
         owl.onMounted(() => this.focus());
         this.props.exposeFocus(() => this.focus());
         useGridDrawing("canvas", this.env.model, () => this.env.model.getters.getSheetViewDimensionWithHeaders());
-        owl.useEffect(() => this.focus(), () => [this.env.model.getters.getActiveSheetId()]);
         this.onMouseWheel = useWheelHandler((deltaX, deltaY) => {
             this.moveCanvas(deltaX, deltaY);
             this.hoveredCell.col = undefined;
@@ -29779,6 +29971,7 @@ class Grid extends owl.Component {
             const content = clipboardData.getData(ClipboardMIMEType.PlainText);
             const target = this.env.model.getters.getSelectedZones();
             const clipboardString = this.env.model.getters.getClipboardTextContent();
+            const isCutOperation = this.env.model.getters.isCutOperation();
             if (clipboardString === content) {
                 // the paste actually comes from o-spreadsheet itself
                 interactivePaste(this.env, target);
@@ -29786,7 +29979,7 @@ class Grid extends owl.Component {
             else {
                 interactivePasteFromOS(this.env, target, content);
             }
-            if (this.env.model.getters.isCutOperation()) {
+            if (isCutOperation) {
                 await this.env.clipboard.write({ [ClipboardMIMEType.PlainText]: "" });
             }
         }
@@ -31399,12 +31592,6 @@ function convertChartData(chartData) {
 }
 function convertExcelRangeToSheetXC(range, dataSetsHaveTitle) {
     let { sheetName, xc } = splitReference(range);
-    if (sheetName) {
-        sheetName = getCanonicalSheetName(sheetName) + "!";
-    }
-    else {
-        sheetName = "";
-    }
     let zone = toUnboundedZone(xc);
     if (dataSetsHaveTitle && zone.bottom !== undefined && zone.right !== undefined) {
         const height = zone.bottom - zone.top + 1;
@@ -31417,7 +31604,7 @@ function convertExcelRangeToSheetXC(range, dataSetsHaveTitle) {
         }
     }
     const dataXC = zoneToXc(zone);
-    return sheetName + dataXC;
+    return getFullReference(sheetName, dataXC);
 }
 
 /**
@@ -34080,6 +34267,14 @@ class BordersPlugin extends CorePlugin {
     // ---------------------------------------------------------------------------
     // Command Handling
     // ---------------------------------------------------------------------------
+    allowDispatch(cmd) {
+        switch (cmd.type) {
+            case "SET_BORDER":
+                return this.checkBordersUnchanged(cmd);
+            default:
+                return "Success" /* CommandResult.Success */;
+        }
+    }
     handle(cmd) {
         switch (cmd.type) {
             case "ADD_MERGE":
@@ -34499,6 +34694,14 @@ class BordersPlugin extends CorePlugin {
             this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersTopLeft.right);
         }
     }
+    checkBordersUnchanged(cmd) {
+        const currentBorder = this.getCellBorder(cmd);
+        const areAllNewBordersUndefined = !cmd.border?.bottom && !cmd.border?.left && !cmd.border?.right && !cmd.border?.top;
+        if ((!currentBorder && areAllNewBordersUndefined) || deepEquals(currentBorder, cmd.border)) {
+            return "NoChanges" /* CommandResult.NoChanges */;
+        }
+        return "Success" /* CommandResult.Success */;
+    }
     // ---------------------------------------------------------------------------
     // Import/Export
     // ---------------------------------------------------------------------------
@@ -35325,7 +35528,6 @@ class CellPlugin extends CorePlugin {
     static getters = [
         "zoneToXC",
         "getCells",
-        "getFormulaCellContent",
         "getTranslatedCellFormula",
         "getCellStyle",
         "getCellById",
@@ -35354,8 +35556,9 @@ class CellPlugin extends CorePlugin {
     allowDispatch(cmd) {
         switch (cmd.type) {
             case "UPDATE_CELL":
+                return this.checkCellOutOfSheet(cmd);
             case "CLEAR_CELL":
-                return this.checkCellOutOfSheet(cmd.sheetId, cmd.col, cmd.row);
+                return this.checkValidations(cmd, this.chainValidations(this.checkCellOutOfSheet, this.checkUselessClearCell));
             default:
                 return "Success" /* CommandResult.Success */;
         }
@@ -35524,24 +35727,18 @@ class CellPlugin extends CorePlugin {
      */
     getCellById(cellId) {
         // this must be as fast as possible
-        for (const sheetId in this.cells) {
-            const sheet = this.cells[sheetId];
-            const cell = sheet[cellId];
-            if (cell) {
-                return cell;
-            }
-        }
-        return undefined;
+        const position = this.getters.getCellPosition(cellId);
+        const sheet = this.cells[position.sheetId];
+        return sheet[cellId];
     }
     /*
      * Reconstructs the original formula string based on a normalized form and its dependencies
      */
     getFormulaCellContent(sheetId, compiledFormula, dependencies) {
-        const ranges = dependencies || compiledFormula.dependencies;
         let rangeIndex = 0;
         return concat(compiledFormula.tokens.map((token) => {
             if (token.type === "REFERENCE") {
-                const range = ranges[rangeIndex++];
+                const range = dependencies[rangeIndex++];
                 return this.getters.getRangeString(range, sheetId);
             }
             return token.value;
@@ -35762,13 +35959,23 @@ class CellPlugin extends CorePlugin {
             },
         };
     }
-    checkCellOutOfSheet(sheetId, col, row) {
+    checkCellOutOfSheet(cmd) {
+        const { sheetId, col, row } = cmd;
         const sheet = this.getters.tryGetSheet(sheetId);
         if (!sheet)
             return "InvalidSheetId" /* CommandResult.InvalidSheetId */;
         const sheetZone = this.getters.getSheetZone(sheetId);
         return isInside(col, row, sheetZone) ? "Success" /* CommandResult.Success */ : "TargetOutOfSheet" /* CommandResult.TargetOutOfSheet */;
     }
+    checkUselessClearCell(cmd) {
+        const cell = this.getters.getCell(cmd);
+        if (!cell)
+            return "NoChanges" /* CommandResult.NoChanges */;
+        if (!cell.content && !cell.style && !cell.format) {
+            return "NoChanges" /* CommandResult.NoChanges */;
+        }
+        return "Success" /* CommandResult.Success */;
+    }
 }
 class FormulaCellWithDependencies {
     id;
@@ -36458,6 +36665,9 @@ class DataValidationPlugin extends CorePlugin {
         return this.rules[sheetId].find((rule) => rule.id === id);
     }
     getValidationRuleForCell({ sheetId, col, row }) {
+        if (!this.rules[sheetId]) {
+            return undefined;
+        }
         for (const rule of this.rules[sheetId]) {
             for (const range of rule.ranges) {
                 if (isInside(col, row, range.zone)) {
@@ -37630,7 +37840,7 @@ class MergePlugin extends CorePlugin {
         const rangeString = this.getters.getRangeString(expandedRange, forSheetId);
         if (this.isSingleCellOrMerge(rangeImpl.sheetId, rangeImpl.zone)) {
             const { sheetName, xc } = splitReference(rangeString);
-            return `${sheetName !== undefined ? getCanonicalSheetName(sheetName) + "!" : ""}${xc.split(":")[0]}`;
+            return getFullReference(sheetName, xc.split(":")[0]);
         }
         return rangeString;
     }
@@ -39055,10 +39265,13 @@ class SheetPlugin extends CorePlugin {
         // begin with the end.
         rows.sort((a, b) => b - a);
         for (let group of groupConsecutive(rows)) {
+            // indexes are sorted in the descending order
+            const from = group[group.length - 1];
+            const to = group[0];
             // Move the cells.
-            this.moveCellOnRowsDeletion(sheet, group[group.length - 1], group[0]);
-            // Effectively delete the element and recompute the left-right/top-bottom.
-            group.map((row) => this.updateRowsStructureOnDeletion(row, sheet));
+            this.moveCellOnRowsDeletion(sheet, from, to);
+            // Effectively delete the rows
+            this.updateRowsStructureOnDeletion(sheet, from, to);
         }
         const count = rows.filter((row) => row < sheet.panes.ySplit).length;
         if (count) {
@@ -39080,8 +39293,6 @@ class SheetPlugin extends CorePlugin {
         this.addEmptyRows(sheet, quantity);
         // Move the cells.
         this.moveCellsOnAddition(sheet, index, quantity, "rows");
-        // Recompute the left-right/top-bottom.
-        this.updateRowsStructureOnAddition(sheet, row, quantity);
         if (index < sheet.panes.ySplit) {
             this.setPaneDivisions(sheet.id, sheet.panes.ySplit + quantity, "ROW");
         }
@@ -39182,35 +39393,20 @@ class SheetPlugin extends CorePlugin {
             }
         }
     }
-    updateRowsStructureOnDeletion(index, sheet) {
+    updateRowsStructureOnDeletion(sheet, deleteFromRow, deleteToRow) {
         const rows = [];
-        const cellsQueue = sheet.rows.map((row) => row.cells);
+        const cellsQueue = sheet.rows.map((row) => row.cells).reverse();
         for (let i in sheet.rows) {
-            if (Number(i) === index) {
+            const row = Number(i);
+            if (row >= deleteFromRow && row <= deleteToRow) {
                 continue;
             }
             rows.push({
-                cells: cellsQueue.shift(),
+                cells: cellsQueue.pop(),
             });
         }
         this.history.update("sheets", sheet.id, "rows", rows);
     }
-    /**
-     * Update the rows of the sheet after an addition:
-     * - Rename the rows
-     *
-     * @param sheet Sheet on which the deletion occurs
-     * @param addedRow Index of the added row
-     * @param rowsToAdd Number of the rows to add
-     */
-    updateRowsStructureOnAddition(sheet, addedRow, rowsToAdd) {
-        const rows = [];
-        const cellsQueue = sheet.rows.map((row) => row.cells);
-        sheet.rows.forEach(() => rows.push({
-            cells: cellsQueue.shift(),
-        }));
-        this.history.update("sheets", sheet.id, "rows", rows);
-    }
     /**
      * Add empty rows at the end of the rows
      *
@@ -39737,6 +39933,7 @@ class CompilationParametersBuilder {
     getters;
     computeCell;
     evalContext;
+    rangeCache = {};
     constructor(context, getters, computeCell) {
         this.getters = getters;
         this.computeCell = computeCell;
@@ -39759,7 +39956,8 @@ class CompilationParametersBuilder {
     refFn(range, isMeta, functionName, paramNumber) {
         if (isMeta) {
             // Use zoneToXc of zone instead of getRangeString to avoid sending unbounded ranges
-            return { value: zoneToXc(range.zone) };
+            const sheetName = this.getters.getSheetName(range.sheetId);
+            return { value: getFullReference(sheetName, zoneToXc(range.zone)) };
         }
         if (!isZoneValid(range.zone)) {
             throw new InvalidReferenceError();
@@ -39822,17 +40020,24 @@ class CompilationParametersBuilder {
         if (!_zone) {
             return [[]];
         }
+        const { top, left, bottom, right } = zone;
+        const cacheKey = `${sheetId}-${top}-${left}-${bottom}-${right}`;
+        if (cacheKey in this.rangeCache) {
+            return this.rangeCache[cacheKey];
+        }
         const height = _zone.bottom - _zone.top + 1;
         const width = _zone.right - _zone.left + 1;
-        const matrix = Array.from({ length: width }, () => Array.from({ length: height }));
+        const matrix = new Array(width);
         // Performance issue: nested loop is faster than a map here
         for (let col = _zone.left; col <= _zone.right; col++) {
+            const colIndex = col - _zone.left;
+            matrix[colIndex] = new Array(height);
             for (let row = _zone.top; row <= _zone.bottom; row++) {
-                const colIndex = col - _zone.left;
                 const rowIndex = row - _zone.top;
                 matrix[colIndex][rowIndex] = this.readCell({ sheetId, col, row });
             }
         }
+        this.rangeCache[cacheKey] = matrix;
         return matrix;
     }
 }
@@ -40038,6 +40243,7 @@ class Evaluator {
         this.formulaDependencies().addDependencies(positionId, dependencies);
     }
     updateCompilationParameters() {
+        // rebuild the compilation parameters (with a clean cache)
         this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
     }
     evaluateCells(positions) {
@@ -40081,6 +40287,16 @@ class Evaluator {
         this.evaluatedCells = new Map();
         this.evaluate(this.getAllCells());
     }
+    evaluateFormula(sheetId, formulaString) {
+        const compiledFormula = compile(formulaString);
+        const ranges = compiledFormula.dependencies.map((xc) => this.getters.getRangeFromSheetXC(sheetId, xc));
+        this.updateCompilationParameters();
+        const result = updateEvalContextAndExecute({ ...compiledFormula, dependencies: ranges }, this.compilationParams, sheetId);
+        if (isMatrix(result)) {
+            return matrixMap(result, (cell) => cell.value);
+        }
+        return result.value;
+    }
     getAllCells() {
         const positionIds = new JetSet();
         for (const sheetId of this.getters.getSheetIds()) {
@@ -40107,6 +40323,7 @@ class Evaluator {
         this.nextPositionsToUpdate = cells;
         let currentIteration = 0;
         while (this.nextPositionsToUpdate.size && currentIteration++ < MAX_ITERATION) {
+            this.updateCompilationParameters();
             const positionIds = Array.from(this.nextPositionsToUpdate);
             this.nextPositionsToUpdate.clear();
             for (let i = 0; i < positionIds.length; ++i) {
@@ -40130,7 +40347,8 @@ class Evaluator {
         if (!this.blockedArrayFormulas.has(positionId)) {
             this.invalidateSpreading(positionId);
         }
-        const cell = this.getCell(positionId);
+        const cellPosition = this.decodePosition(positionId);
+        const cell = this.getters.getCell(cellPosition);
         if (cell === undefined) {
             return createEvaluatedCell("", { locale: this.getters.getLocale() });
         }
@@ -40141,7 +40359,7 @@ class Evaluator {
             }
             this.cellsBeingComputed.add(cellId);
             return cell.isFormula
-                ? this.computeFormulaCell(cell)
+                ? this.computeFormulaCell(cellPosition.sheetId, cell)
                 : evaluateLiteral(cell.content, { format: cell.format, locale: this.getters.getLocale() });
         }
         catch (e) {
@@ -40167,14 +40385,9 @@ class Evaluator {
         e.message = e.message.replace("[[FUNCTION_NAME]]", __lastFnCalled);
         return errorCell(e);
     }
-    computeFormulaCell(cellData) {
+    computeFormulaCell(sheetId, cellData) {
         const cellId = cellData.id;
-        this.compilationParams[2].__originCellXC = () => {
-            // compute the value lazily for performance reasons
-            const position = this.compilationParams[2].getters.getCellPosition(cellId);
-            return toXC(position.col, position.row);
-        };
-        const formulaReturn = cellData.compiledFormula.execute(cellData.compiledFormula.dependencies, ...this.compilationParams);
+        const formulaReturn = updateEvalContextAndExecute(cellData.compiledFormula, this.compilationParams, sheetId, cellId);
         if (!isMatrix(formulaReturn)) {
             return createEvaluatedCell(formulaReturn.value, {
                 format: cellData.format || formulaReturn.format,
@@ -40376,6 +40589,18 @@ class PositionBitsEncoder {
         return sheetId;
     }
 }
+function updateEvalContextAndExecute(compiledFormula, compilationParams, sheetId, cellId) {
+    compilationParams[2].__originCellXC = lazy(() => {
+        if (!cellId) {
+            return undefined;
+        }
+        // compute the value lazily for performance reasons
+        const position = compilationParams[2].getters.getCellPosition(cellId);
+        return toXC(position.col, position.row);
+    });
+    compilationParams[2].__originSheetId = sheetId;
+    return compiledFormula.execute(compiledFormula.dependencies, ...compilationParams);
+}
 
 //#region
 // ---------------------------------------------------------------------------
@@ -40470,7 +40695,6 @@ class PositionBitsEncoder {
 // of other cells depending on it, at the next iteration.
 //#endregion
 class EvaluationPlugin extends UIPlugin {
-    config;
     static getters = [
         "evaluateFormula",
         "getCorrespondingFormulaCell",
@@ -40481,15 +40705,13 @@ class EvaluationPlugin extends UIPlugin {
         "getEvaluatedCells",
         "getEvaluatedCellsInZone",
         "getSpreadPositionsOf",
+        "getArrayFormulaSpreadingOn",
     ];
     shouldRebuildDependenciesGraph = true;
     evaluator;
-    compilationParams;
     positionsToUpdate = [];
     constructor(config) {
         super(config);
-        this.config = config;
-        this.compilationParams = this.getCompilationParameters();
         this.evaluator = new Evaluator(config.custom, this.getters);
     }
     // ---------------------------------------------------------------------------
@@ -40514,10 +40736,6 @@ class EvaluationPlugin extends UIPlugin {
             case "EVALUATE_CELLS":
                 this.evaluator.evaluateAllCells();
                 break;
-            case "UPDATE_LOCALE":
-                this.compilationParams = this.getCompilationParameters();
-                this.evaluator.updateCompilationParameters();
-                break;
         }
     }
     finalize() {
@@ -40535,16 +40753,7 @@ class EvaluationPlugin extends UIPlugin {
     // Getters
     // ---------------------------------------------------------------------------
     evaluateFormula(sheetId, formulaString) {
-        const compiledFormula = compile(formulaString);
-        const ranges = [];
-        for (let xc of compiledFormula.dependencies) {
-            ranges.push(this.getters.getRangeFromSheetXC(sheetId, xc));
-        }
-        const array = compiledFormula.execute(ranges, ...this.compilationParams);
-        if (isMatrix(array)) {
-            return array.map((col) => col.map((row) => row.value));
-        }
-        return array.value;
+        return this.evaluator.evaluateFormula(sheetId, formulaString);
     }
     /**
      * Return the value of each cell in the range as they are displayed in the grid.
@@ -40593,6 +40802,9 @@ class EvaluationPlugin extends UIPlugin {
     getSpreadPositionsOf(position) {
         return this.evaluator.getSpreadPositionsOf(position);
     }
+    getArrayFormulaSpreadingOn(position) {
+        return this.evaluator.getArrayFormulaSpreadingOn(position);
+    }
     // ---------------------------------------------------------------------------
     // Export
     // ---------------------------------------------------------------------------
@@ -40636,7 +40848,7 @@ class EvaluationPlugin extends UIPlugin {
         else if (cell && cell.content) {
             return undefined;
         }
-        const spreadingFormulaPosition = this.evaluator.getArrayFormulaSpreadingOn(position);
+        const spreadingFormulaPosition = this.getArrayFormulaSpreadingOn(position);
         if (spreadingFormulaPosition === undefined) {
             return undefined;
         }
@@ -40646,9 +40858,6 @@ class EvaluationPlugin extends UIPlugin {
         }
         return undefined;
     }
-    getCompilationParameters() {
-        return buildCompilationParameters(this.config.custom, this.getters, (position) => this.evaluator.getEvaluatedCell(position));
-    }
 }
 function isBadExpression(tokens) {
     try {
@@ -43347,11 +43556,26 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
             let cellsInRow = [];
             for (let col of columnsIndex) {
                 const position = { col, row, sheetId };
+                const spreader = getters.getArrayFormulaSpreadingOn(position);
+                let cell = getters.getCell(position);
+                const evaluatedCell = getters.getEvaluatedCell(position);
+                if (spreader) {
+                    const isSpreaderCopied = rowsIndex.includes(spreader.row) && columnsIndex.includes(spreader.col);
+                    const content = isSpreaderCopied
+                        ? ""
+                        : formatValue(evaluatedCell.value, { locale: getters.getLocale() });
+                    cell = {
+                        id: cell?.id || "",
+                        style: cell?.style,
+                        format: evaluatedCell.format,
+                        content,
+                        isFormula: false,
+                    };
+                }
                 cellsInRow.push({
-                    cell: getters.getCell(position),
-                    style: getters.getCellComputedStyle(position),
-                    evaluatedCell: getters.getEvaluatedCell(position),
+                    cell,
                     border: getters.getCellBorder(position) || undefined,
+                    evaluatedCell,
                     position,
                 });
             }
@@ -43473,13 +43697,6 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
             });
         }
         this.pasteCopiedTables(target);
-        this.cells.forEach((row) => {
-            row.forEach((c) => {
-                if (c.cell) {
-                    c.cell = undefined;
-                }
-            });
-        });
     }
     /**
      * The clipped zone is copied as many times as it fits in the target.
@@ -43553,7 +43770,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
     clearClippedZones() {
         for (const row of this.cells) {
             for (const cell of row) {
-                if (cell.cell) {
+                if (cell?.cell) {
                     this.dispatch("CLEAR_CELL", cell.position);
                 }
             }
@@ -43579,6 +43796,9 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
             const rowCells = this.cells[r];
             for (let c = 0; c < width; c++) {
                 const origin = rowCells[c];
+                if (!origin) {
+                    continue;
+                }
                 const position = { col: col + c, row: row + r, sheetId: sheetId };
                 // TODO: refactor this part. the "Paste merge" action is also executed with
                 // MOVE_RANGES in pasteFromCut. Adding a condition on the operation type here
@@ -43602,53 +43822,42 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
     pasteCell(origin, target, operation, clipboardOption) {
         const { sheetId, col, row } = target;
         const targetCell = this.getters.getEvaluatedCell(target);
-        if (clipboardOption?.pasteOption !== "onlyValue") {
-            const targetBorders = this.getters.getCellBorder(target);
-            const originBorders = origin.border;
-            const border = {
-                top: targetBorders?.top || originBorders?.top,
-                bottom: targetBorders?.bottom || originBorders?.bottom,
-                left: targetBorders?.left || originBorders?.left,
-                right: targetBorders?.right || originBorders?.right,
-            };
-            this.dispatch("SET_BORDER", { sheetId, col, row, border });
+        if (clipboardOption?.pasteOption === "onlyValue") {
+            const locale = this.getters.getLocale();
+            const content = formatValue(origin.evaluatedCell.value, { locale });
+            this.dispatch("UPDATE_CELL", { ...target, content });
+            return;
         }
-        if (origin.cell) {
-            if (clipboardOption?.pasteOption === "onlyFormat") {
-                this.dispatch("UPDATE_CELL", {
-                    ...target,
-                    style: origin.cell.style,
-                    format: origin.evaluatedCell.format,
-                });
-                return;
-            }
-            if (clipboardOption?.pasteOption === "onlyValue") {
-                const locale = this.getters.getLocale();
-                const content = formatValue(origin.evaluatedCell.value, { locale });
-                this.dispatch("UPDATE_CELL", { ...target, content });
-                return;
-            }
-            let content = origin.cell.content;
-            if (origin.cell.isFormula && operation === "COPY") {
-                content = this.getters.getTranslatedCellFormula(sheetId, col - origin.position.col, row - origin.position.row, origin.cell.compiledFormula);
-            }
+        const targetBorders = this.getters.getCellBorder(target);
+        const originBorders = origin.border;
+        const border = {
+            top: targetBorders?.top || originBorders?.top,
+            bottom: targetBorders?.bottom || originBorders?.bottom,
+            left: targetBorders?.left || originBorders?.left,
+            right: targetBorders?.right || originBorders?.right,
+        };
+        this.dispatch("SET_BORDER", { sheetId, col, row, border });
+        if (clipboardOption?.pasteOption === "onlyFormat") {
+            this.dispatch("UPDATE_CELL", {
+                ...target,
+                style: origin.cell?.style ?? null,
+                format: origin.cell?.format ?? origin.evaluatedCell.format ?? targetCell.format,
+            });
+            return;
+        }
+        const content = origin.cell && origin.cell.isFormula && operation === "COPY"
+            ? this.getters.getTranslatedCellFormula(sheetId, col - origin.position.col, row - origin.position.row, origin.cell.compiledFormula)
+            : origin.cell?.content;
+        if (content !== "" || origin.cell?.format || origin.cell?.style) {
             this.dispatch("UPDATE_CELL", {
                 ...target,
                 content,
-                style: origin.cell.style || null,
-                format: origin.cell.format,
+                style: origin.cell?.style || null,
+                format: origin.cell?.format,
             });
         }
         else if (targetCell) {
-            if (clipboardOption?.pasteOption === "onlyValue") {
-                this.dispatch("UPDATE_CELL", { ...target, content: "" });
-            }
-            else if (clipboardOption?.pasteOption === "onlyFormat") {
-                this.dispatch("UPDATE_CELL", { ...target, style: null, format: "" });
-            }
-            else {
-                this.dispatch("CLEAR_CELL", target);
-            }
+            this.dispatch("CLEAR_CELL", target);
         }
     }
     /**
@@ -43710,22 +43919,28 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
         return (this.cells
             .map((cells) => {
             return cells
-                .map((c) => this.getters.shouldShowFormulas() && c.cell?.isFormula
+                .map((c) => this.getters.shouldShowFormulas() && c?.cell?.isFormula
                 ? c.cell?.content || ""
-                : c.evaluatedCell?.formattedValue || "")
+                : c?.evaluatedCell?.formattedValue || "")
                 .join("\t");
         })
             .join("\n") || "\t");
     }
     getHTMLContent() {
         if (this.cells.length === 1 && this.cells[0].length === 1) {
+            if (!this.cells[0][0]) {
+                return "";
+            }
             return this.getters.getCellText(this.cells[0][0].position);
         }
         let htmlTable = '<table border="1" style="border-collapse:collapse">';
         for (const row of this.cells) {
             htmlTable += "<tr>";
             for (const cell of row) {
-                const cssStyle = cssPropertiesToCss(cellStyleToCss(cell.style));
+                if (!cell) {
+                    continue;
+                }
+                const cssStyle = cssPropertiesToCss(cellStyleToCss(this.getters.getCellComputedStyle(cell.position)));
                 const cellText = this.getters.getCellText(cell.position);
                 htmlTable += `<td style="${cssStyle}">` + xmlEscape(cellText) + "</td>";
             }
@@ -44053,24 +44268,49 @@ var Direction;
  */
 class FindAndReplacePlugin extends UIPlugin {
     static layers = [3 /* LAYERS.Search */];
-    static getters = ["getSearchMatches", "getCurrentSelectedMatchIndex"];
-    searchMatches = [];
+    static getters = [
+        "getSearchMatches",
+        "getCurrentSelectedMatchIndex",
+        "getSearchOptions",
+        "getAllSheetMatchesCount",
+        "getActiveSheetMatchesCount",
+        "getSpecificRangeMatchesCount",
+    ];
+    allSheetsMatches = [];
+    activeSheetMatches = [];
+    specificRangeMatches = [];
+    // fixme: why do we make selectedMatchIndex on top of a selected
+    // property in the matches?
     selectedMatchIndex = null;
     currentSearchRegex = null;
     searchOptions = {
         matchCase: false,
         exactMatch: false,
         searchFormulas: false,
+        searchScope: "allSheets",
+        specificRange: undefined,
     };
     toSearch = "";
     isSearchDirty = false;
+    get searchMatches() {
+        switch (this.searchOptions.searchScope) {
+            case "allSheets":
+                return this.allSheetsMatches;
+            case "activeSheet":
+                return this.activeSheetMatches;
+            case "specificRange":
+                return this.specificRangeMatches;
+        }
+    }
     // ---------------------------------------------------------------------------
     // Command Handling
     // ---------------------------------------------------------------------------
     handle(cmd) {
         switch (cmd.type) {
             case "UPDATE_SEARCH":
-                this.updateSearch(cmd.toSearch, cmd.searchOptions);
+                const rangeData = cmd.searchOptions.specificRange;
+                const specificRange = rangeData && this.getters.getRangeFromRangeData(rangeData);
+                this.updateSearch(cmd.toSearch, { ...cmd.searchOptions, specificRange });
                 break;
             case "CLEAR_SEARCH":
                 this.clearSearch();
@@ -44100,7 +44340,9 @@ class FindAndReplacePlugin extends UIPlugin {
                 this.isSearchDirty = true;
                 break;
             case "ACTIVATE_SHEET":
-                this.refreshSearch();
+                if (this.searchOptions.searchScope === "activeSheet") {
+                    this.isSearchDirty = true;
+                }
                 break;
         }
     }
@@ -44119,6 +44361,18 @@ class FindAndReplacePlugin extends UIPlugin {
     getCurrentSelectedMatchIndex() {
         return this.selectedMatchIndex;
     }
+    getSearchOptions() {
+        return { ...this.searchOptions, specificRange: this.searchOptions.specificRange?.rangeData };
+    }
+    getAllSheetMatchesCount() {
+        return this.allSheetsMatches.length;
+    }
+    getActiveSheetMatchesCount() {
+        return this.activeSheetMatches.length;
+    }
+    getSpecificRangeMatchesCount() {
+        return this.specificRangeMatches.length;
+    }
     // ---------------------------------------------------------------------------
     // Search
     // ---------------------------------------------------------------------------
@@ -44139,8 +44393,8 @@ class FindAndReplacePlugin extends UIPlugin {
      * refresh the matches according to the current search options
      */
     refreshSearch() {
-        const matches = this.findMatches();
-        this.searchMatches = matches;
+        this.selectedMatchIndex = null;
+        this.findMatches();
         this.selectNextCell(Direction.current);
     }
     /**
@@ -44155,45 +44409,65 @@ class FindAndReplacePlugin extends UIPlugin {
         }
         this.currentSearchRegex = RegExp(searchValue, flags);
     }
+    getSheetsInSearchOrder() {
+        switch (this.searchOptions.searchScope) {
+            case "allSheets":
+                const sheetIds = this.getters.getSheetIds();
+                const activeSheetIndex = sheetIds.findIndex((id) => id === this.getters.getActiveSheetId());
+                return [
+                    sheetIds[activeSheetIndex],
+                    ...sheetIds.slice(activeSheetIndex + 1),
+                    ...sheetIds.slice(0, activeSheetIndex),
+                ];
+            case "activeSheet":
+                return [this.getters.getActiveSheetId()];
+            case "specificRange":
+                const specificRange = this.searchOptions.specificRange;
+                if (!specificRange) {
+                    return [];
+                }
+                return specificRange ? [specificRange.sheetId] : [];
+        }
+    }
     /**
      * Find matches using the current regex
      */
     findMatches() {
-        const sheetId = this.getters.getActiveSheetId();
-        const cells = this.getters.getCells(sheetId);
         const matches = [];
-        if (this.toSearch && this.currentSearchRegex) {
-            for (const cell of Object.values(cells)) {
-                const { col, row } = this.getters.getCellPosition(cell.id);
-                const cellPosition = { sheetId, col, row };
+        if (this.toSearch) {
+            for (const sheetId of this.getters.getSheetIds()) {
+                matches.push(...this.findMatchesInSheet(sheetId));
+            }
+        }
+        // set results
+        this.allSheetsMatches = matches;
+        this.activeSheetMatches = matches.filter((match) => match.sheetId === this.getters.getActiveSheetId());
+        if (this.searchOptions.specificRange) {
+            const { sheetId, zone } = this.searchOptions.specificRange;
+            this.specificRangeMatches = matches.filter((match) => match.sheetId === sheetId && isInside(match.col, match.row, zone));
+        }
+        else {
+            this.specificRangeMatches = [];
+        }
+    }
+    findMatchesInSheet(sheetId) {
+        const matches = [];
+        const { left, right, top, bottom } = this.getters.getSheetZone(sheetId);
+        for (let row = top; row <= bottom; row++) {
+            for (let col = left; col <= right; col++) {
                 const isColHidden = this.getters.isColHidden(sheetId, col);
                 const isRowHidden = this.getters.isRowHidden(sheetId, row);
                 if (isColHidden || isRowHidden) {
                     continue;
                 }
-                if (this.currentSearchRegex.test(this.getSearchableString(cellPosition))) {
-                    const match = { col, row, selected: false };
+                const cellPosition = { sheetId, col, row };
+                if (this.currentSearchRegex?.test(this.getSearchableString(cellPosition))) {
+                    const match = { sheetId, col, row };
                     matches.push(match);
                 }
-                for (const spreadPosition of this.getters.getSpreadPositionsOf(cellPosition)) {
-                    if (this.currentSearchRegex.test(this.getSearchableString(spreadPosition))) {
-                        const match = {
-                            col: spreadPosition.col,
-                            row: spreadPosition.row,
-                            selected: false,
-                        };
-                        matches.push(match);
-                    }
-                }
             }
         }
-        return matches.sort(this.sortByRowThenColumn);
-    }
-    sortByRowThenColumn(a, b) {
-        if (a.row === b.row) {
-            return a.col - b.col;
-        }
-        return a.row > b.row ? 1 : -1;
+        return matches;
     }
     /**
      * Changes the selected search cell. Given a direction it will
@@ -44211,30 +44485,47 @@ class FindAndReplacePlugin extends UIPlugin {
         }
         let nextIndex;
         if (this.selectedMatchIndex === null) {
-            nextIndex = 0;
+            let nextMatchIndex = -1;
+            // if search is not available in current sheet will select in next sheet
+            for (const sheetId of this.getSheetsInSearchOrder()) {
+                nextMatchIndex = matches.findIndex((match) => match.sheetId === sheetId);
+                if (nextMatchIndex !== -1) {
+                    break;
+                }
+            }
+            nextIndex = nextMatchIndex;
         }
         else {
             nextIndex = this.selectedMatchIndex + indexChange;
         }
-        //modulo of negative value to be able to cycle in both directions with previous and next
-        nextIndex = ((nextIndex % matches.length) + matches.length) % matches.length;
+        // loop index value inside the array (index -1 => last index)
+        nextIndex = (nextIndex + matches.length) % matches.length;
         this.selectedMatchIndex = nextIndex;
+        const selectedMatch = matches[nextIndex];
+        // Switch to the sheet where the match is located
+        if (this.getters.getActiveSheetId() !== selectedMatch.sheetId) {
+            this.dispatch("ACTIVATE_SHEET", {
+                sheetIdFrom: this.getters.getActiveSheetId(),
+                sheetIdTo: selectedMatch.sheetId,
+            });
+        }
         // we want grid selection to capture the selection stream
         this.selection.getBackToDefault();
-        this.selection.selectCell(matches[nextIndex].col, matches[nextIndex].row);
-        for (let index = 0; index < this.searchMatches.length; index++) {
-            this.searchMatches[index].selected = index === this.selectedMatchIndex;
-        }
+        this.selection.selectCell(selectedMatch.col, selectedMatch.row);
     }
     clearSearch() {
         this.toSearch = "";
-        this.searchMatches = [];
         this.selectedMatchIndex = null;
         this.currentSearchRegex = null;
+        this.allSheetsMatches = [];
+        this.activeSheetMatches = [];
+        this.specificRangeMatches = [];
         this.searchOptions = {
             matchCase: false,
             exactMatch: false,
             searchFormulas: false,
+            searchScope: "allSheets",
+            specificRange: undefined,
         };
     }
     // ---------------------------------------------------------------------------
@@ -44244,9 +44535,7 @@ class FindAndReplacePlugin extends UIPlugin {
         if (!this.currentSearchRegex) {
             return;
         }
-        const sheetId = this.getters.getActiveSheetId();
-        const position = { sheetId, ...selectedMatch };
-        const cell = this.getters.getCell(position);
+        const cell = this.getters.getCell(selectedMatch);
         if (!cell?.content) {
             return;
         }
@@ -44254,10 +44543,10 @@ class FindAndReplacePlugin extends UIPlugin {
             return;
         }
         const replaceRegex = new RegExp(this.currentSearchRegex.source, this.currentSearchRegex.flags + "g");
-        const toReplace = this.getSearchableString(position);
+        const toReplace = this.getSearchableString(selectedMatch);
         const content = toReplace.replace(replaceRegex, replaceWith);
         const canonicalContent = canonicalizeNumberContent(content, this.getters.getLocale());
-        this.dispatch("UPDATE_CELL", { ...position, content: canonicalContent });
+        this.dispatch("UPDATE_CELL", { ...selectedMatch, content: canonicalContent });
     }
     /**
      * Replace the value of the currently selected match
@@ -44288,7 +44577,10 @@ class FindAndReplacePlugin extends UIPlugin {
     drawGrid(renderingContext) {
         const { ctx } = renderingContext;
         const sheetId = this.getters.getActiveSheetId();
-        for (const match of this.searchMatches) {
+        for (const [index, match] of this.searchMatches.entries()) {
+            if (match.sheetId !== sheetId) {
+                continue; // Skip drawing matches from other sheets
+            }
             const merge = this.getters.getMerge({ sheetId, col: match.col, row: match.row });
             const left = merge ? merge.left : match.col;
             const right = merge ? merge.right : match.col;
@@ -44298,12 +44590,21 @@ class FindAndReplacePlugin extends UIPlugin {
             if (width > 0 && height > 0) {
                 ctx.fillStyle = BACKGROUND_COLOR;
                 ctx.fillRect(x, y, width, height);
-                if (match.selected) {
+                if (index === this.selectedMatchIndex) {
                     ctx.strokeStyle = BORDER_COLOR;
                     ctx.strokeRect(x, y, width, height);
                 }
             }
         }
+        if (this.searchOptions.searchScope === "specificRange") {
+            const range = this.searchOptions.specificRange;
+            if (!range || range.sheetId !== sheetId) {
+                return;
+            }
+            const { x, y, width, height } = this.getters.getVisibleRect(range.zone);
+            ctx.strokeStyle = BORDER_COLOR;
+            ctx.strokeRect(x, y, width, height);
+        }
     }
 }
 
@@ -46769,11 +47070,14 @@ class ClipboardPlugin extends UIPlugin {
                 }
                 const pasteOption = cmd.pasteOption || (this.paintFormatStatus !== "inactive" ? "onlyFormat" : undefined);
                 this.state.paste(cmd.target, { pasteOption, shouldPasteCF: true, selectTarget: true });
+                if (this.state.operation === "CUT") {
+                    this.state = undefined;
+                }
                 this.lastPasteState = this.state;
                 if (this.paintFormatStatus === "oneOff") {
                     this.paintFormatStatus = "inactive";
-                    this.status = "invisible";
                 }
+                this.status = "invisible";
                 break;
             case "COPY_PASTE_CELLS_ABOVE":
                 {
@@ -47000,92 +47304,6 @@ class ClipboardPlugin extends UIPlugin {
     }
 }
 
-/**
- * Change the reference types inside the given token, if the token represent a range or a cell
- *
- * Eg. :
- *   A1 => $A$1 => A$1 => $A1 => A1
- *   A1:$B$1 => $A$1:B$1 => A$1:$B1 => $A1:B1 => A1:$B$1
- */
-function loopThroughReferenceType(token) {
-    if (token.type !== "REFERENCE")
-        return token;
-    const { xc, sheetName } = splitReference(token.value);
-    const [left, right] = xc.split(":");
-    const sheetRef = sheetName ? `${getCanonicalSheetName(sheetName)}!` : "";
-    const updatedLeft = getTokenNextReferenceType(left);
-    const updatedRight = right ? `:${getTokenNextReferenceType(right)}` : "";
-    return { ...token, value: sheetRef + updatedLeft + updatedRight };
-}
-/**
- * Get a new token with a changed type of reference from the given cell token symbol.
- * Undefined behavior if given a token other than a cell or if the Xc contains a sheet reference
- *
- * A1 => $A$1 => A$1 => $A1 => A1
- */
-function getTokenNextReferenceType(xc) {
-    switch (getReferenceType(xc)) {
-        case "none":
-            xc = setXcToReferenceType(xc, "colrow");
-            break;
-        case "colrow":
-            xc = setXcToReferenceType(xc, "row");
-            break;
-        case "row":
-            xc = setXcToReferenceType(xc, "col");
-            break;
-        case "col":
-            xc = setXcToReferenceType(xc, "none");
-            break;
-    }
-    return xc;
-}
-/**
- * Returns the given XC with the given reference type.
- */
-function setXcToReferenceType(xc, referenceType) {
-    xc = xc.replace(/\$/g, "");
-    let indexOfNumber;
-    switch (referenceType) {
-        case "col":
-            return "$" + xc;
-        case "row":
-            indexOfNumber = xc.search(/[0-9]/);
-            return xc.slice(0, indexOfNumber) + "$" + xc.slice(indexOfNumber);
-        case "colrow":
-            indexOfNumber = xc.search(/[0-9]/);
-            xc = xc.slice(0, indexOfNumber) + "$" + xc.slice(indexOfNumber);
-            return "$" + xc;
-        case "none":
-            return xc;
-    }
-}
-/**
- * Return the type of reference used in the given XC of a cell.
- * Undefined behavior if the XC have a sheet reference
- */
-function getReferenceType(xcCell) {
-    if (isColAndRowFixed(xcCell)) {
-        return "colrow";
-    }
-    else if (isColFixed(xcCell)) {
-        return "col";
-    }
-    else if (isRowFixed(xcCell)) {
-        return "row";
-    }
-    return "none";
-}
-function isColFixed(xc) {
-    return xc.startsWith("$");
-}
-function isRowFixed(xc) {
-    return xc.includes("$", 1);
-}
-function isColAndRowFixed(xc) {
-    return xc.startsWith("$") && xc.length > 1 && xc.slice(1).includes("$");
-}
-
 const CELL_DELETED_MESSAGE = _t("The cell you are trying to edit has been deleted.");
 class EditionPlugin extends UIPlugin {
     static getters = [
@@ -48003,32 +48221,32 @@ const selectionStatisticFunctions = [
     {
         name: _t("Sum"),
         types: [CellValueType.number],
-        compute: (values, locale) => SUM.compute.bind({ locale })([values]),
+        compute: (values, locale) => sum([[values]], locale),
     },
     {
         name: _t("Avg"),
         types: [CellValueType.number],
-        compute: (values, locale) => AVERAGE.compute.bind({ locale })([values]),
+        compute: (values, locale) => average([[values]], locale),
     },
     {
         name: _t("Min"),
         types: [CellValueType.number],
-        compute: (values, locale) => MIN.compute.bind({ locale })([values]),
+        compute: (values, locale) => min([[values]], locale),
     },
     {
         name: _t("Max"),
         types: [CellValueType.number],
-        compute: (values, locale) => MAX.compute.bind({ locale })([values]),
+        compute: (values, locale) => max([[values]], locale),
     },
     {
         name: _t("Count"),
         types: [CellValueType.number, CellValueType.text, CellValueType.boolean, CellValueType.error],
-        compute: (values, locale) => COUNTA.compute.bind({ locale })([values]),
+        compute: (values) => countAny([[values]]),
     },
     {
         name: _t("Count Numbers"),
         types: [CellValueType.number, CellValueType.text, CellValueType.boolean, CellValueType.error],
-        compute: (values, locale) => COUNT.compute.bind({ locale })([values]),
+        compute: (values, locale) => countNumbers([[values]], locale),
     },
 ];
 /**
@@ -51943,6 +52161,7 @@ class Spreadsheet extends owl.Component {
     };
     sidePanel;
     composer;
+    spreadsheetRef = owl.useRef("spreadsheet");
     _focusGrid;
     keyDownMapping;
     isViewportTooSmall = false;
@@ -51977,6 +52196,18 @@ class Spreadsheet extends owl.Component {
             clipboard: this.env.clipboard || instantiateClipboard(),
             startCellEdition: (content) => this.onGridComposerCellFocused(content),
         });
+        owl.useEffect(() => {
+            /**
+             * Only refocus the grid if the active element is not a child of the spreadsheet
+             * (i.e. activeElement is outside of the spreadsheetRef component)
+             * and spreadsheet is a child of that element. Anything else means that the focus
+             * is on an element that needs to keep it.
+             */
+            if (!this.spreadsheetRef.el.contains(document.activeElement) &&
+                document.activeElement?.contains(this.spreadsheetRef.el)) {
+                this.focusGrid();
+            }
+        }, () => [this.env.model.getters.getActiveSheetId()]);
         owl.useExternalListener(window, "resize", () => this.render(true));
         owl.useExternalListener(window, "beforeunload", this.unbindModelEvents.bind(this));
         this.bindModelEvents();
@@ -52058,7 +52289,7 @@ class Spreadsheet extends owl.Component {
     }
     focusGrid() {
         if (!this._focusGrid) {
-            throw new Error("_focusGrid should be exposed by the grid component");
+            return;
         }
         this._focusGrid();
     }
@@ -55451,19 +55682,22 @@ class Model extends EventBus {
      * Check if the given command is allowed by all the plugins and the history.
      */
     checkDispatchAllowed(command) {
-        if (isCoreCommand(command)) {
-            return this.checkDispatchAllowedCoreCommand(command);
+        const results = isCoreCommand(command)
+            ? this.checkDispatchAllowedCoreCommand(command)
+            : this.checkDispatchAllowedLocalCommand(command);
+        if (results.some((r) => r !== "Success" /* CommandResult.Success */)) {
+            return new DispatchResult(results.flat());
         }
-        return this.checkDispatchAllowedLocalCommand(command);
+        return DispatchResult.Success;
     }
     checkDispatchAllowedCoreCommand(command) {
         const results = this.corePlugins.map((handler) => handler.allowDispatch(command));
         results.push(this.range.allowDispatch(command));
-        return new DispatchResult(results.flat());
+        return results;
     }
     checkDispatchAllowedLocalCommand(command) {
         const results = this.uiHandlers.map((handler) => handler.allowDispatch(command));
-        return new DispatchResult(results.flat());
+        return results;
     }
     finalize() {
         this.status = 3 /* Status.Finalizing */;
@@ -55758,6 +55992,7 @@ const components = {
     FigureComponent,
     Menu,
     SelectionInput,
+    ValidationMessages,
 };
 const hooks = {
     useDragAndDropListItems,
@@ -55810,6 +56045,6 @@ exports.setTranslationMethod = setTranslationMethod;
 exports.tokenize = tokenize;
 
 
-__info__.version = "17.1.0-alpha.3";
-__info__.date = "2023-11-16T12:04:09.636Z";
-__info__.hash = "2ef5b1a";
+__info__.version = "17.1.0-alpha.4";
+__info__.date = "2023-11-24T13:12:24.882Z";
+__info__.hash = "255821b";