@odoo/o-spreadsheet 17.2.0-alpha.8 → 17.3.0-alpha.0

package/dist/o-spreadsheet.cjs.js

@@ -3,9 +3,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.2.0-alpha.8
- * @date 2024-03-15T11:01:01.388Z
- * @hash 11cf381
+ * @version 17.3.0-alpha.0
+ * @date 2024-03-20T13:42:32.042Z
+ * @hash 073e154
  */
 
 'use strict';
@@ -642,21 +642,6 @@ function isConsecutive(iterable) {
     }
     return true;
 }
-class JetSet extends Set {
-    addMany(iterable) {
-        for (const element of iterable) {
-            super.add(element);
-        }
-        return this;
-    }
-    deleteMany(iterable) {
-        let wasDeleted = false;
-        for (const element of iterable) {
-            wasDeleted ||= super.delete(element);
-        }
-        return wasDeleted;
-    }
-}
 /**
  * Creates a version of the function that's memoized on the value of its first
  * argument, if any.
@@ -4102,14 +4087,6 @@ function positions(zone) {
     }
     return positions;
 }
-function forEachPositionsInZone(zone, callback) {
-    const { left, right, top, bottom } = zone;
-    for (let col = left; col <= right; col++) {
-        for (let row = top; row <= bottom; row++) {
-            callback(col, row);
-        }
-    }
-}
 /**
  * This function returns a zone with coordinates modified according to the change
  * applied to the zone. It may be possible to change the zone by resizing or moving
@@ -10055,6 +10032,9 @@ function makeArg(str, description) {
         result.default = true;
         result.defaultValue = defaultValue;
     }
+    if (types.some((t) => t.startsWith("RANGE"))) {
+        result.acceptMatrix = true;
+    }
     return result;
 }
 /**
@@ -18625,11 +18605,27 @@ class FunctionRegistry extends Registry {
         }
         const descr = addMetaInfoFromArg(addDescr);
         validateArguments(descr.args);
-        this.mapping[name] = addErrorHandling(addResultHandling(descr.compute), name);
+        this.mapping[name] = addErrorHandling(addResultHandling(addInputHandling(descr)), name);
         super.add(name, descr);
         return this;
     }
 }
+function addInputHandling(descr) {
+    function computeWithInputHandling(...args) {
+        for (let i = 0; i < args.length; i++) {
+            const argDefinition = descr.args[descr.getArgToFocus(i + 1) - 1];
+            const arg = args[i];
+            if (isMatrix(arg) && !argDefinition.acceptMatrix) {
+                if (arg.length !== 1 || arg[0].length !== 1) {
+                    throw new EvaluationError(_t("Function [[FUNCTION_NAME]] expects the parameter '%s' to be a single value or a single cell reference, not a range.", argDefinition.name));
+                }
+                args[i] = arg[0][0];
+            }
+        }
+        return descr.compute.apply(this, args);
+    }
+    return computeWithInputHandling;
+}
 function addErrorHandling(compute, functionName) {
     return function (...args) {
         try {
@@ -45851,6 +45847,41 @@ class CompilationParametersBuilder {
     }
 }
 
+class PositionMap {
+    map = {};
+    set({ sheetId, col, row }, value) {
+        const map = this.map;
+        if (!map[sheetId]) {
+            map[sheetId] = {};
+        }
+        if (!map[sheetId][col]) {
+            map[sheetId][col] = {};
+        }
+        map[sheetId][col][row] = value;
+    }
+    get({ sheetId, col, row }) {
+        return this.map[sheetId]?.[col]?.[row];
+    }
+    has({ sheetId, col, row }) {
+        return this.map[sheetId]?.[col]?.[row] !== undefined;
+    }
+    delete({ sheetId, col, row }) {
+        delete this.map[sheetId]?.[col]?.[row];
+    }
+    keys() {
+        const map = this.map;
+        const keys = [];
+        for (const sheetId in map) {
+            for (const col in map[sheetId]) {
+                for (const row in map[sheetId][col]) {
+                    keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
+                }
+            }
+        }
+        return keys;
+    }
+}
+
 function quickselect(arr, k, left, right, compare) {
     quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
 }
@@ -46577,26 +46608,26 @@ class ZoneRBush extends RBush {
  * It uses an R-Tree data structure to efficiently find dependent cells.
  */
 class FormulaDependencyGraph {
-    encoder;
-    dependencies = new Map();
+    createEmptyPositionSet;
+    dependencies = new PositionMap();
     rTree;
-    constructor(encoder, data = []) {
-        this.encoder = encoder;
+    constructor(createEmptyPositionSet, data = []) {
+        this.createEmptyPositionSet = createEmptyPositionSet;
         this.rTree = new SpreadsheetRTree(data);
     }
-    removeAllDependencies(formulaPositionId) {
-        const ranges = this.dependencies.get(formulaPositionId);
+    removeAllDependencies(formulaPosition) {
+        const ranges = this.dependencies.get(formulaPosition);
         if (!ranges) {
             return;
         }
         for (const range of ranges) {
             this.rTree.remove(range);
         }
-        this.dependencies.delete(formulaPositionId);
+        this.dependencies.delete(formulaPosition);
     }
-    addDependencies(formulaPositionId, dependencies) {
+    addDependencies(formulaPosition, dependencies) {
         const rTreeItems = dependencies.map(({ sheetId, zone }) => ({
-            data: formulaPositionId,
+            data: formulaPosition,
             boundingBox: {
                 zone,
                 sheetId,
@@ -46605,12 +46636,12 @@ class FormulaDependencyGraph {
         for (const item of rTreeItems) {
             this.rTree.insert(item);
         }
-        const existingDependencies = this.dependencies.get(formulaPositionId);
+        const existingDependencies = this.dependencies.get(formulaPosition);
         if (existingDependencies) {
             existingDependencies.push(...rTreeItems);
         }
         else {
-            this.dependencies.set(formulaPositionId, rTreeItems);
+            this.dependencies.set(formulaPosition, rTreeItems);
         }
     }
     /**
@@ -46619,23 +46650,194 @@ class FormulaDependencyGraph {
      * This is called a topological ordering (excluding cycles)
      */
     getCellsDependingOn(ranges) {
-        const visited = new JetSet();
+        const visited = this.createEmptyPositionSet();
         const queue = Array.from(ranges).reverse();
         while (queue.length > 0) {
             const range = queue.pop();
-            visited.addMany(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.addMany(positions(range.zone).map((position) => ({ sheetId: range.sheetId, ...position })));
+            const impactedPositions = this.rTree.search(range).map((dep) => dep.data);
+            for (const position of impactedPositions) {
+                if (!visited.has(position)) {
+                    queue.push({ sheetId: position.sheetId, zone: positionToZone(position) });
                 }
             }
         }
-        visited.deleteMany(ranges.flatMap((r) => this.encoder.encodeBoundingBox(r)));
+        visited.deleteMany(ranges.flatMap((r) => positions(r.zone).map((position) => ({ sheetId: r.sheetId, ...position }))));
         return visited;
     }
 }
 
+/**
+ * Implements a fixed-sized grid or 2D matrix of bits.
+ * based on https://github.com/zandaqo/structurae
+ *
+ * The grid is implemented as a 1D array of 32-bit integers, where each bit represents a cell in the grid.
+ * It follows row-major order, with each row stored consecutively in 32-bit blocks.
+ * Pads the number of columns to the next power of 2 to allow quick lookups with bitwise operations.
+ *
+ * Key terminology:
+ * - bucket: Index of an item in the Uint32Array, a 32-bit integer.
+ * - bitPosition: The position of a bit within the bucket 32-bit integer.
+ */
+class BinaryGrid extends Uint32Array {
+    columnOffset = 0;
+    cols = 0;
+    rows = 0;
+    /**
+     * Creates a binary grid of specified dimensions.
+     */
+    static create(rows, columns) {
+        const columnOffset = log2Ceil(columns);
+        const length = (rows << columnOffset) >> 5;
+        const grid = new this(length + 1);
+        grid.columnOffset = columnOffset;
+        grid.cols = columns;
+        grid.rows = rows;
+        return grid;
+    }
+    /**
+     * Returns the bit at given coordinates.
+     */
+    getValue(position) {
+        const [bucket, bitPosition] = this.getCoordinates(position);
+        return ((this[bucket] >> bitPosition) & 1);
+    }
+    /**
+     * Sets the bit at given coordinates.
+     */
+    setValue(position, value) {
+        const [bucket, bitPosition] = this.getCoordinates(position);
+        const currentValue = (this[bucket] >> bitPosition) & 1;
+        const hasBeenInserted = currentValue === 0 && value === 1;
+        this[bucket] = (this[bucket] & ~(1 << bitPosition)) | (value << bitPosition);
+        return hasBeenInserted;
+        // Let's breakdown of the above line:
+        // with an example with a 4-bit integer (instead of 32-bit).
+        //
+        // Let's say we want to set the bit at position 2 to 1 and the existing
+        // bit sequence this[bucket] is 1001. The final bit sequence should be 1101.
+        //
+        // First, we clear the bit at position 2 by AND-ing this[bucket] with a
+        // mask having all 1s except a 0 at the bit position (~ (1 << bitPosition)).
+        // 1 << bitPosition is 0100 (shifting 0001 to the left by 2)
+        // Inverting the bits with ~ gives the final mask ~(1 << bitPosition): 1011
+        //
+        // Then, we shift the value by the bit position (value << bitPosition: 0100)
+        // and OR the result with the previous step's result:
+        // (1001 & 1011) | 0100 = 1101
+    }
+    isEmpty() {
+        return !this.some((bucket) => bucket !== 0);
+    }
+    fillAllPositions() {
+        const thirtyTwoOnes = -1 >>> 0; // same as 2 ** 32 - 1, a 32-bit number with all bits set to 1
+        this.fill(thirtyTwoOnes);
+    }
+    clear() {
+        this.fill(0);
+    }
+    getCoordinates(position) {
+        const { row, col } = position;
+        const index = (row << this.columnOffset) + col;
+        const bucket = index >> 5;
+        return [bucket, index - (bucket << 5)];
+    }
+}
+function log2Ceil(value) {
+    // A faster version of Math.ceil(Math.log2(value)).
+    if (value === 0) {
+        return -Infinity;
+    }
+    else if (value < 0) {
+        return NaN;
+    }
+    // --value handles the case where value is a power of 2
+    return 32 - Math.clz32(--value);
+}
+
+class PositionSet {
+    sheets = {};
+    /**
+     * List of positions in the order they were inserted.
+     */
+    insertions = [];
+    maxSize = 0;
+    constructor(sheetSizes) {
+        for (const sheetId in sheetSizes) {
+            const cols = sheetSizes[sheetId].cols;
+            const rows = sheetSizes[sheetId].rows;
+            this.maxSize += cols * rows;
+            this.sheets[sheetId] = BinaryGrid.create(rows, cols);
+        }
+    }
+    add(position) {
+        const hasBeenInserted = this.sheets[position.sheetId].setValue(position, 1);
+        if (hasBeenInserted) {
+            this.insertions.push(position);
+        }
+    }
+    addMany(positions) {
+        for (const position of positions) {
+            this.add(position);
+        }
+    }
+    delete(position) {
+        this.sheets[position.sheetId].setValue(position, 0);
+    }
+    deleteMany(positions) {
+        for (const position of positions) {
+            this.delete(position);
+        }
+    }
+    has(position) {
+        return this.sheets[position.sheetId].getValue(position) === 1;
+    }
+    clear() {
+        const insertions = this.insertions;
+        this.insertions = [];
+        for (const sheetId in this.sheets) {
+            this.sheets[sheetId].clear();
+        }
+        return insertions;
+    }
+    isEmpty() {
+        if (this.insertions.length === 0) {
+            return true;
+        }
+        for (const sheetId in this.sheets) {
+            if (!this.sheets[sheetId].isEmpty()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    fillAllPositions() {
+        this.insertions = new Array(this.maxSize);
+        let index = 0;
+        for (const sheetId in this.sheets) {
+            const grid = this.sheets[sheetId];
+            grid.fillAllPositions();
+            for (let i = 0; i < grid.rows; i++) {
+                for (let j = 0; j < grid.cols; j++) {
+                    this.insertions[index++] = { sheetId, row: i, col: j };
+                }
+            }
+        }
+    }
+    /**
+     * Iterate over the positions in the order of insertion.
+     * Note that the same position may be yielded multiple times if the value was added
+     * to the set then removed and then added again.
+     */
+    *[Symbol.iterator]() {
+        for (const position of this.insertions) {
+            if (this.sheets[position.sheetId].getValue(position) === 1) {
+                yield position;
+            }
+        }
+    }
+}
+
 /**
  * Contains, for each cell, the array
  * formulas that could potentially spread on it
@@ -46649,6 +46851,7 @@ class FormulaDependencyGraph {
  *
  */
 class SpreadingRelation {
+    createEmptyPositionSet;
     /**
      * Internal structure:
      * For something like
@@ -46677,39 +46880,42 @@ class SpreadingRelation {
      * - (B1) --> (B2, B3, B4)  meaning B1 spreads on B2, B3 and B4
      *
      */
-    resultsToArrayFormulas = new Map();
-    arrayFormulasToResults = new Map();
-    getFormulaPositionsSpreadingOn(resultPositionId) {
-        return this.resultsToArrayFormulas.get(resultPositionId) || EMPTY_ARRAY;
+    resultsToArrayFormulas = new PositionMap();
+    arrayFormulasToResults = new PositionMap();
+    constructor(createEmptyPositionSet) {
+        this.createEmptyPositionSet = createEmptyPositionSet;
+    }
+    getFormulaPositionsSpreadingOn(resultPosition) {
+        return this.resultsToArrayFormulas.get(resultPosition) || EMPTY_ARRAY;
     }
-    getArrayResultPositionIds(formulasPositionId) {
-        return this.arrayFormulasToResults.get(formulasPositionId) || EMPTY_ARRAY;
+    getArrayResultPositions(formulasPosition) {
+        return this.arrayFormulasToResults.get(formulasPosition) || EMPTY_ARRAY;
     }
     /**
      * Remove a node, also remove it from other nodes adjacency list
      */
-    removeNode(positionId) {
-        this.resultsToArrayFormulas.delete(positionId);
-        this.arrayFormulasToResults.delete(positionId);
+    removeNode(position) {
+        this.resultsToArrayFormulas.delete(position);
+        this.arrayFormulasToResults.delete(position);
     }
     /**
      * Create a spreading relation between two cells
      */
-    addRelation({ arrayFormulaPositionId, resultPositionId, }) {
-        if (!this.resultsToArrayFormulas.has(resultPositionId)) {
-            this.resultsToArrayFormulas.set(resultPositionId, new Set());
+    addRelation({ arrayFormulaPosition, resultPosition, }) {
+        if (!this.resultsToArrayFormulas.has(resultPosition)) {
+            this.resultsToArrayFormulas.set(resultPosition, this.createEmptyPositionSet());
         }
-        this.resultsToArrayFormulas.get(resultPositionId)?.add(arrayFormulaPositionId);
-        if (!this.arrayFormulasToResults.has(arrayFormulaPositionId)) {
-            this.arrayFormulasToResults.set(arrayFormulaPositionId, new Set());
+        this.resultsToArrayFormulas.get(resultPosition)?.add(arrayFormulaPosition);
+        if (!this.arrayFormulasToResults.has(arrayFormulaPosition)) {
+            this.arrayFormulasToResults.set(arrayFormulaPosition, this.createEmptyPositionSet());
         }
-        this.arrayFormulasToResults.get(arrayFormulaPositionId)?.add(resultPositionId);
+        this.arrayFormulasToResults.get(arrayFormulaPosition)?.add(resultPosition);
     }
-    hasArrayFormulaResult(positionId) {
-        return this.resultsToArrayFormulas.has(positionId);
+    hasArrayFormulaResult(position) {
+        return this.resultsToArrayFormulas.has(position);
     }
-    isArrayFormula(positionId) {
-        return this.arrayFormulasToResults.has(positionId);
+    isArrayFormula(position) {
+        return this.arrayFormulasToResults.has(position);
     }
 }
 const EMPTY_ARRAY = [];
@@ -46721,50 +46927,41 @@ class Evaluator {
     context;
     getters;
     compilationParams;
-    encoder = new PositionBitsEncoder();
-    evaluatedCells = new Map();
-    formulaDependencies = lazy(new FormulaDependencyGraph(this.encoder));
-    blockedArrayFormulas = new Set();
-    spreadingRelations = new SpreadingRelation();
+    evaluatedCells = new PositionMap();
+    formulaDependencies = lazy(new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this)));
+    blockedArrayFormulas = new PositionSet({});
+    spreadingRelations = new SpreadingRelation(this.createEmptyPositionSet.bind(this));
     constructor(context, getters) {
         this.context = context;
         this.getters = getters;
         this.compilationParams = buildCompilationParameters(this.context, this.getters, this.computeAndSave.bind(this));
     }
     getEvaluatedCell(position) {
-        return this.evaluatedCells.get(this.encoder.encode(position)) || EMPTY_CELL;
+        return this.evaluatedCells.get(position) || EMPTY_CELL;
     }
     getSpreadPositionsOf(position) {
-        const positionId = this.encoder.encode(position);
-        if (!this.spreadingRelations.isArrayFormula(positionId)) {
+        if (!this.spreadingRelations.isArrayFormula(position)) {
             return [];
         }
-        return Array.from(this.spreadingRelations.getArrayResultPositionIds(positionId)).map((positionId) => this.encoder.decode(positionId));
-    }
-    getArrayFormulaSpreadingOn(position) {
-        const positionId = this.encoder.encode(position);
-        const formulaPosition = this.getArrayFormulaSpreadingOnId(positionId);
-        return formulaPosition !== undefined ? this.encoder.decode(formulaPosition) : undefined;
+        return Array.from(this.spreadingRelations.getArrayResultPositions(position));
     }
     getEvaluatedPositions() {
-        return [...this.evaluatedCells.keys()].map((p) => this.encoder.decode(p));
+        return this.evaluatedCells.keys();
     }
-    getArrayFormulaSpreadingOnId(positionId) {
-        if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
+    getArrayFormulaSpreadingOn(position) {
+        if (!this.spreadingRelations.hasArrayFormulaResult(position)) {
             return undefined;
         }
-        const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(positionId);
-        return Array.from(arrayFormulas).find((positionId) => !this.blockedArrayFormulas.has(positionId));
+        const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(position);
+        return Array.from(arrayFormulas).find((position) => !this.blockedArrayFormulas.has(position));
     }
     updateDependencies(position) {
-        const positionId = this.encoder.encode(position);
-        this.formulaDependencies().removeAllDependencies(positionId);
-        const dependencies = this.getDirectDependencies(positionId);
-        this.formulaDependencies().addDependencies(positionId, dependencies);
+        this.formulaDependencies().removeAllDependencies(position);
+        const dependencies = this.getDirectDependencies(position);
+        this.formulaDependencies().addDependencies(position, dependencies);
     }
     addDependencies(position, dependencies) {
-        const positionId = this.encoder.encode(position);
-        this.formulaDependencies().addDependencies(positionId, dependencies);
+        this.formulaDependencies().addDependencies(position, dependencies);
     }
     updateCompilationParameters() {
         // rebuild the compilation parameters (with a clean cache)
@@ -46772,47 +46969,57 @@ class Evaluator {
         this.compilationParams.evalContext.updateDependencies = this.updateDependencies.bind(this);
         this.compilationParams.evalContext.addDependencies = this.addDependencies.bind(this);
     }
+    createEmptyPositionSet() {
+        const sheetSizes = {};
+        for (const sheetId of this.getters.getSheetIds()) {
+            sheetSizes[sheetId] = {
+                rows: this.getters.getNumberRows(sheetId),
+                cols: this.getters.getNumberCols(sheetId),
+            };
+        }
+        return new PositionSet(sheetSizes);
+    }
     evaluateCells(positions) {
-        const cells = positions.map((p) => this.encoder.encode(p));
-        const cellsToCompute = new JetSet(cells);
-        const arrayFormulasPositionIds = this.getArrayFormulasImpactedByChangesOf(cells);
-        cellsToCompute.addMany(this.getCellsDependingOn(cells));
-        cellsToCompute.addMany(arrayFormulasPositionIds);
-        cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositionIds));
+        const cellsToCompute = this.createEmptyPositionSet();
+        cellsToCompute.addMany(positions);
+        const arrayFormulasPositions = this.getArrayFormulasImpactedByChangesOf(positions);
+        cellsToCompute.addMany(this.getCellsDependingOn(positions));
+        cellsToCompute.addMany(arrayFormulasPositions);
+        cellsToCompute.addMany(this.getCellsDependingOn(arrayFormulasPositions));
         this.evaluate(cellsToCompute);
     }
-    getArrayFormulasImpactedByChangesOf(positionIds) {
-        const impactedPositionIds = new JetSet();
-        for (const positionId of positionIds) {
-            const content = this.getCell(positionId)?.content;
-            const arrayFormulaPositionId = this.getArrayFormulaSpreadingOnId(positionId);
-            if (arrayFormulaPositionId !== undefined) {
+    getArrayFormulasImpactedByChangesOf(positions) {
+        const impactedPositions = this.createEmptyPositionSet();
+        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.
-                impactedPositionIds.add(arrayFormulaPositionId);
+                impactedPositions.add(arrayFormulaPosition);
             }
             if (!content) {
                 // The previous content could have blocked some array formulas
-                impactedPositionIds.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(positionId));
+                impactedPositions.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(position));
             }
         }
-        return impactedPositionIds;
+        return impactedPositions;
     }
     buildDependencyGraph() {
-        this.blockedArrayFormulas = new Set();
-        this.spreadingRelations = new SpreadingRelation();
+        this.blockedArrayFormulas = this.createEmptyPositionSet();
+        this.spreadingRelations = new SpreadingRelation(this.createEmptyPositionSet.bind(this));
         this.formulaDependencies = lazy(() => {
-            const dependencies = [...this.getAllCells()].flatMap((positionId) => this.getDirectDependencies(positionId).map((range) => ({
-                data: positionId,
+            const dependencies = [...this.getAllCells()].flatMap((position) => this.getDirectDependencies(position).map((range) => ({
+                data: position,
                 boundingBox: {
                     zone: range.zone,
                     sheetId: range.sheetId,
                 },
             })));
-            return new FormulaDependencyGraph(this.encoder, dependencies);
+            return new FormulaDependencyGraph(this.createEmptyPositionSet.bind(this), dependencies);
         });
     }
     evaluateAllCells() {
-        this.evaluatedCells = new Map();
+        this.evaluatedCells = new PositionMap();
         this.evaluate(this.getAllCells());
     }
     evaluateFormula(sheetId, formulaString) {
@@ -46829,57 +47036,50 @@ class Evaluator {
         return result.value;
     }
     getAllCells() {
-        const positionIds = new JetSet();
-        for (const sheetId of this.getters.getSheetIds()) {
-            const cellIds = this.getters.getCells(sheetId);
-            for (const cellId in cellIds) {
-                positionIds.add(this.encoder.encode(this.getters.getCellPosition(cellId)));
-            }
-        }
-        return positionIds;
+        const positions = this.createEmptyPositionSet();
+        positions.fillAllPositions();
+        return positions;
     }
-    getArrayFormulasBlockedByOrSpreadingOn(positionId) {
-        if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
+    getArrayFormulasBlockedByOrSpreadingOn(position) {
+        if (!this.spreadingRelations.hasArrayFormulaResult(position)) {
             return [];
         }
-        const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(positionId);
-        const cells = new JetSet(arrayFormulas);
-        cells.addMany(this.getCellsDependingOn(arrayFormulas));
-        return cells;
+        const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(position);
+        const positions = this.createEmptyPositionSet();
+        positions.addMany(arrayFormulas);
+        positions.addMany(this.getCellsDependingOn(arrayFormulas));
+        return positions;
     }
-    nextPositionsToUpdate = new JetSet();
+    nextPositionsToUpdate = new PositionSet({});
     cellsBeingComputed = new Set();
-    evaluate(cells) {
+    evaluate(positions) {
         this.cellsBeingComputed = new Set();
-        this.nextPositionsToUpdate = cells;
+        this.nextPositionsToUpdate = positions;
         let currentIteration = 0;
-        while (this.nextPositionsToUpdate.size && currentIteration++ < MAX_ITERATION) {
+        while (!this.nextPositionsToUpdate.isEmpty() && currentIteration++ < MAX_ITERATION) {
             this.updateCompilationParameters();
-            const positionIds = Array.from(this.nextPositionsToUpdate);
-            this.nextPositionsToUpdate.clear();
-            for (let i = 0; i < positionIds.length; ++i) {
-                const cell = positionIds[i];
-                this.evaluatedCells.delete(cell);
+            const positions = this.nextPositionsToUpdate.clear();
+            for (let i = 0; i < positions.length; ++i) {
+                this.evaluatedCells.delete(positions[i]);
             }
-            for (let i = 0; i < positionIds.length; ++i) {
-                const cell = positionIds[i];
-                this.setEvaluatedCell(cell, this.computeCell(cell));
+            for (let i = 0; i < positions.length; ++i) {
+                const position = positions[i];
+                const evaluatedCell = this.computeCell(position);
+                if (evaluatedCell !== EMPTY_CELL) {
+                    this.evaluatedCells.set(position, evaluatedCell);
+                }
             }
         }
     }
-    setEvaluatedCell(positionId, evaluatedCell) {
-        this.evaluatedCells.set(positionId, evaluatedCell);
-    }
-    computeCell(positionId) {
-        const evaluation = this.evaluatedCells.get(positionId);
+    computeCell(position) {
+        const evaluation = this.evaluatedCells.get(position);
         if (evaluation) {
             return evaluation; // already computed
         }
-        if (!this.blockedArrayFormulas.has(positionId)) {
-            this.invalidateSpreading(positionId);
+        if (!this.blockedArrayFormulas.has(position)) {
+            this.invalidateSpreading(position);
         }
-        const cellPosition = this.encoder.decode(positionId);
-        const cell = this.getters.getCell(cellPosition);
+        const cell = this.getters.getCell(position);
         if (cell === undefined) {
             return EMPTY_CELL;
         }
@@ -46891,7 +47091,7 @@ class Evaluator {
             }
             this.cellsBeingComputed.add(cellId);
             return cell.isFormula
-                ? this.computeFormulaCell(cellPosition.sheetId, cell)
+                ? this.computeFormulaCell(position.sheetId, cell)
                 : evaluateLiteral(cell.content, localeFormat);
         }
         catch (e) {
@@ -46904,10 +47104,9 @@ class Evaluator {
         }
     }
     computeAndSave(position) {
-        const positionId = this.encoder.encode(position);
-        const evaluatedCell = this.computeCell(positionId);
-        if (!this.evaluatedCells.has(positionId)) {
-            this.setEvaluatedCell(positionId, evaluatedCell);
+        const evaluatedCell = this.computeCell(position);
+        if (!this.evaluatedCells.has(position)) {
+            this.evaluatedCells.set(position, evaluatedCell);
         }
         return evaluatedCell;
     }
@@ -46945,24 +47144,23 @@ class Evaluator {
         throw new EvaluationError(_t("Result couldn't be automatically expanded. Please insert more columns and rows."));
     }
     updateSpreadRelation({ sheetId, col, row, }) {
-        const arrayFormulaPositionId = this.encoder.encode({ sheetId, col, row });
+        const arrayFormulaPosition = { sheetId, col, row };
         return (i, j) => {
             const position = { sheetId, col: i + col, row: j + row };
-            const resultPositionId = this.encoder.encode(position);
-            this.spreadingRelations.addRelation({ resultPositionId, arrayFormulaPositionId });
+            this.spreadingRelations.addRelation({ resultPosition: position, arrayFormulaPosition });
         };
     }
-    checkCollision({ sheetId, col, row }) {
-        const formulaPositionId = this.encoder.encode({ sheetId, col, row });
+    checkCollision(formulaPosition) {
+        const { sheetId, col, row } = formulaPosition;
         return (i, j) => {
             const position = { sheetId: sheetId, col: i + col, row: j + row };
             const rawCell = this.getters.getCell(position);
             if (rawCell?.content ||
                 this.getters.getEvaluatedCell(position).type !== CellValueType.empty) {
-                this.blockedArrayFormulas.add(formulaPositionId);
+                this.blockedArrayFormulas.add(formulaPosition);
                 throw new EvaluationError(_t("Array result was not expanded because it would overwrite data in %s.", toXC(position.col, position.row)));
             }
-            this.blockedArrayFormulas.delete(formulaPositionId);
+            this.blockedArrayFormulas.delete(formulaPosition);
         };
     }
     spreadValues({ sheetId, col, row }, matrixResult) {
@@ -46970,19 +47168,18 @@ class Evaluator {
             const position = { sheetId, col: i + col, row: j + row };
             const cell = this.getters.getCell(position);
             const evaluatedCell = createEvaluatedCell(nullValueToZeroValue(matrixResult[i][j]), this.getters.getLocale(), cell);
-            const positionId = this.encoder.encode(position);
-            this.setEvaluatedCell(positionId, evaluatedCell);
+            this.evaluatedCells.set(position, evaluatedCell);
             // check if formula dependencies present in the spread zone
             // if so, they need to be recomputed
-            this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([positionId]));
+            this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([position]));
         };
     }
-    invalidateSpreading(positionId) {
-        if (!this.spreadingRelations.isArrayFormula(positionId)) {
+    invalidateSpreading(position) {
+        if (!this.spreadingRelations.isArrayFormula(position)) {
             return;
         }
-        for (const child of this.spreadingRelations.getArrayResultPositionIds(positionId)) {
-            const content = this.getCell(child)?.content;
+        for (const child of this.spreadingRelations.getArrayResultPositions(position)) {
+            const content = this.getters.getCell(child)?.content;
             if (content) {
                 // there's no point at re-evaluating overlapping array formulas,
                 // there's still a collision
@@ -46992,28 +47189,25 @@ class Evaluator {
             this.nextPositionsToUpdate.addMany(this.getCellsDependingOn([child]));
             this.nextPositionsToUpdate.addMany(this.getArrayFormulasBlockedByOrSpreadingOn(child));
         }
-        this.spreadingRelations.removeNode(positionId);
+        this.spreadingRelations.removeNode(position);
     }
     // ----------------------------------------------------------
     //                 COMMON FUNCTIONALITY
     // ----------------------------------------------------------
-    getDirectDependencies(positionId) {
-        const cell = this.getCell(positionId);
+    getDirectDependencies(position) {
+        const cell = this.getters.getCell(position);
         if (!cell?.isFormula) {
             return [];
         }
         return cell.compiledFormula.dependencies;
     }
-    getCellsDependingOn(positionIds) {
+    getCellsDependingOn(positions) {
         const ranges = [];
-        for (const positionId of positionIds) {
-            ranges.push(this.encoder.decodeToBoundingBox(positionId));
+        for (const position of positions) {
+            ranges.push({ sheetId: position.sheetId, zone: positionToZone(position) });
         }
         return this.formulaDependencies().getCellsDependingOn(ranges);
     }
-    getCell(positionId) {
-        return this.getters.getCell(this.encoder.decode(positionId));
-    }
 }
 function forEachSpreadPositionInMatrix(nbColumns, nbRows, callback) {
     for (let i = 0; i < nbColumns; ++i) {
@@ -47039,85 +47233,6 @@ function nullValueToZeroValue(fPayload) {
     }
     return fPayload;
 }
-/**
- * Encode (and decode) cell positions { sheetId, col, row }
- * to a single integer.
- *
- * `col` and `row` values are encoded on 21 bits each (max 2^21 = 2_097_152),
- * An incremental integer id is assigned to each different sheet id, starting at 0.
- *
- * e.g.
- * Given { col: 10, row: 4, sheetId: "abcde" }
- * we have:
- *  - row "4" encoded on 21 bits:  000000000000000000100
- *  - col "10" encoded on 21 bits: 000000000000000001010
- *  - sheetId: let's say it's the 4th sheetId met, encoded to: 11
- *
- * The final encoded value is found by concatenating the 3 bit sequences:
- *
- * sheetId: 11
- * col:       000000000000000001010
- * row:                            000000000000000000100
- * =>       11000000000000000001010000000000000000000100
- *
- * this binary sequence is the integer 13194160504836
- */
-class PositionBitsEncoder {
-    sheetMapping = {};
-    inverseSheetMapping = new Map();
-    constructor() {
-        try {
-            // @ts-ignore
-            o_spreadsheet.__DEBUG__ = o_spreadsheet.__DEBUG__ || {};
-            // @ts-ignore
-            o_spreadsheet.__DEBUG__.decodePosition = this.decode.bind(this);
-            // @ts-ignore
-            o_spreadsheet.__DEBUG__.encodePosition = this.encode.bind(this);
-        }
-        catch (error) { }
-    }
-    /**
-     * Encode a cell position to a single integer.
-     */
-    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);
-        const col = Number((id >> 21n) & 2097151n);
-        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) {
-            const newSheetKey = BigInt(Object.keys(this.sheetMapping).length);
-            this.sheetMapping[sheetId] = newSheetKey;
-            this.inverseSheetMapping.set(newSheetKey, sheetId);
-            return newSheetKey;
-        }
-        return sheetKey;
-    }
-    decodeSheet(sheetKey) {
-        const sheetId = this.inverseSheetMapping.get(sheetKey);
-        if (sheetId === undefined) {
-            throw new Error("Sheet id not found");
-        }
-        return sheetId;
-    }
-}
 function updateEvalContextAndExecute(compiledFormula, compilationParams, sheetId, cellId) {
     compilationParams.evalContext.__originCellXC = lazy(() => {
         if (!cellId) {
@@ -47264,6 +47379,10 @@ class EvaluationPlugin extends UIPlugin {
                     this.evaluator.updateDependencies(cmd);
                 }
                 break;
+            case "DUPLICATE_SHEET":
+            case "CREATE_SHEET":
+                this.shouldRebuildDependenciesGraph = true;
+                break;
             case "EVALUATE_CELLS":
                 this.evaluator.evaluateAllCells();
                 break;
@@ -60048,6 +60167,6 @@ exports.tokenColors = tokenColors;
 exports.tokenize = tokenize;
 
 
-__info__.version = "17.2.0-alpha.8";
-__info__.date = "2024-03-15T11:01:01.388Z";
-__info__.hash = "11cf381";
+__info__.version = "17.3.0-alpha.0";
+__info__.date = "2024-03-20T13:42:32.042Z";
+__info__.hash = "073e154";