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

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.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
  */
 
 (function (exports, owl) {
@@ -228,7 +228,6 @@
   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;
@@ -692,8 +691,7 @@
    *
    * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes
    */
-  const whiteSpaceCharacters = [
-      " ",
+  const whiteSpaceSpecialCharacters = [
       "\t",
       "\f",
       "\v",
@@ -708,8 +706,7 @@
       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.
@@ -717,9 +714,9 @@
   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.
@@ -2061,6 +2058,7 @@
       CommandResult["InvalidNumberOfCriterionValues"] = "InvalidNumberOfCriterionValues";
       CommandResult["BlockingValidationRule"] = "BlockingValidationRule";
       CommandResult["InvalidCopyPasteSelection"] = "InvalidCopyPasteSelection";
+      CommandResult["NoChanges"] = "NoChanges";
   })(exports.CommandResult || (exports.CommandResult = {}));
 
   const DEFAULT_LOCALES = [
@@ -2190,12 +2188,12 @@
       }
   }
   /** 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) {
@@ -3428,11 +3426,18 @@
       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
@@ -4541,14 +4546,14 @@
       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;
@@ -4611,6 +4616,7 @@
       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,
@@ -4629,6 +4635,7 @@
           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,
@@ -6984,11 +6991,9 @@
     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;
@@ -6999,20 +7004,12 @@
         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,
@@ -7355,7 +7352,7 @@
       return result;
   }
   function tokenizeDebugger(chars) {
-      if (chars.current() === "?") {
+      if (chars.current === "?") {
           chars.shift();
           return { type: "DEBUGGER", value: "?" };
       }
@@ -7366,7 +7363,7 @@
       ")": "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 };
@@ -7374,7 +7371,7 @@
       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 };
@@ -7399,14 +7396,13 @@
       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 {
@@ -7433,14 +7429,14 @@
       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;
                   }
@@ -7456,7 +7452,7 @@
               };
           }
       }
-      while (chars.current() && separatorRegexp.test(chars.current())) {
+      while (chars.current && separatorRegexp.test(chars.current)) {
           result += chars.shift();
       }
       if (result.length) {
@@ -7471,14 +7467,14 @@
   }
   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();
       }
@@ -7497,17 +7493,20 @@
   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;
@@ -11311,7 +11310,7 @@
       ) {
           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]);
@@ -11800,6 +11799,10 @@
     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;
@@ -12751,7 +12754,7 @@
           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,
   };
@@ -12920,6 +12923,44 @@
       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 = [];
@@ -13190,13 +13231,7 @@
           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,
   };
@@ -13354,24 +13389,7 @@
       ],
       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,
   };
@@ -13386,7 +13404,7 @@
       ],
       returns: ["NUMBER"],
       compute: function (...values) {
-          return reduceAny(values, (acc, a) => (a !== undefined && a !== null ? acc + 1 : acc), 0);
+          return countAny(values);
       },
       isExported: true,
   };
@@ -13616,8 +13634,7 @@
           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,
   };
@@ -13704,8 +13721,7 @@
           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,
   };
@@ -17876,6 +17892,149 @@
     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
   // -----------------------------------------------------------------------------
@@ -18031,6 +18190,7 @@
 
   var info = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    CELL: CELL,
     ISBLANK: ISBLANK,
     ISERR: ISERR,
     ISERROR: ISERROR,
@@ -18322,7 +18482,7 @@
               cellReference = rowPart + colPart;
           }
           if (sheet !== undefined) {
-              return `${getCanonicalSheetName(toString(sheet))}!${cellReference}`;
+              return getFullReference(toString(sheet), cellReference);
           }
           return cellReference;
       },
@@ -18338,7 +18498,7 @@
       ],
       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;
@@ -18505,7 +18665,7 @@
       ],
       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;
@@ -23857,31 +24017,65 @@
 `;
   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) {
@@ -23898,11 +24092,36 @@
               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");
@@ -23910,10 +24129,14 @@
       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() {
@@ -23925,28 +24148,14 @@
       }
       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,
@@ -27092,7 +27301,7 @@
       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;
@@ -28535,22 +28744,15 @@
       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 = {
@@ -28660,8 +28862,8 @@
               dimension: "COL",
           });
       }
-      unhideStyleValue(hiddenIndex) {
-          return this._getDimensionsInViewport(hiddenIndex).start;
+      getUnhideButtonStyle(hiddenIndex) {
+          return cssPropertiesToCss({ left: this._getDimensionsInViewport(hiddenIndex).start + "px" });
       }
   }
   css /* scss */ `
@@ -28707,18 +28909,9 @@
       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};
@@ -28833,8 +29026,8 @@
               elements: hiddenElements,
           });
       }
-      unhideStyleValue(hiddenIndex) {
-          return this._getDimensionsInViewport(hiddenIndex).start;
+      getUnhideButtonStyle(hiddenIndex) {
+          return cssPropertiesToCss({ top: this._getDimensionsInViewport(hiddenIndex).start + "px" });
       }
   }
   css /* scss */ `
@@ -29341,7 +29534,6 @@
           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;
@@ -29778,6 +29970,7 @@
               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);
@@ -29785,7 +29978,7 @@
               else {
                   interactivePasteFromOS(this.env, target, content);
               }
-              if (this.env.model.getters.isCutOperation()) {
+              if (isCutOperation) {
                   await this.env.clipboard.write({ [ClipboardMIMEType.PlainText]: "" });
               }
           }
@@ -31398,12 +31591,6 @@
   }
   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;
@@ -31416,7 +31603,7 @@
           }
       }
       const dataXC = zoneToXc(zone);
-      return sheetName + dataXC;
+      return getFullReference(sheetName, dataXC);
   }
 
   /**
@@ -34079,6 +34266,14 @@
       // ---------------------------------------------------------------------------
       // 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":
@@ -34498,6 +34693,14 @@
               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
       // ---------------------------------------------------------------------------
@@ -35324,7 +35527,6 @@
       static getters = [
           "zoneToXC",
           "getCells",
-          "getFormulaCellContent",
           "getTranslatedCellFormula",
           "getCellStyle",
           "getCellById",
@@ -35353,8 +35555,9 @@
       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 */;
           }
@@ -35523,24 +35726,18 @@
        */
       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;
@@ -35761,13 +35958,23 @@
               },
           };
       }
-      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;
@@ -36457,6 +36664,9 @@
           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)) {
@@ -37629,7 +37839,7 @@
           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;
       }
@@ -39054,10 +39264,13 @@
           // 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) {
@@ -39079,8 +39292,6 @@
           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");
           }
@@ -39181,35 +39392,20 @@
               }
           }
       }
-      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
        *
@@ -39736,6 +39932,7 @@
       getters;
       computeCell;
       evalContext;
+      rangeCache = {};
       constructor(context, getters, computeCell) {
           this.getters = getters;
           this.computeCell = computeCell;
@@ -39758,7 +39955,8 @@
       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();
@@ -39821,17 +40019,24 @@
           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;
       }
   }
@@ -40037,6 +40242,7 @@
           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) {
@@ -40080,6 +40286,16 @@
           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()) {
@@ -40106,6 +40322,7 @@
           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) {
@@ -40129,7 +40346,8 @@
           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() });
           }
@@ -40140,7 +40358,7 @@
               }
               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) {
@@ -40166,14 +40384,9 @@
           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,
@@ -40375,6 +40588,18 @@
           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
   // ---------------------------------------------------------------------------
@@ -40469,7 +40694,6 @@
   // of other cells depending on it, at the next iteration.
   //#endregion
   class EvaluationPlugin extends UIPlugin {
-      config;
       static getters = [
           "evaluateFormula",
           "getCorrespondingFormulaCell",
@@ -40480,15 +40704,13 @@
           "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);
       }
       // ---------------------------------------------------------------------------
@@ -40513,10 +40735,6 @@
               case "EVALUATE_CELLS":
                   this.evaluator.evaluateAllCells();
                   break;
-              case "UPDATE_LOCALE":
-                  this.compilationParams = this.getCompilationParameters();
-                  this.evaluator.updateCompilationParameters();
-                  break;
           }
       }
       finalize() {
@@ -40534,16 +40752,7 @@
       // 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.
@@ -40592,6 +40801,9 @@
       getSpreadPositionsOf(position) {
           return this.evaluator.getSpreadPositionsOf(position);
       }
+      getArrayFormulaSpreadingOn(position) {
+          return this.evaluator.getArrayFormulaSpreadingOn(position);
+      }
       // ---------------------------------------------------------------------------
       // Export
       // ---------------------------------------------------------------------------
@@ -40635,7 +40847,7 @@
           else if (cell && cell.content) {
               return undefined;
           }
-          const spreadingFormulaPosition = this.evaluator.getArrayFormulaSpreadingOn(position);
+          const spreadingFormulaPosition = this.getArrayFormulaSpreadingOn(position);
           if (spreadingFormulaPosition === undefined) {
               return undefined;
           }
@@ -40645,9 +40857,6 @@
           }
           return undefined;
       }
-      getCompilationParameters() {
-          return buildCompilationParameters(this.config.custom, this.getters, (position) => this.evaluator.getEvaluatedCell(position));
-      }
   }
   function isBadExpression(tokens) {
       try {
@@ -43346,11 +43555,26 @@
               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,
                   });
               }
@@ -43472,13 +43696,6 @@
               });
           }
           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.
@@ -43552,7 +43769,7 @@
       clearClippedZones() {
           for (const row of this.cells) {
               for (const cell of row) {
-                  if (cell.cell) {
+                  if (cell?.cell) {
                       this.dispatch("CLEAR_CELL", cell.position);
                   }
               }
@@ -43578,6 +43795,9 @@
               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
@@ -43601,53 +43821,42 @@
       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);
           }
       }
       /**
@@ -43709,22 +43918,28 @@
           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>";
               }
@@ -44052,24 +44267,49 @@
    */
   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();
@@ -44099,7 +44339,9 @@
                   this.isSearchDirty = true;
                   break;
               case "ACTIVATE_SHEET":
-                  this.refreshSearch();
+                  if (this.searchOptions.searchScope === "activeSheet") {
+                      this.isSearchDirty = true;
+                  }
                   break;
           }
       }
@@ -44118,6 +44360,18 @@
       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
       // ---------------------------------------------------------------------------
@@ -44138,8 +44392,8 @@
        * 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);
       }
       /**
@@ -44154,45 +44408,65 @@
           }
           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
@@ -44210,30 +44484,47 @@
           }
           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,
           };
       }
       // ---------------------------------------------------------------------------
@@ -44243,9 +44534,7 @@
           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;
           }
@@ -44253,10 +44542,10 @@
               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
@@ -44287,7 +44576,10 @@
       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;
@@ -44297,12 +44589,21 @@
               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);
+          }
       }
   }
 
@@ -46768,11 +47069,14 @@
                   }
                   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":
                   {
@@ -46999,92 +47303,6 @@
       }
   }
 
-  /**
-   * 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 = [
@@ -48002,32 +48220,32 @@
       {
           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),
       },
   ];
   /**
@@ -51942,6 +52160,7 @@
       };
       sidePanel;
       composer;
+      spreadsheetRef = owl.useRef("spreadsheet");
       _focusGrid;
       keyDownMapping;
       isViewportTooSmall = false;
@@ -51976,6 +52195,18 @@
               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();
@@ -52057,7 +52288,7 @@
       }
       focusGrid() {
           if (!this._focusGrid) {
-              throw new Error("_focusGrid should be exposed by the grid component");
+              return;
           }
           this._focusGrid();
       }
@@ -55450,19 +55681,22 @@
        * 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 */;
@@ -55757,6 +55991,7 @@
       FigureComponent,
       Menu,
       SelectionInput,
+      ValidationMessages,
   };
   const hooks = {
       useDragAndDropListItems,
@@ -55809,9 +56044,9 @@
   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";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);