@odoo/o-spreadsheet 16.3.1 → 16.4.0-alpha.1

package/dist/o-spreadsheet.cjs.js

@@ -1117,6 +1117,21 @@ function isConsecutive(iterable) {
         }
     }
     return true;
+}
+class JetSet extends Set {
+    add(...iterable) {
+        for (const element of iterable) {
+            super.add(element);
+        }
+        return this;
+    }
+    delete(...iterable) {
+        let deleted = false;
+        for (const element of iterable) {
+            deleted ||= super.delete(element);
+        }
+        return deleted;
+    }
 }
 
 const RBA_REGEX = /rgba?\(|\s+|\)/gi;
@@ -2887,6 +2902,14 @@ 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
@@ -4187,6 +4210,11 @@ const invalidateEvaluationCommands = new Set([
     "INSERT_CELL",
     "UNDO",
     "REDO",
+    "ADD_MERGE",
+]);
+const invalidateDependenciesCommands = new Set([
+    ...invalidateEvaluationCommands,
+    "MOVE_RANGES",
 ]);
 const invalidateCFEvaluationCommands = new Set([
     ...invalidateEvaluationCommands,
@@ -4404,6 +4432,9 @@ exports.CommandResult = void 0;
 })(exports.CommandResult || (exports.CommandResult = {}));
 
 const borderStyles = ["thin", "medium", "thick", "dashed", "dotted"];
+function isMatrix(x) {
+    return Array.isArray(x) && Array.isArray(x[0]);
+}
 var DIRECTION;
 (function (DIRECTION) {
     DIRECTION["UP"] = "up";
@@ -10369,7 +10400,7 @@ const PRODUCT = {
     ],
     returns: ["NUMBER"],
     computeFormat: (factor1) => {
-        return Array.isArray(factor1) ? factor1[0][0]?.format : factor1?.format;
+        return Array.isArray(factor1?.format) ? factor1.format[0][0] : factor1?.format;
     },
     compute: function (...factors) {
         let count = 0;
@@ -10595,7 +10626,7 @@ const SUM = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         return reduceNumbers(values, (acc, a) => acc + a, 0);
@@ -10867,7 +10898,7 @@ const AVERAGE = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         let count = 0;
@@ -10895,7 +10926,7 @@ const AVERAGE_WEIGHTED = {
     ],
     returns: ["NUMBER"],
     computeFormat: (values) => {
-        return Array.isArray(values) ? values[0][0]?.format : values?.format;
+        return Array.isArray(values?.format) ? values.format[0][0] : values?.format;
     },
     compute: function (...values) {
         let sum = 0;
@@ -10953,7 +10984,7 @@ const AVERAGEA = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         let count = 0;
@@ -11126,7 +11157,7 @@ const LARGE = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, n) {
         const _n = Math.trunc(toNumber(n));
@@ -11162,7 +11193,7 @@ const MAX = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         const result = reduceNumbers(values, (acc, a) => (acc < a ? a : acc), -Infinity);
@@ -11181,7 +11212,7 @@ const MAXA = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         const maxa = reduceNumbersTextAs0(values, (acc, a) => {
@@ -11227,7 +11258,7 @@ const MEDIAN = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         let data = [];
@@ -11249,7 +11280,7 @@ const MIN = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity);
@@ -11268,7 +11299,7 @@ const MINA = {
     ],
     returns: ["NUMBER"],
     computeFormat: (value1) => {
-        return Array.isArray(value1) ? value1[0][0]?.format : value1?.format;
+        return Array.isArray(value1?.format) ? value1.format[0][0] : value1?.format;
     },
     compute: function (...values) {
         const mina = reduceNumbersTextAs0(values, (acc, a) => {
@@ -11314,7 +11345,7 @@ const PERCENTILE = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, percentile) {
         return PERCENTILE_INC.compute(data, percentile);
@@ -11332,7 +11363,7 @@ const PERCENTILE_EXC = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, percentile) {
         return centile([data], percentile, false);
@@ -11350,7 +11381,7 @@ const PERCENTILE_INC = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, percentile) {
         return centile([data], percentile, true);
@@ -11368,7 +11399,7 @@ const QUARTILE = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, quartileNumber) {
         return QUARTILE_INC.compute(data, quartileNumber);
@@ -11386,7 +11417,7 @@ const QUARTILE_EXC = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, quartileNumber) {
         const _quartileNumber = Math.trunc(toNumber(quartileNumber));
@@ -11405,7 +11436,7 @@ const QUARTILE_INC = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, quartileNumber) {
         const _quartileNumber = Math.trunc(toNumber(quartileNumber));
@@ -11424,7 +11455,7 @@ const SMALL = {
     ],
     returns: ["NUMBER"],
     computeFormat: (data) => {
-        return Array.isArray(data) ? data[0][0]?.format : data?.format;
+        return Array.isArray(data?.format) ? data.format[0][0] : data?.format;
     },
     compute: function (data, n) {
         const _n = Math.trunc(toNumber(n));
@@ -16211,17 +16242,11 @@ function extractArgValuesFromArgs(args) {
             return undefined;
         }
         if (typeof arg === "function") {
-            return () => _extractArgValuesFromArgs(arg());
+            return () => arg()?.value;
         }
-        return _extractArgValuesFromArgs(arg);
+        return arg.value;
     });
 }
-function _extractArgValuesFromArgs(arg) {
-    if (Array.isArray(arg)) {
-        return arg.map((col) => col.map((simpleArg) => simpleArg?.value));
-    }
-    return arg?.value;
-}
 const functionRegistry = new FunctionRegistry();
 for (let category of categories) {
     const fns = category.functions;
@@ -20761,7 +20786,7 @@ FunctionDescriptionProvider.props = {
     argToFocus: Number,
 };
 
-const functions$2 = functionRegistry.content;
+const functions$3 = functionRegistry.content;
 const ASSISTANT_WIDTH = 300;
 const selectionIndicatorClass = "selector-flag";
 const selectionIndicatorColor = "#a9a9a9";
@@ -21263,7 +21288,7 @@ class Composer extends owl.Component {
                     // initialize Formula Assistant
                     const tokenContext = tokenAtCursor.functionContext;
                     const parentFunction = tokenContext.parent.toUpperCase();
-                    const description = functions$2[parentFunction];
+                    const description = functions$3[parentFunction];
                     const argPosition = tokenContext.argPosition;
                     this.functionDescriptionState.functionName = parentFunction;
                     this.functionDescriptionState.functionDescription = description;
@@ -22134,6 +22159,21 @@ FiguresContainer.props = {
     onFigureDeleted: Function,
 };
 
+/**
+ * Manages an event listener on a ref. Useful for hooks that want to manage
+ * event listeners, especially more than one. Prefer using t-on directly in
+ * components. If your hook only needs a single event listener, consider simply
+ * returning it from the hook and letting the user attach it with t-on.
+ *
+ * Adapted from Odoo Community - See https://github.com/odoo/odoo/blob/saas-16.2/addons/web/static/src/core/utils/hooks.js
+ */
+function useRefListener(ref, ...listener) {
+    owl.useEffect((el) => {
+        el?.addEventListener(...listener);
+        return () => el?.removeEventListener(...listener);
+    }, () => [ref.el]);
+}
+
 /**
  * Repeatedly calls a callback function with a time delay between calls.
  */
@@ -22196,20 +22236,10 @@ function useCellHovered(env, gridRef, callback) {
             setPosition(undefined, undefined);
         }
     }
-    owl.onMounted(() => {
-        const grid = gridRef.el;
-        grid.addEventListener("mousemove", updateMousePosition);
-        grid.addEventListener("mouseleave", pause);
-        grid.addEventListener("mouseenter", resume);
-        grid.addEventListener("mousedown", recompute);
-    });
-    owl.onWillUnmount(() => {
-        const grid = gridRef.el;
-        grid.removeEventListener("mousemove", updateMousePosition);
-        grid.removeEventListener("mouseleave", pause);
-        grid.removeEventListener("mouseenter", resume);
-        grid.removeEventListener("mousedown", recompute);
-    });
+    useRefListener(gridRef, "mousemove", updateMousePosition);
+    useRefListener(gridRef, "mouseleave", pause);
+    useRefListener(gridRef, "mouseenter", resume);
+    useRefListener(gridRef, "mousedown", recompute);
     function setPosition(col, row) {
         if (col !== hoveredPosition.col || row !== hoveredPosition.row) {
             hoveredPosition.col = col;
@@ -22248,16 +22278,9 @@ function useTouchMove(gridRef, handler, canMoveUp) {
         x = currentX;
         y = currentY;
     }
-    owl.onMounted(() => {
-        gridRef.el.addEventListener("touchstart", onTouchStart);
-        gridRef.el.addEventListener("touchend", onTouchEnd);
-        gridRef.el.addEventListener("touchmove", onTouchMove);
-    });
-    owl.onWillUnmount(() => {
-        gridRef.el.removeEventListener("touchstart", onTouchStart);
-        gridRef.el.removeEventListener("touchend", onTouchEnd);
-        gridRef.el.removeEventListener("touchmove", onTouchMove);
-    });
+    useRefListener(gridRef, "touchstart", onTouchStart);
+    useRefListener(gridRef, "touchend", onTouchEnd);
+    useRefListener(gridRef, "touchmove", onTouchMove);
 }
 class GridOverlay extends owl.Component {
     static template = "o-spreadsheet-GridOverlay";
@@ -25108,7 +25131,7 @@ function indentCode(code) {
  * is useful for the composer, which needs to be able to work with incomplete
  * formulas.
  */
-const functions$1 = functionRegistry.content;
+const functions$2 = functionRegistry.content;
 const POSTFIX_UNARY_OPERATORS = ["%"];
 const OPERATORS = "+,-,*,/,:,=,<>,>=,>,<=,<,^,&".split(",").concat(POSTFIX_UNARY_OPERATORS);
 function tokenize(str) {
@@ -25231,7 +25254,7 @@ function tokenizeSymbol(chars) {
     }
     if (result.length) {
         const value = result;
-        const isFunction = value.toUpperCase() in functions$1;
+        const isFunction = value.toUpperCase() in functions$2;
         if (isFunction) {
             return { type: "FUNCTION", value };
         }
@@ -25701,7 +25724,7 @@ function rangeTokenize(formula) {
     return result;
 }
 
-const functions = functionRegistry.content;
+const functions$1 = functionRegistry.content;
 const OPERATOR_MAP = {
     "=": "EQ",
     "+": "ADD",
@@ -25764,56 +25787,32 @@ function compile(formula) {
          * between a cell value and a non cell value.
          */
         function compileFunctionArgs(ast) {
-            const functionDefinition = functions[ast.value.toUpperCase()];
-            const currentFunctionArguments = ast.args;
-            // check if arguments are supplied in the correct quantities
-            const nbrArg = currentFunctionArguments.length;
-            if (nbrArg < functionDefinition.minArgRequired) {
-                throw new BadExpressionError(_lt("Invalid number of arguments for the %s function. Expected %s minimum, but got %s instead.", ast.value.toUpperCase(), functionDefinition.minArgRequired.toString(), nbrArg.toString()));
-            }
-            if (nbrArg > functionDefinition.maxArgPossible) {
-                throw new BadExpressionError(_lt("Invalid number of arguments for the %s function. Expected %s maximum, but got %s instead.", ast.value.toUpperCase(), functionDefinition.maxArgPossible.toString(), nbrArg.toString()));
-            }
-            const repeatingArg = functionDefinition.nbrArgRepeating;
-            if (repeatingArg > 1) {
-                const argBeforeRepeat = functionDefinition.args.length - repeatingArg;
-                const nbrRepeatingArg = nbrArg - argBeforeRepeat;
-                if (nbrRepeatingArg % repeatingArg !== 0) {
-                    throw new BadExpressionError(_lt("Invalid number of arguments for the %s function. Expected all arguments after position %s to be supplied by groups of %s arguments", ast.value.toUpperCase(), argBeforeRepeat.toString(), repeatingArg.toString()));
-                }
-            }
-            let compiledArgs = [];
-            for (let i = 0; i < nbrArg; i++) {
-                const argPosition = functionDefinition.getArgToFocus(i + 1) - 1;
-                if (0 <= argPosition && argPosition < functionDefinition.args.length) {
-                    const currentArg = currentFunctionArguments[i];
-                    const argDefinition = functionDefinition.args[argPosition];
-                    const argTypes = argDefinition.type || [];
-                    // detect when an argument need to be evaluated as a meta argument
-                    const isMeta = argTypes.includes("META");
-                    // detect when an argument need to be evaluated as a lazy argument
-                    const isLazy = argDefinition.lazy;
-                    const hasRange = argTypes.some((t) => t === "RANGE" ||
-                        t === "RANGE<BOOLEAN>" ||
-                        t === "RANGE<DATE>" ||
-                        t === "RANGE<NUMBER>" ||
-                        t === "RANGE<STRING>");
-                    const isRangeOnly = argTypes.every((t) => t === "RANGE" ||
-                        t === "RANGE<BOOLEAN>" ||
-                        t === "RANGE<DATE>" ||
-                        t === "RANGE<NUMBER>" ||
-                        t === "RANGE<STRING>");
-                    if (isRangeOnly) {
-                        if (currentArg.type !== "REFERENCE") {
-                            throw new BadExpressionError(_lt("Function %s expects the parameter %s to be reference to a cell or range, not a %s.", ast.value.toUpperCase(), (i + 1).toString(), currentArg.type.toLowerCase()));
-                        }
+            const { args } = ast;
+            const functionName = ast.value.toUpperCase();
+            const functionDefinition = functions$1[functionName];
+            assertEnoughArgs(ast);
+            const compiledArgs = [];
+            for (let i = 0; i < args.length; i++) {
+                const argToFocus = functionDefinition.getArgToFocus(i + 1) - 1;
+                const argDefinition = functionDefinition.args[argToFocus];
+                const currentArg = args[i];
+                const argTypes = argDefinition.type || [];
+                // detect when an argument need to be evaluated as a meta argument
+                const isMeta = argTypes.includes("META");
+                // detect when an argument need to be evaluated as a lazy argument
+                const isLazy = argDefinition.lazy;
+                const hasRange = argTypes.some((t) => isRangeType(t));
+                const isRangeOnly = argTypes.every((t) => isRangeType(t));
+                if (isRangeOnly) {
+                    if (!isRangeInput(currentArg)) {
+                        throw new BadExpressionError(_lt("Function %s expects the parameter %s to be reference to a cell or range, not a %s.", functionName, (i + 1).toString(), currentArg.type.toLowerCase()));
                     }
-                    const compiledAST = compileAST(currentArg, isMeta, hasRange, {
-                        functionName: ast.value.toUpperCase(),
-                        paramIndex: i + 1,
-                    });
-                    compiledArgs.push(isLazy ? compiledAST.wrapInClosure() : compiledAST);
                 }
+                const compiledAST = compileAST(currentArg, isMeta, hasRange, {
+                    functionName,
+                    paramIndex: i + 1,
+                });
+                compiledArgs.push(isLazy ? compiledAST.wrapInClosure() : compiledAST);
             }
             return compiledArgs;
         }
@@ -25957,6 +25956,41 @@ function formulaArguments(tokens) {
         dependencies,
         constantValues,
     };
+}
+/**
+ * Check if arguments are supplied in the correct quantities
+ */
+function assertEnoughArgs(ast) {
+    const nbrArg = ast.args.length;
+    const functionName = ast.value.toUpperCase();
+    const functionDefinition = functions$1[functionName];
+    if (nbrArg < functionDefinition.minArgRequired) {
+        throw new BadExpressionError(_lt("Invalid number of arguments for the %s function. Expected %s minimum, but got %s instead.", functionName, functionDefinition.minArgRequired.toString(), nbrArg.toString()));
+    }
+    if (nbrArg > functionDefinition.maxArgPossible) {
+        throw new BadExpressionError(_lt("Invalid number of arguments for the %s function. Expected %s maximum, but got %s instead.", functionName, functionDefinition.maxArgPossible.toString(), nbrArg.toString()));
+    }
+    const repeatableArgs = functionDefinition.nbrArgRepeating;
+    if (repeatableArgs > 1) {
+        const unrepeatableArgs = functionDefinition.args.length - repeatableArgs;
+        const repeatingArgs = nbrArg - unrepeatableArgs;
+        if (repeatingArgs % repeatableArgs !== 0) {
+            throw new BadExpressionError(_lt("Invalid number of arguments for the %s function. Expected all arguments after position %s to be supplied by groups of %s arguments", functionName, unrepeatableArgs.toString(), repeatableArgs.toString()));
+        }
+    }
+}
+function isRangeType(type) {
+    return type.startsWith("RANGE");
+}
+function isRangeInput(arg) {
+    if (arg.type === "REFERENCE") {
+        return true;
+    }
+    if (arg.type === "FUNCALL") {
+        const fnDef = functions$1[arg.value.toUpperCase()];
+        return fnDef && isRangeType(fnDef.returns[0]);
+    }
+    return false;
 }
 
 /**
@@ -26073,16 +26107,6 @@ function convertOperator(operator) {
 // -------------------------------------
 //        WORKSHEET HELPERS
 // -------------------------------------
-function getCellType(value) {
-    switch (typeof value) {
-        case "boolean":
-            return "b";
-        case "string":
-            return "str";
-        case "number":
-            return "n";
-    }
-}
 function convertHeightToExcel(height) {
     return Math.round(HEIGHT_FACTOR * height * 100) / 100;
 }
@@ -29769,23 +29793,7 @@ class CellPlugin extends CorePlugin {
      */
     createFormulaCellWithDependencies(id, compiledFormula, format, style, sheetId) {
         const dependencies = compiledFormula.dependencies.map((xc) => this.getters.getRangeFromSheetXC(sheetId, xc));
-        const buildFormulaContent = this.buildFormulaContent.bind(this);
-        // Only for formulas with dependencies because
-        // **the closure is expensive memory-wise**
-        return {
-            id,
-            get content() {
-                return buildFormulaContent(sheetId, {
-                    dependencies: this.dependencies,
-                    compiledFormula: this.compiledFormula,
-                });
-            },
-            style,
-            format,
-            isFormula: true,
-            compiledFormula,
-            dependencies,
-        };
+        return new FormulaCellWithDependencies(id, compiledFormula, format, style, dependencies, sheetId, this.buildFormulaContent.bind(this));
     }
     createErrorFormula(id, content, format, style, error) {
         return {
@@ -29811,6 +29819,31 @@ class CellPlugin extends CorePlugin {
         const sheetZone = this.getters.getSheetZone(sheetId);
         return isInside(col, row, sheetZone) ? 0 /* CommandResult.Success */ : 18 /* CommandResult.TargetOutOfSheet */;
     }
+}
+class FormulaCellWithDependencies {
+    id;
+    compiledFormula;
+    format;
+    style;
+    dependencies;
+    sheetId;
+    buildFormulaContent;
+    isFormula = true;
+    constructor(id, compiledFormula, format, style, dependencies, sheetId, buildFormulaContent) {
+        this.id = id;
+        this.compiledFormula = compiledFormula;
+        this.format = format;
+        this.style = style;
+        this.dependencies = dependencies;
+        this.sheetId = sheetId;
+        this.buildFormulaContent = buildFormulaContent;
+    }
+    get content() {
+        return this.buildFormulaContent(this.sheetId, {
+            dependencies: this.dependencies,
+            compiledFormula: this.compiledFormula,
+        });
+    }
 }
 
 class ChartPlugin extends CorePlugin {
@@ -33102,6 +33135,931 @@ class UIPlugin extends BasePlugin {
     drawGrid(ctx, layer) { }
 }
 
+const functionMap = functionRegistry.mapping;
+/**
+ * Return all functions necessary to properly evaluate a formula:
+ * - a refFn function to read any reference, cell or range of a normalized formula
+ * - a range function to convert any reference to a proper value array
+ * - an evaluation context
+ */
+function buildCompilationParameters(context, getters, computeCell) {
+    const builder = new CompilationParametersBuilder(context, getters, computeCell);
+    return builder.getParameters();
+}
+class CompilationParametersBuilder {
+    getters;
+    computeCell;
+    evalContext;
+    constructor(context, getters, computeCell) {
+        this.getters = getters;
+        this.computeCell = computeCell;
+        this.evalContext = Object.assign(Object.create(functionMap), context, {
+            getters: this.getters,
+        });
+    }
+    getParameters() {
+        return [this.refFn.bind(this), this.range.bind(this), this.evalContext];
+    }
+    /**
+     * Returns the value of the cell(s) used in reference
+     *
+     * @param range the references used
+     * @param isMeta if a reference is supposed to be used in a `meta` parameter as described in the
+     *        function for which this parameter is used, we just return the string of the parameter.
+     *        The `compute` of the formula's function must process it completely
+     */
+    refFn(range, isMeta, functionName, paramNumber) {
+        if (isMeta) {
+            // Use zoneToXc of zone instead of getRangeString to avoid sending unbounded ranges
+            return { value: zoneToXc(range.zone) };
+        }
+        if (!isZoneValid(range.zone)) {
+            throw new InvalidReferenceError();
+        }
+        // if the formula definition could have accepted a range, we would pass through the _range function and not here
+        if (range.zone.bottom !== range.zone.top || range.zone.left !== range.zone.right) {
+            throw new Error(paramNumber
+                ? _lt("Function %s expects the parameter %s to be a single value or a single cell reference, not a range.", functionName.toString(), paramNumber.toString())
+                : _lt("Function %s expects its parameters to be single values or single cell references, not ranges.", functionName.toString()));
+        }
+        if (range.invalidSheetName) {
+            throw new Error(_lt("Invalid sheet name: %s", range.invalidSheetName));
+        }
+        return this.readCell(range);
+    }
+    readCell(range) {
+        if (!this.getters.tryGetSheet(range.sheetId)) {
+            throw new Error(_lt("Invalid sheet name"));
+        }
+        const position = { sheetId: range.sheetId, col: range.zone.left, row: range.zone.top };
+        const evaluatedCell = this.getEvaluatedCellIfNotEmpty(position);
+        if (evaluatedCell === undefined) {
+            return { value: null, format: this.getters.getCell(position)?.format };
+        }
+        return evaluatedCell;
+    }
+    getEvaluatedCellIfNotEmpty(position) {
+        const evaluatedCell = this.getEvaluatedCell(position);
+        if (evaluatedCell.type === CellValueType.empty) {
+            const cell = this.getters.getCell(position);
+            if (!cell || cell.content === "") {
+                return undefined;
+            }
+        }
+        return evaluatedCell;
+    }
+    getEvaluatedCell(position) {
+        const evaluatedCell = this.computeCell(position);
+        if (evaluatedCell.type === CellValueType.error) {
+            throw evaluatedCell.error;
+        }
+        return evaluatedCell;
+    }
+    /**
+     * Return the values of the cell(s) used in reference, but always in the format of a range even
+     * if a single cell is referenced. It is a list of col values. This is useful for the formulas that describe parameters as
+     * range<number> etc.
+     *
+     * Note that each col is possibly sparse: it only contain the values of cells
+     * that are actually present in the grid.
+     */
+    range({ sheetId, zone }) {
+        if (!isZoneValid(zone)) {
+            throw new InvalidReferenceError();
+        }
+        // Performance issue: Avoid fetching data on positions that are out of the spreadsheet
+        // e.g. A1:ZZZ9999 in a sheet with 10 cols and 10 rows should ignore everything past J10 and return a 10x10 array
+        const sheetZone = this.getters.getSheetZone(sheetId);
+        const _zone = intersection(zone, sheetZone);
+        if (!_zone) {
+            return { value: [[]], format: [[]] };
+        }
+        const height = _zone.bottom - _zone.top + 1;
+        const width = _zone.right - _zone.left + 1;
+        const value = Array.from({ length: width }, () => Array.from({ length: height }));
+        const format = Array.from({ length: width }, () => Array.from({ length: height }));
+        // Performance issue: nested loop is faster than a map here
+        for (let col = _zone.left; col <= _zone.right; col++) {
+            for (let row = _zone.top; row <= _zone.bottom; row++) {
+                const evaluatedCell = this.getEvaluatedCellIfNotEmpty({ sheetId: sheetId, col, row });
+                if (evaluatedCell) {
+                    const colIndex = col - _zone.left;
+                    const rowIndex = row - _zone.top;
+                    value[colIndex][rowIndex] = evaluatedCell.value;
+                    if (evaluatedCell.format !== undefined) {
+                        format[colIndex][rowIndex] = evaluatedCell.format;
+                    }
+                }
+            }
+        }
+        return { value, format };
+    }
+}
+
+/**
+ * This class is an implementation of a dependency Graph.
+ * The graph is used to evaluate the cells in the correct
+ * order, and should be updated each time a cell's content is modified
+ *
+ */
+class FormulaDependencyGraph {
+    /**
+     * Internal structure:
+     * - key: a cell position (encoded as an integer)
+     * - value: a set of cell positions that depends on the key
+     *
+     * Given
+     * - A1:"= B1 + SQRT(B2)"
+     * - C1:"= B1";
+     * - C2:"= C1"
+     *
+     * we will have something like:
+     * - B1 ---> (A1, C1)   meaning A1 and C1 depends on B1
+     * - B2 ---> (A1)       meaning A1 depends on B2
+     * - C1 ---> (C2)       meaning C2 depends on C1
+     */
+    inverseDependencies = new Map();
+    dependencies = new Map();
+    removeAllDependencies(formulaPositionId) {
+        const dependencies = this.dependencies.get(formulaPositionId);
+        if (!dependencies) {
+            return;
+        }
+        for (const dependency of dependencies) {
+            this.inverseDependencies.get(dependency)?.delete(formulaPositionId);
+        }
+        this.dependencies.delete(formulaPositionId);
+    }
+    addDependencies(formulaPositionId, dependencies) {
+        for (const dependency of dependencies) {
+            const inverseDependencies = this.inverseDependencies.get(dependency);
+            if (inverseDependencies) {
+                inverseDependencies.add(formulaPositionId);
+            }
+            else {
+                this.inverseDependencies.set(dependency, new Set([formulaPositionId]));
+            }
+        }
+        const existingDependencies = this.dependencies.get(formulaPositionId);
+        if (existingDependencies) {
+            existingDependencies.push(...dependencies);
+        }
+        else {
+            this.dependencies.set(formulaPositionId, dependencies);
+        }
+    }
+    /**
+     * Return the cell and all cells that depend on it,
+     * in the correct order they should be evaluated.
+     * This is called a topological ordering (excluding cycles)
+     */
+    getCellsDependingOn(positionIds) {
+        const visited = new JetSet();
+        const queue = Array.from(positionIds);
+        while (queue.length > 0) {
+            const node = queue.shift();
+            visited.add(node);
+            const adjacentNodes = this.inverseDependencies.get(node) || new Set();
+            for (const adjacentNode of adjacentNodes) {
+                if (!visited.has(adjacentNode)) {
+                    queue.push(adjacentNode);
+                }
+            }
+        }
+        visited.delete(...positionIds);
+        return visited;
+    }
+}
+
+/**
+ * Contains, for each cell, the array
+ * formulas that could potentially spread on it
+ * This is essentially a two way mapping between array formulas
+ * and their results.
+ *
+ * As we don't allow two array formulas to spread on the same cell, this structure
+ * is used to force the reevaluation of the potential spreaders of a cell when the
+ * content of this cell is modified. This structure should be updated each time
+ * an array formula is evaluated and try to spread on another cell.
+ *
+ */
+class SpreadingRelation {
+    /**
+     * Internal structure:
+     * For something like
+     * - A2:'=SPLIT("KAYAK", "A")'
+     * - B1:'=TRANSPOSE(SPLIT("COYOTE", "O"))'
+     *
+     * Resulting in:
+     * ```
+     * -----------------
+     * |   | A | B | C |
+     * |---+---+---+---|
+     * | 1 |   | C |   |
+     * | 2 | K | Y | K |
+     * | 3 |   | T |   |
+     * | 4 |   | E |   |
+     * -----------------
+     * ```
+     * We will have `resultsToArrayFormulas` looking like:
+     * - (B2) --> (A2, B1)  meaning B2 can be the result of A2 OR B1
+     * - (C2) --> (A2)      meaning C2 is the result of A2
+     * - (B3) --> (B1)      meaning B3 is the result of B1
+     * - (B4) --> (B1)      meaning B4 is the result of B1
+     *
+     * We will have `arrayFormulasToResults` looking like:
+     * - (A2) --> (B2, C2)      meaning A2 spreads on B2 and C2
+     * - (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;
+    }
+    getArrayResultPositionIds(formulasPositionId) {
+        return this.arrayFormulasToResults.get(formulasPositionId) || EMPTY_ARRAY;
+    }
+    /**
+     * Remove a node, also remove it from other nodes adjacency list
+     */
+    removeNode(positionId) {
+        this.resultsToArrayFormulas.delete(positionId);
+        this.arrayFormulasToResults.delete(positionId);
+    }
+    /**
+     * Create a spreading relation between two cells
+     */
+    addRelation({ arrayFormulaPositionId, resultPositionId, }) {
+        if (!this.resultsToArrayFormulas.has(resultPositionId)) {
+            this.resultsToArrayFormulas.set(resultPositionId, new Set());
+        }
+        this.resultsToArrayFormulas.get(resultPositionId)?.add(arrayFormulaPositionId);
+        if (!this.arrayFormulasToResults.has(arrayFormulaPositionId)) {
+            this.arrayFormulasToResults.set(arrayFormulaPositionId, new Set());
+        }
+        this.arrayFormulasToResults.get(arrayFormulaPositionId)?.add(resultPositionId);
+    }
+    hasArrayFormulaResult(positionId) {
+        return this.resultsToArrayFormulas.has(positionId);
+    }
+    isArrayFormula(positionId) {
+        return this.arrayFormulasToResults.has(positionId);
+    }
+}
+const EMPTY_ARRAY = [];
+
+const MAX_ITERATION = 30;
+class Evaluator {
+    getters;
+    compilationParams;
+    positionEncoder = new PositionBitsEncoder();
+    evaluatedCells = new Map();
+    formulaDependencies = lazy(new FormulaDependencyGraph());
+    blockedArrayFormulas = new Set();
+    spreadingRelations = new SpreadingRelation();
+    constructor(context, getters) {
+        this.getters = getters;
+        this.compilationParams = buildCompilationParameters(context, getters, (position) => this.computeCell(this.encodePosition(position)));
+    }
+    getEvaluatedCell(position) {
+        return this.evaluatedCells.get(this.encodePosition(position)) || createEvaluatedCell("");
+    }
+    getArrayFormulaSpreadingOn(position) {
+        const positionId = this.encodePosition(position);
+        const formulaPosition = this.getArrayFormulaSpreadingOnId(positionId);
+        return formulaPosition !== undefined ? this.decodePosition(formulaPosition) : undefined;
+    }
+    getEvaluatedPositions() {
+        return [...this.evaluatedCells.keys()].map(this.decodePosition.bind(this));
+    }
+    getArrayFormulaSpreadingOnId(positionId) {
+        if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
+            return undefined;
+        }
+        const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(positionId);
+        return Array.from(arrayFormulas).find((positionId) => !this.blockedArrayFormulas.has(positionId));
+    }
+    updateDependencies(position) {
+        const positionId = this.encodePosition(position);
+        this.formulaDependencies().removeAllDependencies(positionId);
+        const dependencies = this.getDirectDependencies(positionId);
+        this.formulaDependencies().addDependencies(positionId, dependencies);
+    }
+    evaluateCells(positions) {
+        const cells = positions.map(this.encodePosition.bind(this));
+        const cellsToCompute = new JetSet(cells);
+        const arrayFormulas = this.getArrayFormulasImpactedByChangesOf(cells);
+        cellsToCompute.add(...this.getCellsDependingOn(cells));
+        cellsToCompute.add(...arrayFormulas);
+        cellsToCompute.add(...this.getCellsDependingOn(arrayFormulas));
+        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) {
+                // take into account new collisions.
+                impactedPositionIds.add(arrayFormulaPositionId);
+            }
+            if (!content) {
+                // The previous content could have blocked some array formulas
+                impactedPositionIds.add(...this.getArrayFormulasBlockedByOrSpreadingOn(positionId));
+            }
+        }
+        return impactedPositionIds;
+    }
+    buildDependencyGraph() {
+        this.blockedArrayFormulas = new Set();
+        this.spreadingRelations = new SpreadingRelation();
+        this.formulaDependencies = lazy(() => {
+            const dependencyGraph = new FormulaDependencyGraph();
+            for (const positionId of this.getAllCells()) {
+                const dependencies = this.getDirectDependencies(positionId);
+                dependencyGraph.addDependencies(positionId, dependencies);
+            }
+            return dependencyGraph;
+        });
+    }
+    evaluateAllCells() {
+        this.evaluatedCells = new Map();
+        this.evaluate(this.getAllCells());
+    }
+    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.encodePosition(this.getters.getCellPosition(cellId)));
+            }
+        }
+        return positionIds;
+    }
+    getArrayFormulasBlockedByOrSpreadingOn(positionId) {
+        if (!this.spreadingRelations.hasArrayFormulaResult(positionId)) {
+            return [];
+        }
+        const arrayFormulas = this.spreadingRelations.getFormulaPositionsSpreadingOn(positionId);
+        const cells = new JetSet(arrayFormulas);
+        cells.add(...this.getCellsDependingOn(arrayFormulas));
+        return cells;
+    }
+    nextPositionsToUpdate = new JetSet();
+    cellsBeingComputed = new Set();
+    evaluate(cells) {
+        this.cellsBeingComputed = new Set();
+        this.nextPositionsToUpdate = cells;
+        let currentIteration = 0;
+        while (this.nextPositionsToUpdate.size && currentIteration++ < MAX_ITERATION) {
+            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);
+            }
+            for (let i = 0; i < positionIds.length; ++i) {
+                const cell = positionIds[i];
+                this.setEvaluatedCell(cell, this.computeCell(cell));
+            }
+        }
+    }
+    setEvaluatedCell(positionId, evaluatedCell) {
+        if (this.nextPositionsToUpdate.has(positionId)) {
+            this.nextPositionsToUpdate.delete(positionId);
+        }
+        this.evaluatedCells.set(positionId, evaluatedCell);
+    }
+    computeCell(positionId) {
+        const evaluation = this.evaluatedCells.get(positionId);
+        if (evaluation) {
+            return evaluation; // already computed
+        }
+        if (!this.blockedArrayFormulas.has(positionId)) {
+            this.invalidateSpreading(positionId);
+        }
+        const cell = this.getCell(positionId);
+        if (cell === undefined) {
+            return createEvaluatedCell("");
+        }
+        const cellId = cell.id;
+        try {
+            if (this.cellsBeingComputed.has(cellId)) {
+                throw new CircularDependencyError();
+            }
+            this.cellsBeingComputed.add(cellId);
+            return cell.isFormula
+                ? this.computeFormulaCell(cell)
+                : evaluateLiteral(cell.content, cell.format);
+        }
+        catch (e) {
+            return this.handleError(e, cell);
+        }
+        finally {
+            this.cellsBeingComputed.delete(cellId);
+        }
+    }
+    handleError(e, cell) {
+        if (!(e instanceof Error)) {
+            e = new Error(e);
+        }
+        const msg = e?.errorType || CellErrorType.GenericError;
+        // apply function name
+        const __lastFnCalled = this.compilationParams[2].__lastFnCalled || "";
+        const error = new EvaluationError(msg, e.message.replace("[[FUNCTION_NAME]]", __lastFnCalled), e.logLevel !== undefined ? e.logLevel : CellErrorLevel.error);
+        return errorCell(cell.content, error);
+    }
+    computeFormulaCell(cellData) {
+        const cellId = cellData.id;
+        this.compilationParams[2].__originCellXC = () => {
+            // compute the value lazily for performance reasons
+            const position = this.compilationParams[2].getters.getCellPosition(cellId);
+            return toXC(position.col, position.row);
+        };
+        const formulaReturn = cellData.compiledFormula.execute(cellData.dependencies, ...this.compilationParams);
+        assertFormulaReturnHasConsistentDimensions(formulaReturn);
+        const { value: computedValue, format: computedFormat } = formulaReturn;
+        if (!isMatrix(computedValue)) {
+            return createEvaluatedCell(computedValue, cellData.format || computedFormat);
+        }
+        const formulaPosition = this.getters.getCellPosition(cellId);
+        this.assertSheetHasEnoughSpaceToSpreadFormulaResult(formulaPosition, computedValue);
+        forEachSpreadPositionInMatrix(computedValue, this.updateSpreadRelation(formulaPosition));
+        forEachSpreadPositionInMatrix(computedValue, this.checkCollision(formulaPosition));
+        forEachSpreadPositionInMatrix(computedValue, 
+        // due the isMatrix check above, we know that formulaReturn is MatrixFunctionReturn
+        this.spreadValues(formulaPosition, formulaReturn));
+        const formatFromPosition = formatFromPositionAccess(computedFormat);
+        return createEvaluatedCell(computedValue[0][0], cellData.format || formatFromPosition(0, 0));
+    }
+    assertSheetHasEnoughSpaceToSpreadFormulaResult({ sheetId, col, row }, matrixResult) {
+        const numberOfCols = this.getters.getNumberCols(sheetId);
+        const numberOfRows = this.getters.getNumberRows(sheetId);
+        const enoughCols = col + matrixResult.length <= numberOfCols;
+        const enoughRows = row + matrixResult[0].length <= numberOfRows;
+        if (enoughCols && enoughRows) {
+            return;
+        }
+        if (enoughCols) {
+            throw new Error(_lt("Result couldn't be automatically expanded. Please insert more rows."));
+        }
+        if (enoughRows) {
+            throw new Error(_lt("Result couldn't be automatically expanded. Please insert more columns."));
+        }
+        throw new Error(_lt("Result couldn't be automatically expanded. Please insert more columns and rows."));
+    }
+    updateSpreadRelation({ sheetId, col, row, }) {
+        const arrayFormulaPositionId = this.encodePosition({ sheetId, col, row });
+        return (i, j) => {
+            const position = { sheetId, col: i + col, row: j + row };
+            const resultPositionId = this.encodePosition(position);
+            this.spreadingRelations.addRelation({ resultPositionId, arrayFormulaPositionId });
+        };
+    }
+    checkCollision({ sheetId, col, row }) {
+        const formulaPositionId = this.encodePosition({ sheetId, col, row });
+        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);
+                throw new Error(_lt("Array result was not expanded because it would overwrite data in %s.", toXC(position.col, position.row)));
+            }
+            this.blockedArrayFormulas.delete(formulaPositionId);
+        };
+    }
+    spreadValues({ sheetId, col, row }, matrixResult) {
+        const formatFromPosition = formatFromPositionAccess(matrixResult.format);
+        return (i, j) => {
+            const position = { sheetId, col: i + col, row: j + row };
+            const cell = this.getters.getCell(position);
+            const format = cell?.format;
+            const evaluatedCell = createEvaluatedCell(matrixResult.value[i][j], format || formatFromPosition(i, j));
+            const positionId = this.encodePosition(position);
+            this.setEvaluatedCell(positionId, evaluatedCell);
+            // check if formula dependencies present in the spread zone
+            // if so, they need to be recomputed
+            this.nextPositionsToUpdate.add(...this.getCellsDependingOn([positionId]));
+        };
+    }
+    invalidateSpreading(positionId) {
+        if (!this.spreadingRelations.isArrayFormula(positionId)) {
+            return;
+        }
+        for (const child of this.spreadingRelations.getArrayResultPositionIds(positionId)) {
+            const content = this.getCell(child)?.content;
+            if (content) {
+                // there's no point at re-evaluating overlapping array formulas,
+                // there's still a collision
+                continue;
+            }
+            this.evaluatedCells.delete(child);
+            this.nextPositionsToUpdate.add(...this.getCellsDependingOn([child]));
+            this.nextPositionsToUpdate.add(...this.getArrayFormulasBlockedByOrSpreadingOn(child));
+        }
+        this.spreadingRelations.removeNode(positionId);
+    }
+    // ----------------------------------------------------------
+    //                 COMMON FUNCTIONALITY
+    // ----------------------------------------------------------
+    getDirectDependencies(positionId) {
+        const cell = this.getCell(positionId);
+        if (!cell?.isFormula) {
+            return [];
+        }
+        const dependencies = [];
+        for (const range of cell.dependencies) {
+            if (range.invalidSheetName || range.invalidXc) {
+                continue;
+            }
+            const sheetId = range.sheetId;
+            forEachPositionsInZone(range.zone, (col, row) => {
+                dependencies.push(this.encodePosition({ sheetId, col, row }));
+            });
+        }
+        return dependencies;
+    }
+    getCellsDependingOn(positionIds) {
+        return this.formulaDependencies().getCellsDependingOn(positionIds);
+    }
+    getCell(positionId) {
+        return this.getters.getCell(this.decodePosition(positionId));
+    }
+    encodePosition(position) {
+        return this.positionEncoder.encode(position);
+    }
+    decodePosition(positionId) {
+        return this.positionEncoder.decode(positionId);
+    }
+}
+function forEachSpreadPositionInMatrix(matrix, callback) {
+    for (let i = 0; i < matrix.length; ++i) {
+        for (let j = 0; j < matrix[i].length; ++j) {
+            if (i === 0 && j === 0) {
+                continue;
+            }
+            callback(i, j);
+        }
+    }
+}
+function formatFromPositionAccess(format) {
+    return isMatrix(format) ? (i, j) => format[i][j] : () => format;
+}
+function assertFormulaReturnHasConsistentDimensions(formulaReturn) {
+    const { value: computedValue, format: computedFormat } = formulaReturn;
+    if (!isMatrix(computedValue)) {
+        if (isMatrix(computedFormat)) {
+            throw new Error("A format matrix should never be associated with a scalar value");
+        }
+        return;
+    }
+    if (isMatrix(computedFormat)) {
+        const sameDimensions = computedValue.length === computedFormat.length &&
+            computedValue[0].length === computedFormat[0].length;
+        if (!sameDimensions) {
+            throw new Error("Formats and values should have the same dimensions!");
+        }
+    }
+}
+/**
+ * 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);
+    }
+    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 };
+    }
+    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;
+    }
+}
+
+const functions = functionRegistry.content;
+//#region
+// ---------------------------------------------------------------------------
+// INTRODUCTION
+// ---------------------------------------------------------------------------
+// The evaluation plugin is in charge of computing the values of the cells.
+// This is a fairly complex task for several reasons:
+// Reason n°1: Cells can contain formulas that must be interpreted to know
+// the final value of the cell. And these formulas can depend on other cells.
+// ex A1:"=SUM(B1:B2)" we have to evaluate B1:B2 first to be able to evaluate A1.
+// We say here that we have a 'formula dependency' between A1 and B1:B2.
+// Reason n°2: A cell can assign value to other cells that haven't content.
+// This concerns cells containing a formula that returns an array of values.
+// ex A1:"=SPLIT('Odoo','d')" Evaluating A1 must assign the value "O" to A1 and
+// "oo" to B1. We say here that we have a 'spread relation' between A1 and B1.
+// B1 have a spread value from A1.
+// Note that a cell can contain a formula which depends on other cells which
+// themselves can:
+// - contain formulas which depends on other cells (and so on).
+// - contain a spread value from other formulas which depends on other cells
+//   (and so on).
+// I - How to build the evaluation ?
+//    If we had only formulas dependencies to treat, the evaluation would be
+//    simple: the formulas dependencies are directly deduced from the content
+//    of the formulas. With the dependencies we are able to calculate which
+//    formula must be evaluated before another.
+//    Cycles
+//    ------
+//    We can also easily detect if the cells are included in reference cycles
+//    and return an error in this case. ex: A1:"=B1" B1:"=C1" C1:"=A1"
+//    The "#CYCLE" error must be returned for
+//    all three cells.
+//    But there's more! There are formulas referring to other cells but never
+//    use them. This is the case for example
+//    with the "IF" formula. ex:
+//    A1:"=IF(D1,A2,B1)"
+//    A2:"=A1"
+//    In this case it is obvious that we have a cyclic dependency. But in practice
+//    this will only exist if D1 is true.
+//    For this reason, we believe that the evaluation should be **partly recursive**:
+//    The function computing a formula cell starts by marking them as 'being evaluated'
+//    and then call itself on the dependencies of the concerned cell. This allows
+//    to evaluate the dependencies before the cell itself and to detect
+//    if the cell that is being evaluated isn't part of a cycle.
+// II - The spread relation anticipation problem
+//    The biggest difficulty to solve with the evaluation lies in the fact that
+//    we cannot anticipate the spread relations: cells impacted by the result array
+//    of a formula are only determined after the array formula has been
+//    evaluated. In the case where the impacted cells are used in other formulas,
+//    this will require to re-evaluation other formulas (and so on...). ex:
+//    A1:"=B2"
+//    A2:"=SPLIT('Odoo','d')"
+//    in the example above, A2 spreads on B2, but we will know it only after
+//    the evaluation of A2. To be able to evaluate A1 correctly, we must therefore
+//    reevaluate A1 after the evaluation of A2.
+//    We could evaluate which formula spreads first. Except that the array formulas
+//    can themselves depend on the spreads of other formulas. ex:
+//    A1:"=SPLIT(B3,'d')"
+//    A2:="odoo odoo"
+//    A3:"=SPLIT(A2,' ')"
+//    In the example above, A3 must be evaluated before A1 because A1 needs B3 which
+//    can be modified by A3.
+//    Therefore, there would be a spatial evaluation order to be respected between
+//    the array formulas. We could imagine that, when an array formula depends
+//    on a cell, then we evaluate the first formula that spreads located in the upper
+//    left corner of this cell.
+//    Although this possibility has been explored, it remains complicated to spatially
+//    predict which formula should be evaluated before another, especially when
+//    the array formulas are located in different sheets or when the array formulas
+//    depends on the spreads of each other. ex:
+//
+//    A1:"=ARRAY_FORMULA_ALPHA(B2)"
+//    A2:"=ARRAY_FORMULA_BETA(B1)"
+//    In the example above, ARRAY_FORMULA_ALPHA and ARRAY_FORMULA_BETA are some
+//    formulas that could spread depending on the value of B2 and B1. This could be a
+//    cyclic dependency that we cannot anticipate.
+//    And as with the "IF" formula, array formulas may not use their dependency.
+//    It then becomes very difficult to manage...
+//    Also, if we have a cycle, that doesn't mean it's bad. The cycle can converge to
+//    a stable state at the scale of the sheets. Functionally, we don't want to forbid
+//    convergent cycles. It is an interesting feature but which requires to re-evaluate
+//    the cycle as many times as convergence is not reached.
+// Thus, in order to respect the relations between the cells (formula dependencies and
+// spread relations), the evaluation of the cells must:
+// - respect a precise order (cells values used by another must be evaluated first) : As
+//   we cannot anticipate which dependencies are really used by the formulas, we must
+//   evaluate the cells in a recursive way;
+// - be done as many times as necessary to ensure that all the cells have been correctly
+//   evaluated in the correct order (in case of, for example, spreading relation cycles).
+// The chosen solution is to reevaluate the formulas impacted by spreads as many times
+// as necessary in several iterations, where evaluated cells can trigger the evaluation
+// of other cells depending on it, at the next iteration.
+//#endregion
+class EvaluationPlugin extends UIPlugin {
+    static getters = [
+        "evaluateFormula",
+        "getRangeFormattedValues",
+        "getRangeValues",
+        "getRangeFormats",
+        "getEvaluatedCell",
+        "getEvaluatedCells",
+        "getEvaluatedCellsInZone",
+    ];
+    shouldRebuildDependenciesGraph = true;
+    evaluator;
+    compilationParams;
+    positionsToUpdate = [];
+    constructor(config) {
+        super(config);
+        this.evaluator = new Evaluator(config.custom, this.getters);
+        this.compilationParams = buildCompilationParameters(config.custom, this.getters, (position) => this.evaluator.getEvaluatedCell(position));
+    }
+    // ---------------------------------------------------------------------------
+    // Command Handling
+    // ---------------------------------------------------------------------------
+    beforeHandle(cmd) {
+        if (invalidateDependenciesCommands.has(cmd.type)) {
+            this.shouldRebuildDependenciesGraph = true;
+        }
+    }
+    handle(cmd) {
+        switch (cmd.type) {
+            case "UPDATE_CELL":
+                if (!("content" in cmd || "format" in cmd) || this.shouldRebuildDependenciesGraph) {
+                    return;
+                }
+                this.positionsToUpdate.push(cmd);
+                if ("content" in cmd) {
+                    this.evaluator.updateDependencies(cmd);
+                }
+                break;
+            case "EVALUATE_CELLS":
+                this.evaluator.evaluateAllCells();
+                break;
+        }
+    }
+    finalize() {
+        if (this.shouldRebuildDependenciesGraph) {
+            this.evaluator.buildDependencyGraph();
+            this.evaluator.evaluateAllCells();
+            this.shouldRebuildDependenciesGraph = false;
+        }
+        else if (this.positionsToUpdate.length) {
+            this.evaluator.evaluateCells(this.positionsToUpdate);
+        }
+        this.positionsToUpdate = [];
+    }
+    // ---------------------------------------------------------------------------
+    // Getters
+    // ---------------------------------------------------------------------------
+    evaluateFormula(formulaString, sheetId = this.getters.getActiveSheetId()) {
+        const compiledFormula = compile(formulaString);
+        const ranges = [];
+        for (let xc of compiledFormula.dependencies) {
+            ranges.push(this.getters.getRangeFromSheetXC(sheetId, xc));
+        }
+        return compiledFormula.execute(ranges, ...this.compilationParams).value;
+    }
+    /**
+     * Return the value of each cell in the range as they are displayed in the grid.
+     */
+    getRangeFormattedValues(range) {
+        const sheet = this.getters.tryGetSheet(range.sheetId);
+        if (sheet === undefined)
+            return [];
+        return this.getters
+            .getEvaluatedCellsInZone(sheet.id, range.zone)
+            .map((cell) => cell.formattedValue);
+    }
+    /**
+     * Return the value of each cell in the range.
+     */
+    getRangeValues(range) {
+        const sheet = this.getters.tryGetSheet(range.sheetId);
+        if (sheet === undefined)
+            return [];
+        return this.getters.getEvaluatedCellsInZone(sheet.id, range.zone).map((cell) => cell.value);
+    }
+    /**
+     * Return the format of each cell in the range.
+     */
+    getRangeFormats(range) {
+        const sheet = this.getters.tryGetSheet(range.sheetId);
+        if (sheet === undefined)
+            return [];
+        return this.getters.getEvaluatedCellsInZone(sheet.id, range.zone).map((cell) => cell.format);
+    }
+    getEvaluatedCell(position) {
+        return this.evaluator.getEvaluatedCell(position);
+    }
+    getEvaluatedCells(sheetId) {
+        const rawCells = this.getters.getCells(sheetId) || {};
+        const record = {};
+        for (let cellId of Object.keys(rawCells)) {
+            const position = this.getters.getCellPosition(cellId);
+            record[cellId] = this.getEvaluatedCell(position);
+        }
+        return record;
+    }
+    getEvaluatedCellsInZone(sheetId, zone) {
+        return positions(zone).map(({ col, row }) => this.getters.getEvaluatedCell({ sheetId, col, row }));
+    }
+    // ---------------------------------------------------------------------------
+    // Export
+    // ---------------------------------------------------------------------------
+    exportForExcel(data) {
+        for (const position of this.evaluator.getEvaluatedPositions()) {
+            const evaluatedCell = this.evaluator.getEvaluatedCell(position);
+            const xc = toXC(position.col, position.row);
+            const value = evaluatedCell.value;
+            let isFormula = false;
+            let newContent = undefined;
+            let newFormat = undefined;
+            let isExported = true;
+            const formulaCell = this.getCorrespondingFormulaCell(position);
+            if (formulaCell) {
+                isExported = formulaCell.compiledFormula.tokens
+                    .filter((tk) => tk.type === "FUNCTION")
+                    .every((tk) => functions[tk.value.toUpperCase()].isExported);
+                isFormula = isExported;
+                if (!isExported) {
+                    newContent = value.toString();
+                    newFormat = evaluatedCell.format;
+                }
+            }
+            const exportedSheetData = data.sheets.find((sheet) => sheet.id === position.sheetId);
+            const exportedCellData = exportedSheetData.cells[xc] || {};
+            const format = newFormat
+                ? getItemId(newFormat, data.formats)
+                : exportedCellData.format;
+            const content = !isExported ? newContent : exportedCellData.content;
+            exportedSheetData.cells[xc] = { ...exportedCellData, value, isFormula, content, format };
+        }
+    }
+    /**
+     * Returns the corresponding formula cell of a given cell
+     * It could be the formula present in the cell itself or the
+     * formula of the array formula that spreads to the cell
+     */
+    getCorrespondingFormulaCell(position) {
+        const cell = this.getters.getCell(position);
+        if (cell && cell.content) {
+            if (cell.isFormula && !isBadExpression(cell.content)) {
+                return cell;
+            }
+            return undefined;
+        }
+        const spreadingFormulaPosition = this.evaluator.getArrayFormulaSpreadingOn(position);
+        if (spreadingFormulaPosition === undefined) {
+            return undefined;
+        }
+        const spreadingFormulaCell = this.getters.getCell(spreadingFormulaPosition);
+        if (spreadingFormulaCell?.isFormula) {
+            return spreadingFormulaCell;
+        }
+        return undefined;
+    }
+}
+function isBadExpression(formula) {
+    try {
+        compile(formula);
+        return false;
+    }
+    catch (error) {
+        return true;
+    }
+}
+
 /**
  * https://tomekdev.com/posts/sorting-colors-in-js
  */
@@ -33252,329 +34210,6 @@ class CustomColorsPlugin extends UIPlugin {
     }
 }
 
-const functionMap = functionRegistry.mapping;
-class EvaluationPlugin extends UIPlugin {
-    static getters = [
-        "evaluateFormula",
-        "getRangeFormattedValues",
-        "getRangeValues",
-        "getRangeFormats",
-        "getEvaluatedCell",
-        "getEvaluatedCells",
-        "getColEvaluatedCells",
-        "getEvaluatedCellsInZone",
-    ];
-    isUpToDate = false;
-    evaluatedCells = {};
-    evalContext;
-    lazyEvaluation;
-    constructor(config) {
-        super(config);
-        this.evalContext = config.custom;
-        this.lazyEvaluation = config.lazyEvaluation;
-    }
-    // ---------------------------------------------------------------------------
-    // Command Handling
-    // ---------------------------------------------------------------------------
-    handle(cmd) {
-        if (invalidateEvaluationCommands.has(cmd.type)) {
-            this.isUpToDate = false;
-        }
-        switch (cmd.type) {
-            case "UPDATE_CELL":
-                if ("content" in cmd || "format" in cmd) {
-                    this.isUpToDate = false;
-                }
-                break;
-            case "EVALUATE_CELLS":
-                this.evaluate();
-                break;
-        }
-    }
-    finalize() {
-        if (!this.isUpToDate) {
-            this.evaluate();
-            this.isUpToDate = true;
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Getters
-    // ---------------------------------------------------------------------------
-    evaluateFormula(formulaString, sheetId = this.getters.getActiveSheetId()) {
-        const compiledFormula = compile(formulaString);
-        const params = this.getCompilationParameters((cell) => this.getEvaluatedCell(this.getters.getCellPosition(cell.id)));
-        const ranges = [];
-        for (let xc of compiledFormula.dependencies) {
-            ranges.push(this.getters.getRangeFromSheetXC(sheetId, xc));
-        }
-        return compiledFormula.execute(ranges, ...params).value;
-    }
-    /**
-     * Return the value of each cell in the range as they are displayed in the grid.
-     */
-    getRangeFormattedValues(range) {
-        const sheet = this.getters.tryGetSheet(range.sheetId);
-        if (sheet === undefined)
-            return [];
-        return this.getters
-            .getEvaluatedCellsInZone(sheet.id, range.zone)
-            .map((cell) => cell.formattedValue);
-    }
-    /**
-     * Return the value of each cell in the range.
-     */
-    getRangeValues(range) {
-        const sheet = this.getters.tryGetSheet(range.sheetId);
-        if (sheet === undefined)
-            return [];
-        return this.getters.getEvaluatedCellsInZone(sheet.id, range.zone).map((cell) => cell.value);
-    }
-    /**
-     * Return the format of each cell in the range.
-     */
-    getRangeFormats(range) {
-        const sheet = this.getters.tryGetSheet(range.sheetId);
-        if (sheet === undefined)
-            return [];
-        return this.getters.getEvaluatedCellsInZone(sheet.id, range.zone).map((cell) => cell.format);
-    }
-    getEvaluatedCell({ sheetId, col, row }) {
-        const cell = this.getters.getCell({ sheetId, col, row });
-        if (cell === undefined) {
-            return createEvaluatedCell("");
-        }
-        // the cell might have been created by a command in the current
-        // dispatch but the evaluation is not done yet.
-        return this.evaluatedCells[sheetId]?.[col]?.[row]?.() || createEvaluatedCell("");
-    }
-    getEvaluatedCells(sheetId) {
-        const rawCells = this.getters.getCells(sheetId) || {};
-        const record = {};
-        for (let cellId of Object.keys(rawCells)) {
-            const position = this.getters.getCellPosition(cellId);
-            record[cellId] = this.getEvaluatedCell(position);
-        }
-        return record;
-    }
-    /**
-     * Returns all the evaluated cells of a col
-     */
-    getColEvaluatedCells(sheetId, col) {
-        return Object.values(this.evaluatedCells[sheetId]?.[col] || [])
-            .filter(isDefined$1)
-            .map((lazyCell) => lazyCell());
-    }
-    getEvaluatedCellsInZone(sheetId, zone) {
-        return positions(zone).map(({ col, row }) => this.getters.getEvaluatedCell({ sheetId, col, row }));
-    }
-    // ---------------------------------------------------------------------------
-    // Evaluator
-    // ---------------------------------------------------------------------------
-    setEvaluatedCell(cellId, evaluatedCell) {
-        const { col, row, sheetId } = this.getters.getCellPosition(cellId);
-        if (!this.evaluatedCells[sheetId]) {
-            this.evaluatedCells[sheetId] = {};
-        }
-        if (!this.evaluatedCells[sheetId][col]) {
-            this.evaluatedCells[sheetId][col] = {};
-        }
-        this.evaluatedCells[sheetId][col][row] = evaluatedCell;
-        if (!this.lazyEvaluation) {
-            this.evaluatedCells[sheetId][col][row]();
-        }
-    }
-    *getAllCells() {
-        // use a generator function to avoid re-building a new object
-        for (const sheetId of this.getters.getSheetIds()) {
-            const cells = this.getters.getCells(sheetId);
-            for (const cellId in cells) {
-                yield cells[cellId];
-            }
-        }
-    }
-    evaluate() {
-        this.evaluatedCells = {};
-        const cellsBeingComputed = new Set();
-        const computeCell = (cell) => {
-            const cellId = cell.id;
-            const { col, row, sheetId } = this.getters.getCellPosition(cellId);
-            const lazyEvaluation = this.evaluatedCells[sheetId]?.[col]?.[row];
-            if (lazyEvaluation) {
-                return lazyEvaluation; // already computed
-            }
-            return lazy(() => {
-                try {
-                    switch (cell.isFormula) {
-                        case true:
-                            return computeFormulaCell(cell);
-                        case false:
-                            return evaluateLiteral(cell.content, cell.format);
-                    }
-                }
-                catch (e) {
-                    return handleError(e, cell);
-                }
-            });
-        };
-        const handleError = (e, cell) => {
-            if (!(e instanceof Error)) {
-                e = new Error(e);
-            }
-            const msg = e?.errorType || CellErrorType.GenericError;
-            // apply function name
-            const __lastFnCalled = compilationParameters[2].__lastFnCalled || "";
-            const error = new EvaluationError(msg, e.message.replace("[[FUNCTION_NAME]]", __lastFnCalled), e.logLevel !== undefined ? e.logLevel : CellErrorLevel.error);
-            return errorCell(cell.content, error);
-        };
-        const computeFormulaCell = (cellData) => {
-            const cellId = cellData.id;
-            if (cellsBeingComputed.has(cellId)) {
-                throw new CircularDependencyError();
-            }
-            compilationParameters[2].__originCellXC = () => {
-                // compute the value lazily for performance reasons
-                const position = compilationParameters[2].getters.getCellPosition(cellId);
-                return toXC(position.col, position.row);
-            };
-            cellsBeingComputed.add(cellId);
-            const computedCell = cellData.compiledFormula.execute(cellData.dependencies, ...compilationParameters);
-            cellsBeingComputed.delete(cellId);
-            if (Array.isArray(computedCell.value)) {
-                // if a value returns an array (like =A1:A3)
-                throw new Error(_lt("This formula depends on invalid values"));
-            }
-            return createEvaluatedCell(computedCell.value, cellData.format || computedCell.format);
-        };
-        const compilationParameters = this.getCompilationParameters((cell) => computeCell(cell)());
-        for (const cell of this.getAllCells()) {
-            this.setEvaluatedCell(cell.id, computeCell(cell));
-        }
-    }
-    /**
-     * Return all functions necessary to properly evaluate a formula:
-     * - a refFn function to read any reference, cell or range of a normalized formula
-     * - a range function to convert any reference to a proper value array
-     * - an evaluation context
-     */
-    getCompilationParameters(computeCell) {
-        const evalContext = Object.assign(Object.create(functionMap), this.evalContext, {
-            getters: this.getters,
-        });
-        const getters = this.getters;
-        function readCell(range) {
-            let cell;
-            if (!getters.tryGetSheet(range.sheetId)) {
-                throw new Error(_lt("Invalid sheet name"));
-            }
-            cell = getters.getCell({ sheetId: range.sheetId, col: range.zone.left, row: range.zone.top });
-            if (!cell || cell.content === "") {
-                // magic "empty" value
-                // Returning {value: null} instead of undefined will ensure that we don't
-                // fall back on the default value of the argument provided to the formula's compute function
-                return { value: null, format: cell?.format };
-            }
-            return getEvaluatedCell(cell);
-        }
-        const getEvaluatedCell = (cell) => {
-            const evaluatedCell = computeCell(cell);
-            if (evaluatedCell.type === CellValueType.error) {
-                throw evaluatedCell.error;
-            }
-            return evaluatedCell;
-        };
-        /**
-         * Return the values of the cell(s) used in reference, but always in the format of a range even
-         * if a single cell is referenced. It is a list of col values. This is useful for the formulas that describe parameters as
-         * range<number> etc.
-         *
-         * Note that each col is possibly sparse: it only contain the values of cells
-         * that are actually present in the grid.
-         */
-        function range(range) {
-            const sheetId = range.sheetId;
-            if (!isZoneValid(range.zone)) {
-                throw new InvalidReferenceError();
-            }
-            // Performance issue: Avoid fetching data on positions that are out of the spreadsheet
-            // e.g. A1:ZZZ9999 in a sheet with 10 cols and 10 rows should ignore everything past J10 and return a 10x10 array
-            const sheetZone = getters.getSheetZone(sheetId);
-            const result = [];
-            const zone = intersection(range.zone, sheetZone);
-            if (!zone) {
-                result.push([]);
-                return result;
-            }
-            // Performance issue: nested loop is faster than a map here
-            for (let col = zone.left; col <= zone.right; col++) {
-                const rowValues = [];
-                for (let row = zone.top; row <= zone.bottom; row++) {
-                    const cell = evalContext.getters.getCell({ sheetId: range.sheetId, col, row });
-                    rowValues.push(cell ? getEvaluatedCell(cell) : undefined);
-                }
-                result.push(rowValues);
-            }
-            return result;
-        }
-        /**
-         * Returns the value of the cell(s) used in reference
-         *
-         * @param range the references used
-         * @param isMeta if a reference is supposed to be used in a `meta` parameter as described in the
-         *        function for which this parameter is used, we just return the string of the parameter.
-         *        The `compute` of the formula's function must process it completely
-         */
-        function refFn(range, isMeta, functionName, paramNumber) {
-            if (isMeta) {
-                // Use zoneToXc of zone instead of getRangeString to avoid sending unbounded ranges
-                return { value: zoneToXc(range.zone) };
-            }
-            if (!isZoneValid(range.zone)) {
-                throw new InvalidReferenceError();
-            }
-            // if the formula definition could have accepted a range, we would pass through the _range function and not here
-            if (range.zone.bottom !== range.zone.top || range.zone.left !== range.zone.right) {
-                throw new Error(paramNumber
-                    ? _lt("Function %s expects the parameter %s to be a single value or a single cell reference, not a range.", functionName.toString(), paramNumber.toString())
-                    : _lt("Function %s expects its parameters to be single values or single cell references, not ranges.", functionName.toString()));
-            }
-            if (range.invalidSheetName) {
-                throw new Error(_lt("Invalid sheet name: %s", range.invalidSheetName));
-            }
-            return readCell(range);
-        }
-        return [refFn, range, evalContext];
-    }
-    // ---------------------------------------------------------------------------
-    // Export
-    // ---------------------------------------------------------------------------
-    exportForExcel(data) {
-        for (let sheet of data.sheets) {
-            for (const xc in sheet.cells) {
-                const position = { sheetId: sheet.id, ...toCartesian(xc) };
-                const cell = this.getters.getCell(position);
-                if (cell) {
-                    const exportedCellData = sheet.cells[xc];
-                    const evaluatedCell = this.getEvaluatedCell(position);
-                    exportedCellData.value = evaluatedCell.value;
-                    exportedCellData.isFormula = cell.isFormula && !this.isBadExpression(cell.content);
-                    if (cell.format !== evaluatedCell.format) {
-                        exportedCellData.computedFormat = evaluatedCell.format;
-                    }
-                }
-            }
-        }
-    }
-    isBadExpression(formula) {
-        try {
-            compile(formula);
-            return false;
-        }
-        catch (error) {
-            return true;
-        }
-    }
-}
-
 class EvaluationChartPlugin extends UIPlugin {
     static getters = ["getChartRuntime", "getBackgroundOfSingleCellChart"];
     charts = {};
@@ -45793,44 +46428,30 @@ function numberRef(reference) {
 
 function addFormula(cell) {
     const formula = cell.content;
-    const functions = functionRegistry.content;
-    const tokens = tokenize(formula);
     const attrs = [];
     let node = escapeXml ``;
-    const isExported = tokens
-        .filter((tk) => tk.type === "FUNCTION")
-        .every((tk) => functions[tk.value.toUpperCase()].isExported);
-    if (isExported) {
-        let cycle = escapeXml ``;
-        const XlsxFormula = adaptFormulaToExcel(formula);
-        // hack for cycles : if we don't set a value (be it 0 or #VALUE!), it will appear as invisible on excel,
-        // Making it very hard for the client to find where the recursion is.
-        if (cell.value === CellErrorType.CircularDependency) {
-            attrs.push(["t", "str"]);
-            cycle = escapeXml /*xml*/ `<v>${cell.value}</v>`;
-        }
-        node = escapeXml /*xml*/ `
+    let cycle = escapeXml ``;
+    const XlsxFormula = adaptFormulaToExcel(formula);
+    // hack for cycles : if we don't set a value (be it 0 or #VALUE!), it will appear as invisible on excel,
+    // Making it very hard for the client to find where the recursion is.
+    if (cell.value === CellErrorType.CircularDependency) {
+        attrs.push(["t", "str"]);
+        cycle = escapeXml /*xml*/ `<v>${cell.value}</v>`;
+    }
+    node = escapeXml /*xml*/ `
       <f>
         ${XlsxFormula}
       </f>
       ${cycle}
     `;
-        return { attrs, node };
-    }
-    else {
-        // Shouldn't we always output the value then ?
-        const value = cell.value;
-        const type = getCellType(value);
-        attrs.push(["t", type]);
-        node = escapeXml /*xml*/ `<v>${value}</v>`;
-        return { attrs, node };
-    }
+    return { attrs, node };
 }
 function addContent(content, sharedStrings, forceString = false) {
     let value = content;
     const attrs = [];
-    if (!forceString && ["TRUE", "FALSE"].includes(value.trim())) {
-        value = value === "TRUE" ? "1" : "0";
+    const clearValue = value.trim().toUpperCase();
+    if (!forceString && ["TRUE", "FALSE"].includes(clearValue)) {
+        value = clearValue === "TRUE" ? "1" : "0";
         attrs.push(["t", "b"]);
     }
     else if (forceString || !isNumber(value)) {
@@ -47221,7 +47842,6 @@ class Model extends EventBus {
             moveClient: () => { },
             snapshotRequested: false,
             notifyUI: (payload) => this.trigger("notify-ui", payload),
-            lazyEvaluation: "lazyEvaluation" in config ? config.lazyEvaluation : true,
         };
     }
     setupCorePluginConfig() {
@@ -47244,7 +47864,6 @@ class Model extends EventBus {
             moveClient: this.session.move.bind(this.session),
             custom: this.config.custom,
             uiActions: this.config,
-            lazyEvaluation: this.config.lazyEvaluation,
             session: this.session,
         };
     }
@@ -47583,6 +48202,6 @@ exports.setTranslationMethod = setTranslationMethod;
 exports.tokenize = tokenize;
 
 
-__info__.version = '16.3.1';
-__info__.date = '2023-05-25T13:00:27.320Z';
-__info__.hash = 'b3cfd2c';
+__info__.version = '16.4.0-alpha.1';
+__info__.date = '2023-05-25T13:00:14.133Z';
+__info__.hash = '564c094';