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

package/dist/o-spreadsheet.cjs.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.1.0-alpha.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
  */
 
 'use strict';
@@ -330,13 +330,6 @@ const FONT_SIZES = [6, 7, 8, 9, 10, 11, 12, 14, 18, 24, 36];
 //------------------------------------------------------------------------------
 // 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
@@ -559,7 +552,7 @@ function isObjectEmptyRecursive(argument) {
  */
 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);
         }
     }
@@ -2062,6 +2055,8 @@ exports.CommandResult = void 0;
     CommandResult["NoChanges"] = "NoChanges";
 })(exports.CommandResult || (exports.CommandResult = {}));
 
+const PLAIN_TEXT_FORMAT = "@"; // see OpenXML spec §18.8.31
+
 const DEFAULT_LOCALES = [
     {
         name: "English (US)",
@@ -2825,6 +2820,9 @@ function parseFormat(formatString) {
  * 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;
@@ -3388,8 +3386,10 @@ function convertInternalFormatToFormat(internalFormat) {
 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) */
@@ -3419,6 +3419,9 @@ function isRowReference(xc) {
 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)
@@ -4109,18 +4112,10 @@ class RangeImpl {
         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;
     }
@@ -4362,7 +4357,7 @@ function computeTextLinesHeight(textLineHeight, numberOfLines = 1) {
 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;
@@ -5299,7 +5294,7 @@ function createScorecardChartRuntime(chart, getters) {
         };
         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),
@@ -5308,7 +5303,7 @@ function createScorecardChartRuntime(chart, getters) {
         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({
@@ -5734,6 +5729,9 @@ function detectLink(value) {
 }
 
 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) {
@@ -5768,6 +5766,9 @@ function createEvaluatedCell(value, localeFormat) {
 }
 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) {
@@ -6259,10 +6260,6 @@ css /* scss */ `
 
     .o-error-tooltip-message {
       overflow: hidden;
-      display: -webkit-box; /* Limit to 3 lines */
-      -webkit-line-clamp: 3;
-      line-clamp: 3;
-      -webkit-box-orient: vertical;
     }
   }
 `;
@@ -6607,6 +6604,7 @@ const FilterMenuPopoverBuilder = {
     },
 };
 
+const macRegex = /Mac/i;
 /**
  * Return true if the event was triggered from
  * a child element.
@@ -6658,7 +6656,7 @@ const letterRegex = /^[a-zA-Z]$/;
  */
 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+";
@@ -6670,6 +6668,17 @@ function keyboardEventToShortcutString(ev, mode = "key") {
     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
@@ -8907,7 +8916,7 @@ function createGaugeChartRuntime(chart, getters) {
     });
     return {
         chartJsConfig: config,
-        background: getters.getBackgroundOfSingleCellChart(chart.background, dataRange),
+        background: getters.getStyleOfSingleCellChart(chart.background, dataRange).background,
     };
 }
 
@@ -8988,7 +8997,7 @@ function getFormatMinDisplayUnit(format) {
     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")) {
@@ -9500,6 +9509,27 @@ function calculatePercentage(dataset, dataIndex) {
     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;
@@ -9513,6 +9543,7 @@ function createPieChartRuntime(chart, getters) {
     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 });
@@ -10350,7 +10381,7 @@ function setStyle(env, style) {
 // 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();
@@ -10363,7 +10394,7 @@ async function paste$1(env, pasteOption) {
             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;
@@ -10778,9 +10809,9 @@ const pasteSpecial = {
     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"),
@@ -17949,6 +17980,10 @@ function setXcToFixedReferenceType(xc, referenceType) {
             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":
@@ -20015,6 +20050,11 @@ const formatNumberAutomatic = {
     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,
@@ -20374,6 +20414,7 @@ var ACTION_FORMAT = /*#__PURE__*/Object.freeze({
   formatNumberFullWeekDayAndMonth: formatNumberFullWeekDayAndMonth,
   formatNumberNumber: formatNumberNumber,
   formatNumberPercent: formatNumberPercent,
+  formatNumberPlainText: formatNumberPlainText,
   formatNumberShortMonth: formatNumberShortMonth,
   formatNumberShortWeekDay: formatNumberShortWeekDay,
   formatNumberTime: formatNumberTime,
@@ -20804,6 +20845,10 @@ numberFormatMenuRegistry
     .add("format_number_automatic", {
     ...formatNumberAutomatic,
     sequence: 10,
+})
+    .add("format_number_plain_text", {
+    ...formatNumberPlainText,
+    sequence: 15,
     separator: true,
 })
     .add("format_number_number", {
@@ -21402,10 +21447,10 @@ const arrowMap = {
 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);
     }
 }
 
@@ -24014,6 +24059,12 @@ css /* scss */ `
         padding: 4px 0 4px 4px;
       }
     }
+
+    .o-matches-count div {
+      text-overflow: ellipsis;
+      overflow: hidden;
+      white-space: nowrap;
+    }
   }
 `;
 class FindAndReplacePanel extends owl.Component {
@@ -28444,7 +28495,10 @@ class GridOverlay extends owl.Component {
             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);
@@ -28519,6 +28573,7 @@ class AbstractResizer extends owl.Component {
         draggerShadowThickness: 0,
         delta: 0,
         base: 0,
+        position: "before",
     });
     _computeHandleDisplay(ev) {
         const position = this._getEvOffset(ev);
@@ -28643,11 +28698,13 @@ class AbstractResizer extends owl.Component {
                     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;
@@ -28671,7 +28728,7 @@ class AbstractResizer extends owl.Component {
             this._increaseSelection(index);
         }
         else {
-            this._selectElement(index, ev.ctrlKey);
+            this._selectElement(index, isCtrlKey(ev));
         }
         this.lastSelectedElementIndex = index;
         const mouseMoveSelect = (col, row) => {
@@ -28822,13 +28879,14 @@ class ColResizer extends AbstractResizer {
             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");
@@ -28986,13 +29044,14 @@ class RowResizer extends AbstractResizer {
             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");
@@ -29093,8 +29152,8 @@ function useWheelHandler(handler) {
         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;
@@ -29685,7 +29744,7 @@ class Grid extends owl.Component {
         "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+ ": () => {
@@ -29793,17 +29852,17 @@ class Grid extends owl.Component {
     // ---------------------------------------------------------------------------
     // 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 {
@@ -30606,7 +30665,7 @@ const XLSX_FORMATS_CONVERSION_MAP = {
     46: "hhhh:mm:ss",
     47: "hhhh:mm:ss",
     48: undefined,
-    49: undefined,
+    49: PLAIN_TEXT_FORMAT,
 };
 /**
  * Mapping format index to format defined by default
@@ -33531,7 +33590,7 @@ const machine = {
         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),
@@ -33542,6 +33601,7 @@ const machine = {
         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]: {},
 };
@@ -34738,7 +34798,7 @@ class BordersPlugin extends CorePlugin {
          */
         function getBorderId(border) {
             for (let [key, value] of Object.entries(borders)) {
-                if (stringify(value) === stringify(border)) {
+                if (deepEquals(value, border)) {
                     return parseInt(key, 10);
                 }
             }
@@ -35909,7 +35969,9 @@ class CellPlugin extends CorePlugin {
     }
     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,
@@ -37521,7 +37583,16 @@ class HeaderVisibilityPlugin extends CorePlugin {
         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) {
@@ -39982,10 +40053,13 @@ class CompilationParametersBuilder {
         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 === "")) {
@@ -39994,13 +40068,6 @@ class CompilationParametersBuilder {
         }
         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
@@ -40023,7 +40090,11 @@ class CompilationParametersBuilder {
         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;
@@ -40033,6 +40104,11 @@ class CompilationParametersBuilder {
             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 });
             }
@@ -40042,56 +40118,758 @@ class CompilationParametersBuilder {
     }
 }
 
+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);
         }
     }
     /**
@@ -40099,20 +40877,20 @@ class FormulaDependencyGraph {
      * 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;
     }
 }
@@ -40200,9 +40978,9 @@ class Evaluator {
     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) {
@@ -40211,23 +40989,23 @@ class Evaluator {
         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)) {
@@ -40237,7 +41015,7 @@ class Evaluator {
         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);
@@ -40247,12 +41025,12 @@ class Evaluator {
         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) {
@@ -40275,12 +41053,14 @@ class Evaluator {
         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() {
@@ -40302,7 +41082,7 @@ class Evaluator {
         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;
@@ -40347,7 +41127,7 @@ class Evaluator {
         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() });
@@ -40370,7 +41150,7 @@ class Evaluator {
         }
     }
     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);
@@ -40425,15 +41205,15 @@ class Evaluator {
         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);
@@ -40454,7 +41234,7 @@ class Evaluator {
                 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
@@ -40486,29 +41266,17 @@ class Evaluator {
         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) {
@@ -40564,6 +41332,13 @@ class PositionBitsEncoder {
     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);
@@ -40571,6 +41346,10 @@ class PositionBitsEncoder {
         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) {
@@ -40753,7 +41532,12 @@ class EvaluationPlugin extends UIPlugin {
     // 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.
@@ -41022,7 +41806,7 @@ class CustomColorsPlugin extends UIPlugin {
 }
 
 class EvaluationChartPlugin extends UIPlugin {
-    static getters = ["getChartRuntime", "getBackgroundOfSingleCellChart"];
+    static getters = ["getChartRuntime", "getStyleOfSingleCellChart"];
     charts = {};
     createRuntimeChart = chartRuntimeFactory(this.getters);
     handle(cmd) {
@@ -41060,25 +41844,26 @@ class EvaluationChartPlugin extends UIPlugin {
         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) {
@@ -41134,7 +41919,7 @@ class EvaluationConditionalFormatPlugin extends UIPlugin {
     // ---------------------------------------------------------------------------
     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;
         }
     }
@@ -41189,45 +41974,40 @@ class EvaluationConditionalFormatPlugin extends UIPlugin {
     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;
@@ -41460,7 +42240,7 @@ class EvaluationDataValidationPlugin extends UIPlugin {
     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;
         }
@@ -41838,11 +42618,6 @@ class AutofillPlugin extends UIPlugin {
                     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 */;
     }
@@ -41998,19 +42773,21 @@ class AutofillPlugin extends UIPlugin {
         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 };
                 }
             }
         }
@@ -43002,6 +43779,7 @@ class Session extends EventBus {
     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
@@ -43034,6 +43812,11 @@ class Session extends EventBus {
             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",
@@ -43130,19 +43913,10 @@ class Session extends EventBus {
         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
@@ -43202,7 +43976,7 @@ class Session extends EventBus {
                 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
@@ -43215,10 +43989,11 @@ class Session extends EventBus {
                 }
                 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;
             }
         }
@@ -43604,7 +44379,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
     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) {
@@ -43786,7 +44561,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
         // 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
@@ -43822,10 +44597,11 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
     pasteCell(origin, target, operation, clipboardOption) {
         const { sheetId, col, row } = target;
         const targetCell = this.getters.getEvaluatedCell(target);
-        if (clipboardOption?.pasteOption === "onlyValue") {
+        const 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);
@@ -43841,7 +44617,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
             this.dispatch("UPDATE_CELL", {
                 ...target,
                 style: origin.cell?.style ?? null,
-                format: origin.cell?.format ?? origin.evaluatedCell.format ?? targetCell.format,
+                format: originFormat ?? targetCell.format,
             });
             return;
         }
@@ -45863,6 +46639,9 @@ class SelectionInputsManagerPlugin extends UIPlugin {
     // 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];
@@ -46571,7 +47350,7 @@ class HistoryPlugin extends UIPlugin {
      * Ignore standard undo/redo revisions (that are empty)
      */
     getPossibleRevisionToRepeat() {
-        return this.session.getLastLocalNonEmptyRevision(["REQUEST_REDO"]);
+        return this.session.getLastLocalNonEmptyRevision();
     }
 }
 
@@ -48042,6 +48821,12 @@ class FilterEvaluationPlugin extends UIPlugin {
                 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":
@@ -48743,7 +49528,7 @@ class GridSelectionPlugin extends UIPlugin {
             sheetId: cmd.sheetId,
             base: cmd.base,
             quantity: thickness,
-            position: "before",
+            position: cmd.position,
         });
         const isCol = cmd.dimension === "COL";
         const start = cmd.elements[0];
@@ -48760,12 +49545,13 @@ class GridSelectionPlugin extends UIPlugin {
             },
         ];
         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 });
@@ -48800,6 +49586,11 @@ class GridSelectionPlugin extends UIPlugin {
             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 */;
     }
     //-------------------------------------------
@@ -48977,9 +49768,6 @@ class InternalViewport {
      */
     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)) {
@@ -48992,56 +49780,50 @@ class InternalViewport {
     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);
@@ -49057,11 +49839,10 @@ class InternalViewport {
      * @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 {
@@ -49071,9 +49852,7 @@ class InternalViewport {
                 height,
             };
         }
-        else {
-            return undefined;
-        }
+        return undefined;
     }
     isVisible(col, row) {
         const isInside = row <= this.bottom && row >= this.top && col >= this.left && col <= this.right;
@@ -49081,7 +49860,6 @@ class InternalViewport {
             !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);
@@ -49104,9 +49882,6 @@ class InternalViewport {
         }
         return -1;
     }
-    get zone() {
-        return { left: this.left, right: this.right, top: this.top, bottom: this.bottom };
-    }
     setViewportOffsetX(offsetX) {
         if (!this.canScrollHorizontally) {
             return;
@@ -49131,11 +49906,6 @@ class InternalViewport {
                 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
@@ -49148,11 +49918,6 @@ class InternalViewport {
                 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
@@ -49530,7 +50295,7 @@ class SheetViewPlugin extends UIPlugin {
     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;
@@ -49845,10 +50610,13 @@ class HeaderPositionsUIPlugin extends UIPlugin {
                 }
                 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":
@@ -52005,6 +52773,8 @@ css /* scss */ `
     *:before,
     *:after {
       box-sizing: content-box;
+      /** rtl not supported ATM */
+      direction: ltr;
     }
     .o-separator {
       border-bottom: ${MENU_SEPARATOR_BORDER_WIDTH}px solid ${SEPARATOR_COLOR};
@@ -52295,7 +53065,7 @@ class Spreadsheet extends owl.Component {
     }
     onKeydown(ev) {
         let keyDownString = "";
-        if (ev.ctrlKey || ev.metaKey) {
+        if (isCtrlKey(ev)) {
             keyDownString += "CTRL+";
         }
         keyDownString += ev.key.toUpperCase();
@@ -55032,7 +55802,8 @@ function addRows(construct, data, sheet) {
                 }
                 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*/ `
@@ -55961,6 +56732,7 @@ const helpers = {
     colorToRGBA,
     positionToZone,
     isDefined: isDefined$1,
+    isMatrix,
     lazy,
     genericRepeat,
     createAction,
@@ -56045,6 +56817,6 @@ exports.setTranslationMethod = setTranslationMethod;
 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";