@odoo/o-spreadsheet 17.0.69 → 17.0.71

package/dist/o-spreadsheet.iife.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.69
- * @date 2025-07-11T11:06:35.446Z
- * @hash 8c0d3da
+ * @version 17.0.71
+ * @date 2025-08-21T06:37:34.192Z
+ * @hash 1592964
  */
 
 (function (exports, owl) {
@@ -30694,6 +30694,897 @@
   ];
   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
    */
@@ -31442,9 +32333,9 @@
                   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;
           }
@@ -31587,6 +32478,11 @@
               ? 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
   // ---------------------------------------------------------------------------
@@ -33935,160 +34831,20 @@
       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());
+              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;
   }
 
   /**
@@ -34962,1175 +35718,424 @@
       }
       /**
        * 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);
-      }
-  }
-  /**
-   * 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--;
+       * 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);
+      /**
+       * 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);
       }
-      const result = parseExpression(tokens);
-      if (tokens.length) {
-          throw new BadExpressionError(DEFAULT_ERROR_MESSAGE);
+      /**
+       * 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");
+          });
       }
-      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 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,
+              });
           }
-          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.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");
               }
-              break;
-          case "UNARY_OPERATION":
-              yield* astIterator(ast.operand);
-              break;
-          case "BIN_OPERATION":
-              yield* astIterator(ast.left);
-              yield* astIterator(ast.right);
-              break;
+              this.moveBordersOfRow(sheetId, row, delta, "vertical");
+          });
       }
-  }
-  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;
+      /**
+       * 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);
+          });
       }
-  }
-  /**
-   * 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;
+      /**
+       * 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);
+          });
       }
-  }
-  /**
-   * 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;
+      /**
+       * 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);
+              }
+          }
       }
-      else if (rightPriority < mainPriority) {
-          needParenthesis = true;
+      /**
+       * 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);
+                  }
+              }
+          }
       }
-      else if (rightPriority === mainPriority && !ASSOCIATIVE_OPERATORS.includes(mainOperator)) {
-          needParenthesis = true;
+      /**
+       * 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,
+          });
       }
-      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"));
+      /**
+       * 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);
           }
-          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);
+          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 });
+                      }
+                  }
               }
-              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 (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 });
                       }
                   }
-                  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 (position === "left" || position === "all" || position === "external") {
+                  for (let row = zone.top; row <= zone.bottom; row++) {
+                      this.addBorder(sheetId, zone.left, row, { left: border });
                   }
               }
-              if (ast.debug) {
-                  code.append("debugger;");
+              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 });
+                  }
               }
-              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})`);
+              if (position === "top" || position === "all" || position === "external") {
+                  for (let col = zone.left; col <= zone.right; col++) {
+                      this.addBorder(sheetId, col, zone.top, { top: border });
                   }
-                  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 === "bottom" || position === "all" || position === "external") {
+                  for (let col = zone.left; col <= zone.right; col++) {
+                      this.addBorder(sheetId, col, zone.bottom + 1, { top: 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;
+      /**
+       * 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);
           }
-      }));
-  }
-  /**
-   * 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;
-              }
+          if (bordersTopLeft?.left) {
+              this.setBorders(sheetId, [{ ...zone, right: left }], "left", bordersTopLeft.left);
           }
-      }
-      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()));
+          if (bordersBottomRight?.bottom) {
+              this.setBorders(sheetId, [{ ...zone, top: bottom }], "bottom", bordersBottomRight.bottom);
           }
-      }
-  }
-  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 (bordersTopLeft?.bottom) {
+              this.setBorders(sheetId, [{ ...zone, top: bottom }], "bottom", bordersTopLeft.bottom);
           }
-          else if (token.type === "RIGHT_PAREN") {
-              token.parenIndex = stack.pop();
+          if (bordersBottomRight?.right) {
+              this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersBottomRight.right);
           }
-          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?.right) {
+              this.setBorders(sheetId, [{ ...zone, left: right }], "right", bordersTopLeft.right);
           }
-          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++;
+      }
+      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);
       }
   }
 
@@ -43470,6 +43475,23 @@
       static getters = ["getRowSize", "getHeaderSize"];
       tallestCellInRow = {};
       ctx = document.createElement("canvas").getContext("2d");
+      beforeHandle(cmd) {
+          switch (cmd.type) {
+              // Ensure rows are updated before "UPDATE_CELL" is dispatched from cell plugin.
+              // "UPDATE_CELL" uses the Sheet core plugin to access row data.
+              // If "ADD_COLUMNS_ROWS" has not been processed yet by header_sizes_ui,
+              // size updates may apply to incorrect (pre-insert) rows.
+              case "ADD_COLUMNS_ROWS":
+                  if (cmd.dimension === "COL") {
+                      return;
+                  }
+                  const addIndex = getAddHeaderStartIndex(cmd.position, cmd.base);
+                  const newCells = Array(cmd.quantity).fill(undefined);
+                  const newTallestCells = insertItemsAtIndex(this.tallestCellInRow[cmd.sheetId], newCells, addIndex);
+                  this.history.update("tallestCellInRow", cmd.sheetId, newTallestCells);
+                  break;
+          }
+      }
       handle(cmd) {
           switch (cmd.type) {
               case "START":
@@ -43499,16 +43521,6 @@
                   this.history.update("tallestCellInRow", cmd.sheetId, tallestCells);
                   break;
               }
-              case "ADD_COLUMNS_ROWS": {
-                  if (cmd.dimension === "COL") {
-                      return;
-                  }
-                  const addIndex = getAddHeaderStartIndex(cmd.position, cmd.base);
-                  const newCells = Array(cmd.quantity).fill(undefined);
-                  const newTallestCells = insertItemsAtIndex(this.tallestCellInRow[cmd.sheetId], newCells, addIndex);
-                  this.history.update("tallestCellInRow", cmd.sheetId, newTallestCells);
-                  break;
-              }
               case "RESIZE_COLUMNS_ROWS":
                   {
                       const sheetId = cmd.sheetId;
@@ -50873,6 +50885,14 @@
           const isBasedBefore = cmd.base < start;
           const deltaCol = isBasedBefore && isCol ? thickness : 0;
           const deltaRow = isBasedBefore && !isCol ? thickness : 0;
+          const toRemove = isBasedBefore ? cmd.elements.map((el) => el + thickness) : cmd.elements;
+          const originalSize = Object.fromEntries(toRemove.map((element) => {
+              const size = isCol
+                  ? this.getters.getColSize(cmd.sheetId, element)
+                  : this.getters.getUserRowSize(cmd.sheetId, element);
+              const isDefaultCol = isCol && size === DEFAULT_CELL_WIDTH;
+              return [element, isDefaultCol || size === undefined ? null : size];
+          }));
           const target = [
               {
                   left: isCol ? start + deltaCol : 0,
@@ -50892,14 +50912,12 @@
               },
           ];
           state.paste(pasteTarget, { selectTarget: true });
-          const toRemove = isBasedBefore ? cmd.elements.map((el) => el + thickness) : cmd.elements;
           let currentIndex = isBasedBefore ? cmd.base : cmd.base + 1;
           for (const element of toRemove) {
-              const size = this.getters.getHeaderSize(cmd.sheetId, cmd.dimension, element);
               this.dispatch("RESIZE_COLUMNS_ROWS", {
                   dimension: cmd.dimension,
                   sheetId: cmd.sheetId,
-                  size,
+                  size: originalSize[element],
                   elements: [currentIndex],
               });
               currentIndex += 1;
@@ -58435,9 +58453,9 @@
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.0.69";
-  __info__.date = "2025-07-11T11:06:35.446Z";
-  __info__.hash = "8c0d3da";
+  __info__.version = "17.0.71";
+  __info__.date = "2025-08-21T06:37:34.192Z";
+  __info__.hash = "1592964";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);