@odoo/o-spreadsheet 18.4.8 → 18.4.10

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.4.8
- * @date 2025-08-26T10:14:08.954Z
- * @hash 746217a
+ * @version 18.4.10
+ * @date 2025-09-11T08:45:39.178Z
+ * @hash 15a11a4
  */
 
 (function (exports, owl) {
@@ -2644,6 +2644,7 @@
       "AUTOFILL_CELL",
       "SET_BORDER",
       "SET_ZONE_BORDERS",
+      "SET_BORDERS_ON_TARGET",
   ]);
   const readonlyAllowedCommands = new Set([
       "START",
@@ -3990,6 +3991,10 @@
       }
       return true;
   }
+  const noValidInputErrorMessage = _t("[[FUNCTION_NAME]] has no valid input data.");
+  function emptyDataErrorMessage(argName) {
+      return _t("[[FUNCTION_NAME]] expects the provided values of %(argName)s to be a non-empty matrix.", { argName });
+  }
 
   function tokenizeFormat(str) {
       const chars = new TokenizingChars(str);
@@ -6591,40 +6596,44 @@
       };
   }
   function getRangeAdapter(cmd) {
-      switch (cmd.type) {
-          case "REMOVE_COLUMNS_ROWS":
-              return {
-                  applyChange: getApplyRangeChangeRemoveColRow(cmd),
-                  sheetId: cmd.sheetId,
-                  sheetName: cmd.sheetName,
-              };
-          case "ADD_COLUMNS_ROWS":
-              return {
-                  applyChange: getApplyRangeChangeAddColRow(cmd),
-                  sheetId: cmd.sheetId,
-                  sheetName: cmd.sheetName,
-              };
-          case "DELETE_SHEET":
-              return {
-                  applyChange: getApplyRangeChangeDeleteSheet(cmd),
-                  sheetId: cmd.sheetId,
-                  sheetName: cmd.sheetName,
-              };
-          case "RENAME_SHEET":
-              return {
-                  applyChange: getApplyRangeChangeRenameSheet(cmd),
-                  sheetId: cmd.sheetId,
-                  sheetName: cmd.oldName,
-              };
-          case "MOVE_RANGES":
-              return {
-                  applyChange: getApplyRangeChangeMoveRange(cmd),
-                  sheetId: cmd.sheetId,
-                  sheetName: cmd.sheetName,
-              };
+      return rangeAdapterRegistry.get(cmd.type)?.(cmd);
+  }
+  class RangeAdapterRegistry extends Registry {
+      add(cmdType, fn) {
+          super.add(cmdType, fn);
+          return this;
+      }
+      get(cmdType) {
+          return this.content[cmdType];
       }
-      return undefined;
   }
+  const rangeAdapterRegistry = new RangeAdapterRegistry();
+  rangeAdapterRegistry
+      .add("REMOVE_COLUMNS_ROWS", (cmd) => ({
+      applyChange: getApplyRangeChangeRemoveColRow(cmd),
+      sheetId: cmd.sheetId,
+      sheetName: { old: cmd.sheetName, current: cmd.sheetName },
+  }))
+      .add("ADD_COLUMNS_ROWS", (cmd) => ({
+      applyChange: getApplyRangeChangeAddColRow(cmd),
+      sheetId: cmd.sheetId,
+      sheetName: { old: cmd.sheetName, current: cmd.sheetName },
+  }))
+      .add("DELETE_SHEET", (cmd) => ({
+      applyChange: getApplyRangeChangeDeleteSheet(cmd),
+      sheetId: cmd.sheetId,
+      sheetName: { old: cmd.sheetName, current: cmd.sheetName },
+  }))
+      .add("RENAME_SHEET", (cmd) => ({
+      applyChange: getApplyRangeChangeRenameSheet(cmd),
+      sheetId: cmd.sheetId,
+      sheetName: { old: cmd.oldName, current: cmd.newName },
+  }))
+      .add("MOVE_RANGES", (cmd) => ({
+      applyChange: getApplyRangeChangeMoveRange(cmd),
+      sheetId: cmd.sheetId,
+      sheetName: { old: cmd.sheetName, current: cmd.sheetName },
+  }));
   function getApplyRangeChangeRemoveColRow(cmd) {
       const start = cmd.dimension === "COL" ? "left" : "top";
       const end = cmd.dimension === "COL" ? "right" : "bottom";
@@ -7346,7 +7355,7 @@
           this.getters = getters;
           this.dispatch = dispatch;
       }
-      copy(data, isCutOperation) {
+      copy(data, isCutOperation, mode = "copyPaste") {
           return;
       }
       paste(target, clippedContent, options) { }
@@ -7365,7 +7374,7 @@
   }
 
   class AbstractCellClipboardHandler extends ClipboardHandler {
-      copy(data) {
+      copy(data, isCutOperation, mode = "copyPaste") {
           return;
       }
       pasteFromCopy(sheetId, target, content, options) {
@@ -8001,8 +8010,11 @@
       // (a) Swap 2 rows. This multiply the determinant by -1.
       // (b) Multiply a row by a scalar. This multiply the determinant by that scalar.
       // (c) Add to a row a multiple of another row. This does not change the determinant.
+      if (M.length < 1 || M[0].length < 1) {
+          throw new Error("invertMatrix: an empty matrix cannot be inverted.");
+      }
       if (M.length !== M[0].length) {
-          throw new EvaluationError(_t("Function [[FUNCTION_NAME]] invert matrix error, only square matrices are invertible"));
+          throw new Error("invertMatrix: only square matrices are invertible");
       }
       let determinant = 1;
       const dim = M.length;
@@ -8071,8 +8083,11 @@
    * Note: we use indexing [col][row] instead of the standard mathematical notation [row][col]
    */
   function multiplyMatrices(matrix1, matrix2) {
+      if (matrix1.length < 1 || matrix2.length < 1) {
+          throw new Error("multiplyMatrices: empty matrices cannot be multiplied.");
+      }
       if (matrix1.length !== matrix2[0].length) {
-          throw new EvaluationError(_t("Cannot multiply matrices : incompatible matrices size."));
+          throw new Error("multiplyMatrices: incompatible matrices size.");
       }
       const rowsM1 = matrix1[0].length;
       const colsM2 = matrix2.length;
@@ -8098,7 +8113,7 @@
           return arg;
       }
       if (!isSingleElementMatrix(arg)) {
-          throw new EvaluationError(_t("The value should be a scalar or a 1x1 matrix"));
+          throw new Error("The value should be a scalar or a 1x1 matrix");
       }
       return arg[0][0];
   }
@@ -8889,7 +8904,7 @@
           }
           return "Success" /* CommandResult.Success */;
       }
-      copy(data) {
+      copy(data, isCutOperation, mode = "copyPaste") {
           const sheetId = data.sheetId;
           const { clippedZones, rowsIndexes, columnsIndexes } = data;
           const clippedCells = [];
@@ -8902,7 +8917,7 @@
                   const evaluatedCell = this.getters.getEvaluatedCell(position);
                   const pivotId = this.getters.getPivotIdFromPosition(position);
                   const spreader = this.getters.getArrayFormulaSpreadingOn(position);
-                  if (pivotId && spreader) {
+                  if (mode !== "shiftCells" && pivotId && spreader) {
                       const pivotZone = this.getters.getSpreadZone(spreader);
                       if ((!deepEquals(spreader, position) || !isCopyingOneCell) &&
                           pivotZone &&
@@ -8920,7 +8935,7 @@
                           };
                       }
                   }
-                  else {
+                  else if (mode !== "shiftCells") {
                       if (spreader && !deepEquals(spreader, position)) {
                           const isSpreaderCopied = rowsIndexes.includes(spreader.row) && columnsIndexes.includes(spreader.col);
                           const content = isSpreaderCopied
@@ -9618,7 +9633,7 @@
   }
 
   class TableClipboardHandler extends AbstractCellClipboardHandler {
-      copy(data, isCutOperation) {
+      copy(data, isCutOperation, mode = "copyPaste") {
           const sheetId = data.sheetId;
           const { rowsIndexes, columnsIndexes, zones } = data;
           const copiedTablesIds = new Set();
@@ -9656,11 +9671,13 @@
                           type: coreTable.type,
                       };
                   }
-                  tableCellsInRow.push({
-                      table: copiedTable,
-                      style: this.getTableStyleToCopy(position),
-                      isWholeTableCopied: copiedTablesIds.has(table.id),
-                  });
+                  if (mode !== "shiftCells") {
+                      tableCellsInRow.push({
+                          table: copiedTable,
+                          style: this.getTableStyleToCopy(position),
+                          isWholeTableCopied: copiedTablesIds.has(table.id),
+                      });
+                  }
               }
           }
           return {
@@ -11237,6 +11254,9 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (matrix1, matrix2) {
           const _matrix1 = toNumberMatrix(matrix1, "matrix1");
           const _matrix2 = toNumberMatrix(matrix2, "matrix2");
+          if (_matrix1.length === 0 || _matrix2.length === 0) {
+              return new EvaluationError(_t("The first and second arguments of [[FUNCTION_NAME]] must be non-empty matrices."));
+          }
           if (_matrix1.length !== _matrix2[0].length) {
               return new EvaluationError(_t("In [[FUNCTION_NAME]], the number of columns of the first matrix (%s) must be equal to the \
           number of rows of the second matrix (%s).", _matrix1.length.toString(), _matrix2[0].length.toString()));
@@ -12849,7 +12869,7 @@ stores.inject(MyMetaStore, storeInstance);
               count++;
           }
       });
-      assert(count !== 0, _t("[[FUNCTION_NAME]] has no valid input data."));
+      assert(count !== 0, noValidInputErrorMessage);
       if (!isInclusive) {
           // 2nd argument must be between 1/(n+1) and n/(n+1) with n the number of data
           assert(1 / (count + 1) <= _percent && _percent <= count / (count + 1), _t("Function [[FUNCTION_NAME]] parameter 2 value is out of range."));
@@ -13124,6 +13144,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (x, dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          if (flatDataX.length === 0 || flatDataY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
+          }
           return predictLinearValues([flatDataY], [flatDataX], matrixMap(toMatrix(x), (value) => toNumber(value, this.locale)), true);
       },
       isExported: true,
@@ -13140,6 +13163,9 @@ stores.inject(MyMetaStore, storeInstance);
           arg("b (boolean, default=TRUE)", _t("Given a general exponential form of y = b*m^x for a curve fit, calculates b if TRUE or forces b to be 1 and only calculates the m values if FALSE.")),
       ],
       compute: function (knownDataY, knownDataX = [[]], newDataX = [[]], b = { value: true }) {
+          if (knownDataY.length === 0 || knownDataY[0].length === 0) {
+              return new EvaluationError(emptyDataErrorMessage("known_data_y"));
+          }
           return expM(predictLinearValues(logM(toNumberMatrix(knownDataY, "the first argument (known_data_y)")), toNumberMatrix(knownDataX, "the second argument (known_data_x)"), toNumberMatrix(newDataX, "the third argument (new_data_y)"), toBoolean(b)));
       },
   };
@@ -13154,6 +13180,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          if (flatDataX.length === 0 || flatDataY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
+          }
           const [[], [intercept]] = fullLinearRegression([flatDataX], [flatDataY]);
           return intercept;
       },
@@ -13186,7 +13215,7 @@ stores.inject(MyMetaStore, storeInstance);
           });
           const result = largests.shift();
           if (result === undefined) {
-              return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+              return new EvaluationError(noValidInputErrorMessage);
           }
           if (count < _n) {
               return new EvaluationError(_t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
@@ -13207,6 +13236,9 @@ stores.inject(MyMetaStore, storeInstance);
           arg("verbose (boolean, default=FALSE)", _t("A flag specifying whether to return additional regression statistics or only the linear coefficients and the y-intercept")),
       ],
       compute: function (dataY, dataX = [[]], calculateB = { value: true }, verbose = { value: false }) {
+          if (dataY.length === 0 || dataY[0].length === 0) {
+              return new EvaluationError(emptyDataErrorMessage("data_y"));
+          }
           return fullLinearRegression(toNumberMatrix(dataX, "the first argument (data_y)"), toNumberMatrix(dataY, "the second argument (data_x)"), toBoolean(calculateB), toBoolean(verbose));
       },
       isExported: true,
@@ -13223,6 +13255,9 @@ stores.inject(MyMetaStore, storeInstance);
           arg("verbose (boolean, default=FALSE)", _t("A flag specifying whether to return additional regression statistics or only the linear coefficients and the y-intercept")),
       ],
       compute: function (dataY, dataX = [[]], calculateB = { value: true }, verbose = { value: false }) {
+          if (dataY.length === 0 || dataY[0].length === 0) {
+              return new EvaluationError(emptyDataErrorMessage("data_y"));
+          }
           const coeffs = fullLinearRegression(toNumberMatrix(dataX, "the second argument (data_x)"), logM(toNumberMatrix(dataY, "the first argument (data_y)")), toBoolean(calculateB), toBoolean(verbose));
           for (let i = 0; i < coeffs.length; i++) {
               coeffs[i][0] = Math.exp(coeffs[i][0]);
@@ -13244,8 +13279,8 @@ stores.inject(MyMetaStore, storeInstance);
           const flatX = dataX.flat();
           const flatY = dataY.flat();
           assertSameNumberOfElements(flatX, flatY);
-          if (flatX.length === 0) {
-              return new EvaluationError(_t("[[FUNCTION_NAME]] expects non-empty ranges for both parameters."));
+          if (flatX.length === 0 || flatY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
           }
           const n = flatX.length;
           let trueN = 0, trueP = 0, falseP = 0, falseN = 0;
@@ -13410,11 +13445,8 @@ stores.inject(MyMetaStore, storeInstance);
   // -----------------------------------------------------------------------------
   function pearson(dataY, dataX) {
       const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
-      if (flatDataX.length === 0) {
-          throw new EvaluationError(_t("[[FUNCTION_NAME]] expects non-empty ranges for both parameters."));
-      }
-      if (flatDataX.length < 2) {
-          throw new EvaluationError(_t("[[FUNCTION_NAME]] needs at least two values for both parameters."));
+      if (flatDataX.length === 0 || flatDataY.length === 0) {
+          return new NotAvailableError(noValidInputErrorMessage);
       }
       const n = flatDataX.length;
       let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0, sumYY = 0;
@@ -13504,6 +13536,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX, order, intercept = { value: true }) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          if (flatDataX.length === 0 || flatDataY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
+          }
           return polynomialRegression(flatDataY, flatDataX, toNumber(order, this.locale), toBoolean(intercept));
       },
       isExported: false,
@@ -13523,6 +13558,9 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (x, dataY, dataX, order, intercept = { value: true }) {
           const _order = toNumber(order, this.locale);
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          if (flatDataX.length === 0 || flatDataY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
+          }
           const coeffs = polynomialRegression(flatDataY, flatDataX, _order, toBoolean(intercept)).flat();
           return matrixMap(toMatrix(x), (xij) => evaluatePolynomial(coeffs, toNumber(xij, this.locale), _order));
       },
@@ -13624,7 +13662,11 @@ stores.inject(MyMetaStore, storeInstance);
           arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
       ],
       compute: function (dataY, dataX) {
-          return Math.pow(pearson(dataX, dataY), 2.0);
+          const value = pearson(dataY, dataX);
+          if (value instanceof Error) {
+              throw value;
+          }
+          return Math.pow(value, 2.0);
       },
       isExported: true,
   };
@@ -13639,6 +13681,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          if (flatDataX.length === 0 || flatDataY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
+          }
           const [[slope]] = fullLinearRegression([flatDataX], [flatDataY]);
           return slope;
       },
@@ -13671,7 +13716,7 @@ stores.inject(MyMetaStore, storeInstance);
           });
           const result = largests.pop();
           if (result === undefined) {
-              return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+              return new EvaluationError(noValidInputErrorMessage);
           }
           if (count < _n) {
               return new EvaluationError(_t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
@@ -13691,6 +13736,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataX, dataY) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          if (flatDataX.length === 0 || flatDataY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
+          }
           const n = flatDataX.length;
           const order = flatDataX.map((e, i) => [e, flatDataY[i]]);
           order.sort((a, b) => a[0] - b[0]);
@@ -13801,6 +13849,9 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          if (flatDataX.length === 0 || flatDataY.length === 0) {
+              return new NotAvailableError(noValidInputErrorMessage);
+          }
           const data = fullLinearRegression([flatDataX], [flatDataY], true, true);
           return data[1][2];
       },
@@ -13818,6 +13869,9 @@ stores.inject(MyMetaStore, storeInstance);
           arg("b (boolean, optional, default=TRUE)", _t("Given a general linear form of y = m*x+b for a curve fit, calculates b if TRUE or forces b to be 0 and only calculates the m values if FALSE, i.e. forces the curve fit to pass through the origin.")),
       ],
       compute: function (knownDataY, knownDataX = [[]], newDataX = [[]], b = { value: true }) {
+          if (knownDataY.length === 0 || knownDataY[0].length === 0) {
+              return new EvaluationError(emptyDataErrorMessage("known_data_y"));
+          }
           return predictLinearValues(toNumberMatrix(knownDataY, "the first argument (known_data_y)"), toNumberMatrix(knownDataX, "the second argument (known_data_x)"), toNumberMatrix(newDataX, "the third argument (new_data_y)"), toBoolean(b));
       },
   };
@@ -18733,7 +18787,7 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (...logicalExpressions) {
           const { result, foundBoolean } = boolAnd(logicalExpressions);
           if (!foundBoolean) {
-              return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+              return new EvaluationError(noValidInputErrorMessage);
           }
           return result;
       },
@@ -18859,7 +18913,7 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (...logicalExpressions) {
           const { result, foundBoolean } = boolOr(logicalExpressions);
           if (!foundBoolean) {
-              return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+              return new EvaluationError(noValidInputErrorMessage);
           }
           return result;
       },
@@ -18922,7 +18976,7 @@ stores.inject(MyMetaStore, storeInstance);
               return true; // no stop condition
           });
           if (!foundBoolean) {
-              return new EvaluationError(_t("[[FUNCTION_NAME]] has no valid input data."));
+              return new EvaluationError(noValidInputErrorMessage);
           }
           return acc;
       },
@@ -21386,7 +21440,7 @@ stores.inject(MyMetaStore, storeInstance);
   function adaptStringRange(defaultSheetId, sheetXC, applyChange) {
       const sheetName = splitReference(sheetXC).sheetName;
       if (sheetName
-          ? !isSheetNameEqual(sheetName, applyChange.sheetName)
+          ? !isSheetNameEqual(sheetName, applyChange.sheetName.old)
           : defaultSheetId !== applyChange.sheetId) {
           return sheetXC;
       }
@@ -21403,7 +21457,7 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function getSheetNameGetter(applyChange) {
       return (sheetId) => {
-          return sheetId === applyChange.sheetId ? applyChange.sheetName : "";
+          return sheetId === applyChange.sheetId ? applyChange.sheetName.current : "";
       };
   }
   function defaultGetSheetSize(sheetId) {
@@ -27394,9 +27448,13 @@ stores.inject(MyMetaStore, storeInstance);
                   : undefined,
           };
       }
-      updateRanges(applyChange) {
+      updateRanges(applyChange, sheetId, adaptSheetName) {
           const dataRange = adaptChartRange(this.dataRange, applyChange);
-          const adaptFormula = (formula) => this.getters.adaptFormulaStringDependencies(this.sheetId, formula, applyChange);
+          const adaptFormula = (formula) => adaptFormulaStringRanges(this.sheetId, formula, {
+              applyChange,
+              sheetId,
+              sheetName: adaptSheetName,
+          });
           const sectionRule = adaptSectionRuleFormulas(this.sectionRule, adaptFormula);
           const definition = this.getDefinitionWithSpecificRanges(dataRange, sectionRule);
           return new GaugeChart(definition, this.sheetId, this.getters);
@@ -33719,6 +33777,9 @@ stores.inject(MyMetaStore, storeInstance);
           this.contentHelper.removeSelection();
       }
       onMouseup() {
+          if (this.env.model.getters.isReadonly()) {
+              return;
+          }
           const selection = this.contentHelper.getCurrentSelection();
           if (selection.start !== selection.end) {
               this.props.composerStore.hoverToken(undefined);
@@ -37454,7 +37515,7 @@ stores.inject(MyMetaStore, storeInstance);
   ];
   const SUPPORTED_VERTICAL_ALIGNMENTS = ["top", "center", "bottom"];
   const SUPPORTED_FONTS = ["Arial"];
-  const SUPPORTED_FILL_PATTERNS = ["solid"];
+  const SUPPORTED_FILL_PATTERNS = ["solid", "none"];
   const SUPPORTED_CF_TYPES = [
       "expression",
       "cellIs",
@@ -37654,7 +37715,7 @@ stores.inject(MyMetaStore, storeInstance);
   };
   /** Mapping between Excel format indexes (see XLSX_FORMAT_MAP) and some supported formats  */
   const XLSX_FORMATS_CONVERSION_MAP = {
-      0: "",
+      0: "General",
       1: "0",
       2: "0.00",
       3: "#,#00",
@@ -37980,11 +38041,11 @@ stores.inject(MyMetaStore, storeInstance);
    * Excel format are defined in openXML §18.8.31
    */
   function convertXlsxFormat(numFmtId, formats, warningManager) {
-      if (numFmtId === 0) {
-          return undefined;
-      }
       // Format is either defined in the imported data, or the formatId is defined in openXML §18.8.30
       const format = XLSX_FORMATS_CONVERSION_MAP[numFmtId] || formats.find((f) => f.id === numFmtId)?.format;
+      if (format === "General") {
+          return undefined;
+      }
       if (format) {
           try {
               let convertedFormat = format.replace(/\[(.*)-[A-Z0-9]{3}\]/g, "[$1]"); // remove currency and locale/date system/number system info (ECMA §18.8.31)
@@ -38182,9 +38243,9 @@ stores.inject(MyMetaStore, storeInstance);
                   if (!rule.operator || !rule.formula || rule.formula.length === 0)
                       continue;
                   operator = CF_OPERATOR_TYPE_CONVERSION_MAP[rule.operator];
-                  values.push(rule.formula[0]);
+                  values.push(prefixFormula(rule.formula[0]));
                   if (rule.formula.length === 2) {
-                      values.push(rule.formula[1]);
+                      values.push(prefixFormula(rule.formula[1]));
                   }
                   break;
           }
@@ -38342,6 +38403,11 @@ stores.inject(MyMetaStore, storeInstance);
               ? ICON_SETS[iconSet].neutral
               : ICON_SETS[iconSet].good;
   }
+  /** Prefix the string by "=" if the string looks like a formula */
+  function prefixFormula(formula) {
+      const tokens = tokenize(formula);
+      return tokens.length === 1 && tokens[0].type !== "REFERENCE" ? formula : "=" + formula;
+  }
   // ---------------------------------------------------------------------------
   // Warnings
   // ---------------------------------------------------------------------------
@@ -38624,7 +38690,7 @@ stores.inject(MyMetaStore, storeInstance);
   function getRowPosition(rowIndex, sheetData) {
       let position = 0;
       for (let i = 0; i < rowIndex; i++) {
-          const rowAtIndex = sheetData.rows[i];
+          const rowAtIndex = sheetData.rows.find((row) => row.index - 1 === i);
           if (rowAtIndex?.height) {
               position += rowAtIndex.height;
           }
@@ -38779,8 +38845,8 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function convertAnchor(XLSXanchor) {
       const offset = {
-          x: convertEMUToDotValue(XLSXanchor.colOffset),
-          y: convertEMUToDotValue(XLSXanchor.rowOffset),
+          x: convertEMUToDotValue(XLSXanchor.colOffset) - FIGURE_BORDER_WIDTH,
+          y: convertEMUToDotValue(XLSXanchor.rowOffset) - FIGURE_BORDER_WIDTH,
       };
       return { col: XLSXanchor.col, row: XLSXanchor.row, offset };
   }
@@ -39163,8 +39229,12 @@ stores.inject(MyMetaStore, storeInstance);
           dims[0] = Math.max(dims[0], largeMax(row.cells.map((cell) => toCartesian(cell.xc).col)));
           dims[1] = Math.max(dims[1], row.index);
       }
-      dims[0] = Math.max(dims[0], EXCEL_IMPORT_DEFAULT_NUMBER_OF_COLS);
-      dims[1] = Math.max(dims[1], EXCEL_IMPORT_DEFAULT_NUMBER_OF_ROWS);
+      for (const fig of sheet.figures) {
+          dims[0] = Math.max(dims[0], fig.anchors[fig.anchors.length - 1]?.col ?? 0);
+          dims[1] = Math.max(dims[1], fig.anchors[fig.anchors.length - 1]?.row ?? 0);
+      }
+      dims[0] = Math.max(dims[0] + 5, EXCEL_IMPORT_DEFAULT_NUMBER_OF_COLS);
+      dims[1] = Math.max(dims[1] + 5, EXCEL_IMPORT_DEFAULT_NUMBER_OF_ROWS);
       return dims;
   }
   /**
@@ -40553,10 +40623,11 @@ stores.inject(MyMetaStore, storeInstance);
           });
       }
       extractRows(worksheet) {
+          const spilledCells = new Set();
           return this.mapOnElements({ parent: worksheet, query: "sheetData row" }, (rowElement) => {
               return {
                   index: this.extractAttr(rowElement, "r", { required: true })?.asNum(),
-                  cells: this.extractCells(rowElement),
+                  cells: this.extractCells(rowElement, spilledCells),
                   height: this.extractAttr(rowElement, "ht")?.asNum(),
                   customHeight: this.extractAttr(rowElement, "customHeight")?.asBool(),
                   hidden: this.extractAttr(rowElement, "hidden")?.asBool(),
@@ -40566,14 +40637,26 @@ stores.inject(MyMetaStore, storeInstance);
               };
           });
       }
-      extractCells(row) {
+      extractCells(row, spilledCells) {
           return this.mapOnElements({ parent: row, query: "c" }, (cellElement) => {
+              const xc = this.extractAttr(cellElement, "r", { required: true })?.asString();
+              const formula = this.extractCellFormula(cellElement);
+              if (formula?.ref && formula.sharedIndex === undefined) {
+                  const zone = toZone(formula.ref);
+                  for (const { col, row } of positions(zone)) {
+                      const followerXc = toXC(col, row);
+                      if (followerXc !== xc) {
+                          spilledCells.add(followerXc);
+                      }
+                  }
+              }
+              const isSpilled = spilledCells.has(xc);
               return {
-                  xc: this.extractAttr(cellElement, "r", { required: true })?.asString(),
+                  xc,
                   styleIndex: this.extractAttr(cellElement, "s")?.asNum(),
                   type: CELL_TYPE_CONVERSION_MAP[this.extractAttr(cellElement, "t", { default: "n" })?.asString()],
-                  value: this.extractChildTextContent(cellElement, "v"),
-                  formula: this.extractCellFormula(cellElement),
+                  value: isSpilled ? undefined : this.extractChildTextContent(cellElement, "v") ?? undefined,
+                  formula: isSpilled ? undefined : formula,
               };
           });
       }
@@ -40581,11 +40664,14 @@ stores.inject(MyMetaStore, storeInstance);
           const formulaElement = this.querySelector(cellElement, "f");
           if (!formulaElement)
               return undefined;
-          return {
-              content: this.extractTextContent(formulaElement),
-              sharedIndex: this.extractAttr(formulaElement, "si")?.asNum(),
-              ref: this.extractAttr(formulaElement, "ref")?.asString(),
-          };
+          const content = this.extractTextContent(formulaElement);
+          const sharedIndex = this.extractAttr(formulaElement, "si")?.asNum();
+          const ref = this.extractAttr(formulaElement, "ref")?.asString();
+          // This is the case of spilled cells of array formulas where <f> is empty
+          if ((content === undefined || content.trim() === "") && sharedIndex === undefined) {
+              return undefined;
+          }
+          return { content, sharedIndex, ref };
       }
       extractHyperLinks(worksheet) {
           return this.mapOnElements({ parent: worksheet, query: "hyperlink" }, (linkElement) => {
@@ -40867,7 +40953,7 @@ stores.inject(MyMetaStore, storeInstance);
       return relsFile;
   }
 
-  const EXCEL_IMPORT_VERSION = "18.4.1";
+  const EXCEL_IMPORT_VERSION = "18.4.2";
   class XlsxReader {
       warningManager;
       xmls;
@@ -44412,7 +44498,7 @@ stores.inject(MyMetaStore, storeInstance);
   const reinsertDynamicPivotMenu = {
       id: "reinsert_dynamic_pivot",
       name: _t("Re-insert dynamic pivot"),
-      sequence: 1020,
+      sequence: 60,
       icon: "o-spreadsheet-Icon.INSERT_PIVOT",
       children: [REINSERT_DYNAMIC_PIVOT_CHILDREN],
       isVisible: (env) => env.model.getters.getPivotIds().some((id) => env.model.getters.getPivot(id).isValid()),
@@ -44420,7 +44506,7 @@ stores.inject(MyMetaStore, storeInstance);
   const reinsertStaticPivotMenu = {
       id: "reinsert_static_pivot",
       name: _t("Re-insert static pivot"),
-      sequence: 1020,
+      sequence: 70,
       icon: "o-spreadsheet-Icon.INSERT_PIVOT",
       children: [REINSERT_STATIC_PIVOT_CHILDREN],
       isVisible: (env) => env.model.getters.getPivotIds().some((id) => env.model.getters.getPivot(id).isValid()),
@@ -58691,7 +58777,8 @@ stores.inject(MyMetaStore, storeInstance);
        * the type of change that occurred.
        *
        * @param applyChange a function that, when called, will adapt the range according to the change on the grid
-       * @param sheetId an optional sheetId to adapt either range of that sheet specifically, or ranges pointing to that sheet
+       * @param sheetId an sheetId to adapt either range of that sheet specifically, or ranges pointing to that sheet
+       * @param sheetName couple of old and new sheet names to adapt ranges pointing to that sheet
        */
       adaptRanges(applyChange, sheetId, sheetName) { }
       /**
@@ -59294,9 +59381,7 @@ stores.inject(MyMetaStore, storeInstance);
               for (const cell of Object.values(this.cells[sheet] || {})) {
                   if (cell.isFormula) {
                       for (const range of cell.compiledFormula.dependencies) {
-                          if (!sheetId ||
-                              range.sheetId === sheetId ||
-                              (sheetName && range.invalidSheetName === sheetName)) {
+                          if (range.sheetId === sheetId || range.invalidSheetName === sheetName.old) {
                               const change = applyChange(range);
                               if (change.changeType !== "NONE") {
                                   this.history.update("cells", sheet, cell.id, "compiledFormula", "dependencies", cell.compiledFormula.dependencies.indexOf(range), change.range);
@@ -59912,9 +59997,9 @@ stores.inject(MyMetaStore, storeInstance);
       charts = {};
       createChart = chartFactory(this.getters);
       validateChartDefinition = (cmd) => validateChartDefinition(this, cmd.definition);
-      adaptRanges(applyChange) {
+      adaptRanges(applyChange, sheetId, adaptSheetName) {
           for (const [chartId, chart] of Object.entries(this.charts)) {
-              this.history.update("charts", chartId, chart?.updateRanges(applyChange));
+              this.history.update("charts", chartId, chart?.updateRanges(applyChange, sheetId, adaptSheetName));
           }
       }
       // ---------------------------------------------------------------------------
@@ -60177,7 +60262,7 @@ stores.inject(MyMetaStore, storeInstance);
               }
           }
       }
-      adaptRanges(applyChange, sheetId, sheetName) {
+      adaptRanges(applyChange, sheetId) {
           const sheetIds = sheetId ? [sheetId] : Object.keys(this.cfRules);
           for (const sheetId of sheetIds) {
               this.adaptCFRanges(sheetId, applyChange);
@@ -60559,11 +60644,8 @@ stores.inject(MyMetaStore, storeInstance);
           "getValidationRuleForCell",
       ];
       rules = {};
-      adaptRanges(applyChange, sheetId, sheetName) {
-          const sheetIds = sheetId ? [sheetId] : Object.keys(this.rules);
-          for (const sheetId of sheetIds) {
-              this.adaptDVRanges(sheetId, applyChange);
-          }
+      adaptRanges(applyChange, sheetId) {
+          this.adaptDVRanges(sheetId, applyChange);
           this.adaptDVFormulas(applyChange);
       }
       adaptDVFormulas(applyChange) {
@@ -60853,9 +60935,6 @@ stores.inject(MyMetaStore, storeInstance);
       // Command Handling
       // ---------------------------------------------------------------------------
       adaptRanges(applyChange, sheetId) {
-          if (!sheetId) {
-              return;
-          }
           for (const figure of this.getFigures(sheetId)) {
               const change = applyChange(this.getters.getRangeFromZone(sheetId, {
                   left: figure.col,
@@ -61664,11 +61743,8 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
           }
       }
-      adaptRanges(applyChange, sheetId, sheetName) {
-          const sheetIds = sheetId ? [sheetId] : Object.keys(this.merges);
-          for (const sheetId of sheetIds) {
-              this.applyRangeChangeOnSheet(sheetId, applyChange);
-          }
+      adaptRanges(applyChange, sheetId) {
+          this.applyRangeChangeOnSheet(sheetId, applyChange);
       }
       // ---------------------------------------------------------------------------
       // Getters
@@ -63173,12 +63249,9 @@ stores.inject(MyMetaStore, storeInstance);
       static getters = ["getCoreTable", "getCoreTables", "getCoreTableMatchingTopLeft"];
       tables = {};
       nextTableId = 1;
-      adaptRanges(applyChange, sheetId, sheetName) {
-          const sheetIds = sheetId ? [sheetId] : this.getters.getSheetIds();
-          for (const sheetId of sheetIds) {
-              for (const table of this.getCoreTables(sheetId)) {
-                  this.applyRangeChangeOnTable(sheetId, table, applyChange);
-              }
+      adaptRanges(applyChange, sheetId) {
+          for (const table of this.getCoreTables(sheetId)) {
+              this.applyRangeChangeOnTable(sheetId, table, applyChange);
           }
       }
       allowDispatch(cmd) {
@@ -64141,7 +64214,7 @@ stores.inject(MyMetaStore, storeInstance);
               }
           }
       }
-      adaptRanges(applyChange, sheetId, sheetName) {
+      adaptRanges(applyChange) {
           for (const sheetId in this.compiledMeasureFormulas) {
               for (const formulaString in this.compiledMeasureFormulas[sheetId]) {
                   const compiledFormula = this.compiledMeasureFormulas[sheetId][formulaString];
@@ -68542,7 +68615,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (!result) {
               return EMPTY_PIVOT_CELL;
           }
-          const { functionName, args } = result;
+          let { functionName, args } = result;
           const formulaId = args[0];
           if (!formulaId) {
               return EMPTY_PIVOT_CELL;
@@ -68577,6 +68650,9 @@ stores.inject(MyMetaStore, storeInstance);
               return pivotCells[pivotCol][pivotRow];
           }
           try {
+              const offsetRow = position.row - mainPosition.row;
+              const offsetCol = position.col - mainPosition.col;
+              args = args.map((arg) => (isMatrix(arg) ? arg[offsetCol][offsetRow] : arg));
               if (functionName === "PIVOT.HEADER" && args.at(-2) === "measure") {
                   const domain = pivot.parseArgsToPivotDomain(args.slice(1, -2).map((value) => ({ value })));
                   return {
@@ -70185,7 +70261,8 @@ stores.inject(MyMetaStore, storeInstance);
           // If the executed command is not in the registry, we skip it
           // because we know there won't be any transformation impacting the
           // commands to transform.
-          if (possibleTransformations.has(executedCommand.type)) {
+          if (possibleTransformations.has(executedCommand.type) ||
+              rangeAdapterRegistry.contains(executedCommand.type)) {
               transformedCommands = transformedCommands.reduce((acc, cmd) => {
                   const transformed = transform(cmd, executedCommand);
                   if (transformed) {
@@ -70932,7 +71009,7 @@ stores.inject(MyMetaStore, storeInstance);
               bottom: rowIndex,
           }));
           const handler = new CellClipboardHandler(this.getters, this.dispatch);
-          const data = handler.copy(getClipboardDataPositions(sheetId, rowsToKeep));
+          const data = handler.copy(getClipboardDataPositions(sheetId, rowsToKeep), false);
           if (!data) {
               return;
           }
@@ -73017,12 +73094,12 @@ stores.inject(MyMetaStore, storeInstance);
               }
               case "INSERT_CELL": {
                   const { cut, paste } = this.getInsertCellsTargets(cmd.zone, cmd.shiftDimension);
-                  const copiedData = this.copy(cut);
+                  const copiedData = this.copy(cut, "shiftCells");
                   return this.isPasteAllowed(paste, copiedData, { isCutOperation: true });
               }
               case "DELETE_CELL": {
                   const { cut, paste } = this.getDeleteCellsTargets(cmd.zone, cmd.shiftDimension);
-                  const copiedData = this.copy(cut);
+                  const copiedData = this.copy(cut, "shiftCells");
                   return this.isPasteAllowed(paste, copiedData, { isCutOperation: true });
               }
           }
@@ -73133,13 +73210,13 @@ stores.inject(MyMetaStore, storeInstance);
                       });
                       break;
                   }
-                  const copiedData = this.copy(cut);
+                  const copiedData = this.copy(cut, "shiftCells");
                   this.paste(paste, copiedData, { isCutOperation: true });
                   break;
               }
               case "INSERT_CELL": {
                   const { cut, paste } = this.getInsertCellsTargets(cmd.zone, cmd.shiftDimension);
-                  const copiedData = this.copy(cut);
+                  const copiedData = this.copy(cut, "shiftCells");
                   this.paste(paste, copiedData, { isCutOperation: true });
                   break;
               }
@@ -73254,11 +73331,11 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return false;
       }
-      copy(zones) {
+      copy(zones, mode = "copyPaste") {
           const copiedData = {};
           const clipboardData = this.getClipboardData(zones);
           for (const { handlerName, handler } of this.selectClipboardHandlers(clipboardData)) {
-              const data = handler.copy(clipboardData, this._isCutOperation);
+              const data = handler.copy(clipboardData, this._isCutOperation, mode);
               copiedData[handlerName] = data;
               const minimalKeys = ["sheetId", "cells", "zones", "figureId"];
               for (const key of minimalKeys) {
@@ -74272,7 +74349,7 @@ stores.inject(MyMetaStore, storeInstance);
           ];
           for (const Handler of clipboardHandlersRegistries.cellHandlers.getAll()) {
               const handler = new Handler(this.getters, this.dispatch);
-              const data = handler.copy(getClipboardDataPositions(sheetId, target));
+              const data = handler.copy(getClipboardDataPositions(sheetId, target), false, "shiftCells");
               if (!data) {
                   continue;
               }
@@ -76177,7 +76254,8 @@ stores.inject(MyMetaStore, storeInstance);
       .add("HIDE_COLUMNS_ROWS", inverseHideColumnsRows)
       .add("UNHIDE_COLUMNS_ROWS", inverseUnhideColumnsRows)
       .add("CREATE_TABLE_STYLE", inverseCreateTableStyle)
-      .add("ADD_PIVOT", inverseAddPivot);
+      .add("ADD_PIVOT", inverseAddPivot)
+      .add("RENAME_SHEET", inverseRenameSheet);
   for (const cmd of coreTypes.values()) {
       if (!inverseCommandRegistry.contains(cmd)) {
           inverseCommandRegistry.add(cmd, identity);
@@ -76275,6 +76353,16 @@ stores.inject(MyMetaStore, storeInstance);
   function inverseCreateTableStyle(cmd) {
       return [{ type: "REMOVE_TABLE_STYLE", tableStyleId: cmd.tableStyleId }];
   }
+  function inverseRenameSheet(cmd) {
+      return [
+          {
+              type: "RENAME_SHEET",
+              sheetId: cmd.sheetId,
+              oldName: cmd.newName,
+              newName: cmd.oldName,
+          },
+      ];
+  }
 
   const numberFormatMenuRegistry = new Registry();
   numberFormatMenuRegistry
@@ -76873,8 +76961,9 @@ stores.inject(MyMetaStore, storeInstance);
       sequence: 40,
       separator: true,
   })
-      .addChild("data_sources_data", ["data"], (env) => {
+      .addChild("pivot_data_sources", ["data"], (env) => {
       const sequence = 50;
+      const numberOfPivots = env.model.getters.getPivotIds().length;
       return env.model.getters.getPivotIds().map((pivotId, index) => {
           const highlightProvider = {
               get highlights() {
@@ -76884,7 +76973,7 @@ stores.inject(MyMetaStore, storeInstance);
           return {
               id: `item_pivot_${env.model.getters.getPivotFormulaId(pivotId)}`,
               name: env.model.getters.getPivotDisplayName(pivotId),
-              sequence: sequence + index,
+              sequence: sequence + index / numberOfPivots,
               isReadonlyAllowed: true,
               execute: (env) => env.openSidePanel("PivotSidePanel", { pivotId }),
               isEnabled: (env) => !env.isSmall,
@@ -83004,7 +83093,7 @@ stores.inject(MyMetaStore, storeInstance);
       for (const [headerIndex, header] of headers.slice(anchor).entries()) {
           if (currentPosition <= offset && offset < currentPosition + header.size) {
               return {
-                  index: headerIndex,
+                  index: anchor + headerIndex,
                   offset: convertDotValueToEMU(offset - currentPosition + FIGURE_BORDER_WIDTH),
               };
           }
@@ -84750,9 +84839,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.4.8";
-  __info__.date = "2025-08-26T10:14:08.954Z";
-  __info__.hash = "746217a";
+  __info__.version = "18.4.10";
+  __info__.date = "2025-09-11T08:45:39.178Z";
+  __info__.hash = "15a11a4";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);