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

package/dist/o-spreadsheet-engine.iife.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
  */
 
 (function (exports) {
@@ -911,8 +911,17 @@
   /**
    * 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.
    *
@@ -920,21 +929,21 @@
    */
   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 = () => {
@@ -5185,6 +5194,29 @@
           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
@@ -5269,7 +5301,18 @@
       }
       // 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;
@@ -5308,8 +5351,10 @@
                   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];
@@ -5764,17 +5809,6 @@
       }
       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.
    */
@@ -14523,6 +14557,13 @@
       .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"),
@@ -14818,6 +14859,25 @@
           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.
@@ -15432,24 +15492,18 @@
           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 });
@@ -15460,20 +15514,20 @@
           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] = [];
@@ -15496,7 +15550,7 @@
                   }
               }
           }
-          if (visibilityOptions.displayColumnHeaders || visibilityOptions.displayMeasuresRow) {
+          if (pivotStyle.displayColumnHeaders || pivotStyle.displayMeasuresRow) {
               result[0][0] = { value: pivotTitle };
           }
           return result;
@@ -17968,6 +18022,10 @@
       }
       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.
@@ -26656,6 +26714,7 @@
           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 || []) {
@@ -26663,6 +26722,12 @@
                   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;
@@ -27030,11 +27095,6 @@
        * @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 {
@@ -30878,17 +30938,6 @@
                   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
       // ---------------------------------------------------------------------------
@@ -30950,13 +30999,6 @@
               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 {
@@ -31732,26 +31774,22 @@
       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;
@@ -31763,7 +31801,7 @@
                   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++) {
@@ -34882,6 +34920,281 @@
       }
   }
 
+  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
@@ -34890,12 +35203,10 @@
    * 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);
@@ -34909,7 +35220,10 @@
       }
       addDependencies(formulaPosition, dependencies) {
           const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
-              data: formulaPosition,
+              data: {
+                  sheetId: formulaPosition.sheetId,
+                  zone: positionToZone(formulaPosition),
+              },
               boundingBox: {
                   zone,
                   sheetId,
@@ -34927,46 +35241,20 @@
           }
       }
       /**
-       * 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;
       }
@@ -35243,7 +35531,7 @@
       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) {
@@ -35278,7 +35566,7 @@
               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
@@ -35322,57 +35610,72 @@
       }
       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) {
@@ -35396,48 +35699,47 @@
               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));
@@ -35446,6 +35748,16 @@
               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) {
@@ -35518,9 +35830,9 @@
       }
       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);
@@ -35595,7 +35907,7 @@
           }
           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
@@ -35630,13 +35942,8 @@
           }
           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) {
@@ -40136,18 +40443,8 @@
               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];
@@ -49877,7 +50174,6 @@
               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");
@@ -50263,11 +50559,6 @@
           data = deepCopy(data);
           return getXLSX(data);
       }
-      garbageCollectExternalResources() {
-          for (const plugin of this.corePlugins) {
-              plugin.garbageCollectExternalResources();
-          }
-      }
   }
   function createCommand(type, payload = {}) {
       const command = deepCopy(payload);
@@ -50411,8 +50702,8 @@
 
 
   __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";
 
 
 })(this.o_spreadsheet_engine = this.o_spreadsheet_engine || {});