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

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.4
- * @date 2023-11-24T13:12:24.882Z
- * @hash 255821b
+ * @version 17.1.0-alpha.6
+ * @date 2024-01-04T12:22:45.921Z
+ * @hash 56dbdc9
  */
 
 (function (exports, owl) {
@@ -329,13 +329,6 @@
   //------------------------------------------------------------------------------
   // Miscellaneous
   //------------------------------------------------------------------------------
-  /**
-   * Stringify an object, like JSON.stringify, except that the first level of keys
-   * is ordered.
-   */
-  function stringify(obj) {
-      return JSON.stringify(obj, Object.keys(obj).sort());
-  }
   /**
    * Remove quotes from a quoted string
    * ```js
@@ -558,7 +551,7 @@
    */
   function getItemId(item, itemsDic) {
       for (let [key, value] of Object.entries(itemsDic)) {
-          if (stringify(value) === stringify(item)) {
+          if (deepEquals(value, item)) {
               return parseInt(key, 10);
           }
       }
@@ -2061,6 +2054,8 @@
       CommandResult["NoChanges"] = "NoChanges";
   })(exports.CommandResult || (exports.CommandResult = {}));
 
+  const PLAIN_TEXT_FORMAT = "@"; // see OpenXML spec §18.8.31
+
   const DEFAULT_LOCALES = [
       {
           name: "English (US)",
@@ -2824,6 +2819,9 @@
    * Formats a cell value with its format.
    */
   function formatValue(value, { format, locale }) {
+      if (format === PLAIN_TEXT_FORMAT) {
+          return toString(value) || "";
+      }
       switch (typeof value) {
           case "string":
               return value;
@@ -3387,8 +3385,10 @@
   const cellReference = new RegExp(/\$?([A-Z]{1,3})\$?([0-9]{1,7})/, "i");
   // Same as above, but matches the exact string (nothing before or after)
   const singleCellReference = new RegExp(/^\$?([A-Z]{1,3})\$?([0-9]{1,7})$/, "i");
-  /** Reference of a column header (eg. A, AB) */
-  const colHeader = new RegExp(/^([A-Z]{1,3})+$/, "i");
+  /** Reference of a column header (eg. A, AB, $A) */
+  const colHeader = new RegExp(/^\$?([A-Z]{1,3})+$/, "i");
+  /** Reference of a row header (eg. 1, $1) */
+  const rowHeader = new RegExp(/^\$?([0-9]{1,7})+$/, "i");
   /** Reference of a column (eg. A, $CA, Sheet1!B) */
   const colReference = new RegExp(/^\s*('.+'!|[^']+!)?\$?([A-Z]{1,3})$/, "i");
   /** Reference of a row (eg. 1, 59, Sheet1!9) */
@@ -3418,6 +3418,9 @@
   function isColHeader(str) {
       return colHeader.test(str);
   }
+  function isRowHeader(str) {
+      return rowHeader.test(str);
+  }
   /**
    * Return true if the given xc is the reference of a single cell,
    * without any specified sheet (e.g. A1)
@@ -4108,18 +4111,10 @@
           if (isFullCol) {
               parts[0].rowFixed = parts[0].rowFixed || parts[1].rowFixed;
               parts[1].rowFixed = parts[0].rowFixed || parts[1].rowFixed;
-              if (zone.left === zone.right) {
-                  parts[0].colFixed = parts[0].colFixed || parts[1].colFixed;
-                  parts[1].colFixed = parts[0].colFixed || parts[1].colFixed;
-              }
           }
           if (isFullRow) {
               parts[0].colFixed = parts[0].colFixed || parts[1].colFixed;
               parts[1].colFixed = parts[0].colFixed || parts[1].colFixed;
-              if (zone.top === zone.bottom) {
-                  parts[0].rowFixed = parts[0].rowFixed || parts[1].rowFixed;
-                  parts[1].rowFixed = parts[0].rowFixed || parts[1].rowFixed;
-              }
           }
           return parts;
       }
@@ -4361,7 +4356,7 @@
   function getDefaultCellHeight(ctx, cell, colSize) {
       if (!cell || !cell.content)
           return DEFAULT_CELL_HEIGHT;
-      const maxWidth = cell.style?.wrapping ? colSize - 2 * MIN_CELL_TEXT_MARGIN : undefined;
+      const maxWidth = cell.style?.wrapping === "wrap" ? colSize - 2 * MIN_CELL_TEXT_MARGIN : undefined;
       const numberOfLines = cell.isFormula
           ? 1
           : splitTextToWidth(ctx, cell.content, cell.style, maxWidth).length;
@@ -5298,7 +5293,7 @@
           };
           baselineCell = getters.getEvaluatedCell(baselinePosition);
       }
-      const background = getters.getBackgroundOfSingleCellChart(chart.background, chart.keyValue);
+      const { background, fontColor } = getters.getStyleOfSingleCellChart(chart.background, chart.keyValue);
       const locale = getters.getLocale();
       return {
           title: _t(chart.title),
@@ -5307,7 +5302,7 @@
           baselineArrow: getBaselineArrowDirection(baselineCell, keyValueCell, chart.baselineMode),
           baselineColor: getBaselineColor(baselineCell, chart.baselineMode, keyValueCell, chart.baselineColorUp, chart.baselineColorDown),
           baselineDescr: chart.baselineDescr ? _t(chart.baselineDescr) : "",
-          fontColor: chartFontColor(background),
+          fontColor,
           background,
           baselineStyle: chart.baselineMode !== "percentage" && baseline
               ? getters.getCellStyle({
@@ -5733,6 +5728,9 @@
   }
 
   function evaluateLiteral(content, localeFormat) {
+      if (localeFormat.format === PLAIN_TEXT_FORMAT) {
+          return textCell(content || "", localeFormat);
+      }
       return createEvaluatedCell(parseLiteral(content || "", localeFormat.locale), localeFormat);
   }
   function parseLiteral(content, locale) {
@@ -5767,6 +5765,9 @@
   }
   function _createEvaluatedCell(value, localeFormat) {
       try {
+          if (localeFormat.format === PLAIN_TEXT_FORMAT) {
+              return textCell(toString(value), localeFormat);
+          }
           for (const builder of builders) {
               const evaluateCell = builder(value, localeFormat);
               if (evaluateCell) {
@@ -6258,10 +6259,6 @@
 
     .o-error-tooltip-message {
       overflow: hidden;
-      display: -webkit-box; /* Limit to 3 lines */
-      -webkit-line-clamp: 3;
-      line-clamp: 3;
-      -webkit-box-orient: vertical;
     }
   }
 `;
@@ -6606,6 +6603,7 @@
       },
   };
 
+  const macRegex = /Mac/i;
   /**
    * Return true if the event was triggered from
    * a child element.
@@ -6657,7 +6655,7 @@
    */
   function keyboardEventToShortcutString(ev, mode = "key") {
       let keyDownString = "";
-      if (ev.ctrlKey && ev.key !== "Ctrl")
+      if (isCtrlKey(ev) && ev.key !== "Ctrl")
           keyDownString += "Ctrl+";
       if (ev.metaKey)
           keyDownString += "Ctrl+";
@@ -6669,6 +6667,17 @@
       keyDownString += letterRegex.test(key) ? key.toUpperCase() : key;
       return keyDownString;
   }
+  function isMacOS() {
+      return Boolean(macRegex.test(navigator.userAgent));
+  }
+  /**
+   * @param {KeyboardEvent | MouseEvent} ev
+   * @returns Returns true if the event was triggered with the "ctrl" modifier pressed.
+   * On Mac, this is the "meta" or "command" key.
+   */
+  function isCtrlKey(ev) {
+      return isMacOS() ? ev.metaKey : ev.ctrlKey;
+  }
 
   /**
    * Return the o-spreadsheet element position relative
@@ -8906,7 +8915,7 @@
       });
       return {
           chartJsConfig: config,
-          background: getters.getBackgroundOfSingleCellChart(chart.background, dataRange),
+          background: getters.getStyleOfSingleCellChart(chart.background, dataRange).background,
       };
   }
 
@@ -8987,7 +8996,7 @@
       else if (format.includes("h") || format.includes("H")) {
           return "hour";
       }
-      else if (format.includes("D")) {
+      else if (format.includes("d")) {
           return "day";
       }
       else if (format.includes("M")) {
@@ -9499,6 +9508,27 @@
       const percentage = (dataset[dataIndex] / total) * 100;
       return percentage.toFixed(2);
   }
+  function filterNegativeValues(labels, datasets) {
+      const dataPointsIndexes = labels.reduce((indexes, label, i) => {
+          const shouldKeep = datasets.some((dataset) => {
+              const dataPoint = dataset.data[i];
+              return typeof dataPoint !== "number" || dataPoint >= 0;
+          });
+          if (shouldKeep) {
+              indexes.push(i);
+          }
+          return indexes;
+      }, []);
+      const filteredLabels = dataPointsIndexes.map((i) => labels[i] || "");
+      const filteredDatasets = datasets.map((dataset) => ({
+          ...dataset,
+          data: dataPointsIndexes.map((i) => {
+              const dataPoint = dataset.data[i];
+              return typeof dataPoint !== "number" || dataPoint >= 0 ? dataPoint : 0;
+          }),
+      }));
+      return { labels: filteredLabels, dataSetsValues: filteredDatasets };
+  }
   function createPieChartRuntime(chart, getters) {
       const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
       let labels = labelValues.formattedValues;
@@ -9512,6 +9542,7 @@
       if (chart.aggregated) {
           ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
       }
+      ({ dataSetsValues, labels } = filterNegativeValues(labels, dataSetsValues));
       const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
       const locale = getters.getLocale();
       const config = getPieConfiguration(chart, labels, { format: dataSetFormat, locale });
@@ -10349,7 +10380,7 @@
   // Simple actions
   //------------------------------------------------------------------------------
   const PASTE_ACTION = async (env) => paste$1(env);
-  const PASTE_VALUE_ACTION = async (env) => paste$1(env, "onlyValue");
+  const PASTE_AS_VALUE_ACTION = async (env) => paste$1(env, "asValue");
   async function paste$1(env, pasteOption) {
       const spreadsheetClipboard = env.model.getters.getClipboardTextContent();
       const osClipboard = await env.clipboard.readText();
@@ -10362,7 +10393,7 @@
               else {
                   interactivePaste(env, target, pasteOption);
               }
-              if (env.model.getters.isCutOperation() && pasteOption !== "onlyValue") {
+              if (env.model.getters.isCutOperation() && pasteOption !== "asValue") {
                   await env.clipboard.write({ [ClipboardMIMEType.PlainText]: "" });
               }
               break;
@@ -10777,9 +10808,9 @@
       icon: "o-spreadsheet-Icon.PASTE",
   };
   const pasteSpecialValue = {
-      name: _t("Paste value only"),
+      name: _t("Paste as value"),
       description: "Ctrl+Shift+V",
-      execute: PASTE_VALUE_ACTION,
+      execute: PASTE_AS_VALUE_ACTION,
   };
   const pasteSpecialFormat = {
       name: _t("Paste format only"),
@@ -17948,6 +17979,10 @@
               return xc.slice(0, indexOfNumber) + "$" + xc.slice(indexOfNumber);
           case "colrow":
               indexOfNumber = xc.search(/[0-9]/);
+              if (indexOfNumber === -1 || indexOfNumber === 0) {
+                  // no row number (eg. A) or no column (eg. 1)
+                  return "$" + xc;
+              }
               xc = xc.slice(0, indexOfNumber) + "$" + xc.slice(indexOfNumber);
               return "$" + xc;
           case "none":
@@ -20014,6 +20049,11 @@
       execute: (env) => setFormatter(env, ""),
       isActive: (env) => isAutomaticFormatSelected(env),
   };
+  const formatNumberPlainText = {
+      name: _t("Plain text"),
+      execute: (env) => setFormatter(env, PLAIN_TEXT_FORMAT),
+      isActive: (env) => isFormatSelected(env, PLAIN_TEXT_FORMAT),
+  };
   const formatNumberNumber = createFormatActionSpec({
       name: _t("Number"),
       descriptionValue: 1000.12,
@@ -20373,6 +20413,7 @@
     formatNumberFullWeekDayAndMonth: formatNumberFullWeekDayAndMonth,
     formatNumberNumber: formatNumberNumber,
     formatNumberPercent: formatNumberPercent,
+    formatNumberPlainText: formatNumberPlainText,
     formatNumberShortMonth: formatNumberShortMonth,
     formatNumberShortWeekDay: formatNumberShortWeekDay,
     formatNumberTime: formatNumberTime,
@@ -20803,6 +20844,10 @@
       .add("format_number_automatic", {
       ...formatNumberAutomatic,
       sequence: 10,
+  })
+      .add("format_number_plain_text", {
+      ...formatNumberPlainText,
+      sequence: 15,
       separator: true,
   })
       .add("format_number_number", {
@@ -21401,10 +21446,10 @@
   function updateSelectionWithArrowKeys(ev, selection) {
       const direction = arrowMap[ev.key];
       if (ev.shiftKey) {
-          selection.resizeAnchorZone(direction, ev.ctrlKey ? "end" : 1);
+          selection.resizeAnchorZone(direction, isCtrlKey(ev) ? "end" : 1);
       }
       else {
-          selection.moveAnchorCell(direction, ev.ctrlKey ? "end" : 1);
+          selection.moveAnchorCell(direction, isCtrlKey(ev) ? "end" : 1);
       }
   }
 
@@ -24013,6 +24058,12 @@
         padding: 4px 0 4px 4px;
       }
     }
+
+    .o-matches-count div {
+      text-overflow: ellipsis;
+      overflow: hidden;
+      white-space: nowrap;
+    }
   }
 `;
   class FindAndReplacePanel extends owl.Component {
@@ -28443,7 +28494,10 @@
               return;
           }
           const [col, row] = this.getCartesianCoordinates(ev);
-          this.props.onCellClicked(col, row, { shiftKey: ev.shiftKey, ctrlKey: ev.ctrlKey });
+          this.props.onCellClicked(col, row, {
+              expandZone: ev.shiftKey,
+              addZone: isCtrlKey(ev),
+          });
       }
       onDoubleClick(ev) {
           const [col, row] = this.getCartesianCoordinates(ev);
@@ -28518,6 +28572,7 @@
           draggerShadowThickness: 0,
           delta: 0,
           base: 0,
+          position: "before",
       });
       _computeHandleDisplay(ev) {
           const position = this._getEvOffset(ev);
@@ -28642,11 +28697,13 @@
                       this.state.draggerLinePosition = dimensions.start;
                       this.state.draggerShadowPosition = dimensions.start;
                       this.state.base = elementIndex;
+                      this.state.position = "before";
                   }
                   else if (this._getSelectedZoneEnd() < elementIndex) {
                       this.state.draggerLinePosition = dimensions.end;
                       this.state.draggerShadowPosition = dimensions.end - this.state.draggerShadowThickness;
-                      this.state.base = elementIndex + 1;
+                      this.state.base = elementIndex;
+                      this.state.position = "after";
                   }
                   else {
                       this.state.draggerLinePosition = startDimensions.start;
@@ -28670,7 +28727,7 @@
               this._increaseSelection(index);
           }
           else {
-              this._selectElement(index, ev.ctrlKey);
+              this._selectElement(index, isCtrlKey(ev));
           }
           this.lastSelectedElementIndex = index;
           const mouseMoveSelect = (col, row) => {
@@ -28821,13 +28878,14 @@
               dimension: "COL",
               base: this.state.base,
               elements,
+              position: this.state.position,
           });
           if (!result.isSuccessful && result.reasons.includes("WillRemoveExistingMerge" /* CommandResult.WillRemoveExistingMerge */)) {
               this.env.raiseError(MergeErrorMessage);
           }
       }
-      _selectElement(index, ctrlKey) {
-          this.env.model.selection.selectColumn(index, ctrlKey ? "newAnchor" : "overrideSelection");
+      _selectElement(index, addDistinctHeader) {
+          this.env.model.selection.selectColumn(index, addDistinctHeader ? "newAnchor" : "overrideSelection");
       }
       _increaseSelection(index) {
           this.env.model.selection.selectColumn(index, "updateAnchor");
@@ -28985,13 +29043,14 @@
               dimension: "ROW",
               base: this.state.base,
               elements,
+              position: this.state.position,
           });
           if (!result.isSuccessful && result.reasons.includes("WillRemoveExistingMerge" /* CommandResult.WillRemoveExistingMerge */)) {
               this.env.raiseError(MergeErrorMessage);
           }
       }
-      _selectElement(index, ctrlKey) {
-          this.env.model.selection.selectRow(index, ctrlKey ? "newAnchor" : "overrideSelection");
+      _selectElement(index, addDistinctHeader) {
+          this.env.model.selection.selectRow(index, addDistinctHeader ? "newAnchor" : "overrideSelection");
       }
       _increaseSelection(index) {
           this.env.model.selection.selectRow(index, "updateAnchor");
@@ -29092,8 +29151,8 @@
           return val * (deltaMode === 0 ? 1 : DEFAULT_CELL_HEIGHT);
       }
       const onMouseWheel = (ev) => {
-          const deltaX = normalize(ev.shiftKey ? ev.deltaY : ev.deltaX, ev.deltaMode);
-          const deltaY = normalize(ev.shiftKey ? ev.deltaX : ev.deltaY, ev.deltaMode);
+          const deltaX = normalize(ev.shiftKey && !isMacOS() ? ev.deltaY : ev.deltaX, ev.deltaMode);
+          const deltaY = normalize(ev.shiftKey && !isMacOS() ? ev.deltaX : ev.deltaY, ev.deltaMode);
           handler(deltaX, deltaY);
       };
       return onMouseWheel;
@@ -29684,7 +29743,7 @@
           "Ctrl+Shift+E": () => this.setHorizontalAlign("center"),
           "Ctrl+Shift+L": () => this.setHorizontalAlign("left"),
           "Ctrl+Shift+R": () => this.setHorizontalAlign("right"),
-          "Ctrl+Shift+V": () => PASTE_VALUE_ACTION(this.env),
+          "Ctrl+Shift+V": () => PASTE_AS_VALUE_ACTION(this.env),
           "Ctrl+Shift+<": () => this.clearFormatting(),
           "Ctrl+<": () => this.clearFormatting(),
           "Ctrl+Shift+ ": () => {
@@ -29792,17 +29851,17 @@
       // ---------------------------------------------------------------------------
       // Zone selection with mouse
       // ---------------------------------------------------------------------------
-      onCellClicked(col, row, { ctrlKey, shiftKey }) {
+      onCellClicked(col, row, { addZone, expandZone }) {
           if (this.env.model.getters.hasOpenedPopover()) {
               this.closeOpenedPopover();
           }
           if (this.env.model.getters.getEditionMode() === "editing") {
               interactiveStopEdition(this.env);
           }
-          if (shiftKey) {
+          if (expandZone) {
               this.env.model.selection.setAnchorCorner(col, row);
           }
-          else if (ctrlKey) {
+          else if (addZone) {
               this.env.model.selection.addCellToSelection(col, row);
           }
           else {
@@ -30605,7 +30664,7 @@
       46: "hhhh:mm:ss",
       47: "hhhh:mm:ss",
       48: undefined,
-      49: undefined,
+      49: PLAIN_TEXT_FORMAT,
   };
   /**
    * Mapping format index to format defined by default
@@ -33530,7 +33589,7 @@
           SPACE: goTo(State.RightRef),
           NUMBER: goTo(State.Found),
           REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value)),
+          SYMBOL: goTo(State.Found, (token) => isColHeader(token.value) || isRowHeader(token.value)),
       },
       [State.RightColumnRef]: {
           SPACE: goTo(State.RightColumnRef),
@@ -33541,6 +33600,7 @@
           SPACE: goTo(State.RightRowRef),
           NUMBER: goTo(State.Found),
           REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+          SYMBOL: goTo(State.Found, (token) => isRowHeader(token.value)),
       },
       [State.Found]: {},
   };
@@ -34737,7 +34797,7 @@
            */
           function getBorderId(border) {
               for (let [key, value] of Object.entries(borders)) {
-                  if (stringify(value) === stringify(border)) {
+                  if (deepEquals(value, border)) {
                       return parseInt(key, 10);
                   }
               }
@@ -35908,7 +35968,9 @@
       }
       createLiteralCell(id, content, format, style) {
           const locale = this.getters.getLocale();
-          content = parseLiteral(content, locale).toString();
+          if (format !== PLAIN_TEXT_FORMAT) {
+              content = toString(parseLiteral(content, locale));
+          }
           return {
               id,
               content,
@@ -37520,7 +37582,16 @@
           return consecutiveIndexes;
       }
       getAllVisibleHeaders(sheetId, dimension) {
-          return range(0, this.hiddenHeaders[sheetId][dimension].length).filter((i) => !this.hiddenHeaders[sheetId][dimension][i]);
+          const headers = range(0, this.getters.getNumberHeaders(sheetId, dimension));
+          const foldedHeaders = [];
+          this.getters.getHeaderGroups(sheetId, dimension).forEach((group) => {
+              if (group.isFolded) {
+                  foldedHeaders.push(...range(group.start, group.end + 1));
+              }
+          });
+          return headers.filter((i) => {
+              return !this.hiddenHeaders[sheetId][dimension][i] && !foldedHeaders.includes(i);
+          });
       }
       import(data) {
           for (let sheet of data.sheets) {
@@ -39981,10 +40052,13 @@
           if (evaluatedCell === undefined) {
               return { value: null, format: this.getters.getCell(position)?.format };
           }
+          if (evaluatedCell.type === CellValueType.error) {
+              throw evaluatedCell.error;
+          }
           return evaluatedCell;
       }
       getEvaluatedCellIfNotEmpty(position) {
-          const evaluatedCell = this.getEvaluatedCell(position);
+          const evaluatedCell = this.computeCell(position);
           if (evaluatedCell.type === CellValueType.empty) {
               const cell = this.getters.getCell(position);
               if (!cell || (!cell.isFormula && cell.content === "")) {
@@ -39993,13 +40067,6 @@
           }
           return evaluatedCell;
       }
-      getEvaluatedCell(position) {
-          const evaluatedCell = this.computeCell(position);
-          if (evaluatedCell.type === CellValueType.error) {
-              throw evaluatedCell.error;
-          }
-          return evaluatedCell;
-      }
       /**
        * Return the values of the cell(s) used in reference, but always in the format of a range even
        * if a single cell is referenced. It is a list of col values. This is useful for the formulas that describe parameters as
@@ -40022,7 +40089,11 @@
           const { top, left, bottom, right } = zone;
           const cacheKey = `${sheetId}-${top}-${left}-${bottom}-${right}`;
           if (cacheKey in this.rangeCache) {
-              return this.rangeCache[cacheKey];
+              const result = this.rangeCache[cacheKey];
+              if (result instanceof EvaluationError) {
+                  throw result;
+              }
+              return result;
           }
           const height = _zone.bottom - _zone.top + 1;
           const width = _zone.right - _zone.left + 1;
@@ -40032,6 +40103,11 @@
               const colIndex = col - _zone.left;
               matrix[colIndex] = new Array(height);
               for (let row = _zone.top; row <= _zone.bottom; row++) {
+                  const evaluatedCell = this.getEvaluatedCellIfNotEmpty({ sheetId, col, row });
+                  if (evaluatedCell?.type === CellValueType.error) {
+                      this.rangeCache[cacheKey] = evaluatedCell.error;
+                      throw evaluatedCell.error;
+                  }
                   const rowIndex = row - _zone.top;
                   matrix[colIndex][rowIndex] = this.readCell({ sheetId, col, row });
               }
@@ -40041,56 +40117,758 @@
       }
   }
 
+  function quickselect(arr, k, left, right, compare) {
+      quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
+  }
+
+  function quickselectStep(arr, k, left, right, compare) {
+
+      while (right > left) {
+          if (right - left > 600) {
+              var n = right - left + 1;
+              var m = k - left + 1;
+              var z = Math.log(n);
+              var s = 0.5 * Math.exp(2 * z / 3);
+              var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
+              var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
+              var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
+              quickselectStep(arr, k, newLeft, newRight, compare);
+          }
+
+          var t = arr[k];
+          var i = left;
+          var j = right;
+
+          swap(arr, left, k);
+          if (compare(arr[right], t) > 0) swap(arr, left, right);
+
+          while (i < j) {
+              swap(arr, i, j);
+              i++;
+              j--;
+              while (compare(arr[i], t) < 0) i++;
+              while (compare(arr[j], t) > 0) j--;
+          }
+
+          if (compare(arr[left], t) === 0) swap(arr, left, j);
+          else {
+              j++;
+              swap(arr, j, right);
+          }
+
+          if (j <= k) left = j + 1;
+          if (k <= j) right = j - 1;
+      }
+  }
+
+  function swap(arr, i, j) {
+      var tmp = arr[i];
+      arr[i] = arr[j];
+      arr[j] = tmp;
+  }
+
+  function defaultCompare(a, b) {
+      return a < b ? -1 : a > b ? 1 : 0;
+  }
+
+  class RBush {
+      constructor(maxEntries = 9) {
+          // max entries in a node is 9 by default; min node fill is 40% for best performance
+          this._maxEntries = Math.max(4, maxEntries);
+          this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
+          this.clear();
+      }
+
+      all() {
+          return this._all(this.data, []);
+      }
+
+      search(bbox) {
+          let node = this.data;
+          const result = [];
+
+          if (!intersects(bbox, node)) return result;
+
+          const toBBox = this.toBBox;
+          const nodesToSearch = [];
+
+          while (node) {
+              for (let i = 0; i < node.children.length; i++) {
+                  const child = node.children[i];
+                  const childBBox = node.leaf ? toBBox(child) : child;
+
+                  if (intersects(bbox, childBBox)) {
+                      if (node.leaf) result.push(child);
+                      else if (contains(bbox, childBBox)) this._all(child, result);
+                      else nodesToSearch.push(child);
+                  }
+              }
+              node = nodesToSearch.pop();
+          }
+
+          return result;
+      }
+
+      collides(bbox) {
+          let node = this.data;
+
+          if (!intersects(bbox, node)) return false;
+
+          const nodesToSearch = [];
+          while (node) {
+              for (let i = 0; i < node.children.length; i++) {
+                  const child = node.children[i];
+                  const childBBox = node.leaf ? this.toBBox(child) : child;
+
+                  if (intersects(bbox, childBBox)) {
+                      if (node.leaf || contains(bbox, childBBox)) return true;
+                      nodesToSearch.push(child);
+                  }
+              }
+              node = nodesToSearch.pop();
+          }
+
+          return false;
+      }
+
+      load(data) {
+          if (!(data && data.length)) return this;
+
+          if (data.length < this._minEntries) {
+              for (let i = 0; i < data.length; i++) {
+                  this.insert(data[i]);
+              }
+              return this;
+          }
+
+          // recursively build the tree with the given data from scratch using OMT algorithm
+          let node = this._build(data.slice(), 0, data.length - 1, 0);
+
+          if (!this.data.children.length) {
+              // save as is if tree is empty
+              this.data = node;
+
+          } else if (this.data.height === node.height) {
+              // split root if trees have the same height
+              this._splitRoot(this.data, node);
+
+          } else {
+              if (this.data.height < node.height) {
+                  // swap trees if inserted one is bigger
+                  const tmpNode = this.data;
+                  this.data = node;
+                  node = tmpNode;
+              }
+
+              // insert the small tree into the large tree at appropriate level
+              this._insert(node, this.data.height - node.height - 1, true);
+          }
+
+          return this;
+      }
+
+      insert(item) {
+          if (item) this._insert(item, this.data.height - 1);
+          return this;
+      }
+
+      clear() {
+          this.data = createNode([]);
+          return this;
+      }
+
+      remove(item, equalsFn) {
+          if (!item) return this;
+
+          let node = this.data;
+          const bbox = this.toBBox(item);
+          const path = [];
+          const indexes = [];
+          let i, parent, goingUp;
+
+          // depth-first iterative tree traversal
+          while (node || path.length) {
+
+              if (!node) { // go up
+                  node = path.pop();
+                  parent = path[path.length - 1];
+                  i = indexes.pop();
+                  goingUp = true;
+              }
+
+              if (node.leaf) { // check current node
+                  const index = findItem(item, node.children, equalsFn);
+
+                  if (index !== -1) {
+                      // item found, remove the item and condense tree upwards
+                      node.children.splice(index, 1);
+                      path.push(node);
+                      this._condense(path);
+                      return this;
+                  }
+              }
+
+              if (!goingUp && !node.leaf && contains(node, bbox)) { // go down
+                  path.push(node);
+                  indexes.push(i);
+                  i = 0;
+                  parent = node;
+                  node = node.children[0];
+
+              } else if (parent) { // go right
+                  i++;
+                  node = parent.children[i];
+                  goingUp = false;
+
+              } else node = null; // nothing found
+          }
+
+          return this;
+      }
+
+      toBBox(item) { return item; }
+
+      compareMinX(a, b) { return a.minX - b.minX; }
+      compareMinY(a, b) { return a.minY - b.minY; }
+
+      toJSON() { return this.data; }
+
+      fromJSON(data) {
+          this.data = data;
+          return this;
+      }
+
+      _all(node, result) {
+          const nodesToSearch = [];
+          while (node) {
+              if (node.leaf) result.push(...node.children);
+              else nodesToSearch.push(...node.children);
+
+              node = nodesToSearch.pop();
+          }
+          return result;
+      }
+
+      _build(items, left, right, height) {
+
+          const N = right - left + 1;
+          let M = this._maxEntries;
+          let node;
+
+          if (N <= M) {
+              // reached leaf level; return leaf
+              node = createNode(items.slice(left, right + 1));
+              calcBBox(node, this.toBBox);
+              return node;
+          }
+
+          if (!height) {
+              // target height of the bulk-loaded tree
+              height = Math.ceil(Math.log(N) / Math.log(M));
+
+              // target number of root entries to maximize storage utilization
+              M = Math.ceil(N / Math.pow(M, height - 1));
+          }
+
+          node = createNode([]);
+          node.leaf = false;
+          node.height = height;
+
+          // split the items into M mostly square tiles
+
+          const N2 = Math.ceil(N / M);
+          const N1 = N2 * Math.ceil(Math.sqrt(M));
+
+          multiSelect(items, left, right, N1, this.compareMinX);
+
+          for (let i = left; i <= right; i += N1) {
+
+              const right2 = Math.min(i + N1 - 1, right);
+
+              multiSelect(items, i, right2, N2, this.compareMinY);
+
+              for (let j = i; j <= right2; j += N2) {
+
+                  const right3 = Math.min(j + N2 - 1, right2);
+
+                  // pack each entry recursively
+                  node.children.push(this._build(items, j, right3, height - 1));
+              }
+          }
+
+          calcBBox(node, this.toBBox);
+
+          return node;
+      }
+
+      _chooseSubtree(bbox, node, level, path) {
+          while (true) {
+              path.push(node);
+
+              if (node.leaf || path.length - 1 === level) break;
+
+              let minArea = Infinity;
+              let minEnlargement = Infinity;
+              let targetNode;
+
+              for (let i = 0; i < node.children.length; i++) {
+                  const child = node.children[i];
+                  const area = bboxArea(child);
+                  const enlargement = enlargedArea(bbox, child) - area;
+
+                  // choose entry with the least area enlargement
+                  if (enlargement < minEnlargement) {
+                      minEnlargement = enlargement;
+                      minArea = area < minArea ? area : minArea;
+                      targetNode = child;
+
+                  } else if (enlargement === minEnlargement) {
+                      // otherwise choose one with the smallest area
+                      if (area < minArea) {
+                          minArea = area;
+                          targetNode = child;
+                      }
+                  }
+              }
+
+              node = targetNode || node.children[0];
+          }
+
+          return node;
+      }
+
+      _insert(item, level, isNode) {
+          const bbox = isNode ? item : this.toBBox(item);
+          const insertPath = [];
+
+          // find the best node for accommodating the item, saving all nodes along the path too
+          const node = this._chooseSubtree(bbox, this.data, level, insertPath);
+
+          // put the item into the node
+          node.children.push(item);
+          extend(node, bbox);
+
+          // split on node overflow; propagate upwards if necessary
+          while (level >= 0) {
+              if (insertPath[level].children.length > this._maxEntries) {
+                  this._split(insertPath, level);
+                  level--;
+              } else break;
+          }
+
+          // adjust bboxes along the insertion path
+          this._adjustParentBBoxes(bbox, insertPath, level);
+      }
+
+      // split overflowed node into two
+      _split(insertPath, level) {
+          const node = insertPath[level];
+          const M = node.children.length;
+          const m = this._minEntries;
+
+          this._chooseSplitAxis(node, m, M);
+
+          const splitIndex = this._chooseSplitIndex(node, m, M);
+
+          const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
+          newNode.height = node.height;
+          newNode.leaf = node.leaf;
+
+          calcBBox(node, this.toBBox);
+          calcBBox(newNode, this.toBBox);
+
+          if (level) insertPath[level - 1].children.push(newNode);
+          else this._splitRoot(node, newNode);
+      }
+
+      _splitRoot(node, newNode) {
+          // split root node
+          this.data = createNode([node, newNode]);
+          this.data.height = node.height + 1;
+          this.data.leaf = false;
+          calcBBox(this.data, this.toBBox);
+      }
+
+      _chooseSplitIndex(node, m, M) {
+          let index;
+          let minOverlap = Infinity;
+          let minArea = Infinity;
+
+          for (let i = m; i <= M - m; i++) {
+              const bbox1 = distBBox(node, 0, i, this.toBBox);
+              const bbox2 = distBBox(node, i, M, this.toBBox);
+
+              const overlap = intersectionArea(bbox1, bbox2);
+              const area = bboxArea(bbox1) + bboxArea(bbox2);
+
+              // choose distribution with minimum overlap
+              if (overlap < minOverlap) {
+                  minOverlap = overlap;
+                  index = i;
+
+                  minArea = area < minArea ? area : minArea;
+
+              } else if (overlap === minOverlap) {
+                  // otherwise choose distribution with minimum area
+                  if (area < minArea) {
+                      minArea = area;
+                      index = i;
+                  }
+              }
+          }
+
+          return index || M - m;
+      }
+
+      // sorts node children by the best axis for split
+      _chooseSplitAxis(node, m, M) {
+          const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;
+          const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;
+          const xMargin = this._allDistMargin(node, m, M, compareMinX);
+          const yMargin = this._allDistMargin(node, m, M, compareMinY);
+
+          // if total distributions margin value is minimal for x, sort by minX,
+          // otherwise it's already sorted by minY
+          if (xMargin < yMargin) node.children.sort(compareMinX);
+      }
+
+      // total margin of all possible split distributions where each node is at least m full
+      _allDistMargin(node, m, M, compare) {
+          node.children.sort(compare);
+
+          const toBBox = this.toBBox;
+          const leftBBox = distBBox(node, 0, m, toBBox);
+          const rightBBox = distBBox(node, M - m, M, toBBox);
+          let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);
+
+          for (let i = m; i < M - m; i++) {
+              const child = node.children[i];
+              extend(leftBBox, node.leaf ? toBBox(child) : child);
+              margin += bboxMargin(leftBBox);
+          }
+
+          for (let i = M - m - 1; i >= m; i--) {
+              const child = node.children[i];
+              extend(rightBBox, node.leaf ? toBBox(child) : child);
+              margin += bboxMargin(rightBBox);
+          }
+
+          return margin;
+      }
+
+      _adjustParentBBoxes(bbox, path, level) {
+          // adjust bboxes along the given tree path
+          for (let i = level; i >= 0; i--) {
+              extend(path[i], bbox);
+          }
+      }
+
+      _condense(path) {
+          // go through the path, removing empty nodes and updating bboxes
+          for (let i = path.length - 1, siblings; i >= 0; i--) {
+              if (path[i].children.length === 0) {
+                  if (i > 0) {
+                      siblings = path[i - 1].children;
+                      siblings.splice(siblings.indexOf(path[i]), 1);
+
+                  } else this.clear();
+
+              } else calcBBox(path[i], this.toBBox);
+          }
+      }
+  }
+
+  function findItem(item, items, equalsFn) {
+      if (!equalsFn) return items.indexOf(item);
+
+      for (let i = 0; i < items.length; i++) {
+          if (equalsFn(item, items[i])) return i;
+      }
+      return -1;
+  }
+
+  // calculate node's bbox from bboxes of its children
+  function calcBBox(node, toBBox) {
+      distBBox(node, 0, node.children.length, toBBox, node);
+  }
+
+  // min bounding rectangle of node children from k to p-1
+  function distBBox(node, k, p, toBBox, destNode) {
+      if (!destNode) destNode = createNode(null);
+      destNode.minX = Infinity;
+      destNode.minY = Infinity;
+      destNode.maxX = -Infinity;
+      destNode.maxY = -Infinity;
+
+      for (let i = k; i < p; i++) {
+          const child = node.children[i];
+          extend(destNode, node.leaf ? toBBox(child) : child);
+      }
+
+      return destNode;
+  }
+
+  function extend(a, b) {
+      a.minX = Math.min(a.minX, b.minX);
+      a.minY = Math.min(a.minY, b.minY);
+      a.maxX = Math.max(a.maxX, b.maxX);
+      a.maxY = Math.max(a.maxY, b.maxY);
+      return a;
+  }
+
+  function compareNodeMinX(a, b) { return a.minX - b.minX; }
+  function compareNodeMinY(a, b) { return a.minY - b.minY; }
+
+  function bboxArea(a)   { return (a.maxX - a.minX) * (a.maxY - a.minY); }
+  function bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }
+
+  function enlargedArea(a, b) {
+      return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *
+             (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
+  }
+
+  function intersectionArea(a, b) {
+      const minX = Math.max(a.minX, b.minX);
+      const minY = Math.max(a.minY, b.minY);
+      const maxX = Math.min(a.maxX, b.maxX);
+      const maxY = Math.min(a.maxY, b.maxY);
+
+      return Math.max(0, maxX - minX) *
+             Math.max(0, maxY - minY);
+  }
+
+  function contains(a, b) {
+      return a.minX <= b.minX &&
+             a.minY <= b.minY &&
+             b.maxX <= a.maxX &&
+             b.maxY <= a.maxY;
+  }
+
+  function intersects(a, b) {
+      return b.minX <= a.maxX &&
+             b.minY <= a.maxY &&
+             b.maxX >= a.minX &&
+             b.maxY >= a.minY;
+  }
+
+  function createNode(children) {
+      return {
+          children,
+          height: 1,
+          leaf: true,
+          minX: Infinity,
+          minY: Infinity,
+          maxX: -Infinity,
+          maxY: -Infinity
+      };
+  }
+
+  // sort an array so that items come in groups of n unsorted items, with groups sorted between each other;
+  // combines selection algorithm with binary divide & conquer approach
+
+  function multiSelect(arr, left, right, n, compare) {
+      const stack = [left, right];
+
+      while (stack.length) {
+          right = stack.pop();
+          left = stack.pop();
+
+          if (right - left <= n) continue;
+
+          const mid = left + Math.ceil((right - left) / n / 2) * n;
+          quickselect(arr, mid, left, right, compare);
+
+          stack.push(left, mid, mid, right);
+      }
+  }
+
   /**
-   * This class is an implementation of a dependency Graph.
+   * R-Tree Data Structure
+   *
+   * R-Tree is a spatial data structure used for efficient indexing and querying
+   * of multi-dimensional objects, particularly in geometric and spatial applications.
+   *
+   * It organizes objects into a tree hierarchy, grouping nearby objects together
+   * in bounding boxes. Each node in the tree represents a bounding box that
+   * contains its child nodes or leaf objects. This hierarchical structure allows
+   * for faster spatial queries.
+   *
+   * @see https://en.wikipedia.org/wiki/R-tree
+   *
+   * Consider a 2D Space with four zones: A, B, C, D
+   * +--------------------------+
+   * |                          |
+   * |   +---+     +-------+    |
+   * |   | A |     |   B   |    |
+   * |   +---+     +-------+    |
+   * |                          |
+   * |                          |
+   * |          +---+           |
+   * |          | C |           |
+   * |          +---+           |
+   * |      +-----------+       |
+   * |      |     D     |       |
+   * |      +-----------+       |
+   * |                          |
+   * +--------------------------+
+   *
+   * It groups together zones that are spatially close into a minimum bounding box.
+   * For example, A and B are grouped together in rectangle R1, and C and D are grouped
+   * in R2.
+   *
+   * R0
+   * +--------------------------+
+   * |   R1                     |
+   * |   +-----------------+    |
+   * |   | A |     |   B   |    |
+   * |   +-----------------+    |
+   * |                          |
+   * |      R2                  |
+   * |      +---+---+---+       |
+   * |      |   | C |   |       |
+   * |      |   +---+   |       |
+   * |      +-----------+       |
+   * |      |     D     |       |
+   * |      +-----------+       |
+   * |                          |
+   * +--------------------------+
+   *
+   * The tree would look like this:
+   *          R0
+   *         /  \
+   *        /    \
+   *       R1     R2
+   *       |      |
+   *      A,B    C,D
+
+   * Choosing how to group the zones is crucial for the performance of the tree.
+   * Key considerations include avoiding excessive empty space coverage and minimizing overlap
+   * to reduce the number of subtrees processed during searches.
+   *
+   * Various heuristics exist for determining the optimal grouping strategy, such as "least enlargement"
+   * which prioritizes grouping nodes resulting in the smallest increase in bounding box size. In cases where
+   * the choice cannot be made based on this criterion due to the same enlargement for different groupings,
+   * we then evaluate "least area," aiming to minimize the overall area of bounding boxes.
+   *
+   * This implementation is tailored for spreadsheet use, indexing objects associated
+   * with a zone and a sheet.
+   *
+   * It uses the RBush library under the hood. One 2D RBush R-tree per sheet.
+   * @see https://github.com/mourner/rbush
+   */
+  class SpreadsheetRTree {
+      /**
+       * One 2D R-tree per sheet
+       */
+      rTrees = {};
+      /**
+       * Bulk-inserts the given items into the tree. Bulk insertion is usually ~2-3 times
+       * faster than inserting items one by one. After bulk loading (bulk insertion into
+       * an empty tree), subsequent query performance is also ~20-30% better.
+       */
+      constructor(items = []) {
+          const rangesPerSheet = {};
+          for (const item of items) {
+              const sheetId = item.boundingBox.sheetId;
+              if (!rangesPerSheet[sheetId]) {
+                  rangesPerSheet[sheetId] = [];
+              }
+              rangesPerSheet[sheetId].push(item);
+          }
+          for (const sheetId in rangesPerSheet) {
+              this.rTrees[sheetId] = new ZoneRBush();
+              this.rTrees[sheetId].load(rangesPerSheet[sheetId]); // bulk-insert
+          }
+      }
+      insert(item) {
+          const sheetId = item.boundingBox.sheetId;
+          if (!this.rTrees[sheetId]) {
+              this.rTrees[sheetId] = new ZoneRBush();
+          }
+          this.rTrees[sheetId].insert(item);
+      }
+      search({ zone, sheetId }) {
+          if (!this.rTrees[sheetId]) {
+              return [];
+          }
+          return this.rTrees[sheetId].search({
+              minX: zone.left,
+              minY: zone.top,
+              maxX: zone.right,
+              maxY: zone.bottom,
+          });
+      }
+      remove(item) {
+          const sheetId = item.boundingBox.sheetId;
+          if (!this.rTrees[sheetId]) {
+              return;
+          }
+          this.rTrees[sheetId].remove(item, deepEquals);
+      }
+  }
+  /**
+   * RBush extension to use zones as bounding boxes
+   */
+  class ZoneRBush extends RBush {
+      toBBox({ boundingBox }) {
+          const zone = boundingBox.zone;
+          return {
+              minX: zone.left,
+              minY: zone.top,
+              maxX: zone.right,
+              maxY: zone.bottom,
+          };
+      }
+      compareMinX(a, b) {
+          return a.boundingBox.zone.left - b.boundingBox.zone.left;
+      }
+      compareMinY(a, b) {
+          return a.boundingBox.zone.top - b.boundingBox.zone.top;
+      }
+  }
+
+  /**
+   * Implementation of a dependency Graph.
    * The graph is used to evaluate the cells in the correct
    * order, and should be updated each time a cell's content is modified
    *
+   * It uses an R-Tree data structure to efficiently find dependent cells.
    */
   class FormulaDependencyGraph {
-      /**
-       * Internal structure:
-       * - key: a cell position (encoded as an integer)
-       * - value: a set of cell positions that depends on the key
-       *
-       * Given
-       * - A1:"= B1 + SQRT(B2)"
-       * - C1:"= B1";
-       * - C2:"= C1"
-       *
-       * we will have something like:
-       * - B1 ---> (A1, C1)   meaning A1 and C1 depends on B1
-       * - B2 ---> (A1)       meaning A1 depends on B2
-       * - C1 ---> (C2)       meaning C2 depends on C1
-       */
-      inverseDependencies = new Map();
+      encoder;
       dependencies = new Map();
+      rTree;
+      constructor(encoder, data = []) {
+          this.encoder = encoder;
+          this.rTree = new SpreadsheetRTree(data);
+      }
       removeAllDependencies(formulaPositionId) {
-          const dependencies = this.dependencies.get(formulaPositionId);
-          if (!dependencies) {
+          const ranges = this.dependencies.get(formulaPositionId);
+          if (!ranges) {
               return;
           }
-          for (const dependency of dependencies) {
-              this.inverseDependencies.get(dependency)?.delete(formulaPositionId);
+          for (const range of ranges) {
+              this.rTree.remove(range);
           }
           this.dependencies.delete(formulaPositionId);
       }
       addDependencies(formulaPositionId, dependencies) {
-          for (const dependency of dependencies) {
-              const inverseDependencies = this.inverseDependencies.get(dependency);
-              if (inverseDependencies) {
-                  inverseDependencies.add(formulaPositionId);
-              }
-              else {
-                  this.inverseDependencies.set(dependency, new Set([formulaPositionId]));
-              }
+          const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
+              data: formulaPositionId,
+              boundingBox: {
+                  zone,
+                  sheetId,
+              },
+          }));
+          for (const item of rTreeItems) {
+              this.rTree.insert(item);
           }
           const existingDependencies = this.dependencies.get(formulaPositionId);
           if (existingDependencies) {
-              existingDependencies.push(...dependencies);
+              existingDependencies.push(...rTreeItems);
           }
           else {
-              this.dependencies.set(formulaPositionId, dependencies);
+              this.dependencies.set(formulaPositionId, rTreeItems);
           }
       }
       /**
@@ -40098,20 +40876,20 @@
        * in the correct order they should be evaluated.
        * This is called a topological ordering (excluding cycles)
        */
-      getCellsDependingOn(positionIds) {
+      getCellsDependingOn(ranges) {
           const visited = new JetSet();
-          const queue = Array.from(positionIds).reverse();
+          const queue = Array.from(ranges).reverse();
           while (queue.length > 0) {
-              const node = queue.pop();
-              visited.add(node);
-              const adjacentNodes = this.inverseDependencies.get(node) || new Set();
-              for (const adjacentNode of adjacentNodes) {
-                  if (!visited.has(adjacentNode)) {
-                      queue.push(adjacentNode);
+              const range = queue.pop();
+              visited.add(...this.encoder.encodeBoundingBox(range));
+              const impactedPositionIds = this.rTree.search(range).map((dep) => dep.data);
+              for (const positionId of impactedPositionIds) {
+                  if (!visited.has(positionId)) {
+                      queue.push(this.encoder.decodeToBoundingBox(positionId));
                   }
               }
           }
-          visited.delete(...positionIds);
+          visited.delete(...ranges.flatMap((r) => this.encoder.encodeBoundingBox(r)));
           return visited;
       }
   }
@@ -40199,9 +40977,9 @@
       context;
       getters;
       compilationParams;
-      positionEncoder = new PositionBitsEncoder();
+      encoder = new PositionBitsEncoder();
       evaluatedCells = new Map();
-      formulaDependencies = lazy(new FormulaDependencyGraph());
+      formulaDependencies = lazy(new FormulaDependencyGraph(this.encoder));
       blockedArrayFormulas = new Set();
       spreadingRelations = new SpreadingRelation();
       constructor(context, getters) {
@@ -40210,23 +40988,23 @@
           this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
       }
       getEvaluatedCell(position) {
-          return (this.evaluatedCells.get(this.encodePosition(position)) ||
+          return (this.evaluatedCells.get(this.encoder.encode(position)) ||
               createEvaluatedCell("", { locale: this.getters.getLocale() }));
       }
       getSpreadPositionsOf(position) {
-          const positionId = this.encodePosition(position);
+          const positionId = this.encoder.encode(position);
           if (!this.spreadingRelations.isArrayFormula(positionId)) {
               return [];
           }
-          return Array.from(this.spreadingRelations.getArrayResultPositionIds(positionId)).map(this.decodePosition.bind(this));
+          return Array.from(this.spreadingRelations.getArrayResultPositionIds(positionId)).map((positionId) => this.encoder.decode(positionId));
       }
       getArrayFormulaSpreadingOn(position) {
-          const positionId = this.encodePosition(position);
+          const positionId = this.encoder.encode(position);
           const formulaPosition = this.getArrayFormulaSpreadingOnId(positionId);
-          return formulaPosition !== undefined ? this.decodePosition(formulaPosition) : undefined;
+          return formulaPosition !== undefined ? this.encoder.decode(formulaPosition) : undefined;
       }
       getEvaluatedPositions() {
-          return [...this.evaluatedCells.keys()].map(this.decodePosition.bind(this));
+          return [...this.evaluatedCells.keys()].map((p) => this.encoder.decode(p));
       }
       getArrayFormulaSpreadingOnId(positionId) {
           if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
@@ -40236,7 +41014,7 @@
           return Array.from(arrayFormulas).find((positionId) => !this.blockedArrayFormulas.has(positionId));
       }
       updateDependencies(position) {
-          const positionId = this.encodePosition(position);
+          const positionId = this.encoder.encode(position);
           this.formulaDependencies().removeAllDependencies(positionId);
           const dependencies = this.getDirectDependencies(positionId);
           this.formulaDependencies().addDependencies(positionId, dependencies);
@@ -40246,12 +41024,12 @@
           this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
       }
       evaluateCells(positions) {
-          const cells = positions.map(this.encodePosition.bind(this));
+          const cells = positions.map((p) => this.encoder.encode(p));
           const cellsToCompute = new JetSet(cells);
-          const arrayFormulas = this.getArrayFormulasImpactedByChangesOf(cells);
+          const arrayFormulasPositionIds = this.getArrayFormulasImpactedByChangesOf(cells);
           cellsToCompute.add(...this.getCellsDependingOn(cells));
-          cellsToCompute.add(...arrayFormulas);
-          cellsToCompute.add(...this.getCellsDependingOn(arrayFormulas));
+          cellsToCompute.add(...arrayFormulasPositionIds);
+          cellsToCompute.add(...this.getCellsDependingOn(arrayFormulasPositionIds));
           this.evaluate(cellsToCompute);
       }
       getArrayFormulasImpactedByChangesOf(positionIds) {
@@ -40274,12 +41052,14 @@
           this.blockedArrayFormulas = new Set();
           this.spreadingRelations = new SpreadingRelation();
           this.formulaDependencies = lazy(() => {
-              const dependencyGraph = new FormulaDependencyGraph();
-              for (const positionId of this.getAllCells()) {
-                  const dependencies = this.getDirectDependencies(positionId);
-                  dependencyGraph.addDependencies(positionId, dependencies);
-              }
-              return dependencyGraph;
+              const dependencies = [...this.getAllCells()].flatMap((positionId) => this.getDirectDependencies(positionId).map((range) => ({
+                  data: positionId,
+                  boundingBox: {
+                      zone: range.zone,
+                      sheetId: range.sheetId,
+                  },
+              })));
+              return new FormulaDependencyGraph(this.encoder, dependencies);
           });
       }
       evaluateAllCells() {
@@ -40301,7 +41081,7 @@
           for (const sheetId of this.getters.getSheetIds()) {
               const cellIds = this.getters.getCells(sheetId);
               for (const cellId in cellIds) {
-                  positionIds.add(this.encodePosition(this.getters.getCellPosition(cellId)));
+                  positionIds.add(this.encoder.encode(this.getters.getCellPosition(cellId)));
               }
           }
           return positionIds;
@@ -40346,7 +41126,7 @@
           if (!this.blockedArrayFormulas.has(positionId)) {
               this.invalidateSpreading(positionId);
           }
-          const cellPosition = this.decodePosition(positionId);
+          const cellPosition = this.encoder.decode(positionId);
           const cell = this.getters.getCell(cellPosition);
           if (cell === undefined) {
               return createEvaluatedCell("", { locale: this.getters.getLocale() });
@@ -40369,7 +41149,7 @@
           }
       }
       computeAndSave(position) {
-          const positionId = this.encodePosition(position);
+          const positionId = this.encoder.encode(position);
           const evaluatedCell = this.computeCell(positionId);
           if (!this.evaluatedCells.has(positionId)) {
               this.setEvaluatedCell(positionId, evaluatedCell);
@@ -40424,15 +41204,15 @@
           throw new Error(_t("Result couldn't be automatically expanded. Please insert more columns and rows."));
       }
       updateSpreadRelation({ sheetId, col, row, }) {
-          const arrayFormulaPositionId = this.encodePosition({ sheetId, col, row });
+          const arrayFormulaPositionId = this.encoder.encode({ sheetId, col, row });
           return (i, j) => {
               const position = { sheetId, col: i + col, row: j + row };
-              const resultPositionId = this.encodePosition(position);
+              const resultPositionId = this.encoder.encode(position);
               this.spreadingRelations.addRelation({ resultPositionId, arrayFormulaPositionId });
           };
       }
       checkCollision({ sheetId, col, row }) {
-          const formulaPositionId = this.encodePosition({ sheetId, col, row });
+          const formulaPositionId = this.encoder.encode({ sheetId, col, row });
           return (i, j) => {
               const position = { sheetId: sheetId, col: i + col, row: j + row };
               const rawCell = this.getters.getCell(position);
@@ -40453,7 +41233,7 @@
                   format: format || matrixResult[i][j]?.format,
                   locale: this.getters.getLocale(),
               });
-              const positionId = this.encodePosition(position);
+              const positionId = this.encoder.encode(position);
               this.setEvaluatedCell(positionId, evaluatedCell);
               // check if formula dependencies present in the spread zone
               // if so, they need to be recomputed
@@ -40485,29 +41265,17 @@
           if (!cell?.isFormula) {
               return [];
           }
-          const dependencies = [];
-          for (const range of cell.compiledFormula.dependencies) {
-              if (range.invalidSheetName || range.invalidXc) {
-                  continue;
-              }
-              const sheetId = range.sheetId;
-              forEachPositionsInZone(range.zone, (col, row) => {
-                  dependencies.push(this.encodePosition({ sheetId, col, row }));
-              });
-          }
-          return dependencies;
+          return cell.compiledFormula.dependencies;
       }
       getCellsDependingOn(positionIds) {
-          return this.formulaDependencies().getCellsDependingOn(positionIds);
+          const ranges = [];
+          for (const positionId of positionIds) {
+              ranges.push(this.encoder.decodeToBoundingBox(positionId));
+          }
+          return this.formulaDependencies().getCellsDependingOn(ranges);
       }
       getCell(positionId) {
-          return this.getters.getCell(this.decodePosition(positionId));
-      }
-      encodePosition(position) {
-          return this.positionEncoder.encode(position);
-      }
-      decodePosition(positionId) {
-          return this.positionEncoder.decode(positionId);
+          return this.getters.getCell(this.encoder.decode(positionId));
       }
   }
   function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
@@ -40563,6 +41331,13 @@
       encode({ sheetId, col, row }) {
           return (this.encodeSheet(sheetId) << 42n) | (BigInt(col) << 21n) | BigInt(row);
       }
+      encodeBoundingBox({ sheetId, zone }) {
+          const positions = [];
+          forEachPositionsInZone(zone, (col, row) => {
+              positions.push(this.encode({ sheetId, col, row }));
+          });
+          return positions;
+      }
       decode(id) {
           // keep only the last 21 bits by AND-ing the bit sequence with 21 ones
           const row = Number(id & 2097151n);
@@ -40570,6 +41345,10 @@
           const sheetId = this.decodeSheet(id >> 42n);
           return { sheetId, col, row };
       }
+      decodeToBoundingBox(id) {
+          const { sheetId, col, row } = this.decode(id);
+          return { sheetId, zone: { left: col, top: row, right: col, bottom: row } };
+      }
       encodeSheet(sheetId) {
           const sheetKey = this.sheetMapping[sheetId];
           if (sheetKey === undefined) {
@@ -40752,7 +41531,12 @@
       // Getters
       // ---------------------------------------------------------------------------
       evaluateFormula(sheetId, formulaString) {
-          return this.evaluator.evaluateFormula(sheetId, formulaString);
+          try {
+              return this.evaluator.evaluateFormula(sheetId, formulaString);
+          }
+          catch (error) {
+              return error instanceof EvaluationError ? error.errorType : CellErrorType.GenericError;
+          }
       }
       /**
        * Return the value of each cell in the range as they are displayed in the grid.
@@ -41021,7 +41805,7 @@
   }
 
   class EvaluationChartPlugin extends UIPlugin {
-      static getters = ["getChartRuntime", "getBackgroundOfSingleCellChart"];
+      static getters = ["getChartRuntime", "getStyleOfSingleCellChart"];
       charts = {};
       createRuntimeChart = chartRuntimeFactory(this.getters);
       handle(cmd) {
@@ -41059,25 +41843,26 @@
           return this.charts[figureId];
       }
       /**
-       * Get the background color of a chart based on the color of the first cell of the main range
-       * of the chart. In order of priority, it will return :
-       *
-       *  - the chart background color if one is defined
-       *  - the fill color of the cell if one is defined
-       *  - the fill color of the cell from conditional formats if one is defined
-       *  - the default chart color if no other color is defined
+       * Get the background and textColor of a chart based on the color of the first cell of the main range of the chart.
        */
-      getBackgroundOfSingleCellChart(chartBackground, mainRange) {
+      getStyleOfSingleCellChart(chartBackground, mainRange) {
           if (chartBackground)
-              return chartBackground;
+              return { background: chartBackground, fontColor: chartFontColor(chartBackground) };
           if (!mainRange) {
-              return BACKGROUND_CHART_COLOR;
+              return {
+                  background: BACKGROUND_CHART_COLOR,
+                  fontColor: chartFontColor(BACKGROUND_CHART_COLOR),
+              };
           }
           const col = mainRange.zone.left;
           const row = mainRange.zone.top;
           const sheetId = mainRange.sheetId;
           const style = this.getters.getCellComputedStyle({ sheetId, col, row });
-          return style.fillColor || BACKGROUND_CHART_COLOR;
+          const background = style.fillColor || BACKGROUND_CHART_COLOR;
+          return {
+              background,
+              fontColor: style.textColor || chartFontColor(background),
+          };
       }
       exportForExcel(data) {
           for (const sheet of data.sheets) {
@@ -41133,7 +41918,7 @@
       // ---------------------------------------------------------------------------
       handle(cmd) {
           if (invalidateCFEvaluationCommands.has(cmd.type) ||
-              (cmd.type === "UPDATE_CELL" && "content" in cmd)) {
+              (cmd.type === "UPDATE_CELL" && ("content" in cmd || "format" in cmd))) {
               this.isStale = true;
           }
       }
@@ -41188,45 +41973,40 @@
       getComputedStyles(sheetId) {
           const computedStyle = {};
           for (let cf of this.getters.getConditionalFormats(sheetId).reverse()) {
-              try {
-                  switch (cf.rule.type) {
-                      case "ColorScaleRule":
-                          for (let range of cf.ranges) {
-                              this.applyColorScale(sheetId, range, cf.rule, computedStyle);
-                          }
-                          break;
-                      case "CellIsRule":
-                          const formulas = cf.rule.values.map((value) => value.startsWith("=") ? compile(value) : undefined);
-                          for (let ref of cf.ranges) {
-                              const zone = this.getters.getRangeFromSheetXC(sheetId, ref).zone;
-                              for (let row = zone.top; row <= zone.bottom; row++) {
-                                  for (let col = zone.left; col <= zone.right; col++) {
-                                      const predicate = this.rulePredicate[cf.rule.type];
-                                      const target = { sheetId, col, row };
-                                      const values = cf.rule.values.map((value, i) => {
-                                          const compiledFormula = formulas[i];
-                                          if (compiledFormula) {
-                                              return this.getters.getTranslatedCellFormula(sheetId, col - zone.left, row - zone.top, {
-                                                  ...compiledFormula,
-                                                  dependencies: compiledFormula.dependencies.map((d) => this.getters.getRangeFromSheetXC(sheetId, d)),
-                                              });
-                                          }
-                                          return value;
-                                      });
-                                      if (predicate && predicate(target, { ...cf.rule, values })) {
-                                          if (!computedStyle[col])
-                                              computedStyle[col] = [];
-                                          // we must combine all the properties of all the CF rules applied to the given cell
-                                          computedStyle[col][row] = Object.assign(computedStyle[col]?.[row] || {}, cf.rule.style);
+              switch (cf.rule.type) {
+                  case "ColorScaleRule":
+                      for (let range of cf.ranges) {
+                          this.applyColorScale(sheetId, range, cf.rule, computedStyle);
+                      }
+                      break;
+                  case "CellIsRule":
+                      const formulas = cf.rule.values.map((value) => value.startsWith("=") ? compile(value) : undefined);
+                      for (let ref of cf.ranges) {
+                          const zone = this.getters.getRangeFromSheetXC(sheetId, ref).zone;
+                          for (let row = zone.top; row <= zone.bottom; row++) {
+                              for (let col = zone.left; col <= zone.right; col++) {
+                                  const predicate = this.rulePredicate[cf.rule.type];
+                                  const target = { sheetId, col, row };
+                                  const values = cf.rule.values.map((value, i) => {
+                                      const compiledFormula = formulas[i];
+                                      if (compiledFormula) {
+                                          return this.getters.getTranslatedCellFormula(sheetId, col - zone.left, row - zone.top, {
+                                              ...compiledFormula,
+                                              dependencies: compiledFormula.dependencies.map((d) => this.getters.getRangeFromSheetXC(sheetId, d)),
+                                          });
                                       }
+                                      return value;
+                                  });
+                                  if (predicate && predicate(target, { ...cf.rule, values })) {
+                                      if (!computedStyle[col])
+                                          computedStyle[col] = [];
+                                      // we must combine all the properties of all the CF rules applied to the given cell
+                                      computedStyle[col][row] = Object.assign(computedStyle[col]?.[row] || {}, cf.rule.style);
                                   }
                               }
                           }
-                          break;
-                  }
-              }
-              catch (_) {
-                  // we don't care about the errors within the evaluation of a rule
+                      }
+                      break;
               }
           }
           return computedStyle;
@@ -41459,7 +42239,7 @@
       handle(cmd) {
           if (invalidateEvaluationCommands.has(cmd.type) ||
               cmd.type === "EVALUATE_CELLS" ||
-              (cmd.type === "UPDATE_CELL" && "content" in cmd)) {
+              (cmd.type === "UPDATE_CELL" && ("content" in cmd || "format" in cmd))) {
               this.validationResults = {};
               return;
           }
@@ -41837,11 +42617,6 @@
                       return "Success" /* CommandResult.Success */;
                   }
                   return "InvalidAutofillSelection" /* CommandResult.InvalidAutofillSelection */;
-              case "AUTOFILL_AUTO":
-                  const zone = this.getters.getSelectedZone();
-                  return zone.top === zone.bottom
-                      ? "Success" /* CommandResult.Success */
-                      : "CancelledForUnknownReason" /* CommandResult.CancelledForUnknownReason */;
           }
           return "Success" /* CommandResult.Success */;
       }
@@ -41997,19 +42772,21 @@
           let col = zone.left;
           let row = zone.bottom;
           if (col > 0) {
-              let left = this.getters.getEvaluatedCell({ sheetId, col: col - 1, row });
-              while (left.type !== CellValueType.empty) {
+              let leftPosition = { sheetId, col: col - 1, row };
+              while (this.getters.getCorrespondingFormulaCell(leftPosition) ||
+                  this.getters.getCell(leftPosition)?.content) {
                   row += 1;
-                  left = this.getters.getEvaluatedCell({ sheetId, col: col - 1, row });
+                  leftPosition = { sheetId, col: col - 1, row };
               }
           }
           if (row === zone.bottom) {
               col = zone.right;
               if (col <= this.getters.getNumberCols(sheetId)) {
-                  let right = this.getters.getEvaluatedCell({ sheetId, col: col + 1, row });
-                  while (right.type !== CellValueType.empty) {
+                  let rightPosition = { sheetId, col: col + 1, row };
+                  while (this.getters.getCorrespondingFormulaCell(rightPosition) ||
+                      this.getters.getCell(rightPosition)?.content) {
                       row += 1;
-                      right = this.getters.getEvaluatedCell({ sheetId, col: col + 1, row });
+                      rightPosition = { sheetId, col: col + 1, row };
                   }
               }
           }
@@ -43001,6 +43778,7 @@
       isReplayingInitialRevisions = false;
       processedRevisions = new Set();
       uuidGenerator = new UuidGenerator();
+      lastLocalOperation;
       /**
        * Manages the collaboration between multiple users on the same spreadsheet.
        * It can forward local state changes to other users to ensure they all eventually
@@ -43033,6 +43811,11 @@
               return;
           const revision = new Revision(this.uuidGenerator.uuidv4(), this.clientId, commands, rootCommand, changes, Date.now());
           this.revisions.append(revision.id, revision);
+          // REQUEST_REDO just repeats the last operation, the
+          // last operation is still the same and should not change.
+          if (rootCommand.type !== "REQUEST_REDO") {
+              this.lastLocalOperation = revision;
+          }
           this.trigger("new-local-state-update", { id: revision.id });
           this.sendUpdateMessage({
               type: "REMOTE_REVISION",
@@ -43129,19 +43912,10 @@
           return this.pendingMessages.length === 0;
       }
       /**
-       * Get the last local revision whose root command isn't in the given list of ignored commands
+       * Get the last local revision
        * */
-      getLastLocalNonEmptyRevision(ignoredRootCommands) {
-          const revisions = this.revisions.getRevertedExecution();
-          for (const rev of revisions) {
-              if (rev.rootCommand === "SNAPSHOT")
-                  return undefined;
-              if (!rev.rootCommand || rev.rootCommand === "REMOTE")
-                  continue;
-              if (!ignoredRootCommands.includes(rev.rootCommand?.type) && rev.commands.length)
-                  return rev;
-          }
-          return undefined;
+      getLastLocalNonEmptyRevision() {
+          return this.lastLocalOperation;
       }
       _move(position) {
           // this method is debounced and might be called after the client
@@ -43201,7 +43975,7 @@
                   break;
               case "REMOTE_REVISION":
                   const { clientId, commands, timestamp } = message;
-                  const revision = new Revision(message.nextRevisionId, clientId, commands, "REMOTE", undefined, timestamp);
+                  const revision = new Revision(message.nextRevisionId, clientId, commands, undefined, undefined, timestamp);
                   if (revision.clientId !== this.clientId) {
                       this.revisions.insert(revision.id, revision, message.serverRevisionId);
                       const pendingCommands = this.pendingMessages
@@ -43214,10 +43988,11 @@
                   }
                   break;
               case "SNAPSHOT_CREATED": {
-                  const revision = new Revision(message.nextRevisionId, "server", [], "SNAPSHOT", undefined, Date.now());
+                  const revision = new Revision(message.nextRevisionId, "server", [], undefined, undefined, Date.now());
                   this.revisions.insert(revision.id, revision, message.serverRevisionId);
                   this.dropPendingHistoryMessages();
                   this.trigger("snapshot");
+                  this.lastLocalOperation = undefined;
                   break;
               }
           }
@@ -43603,7 +44378,7 @@
       isPasteAllowed(target, clipboardOption) {
           const sheetId = this.getters.getActiveSheetId();
           if (this.operation === "CUT" && clipboardOption?.pasteOption !== undefined) {
-              // cannot paste only format or only value if the previous operation is a CUT
+              // cannot paste only format or as value if the previous operation is a CUT
               return "WrongPasteOption" /* CommandResult.WrongPasteOption */;
           }
           if (target.length > 1) {
@@ -43785,7 +44560,7 @@
           // This condition is used to determine if we have to paste the CF or not.
           // We have to do it when the command handled is "PASTE", not "INSERT_CELL"
           // or "DELETE_CELL". So, the state should be the local state
-          const shouldPasteCF = clipboardOptions?.pasteOption !== "onlyValue" && clipboardOptions?.shouldPasteCF;
+          const shouldPasteCF = clipboardOptions?.pasteOption !== "asValue" && clipboardOptions?.shouldPasteCF;
           const shouldPasteDV = !clipboardOptions?.pasteOption;
           const sheetId = this.getters.getActiveSheetId();
           // first, add missing cols/rows if needed
@@ -43821,10 +44596,11 @@
       pasteCell(origin, target, operation, clipboardOption) {
           const { sheetId, col, row } = target;
           const targetCell = this.getters.getEvaluatedCell(target);
-          if (clipboardOption?.pasteOption === "onlyValue") {
+          const originFormat = origin.cell?.format ?? origin.evaluatedCell.format;
+          if (clipboardOption?.pasteOption === "asValue") {
               const locale = this.getters.getLocale();
               const content = formatValue(origin.evaluatedCell.value, { locale });
-              this.dispatch("UPDATE_CELL", { ...target, content });
+              this.dispatch("UPDATE_CELL", { ...target, content, format: originFormat });
               return;
           }
           const targetBorders = this.getters.getCellBorder(target);
@@ -43840,7 +44616,7 @@
               this.dispatch("UPDATE_CELL", {
                   ...target,
                   style: origin.cell?.style ?? null,
-                  format: origin.cell?.format ?? origin.evaluatedCell.format ?? targetCell.format,
+                  format: originFormat ?? targetCell.format,
               });
               return;
           }
@@ -45862,6 +46638,9 @@
       // Other
       // ---------------------------------------------------------------------------
       initInput(id, initialRanges, inputHasSingleRange = false) {
+          if (this.inputs[id]) {
+              this.unfocus();
+          }
           this.inputs[id] = new SelectionInputPlugin(this.config, initialRanges, inputHasSingleRange);
           if (initialRanges.length === 0) {
               const input = this.inputs[id];
@@ -46570,7 +47349,7 @@
        * Ignore standard undo/redo revisions (that are empty)
        */
       getPossibleRevisionToRepeat() {
-          return this.session.getLastLocalNonEmptyRevision(["REQUEST_REDO"]);
+          return this.session.getLastLocalNonEmptyRevision();
       }
   }
 
@@ -48041,6 +48820,12 @@
                   break;
               case "HIDE_COLUMNS_ROWS":
               case "UNHIDE_COLUMNS_ROWS":
+              case "GROUP_HEADERS":
+              case "UNGROUP_HEADERS":
+              case "FOLD_HEADER_GROUP":
+              case "UNFOLD_HEADER_GROUP":
+              case "FOLD_ALL_HEADER_GROUPS":
+              case "UNFOLD_ALL_HEADER_GROUPS":
                   this.updateHiddenRows();
                   break;
               case "UPDATE_FILTER":
@@ -48742,7 +49527,7 @@
               sheetId: cmd.sheetId,
               base: cmd.base,
               quantity: thickness,
-              position: "before",
+              position: cmd.position,
           });
           const isCol = cmd.dimension === "COL";
           const start = cmd.elements[0];
@@ -48759,12 +49544,13 @@
               },
           ];
           const state = new ClipboardCellsState(target, "CUT", this.getters, this.dispatch, this.selection);
+          const base = isBasedBefore ? cmd.base : cmd.base + 1;
           const pasteTarget = [
               {
-                  left: isCol ? cmd.base : 0,
-                  right: isCol ? cmd.base + thickness - 1 : this.getters.getNumberCols(cmd.sheetId) - 1,
-                  top: !isCol ? cmd.base : 0,
-                  bottom: !isCol ? cmd.base + thickness - 1 : this.getters.getNumberRows(cmd.sheetId) - 1,
+                  left: isCol ? base : 0,
+                  right: isCol ? base + thickness - 1 : this.getters.getNumberCols(cmd.sheetId) - 1,
+                  top: !isCol ? base : 0,
+                  bottom: !isCol ? base + thickness - 1 : this.getters.getNumberRows(cmd.sheetId) - 1,
               },
           ];
           state.paste(pasteTarget, { selectTarget: true });
@@ -48799,6 +49585,11 @@
               doesElementsHaveCommonMerges(id, cmd.base - 1, cmd.base)) {
               return "WillRemoveExistingMerge" /* CommandResult.WillRemoveExistingMerge */;
           }
+          const headers = [cmd.base, ...cmd.elements];
+          const maxHeaderValue = isCol ? this.getters.getNumberCols(id) : this.getters.getNumberRows(id);
+          if (headers.some((h) => h < 0 || h >= maxHeaderValue)) {
+              return "InvalidHeaderIndex" /* CommandResult.InvalidHeaderIndex */;
+          }
           return "Success" /* CommandResult.Success */;
       }
       //-------------------------------------------
@@ -48976,9 +49767,6 @@
        */
       adjustPosition(position) {
           const sheetId = this.sheetId;
-          if (!position) {
-              position = this.getters.getSheetPosition(sheetId);
-          }
           const mainCellPosition = this.getters.getMainCellPosition({ sheetId, ...position });
           const { col, row } = this.getters.getNextVisibleCellPosition(mainCellPosition);
           if (isInside(col, this.boundaries.top, this.boundaries)) {
@@ -48991,56 +49779,50 @@
       adjustPositionX(targetCol) {
           const sheetId = this.sheetId;
           const { end } = this.getters.getColDimensions(sheetId, targetCol);
-          const maxCol = this.getters.getNumberCols(sheetId);
           if (this.offsetX + this.offsetCorrectionX + this.viewportWidth < end) {
+              const maxCol = this.getters.getNumberCols(sheetId);
               let finalTarget = targetCol;
-              while (this.getters.isColHidden(sheetId, finalTarget) && targetCol < maxCol) {
+              while (this.getters.isColHidden(sheetId, finalTarget) && finalTarget < maxCol) {
                   finalTarget++;
               }
               const finalTargetEnd = this.getters.getColDimensions(sheetId, finalTarget).end;
               const startIndex = this.searchHeaderIndex("COL", finalTargetEnd - this.viewportWidth - this.offsetCorrectionX, this.boundaries.left);
-              this.offsetX =
+              this.offsetScrollbarX =
                   this.getters.getColDimensions(sheetId, startIndex).end - this.offsetCorrectionX;
-              this.offsetScrollbarX = this.offsetX;
-              this.adjustViewportZoneX();
           }
           else if (this.left > targetCol) {
               let finalTarget = targetCol;
-              while (this.getters.isColHidden(sheetId, finalTarget) && targetCol > 0) {
+              while (this.getters.isColHidden(sheetId, finalTarget) && finalTarget > 0) {
                   finalTarget--;
               }
-              this.offsetX =
+              this.offsetScrollbarX =
                   this.getters.getColDimensions(sheetId, finalTarget).start - this.offsetCorrectionX;
-              this.offsetScrollbarX = this.offsetX;
-              this.adjustViewportZoneX();
           }
+          this.adjustViewportZoneX();
       }
       adjustPositionY(targetRow) {
           const sheetId = this.sheetId;
           const { end } = this.getters.getRowDimensions(sheetId, targetRow);
-          const maxRow = this.getters.getNumberRows(sheetId);
           if (this.offsetY + this.viewportHeight + this.offsetCorrectionY < end) {
+              const maxRow = this.getters.getNumberRows(sheetId);
               let finalTarget = targetRow;
-              while (this.getters.isRowHidden(sheetId, finalTarget) && targetRow < maxRow) {
+              while (this.getters.isRowHidden(sheetId, finalTarget) && finalTarget < maxRow) {
                   finalTarget++;
               }
               const finalTargetEnd = this.getters.getRowDimensions(sheetId, finalTarget).end;
               const startIndex = this.searchHeaderIndex("ROW", finalTargetEnd - this.viewportHeight - this.offsetCorrectionY, this.boundaries.top);
-              this.offsetY =
+              this.offsetScrollbarY =
                   this.getters.getRowDimensions(sheetId, startIndex).end - this.offsetCorrectionY;
-              this.offsetScrollbarY = this.offsetY;
-              this.adjustViewportZoneY();
           }
           else if (this.top > targetRow) {
               let finalTarget = targetRow;
-              while (this.getters.isRowHidden(sheetId, finalTarget) && targetRow > 0) {
+              while (this.getters.isRowHidden(sheetId, finalTarget) && finalTarget > 0) {
                   finalTarget--;
               }
-              this.offsetY =
+              this.offsetScrollbarY =
                   this.getters.getRowDimensions(sheetId, finalTarget).start - this.offsetCorrectionY;
-              this.offsetScrollbarY = this.offsetY;
-              this.adjustViewportZoneY();
           }
+          this.adjustViewportZoneY();
       }
       setViewportOffset(offsetX, offsetY) {
           this.setViewportOffsetX(offsetX);
@@ -49056,11 +49838,10 @@
        * @returns Computes the absolute coordinate of a given zone inside the viewport
        */
       getRect(zone) {
-          const targetZone = intersection(zone, this.zone);
+          const targetZone = intersection(zone, this);
           if (targetZone) {
-              const x = this.getters.getColRowOffset("COL", this.zone.left, targetZone.left) +
-                  this.offsetCorrectionX;
-              const y = this.getters.getColRowOffset("ROW", this.zone.top, targetZone.top) + this.offsetCorrectionY;
+              const x = this.getters.getColRowOffset("COL", this.left, targetZone.left) + this.offsetCorrectionX;
+              const y = this.getters.getColRowOffset("ROW", this.top, targetZone.top) + this.offsetCorrectionY;
               const width = Math.min(this.getters.getColRowOffset("COL", targetZone.left, targetZone.right + 1), this.viewportWidth);
               const height = Math.min(this.getters.getColRowOffset("ROW", targetZone.top, targetZone.bottom + 1), this.viewportHeight);
               return {
@@ -49070,9 +49851,7 @@
                   height,
               };
           }
-          else {
-              return undefined;
-          }
+          return undefined;
       }
       isVisible(col, row) {
           const isInside = row <= this.bottom && row >= this.top && col >= this.left && col <= this.right;
@@ -49080,7 +49859,6 @@
               !this.getters.isColHidden(this.sheetId, col) &&
               !this.getters.isRowHidden(this.sheetId, row));
       }
-      // PRIVATE
       searchHeaderIndex(dimension, position, startIndex = 0) {
           const sheetId = this.sheetId;
           const headers = this.getters.getNumberHeaders(sheetId, dimension);
@@ -49103,9 +49881,6 @@
           }
           return -1;
       }
-      get zone() {
-          return { left: this.left, right: this.right, top: this.top, bottom: this.bottom };
-      }
       setViewportOffsetX(offsetX) {
           if (!this.canScrollHorizontally) {
               return;
@@ -49130,11 +49905,6 @@
                   this.offsetScrollbarX = Math.max(0, viewportWidth - this.viewportWidth);
               }
           }
-          this.left = this.getColIndex(this.offsetScrollbarX);
-          this.right = this.getColIndex(this.offsetScrollbarX + this.viewportWidth);
-          if (this.right === -1) {
-              this.right = this.boundaries.right;
-          }
           this.adjustViewportZoneX();
       }
       /** Corrects the viewport's vertical offset based on the current structure
@@ -49147,11 +49917,6 @@
                   this.offsetScrollbarY = Math.max(0, paneHeight - this.viewportHeight);
               }
           }
-          this.top = this.getRowIndex(this.offsetScrollbarY);
-          this.bottom = this.getRowIndex(this.offsetScrollbarY + this.viewportHeight);
-          if (this.bottom === -1) {
-              this.bottom = this.boundaries.bottom;
-          }
           this.adjustViewportZoneY();
       }
       /** Updates the pane zone and snapped offset based on its horizontal
@@ -49529,7 +50294,7 @@
       isVisibleInViewport({ sheetId, col, row }) {
           return this.getSubViewports(sheetId).some((pane) => pane.isVisible(col, row));
       }
-      // => return s the new offset
+      // => returns the new offset
       getEdgeScrollCol(x, previousX, startingX) {
           let canEdgeScroll = false;
           let direction = 0;
@@ -49844,10 +50609,13 @@
                   }
                   break;
               case "UPDATE_CELL":
-                  if ("content" in cmd || "format" in cmd || cmd.style?.fontSize !== undefined) {
+                  if ("content" in cmd || "format" in cmd) {
                       this.headerPositions = {};
                       this.isDirty = true;
                   }
+                  else {
+                      this.headerPositions[cmd.sheetId] = this.computeHeaderPositionsOfSheet(cmd.sheetId);
+                  }
                   break;
               case "UPDATE_FILTER":
               case "REMOVE_FILTER_TABLE":
@@ -52004,6 +52772,8 @@
     *:before,
     *:after {
       box-sizing: content-box;
+      /** rtl not supported ATM */
+      direction: ltr;
     }
     .o-separator {
       border-bottom: ${MENU_SEPARATOR_BORDER_WIDTH}px solid ${SEPARATOR_COLOR};
@@ -52294,7 +53064,7 @@
       }
       onKeydown(ev) {
           let keyDownString = "";
-          if (ev.ctrlKey || ev.metaKey) {
+          if (isCtrlKey(ev)) {
               keyDownString += "CTRL+";
           }
           keyDownString += ev.key.toUpperCase();
@@ -55031,7 +55801,8 @@
                   }
                   else if (cell.content && cell.content !== "") {
                       const isTableHeader = isCellTableHeader(c, r, sheet);
-                      ({ attrs: additionalAttrs, node: cellNode } = addContent(cell.content, construct.sharedStrings, isTableHeader));
+                      const isPlainText = !!(cell.format && data.formats[cell.format] === PLAIN_TEXT_FORMAT);
+                      ({ attrs: additionalAttrs, node: cellNode } = addContent(cell.content, construct.sharedStrings, isTableHeader || isPlainText));
                   }
                   attributes.push(...additionalAttrs);
                   cellNodes.push(escapeXml /*xml*/ `
@@ -55960,6 +56731,7 @@
       colorToRGBA,
       positionToZone,
       isDefined: isDefined$1,
+      isMatrix,
       lazy,
       genericRepeat,
       createAction,
@@ -56044,9 +56816,9 @@
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.1.0-alpha.4";
-  __info__.date = "2023-11-24T13:12:24.882Z";
-  __info__.hash = "255821b";
+  __info__.version = "17.1.0-alpha.6";
+  __info__.date = "2024-01-04T12:22:45.921Z";
+  __info__.hash = "56dbdc9";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);