@odoo/o-spreadsheet 18.3.18 → 18.3.20

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.3.18
- * @date 2025-08-26T10:14:21.408Z
- * @hash ec2777d
+ * @version 18.3.20
+ * @date 2025-09-11T08:45:37.934Z
+ * @hash ef829f4
  */
 
 (function (exports, owl) {
@@ -3498,6 +3498,7 @@
       "AUTOFILL_CELL",
       "SET_BORDER",
       "SET_ZONE_BORDERS",
+      "SET_BORDERS_ON_TARGET",
   ]);
   const readonlyAllowedCommands = new Set([
       "START",
@@ -6443,40 +6444,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) {
       let start = cmd.dimension === "COL" ? "left" : "top";
       let end = cmd.dimension === "COL" ? "right" : "bottom";
@@ -7203,7 +7208,7 @@
           this.getters = getters;
           this.dispatch = dispatch;
       }
-      copy(data, isCutOperation) {
+      copy(data, isCutOperation, mode = "copyPaste") {
           return;
       }
       paste(target, clippedContent, options) { }
@@ -7222,7 +7227,7 @@
   }
 
   class AbstractCellClipboardHandler extends ClipboardHandler {
-      copy(data) {
+      copy(data, isCutOperation, mode = "copyPaste") {
           return;
       }
       pasteFromCopy(sheetId, target, content, options) {
@@ -7827,8 +7832,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;
@@ -7897,8 +7905,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;
@@ -7924,7 +7935,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];
   }
@@ -8161,6 +8172,16 @@
       }
       return values;
   }
+  function assertNonEmptyMatrix(matrix, argName) {
+      assert(() => matrix.length > 0 && matrix[0].length > 0, _t("[[FUNCTION_NAME]] expects the provided values of %(argName)s to be a non-empty matrix.", {
+          argName,
+      }));
+  }
+  function assertNonEmpty(...data) {
+      if (data.length === 0 || data.some((arg) => arg.length === 0)) {
+          throw new NotAvailableError(_t("[[FUNCTION_NAME]] has no valid input data."));
+      }
+  }
 
   const PREVIOUS_VALUE = "(previous)";
   const NEXT_VALUE = "(next)";
@@ -8929,7 +8950,7 @@
           }
           return "Success" /* CommandResult.Success */;
       }
-      copy(data) {
+      copy(data, isCutOperation, mode = "copyPaste") {
           const sheetId = data.sheetId;
           const { clippedZones, rowsIndexes, columnsIndexes } = data;
           const clippedCells = [];
@@ -8942,7 +8963,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 &&
@@ -8960,7 +8981,7 @@
                           };
                       }
                   }
-                  else {
+                  else if (mode !== "shiftCells") {
                       if (spreader && !deepEquals(spreader, position)) {
                           const isSpreaderCopied = rowsIndexes.includes(spreader.row) && columnsIndexes.includes(spreader.col);
                           const content = isSpreaderCopied
@@ -9660,7 +9681,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();
@@ -9698,11 +9719,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 {
@@ -10984,6 +11007,7 @@ stores.inject(MyMetaStore, storeInstance);
       compute: function (matrix1, matrix2) {
           const _matrix1 = toNumberMatrix(matrix1, "matrix1");
           const _matrix2 = toNumberMatrix(matrix2, "matrix2");
+          assert(() => _matrix1.length > 0 && _matrix2.length > 0, _t("The first and second arguments of [[FUNCTION_NAME]] must be non-empty matrices."));
           assert(() => _matrix1.length === _matrix2[0].length, _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()));
           return multiplyMatrices(_matrix1, _matrix2);
@@ -12779,6 +12803,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (x, dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          assertNonEmpty(flatDataX, flatDataY);
           return predictLinearValues([flatDataY], [flatDataX], matrixMap(toMatrix(x), (value) => toNumber(value, this.locale)), true);
       },
       isExported: true,
@@ -12795,6 +12820,7 @@ 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 }) {
+          assertNonEmptyMatrix(knownDataY, "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)));
       },
   };
@@ -12809,6 +12835,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          assertNonEmpty(flatDataX, flatDataY);
           const [[], [intercept]] = fullLinearRegression([flatDataX], [flatDataY]);
           return intercept;
       },
@@ -12858,6 +12885,7 @@ 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 }) {
+          assertNonEmptyMatrix(dataY, "data_y");
           return fullLinearRegression(toNumberMatrix(dataX, "the first argument (data_y)"), toNumberMatrix(dataY, "the second argument (data_x)"), toBoolean(calculateB), toBoolean(verbose));
       },
       isExported: true,
@@ -12874,6 +12902,7 @@ 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 }) {
+          assertNonEmptyMatrix(dataY, "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]);
@@ -12895,9 +12924,7 @@ 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."));
-          }
+          assertNonEmpty(flatX, flatY);
           const n = flatX.length;
           let trueN = 0, trueP = 0, falseP = 0, falseN = 0;
           for (let i = 0; i < n; ++i) {
@@ -13061,12 +13088,7 @@ 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."));
-      }
+      assertNonEmpty(flatDataX, flatDataY);
       const n = flatDataX.length;
       let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0, sumYY = 0;
       for (let i = 0; i < n; i++) {
@@ -13155,6 +13177,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX, order, intercept = { value: true }) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          assertNonEmpty(flatDataX, flatDataY);
           return polynomialRegression(flatDataY, flatDataX, toNumber(order, this.locale), toBoolean(intercept));
       },
       isExported: false,
@@ -13174,6 +13197,7 @@ 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);
+          assertNonEmpty(flatDataX, flatDataY);
           const coeffs = polynomialRegression(flatDataY, flatDataX, _order, toBoolean(intercept)).flat();
           return matrixMap(toMatrix(x), (xij) => evaluatePolynomial(coeffs, toNumber(xij, this.locale), _order));
       },
@@ -13290,6 +13314,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          assertNonEmpty(flatDataX, flatDataY);
           const [[slope]] = fullLinearRegression([flatDataX], [flatDataY]);
           return slope;
       },
@@ -13338,6 +13363,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataX, dataY) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          assertNonEmpty(flatDataX, flatDataY);
           const n = flatDataX.length;
           const order = flatDataX.map((e, i) => [e, flatDataY[i]]);
           order.sort((a, b) => a[0] - b[0]);
@@ -13448,6 +13474,7 @@ stores.inject(MyMetaStore, storeInstance);
       ],
       compute: function (dataY, dataX) {
           const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          assertNonEmpty(flatDataX, flatDataY);
           const data = fullLinearRegression([flatDataX], [flatDataY], true, true);
           return data[1][2];
       },
@@ -13465,6 +13492,7 @@ 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 }) {
+          assertNonEmptyMatrix(knownDataY, "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));
       },
   };
@@ -20601,7 +20629,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;
       }
@@ -20618,7 +20646,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) {
@@ -27581,9 +27609,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);
@@ -30210,7 +30242,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);
@@ -30308,6 +30341,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,
+          },
+      ];
+  }
 
   /**
    * The class Registry is extended in order to add the function addChild
@@ -30844,7 +30887,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",
@@ -31029,7 +31072,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",
@@ -31355,11 +31398,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
       let 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)
@@ -31557,9 +31600,9 @@ stores.inject(MyMetaStore, storeInstance);
                   if (!rule.operator || !rule.formula || rule.formula.length === 0)
                       continue;
                   operator = convertCFCellIsOperator(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;
           }
@@ -31717,6 +31760,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
   // ---------------------------------------------------------------------------
@@ -31979,7 +32027,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;
           }
@@ -32119,8 +32167,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 };
   }
@@ -32503,8 +32551,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;
   }
   /**
@@ -34195,10 +34247,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(),
@@ -34208,14 +34261,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,
               };
           });
       }
@@ -34223,11 +34288,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) => {
@@ -34509,7 +34577,7 @@ stores.inject(MyMetaStore, storeInstance);
       return relsFile;
   }
 
-  const EXCEL_IMPORT_VERSION = "18.3";
+  const EXCEL_IMPORT_VERSION = "18.3.1";
   class XlsxReader {
       warningManager;
       xmls;
@@ -38513,7 +38581,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()),
@@ -38521,7 +38589,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()),
@@ -40190,8 +40258,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() {
@@ -40201,7 +40270,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 }),
               onStartHover: (env) => env.getStore(HighlightStore).register(highlightProvider),
@@ -57199,7 +57268,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) { }
       /**
@@ -57802,9 +57872,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);
@@ -58420,9 +58488,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));
           }
       }
       // ---------------------------------------------------------------------------
@@ -58685,7 +58753,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);
@@ -59081,11 +59149,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) {
@@ -59375,9 +59440,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,
@@ -60185,11 +60247,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
@@ -61697,12 +61756,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) {
@@ -62665,7 +62721,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];
@@ -66826,7 +66882,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;
@@ -66856,6 +66912,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 {
@@ -68054,7 +68113,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) {
@@ -68788,7 +68848,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;
           }
@@ -70828,12 +70888,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 });
               }
           }
@@ -70944,13 +71004,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;
               }
@@ -71065,11 +71125,11 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return false;
       }
-      copy(zones) {
+      copy(zones, mode = "copyPaste") {
           let 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) {
@@ -72020,7 +72080,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;
               }
@@ -79215,7 +79275,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),
               };
           }
@@ -80954,9 +81014,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.3.18";
-  __info__.date = "2025-08-26T10:14:21.408Z";
-  __info__.hash = "ec2777d";
+  __info__.version = "18.3.20";
+  __info__.date = "2025-09-11T08:45:37.934Z";
+  __info__.hash = "ef829f4";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);