@odoo/o-spreadsheet 19.1.0-alpha.7 → 19.1.0-alpha.9

package/dist/o-spreadsheet-engine.esm.js

@@ -3,8 +3,8 @@
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
  * @version 19.1.0-alpha.3
- * @date 2025-10-17T11:08:54.279Z
- * @hash a11279d
+ * @date 2025-10-23T11:12:13.207Z
+ * @hash bd756dd
  */
 
 class FunctionCodeBuilder {
@@ -908,8 +908,17 @@ function isObjectEmptyRecursive(argument) {
 /**
  * Returns a function, that, as long as it continues to be invoked, will not
  * be triggered. The function will be called after it stops being called for
- * N milliseconds. If `immediate` is passed, trigger the function on the
- * leading edge, instead of the trailing.
+ * N milliseconds. If `immediate` is passed,  the function is called is called
+ * immediately on the first call and the debouncing is triggered starting the second
+ * call in the defined time window.
+ *
+ * Example:
+ * debouncedFunction = debounce(() => console.log('Hello!'), 250);
+ * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' after 250ms
+ *
+ * debouncedFunction = debounce(() => console.log('Hello!'), 250, true);
+ * debouncedFunction(); debouncedFunction(); // Will log 'Hello!' and relog it after 250ms
+ *
  *
  * Also decorate the argument function with two methods: stopDebounce and isDebouncePending.
  *
@@ -917,21 +926,21 @@ function isObjectEmptyRecursive(argument) {
  */
 function debounce(func, wait, immediate) {
     let timeout = undefined;
+    let firstCalled = false;
     const debounced = function () {
         const context = this;
         const args = Array.from(arguments);
+        if (!firstCalled && immediate) {
+            firstCalled = true;
+            return func.apply(context, args);
+        }
         function later() {
             timeout = undefined;
-            if (!immediate) {
-                func.apply(context, args);
-            }
+            firstCalled = false;
+            func.apply(context, args);
         }
-        const callNow = immediate && !timeout;
         clearTimeout(timeout);
         timeout = setTimeout(later, wait);
-        if (callNow) {
-            func.apply(context, args);
-        }
     };
     debounced.isDebouncePending = () => timeout !== undefined;
     debounced.stopDebounce = () => {
@@ -5182,6 +5191,29 @@ profilesStartingPosition, profiles, zones, toRemove = false) {
         removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex);
     }
 }
+function profilesContainsZone(profilesStartingPosition, profiles, zone) {
+    const leftValue = zone.left;
+    const rightValue = zone.right;
+    const topValue = zone.top;
+    const bottomValue = zone.bottom + 1;
+    const leftIndex = binaryPredecessorSearch(profilesStartingPosition, leftValue, 0);
+    const rightIndex = binaryPredecessorSearch(profilesStartingPosition, rightValue, leftIndex);
+    if (leftIndex === -1 || rightIndex === -1) {
+        return false;
+    }
+    for (let i = leftIndex; i <= rightIndex; i++) {
+        const profile = profiles.get(profilesStartingPosition[i]);
+        const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, true);
+        const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, true);
+        if (topPredIndex === -1 || topPredIndex % 2 !== 0) {
+            return false;
+        }
+        if (topValue < profile[topPredIndex] || bottomValue > profile[bottomSuccIndex]) {
+            return false;
+        }
+    }
+    return true;
+}
 function findIndexAndCreateProfile(profilesStartingPosition, profiles, value, searchLeft, startIndex) {
     if (value === undefined) {
         // this is only the case when the value correspond to a bottom value that could be undefined
@@ -5266,7 +5298,18 @@ function modifyProfile(profile, zone, toRemove = false) {
     }
     // add the top and bottom value to the profile and
     // remove all information between the top and bottom index
-    profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
+    const toDelete = bottomSuccIndex - topPredIndex - 1;
+    const toInsert = newPoints.length;
+    const start = topPredIndex + 1;
+    // fast path and slow path
+    if (start === profile.length - 1 && toDelete === 1 && toInsert === 1) {
+        // fast path: we just need to replace the last element
+        profile[start] = newPoints[0] ?? newPoints[1];
+    }
+    else {
+        // equivalent but slower and with memory allocation
+        profile.splice(start, toDelete, ...newPoints);
+    }
 }
 function removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex) {
     const start = leftIndex - 1 === -1 ? 0 : leftIndex - 1;
@@ -5305,8 +5348,10 @@ function constructZonesFromProfiles(profilesStartingPosition, profiles) {
                 left,
                 bottom,
                 right,
-                hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
             };
+            if ((bottom === undefined && top !== 0) || (right === undefined && left !== 0)) {
+                profileZone.hasHeader = true;
+            }
             let findCorrespondingZone = false;
             for (let j = pendingZones.length - 1; j >= 0; j--) {
                 const pendingZone = pendingZones[j];
@@ -5761,17 +5806,6 @@ function excludeTopLeft(zone) {
     }
     return [leftColumnZone, rightPartZone];
 }
-function aggregatePositionsToZones(positions) {
-    const result = {};
-    for (const position of positions) {
-        result[position.sheetId] ??= [];
-        result[position.sheetId].push(positionToZone(position));
-    }
-    for (const sheetId in result) {
-        result[sheetId] = recomputeZones(result[sheetId]);
-    }
-    return result;
-}
 /**
  * Array of all positions in the zone.
  */
@@ -14520,6 +14554,13 @@ pivotTimeAdapterRegistry
     .add("minute_number", nullHandlerDecorator(minuteNumberAdapter))
     .add("second_number", nullHandlerDecorator(secondNumberAdapter));
 
+const DEFAULT_PIVOT_STYLE = {
+    displayTotals: true,
+    displayColumnHeaders: true,
+    displayMeasuresRow: true,
+    numberOfRows: Number.MAX_VALUE,
+    numberOfColumns: Number.MAX_VALUE,
+};
 const AGGREGATOR_NAMES = {
     count: _t("Count"),
     count_distinct: _t("Count Distinct"),
@@ -14815,6 +14856,25 @@ function togglePivotCollapse(position, env) {
         pivot: { ...definition, collapsedDomains: newDomains },
     });
 }
+function getPivotStyleFromFnArgs(definition, rowCountArg, includeTotalArg, includeColumnHeadersArg, columnCountArg, includeMeasuresRowArg, locale) {
+    const style = definition.style;
+    const numberOfRows = rowCountArg !== undefined
+        ? toNumber(rowCountArg, locale)
+        : style?.numberOfRows ?? DEFAULT_PIVOT_STYLE.numberOfRows;
+    const numberOfColumns = columnCountArg !== undefined
+        ? toNumber(columnCountArg, locale)
+        : style?.numberOfColumns ?? DEFAULT_PIVOT_STYLE.numberOfColumns;
+    const displayTotals = includeTotalArg !== undefined
+        ? toBoolean(includeTotalArg)
+        : style?.displayTotals ?? DEFAULT_PIVOT_STYLE.displayTotals;
+    const displayColumnHeaders = includeColumnHeadersArg !== undefined
+        ? toBoolean(includeColumnHeadersArg)
+        : style?.displayColumnHeaders ?? DEFAULT_PIVOT_STYLE.displayColumnHeaders;
+    const displayMeasuresRow = includeMeasuresRowArg !== undefined
+        ? toBoolean(includeMeasuresRowArg)
+        : style?.displayMeasuresRow ?? DEFAULT_PIVOT_STYLE.displayMeasuresRow;
+    return { numberOfRows, numberOfColumns, displayTotals, displayColumnHeaders, displayMeasuresRow };
+}
 
 /**
  * Get the pivot ID from the formula pivot ID.
@@ -15429,24 +15489,18 @@ const PIVOT = {
         arg("column_count (number, optional)", _t("number of columns")),
         arg("include_measure_titles (boolean, default=TRUE)", _t("Whether to include the measure titles row or not.")),
     ],
-    compute: function (pivotFormulaId, rowCount = { value: 10000 }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }, includeMeasureTitles = { value: true }) {
+    compute: function (pivotFormulaId, rowCount, includeTotal, includeColumnHeaders, columnCount, includeMeasureTitles) {
         const _pivotFormulaId = toString(pivotFormulaId);
-        const _rowCount = toNumber(rowCount, this.locale);
-        if (_rowCount < 0) {
+        const pivotId = getPivotId(_pivotFormulaId, this.getters);
+        const pivot = this.getters.getPivot(pivotId);
+        const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
+        const pivotStyle = getPivotStyleFromFnArgs(coreDefinition, rowCount, includeTotal, includeColumnHeaders, columnCount, includeMeasureTitles, this.locale);
+        if (pivotStyle.numberOfRows < 0) {
             return new EvaluationError(_t("The number of rows must be positive."));
         }
-        const _columnCount = toNumber(columnCount, this.locale);
-        if (_columnCount < 0) {
+        if (pivotStyle.numberOfColumns < 0) {
             return new EvaluationError(_t("The number of columns must be positive."));
         }
-        const visibilityOptions = {
-            displayColumnHeaders: toBoolean(includeColumnHeaders),
-            displayTotals: toBoolean(includeTotal),
-            displayMeasuresRow: toBoolean(includeMeasureTitles),
-        };
-        const pivotId = getPivotId(_pivotFormulaId, this.getters);
-        const pivot = this.getters.getPivot(pivotId);
-        const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
         addPivotDependencies(this, coreDefinition, coreDefinition.measures);
         pivot.init({ reload: pivot.needsReevaluation });
         const error = pivot.assertIsValid({ throwOnError: false });
@@ -15457,20 +15511,20 @@ const PIVOT = {
         if (table.numberOfCells > PIVOT_MAX_NUMBER_OF_CELLS) {
             return new EvaluationError(getPivotTooBigErrorMessage(table.numberOfCells, this.locale));
         }
-        const cells = table.getPivotCells(visibilityOptions);
+        const cells = table.getPivotCells(pivotStyle);
         let headerRows = 0;
-        if (visibilityOptions.displayColumnHeaders) {
+        if (pivotStyle.displayColumnHeaders) {
             headerRows = table.columns.length - 1;
         }
-        if (visibilityOptions.displayMeasuresRow) {
+        if (pivotStyle.displayMeasuresRow) {
             headerRows++;
         }
         const pivotTitle = this.getters.getPivotName(pivotId);
-        const tableHeight = Math.min(headerRows + _rowCount, cells[0].length);
+        const tableHeight = Math.min(headerRows + pivotStyle.numberOfRows, cells[0].length);
         if (tableHeight === 0) {
             return [[{ value: pivotTitle }]];
         }
-        const tableWidth = Math.min(1 + _columnCount, cells.length);
+        const tableWidth = Math.min(1 + pivotStyle.numberOfColumns, cells.length);
         const result = [];
         for (const col of range(0, tableWidth)) {
             result[col] = [];
@@ -15493,7 +15547,7 @@ const PIVOT = {
                 }
             }
         }
-        if (visibilityOptions.displayColumnHeaders || visibilityOptions.displayMeasuresRow) {
+        if (pivotStyle.displayColumnHeaders || pivotStyle.displayMeasuresRow) {
             result[0][0] = { value: pivotTitle };
         }
         return result;
@@ -17965,6 +18019,10 @@ function getRangeParts(xc, zone) {
     }
     return parts;
 }
+function positionToBoundedRange(position) {
+    const zone = { left: position.col, top: position.row, right: position.col, bottom: position.row };
+    return { sheetId: position.sheetId, zone };
+}
 /**
  * Check that a zone is valid regarding the order of top-bottom and left-right.
  * Left should be smaller than right, top should be smaller than bottom.
@@ -26653,6 +26711,7 @@ function forceUnicityOfFigure(data) {
         return data;
     }
     const figureIds = new Set();
+    const chartIds = new Set();
     const uuidGenerator = new UuidGenerator();
     for (const sheet of data.sheets || []) {
         for (const figure of sheet.figures || []) {
@@ -26660,6 +26719,12 @@ function forceUnicityOfFigure(data) {
                 figure.id += uuidGenerator.smallUuid();
             }
             figureIds.add(figure.id);
+            if (figure.tag === "chart") {
+                if (chartIds.has(figure.data?.chartId)) {
+                    figure.data.chartId += uuidGenerator.smallUuid();
+                }
+                chartIds.add(figure.data?.chartId);
+            }
         }
     }
     data.uniqueFigureIds = true;
@@ -27027,11 +27092,6 @@ class CorePlugin extends BasePlugin {
      * @param sheetName couple of old and new sheet names to adapt ranges pointing to that sheet
      */
     adaptRanges(applyChange, sheetId, sheetName) { }
-    /**
-     * Implement this method to clean unused external resources, such as images
-     * stored on a server which have been deleted.
-     */
-    garbageCollectExternalResources() { }
 }
 
 class BordersPlugin extends CorePlugin {
@@ -30875,17 +30935,6 @@ class ImagePlugin extends CorePlugin {
                 break;
         }
     }
-    /**
-     * Delete unused images from the file store
-     */
-    garbageCollectExternalResources() {
-        const images = new Set(this.getAllImages().map((image) => image.path));
-        for (const path of this.syncedImages) {
-            if (!images.has(path)) {
-                this.fileStore?.delete(path);
-            }
-        }
-    }
     // ---------------------------------------------------------------------------
     // Getters
     // ---------------------------------------------------------------------------
@@ -30947,13 +30996,6 @@ class ImagePlugin extends CorePlugin {
             sheet.images = [...sheet.images, ...images];
         }
     }
-    getAllImages() {
-        const images = [];
-        for (const sheetId in this.images) {
-            images.push(...Object.values(this.images[sheetId] || {}).filter(isDefined));
-        }
-        return images;
-    }
 }
 
 class MergePlugin extends CorePlugin {
@@ -31729,26 +31771,22 @@ class SpreadsheetPivotTable {
     getNumberOfDataColumns() {
         return this.columns.at(-1)?.length || 0;
     }
-    getSkippedRows(visibilityOptions) {
+    getSkippedRows(pivotStyle) {
         const skippedRows = new Set();
-        if (!visibilityOptions.displayColumnHeaders) {
+        if (!pivotStyle.displayColumnHeaders) {
             for (let i = 0; i < this.columns.length - 1; i++) {
                 skippedRows.add(i);
             }
         }
-        if (!visibilityOptions.displayMeasuresRow) {
+        if (!pivotStyle.displayMeasuresRow) {
             skippedRows.add(this.columns.length - 1);
         }
         return skippedRows;
     }
-    getPivotCells(visibilityOptions = {
-        displayColumnHeaders: true,
-        displayTotals: true,
-        displayMeasuresRow: true,
-    }) {
-        const key = JSON.stringify(visibilityOptions);
+    getPivotCells(pivotStyle = DEFAULT_PIVOT_STYLE) {
+        const key = JSON.stringify(pivotStyle);
         if (!this.pivotCells[key]) {
-            const { displayTotals } = visibilityOptions;
+            const { displayTotals } = pivotStyle;
             const numberOfDataRows = this.rows.length;
             const numberOfDataColumns = this.getNumberOfDataColumns();
             let pivotHeight = this.columns.length + numberOfDataRows;
@@ -31760,7 +31798,7 @@ class SpreadsheetPivotTable {
                 pivotWidth -= this.measures.length;
             }
             const domainArray = [];
-            const skippedRows = this.getSkippedRows(visibilityOptions);
+            const skippedRows = this.getSkippedRows(pivotStyle);
             for (let col = 0; col < pivotWidth; col++) {
                 domainArray.push([]);
                 for (let row = 0; row < pivotHeight; row++) {
@@ -34879,6 +34917,281 @@ class ZoneRBush extends RBush {
     }
 }
 
+class ZoneSet {
+    profilesStartingPosition = [0];
+    profiles = new Map([[0, []]]);
+    constructor(zones = []) {
+        for (const zone of zones) {
+            this.add(zone);
+        }
+    }
+    isEmpty() {
+        return this.profiles.size === 1 && this.profiles.get(0)?.length === 0;
+    }
+    add(zone) {
+        modifyProfiles(this.profilesStartingPosition, this.profiles, [zone]);
+    }
+    delete(zone) {
+        modifyProfiles(this.profilesStartingPosition, this.profiles, [zone], true);
+    }
+    has(zone) {
+        return profilesContainsZone(this.profilesStartingPosition, this.profiles, zone);
+    }
+    difference(other) {
+        const result = this.copy();
+        for (const zone of other) {
+            result.delete(zone);
+        }
+        return result;
+    }
+    copy() {
+        const result = new ZoneSet();
+        result.profilesStartingPosition = [...this.profilesStartingPosition];
+        result.profiles = new Map();
+        for (const [key, value] of this.profiles) {
+            result.profiles.set(key, [...value]);
+        }
+        return result;
+    }
+    size() {
+        let size = 0;
+        for (const profile of this.profiles.values()) {
+            size += profile.length;
+        }
+        return size / 2;
+    }
+    /**
+     * iterator of all the zones in the ZoneSet
+     */
+    [Symbol.iterator]() {
+        return constructZonesFromProfiles(this.profilesStartingPosition, this.profiles)[Symbol.iterator]();
+    }
+}
+
+class RangeSet {
+    setsBySheetId = {};
+    constructor(ranges = []) {
+        for (const range of ranges) {
+            this.add(range);
+        }
+    }
+    add(range) {
+        if (!this.setsBySheetId[range.sheetId]) {
+            this.setsBySheetId[range.sheetId] = new ZoneSet();
+        }
+        this.setsBySheetId[range.sheetId].add(range.zone);
+    }
+    addMany(ranges) {
+        for (const range of ranges) {
+            this.add(range);
+        }
+    }
+    addPosition(position) {
+        this.add(positionToBoundedRange(position));
+    }
+    addManyPositions(positions) {
+        for (const position of positions) {
+            this.addPosition(position);
+        }
+    }
+    has(range) {
+        if (!this.setsBySheetId[range.sheetId]) {
+            return false;
+        }
+        return this.setsBySheetId[range.sheetId].has(range.zone);
+    }
+    hasPosition(position) {
+        return this.has(positionToBoundedRange(position));
+    }
+    delete(range) {
+        if (!this.setsBySheetId[range.sheetId]) {
+            return;
+        }
+        this.setsBySheetId[range.sheetId].delete(range.zone);
+    }
+    deleteMany(ranges) {
+        for (const range of ranges) {
+            this.delete(range);
+        }
+    }
+    deleteManyPositions(positions) {
+        for (const position of positions) {
+            this.delete(positionToBoundedRange(position));
+        }
+    }
+    difference(other) {
+        const result = new RangeSet();
+        for (const sheetId in this.setsBySheetId) {
+            result.setsBySheetId[sheetId] = this.setsBySheetId[sheetId];
+        }
+        for (const sheetId in other.setsBySheetId) {
+            if (result.setsBySheetId[sheetId]) {
+                result.setsBySheetId[sheetId] = result.setsBySheetId[sheetId].difference(other.setsBySheetId[sheetId]);
+            }
+        }
+        return result;
+    }
+    copy() {
+        const result = new RangeSet();
+        for (const sheetId in this.setsBySheetId) {
+            result.setsBySheetId[sheetId] = this.setsBySheetId[sheetId].copy();
+        }
+        return result;
+    }
+    clear() {
+        this.setsBySheetId = {};
+    }
+    size() {
+        let size = 0;
+        for (const sheetId in this.setsBySheetId) {
+            size += this.setsBySheetId[sheetId].size();
+        }
+        return size;
+    }
+    isEmpty() {
+        for (const sheetId in this.setsBySheetId) {
+            if (!this.setsBySheetId[sheetId].isEmpty()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * iterator of all the ranges in the RangeSet
+     */
+    [Symbol.iterator]() {
+        const result = [];
+        for (const sheetId in this.setsBySheetId) {
+            for (const zone of this.setsBySheetId[sheetId]) {
+                result.push({ sheetId: sheetId, zone });
+            }
+        }
+        return result[Symbol.iterator]();
+    }
+}
+
+/**
+ * R-Tree of ranges, mapping zones (r-tree bounding boxes) to ranges (data of the r-tree item).
+ * Ranges associated to the exact same bounding box are grouped together
+ * to reduce the number of nodes in the R-tree.
+ */
+class DependenciesRTree {
+    rTree;
+    constructor(items = []) {
+        const compactedBoxes = groupSameBoundingBoxes(items);
+        this.rTree = new SpreadsheetRTree(compactedBoxes);
+    }
+    insert(item) {
+        const data = this.rTree.search(item.boundingBox);
+        const itemBoundingBox = item.boundingBox;
+        const exactBoundingBox = data.find(({ boundingBox }) => boundingBox.sheetId === itemBoundingBox.sheetId &&
+            boundingBox.zone.left === itemBoundingBox.zone.left &&
+            boundingBox.zone.top === itemBoundingBox.zone.top &&
+            boundingBox.zone.right === itemBoundingBox.zone.right &&
+            boundingBox.zone.bottom === itemBoundingBox.zone.bottom);
+        if (exactBoundingBox) {
+            exactBoundingBox.data.add(item.data);
+        }
+        else {
+            this.rTree.insert({ ...item, data: new RangeSet([item.data]) });
+        }
+    }
+    search({ zone, sheetId }) {
+        const results = new RangeSet();
+        for (const { data } of this.rTree.search({ zone, sheetId })) {
+            results.addMany(data);
+        }
+        return results;
+    }
+    remove(item) {
+        const data = this.rTree.search(item.boundingBox);
+        const itemBoundingBox = item.boundingBox;
+        const exactBoundingBox = data.find(({ boundingBox }) => boundingBox.sheetId === itemBoundingBox.sheetId &&
+            boundingBox.zone.left === itemBoundingBox.zone.left &&
+            boundingBox.zone.top === itemBoundingBox.zone.top &&
+            boundingBox.zone.right === itemBoundingBox.zone.right &&
+            boundingBox.zone.bottom === itemBoundingBox.zone.bottom);
+        if (exactBoundingBox) {
+            exactBoundingBox.data.delete(item.data);
+        }
+        else {
+            this.rTree.remove({ ...item, data: new RangeSet([item.data]) });
+        }
+    }
+}
+/**
+ * Group together all formulas pointing to the exact same dependency (bounding box).
+ * The goal is to optimize the following case:
+ * - if any cell in B1:B1000 changes, C1 must be recomputed
+ * - if any cell in B1:B1000 changes, C2 must be recomputed
+ * - if any cell in B1:B1000 changes, C3 must be recomputed
+ * ...
+ * - if any cell in B1:B1000 changes, C1000 must be recomputed
+ *
+ * Instead of having 1000 entries in the R-tree, we want to have a single entry
+ * with B1:B1000 (bounding box) pointing to C1:C1000 (formulas).
+ */
+function groupSameBoundingBoxes(items) {
+    // Important: this function must be as fast as possible. It is on the evaluation hot path.
+    let maxCol = 0;
+    let maxRow = 0;
+    for (let i = 0; i < items.length; i++) {
+        const zone = items[i].boundingBox.zone;
+        if (zone.right > maxCol) {
+            maxCol = zone.right;
+        }
+        if (zone.bottom > maxRow) {
+            maxRow = zone.bottom;
+        }
+    }
+    maxCol += 1;
+    maxRow += 1;
+    // in most real-world cases, we can use a fast numeric key
+    // but if the zones are too far right or bottom, we fallback to a slower string key
+    const maxPossibleKey = (((maxRow + 1) * maxCol + 1) * maxRow + 1) * maxCol;
+    const useFastKey = maxPossibleKey <= Number.MAX_SAFE_INTEGER;
+    if (!useFastKey) {
+        console.warn("Max col/row size exceeded, using slow zone key");
+    }
+    const groupedByBBox = {};
+    for (const item of items) {
+        const sheetId = item.boundingBox.sheetId;
+        if (!groupedByBBox[sheetId]) {
+            groupedByBBox[sheetId] = {};
+        }
+        const bBox = item.boundingBox.zone;
+        let bBoxKey = 0;
+        if (useFastKey) {
+            bBoxKey =
+                bBox.left +
+                    bBox.top * maxCol +
+                    bBox.right * maxCol * maxRow +
+                    bBox.bottom * maxCol * maxRow * maxCol;
+        }
+        else {
+            bBoxKey = `${bBox.left},${bBox.top},${bBox.right},${bBox.bottom}`;
+        }
+        if (groupedByBBox[sheetId][bBoxKey]) {
+            const ranges = groupedByBBox[sheetId][bBoxKey].data;
+            ranges.add(item.data);
+        }
+        else {
+            groupedByBBox[sheetId][bBoxKey] = {
+                boundingBox: item.boundingBox,
+                data: new RangeSet([item.data]),
+            };
+        }
+    }
+    const result = [];
+    for (const sheetId in groupedByBBox) {
+        const map = groupedByBBox[sheetId];
+        for (const key in map) {
+            result.push(map[key]);
+        }
+    }
+    return result;
+}
+
 /**
  * Implementation of a dependency Graph.
  * The graph is used to evaluate the cells in the correct
@@ -34887,12 +35200,10 @@ class ZoneRBush extends RBush {
  * It uses an R-Tree data structure to efficiently find dependent cells.
  */
 class FormulaDependencyGraph {
-    createEmptyPositionSet;
     dependencies = new PositionMap();
     rTree;
-    constructor(createEmptyPositionSet, data = []) {
-        this.createEmptyPositionSet = createEmptyPositionSet;
-        this.rTree = new SpreadsheetRTree(data);
+    constructor(data = []) {
+        this.rTree = new DependenciesRTree(data);
     }
     removeAllDependencies(formulaPosition) {
         const ranges = this.dependencies.get(formulaPosition);
@@ -34906,7 +35217,10 @@ class FormulaDependencyGraph {
     }
     addDependencies(formulaPosition, dependencies) {
         const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
-            data: formulaPosition,
+            data: {
+                sheetId: formulaPosition.sheetId,
+                zone: positionToZone(formulaPosition),
+            },
             boundingBox: {
                 zone,
                 sheetId,
@@ -34924,46 +35238,20 @@ class FormulaDependencyGraph {
         }
     }
     /**
-     * Return all the cells that depend on the provided ranges,
-     * in the correct order they should be evaluated.
-     * This is called a topological ordering (excluding cycles)
+     * Return all the cells that depend on the provided ranges.
      */
-    getCellsDependingOn(ranges, ignore) {
-        const visited = this.createEmptyPositionSet();
+    getCellsDependingOn(ranges, visited = new RangeSet()) {
+        visited = visited.copy();
         const queue = Array.from(ranges).reverse();
         while (queue.length > 0) {
             const range = queue.pop();
-            const zone = range.zone;
-            const sheetId = range.sheetId;
-            for (let col = zone.left; col <= zone.right; col++) {
-                for (let row = zone.top; row <= zone.bottom; row++) {
-                    visited.add({ sheetId, col, row });
-                }
-            }
-            const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
-            const nextInQueue = {};
-            for (const position of impactedPositions) {
-                if (!visited.has(position) && !ignore.has(position)) {
-                    if (!nextInQueue[position.sheetId]) {
-                        nextInQueue[position.sheetId] = [];
-                    }
-                    nextInQueue[position.sheetId].push(positionToZone(position));
-                }
-            }
-            for (const sheetId in nextInQueue) {
-                const zones = recomputeZones(nextInQueue[sheetId], []);
-                queue.push(...zones.map((zone) => ({ sheetId, zone })));
-            }
+            visited.add(range);
+            const impactedRanges = this.rTree.search(range);
+            queue.push(...impactedRanges.difference(visited));
         }
         // remove initial ranges
         for (const range of ranges) {
-            const zone = range.zone;
-            const sheetId = range.sheetId;
-            for (let col = zone.left; col <= zone.right; col++) {
-                for (let row = zone.top; row <= zone.bottom; row++) {
-                    visited.delete({ sheetId, col, row });
-                }
-            }
+            visited.delete(range);
         }
         return visited;
     }
@@ -35240,7 +35528,7 @@ class Evaluator {
     getters;
     compilationParams;
     evaluatedCells = new PositionMap();
-    formulaDependencies = lazy(new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this)));
+    formulaDependencies = lazy(new FormulaDependencyGraph());
     blockedArrayFormulas = new PositionSet({});
     spreadingRelations = new SpreadingRelation();
     constructor(context, getters) {
@@ -35275,7 +35563,7 @@ class Evaluator {
             return undefined;
         }
         const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(position.sheetId, positionToZone(position));
-        return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
+        return arrayFormulas.find((position) => !this.blockedArrayFormulas.has(position));
     }
     updateDependencies(position) {
         // removing dependencies is slow because it requires
@@ -35319,57 +35607,72 @@ class Evaluator {
     }
     evaluateCells(positions) {
         const start = performance.now();
-        const cellsToCompute = this.createEmptyPositionSet();
-        cellsToCompute.addMany(positions);
+        const rangesToCompute = new RangeSet();
+        rangesToCompute.addManyPositions(positions);
         const arrayFormulasPositions = this.getArrayFormulasImpactedByChangesOf(positions);
-        cellsToCompute.addMany(this.getCellsDependingOn(positions));
-        cellsToCompute.addMany(arrayFormulasPositions);
-        cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
-        this.evaluate(cellsToCompute);
+        rangesToCompute.addMany(this.getCellsDependingOn(rangesToCompute));
+        rangesToCompute.addMany(arrayFormulasPositions);
+        rangesToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
+        this.evaluate(rangesToCompute);
         console.debug("evaluate Cells", performance.now() - start, "ms");
     }
     getArrayFormulasImpactedByChangesOf(positions) {
-        const impactedPositions = this.createEmptyPositionSet();
+        const impactedRanges = new RangeSet();
         for (const position of positions) {
             const content = this.getters.getCell(position)?.content;
             const arrayFormulaPosition = this.getArrayFormulaSpreadingOn(position);
             if (arrayFormulaPosition !== undefined) {
                 // take into account new collisions.
-                impactedPositions.add(arrayFormulaPosition);
+                impactedRanges.addPosition(arrayFormulaPosition);
             }
             if (!content) {
                 // The previous content could have blocked some array formulas
-                impactedPositions.add(position);
+                impactedRanges.addPosition(position);
             }
         }
-        const zonesBySheetIds = aggregatePositionsToZones(impactedPositions);
-        for (const sheetId in zonesBySheetIds) {
-            for (const zone of zonesBySheetIds[sheetId]) {
-                impactedPositions.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
-            }
+        for (const range of [...impactedRanges]) {
+            impactedRanges.addMany(this.getArrayFormulasBlockedBy(range.sheetId, range.zone));
         }
-        return impactedPositions;
+        return impactedRanges;
     }
     buildDependencyGraph() {
         this.blockedArrayFormulas = this.createEmptyPositionSet();
         this.spreadingRelations = new SpreadingRelation();
         this.formulaDependencies = lazy(() => {
-            const dependencies = [...this.getAllCells()].flatMap((position) => this.getDirectDependencies(position)
-                .filter((range) => !range.invalidSheetName && !range.invalidXc)
-                .map((range) => ({
-                data: position,
-                boundingBox: {
-                    zone: range.zone,
-                    sheetId: range.sheetId,
-                },
-            })));
-            return new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this), dependencies);
+            const rTreeItems = [];
+            for (const sheetId of this.getters.getSheetIds()) {
+                const cells = this.getters.getCells(sheetId);
+                for (const cellId in cells) {
+                    const cell = cells[cellId];
+                    if (cell.isFormula) {
+                        const directDependencies = cell.compiledFormula.dependencies;
+                        for (const range of directDependencies) {
+                            if (range.invalidSheetName || range.invalidXc) {
+                                continue;
+                            }
+                            rTreeItems.push({
+                                data: {
+                                    sheetId,
+                                    zone: positionToZone(this.getters.getCellPosition(cellId)),
+                                },
+                                boundingBox: { sheetId: range.sheetId, zone: range.zone },
+                            });
+                        }
+                    }
+                }
+            }
+            return new FormulaDependencyGraph(rTreeItems);
         });
     }
     evaluateAllCells() {
         const start = performance.now();
         this.evaluatedCells = new PositionMap();
-        this.evaluate(this.getAllCells());
+        const ranges = [];
+        for (const sheetId of this.getters.getSheetIds()) {
+            const zone = this.getters.getSheetZone(sheetId);
+            ranges.push({ sheetId, zone });
+        }
+        this.evaluate(ranges);
         console.debug("evaluate all cells", performance.now() - start, "ms");
     }
     evaluateFormulaResult(sheetId, formulaString) {
@@ -35393,48 +35696,47 @@ class Evaluator {
             return handleError(error, "");
         }
     }
-    getAllCells() {
-        const positions = this.createEmptyPositionSet();
-        positions.fillAllPositions();
-        return positions;
-    }
     /**
      * Return the position of formulas blocked by the given positions
      * as well as all their dependencies.
      */
     getArrayFormulasBlockedBy(sheetId, zone) {
-        const arrayFormulaPositions = this.createEmptyPositionSet();
+        const arrayFormulaPositions = new RangeSet();
         const arrayFormulas = this.spreadingRelations.searchFormulaPositionsSpreadingOn(sheetId, zone);
-        arrayFormulaPositions.addMany(arrayFormulas);
+        arrayFormulaPositions.addManyPositions(arrayFormulas);
         const spilledPositions = [...arrayFormulas].filter((position) => !this.blockedArrayFormulas.has(position));
         if (spilledPositions.length) {
             // ignore the formula spreading on the position. Keep only the blocked ones
-            arrayFormulaPositions.deleteMany(spilledPositions);
+            arrayFormulaPositions.deleteManyPositions(spilledPositions);
         }
         arrayFormulaPositions.addMany(this.getCellsDependingOn(arrayFormulaPositions));
         return arrayFormulaPositions;
     }
-    nextPositionsToUpdate = new PositionSet({});
+    nextRangesToUpdate = new RangeSet();
     cellsBeingComputed = new Set();
     symbolsBeingComputed = new Set();
-    evaluate(positions) {
+    evaluate(ranges) {
         this.cellsBeingComputed = new Set();
-        this.nextPositionsToUpdate = positions;
+        this.nextRangesToUpdate = new RangeSet(ranges);
         let currentIteration = 0;
-        while (!this.nextPositionsToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
+        while (!this.nextRangesToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
             this.updateCompilationParameters();
-            const positions = this.nextPositionsToUpdate.clear();
-            for (let i = 0; i < positions.length; ++i) {
-                this.evaluatedCells.delete(positions[i]);
-            }
-            for (let i = 0; i < positions.length; ++i) {
-                const position = positions[i];
-                if (this.nextPositionsToUpdate.has(position)) {
-                    continue;
-                }
-                const evaluatedCell = this.computeCell(position);
-                if (evaluatedCell !== EMPTY_CELL) {
-                    this.evaluatedCells.set(position, evaluatedCell);
+            const ranges = [...this.nextRangesToUpdate];
+            this.nextRangesToUpdate.clear();
+            this.clearEvaluatedRanges(ranges);
+            for (const range of ranges) {
+                const { left, bottom, right, top } = range.zone;
+                for (let col = left; col <= right; col++) {
+                    for (let row = top; row <= bottom; row++) {
+                        const position = { sheetId: range.sheetId, col, row };
+                        if (this.nextRangesToUpdate.hasPosition(position)) {
+                            continue;
+                        }
+                        const evaluatedCell = this.computeCell(position);
+                        if (evaluatedCell !== EMPTY_CELL) {
+                            this.evaluatedCells.set(position, evaluatedCell);
+                        }
+                    }
                 }
             }
             onIterationEndEvaluationRegistry.getAll().forEach((callback) => callback(this.getters));
@@ -35443,6 +35745,16 @@ class Evaluator {
             console.warn("Maximum iteration reached while evaluating cells");
         }
     }
+    clearEvaluatedRanges(ranges) {
+        for (const range of ranges) {
+            const { left, bottom, right, top } = range.zone;
+            for (let col = left; col <= right; col++) {
+                for (let row = top; row <= bottom; row++) {
+                    this.evaluatedCells.delete({ sheetId: range.sheetId, col, row });
+                }
+            }
+        }
+    }
     computeCell(position) {
         const evaluation = this.evaluatedCells.get(position);
         if (evaluation) {
@@ -35515,9 +35827,9 @@ class Evaluator {
     }
     invalidatePositionsDependingOnSpread(sheetId, resultZone) {
         // the result matrix is split in 2 zones to exclude the array formula position
-        const invalidatedPositions = this.formulaDependencies().getCellsDependingOn(excludeTopLeft(resultZone).map((zone) => ({ sheetId, zone })), this.nextPositionsToUpdate);
-        invalidatedPositions.delete({ sheetId, col: resultZone.left, row: resultZone.top });
-        this.nextPositionsToUpdate.addMany(invalidatedPositions);
+        const invalidatedPositions = this.getCellsDependingOn(excludeTopLeft(resultZone).map((zone) => ({ sheetId, zone })));
+        invalidatedPositions.delete({ sheetId, zone: resultZone });
+        this.nextRangesToUpdate.addMany(invalidatedPositions);
     }
     assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
         const numberOfCols = this.getters.getNumberCols(sheetId);
@@ -35592,7 +35904,7 @@ class Evaluator {
         }
         const sheetId = position.sheetId;
         this.invalidatePositionsDependingOnSpread(sheetId, zone);
-        this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
+        this.nextRangesToUpdate.addMany(this.getArrayFormulasBlockedBy(sheetId, zone));
     }
     /**
      * Wraps a GetSymbolValue function to add cycle detection
@@ -35627,13 +35939,8 @@ class Evaluator {
         }
         return cell.compiledFormula.dependencies;
     }
-    getCellsDependingOn(positions) {
-        const ranges = [];
-        const zonesBySheetIds = aggregatePositionsToZones(positions);
-        for (const sheetId in zonesBySheetIds) {
-            ranges.push(...zonesBySheetIds[sheetId].map((zone) => ({ sheetId, zone })));
-        }
-        return this.formulaDependencies().getCellsDependingOn(ranges, this.nextPositionsToUpdate);
+    getCellsDependingOn(ranges) {
+        return this.formulaDependencies().getCellsDependingOn(ranges, this.nextRangesToUpdate);
     }
 }
 function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
@@ -40133,18 +40440,8 @@ class PivotUIPlugin extends CoreViewPlugin {
             return EMPTY_PIVOT_CELL;
         }
         if (functionName === "PIVOT") {
-            const includeTotal = toScalar(args[2]);
-            const shouldIncludeTotal = includeTotal === undefined ? true : toBoolean(includeTotal);
-            const includeColumnHeaders = toScalar(args[3]);
-            const includeMeasures = toScalar(args[5]);
-            const shouldIncludeMeasures = includeMeasures === undefined ? true : toBoolean(includeMeasures);
-            const shouldIncludeColumnHeaders = includeColumnHeaders === undefined ? true : toBoolean(includeColumnHeaders);
-            const visibilityOptions = {
-                displayColumnHeaders: shouldIncludeColumnHeaders,
-                displayTotals: shouldIncludeTotal,
-                displayMeasuresRow: shouldIncludeMeasures,
-            };
-            const pivotCells = pivot.getCollapsedTableStructure().getPivotCells(visibilityOptions);
+            const pivotStyle = getPivotStyleFromFnArgs(this.getters.getPivotCoreDefinition(pivotId), toScalar(args[1]), toScalar(args[2]), toScalar(args[3]), toScalar(args[4]), toScalar(args[5]), this.getters.getLocale());
+            const pivotCells = pivot.getCollapsedTableStructure().getPivotCells(pivotStyle);
             const pivotCol = position.col - mainPosition.col;
             const pivotRow = position.row - mainPosition.row;
             return pivotCells[pivotCol][pivotRow];
@@ -49874,7 +50171,6 @@ class Model extends EventBus {
             const startSnapshot = performance.now();
             console.debug("Snapshot requested");
             this.session.snapshot(this.exportData());
-            this.garbageCollectExternalResources();
             console.debug("Snapshot taken in", performance.now() - startSnapshot, "ms");
         }
         console.debug("Model created in", performance.now() - start, "ms");
@@ -50260,11 +50556,6 @@ class Model extends EventBus {
         data = deepCopy(data);
         return getXLSX(data);
     }
-    garbageCollectExternalResources() {
-        for (const plugin of this.corePlugins) {
-            plugin.garbageCollectExternalResources();
-        }
-    }
 }
 function createCommand(type, payload = {}) {
     const command = deepCopy(payload);
@@ -50300,5 +50591,5 @@ export { BadExpressionError, BasePlugin, CellErrorType, CircularDependencyError,
 
 
 __info__.version = "19.1.0-alpha.3";
-__info__.date = "2025-10-17T11:08:54.279Z";
-__info__.hash = "a11279d";
+__info__.date = "2025-10-23T11:12:13.207Z";
+__info__.hash = "bd756dd";