@odoo/o-spreadsheet 17.0.70 → 17.0.71

package/dist/o-spreadsheet.cjs.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.0.70
- * @date 2025-07-28T13:26:37.626Z
- * @hash 2ec8d82
+ * @version 17.0.71
+ * @date 2025-08-21T06:37:34.192Z
+ * @hash 1592964
  */
 
 'use strict';
@@ -30695,6 +30695,897 @@ const NON_RETROCOMPATIBLE_FUNCTIONS = [
 ];
 const CONTENT_TYPES_FILE = "[Content_Types].xml";
 
+class FunctionCodeBuilder {
+    scope;
+    code = "";
+    constructor(scope = new Scope()) {
+        this.scope = scope;
+    }
+    append(...lines) {
+        this.code += lines.map((line) => line.toString()).join("\n") + "\n";
+    }
+    return(expression) {
+        return new FunctionCodeImpl(this.scope, this.code, expression);
+    }
+    toString() {
+        return indentCode(this.code);
+    }
+}
+class FunctionCodeImpl {
+    scope;
+    returnExpression;
+    code;
+    constructor(scope, code, returnExpression) {
+        this.scope = scope;
+        this.returnExpression = returnExpression;
+        this.code = indentCode(code);
+    }
+    toString() {
+        return this.code;
+    }
+    wrapInClosure() {
+        const closureName = this.scope.nextVariableName();
+        const code = new FunctionCodeBuilder(this.scope);
+        code.append(`const ${closureName} = () => {`);
+        code.append(this.code);
+        code.append(`return ${this.returnExpression};`);
+        code.append(`}`);
+        return code.return(closureName);
+    }
+    assignResultToVariable() {
+        if (this.scope.isAlreadyDeclared(this.returnExpression)) {
+            return this;
+        }
+        const variableName = this.scope.nextVariableName();
+        const code = new FunctionCodeBuilder(this.scope);
+        code.append(this.code);
+        code.append(`const ${variableName} = ${this.returnExpression};`);
+        return code.return(variableName);
+    }
+}
+class Scope {
+    nextId = 1;
+    declaredVariables = new Set();
+    nextVariableName() {
+        const name = `_${this.nextId++}`;
+        this.declaredVariables.add(name);
+        return name;
+    }
+    isAlreadyDeclared(name) {
+        return this.declaredVariables.has(name);
+    }
+}
+/**
+ * Takes a list of strings that might be single or multiline
+ * and maps them in a list of single line strings.
+ */
+function splitLines(str) {
+    return str
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line !== "");
+}
+function indentCode(code) {
+    let result = "";
+    let indentLevel = 0;
+    const lines = splitLines(code);
+    for (const line of lines) {
+        if (line.startsWith("}")) {
+            indentLevel--;
+        }
+        result += "\t".repeat(indentLevel) + line + "\n";
+        if (line.endsWith("{")) {
+            indentLevel++;
+        }
+    }
+    return result.trim();
+}
+
+var State;
+(function (State) {
+    /**
+     * Initial state.
+     * Expecting any reference for the left part of a range
+     * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
+     */
+    State[State["LeftRef"] = 0] = "LeftRef";
+    /**
+     * Expecting any reference for the right part of a range
+     * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
+     */
+    State[State["RightRef"] = 1] = "RightRef";
+    /**
+     * Expecting the separator without any constraint on the right part
+     */
+    State[State["Separator"] = 2] = "Separator";
+    /**
+     * Expecting the separator for a full column range
+     */
+    State[State["FullColumnSeparator"] = 3] = "FullColumnSeparator";
+    /**
+     * Expecting the separator for a full row range
+     */
+    State[State["FullRowSeparator"] = 4] = "FullRowSeparator";
+    /**
+     * Expecting the right part of a full column range
+     * e.g. "1", "A1"
+     */
+    State[State["RightColumnRef"] = 5] = "RightColumnRef";
+    /**
+     * Expecting the right part of a full row range
+     * e.g. "A", "A1"
+     */
+    State[State["RightRowRef"] = 6] = "RightRowRef";
+    /**
+     * Final state. A range has been matched
+     */
+    State[State["Found"] = 7] = "Found";
+})(State || (State = {}));
+const goTo = (state, guard = () => true) => [
+    {
+        goTo: state,
+        guard,
+    },
+];
+const goToMulti = (state, guard = () => true) => ({
+    goTo: state,
+    guard,
+});
+const machine = {
+    [State.LeftRef]: {
+        REFERENCE: goTo(State.Separator),
+        NUMBER: goTo(State.FullRowSeparator),
+        SYMBOL: [
+            goToMulti(State.FullColumnSeparator, (token) => isColReference(token.value)),
+            goToMulti(State.FullRowSeparator, (token) => isRowReference(token.value)),
+        ],
+    },
+    [State.FullColumnSeparator]: {
+        SPACE: goTo(State.FullColumnSeparator),
+        OPERATOR: goTo(State.RightColumnRef, (token) => token.value === ":"),
+    },
+    [State.FullRowSeparator]: {
+        SPACE: goTo(State.FullRowSeparator),
+        OPERATOR: goTo(State.RightRowRef, (token) => token.value === ":"),
+    },
+    [State.Separator]: {
+        SPACE: goTo(State.Separator),
+        OPERATOR: goTo(State.RightRef, (token) => token.value === ":"),
+    },
+    [State.RightRef]: {
+        SPACE: goTo(State.RightRef),
+        NUMBER: goTo(State.Found),
+        REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+        SYMBOL: goTo(State.Found, (token) => isColHeader(token.value) || isRowHeader(token.value)),
+    },
+    [State.RightColumnRef]: {
+        SPACE: goTo(State.RightColumnRef),
+        SYMBOL: goTo(State.Found, (token) => isColHeader(token.value)),
+        REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+    },
+    [State.RightRowRef]: {
+        SPACE: goTo(State.RightRowRef),
+        NUMBER: goTo(State.Found),
+        REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
+        SYMBOL: goTo(State.Found, (token) => isRowHeader(token.value)),
+    },
+    [State.Found]: {},
+};
+/**
+ * Check if the list of tokens starts with a sequence of tokens representing
+ * a range.
+ * If a range is found, the sequence is removed from the list and is returned
+ * as a single token.
+ */
+function matchReference(tokens) {
+    let head = 0;
+    let transitions = machine[State.LeftRef];
+    let matchedTokens = "";
+    while (transitions !== undefined) {
+        const token = tokens[head++];
+        if (!token) {
+            return null;
+        }
+        const transition = transitions[token.type]?.find((transition) => transition.guard(token));
+        const nextState = transition ? transition.goTo : undefined;
+        switch (nextState) {
+            case undefined:
+                return null;
+            case State.Found:
+                matchedTokens += token.value;
+                tokens.splice(0, head);
+                return {
+                    type: "REFERENCE",
+                    value: matchedTokens,
+                };
+            default:
+                transitions = machine[nextState];
+                matchedTokens += token.value;
+                break;
+        }
+    }
+    return null;
+}
+/**
+ * Take the result of the tokenizer and transform it to be usable in the
+ * manipulations of range
+ *
+ * @param formula
+ */
+function rangeTokenize(formula, locale = DEFAULT_LOCALE) {
+    const tokens = tokenize(formula, locale);
+    const result = [];
+    while (tokens.length) {
+        result.push(matchReference(tokens) || tokens.shift());
+    }
+    return result;
+}
+
+const functionRegex = /[a-zA-Z0-9\_]+(\.[a-zA-Z0-9\_]+)*/;
+const UNARY_OPERATORS_PREFIX = ["-", "+"];
+const UNARY_OPERATORS_POSTFIX = ["%"];
+const ASSOCIATIVE_OPERATORS = ["*", "+", "&"];
+const OP_PRIORITY = {
+    "^": 30,
+    "%": 30,
+    "*": 20,
+    "/": 20,
+    "+": 15,
+    "-": 15,
+    "&": 13,
+    ">": 10,
+    "<>": 10,
+    ">=": 10,
+    "<": 10,
+    "<=": 10,
+    "=": 10,
+};
+/**
+ * Parse the next operand in an arithmetic expression.
+ * e.g.
+ *  for 1+2*3, the next operand is 1
+ *  for (1+2)*3, the next operand is (1+2)
+ *  for SUM(1,2)+3, the next operand is SUM(1,2)
+ */
+function parseOperand(tokens) {
+    const current = tokens.shift();
+    if (!current) {
+        throw new BadExpressionError(DEFAULT_ERROR_MESSAGE);
+    }
+    switch (current.type) {
+        case "DEBUGGER":
+            const next = parseExpression(tokens, 1000);
+            next.debug = true;
+            return next;
+        case "NUMBER":
+            return { type: "NUMBER", value: parseNumber(current.value, DEFAULT_LOCALE) };
+        case "STRING":
+            return { type: "STRING", value: removeStringQuotes(current.value) };
+        case "INVALID_REFERENCE":
+            return {
+                type: "REFERENCE",
+                value: CellErrorType.InvalidReference,
+            };
+        case "REFERENCE":
+            if (tokens[0]?.value === ":" && tokens[1]?.type === "REFERENCE") {
+                tokens.shift();
+                const rightReference = tokens.shift();
+                return {
+                    type: "REFERENCE",
+                    value: `${current.value}:${rightReference?.value}`,
+                };
+            }
+            return {
+                type: "REFERENCE",
+                value: current.value,
+            };
+        case "SYMBOL":
+            const value = current.value;
+            const nextToken = tokens[0];
+            if (nextToken?.type === "LEFT_PAREN" && functionRegex.test(current.value)) {
+                const args = parseFunctionArgs(tokens);
+                return { type: "FUNCALL", value: value, args };
+            }
+            const upperCaseValue = value.toUpperCase();
+            if (upperCaseValue === "TRUE" || upperCaseValue === "FALSE") {
+                return { type: "BOOLEAN", value: upperCaseValue === "TRUE" };
+            }
+            throw new BadExpressionError(_t("Invalid formula"));
+        case "LEFT_PAREN":
+            const result = parseExpression(tokens);
+            consumeOrThrow(tokens, "RIGHT_PAREN", _t("Missing closing parenthesis"));
+            return result;
+        case "OPERATOR":
+            const operator = current.value;
+            if (UNARY_OPERATORS_PREFIX.includes(operator)) {
+                return {
+                    type: "UNARY_OPERATION",
+                    value: operator,
+                    operand: parseExpression(tokens, OP_PRIORITY[operator]),
+                };
+            }
+            throw new BadExpressionError(_t("Unexpected token: %s", current.value));
+        default:
+            throw new BadExpressionError(_t("Unexpected token: %s", current.value));
+    }
+}
+function parseFunctionArgs(tokens) {
+    consumeOrThrow(tokens, "LEFT_PAREN", _t("Missing opening parenthesis"));
+    const nextToken = tokens[0];
+    if (nextToken?.type === "RIGHT_PAREN") {
+        consumeOrThrow(tokens, "RIGHT_PAREN");
+        return [];
+    }
+    const args = [];
+    args.push(parseOneFunctionArg(tokens));
+    while (tokens[0]?.type !== "RIGHT_PAREN") {
+        consumeOrThrow(tokens, "ARG_SEPARATOR", _t("Wrong function call"));
+        args.push(parseOneFunctionArg(tokens));
+    }
+    consumeOrThrow(tokens, "RIGHT_PAREN");
+    return args;
+}
+function parseOneFunctionArg(tokens) {
+    const nextToken = tokens[0];
+    if (nextToken?.type === "ARG_SEPARATOR" || nextToken?.type === "RIGHT_PAREN") {
+        // arg is empty: "sum(1,,2)" "sum(,1)" "sum(1,)"
+        return { type: "EMPTY", value: "" };
+    }
+    return parseExpression(tokens);
+}
+function consumeOrThrow(tokens, type, message = DEFAULT_ERROR_MESSAGE) {
+    const token = tokens.shift();
+    if (!token || token.type !== type) {
+        throw new BadExpressionError(message);
+    }
+}
+function parseExpression(tokens, parent_priority = 0) {
+    if (tokens.length === 0) {
+        throw new BadExpressionError(DEFAULT_ERROR_MESSAGE);
+    }
+    let left = parseOperand(tokens);
+    // as long as we have operators with higher priority than the parent one,
+    // continue parsing the expression because it is a child sub-expression
+    while (tokens[0]?.type === "OPERATOR" && OP_PRIORITY[tokens[0].value] > parent_priority) {
+        const operator = tokens.shift().value;
+        if (UNARY_OPERATORS_POSTFIX.includes(operator)) {
+            left = {
+                type: "UNARY_OPERATION",
+                value: operator,
+                operand: left,
+                postfix: true,
+            };
+        }
+        else {
+            const right = parseExpression(tokens, OP_PRIORITY[operator]);
+            left = {
+                type: "BIN_OPERATION",
+                value: operator,
+                left,
+                right,
+            };
+        }
+    }
+    return left;
+}
+/**
+ * Parse an expression (as a string) into an AST.
+ */
+function parse(str) {
+    return parseTokens(rangeTokenize(str));
+}
+function parseTokens(tokens) {
+    tokens = tokens.filter((x) => x.type !== "SPACE");
+    if (tokens[0]?.value === "=") {
+        tokens.splice(0, 1);
+    }
+    const result = parseExpression(tokens);
+    if (tokens.length) {
+        throw new BadExpressionError(DEFAULT_ERROR_MESSAGE);
+    }
+    return result;
+}
+/**
+ * Allows to visit all nodes of an AST and apply a mapping function
+ * to nodes of a specific type.
+ * Useful if you want to convert some part of a formula.
+ *
+ * @example
+ * convertAstNodes(ast, "FUNCALL", convertFormulaToExcel)
+ *
+ * function convertFormulaToExcel(ast: ASTFuncall) {
+ *   // ...
+ *   return modifiedAst
+ * }
+ */
+function convertAstNodes(ast, type, fn) {
+    return mapAst(ast, (ast) => {
+        if (ast.type === type) {
+            return fn(ast);
+        }
+        return ast;
+    });
+}
+function iterateAstNodes(ast) {
+    return Array.from(astIterator(ast));
+}
+function* astIterator(ast) {
+    yield ast;
+    switch (ast.type) {
+        case "FUNCALL":
+            for (const arg of ast.args) {
+                yield* astIterator(arg);
+            }
+            break;
+        case "UNARY_OPERATION":
+            yield* astIterator(ast.operand);
+            break;
+        case "BIN_OPERATION":
+            yield* astIterator(ast.left);
+            yield* astIterator(ast.right);
+            break;
+    }
+}
+function mapAst(ast, fn) {
+    ast = fn(ast);
+    switch (ast.type) {
+        case "FUNCALL":
+            return {
+                ...ast,
+                args: ast.args.map((child) => mapAst(child, fn)),
+            };
+        case "UNARY_OPERATION":
+            return {
+                ...ast,
+                operand: mapAst(ast.operand, fn),
+            };
+        case "BIN_OPERATION":
+            return {
+                ...ast,
+                right: mapAst(ast.right, fn),
+                left: mapAst(ast.left, fn),
+            };
+        default:
+            return ast;
+    }
+}
+/**
+ * Converts an ast formula to the corresponding string
+ */
+function astToFormula(ast) {
+    switch (ast.type) {
+        case "FUNCALL":
+            const args = ast.args.map((arg) => astToFormula(arg));
+            return `${ast.value}(${args.join(",")})`;
+        case "NUMBER":
+            return ast.value.toString();
+        case "REFERENCE":
+            return ast.value;
+        case "STRING":
+            return `"${ast.value}"`;
+        case "BOOLEAN":
+            return ast.value ? "TRUE" : "FALSE";
+        case "UNARY_OPERATION":
+            return ast.postfix
+                ? leftOperandToFormula(ast) + ast.value
+                : ast.value + rightOperandToFormula(ast);
+        case "BIN_OPERATION":
+            return leftOperandToFormula(ast) + ast.value + rightOperandToFormula(ast);
+        default:
+            return ast.value;
+    }
+}
+/**
+ * Convert the left operand of a binary operation to the corresponding string
+ * and enclose the result inside parenthesis if necessary.
+ */
+function leftOperandToFormula(operationAST) {
+    const mainOperator = operationAST.value;
+    const leftOperation = "left" in operationAST ? operationAST.left : operationAST.operand;
+    const leftOperator = leftOperation.value;
+    const needParenthesis = leftOperation.type === "BIN_OPERATION" && OP_PRIORITY[leftOperator] < OP_PRIORITY[mainOperator];
+    return needParenthesis ? `(${astToFormula(leftOperation)})` : astToFormula(leftOperation);
+}
+/**
+ * Convert the right operand of a binary or unary operation to the corresponding string
+ * and enclose the result inside parenthesis if necessary.
+ */
+function rightOperandToFormula(operationAST) {
+    const mainOperator = operationAST.value;
+    const rightOperation = "right" in operationAST ? operationAST.right : operationAST.operand;
+    const rightPriority = OP_PRIORITY[rightOperation.value];
+    const mainPriority = OP_PRIORITY[mainOperator];
+    let needParenthesis = false;
+    if (rightOperation.type !== "BIN_OPERATION") {
+        needParenthesis = false;
+    }
+    else if (rightPriority < mainPriority) {
+        needParenthesis = true;
+    }
+    else if (rightPriority === mainPriority && !ASSOCIATIVE_OPERATORS.includes(mainOperator)) {
+        needParenthesis = true;
+    }
+    return needParenthesis ? `(${astToFormula(rightOperation)})` : astToFormula(rightOperation);
+}
+
+const functions$1 = functionRegistry.content;
+const OPERATOR_MAP = {
+    "=": "EQ",
+    "+": "ADD",
+    "-": "MINUS",
+    "*": "MULTIPLY",
+    "/": "DIVIDE",
+    ">=": "GTE",
+    "<>": "NE",
+    ">": "GT",
+    "<=": "LTE",
+    "<": "LT",
+    "^": "POWER",
+    "&": "CONCATENATE",
+};
+const UNARY_OPERATOR_MAP = {
+    "-": "UMINUS",
+    "+": "UPLUS",
+    "%": "UNARY.PERCENT",
+};
+// this cache contains all compiled function code, grouped by "structure". For
+// example, "=2*sum(A1:A4)" and "=2*sum(B1:B4)" are compiled into the same
+// structural function.
+// It is only exported for testing purposes
+const functionCache = {};
+// -----------------------------------------------------------------------------
+// COMPILER
+// -----------------------------------------------------------------------------
+function compile(formula) {
+    const tokens = rangeTokenize(formula);
+    return compileTokens(tokens);
+}
+function compileTokens(tokens) {
+    const { dependencies, constantValues } = formulaArguments(tokens);
+    const cacheKey = compilationCacheKey(tokens, dependencies, constantValues);
+    if (!functionCache[cacheKey]) {
+        const ast = parseTokens([...tokens]);
+        const scope = new Scope();
+        if (ast.type === "BIN_OPERATION" && ast.value === ":") {
+            throw new BadExpressionError(_t("Invalid formula"));
+        }
+        if (ast.type === "EMPTY") {
+            throw new BadExpressionError(_t("Invalid formula"));
+        }
+        const compiledAST = compileAST(ast);
+        const code = new FunctionCodeBuilder();
+        code.append(`// ${cacheKey}`);
+        code.append(compiledAST);
+        code.append(`return ${compiledAST.returnExpression};`);
+        let baseFunction = new Function("deps", // the dependencies in the current formula
+        "ref", // a function to access a certain dependency at a given index
+        "range", // same as above, but guarantee that the result is in the form of a range
+        "ctx", code.toString());
+        functionCache[cacheKey] = {
+            // @ts-ignore
+            execute: baseFunction,
+        };
+        /**
+         * This function compile the function arguments. It is mostly straightforward,
+         * except that there is a non trivial transformation in one situation:
+         *
+         * If a function argument is asking for a range, and get a cell, we transform
+         * the cell value into a range. This allow the grid model to differentiate
+         * between a cell value and a non cell value.
+         */
+        function compileFunctionArgs(ast) {
+            const { args } = ast;
+            const functionName = ast.value.toUpperCase();
+            const functionDefinition = functions$1[functionName];
+            if (!functionDefinition) {
+                throw new UnknownFunctionError(ast.value);
+            }
+            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(_t("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,
+                    paramIndex: i + 1,
+                });
+                compiledArgs.push(isLazy ? compiledAST.wrapInClosure() : compiledAST);
+            }
+            return compiledArgs;
+        }
+        /**
+         * This function compiles all the information extracted by the parser into an
+         * executable code for the evaluation of the cells content. It uses a cash to
+         * not reevaluate identical code structures.
+         *
+         * The function is sensitive to parameter “isMeta”. This
+         * parameter may vary when compiling function arguments:
+         * isMeta: In some cases the function arguments expects information on the
+         * cell/range other than the associated value(s). For example the COLUMN
+         * function needs to receive as argument the coordinates of a cell rather
+         * than its value. For this we have meta arguments.
+         */
+        function compileAST(ast, isMeta = false, hasRange = false, referenceVerification = {}) {
+            const code = new FunctionCodeBuilder(scope);
+            if (ast.type !== "REFERENCE" && !(ast.type === "BIN_OPERATION" && ast.value === ":")) {
+                if (isMeta) {
+                    throw new BadExpressionError(_t("Argument must be a reference to a cell or range."));
+                }
+            }
+            if (ast.debug) {
+                code.append("debugger;");
+            }
+            switch (ast.type) {
+                case "BOOLEAN":
+                    return code.return(`{ value: ${ast.value} }`);
+                case "NUMBER":
+                    return code.return(`{ value: this.constantValues.numbers[${constantValues.numbers.indexOf(ast.value)}] }`);
+                case "STRING":
+                    return code.return(`{ value: this.constantValues.strings[${constantValues.strings.indexOf(ast.value)}] }`);
+                case "REFERENCE":
+                    const referenceIndex = dependencies.indexOf(ast.value);
+                    if (hasRange) {
+                        return code.return(`range(deps[${referenceIndex}])`);
+                    }
+                    else {
+                        return code.return(`ref(deps[${referenceIndex}], ${isMeta ? "true" : "false"}, "${referenceVerification.functionName || OPERATOR_MAP["="]}",  ${referenceVerification.paramIndex})`);
+                    }
+                case "FUNCALL":
+                    const args = compileFunctionArgs(ast).map((arg) => arg.assignResultToVariable());
+                    code.append(...args);
+                    const fnName = ast.value.toUpperCase();
+                    code.append(`ctx.__lastFnCalled = '${fnName}';`);
+                    return code.return(`ctx['${fnName}'](${args.map((arg) => arg.returnExpression)})`);
+                case "UNARY_OPERATION": {
+                    const fnName = UNARY_OPERATOR_MAP[ast.value];
+                    const operand = compileAST(ast.operand, false, false, {
+                        functionName: fnName,
+                    }).assignResultToVariable();
+                    code.append(operand);
+                    code.append(`ctx.__lastFnCalled = '${fnName}';`);
+                    return code.return(`ctx['${fnName}'](${operand.returnExpression})`);
+                }
+                case "BIN_OPERATION": {
+                    const fnName = OPERATOR_MAP[ast.value];
+                    const left = compileAST(ast.left, false, false, {
+                        functionName: fnName,
+                    }).assignResultToVariable();
+                    const right = compileAST(ast.right, false, false, {
+                        functionName: fnName,
+                    }).assignResultToVariable();
+                    code.append(left);
+                    code.append(right);
+                    code.append(`ctx.__lastFnCalled = '${fnName}';`);
+                    return code.return(`ctx['${fnName}'](${left.returnExpression}, ${right.returnExpression})`);
+                }
+                case "EMPTY":
+                    return code.return("undefined");
+            }
+        }
+    }
+    const compiledFormula = {
+        execute: functionCache[cacheKey].execute,
+        dependencies,
+        constantValues,
+        tokens,
+    };
+    return compiledFormula;
+}
+/**
+ * Compute a cache key for the formula.
+ * References, numbers and strings are replaced with placeholders because
+ * the compiled formula does not depend on their actual value.
+ * Both `=A1+1+"2"` and `=A2+2+"3"` are compiled to the exact same function.
+ *
+ * Spaces are also ignored to compute the cache key.
+ *
+ * A formula `=A1+A2+SUM(2, 2, "2")` have the cache key `=|0|+|1|+SUM(|N0|,|N0|,|S0|)`
+ */
+function compilationCacheKey(tokens, dependencies, constantValues) {
+    return concat(tokens.map((token) => {
+        switch (token.type) {
+            case "STRING":
+                const value = removeStringQuotes(token.value);
+                return `|S${constantValues.strings.indexOf(value)}|`;
+            case "NUMBER":
+                return `|N${constantValues.numbers.indexOf(parseNumber(token.value, DEFAULT_LOCALE))}|`;
+            case "REFERENCE":
+            case "INVALID_REFERENCE":
+                return `|${dependencies.indexOf(token.value)}|`;
+            case "SPACE":
+                return "";
+            default:
+                return token.value;
+        }
+    }));
+}
+/**
+ * Return formula arguments which are references, strings and numbers.
+ */
+function formulaArguments(tokens) {
+    const constantValues = {
+        numbers: [],
+        strings: [],
+    };
+    const dependencies = [];
+    for (const token of tokens) {
+        switch (token.type) {
+            case "INVALID_REFERENCE":
+            case "REFERENCE":
+                dependencies.push(token.value);
+                break;
+            case "STRING":
+                const value = removeStringQuotes(token.value);
+                if (!constantValues.strings.includes(value)) {
+                    constantValues.strings.push(value);
+                }
+                break;
+            case "NUMBER": {
+                const value = parseNumber(token.value, DEFAULT_LOCALE);
+                if (!constantValues.numbers.includes(value)) {
+                    constantValues.numbers.push(value);
+                }
+                break;
+            }
+        }
+    }
+    return {
+        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(_t("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(_t("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(_t("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;
+}
+
+/**
+ * Add the following information on tokens:
+ * - length
+ * - start
+ * - end
+ */
+function enrichTokens(tokens) {
+    let current = 0;
+    return tokens.map((x) => {
+        const len = x.value.toString().length;
+        const token = Object.assign({}, x, {
+            start: current,
+            end: current + len,
+            length: len,
+        });
+        current = token.end;
+        return token;
+    });
+}
+/**
+ * add on each token the length, start and end
+ * also matches the opening to its closing parenthesis (using the same number)
+ */
+function mapParenthesis(tokens) {
+    let maxParen = 1;
+    const stack = [];
+    return tokens.map((token) => {
+        if (token.type === "LEFT_PAREN") {
+            stack.push(maxParen);
+            token.parenIndex = maxParen;
+            maxParen++;
+        }
+        else if (token.type === "RIGHT_PAREN") {
+            token.parenIndex = stack.pop();
+        }
+        return token;
+    });
+}
+/**
+ * add on each token its parent function and the index corresponding to
+ * its position as an argument of the function.
+ * In this example "=MIN(42,SUM(MAX(1,2),3))":
+ * - the parent function of the token correspond to number 42 is the MIN function
+ * - the argument position of the token correspond to number 42 is 0
+ * - the parent function of the token correspond to number 3 is the SUM function
+ * - the argument position of the token correspond to number 3 is 1
+ */
+function mapParentFunction(tokens) {
+    let stack = [];
+    let functionStarted = "";
+    const res = tokens.map((token, i) => {
+        if (!["SPACE", "LEFT_PAREN"].includes(token.type)) {
+            functionStarted = "";
+        }
+        switch (token.type) {
+            case "SYMBOL":
+                functionStarted = token.value;
+                break;
+            case "LEFT_PAREN":
+                stack.push({ parent: functionStarted, argPosition: 0 });
+                functionStarted = "";
+                break;
+            case "RIGHT_PAREN":
+                stack.pop();
+                break;
+            case "ARG_SEPARATOR":
+                if (stack.length) {
+                    // increment position on current function
+                    stack[stack.length - 1].argPosition++;
+                }
+                break;
+        }
+        if (stack.length) {
+            const functionContext = stack[stack.length - 1];
+            if (functionContext.parent) {
+                token.functionContext = Object.assign({}, functionContext);
+            }
+        }
+        return token;
+    });
+    return res;
+}
+/**
+ * Take the result of the tokenizer and transform it to be usable in the composer.
+ *
+ * @param formula
+ */
+function composerTokenize(formula, locale) {
+    const tokens = rangeTokenize(formula, locale);
+    return mapParentFunction(mapParenthesis(enrichTokens(tokens)));
+}
+
+const functions = functionRegistry.content;
+function isExportableToExcel(tokens) {
+    try {
+        const nonExportableFunctions = iterateAstNodes(parseTokens(tokens)).filter((ast) => ast.type === "FUNCALL" && !functions[ast.value.toUpperCase()]?.isExported);
+        return nonExportableFunctions.length === 0;
+    }
+    catch (error) {
+        return false;
+    }
+}
+
 /**
  * Map of the different types of conversions warnings and their name in error messages
  */
@@ -31443,9 +32334,9 @@ function convertConditionalFormats(xlsxCfs, dxfs, warningManager) {
                 if (!rule.operator || !rule.formula || rule.formula.length === 0)
                     continue;
                 operator = convertCFCellIsOperator(rule.operator);
-                values.push(rule.formula[0]);
+                values.push(prefixFormula(rule.formula[0]));
                 if (rule.formula.length === 2) {
-                    values.push(rule.formula[1]);
+                    values.push(prefixFormula(rule.formula[1]));
                 }
                 break;
         }
@@ -31588,6 +32479,11 @@ function convertIcons(xlsxIconSet, index) {
             ? ICON_SETS[iconSet].neutral
             : ICON_SETS[iconSet].good;
 }
+/** Prefix the string by "=" if the string looks like a formula */
+function prefixFormula(formula) {
+    const tokens = tokenize(formula);
+    return tokens.length === 1 && tokens[0].type !== "REFERENCE" ? formula : "=" + formula;
+}
 // ---------------------------------------------------------------------------
 // Warnings
 // ---------------------------------------------------------------------------
@@ -33925,171 +34821,31 @@ class XlsxReader {
             externalLinks: getXLSXFilesOfType(CONTENT_TYPES.externalLink, this.xmls),
             images: this.images,
         };
-        if (!xlsxFileStructure.workbook.rels) {
-            throw Error(_t("Cannot find workbook relations file"));
-        }
-        return xlsxFileStructure;
-    }
-    // ---------------------------------------------------------------------------
-    // Conversion
-    // ---------------------------------------------------------------------------
-    convertImportedData(data) {
-        const convertedData = {
-            version: EXCEL_IMPORT_VERSION,
-            sheets: convertSheets(data, this.warningManager),
-            styles: convertStyles(data, this.warningManager),
-            formats: convertFormats(data, this.warningManager),
-            borders: convertBorders(data, this.warningManager),
-            entities: {},
-            revisionId: DEFAULT_REVISION_ID,
-        };
-        convertTables(convertedData, data);
-        // Remove falsy attributes in styles. Not mandatory, but make objects more readable when debugging
-        Object.keys(data.styles).map((key) => {
-            data.styles[key] = removeFalsyAttributes(data.styles[key]);
-        });
-        return convertedData;
-    }
-}
-
-var State;
-(function (State) {
-    /**
-     * Initial state.
-     * Expecting any reference for the left part of a range
-     * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
-     */
-    State[State["LeftRef"] = 0] = "LeftRef";
-    /**
-     * Expecting any reference for the right part of a range
-     * e.g. "A1", "1", "A", "Sheet1!A1", "Sheet1!A"
-     */
-    State[State["RightRef"] = 1] = "RightRef";
-    /**
-     * Expecting the separator without any constraint on the right part
-     */
-    State[State["Separator"] = 2] = "Separator";
-    /**
-     * Expecting the separator for a full column range
-     */
-    State[State["FullColumnSeparator"] = 3] = "FullColumnSeparator";
-    /**
-     * Expecting the separator for a full row range
-     */
-    State[State["FullRowSeparator"] = 4] = "FullRowSeparator";
-    /**
-     * Expecting the right part of a full column range
-     * e.g. "1", "A1"
-     */
-    State[State["RightColumnRef"] = 5] = "RightColumnRef";
-    /**
-     * Expecting the right part of a full row range
-     * e.g. "A", "A1"
-     */
-    State[State["RightRowRef"] = 6] = "RightRowRef";
-    /**
-     * Final state. A range has been matched
-     */
-    State[State["Found"] = 7] = "Found";
-})(State || (State = {}));
-const goTo = (state, guard = () => true) => [
-    {
-        goTo: state,
-        guard,
-    },
-];
-const goToMulti = (state, guard = () => true) => ({
-    goTo: state,
-    guard,
-});
-const machine = {
-    [State.LeftRef]: {
-        REFERENCE: goTo(State.Separator),
-        NUMBER: goTo(State.FullRowSeparator),
-        SYMBOL: [
-            goToMulti(State.FullColumnSeparator, (token) => isColReference(token.value)),
-            goToMulti(State.FullRowSeparator, (token) => isRowReference(token.value)),
-        ],
-    },
-    [State.FullColumnSeparator]: {
-        SPACE: goTo(State.FullColumnSeparator),
-        OPERATOR: goTo(State.RightColumnRef, (token) => token.value === ":"),
-    },
-    [State.FullRowSeparator]: {
-        SPACE: goTo(State.FullRowSeparator),
-        OPERATOR: goTo(State.RightRowRef, (token) => token.value === ":"),
-    },
-    [State.Separator]: {
-        SPACE: goTo(State.Separator),
-        OPERATOR: goTo(State.RightRef, (token) => token.value === ":"),
-    },
-    [State.RightRef]: {
-        SPACE: goTo(State.RightRef),
-        NUMBER: goTo(State.Found),
-        REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-        SYMBOL: goTo(State.Found, (token) => isColHeader(token.value) || isRowHeader(token.value)),
-    },
-    [State.RightColumnRef]: {
-        SPACE: goTo(State.RightColumnRef),
-        SYMBOL: goTo(State.Found, (token) => isColHeader(token.value)),
-        REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-    },
-    [State.RightRowRef]: {
-        SPACE: goTo(State.RightRowRef),
-        NUMBER: goTo(State.Found),
-        REFERENCE: goTo(State.Found, (token) => isSingleCellReference(token.value)),
-        SYMBOL: goTo(State.Found, (token) => isRowHeader(token.value)),
-    },
-    [State.Found]: {},
-};
-/**
- * Check if the list of tokens starts with a sequence of tokens representing
- * a range.
- * If a range is found, the sequence is removed from the list and is returned
- * as a single token.
- */
-function matchReference(tokens) {
-    let head = 0;
-    let transitions = machine[State.LeftRef];
-    let matchedTokens = "";
-    while (transitions !== undefined) {
-        const token = tokens[head++];
-        if (!token) {
-            return null;
-        }
-        const transition = transitions[token.type]?.find((transition) => transition.guard(token));
-        const nextState = transition ? transition.goTo : undefined;
-        switch (nextState) {
-            case undefined:
-                return null;
-            case State.Found:
-                matchedTokens += token.value;
-                tokens.splice(0, head);
-                return {
-                    type: "REFERENCE",
-                    value: matchedTokens,
-                };
-            default:
-                transitions = machine[nextState];
-                matchedTokens += token.value;
-                break;
-        }
-    }
-    return null;
-}
-/**
- * Take the result of the tokenizer and transform it to be usable in the
- * manipulations of range
- *
- * @param formula
- */
-function rangeTokenize(formula, locale = DEFAULT_LOCALE) {
-    const tokens = tokenize(formula, locale);
-    const result = [];
-    while (tokens.length) {
-        result.push(matchReference(tokens) || tokens.shift());
+        if (!xlsxFileStructure.workbook.rels) {
+            throw Error(_t("Cannot find workbook relations file"));
+        }
+        return xlsxFileStructure;
+    }
+    // ---------------------------------------------------------------------------
+    // Conversion
+    // ---------------------------------------------------------------------------
+    convertImportedData(data) {
+        const convertedData = {
+            version: EXCEL_IMPORT_VERSION,
+            sheets: convertSheets(data, this.warningManager),
+            styles: convertStyles(data, this.warningManager),
+            formats: convertFormats(data, this.warningManager),
+            borders: convertBorders(data, this.warningManager),
+            entities: {},
+            revisionId: DEFAULT_REVISION_ID,
+        };
+        convertTables(convertedData, data);
+        // Remove falsy attributes in styles. Not mandatory, but make objects more readable when debugging
+        Object.keys(data.styles).map((key) => {
+            data.styles[key] = removeFalsyAttributes(data.styles[key]);
+        });
+        return convertedData;
     }
-    return result;
 }
 
 /**
@@ -34955,1183 +35711,432 @@ class BordersPlugin extends CorePlugin {
         else {
             this.shiftBordersHorizontally(cmd.sheetId, cmd.base + 1, cmd.quantity, {
                 moveFirstLeftBorder: false,
-            });
-            colLeftOfInsertion = cmd.base;
-            colRightOfInsertion = cmd.base + cmd.quantity + 1;
-        }
-        this.ensureColumnBorderContinuity(cmd.sheetId, colLeftOfInsertion, colRightOfInsertion);
-    }
-    /**
-     * Move borders according to the inserted rows.
-     * Ensure borders continuity.
-     */
-    handleAddRows(cmd) {
-        // The new rows have already been inserted at this point.
-        let rowAboveInsertion;
-        let rowBelowInsertion;
-        if (cmd.position === "before") {
-            this.shiftBordersVertically(cmd.sheetId, cmd.base, cmd.quantity, {
-                moveFirstTopBorder: true,
-            });
-            rowAboveInsertion = cmd.base - 1;
-            rowBelowInsertion = cmd.base + cmd.quantity;
-        }
-        else {
-            this.shiftBordersVertically(cmd.sheetId, cmd.base + 1, cmd.quantity, {
-                moveFirstTopBorder: false,
-            });
-            rowAboveInsertion = cmd.base;
-            rowBelowInsertion = cmd.base + cmd.quantity + 1;
-        }
-        this.ensureRowBorderContinuity(cmd.sheetId, rowAboveInsertion, rowBelowInsertion);
-    }
-    // ---------------------------------------------------------------------------
-    // Getters
-    // ---------------------------------------------------------------------------
-    getCellBorder({ sheetId, col, row }) {
-        const border = {
-            top: this.borders[sheetId]?.[col]?.[row]?.horizontal,
-            bottom: this.borders[sheetId]?.[col]?.[row + 1]?.horizontal,
-            left: this.borders[sheetId]?.[col]?.[row]?.vertical,
-            right: this.borders[sheetId]?.[col + 1]?.[row]?.vertical,
-        };
-        if (!border.bottom && !border.left && !border.right && !border.top) {
-            return null;
-        }
-        return border;
-    }
-    getBordersColors(sheetId) {
-        const colors = [];
-        const sheetBorders = this.borders[sheetId];
-        if (sheetBorders) {
-            for (const borders of sheetBorders.filter(isDefined$1)) {
-                for (const cellBorder of borders) {
-                    if (cellBorder?.horizontal) {
-                        colors.push(cellBorder.horizontal.color);
-                    }
-                    if (cellBorder?.vertical) {
-                        colors.push(cellBorder.vertical.color);
-                    }
-                }
-            }
-        }
-        return colors;
-    }
-    // ---------------------------------------------------------------------------
-    // Private
-    // ---------------------------------------------------------------------------
-    /**
-     * Ensure border continuity between two columns.
-     * If the two columns have the same borders (at each row respectively),
-     * the same borders are applied to each cell in between.
-     */
-    ensureColumnBorderContinuity(sheetId, leftColumn, rightColumn) {
-        const targetCols = range(leftColumn + 1, rightColumn);
-        for (let row = 0; row < this.getters.getNumberRows(sheetId); row++) {
-            const leftBorder = this.getCellBorder({ sheetId, col: leftColumn, row });
-            const rightBorder = this.getCellBorder({ sheetId, col: rightColumn, row });
-            if (leftBorder && rightBorder) {
-                const commonSides = this.getCommonSides(leftBorder, rightBorder);
-                for (let col of targetCols) {
-                    this.addBorder(sheetId, col, row, commonSides);
-                }
-            }
-        }
-    }
-    /**
-     * Ensure border continuity between two rows.
-     * If the two rows have the same borders (at each column respectively),
-     * the same borders are applied to each cell in between.
-     */
-    ensureRowBorderContinuity(sheetId, topRow, bottomRow) {
-        const targetRows = range(topRow + 1, bottomRow);
-        for (let col = 0; col < this.getters.getNumberCols(sheetId); col++) {
-            const aboveBorder = this.getCellBorder({ sheetId, col, row: topRow });
-            const belowBorder = this.getCellBorder({ sheetId, col, row: bottomRow });
-            if (aboveBorder && belowBorder) {
-                const commonSides = this.getCommonSides(aboveBorder, belowBorder);
-                for (let row of targetRows) {
-                    this.addBorder(sheetId, col, row, commonSides);
-                }
-            }
-        }
-    }
-    /**
-     * From two borders, return a new border with sides defined in both borders.
-     * i.e. the intersection of two borders.
-     */
-    getCommonSides(border1, border2) {
-        const commonBorder = {};
-        for (let side of ["top", "bottom", "left", "right"]) {
-            if (border1[side] && deepEquals(border1[side], border2[side])) {
-                commonBorder[side] = border1[side];
-            }
-        }
-        return commonBorder;
-    }
-    /**
-     * Get all the columns which contains at least a border
-     */
-    getColumnsWithBorders(sheetId) {
-        const sheetBorders = this.borders[sheetId];
-        if (!sheetBorders)
-            return [];
-        return Object.keys(sheetBorders).map((index) => parseInt(index, 10));
-    }
-    /**
-     * Get all the rows which contains at least a border
-     */
-    getRowsWithBorders(sheetId) {
-        const sheetBorders = this.borders[sheetId]?.filter(isDefined$1);
-        if (!sheetBorders)
-            return [];
-        const rowsWithBorders = new Set();
-        for (const rowBorders of sheetBorders) {
-            for (const rowBorder in rowBorders) {
-                rowsWithBorders.add(parseInt(rowBorder, 10));
-            }
-        }
-        return Array.from(rowsWithBorders);
-    }
-    /**
-     * Get the range of all the rows in the sheet
-     */
-    getRowsRange(sheetId) {
-        const sheetBorders = this.borders[sheetId];
-        if (!sheetBorders)
-            return [];
-        return range(0, this.getters.getNumberRows(sheetId) + 1);
-    }
-    /**
-     * Move borders of a sheet horizontally.
-     * @param sheetId
-     * @param start starting column (included)
-     * @param delta how much borders will be moved (negative if moved to the left)
-     */
-    shiftBordersHorizontally(sheetId, start, delta, { moveFirstLeftBorder } = {}) {
-        const borders = this.borders[sheetId];
-        if (!borders)
-            return;
-        if (delta < 0) {
-            this.moveBordersOfColumn(sheetId, start, delta, "vertical", {
-                destructive: false,
-            });
-        }
-        this.getColumnsWithBorders(sheetId)
-            .filter((col) => col >= start)
-            .sort((a, b) => (delta < 0 ? a - b : b - a)) // start by the end when moving up
-            .forEach((col) => {
-            if ((col === start && moveFirstLeftBorder) || col !== start) {
-                this.moveBordersOfColumn(sheetId, col, delta, "vertical");
-            }
-            this.moveBordersOfColumn(sheetId, col, delta, "horizontal");
-        });
-    }
-    /**
-     * Move borders of a sheet vertically.
-     * @param sheetId
-     * @param start starting row (included)
-     * @param delta how much borders will be moved (negative if moved to the above)
-     */
-    shiftBordersVertically(sheetId, start, delta, { moveFirstTopBorder } = {}) {
-        const borders = this.borders[sheetId];
-        if (!borders)
-            return;
-        if (delta < 0) {
-            this.moveBordersOfRow(sheetId, start, delta, "horizontal", {
-                destructive: false,
-            });
-        }
-        this.getRowsWithBorders(sheetId)
-            .filter((row) => row >= start)
-            .sort((a, b) => (delta < 0 ? a - b : b - a)) // start by the end when moving up
-            .forEach((row) => {
-            if ((row === start && moveFirstTopBorder) || row !== start) {
-                this.moveBordersOfRow(sheetId, row, delta, "horizontal");
-            }
-            this.moveBordersOfRow(sheetId, row, delta, "vertical");
-        });
-    }
-    /**
-     * Moves the borders (left if `vertical` or top if `horizontal` depending on
-     * `borderDirection`) of all cells in an entire row `delta` rows to the right
-     * (`delta` > 0) or to the left (`delta` < 0).
-     * Note that as the left of a cell is the right of the cell-1, if the left is
-     * moved the right is also moved. However, if `horizontal`, the bottom border
-     * is not moved.
-     * It does it by replacing the target border by the moved border. If the
-     * argument `destructive` is given false, the target border is preserved if
-     * the moved border is empty
-     */
-    moveBordersOfRow(sheetId, row, delta, borderDirection, { destructive } = { destructive: true }) {
-        const borders = this.borders[sheetId];
-        if (!borders)
-            return;
-        this.getColumnsWithBorders(sheetId).forEach((col) => {
-            const targetBorder = borders[col]?.[row + delta]?.[borderDirection];
-            const movedBorder = borders[col]?.[row]?.[borderDirection];
-            this.history.update("borders", sheetId, col, row + delta, borderDirection, destructive ? movedBorder : movedBorder || targetBorder);
-            this.history.update("borders", sheetId, col, row, borderDirection, undefined);
-        });
-    }
-    /**
-     * Moves the borders (left if `vertical` or top if `horizontal` depending on
-     * `borderDirection`) of all cells in an entire column `delta` columns below
-     * (`delta` > 0) or above (`delta` < 0).
-     * Note that as the top of a cell is the bottom of the cell-1, if the top is
-     * moved the bottom is also moved. However, if `vertical`, the right border
-     * is not moved.
-     * It does it by replacing the target border by the moved border. If the
-     * argument `destructive` is given false, the target border is preserved if
-     * the moved border is empty
-     */
-    moveBordersOfColumn(sheetId, col, delta, borderDirection, { destructive } = { destructive: true }) {
-        const borders = this.borders[sheetId];
-        if (!borders)
-            return;
-        this.getRowsRange(sheetId).forEach((row) => {
-            const targetBorder = borders[col + delta]?.[row]?.[borderDirection];
-            const movedBorder = borders[col]?.[row]?.[borderDirection];
-            this.history.update("borders", sheetId, col + delta, row, borderDirection, destructive ? movedBorder : movedBorder || targetBorder);
-            this.history.update("borders", sheetId, col, row, borderDirection, undefined);
-        });
-    }
-    /**
-     * Set the borders of a cell.
-     * It overrides the current border if override === true.
-     */
-    setBorder(sheetId, col, row, border, override = true) {
-        if (override || !this.borders?.[sheetId]?.[col]?.[row]?.vertical) {
-            this.history.update("borders", sheetId, col, row, "vertical", border?.left);
-        }
-        if (override || !this.borders?.[sheetId]?.[col]?.[row]?.horizontal) {
-            this.history.update("borders", sheetId, col, row, "horizontal", border?.top);
-        }
-        if (override || !this.borders?.[sheetId]?.[col + 1]?.[row]?.vertical) {
-            this.history.update("borders", sheetId, col + 1, row, "vertical", border?.right);
-        }
-        if (override || !this.borders?.[sheetId]?.[col]?.[row + 1]?.horizontal) {
-            this.history.update("borders", sheetId, col, row + 1, "horizontal", border?.bottom);
-        }
-    }
-    /**
-     * Remove the borders of a zone
-     */
-    clearBorders(sheetId, zones) {
-        for (let zone of zones) {
-            for (let row = zone.top; row <= zone.bottom; row++) {
-                this.history.update("borders", sheetId, zone.right + 1, row, "vertical", undefined);
-                for (let col = zone.left; col <= zone.right; col++) {
-                    this.history.update("borders", sheetId, col, row, undefined);
-                }
-            }
-            for (let col = zone.left; col <= zone.right; col++) {
-                this.history.update("borders", sheetId, col, zone.bottom + 1, "horizontal", undefined);
-            }
-        }
-    }
-    /**
-     * Remove the borders inside of a zone
-     */
-    clearInsideBorders(sheetId, zones) {
-        for (let zone of zones) {
-            for (let row = zone.top; row <= zone.bottom; row++) {
-                for (let col = zone.left; col <= zone.right; col++) {
-                    this.history.update("borders", sheetId, col, row, undefined);
-                }
-            }
-        }
-    }
-    /**
-     * Add a border to the existing one to a cell
-     */
-    addBorder(sheetId, col, row, border) {
-        this.setBorder(sheetId, col, row, {
-            ...this.getCellBorder({ sheetId, col, row }),
-            ...border,
-        });
-    }
-    /**
-     * Set the borders of a zone by computing the borders to add from the given
-     * command
-     */
-    setBorders(sheetId, zones, position, border) {
-        if (position === "clear") {
-            return this.clearBorders(sheetId, zones);
-        }
-        for (let zone of zones) {
-            if (position === "h" || position === "hv" || position === "all") {
-                for (let row = zone.top + 1; row <= zone.bottom; row++) {
-                    for (let col = zone.left; col <= zone.right; col++) {
-                        this.addBorder(sheetId, col, row, { top: border });
-                    }
-                }
-            }
-            if (position === "v" || position === "hv" || position === "all") {
-                for (let row = zone.top; row <= zone.bottom; row++) {
-                    for (let col = zone.left + 1; col <= zone.right; col++) {
-                        this.addBorder(sheetId, col, row, { left: border });
-                    }
-                }
-            }
-            if (position === "left" || position === "all" || position === "external") {
-                for (let row = zone.top; row <= zone.bottom; row++) {
-                    this.addBorder(sheetId, zone.left, row, { left: border });
-                }
-            }
-            if (position === "right" || position === "all" || position === "external") {
-                for (let row = zone.top; row <= zone.bottom; row++) {
-                    this.addBorder(sheetId, zone.right + 1, row, { left: border });
-                }
-            }
-            if (position === "top" || position === "all" || position === "external") {
-                for (let col = zone.left; col <= zone.right; col++) {
-                    this.addBorder(sheetId, col, zone.top, { top: border });
-                }
-            }
-            if (position === "bottom" || position === "all" || position === "external") {
-                for (let col = zone.left; col <= zone.right; col++) {
-                    this.addBorder(sheetId, col, zone.bottom + 1, { top: border });
-                }
-            }
-        }
-    }
-    /**
-     * Compute the borders to add to the given zone merged.
-     */
-    addBordersToMerge(sheetId, zone) {
-        const { left, right, top, bottom } = zone;
-        const bordersTopLeft = this.getCellBorder({ sheetId, col: left, row: top });
-        const bordersBottomRight = this.getCellBorder({ sheetId, col: right, row: bottom });
-        this.clearBorders(sheetId, [zone]);
-        if (bordersTopLeft?.top) {
-            this.setBorders(sheetId, [{ ...zone, bottom: top }], "top", bordersTopLeft.top);
-        }
-        if (bordersTopLeft?.left) {
-            this.setBorders(sheetId, [{ ...zone, right: left }], "left", bordersTopLeft.left);
-        }
-        if (bordersBottomRight?.bottom) {
-            this.setBorders(sheetId, [{ ...zone, top: bottom }], "bottom", bordersBottomRight.bottom);
-        }
-        else if (bordersTopLeft?.bottom) {
-            this.setBorders(sheetId, [{ ...zone, top: bottom }], "bottom", bordersTopLeft.bottom);
-        }
-        if (bordersBottomRight?.right) {
-            this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersBottomRight.right);
-        }
-        else if (bordersTopLeft?.right) {
-            this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersTopLeft.right);
-        }
-    }
-    checkBordersUnchanged(cmd) {
-        const currentBorder = this.getCellBorder(cmd);
-        const areAllNewBordersUndefined = !cmd.border?.bottom && !cmd.border?.left && !cmd.border?.right && !cmd.border?.top;
-        if ((!currentBorder && areAllNewBordersUndefined) || deepEquals(currentBorder, cmd.border)) {
-            return "NoChanges" /* CommandResult.NoChanges */;
-        }
-        return "Success" /* CommandResult.Success */;
-    }
-    // ---------------------------------------------------------------------------
-    // Import/Export
-    // ---------------------------------------------------------------------------
-    import(data) {
-        // Borders
-        if (Object.keys(data.borders || {}).length) {
-            for (let sheet of data.sheets) {
-                for (const xc in sheet.cells) {
-                    const cell = sheet.cells[xc];
-                    if (cell?.border) {
-                        const border = data.borders[cell.border];
-                        const { col, row } = toCartesian(xc);
-                        this.setBorder(sheet.id, col, row, border, false);
-                    }
-                }
-            }
-        }
-        // Merges
-        for (let sheetData of data.sheets) {
-            if (sheetData.merges) {
-                for (let merge of sheetData.merges) {
-                    this.addBordersToMerge(sheetData.id, toZone(merge));
-                }
-            }
-        }
-    }
-    export(data) {
-        const borders = {};
-        for (let sheet of data.sheets) {
-            for (let col = 0; col < sheet.colNumber; col++) {
-                for (let row = 0; row < sheet.rowNumber; row++) {
-                    const border = this.getCellBorder({ sheetId: sheet.id, col, row });
-                    if (border) {
-                        const xc = toXC(col, row);
-                        const cell = sheet.cells[xc];
-                        const borderId = getItemId(border, borders);
-                        if (cell) {
-                            cell.border = borderId;
-                        }
-                        else {
-                            sheet.cells[xc] = { border: borderId };
-                        }
-                    }
-                }
-            }
-        }
-        data.borders = borders;
-    }
-    exportForExcel(data) {
-        this.export(data);
-    }
-}
-
-class FunctionCodeBuilder {
-    scope;
-    code = "";
-    constructor(scope = new Scope()) {
-        this.scope = scope;
-    }
-    append(...lines) {
-        this.code += lines.map((line) => line.toString()).join("\n") + "\n";
-    }
-    return(expression) {
-        return new FunctionCodeImpl(this.scope, this.code, expression);
-    }
-    toString() {
-        return indentCode(this.code);
-    }
-}
-class FunctionCodeImpl {
-    scope;
-    returnExpression;
-    code;
-    constructor(scope, code, returnExpression) {
-        this.scope = scope;
-        this.returnExpression = returnExpression;
-        this.code = indentCode(code);
-    }
-    toString() {
-        return this.code;
-    }
-    wrapInClosure() {
-        const closureName = this.scope.nextVariableName();
-        const code = new FunctionCodeBuilder(this.scope);
-        code.append(`const ${closureName} = () => {`);
-        code.append(this.code);
-        code.append(`return ${this.returnExpression};`);
-        code.append(`}`);
-        return code.return(closureName);
-    }
-    assignResultToVariable() {
-        if (this.scope.isAlreadyDeclared(this.returnExpression)) {
-            return this;
-        }
-        const variableName = this.scope.nextVariableName();
-        const code = new FunctionCodeBuilder(this.scope);
-        code.append(this.code);
-        code.append(`const ${variableName} = ${this.returnExpression};`);
-        return code.return(variableName);
-    }
-}
-class Scope {
-    nextId = 1;
-    declaredVariables = new Set();
-    nextVariableName() {
-        const name = `_${this.nextId++}`;
-        this.declaredVariables.add(name);
-        return name;
-    }
-    isAlreadyDeclared(name) {
-        return this.declaredVariables.has(name);
+            });
+            colLeftOfInsertion = cmd.base;
+            colRightOfInsertion = cmd.base + cmd.quantity + 1;
+        }
+        this.ensureColumnBorderContinuity(cmd.sheetId, colLeftOfInsertion, colRightOfInsertion);
     }
-}
-/**
- * Takes a list of strings that might be single or multiline
- * and maps them in a list of single line strings.
- */
-function splitLines(str) {
-    return str
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line !== "");
-}
-function indentCode(code) {
-    let result = "";
-    let indentLevel = 0;
-    const lines = splitLines(code);
-    for (const line of lines) {
-        if (line.startsWith("}")) {
-            indentLevel--;
+    /**
+     * Move borders according to the inserted rows.
+     * Ensure borders continuity.
+     */
+    handleAddRows(cmd) {
+        // The new rows have already been inserted at this point.
+        let rowAboveInsertion;
+        let rowBelowInsertion;
+        if (cmd.position === "before") {
+            this.shiftBordersVertically(cmd.sheetId, cmd.base, cmd.quantity, {
+                moveFirstTopBorder: true,
+            });
+            rowAboveInsertion = cmd.base - 1;
+            rowBelowInsertion = cmd.base + cmd.quantity;
         }
-        result += "\t".repeat(indentLevel) + line + "\n";
-        if (line.endsWith("{")) {
-            indentLevel++;
+        else {
+            this.shiftBordersVertically(cmd.sheetId, cmd.base + 1, cmd.quantity, {
+                moveFirstTopBorder: false,
+            });
+            rowAboveInsertion = cmd.base;
+            rowBelowInsertion = cmd.base + cmd.quantity + 1;
         }
+        this.ensureRowBorderContinuity(cmd.sheetId, rowAboveInsertion, rowBelowInsertion);
     }
-    return result.trim();
-}
-
-const functionRegex = /[a-zA-Z0-9\_]+(\.[a-zA-Z0-9\_]+)*/;
-const UNARY_OPERATORS_PREFIX = ["-", "+"];
-const UNARY_OPERATORS_POSTFIX = ["%"];
-const ASSOCIATIVE_OPERATORS = ["*", "+", "&"];
-const OP_PRIORITY = {
-    "^": 30,
-    "%": 30,
-    "*": 20,
-    "/": 20,
-    "+": 15,
-    "-": 15,
-    "&": 13,
-    ">": 10,
-    "<>": 10,
-    ">=": 10,
-    "<": 10,
-    "<=": 10,
-    "=": 10,
-};
-/**
- * Parse the next operand in an arithmetic expression.
- * e.g.
- *  for 1+2*3, the next operand is 1
- *  for (1+2)*3, the next operand is (1+2)
- *  for SUM(1,2)+3, the next operand is SUM(1,2)
- */
-function parseOperand(tokens) {
-    const current = tokens.shift();
-    if (!current) {
-        throw new BadExpressionError(DEFAULT_ERROR_MESSAGE);
+    // ---------------------------------------------------------------------------
+    // Getters
+    // ---------------------------------------------------------------------------
+    getCellBorder({ sheetId, col, row }) {
+        const border = {
+            top: this.borders[sheetId]?.[col]?.[row]?.horizontal,
+            bottom: this.borders[sheetId]?.[col]?.[row + 1]?.horizontal,
+            left: this.borders[sheetId]?.[col]?.[row]?.vertical,
+            right: this.borders[sheetId]?.[col + 1]?.[row]?.vertical,
+        };
+        if (!border.bottom && !border.left && !border.right && !border.top) {
+            return null;
+        }
+        return border;
     }
-    switch (current.type) {
-        case "DEBUGGER":
-            const next = parseExpression(tokens, 1000);
-            next.debug = true;
-            return next;
-        case "NUMBER":
-            return { type: "NUMBER", value: parseNumber(current.value, DEFAULT_LOCALE) };
-        case "STRING":
-            return { type: "STRING", value: removeStringQuotes(current.value) };
-        case "INVALID_REFERENCE":
-            return {
-                type: "REFERENCE",
-                value: CellErrorType.InvalidReference,
-            };
-        case "REFERENCE":
-            if (tokens[0]?.value === ":" && tokens[1]?.type === "REFERENCE") {
-                tokens.shift();
-                const rightReference = tokens.shift();
-                return {
-                    type: "REFERENCE",
-                    value: `${current.value}:${rightReference?.value}`,
-                };
-            }
-            return {
-                type: "REFERENCE",
-                value: current.value,
-            };
-        case "SYMBOL":
-            const value = current.value;
-            const nextToken = tokens[0];
-            if (nextToken?.type === "LEFT_PAREN" && functionRegex.test(current.value)) {
-                const args = parseFunctionArgs(tokens);
-                return { type: "FUNCALL", value: value, args };
-            }
-            const upperCaseValue = value.toUpperCase();
-            if (upperCaseValue === "TRUE" || upperCaseValue === "FALSE") {
-                return { type: "BOOLEAN", value: upperCaseValue === "TRUE" };
-            }
-            throw new BadExpressionError(_t("Invalid formula"));
-        case "LEFT_PAREN":
-            const result = parseExpression(tokens);
-            consumeOrThrow(tokens, "RIGHT_PAREN", _t("Missing closing parenthesis"));
-            return result;
-        case "OPERATOR":
-            const operator = current.value;
-            if (UNARY_OPERATORS_PREFIX.includes(operator)) {
-                return {
-                    type: "UNARY_OPERATION",
-                    value: operator,
-                    operand: parseExpression(tokens, OP_PRIORITY[operator]),
-                };
+    getBordersColors(sheetId) {
+        const colors = [];
+        const sheetBorders = this.borders[sheetId];
+        if (sheetBorders) {
+            for (const borders of sheetBorders.filter(isDefined$1)) {
+                for (const cellBorder of borders) {
+                    if (cellBorder?.horizontal) {
+                        colors.push(cellBorder.horizontal.color);
+                    }
+                    if (cellBorder?.vertical) {
+                        colors.push(cellBorder.vertical.color);
+                    }
+                }
             }
-            throw new BadExpressionError(_t("Unexpected token: %s", current.value));
-        default:
-            throw new BadExpressionError(_t("Unexpected token: %s", current.value));
-    }
-}
-function parseFunctionArgs(tokens) {
-    consumeOrThrow(tokens, "LEFT_PAREN", _t("Missing opening parenthesis"));
-    const nextToken = tokens[0];
-    if (nextToken?.type === "RIGHT_PAREN") {
-        consumeOrThrow(tokens, "RIGHT_PAREN");
-        return [];
+        }
+        return colors;
     }
-    const args = [];
-    args.push(parseOneFunctionArg(tokens));
-    while (tokens[0]?.type !== "RIGHT_PAREN") {
-        consumeOrThrow(tokens, "ARG_SEPARATOR", _t("Wrong function call"));
-        args.push(parseOneFunctionArg(tokens));
+    // ---------------------------------------------------------------------------
+    // Private
+    // ---------------------------------------------------------------------------
+    /**
+     * Ensure border continuity between two columns.
+     * If the two columns have the same borders (at each row respectively),
+     * the same borders are applied to each cell in between.
+     */
+    ensureColumnBorderContinuity(sheetId, leftColumn, rightColumn) {
+        const targetCols = range(leftColumn + 1, rightColumn);
+        for (let row = 0; row < this.getters.getNumberRows(sheetId); row++) {
+            const leftBorder = this.getCellBorder({ sheetId, col: leftColumn, row });
+            const rightBorder = this.getCellBorder({ sheetId, col: rightColumn, row });
+            if (leftBorder && rightBorder) {
+                const commonSides = this.getCommonSides(leftBorder, rightBorder);
+                for (let col of targetCols) {
+                    this.addBorder(sheetId, col, row, commonSides);
+                }
+            }
+        }
     }
-    consumeOrThrow(tokens, "RIGHT_PAREN");
-    return args;
-}
-function parseOneFunctionArg(tokens) {
-    const nextToken = tokens[0];
-    if (nextToken?.type === "ARG_SEPARATOR" || nextToken?.type === "RIGHT_PAREN") {
-        // arg is empty: "sum(1,,2)" "sum(,1)" "sum(1,)"
-        return { type: "EMPTY", value: "" };
+    /**
+     * Ensure border continuity between two rows.
+     * If the two rows have the same borders (at each column respectively),
+     * the same borders are applied to each cell in between.
+     */
+    ensureRowBorderContinuity(sheetId, topRow, bottomRow) {
+        const targetRows = range(topRow + 1, bottomRow);
+        for (let col = 0; col < this.getters.getNumberCols(sheetId); col++) {
+            const aboveBorder = this.getCellBorder({ sheetId, col, row: topRow });
+            const belowBorder = this.getCellBorder({ sheetId, col, row: bottomRow });
+            if (aboveBorder && belowBorder) {
+                const commonSides = this.getCommonSides(aboveBorder, belowBorder);
+                for (let row of targetRows) {
+                    this.addBorder(sheetId, col, row, commonSides);
+                }
+            }
+        }
     }
-    return parseExpression(tokens);
-}
-function consumeOrThrow(tokens, type, message = DEFAULT_ERROR_MESSAGE) {
-    const token = tokens.shift();
-    if (!token || token.type !== type) {
-        throw new BadExpressionError(message);
+    /**
+     * From two borders, return a new border with sides defined in both borders.
+     * i.e. the intersection of two borders.
+     */
+    getCommonSides(border1, border2) {
+        const commonBorder = {};
+        for (let side of ["top", "bottom", "left", "right"]) {
+            if (border1[side] && deepEquals(border1[side], border2[side])) {
+                commonBorder[side] = border1[side];
+            }
+        }
+        return commonBorder;
     }
-}
-function parseExpression(tokens, parent_priority = 0) {
-    if (tokens.length === 0) {
-        throw new BadExpressionError(DEFAULT_ERROR_MESSAGE);
+    /**
+     * Get all the columns which contains at least a border
+     */
+    getColumnsWithBorders(sheetId) {
+        const sheetBorders = this.borders[sheetId];
+        if (!sheetBorders)
+            return [];
+        return Object.keys(sheetBorders).map((index) => parseInt(index, 10));
     }
-    let left = parseOperand(tokens);
-    // as long as we have operators with higher priority than the parent one,
-    // continue parsing the expression because it is a child sub-expression
-    while (tokens[0]?.type === "OPERATOR" && OP_PRIORITY[tokens[0].value] > parent_priority) {
-        const operator = tokens.shift().value;
-        if (UNARY_OPERATORS_POSTFIX.includes(operator)) {
-            left = {
-                type: "UNARY_OPERATION",
-                value: operator,
-                operand: left,
-                postfix: true,
-            };
-        }
-        else {
-            const right = parseExpression(tokens, OP_PRIORITY[operator]);
-            left = {
-                type: "BIN_OPERATION",
-                value: operator,
-                left,
-                right,
-            };
+    /**
+     * Get all the rows which contains at least a border
+     */
+    getRowsWithBorders(sheetId) {
+        const sheetBorders = this.borders[sheetId]?.filter(isDefined$1);
+        if (!sheetBorders)
+            return [];
+        const rowsWithBorders = new Set();
+        for (const rowBorders of sheetBorders) {
+            for (const rowBorder in rowBorders) {
+                rowsWithBorders.add(parseInt(rowBorder, 10));
+            }
         }
+        return Array.from(rowsWithBorders);
     }
-    return left;
-}
-/**
- * Parse an expression (as a string) into an AST.
- */
-function parse(str) {
-    return parseTokens(rangeTokenize(str));
-}
-function parseTokens(tokens) {
-    tokens = tokens.filter((x) => x.type !== "SPACE");
-    if (tokens[0]?.value === "=") {
-        tokens.splice(0, 1);
-    }
-    const result = parseExpression(tokens);
-    if (tokens.length) {
-        throw new BadExpressionError(DEFAULT_ERROR_MESSAGE);
+    /**
+     * Get the range of all the rows in the sheet
+     */
+    getRowsRange(sheetId) {
+        const sheetBorders = this.borders[sheetId];
+        if (!sheetBorders)
+            return [];
+        return range(0, this.getters.getNumberRows(sheetId) + 1);
     }
-    return result;
-}
-/**
- * Allows to visit all nodes of an AST and apply a mapping function
- * to nodes of a specific type.
- * Useful if you want to convert some part of a formula.
- *
- * @example
- * convertAstNodes(ast, "FUNCALL", convertFormulaToExcel)
- *
- * function convertFormulaToExcel(ast: ASTFuncall) {
- *   // ...
- *   return modifiedAst
- * }
- */
-function convertAstNodes(ast, type, fn) {
-    return mapAst(ast, (ast) => {
-        if (ast.type === type) {
-            return fn(ast);
+    /**
+     * Move borders of a sheet horizontally.
+     * @param sheetId
+     * @param start starting column (included)
+     * @param delta how much borders will be moved (negative if moved to the left)
+     */
+    shiftBordersHorizontally(sheetId, start, delta, { moveFirstLeftBorder } = {}) {
+        const borders = this.borders[sheetId];
+        if (!borders)
+            return;
+        if (delta < 0) {
+            this.moveBordersOfColumn(sheetId, start, delta, "vertical", {
+                destructive: false,
+            });
         }
-        return ast;
-    });
-}
-function iterateAstNodes(ast) {
-    return Array.from(astIterator(ast));
-}
-function* astIterator(ast) {
-    yield ast;
-    switch (ast.type) {
-        case "FUNCALL":
-            for (const arg of ast.args) {
-                yield* astIterator(arg);
+        this.getColumnsWithBorders(sheetId)
+            .filter((col) => col >= start)
+            .sort((a, b) => (delta < 0 ? a - b : b - a)) // start by the end when moving up
+            .forEach((col) => {
+            if ((col === start && moveFirstLeftBorder) || col !== start) {
+                this.moveBordersOfColumn(sheetId, col, delta, "vertical");
             }
-            break;
-        case "UNARY_OPERATION":
-            yield* astIterator(ast.operand);
-            break;
-        case "BIN_OPERATION":
-            yield* astIterator(ast.left);
-            yield* astIterator(ast.right);
-            break;
-    }
-}
-function mapAst(ast, fn) {
-    ast = fn(ast);
-    switch (ast.type) {
-        case "FUNCALL":
-            return {
-                ...ast,
-                args: ast.args.map((child) => mapAst(child, fn)),
-            };
-        case "UNARY_OPERATION":
-            return {
-                ...ast,
-                operand: mapAst(ast.operand, fn),
-            };
-        case "BIN_OPERATION":
-            return {
-                ...ast,
-                right: mapAst(ast.right, fn),
-                left: mapAst(ast.left, fn),
-            };
-        default:
-            return ast;
-    }
-}
-/**
- * Converts an ast formula to the corresponding string
- */
-function astToFormula(ast) {
-    switch (ast.type) {
-        case "FUNCALL":
-            const args = ast.args.map((arg) => astToFormula(arg));
-            return `${ast.value}(${args.join(",")})`;
-        case "NUMBER":
-            return ast.value.toString();
-        case "REFERENCE":
-            return ast.value;
-        case "STRING":
-            return `"${ast.value}"`;
-        case "BOOLEAN":
-            return ast.value ? "TRUE" : "FALSE";
-        case "UNARY_OPERATION":
-            return ast.postfix
-                ? leftOperandToFormula(ast) + ast.value
-                : ast.value + rightOperandToFormula(ast);
-        case "BIN_OPERATION":
-            return leftOperandToFormula(ast) + ast.value + rightOperandToFormula(ast);
-        default:
-            return ast.value;
+            this.moveBordersOfColumn(sheetId, col, delta, "horizontal");
+        });
     }
-}
-/**
- * Convert the left operand of a binary operation to the corresponding string
- * and enclose the result inside parenthesis if necessary.
- */
-function leftOperandToFormula(operationAST) {
-    const mainOperator = operationAST.value;
-    const leftOperation = "left" in operationAST ? operationAST.left : operationAST.operand;
-    const leftOperator = leftOperation.value;
-    const needParenthesis = leftOperation.type === "BIN_OPERATION" && OP_PRIORITY[leftOperator] < OP_PRIORITY[mainOperator];
-    return needParenthesis ? `(${astToFormula(leftOperation)})` : astToFormula(leftOperation);
-}
-/**
- * Convert the right operand of a binary or unary operation to the corresponding string
- * and enclose the result inside parenthesis if necessary.
- */
-function rightOperandToFormula(operationAST) {
-    const mainOperator = operationAST.value;
-    const rightOperation = "right" in operationAST ? operationAST.right : operationAST.operand;
-    const rightPriority = OP_PRIORITY[rightOperation.value];
-    const mainPriority = OP_PRIORITY[mainOperator];
-    let needParenthesis = false;
-    if (rightOperation.type !== "BIN_OPERATION") {
-        needParenthesis = false;
+    /**
+     * Move borders of a sheet vertically.
+     * @param sheetId
+     * @param start starting row (included)
+     * @param delta how much borders will be moved (negative if moved to the above)
+     */
+    shiftBordersVertically(sheetId, start, delta, { moveFirstTopBorder } = {}) {
+        const borders = this.borders[sheetId];
+        if (!borders)
+            return;
+        if (delta < 0) {
+            this.moveBordersOfRow(sheetId, start, delta, "horizontal", {
+                destructive: false,
+            });
+        }
+        this.getRowsWithBorders(sheetId)
+            .filter((row) => row >= start)
+            .sort((a, b) => (delta < 0 ? a - b : b - a)) // start by the end when moving up
+            .forEach((row) => {
+            if ((row === start && moveFirstTopBorder) || row !== start) {
+                this.moveBordersOfRow(sheetId, row, delta, "horizontal");
+            }
+            this.moveBordersOfRow(sheetId, row, delta, "vertical");
+        });
     }
-    else if (rightPriority < mainPriority) {
-        needParenthesis = true;
+    /**
+     * Moves the borders (left if `vertical` or top if `horizontal` depending on
+     * `borderDirection`) of all cells in an entire row `delta` rows to the right
+     * (`delta` > 0) or to the left (`delta` < 0).
+     * Note that as the left of a cell is the right of the cell-1, if the left is
+     * moved the right is also moved. However, if `horizontal`, the bottom border
+     * is not moved.
+     * It does it by replacing the target border by the moved border. If the
+     * argument `destructive` is given false, the target border is preserved if
+     * the moved border is empty
+     */
+    moveBordersOfRow(sheetId, row, delta, borderDirection, { destructive } = { destructive: true }) {
+        const borders = this.borders[sheetId];
+        if (!borders)
+            return;
+        this.getColumnsWithBorders(sheetId).forEach((col) => {
+            const targetBorder = borders[col]?.[row + delta]?.[borderDirection];
+            const movedBorder = borders[col]?.[row]?.[borderDirection];
+            this.history.update("borders", sheetId, col, row + delta, borderDirection, destructive ? movedBorder : movedBorder || targetBorder);
+            this.history.update("borders", sheetId, col, row, borderDirection, undefined);
+        });
     }
-    else if (rightPriority === mainPriority && !ASSOCIATIVE_OPERATORS.includes(mainOperator)) {
-        needParenthesis = true;
+    /**
+     * Moves the borders (left if `vertical` or top if `horizontal` depending on
+     * `borderDirection`) of all cells in an entire column `delta` columns below
+     * (`delta` > 0) or above (`delta` < 0).
+     * Note that as the top of a cell is the bottom of the cell-1, if the top is
+     * moved the bottom is also moved. However, if `vertical`, the right border
+     * is not moved.
+     * It does it by replacing the target border by the moved border. If the
+     * argument `destructive` is given false, the target border is preserved if
+     * the moved border is empty
+     */
+    moveBordersOfColumn(sheetId, col, delta, borderDirection, { destructive } = { destructive: true }) {
+        const borders = this.borders[sheetId];
+        if (!borders)
+            return;
+        this.getRowsRange(sheetId).forEach((row) => {
+            const targetBorder = borders[col + delta]?.[row]?.[borderDirection];
+            const movedBorder = borders[col]?.[row]?.[borderDirection];
+            this.history.update("borders", sheetId, col + delta, row, borderDirection, destructive ? movedBorder : movedBorder || targetBorder);
+            this.history.update("borders", sheetId, col, row, borderDirection, undefined);
+        });
     }
-    return needParenthesis ? `(${astToFormula(rightOperation)})` : astToFormula(rightOperation);
-}
-
-const functions$1 = functionRegistry.content;
-const OPERATOR_MAP = {
-    "=": "EQ",
-    "+": "ADD",
-    "-": "MINUS",
-    "*": "MULTIPLY",
-    "/": "DIVIDE",
-    ">=": "GTE",
-    "<>": "NE",
-    ">": "GT",
-    "<=": "LTE",
-    "<": "LT",
-    "^": "POWER",
-    "&": "CONCATENATE",
-};
-const UNARY_OPERATOR_MAP = {
-    "-": "UMINUS",
-    "+": "UPLUS",
-    "%": "UNARY.PERCENT",
-};
-// this cache contains all compiled function code, grouped by "structure". For
-// example, "=2*sum(A1:A4)" and "=2*sum(B1:B4)" are compiled into the same
-// structural function.
-// It is only exported for testing purposes
-const functionCache = {};
-// -----------------------------------------------------------------------------
-// COMPILER
-// -----------------------------------------------------------------------------
-function compile(formula) {
-    const tokens = rangeTokenize(formula);
-    return compileTokens(tokens);
-}
-function compileTokens(tokens) {
-    const { dependencies, constantValues } = formulaArguments(tokens);
-    const cacheKey = compilationCacheKey(tokens, dependencies, constantValues);
-    if (!functionCache[cacheKey]) {
-        const ast = parseTokens([...tokens]);
-        const scope = new Scope();
-        if (ast.type === "BIN_OPERATION" && ast.value === ":") {
-            throw new BadExpressionError(_t("Invalid formula"));
+    /**
+     * Set the borders of a cell.
+     * It overrides the current border if override === true.
+     */
+    setBorder(sheetId, col, row, border, override = true) {
+        if (override || !this.borders?.[sheetId]?.[col]?.[row]?.vertical) {
+            this.history.update("borders", sheetId, col, row, "vertical", border?.left);
         }
-        if (ast.type === "EMPTY") {
-            throw new BadExpressionError(_t("Invalid formula"));
+        if (override || !this.borders?.[sheetId]?.[col]?.[row]?.horizontal) {
+            this.history.update("borders", sheetId, col, row, "horizontal", border?.top);
         }
-        const compiledAST = compileAST(ast);
-        const code = new FunctionCodeBuilder();
-        code.append(`// ${cacheKey}`);
-        code.append(compiledAST);
-        code.append(`return ${compiledAST.returnExpression};`);
-        let baseFunction = new Function("deps", // the dependencies in the current formula
-        "ref", // a function to access a certain dependency at a given index
-        "range", // same as above, but guarantee that the result is in the form of a range
-        "ctx", code.toString());
-        functionCache[cacheKey] = {
-            // @ts-ignore
-            execute: baseFunction,
-        };
-        /**
-         * This function compile the function arguments. It is mostly straightforward,
-         * except that there is a non trivial transformation in one situation:
-         *
-         * If a function argument is asking for a range, and get a cell, we transform
-         * the cell value into a range. This allow the grid model to differentiate
-         * between a cell value and a non cell value.
-         */
-        function compileFunctionArgs(ast) {
-            const { args } = ast;
-            const functionName = ast.value.toUpperCase();
-            const functionDefinition = functions$1[functionName];
-            if (!functionDefinition) {
-                throw new UnknownFunctionError(ast.value);
-            }
-            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(_t("Function %s expects the parameter %s to be reference to a cell or range, not a %s.", functionName, (i + 1).toString(), currentArg.type.toLowerCase()));
-                    }
+        if (override || !this.borders?.[sheetId]?.[col + 1]?.[row]?.vertical) {
+            this.history.update("borders", sheetId, col + 1, row, "vertical", border?.right);
+        }
+        if (override || !this.borders?.[sheetId]?.[col]?.[row + 1]?.horizontal) {
+            this.history.update("borders", sheetId, col, row + 1, "horizontal", border?.bottom);
+        }
+    }
+    /**
+     * Remove the borders of a zone
+     */
+    clearBorders(sheetId, zones) {
+        for (let zone of zones) {
+            for (let row = zone.top; row <= zone.bottom; row++) {
+                this.history.update("borders", sheetId, zone.right + 1, row, "vertical", undefined);
+                for (let col = zone.left; col <= zone.right; col++) {
+                    this.history.update("borders", sheetId, col, row, undefined);
                 }
-                const compiledAST = compileAST(currentArg, isMeta, hasRange, {
-                    functionName,
-                    paramIndex: i + 1,
-                });
-                compiledArgs.push(isLazy ? compiledAST.wrapInClosure() : compiledAST);
             }
-            return compiledArgs;
+            for (let col = zone.left; col <= zone.right; col++) {
+                this.history.update("borders", sheetId, col, zone.bottom + 1, "horizontal", undefined);
+            }
         }
-        /**
-         * This function compiles all the information extracted by the parser into an
-         * executable code for the evaluation of the cells content. It uses a cash to
-         * not reevaluate identical code structures.
-         *
-         * The function is sensitive to parameter “isMeta”. This
-         * parameter may vary when compiling function arguments:
-         * isMeta: In some cases the function arguments expects information on the
-         * cell/range other than the associated value(s). For example the COLUMN
-         * function needs to receive as argument the coordinates of a cell rather
-         * than its value. For this we have meta arguments.
-         */
-        function compileAST(ast, isMeta = false, hasRange = false, referenceVerification = {}) {
-            const code = new FunctionCodeBuilder(scope);
-            if (ast.type !== "REFERENCE" && !(ast.type === "BIN_OPERATION" && ast.value === ":")) {
-                if (isMeta) {
-                    throw new BadExpressionError(_t("Argument must be a reference to a cell or range."));
+    }
+    /**
+     * Remove the borders inside of a zone
+     */
+    clearInsideBorders(sheetId, zones) {
+        for (let zone of zones) {
+            for (let row = zone.top; row <= zone.bottom; row++) {
+                for (let col = zone.left; col <= zone.right; col++) {
+                    this.history.update("borders", sheetId, col, row, undefined);
                 }
             }
-            if (ast.debug) {
-                code.append("debugger;");
-            }
-            switch (ast.type) {
-                case "BOOLEAN":
-                    return code.return(`{ value: ${ast.value} }`);
-                case "NUMBER":
-                    return code.return(`{ value: this.constantValues.numbers[${constantValues.numbers.indexOf(ast.value)}] }`);
-                case "STRING":
-                    return code.return(`{ value: this.constantValues.strings[${constantValues.strings.indexOf(ast.value)}] }`);
-                case "REFERENCE":
-                    const referenceIndex = dependencies.indexOf(ast.value);
-                    if (hasRange) {
-                        return code.return(`range(deps[${referenceIndex}])`);
+        }
+    }
+    /**
+     * Add a border to the existing one to a cell
+     */
+    addBorder(sheetId, col, row, border) {
+        this.setBorder(sheetId, col, row, {
+            ...this.getCellBorder({ sheetId, col, row }),
+            ...border,
+        });
+    }
+    /**
+     * Set the borders of a zone by computing the borders to add from the given
+     * command
+     */
+    setBorders(sheetId, zones, position, border) {
+        if (position === "clear") {
+            return this.clearBorders(sheetId, zones);
+        }
+        for (let zone of zones) {
+            if (position === "h" || position === "hv" || position === "all") {
+                for (let row = zone.top + 1; row <= zone.bottom; row++) {
+                    for (let col = zone.left; col <= zone.right; col++) {
+                        this.addBorder(sheetId, col, row, { top: border });
                     }
-                    else {
-                        return code.return(`ref(deps[${referenceIndex}], ${isMeta ? "true" : "false"}, "${referenceVerification.functionName || OPERATOR_MAP["="]}",  ${referenceVerification.paramIndex})`);
+                }
+            }
+            if (position === "v" || position === "hv" || position === "all") {
+                for (let row = zone.top; row <= zone.bottom; row++) {
+                    for (let col = zone.left + 1; col <= zone.right; col++) {
+                        this.addBorder(sheetId, col, row, { left: border });
                     }
-                case "FUNCALL":
-                    const args = compileFunctionArgs(ast).map((arg) => arg.assignResultToVariable());
-                    code.append(...args);
-                    const fnName = ast.value.toUpperCase();
-                    code.append(`ctx.__lastFnCalled = '${fnName}';`);
-                    return code.return(`ctx['${fnName}'](${args.map((arg) => arg.returnExpression)})`);
-                case "UNARY_OPERATION": {
-                    const fnName = UNARY_OPERATOR_MAP[ast.value];
-                    const operand = compileAST(ast.operand, false, false, {
-                        functionName: fnName,
-                    }).assignResultToVariable();
-                    code.append(operand);
-                    code.append(`ctx.__lastFnCalled = '${fnName}';`);
-                    return code.return(`ctx['${fnName}'](${operand.returnExpression})`);
                 }
-                case "BIN_OPERATION": {
-                    const fnName = OPERATOR_MAP[ast.value];
-                    const left = compileAST(ast.left, false, false, {
-                        functionName: fnName,
-                    }).assignResultToVariable();
-                    const right = compileAST(ast.right, false, false, {
-                        functionName: fnName,
-                    }).assignResultToVariable();
-                    code.append(left);
-                    code.append(right);
-                    code.append(`ctx.__lastFnCalled = '${fnName}';`);
-                    return code.return(`ctx['${fnName}'](${left.returnExpression}, ${right.returnExpression})`);
+            }
+            if (position === "left" || position === "all" || position === "external") {
+                for (let row = zone.top; row <= zone.bottom; row++) {
+                    this.addBorder(sheetId, zone.left, row, { left: border });
                 }
-                case "EMPTY":
-                    return code.return("undefined");
             }
-        }
-    }
-    const compiledFormula = {
-        execute: functionCache[cacheKey].execute,
-        dependencies,
-        constantValues,
-        tokens,
-    };
-    return compiledFormula;
-}
-/**
- * Compute a cache key for the formula.
- * References, numbers and strings are replaced with placeholders because
- * the compiled formula does not depend on their actual value.
- * Both `=A1+1+"2"` and `=A2+2+"3"` are compiled to the exact same function.
- *
- * Spaces are also ignored to compute the cache key.
- *
- * A formula `=A1+A2+SUM(2, 2, "2")` have the cache key `=|0|+|1|+SUM(|N0|,|N0|,|S0|)`
- */
-function compilationCacheKey(tokens, dependencies, constantValues) {
-    return concat(tokens.map((token) => {
-        switch (token.type) {
-            case "STRING":
-                const value = removeStringQuotes(token.value);
-                return `|S${constantValues.strings.indexOf(value)}|`;
-            case "NUMBER":
-                return `|N${constantValues.numbers.indexOf(parseNumber(token.value, DEFAULT_LOCALE))}|`;
-            case "REFERENCE":
-            case "INVALID_REFERENCE":
-                return `|${dependencies.indexOf(token.value)}|`;
-            case "SPACE":
-                return "";
-            default:
-                return token.value;
-        }
-    }));
-}
-/**
- * Return formula arguments which are references, strings and numbers.
- */
-function formulaArguments(tokens) {
-    const constantValues = {
-        numbers: [],
-        strings: [],
-    };
-    const dependencies = [];
-    for (const token of tokens) {
-        switch (token.type) {
-            case "INVALID_REFERENCE":
-            case "REFERENCE":
-                dependencies.push(token.value);
-                break;
-            case "STRING":
-                const value = removeStringQuotes(token.value);
-                if (!constantValues.strings.includes(value)) {
-                    constantValues.strings.push(value);
+            if (position === "right" || position === "all" || position === "external") {
+                for (let row = zone.top; row <= zone.bottom; row++) {
+                    this.addBorder(sheetId, zone.right + 1, row, { left: border });
                 }
-                break;
-            case "NUMBER": {
-                const value = parseNumber(token.value, DEFAULT_LOCALE);
-                if (!constantValues.numbers.includes(value)) {
-                    constantValues.numbers.push(value);
+            }
+            if (position === "top" || position === "all" || position === "external") {
+                for (let col = zone.left; col <= zone.right; col++) {
+                    this.addBorder(sheetId, col, zone.top, { top: border });
+                }
+            }
+            if (position === "bottom" || position === "all" || position === "external") {
+                for (let col = zone.left; col <= zone.right; col++) {
+                    this.addBorder(sheetId, col, zone.bottom + 1, { top: border });
                 }
-                break;
             }
         }
     }
-    return {
-        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(_t("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(_t("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(_t("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()));
+    /**
+     * Compute the borders to add to the given zone merged.
+     */
+    addBordersToMerge(sheetId, zone) {
+        const { left, right, top, bottom } = zone;
+        const bordersTopLeft = this.getCellBorder({ sheetId, col: left, row: top });
+        const bordersBottomRight = this.getCellBorder({ sheetId, col: right, row: bottom });
+        this.clearBorders(sheetId, [zone]);
+        if (bordersTopLeft?.top) {
+            this.setBorders(sheetId, [{ ...zone, bottom: top }], "top", bordersTopLeft.top);
         }
-    }
-}
-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;
-}
-
-/**
- * Add the following information on tokens:
- * - length
- * - start
- * - end
- */
-function enrichTokens(tokens) {
-    let current = 0;
-    return tokens.map((x) => {
-        const len = x.value.toString().length;
-        const token = Object.assign({}, x, {
-            start: current,
-            end: current + len,
-            length: len,
-        });
-        current = token.end;
-        return token;
-    });
-}
-/**
- * add on each token the length, start and end
- * also matches the opening to its closing parenthesis (using the same number)
- */
-function mapParenthesis(tokens) {
-    let maxParen = 1;
-    const stack = [];
-    return tokens.map((token) => {
-        if (token.type === "LEFT_PAREN") {
-            stack.push(maxParen);
-            token.parenIndex = maxParen;
-            maxParen++;
+        if (bordersTopLeft?.left) {
+            this.setBorders(sheetId, [{ ...zone, right: left }], "left", bordersTopLeft.left);
         }
-        else if (token.type === "RIGHT_PAREN") {
-            token.parenIndex = stack.pop();
+        if (bordersBottomRight?.bottom) {
+            this.setBorders(sheetId, [{ ...zone, top: bottom }], "bottom", bordersBottomRight.bottom);
         }
-        return token;
-    });
-}
-/**
- * add on each token its parent function and the index corresponding to
- * its position as an argument of the function.
- * In this example "=MIN(42,SUM(MAX(1,2),3))":
- * - the parent function of the token correspond to number 42 is the MIN function
- * - the argument position of the token correspond to number 42 is 0
- * - the parent function of the token correspond to number 3 is the SUM function
- * - the argument position of the token correspond to number 3 is 1
- */
-function mapParentFunction(tokens) {
-    let stack = [];
-    let functionStarted = "";
-    const res = tokens.map((token, i) => {
-        if (!["SPACE", "LEFT_PAREN"].includes(token.type)) {
-            functionStarted = "";
+        else if (bordersTopLeft?.bottom) {
+            this.setBorders(sheetId, [{ ...zone, top: bottom }], "bottom", bordersTopLeft.bottom);
         }
-        switch (token.type) {
-            case "SYMBOL":
-                functionStarted = token.value;
-                break;
-            case "LEFT_PAREN":
-                stack.push({ parent: functionStarted, argPosition: 0 });
-                functionStarted = "";
-                break;
-            case "RIGHT_PAREN":
-                stack.pop();
-                break;
-            case "ARG_SEPARATOR":
-                if (stack.length) {
-                    // increment position on current function
-                    stack[stack.length - 1].argPosition++;
+        if (bordersBottomRight?.right) {
+            this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersBottomRight.right);
+        }
+        else if (bordersTopLeft?.right) {
+            this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersTopLeft.right);
+        }
+    }
+    checkBordersUnchanged(cmd) {
+        const currentBorder = this.getCellBorder(cmd);
+        const areAllNewBordersUndefined = !cmd.border?.bottom && !cmd.border?.left && !cmd.border?.right && !cmd.border?.top;
+        if ((!currentBorder && areAllNewBordersUndefined) || deepEquals(currentBorder, cmd.border)) {
+            return "NoChanges" /* CommandResult.NoChanges */;
+        }
+        return "Success" /* CommandResult.Success */;
+    }
+    // ---------------------------------------------------------------------------
+    // Import/Export
+    // ---------------------------------------------------------------------------
+    import(data) {
+        // Borders
+        if (Object.keys(data.borders || {}).length) {
+            for (let sheet of data.sheets) {
+                for (const xc in sheet.cells) {
+                    const cell = sheet.cells[xc];
+                    if (cell?.border) {
+                        const border = data.borders[cell.border];
+                        const { col, row } = toCartesian(xc);
+                        this.setBorder(sheet.id, col, row, border, false);
+                    }
                 }
-                break;
+            }
         }
-        if (stack.length) {
-            const functionContext = stack[stack.length - 1];
-            if (functionContext.parent) {
-                token.functionContext = Object.assign({}, functionContext);
+        // Merges
+        for (let sheetData of data.sheets) {
+            if (sheetData.merges) {
+                for (let merge of sheetData.merges) {
+                    this.addBordersToMerge(sheetData.id, toZone(merge));
+                }
             }
         }
-        return token;
-    });
-    return res;
-}
-/**
- * Take the result of the tokenizer and transform it to be usable in the composer.
- *
- * @param formula
- */
-function composerTokenize(formula, locale) {
-    const tokens = rangeTokenize(formula, locale);
-    return mapParentFunction(mapParenthesis(enrichTokens(tokens)));
-}
-
-const functions = functionRegistry.content;
-function isExportableToExcel(tokens) {
-    try {
-        const nonExportableFunctions = iterateAstNodes(parseTokens(tokens)).filter((ast) => ast.type === "FUNCALL" && !functions[ast.value.toUpperCase()]?.isExported);
-        return nonExportableFunctions.length === 0;
     }
-    catch (error) {
-        return false;
+    export(data) {
+        const borders = {};
+        for (let sheet of data.sheets) {
+            for (let col = 0; col < sheet.colNumber; col++) {
+                for (let row = 0; row < sheet.rowNumber; row++) {
+                    const border = this.getCellBorder({ sheetId: sheet.id, col, row });
+                    if (border) {
+                        const xc = toXC(col, row);
+                        const cell = sheet.cells[xc];
+                        const borderId = getItemId(border, borders);
+                        if (cell) {
+                            cell.border = borderId;
+                        }
+                        else {
+                            sheet.cells[xc] = { border: borderId };
+                        }
+                    }
+                }
+            }
+        }
+        data.borders = borders;
+    }
+    exportForExcel(data) {
+        this.export(data);
     }
 }
 
@@ -58449,6 +58454,6 @@ exports.setTranslationMethod = setTranslationMethod;
 exports.tokenize = tokenize;
 
 
-__info__.version = "17.0.70";
-__info__.date = "2025-07-28T13:26:37.626Z";
-__info__.hash = "2ec8d82";
+__info__.version = "17.0.71";
+__info__.date = "2025-08-21T06:37:34.192Z";
+__info__.hash = "1592964";