@odoo/o-spreadsheet 16.4.0-alpha.6 → 16.4.0

package/dist/o-spreadsheet.iife.js

@@ -236,6 +236,7 @@
   const HEADER_FONT_SIZE = 11;
   const DEFAULT_FONT = "'Roboto', arial";
   const DEFAULT_VERTICAL_ALIGN = "bottom";
+  const DEFAULT_WRAPPING_MODE = "overflow";
   // Borders
   const DEFAULT_BORDER_DESC = { style: "thin", color: "#000000" };
   const DEFAULT_FILTER_BORDER_DESC = { style: "thin", color: FILTERS_COLOR };
@@ -393,82 +394,6 @@
   function clip(val, min, max) {
       return val < min ? min : val > max ? max : val;
   }
-  function computeTextLinesHeight(textLineHeight, numberOfLines = 1) {
-      return numberOfLines * (textLineHeight + MIN_CELL_TEXT_MARGIN) - MIN_CELL_TEXT_MARGIN;
-  }
-  /**
-   * Get the default height of the cell given its style.
-   */
-  function getDefaultCellHeight(cell) {
-      if (!cell || !cell.content) {
-          return DEFAULT_CELL_HEIGHT;
-      }
-      const fontSize = computeTextFontSizeInPixels(cell.style);
-      // the number of lines should be computed from the formula result, but it's not evaluated at this point
-      const numberOfLines = cell.isFormula ? 1 : cell.content.split(NEWLINE).length;
-      return computeTextLinesHeight(fontSize, numberOfLines) + 2 * PADDING_AUTORESIZE_VERTICAL;
-  }
-  function computeTextWidth(context, text, style) {
-      const font = computeTextFont(style);
-      if (!textWidthCache[font]) {
-          textWidthCache[font] = {};
-      }
-      if (textWidthCache[font][text] === undefined) {
-          context.save();
-          context.font = font;
-          const textWidth = context.measureText(text).width;
-          context.restore();
-          textWidthCache[font][text] = textWidth;
-      }
-      return textWidthCache[font][text];
-  }
-  const textWidthCache = {};
-  function fontSizeInPixels(fontSize) {
-      return Math.round((fontSize * 96) / 72);
-  }
-  function computeTextFont(style) {
-      const italic = style.italic ? "italic " : "";
-      const weight = style.bold ? "bold" : DEFAULT_FONT_WEIGHT;
-      const size = computeTextFontSizeInPixels(style);
-      return `${italic}${weight} ${size}px ${DEFAULT_FONT}`;
-  }
-  function computeTextFontSizeInPixels(style) {
-      const sizeInPt = style?.fontSize || DEFAULT_FONT_SIZE;
-      return fontSizeInPixels(sizeInPt);
-  }
-  /**
-   * Return the font size that makes the width of a text match the given line width.
-   * Minimum font size is 1.
-   *
-   * @param getTextWidth function that takes a fontSize as argument, and return the width of the text with this font size.
-   */
-  function getFontSizeMatchingWidth(lineWidth, maxFontSize, getTextWidth, precision = 0.25) {
-      let minFontSize = 1;
-      if (getTextWidth(minFontSize) > lineWidth)
-          return minFontSize;
-      if (getTextWidth(maxFontSize) < lineWidth)
-          return maxFontSize;
-      // Dichotomic search
-      let fontSize = (minFontSize + maxFontSize) / 2;
-      let currentTextWidth = getTextWidth(fontSize);
-      // Use a maximum number of iterations to be safe, because measuring text isn't 100% precise
-      let iterations = 0;
-      while (Math.abs(currentTextWidth - lineWidth) > precision && iterations < 20) {
-          if (currentTextWidth >= lineWidth) {
-              maxFontSize = (minFontSize + maxFontSize) / 2;
-          }
-          else {
-              minFontSize = (minFontSize + maxFontSize) / 2;
-          }
-          fontSize = (minFontSize + maxFontSize) / 2;
-          currentTextWidth = getTextWidth(fontSize);
-          iterations++;
-      }
-      return fontSize;
-  }
-  function computeIconWidth(style) {
-      return computeTextFontSizeInPixels(style) + 2 * MIN_CF_ICON_MARGIN;
-  }
   /**
    * Create a range from start (included) to end (excluded).
    * range(10, 13) => [10, 11, 12]
@@ -723,10 +648,6 @@
       Object.keys(cleanObject).forEach((key) => !cleanObject[key] && delete cleanObject[key]);
       return cleanObject;
   }
-  /** Transform a string to lower case. If the string is undefined, return an empty string */
-  function toLowerCase(str) {
-      return str ? str.toLowerCase() : "";
-  }
   function transpose2dArray(matrix, callback = (val) => val) {
       if (!matrix.length)
           return [];
@@ -815,6 +736,14 @@
               return cache.get(args[0]);
           },
       }[funcName];
+  }
+  function removeIndexesFromArray(array, indexes) {
+      return array.filter((_, index) => !indexes.includes(index));
+  }
+  function insertItemsAtIndex(array, items, index) {
+      const newArray = [...array];
+      newArray.splice(index, 0, ...items);
+      return newArray;
   }
 
   const RBA_REGEX = /rgba?\(|\s+|\)/gi;
@@ -958,13 +887,13 @@
       let g = rgba.g.toString(16);
       let b = rgba.b.toString(16);
       let a = Math.round(rgba.a * 255).toString(16);
-      if (r.length == 1)
+      if (r.length === 1)
           r = "0" + r;
-      if (g.length == 1)
+      if (g.length === 1)
           g = "0" + g;
-      if (b.length == 1)
+      if (b.length === 1)
           b = "0" + b;
-      if (a.length == 1)
+      if (a.length === 1)
           a = "0" + a;
       if (a === "ff")
           a = "";
@@ -1067,13 +996,13 @@
       let l = 0;
       // Calculate hue
       // No difference
-      if (delta == 0)
+      if (delta === 0)
           h = 0;
       // Red is max
-      else if (cMax == r)
+      else if (cMax === r)
           h = ((g - b) / delta) % 6;
       // Green is max
-      else if (cMax == g)
+      else if (cMax === g)
           h = (b - r) / delta + 2;
       // Blue is max
       else
@@ -1084,7 +1013,7 @@
           h += 360;
       l = (cMax + cMin) / 2;
       // Calculate saturation
-      s = delta == 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+      s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
       // Multiply l and s by 100
       s = +(s * 100).toFixed(1);
       l = +(l * 100).toFixed(1);
@@ -1521,7 +1450,7 @@
   }
   function isLeapYear(year) {
       const _year = Math.trunc(year);
-      return (_year % 4 === 0 && _year % 100 != 0) || _year % 400 == 0;
+      return (_year % 4 === 0 && _year % 100 != 0) || _year % 400 === 0;
   }
   function getYearFrac(startDate, endDate, _dayCountConvention) {
       if (startDate === endDate) {
@@ -2182,6 +2111,39 @@
       }
       return undefined;
   }
+  function createCurrencyFormat(currency) {
+      const decimalPlaces = currency.decimalPlaces ?? 2;
+      const position = currency.position ?? "before";
+      const code = currency.code ?? "";
+      const symbol = currency.symbol ?? "";
+      const decimalRepresentation = decimalPlaces ? "." + "0".repeat(decimalPlaces) : "";
+      const numberFormat = "#,##0" + decimalRepresentation;
+      let textExpression = `${code} ${symbol}`.trim();
+      if (position === "after" && code) {
+          textExpression = " " + textExpression;
+      }
+      return insertTextInFormat(textExpression, position, numberFormat);
+  }
+  function insertTextInFormat(text, position, format) {
+      const textExpression = `[$${text}]`;
+      return position === "before" ? textExpression + format : format + textExpression;
+  }
+  function roundFormat(format) {
+      const internalFormat = parseFormat(format);
+      const roundedFormat = internalFormat.map((formatPart) => {
+          if (formatPart.type === "NUMBER") {
+              return {
+                  type: formatPart.type,
+                  format: {
+                      ...formatPart.format,
+                      decimalPart: undefined,
+                  },
+              };
+          }
+          return formatPart;
+      });
+      return convertInternalFormatToFormat(roundedFormat);
+  }
   function createLargeNumberFormat(format, magnitude, postFix, locale) {
       const internalFormat = parseFormat(format || "#,##0");
       const largeNumberFormat = internalFormat
@@ -3275,6 +3237,169 @@
       return rows;
   }
 
+  function computeTextLinesHeight(textLineHeight, numberOfLines = 1) {
+      return numberOfLines * (textLineHeight + MIN_CELL_TEXT_MARGIN) - MIN_CELL_TEXT_MARGIN;
+  }
+  /**
+   * Get the default height of the cell given its style.
+   */
+  function getDefaultCellHeight(ctx, cell, colSize) {
+      if (!cell || !cell.content)
+          return DEFAULT_CELL_HEIGHT;
+      const maxWidth = cell.style?.wrapping ? colSize - 2 * MIN_CELL_TEXT_MARGIN : undefined;
+      const numberOfLines = cell.isFormula
+          ? 1
+          : splitTextToWidth(ctx, cell.content, cell.style, maxWidth).length;
+      const fontSize = computeTextFontSizeInPixels(cell.style);
+      return computeTextLinesHeight(fontSize, numberOfLines) + 2 * PADDING_AUTORESIZE_VERTICAL;
+  }
+  const textWidthCache = {};
+  function computeTextWidth(context, text, style) {
+      const font = computeTextFont(style);
+      if (!textWidthCache[font]) {
+          textWidthCache[font] = {};
+      }
+      if (textWidthCache[font][text] === undefined) {
+          context.save();
+          context.font = font;
+          const textWidth = context.measureText(text).width;
+          context.restore();
+          textWidthCache[font][text] = textWidth;
+      }
+      return textWidthCache[font][text];
+  }
+  function fontSizeInPixels(fontSize) {
+      return Math.round((fontSize * 96) / 72);
+  }
+  function computeTextFont(style) {
+      const italic = style.italic ? "italic " : "";
+      const weight = style.bold ? "bold" : DEFAULT_FONT_WEIGHT;
+      const size = computeTextFontSizeInPixels(style);
+      return `${italic}${weight} ${size}px ${DEFAULT_FONT}`;
+  }
+  function computeTextFontSizeInPixels(style) {
+      const sizeInPt = style?.fontSize || DEFAULT_FONT_SIZE;
+      return fontSizeInPixels(sizeInPt);
+  }
+  function splitWordToSpecificWidth(ctx, word, width, style) {
+      const wordWidth = computeTextWidth(ctx, word, style);
+      if (wordWidth <= width) {
+          return [word];
+      }
+      const splitWord = [];
+      let wordPart = "";
+      for (let l of word) {
+          const wordPartWidth = computeTextWidth(ctx, wordPart + l, style);
+          if (wordPartWidth > width) {
+              splitWord.push(wordPart);
+              wordPart = l;
+          }
+          else {
+              wordPart += l;
+          }
+      }
+      splitWord.push(wordPart);
+      return splitWord;
+  }
+  /**
+   * Return the given text, split in multiple lines if needed. The text will be split in multiple
+   * line if it contains NEWLINE characters, or if it's longer than the given width.
+   */
+  function splitTextToWidth(ctx, text, style, width) {
+      if (!style)
+          style = {};
+      const brokenText = [];
+      // Checking if text contains NEWLINE before split makes it very slightly slower if text contains it,
+      // but 5-10x faster if it doesn't
+      const lines = text.includes(NEWLINE) ? text.split(NEWLINE) : [text];
+      for (const line of lines) {
+          const words = line.includes(" ") ? line.split(" ") : [line];
+          if (!width) {
+              brokenText.push(line);
+              continue;
+          }
+          let textLine = "";
+          let availableWidth = width;
+          for (let word of words) {
+              const splitWord = splitWordToSpecificWidth(ctx, word, width, style);
+              const lastPart = splitWord.pop();
+              const lastPartWidth = computeTextWidth(ctx, lastPart, style);
+              // At this step: "splitWord" is an array composed of parts of word whose
+              // length is at most equal to "width".
+              // Last part contains the end of the word.
+              // Note that: When word length is less than width, then lastPart is equal
+              // to word and splitWord is empty
+              if (splitWord.length) {
+                  if (textLine !== "") {
+                      brokenText.push(textLine);
+                      textLine = "";
+                      availableWidth = width;
+                  }
+                  splitWord.forEach((wordPart) => {
+                      brokenText.push(wordPart);
+                  });
+                  textLine = lastPart;
+                  availableWidth = width - lastPartWidth;
+              }
+              else {
+                  // here "lastPart" is equal to "word" and the "word" size is smaller than "width"
+                  const _word = textLine === "" ? lastPart : " " + lastPart;
+                  const wordWidth = computeTextWidth(ctx, _word, style);
+                  if (wordWidth <= availableWidth) {
+                      textLine += _word;
+                      availableWidth -= wordWidth;
+                  }
+                  else {
+                      brokenText.push(textLine);
+                      textLine = lastPart;
+                      availableWidth = width - lastPartWidth;
+                  }
+              }
+          }
+          if (textLine !== "") {
+              brokenText.push(textLine);
+          }
+      }
+      return brokenText;
+  }
+  /**
+   * Return the font size that makes the width of a text match the given line width.
+   * Minimum font size is 1.
+   *
+   * @param getTextWidth function that takes a fontSize as argument, and return the width of the text with this font size.
+   */
+  function getFontSizeMatchingWidth(lineWidth, maxFontSize, getTextWidth, precision = 0.25) {
+      let minFontSize = 1;
+      if (getTextWidth(minFontSize) > lineWidth)
+          return minFontSize;
+      if (getTextWidth(maxFontSize) < lineWidth)
+          return maxFontSize;
+      // Dichotomic search
+      let fontSize = (minFontSize + maxFontSize) / 2;
+      let currentTextWidth = getTextWidth(fontSize);
+      // Use a maximum number of iterations to be safe, because measuring text isn't 100% precise
+      let iterations = 0;
+      while (Math.abs(currentTextWidth - lineWidth) > precision && iterations < 20) {
+          if (currentTextWidth >= lineWidth) {
+              maxFontSize = (minFontSize + maxFontSize) / 2;
+          }
+          else {
+              minFontSize = (minFontSize + maxFontSize) / 2;
+          }
+          fontSize = (minFontSize + maxFontSize) / 2;
+          currentTextWidth = getTextWidth(fontSize);
+          iterations++;
+      }
+      return fontSize;
+  }
+  function computeIconWidth(style) {
+      return computeTextFontSizeInPixels(style) + 2 * MIN_CF_ICON_MARGIN;
+  }
+  /** Transform a string to lower case. If the string is undefined, return an empty string */
+  function toLowerCase(str) {
+      return str ? str.toLowerCase() : "";
+  }
+
   /*
    * https://stackoverflow.com/questions/105034/create-guid-uuid-in-javascript
    * */
@@ -3297,7 +3422,7 @@
           else {
               // mainly for jest and other browsers that do not have the crypto functionality
               return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
-                  var r = (Math.random() * 16) | 0, v = c == "x" ? r : (r & 0x3) | 0x8;
+                  var r = (Math.random() * 16) | 0, v = c === "x" ? r : (r & 0x3) | 0x8;
                   return v.toString(16);
               });
           }
@@ -4125,6 +4250,7 @@
       CommandResult[CommandResult["NoSplitSeparatorInSelection"] = 92] = "NoSplitSeparatorInSelection";
       CommandResult[CommandResult["NoActiveSheet"] = 93] = "NoActiveSheet";
       CommandResult[CommandResult["InvalidLocale"] = 94] = "InvalidLocale";
+      CommandResult[CommandResult["AlreadyInPaintingFormatMode"] = 95] = "AlreadyInPaintingFormatMode";
   })(exports.CommandResult || (exports.CommandResult = {}));
 
   const borderStyles = ["thin", "medium", "thick", "dashed", "dotted"];
@@ -5940,8 +6066,8 @@
           return this.props.menuItems.some((menuItem) => !!menuItem.icon || !!menuItem.isActive);
       }
       getIconName(menu) {
-          if (menu.icon) {
-              return menu.icon;
+          if (menu.icon(this.env)) {
+              return menu.icon(this.env);
           }
           if (menu.isActive?.(this.env)) {
               return "o-spreadsheet-Icon.CHECK";
@@ -6375,7 +6501,7 @@
       for (let pivot = 0; pivot < dim; pivot++) {
           let diagonalElement = C[pivot][pivot];
           // if we have a 0 on the diagonal we'll need to swap with a lower row
-          if (diagonalElement == 0) {
+          if (diagonalElement === 0) {
               //look through every row below the i'th row
               for (let row = pivot + 1; row < dim; row++) {
                   //if the ii'th row has a non-0 in the i'th col, swap it with that row
@@ -6402,7 +6528,7 @@
           // the other rows so that there will be 0's in this column in the
           // rows above and below this one
           for (let row = 0; row < dim; row++) {
-              if (row == pivot) {
+              if (row === pivot) {
                   continue;
               }
               // We want to change this element to 0
@@ -12467,7 +12593,7 @@
               return false;
           }
           catch (e) {
-              return e?.errorType == CellErrorType.NotAvailable;
+              return e?.errorType === CellErrorType.NotAvailable;
           }
       },
       isExported: true,
@@ -12593,6 +12719,18 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // FALSE
+  // -----------------------------------------------------------------------------
+  const FALSE = {
+      description: _lt("Logical value `false`."),
+      args: [],
+      returns: ["BOOLEAN"],
+      compute: function () {
+          return false;
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
   // IF
   // -----------------------------------------------------------------------------
   const IF = {
@@ -12728,6 +12866,18 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // TRUE
+  // -----------------------------------------------------------------------------
+  const TRUE = {
+      description: _lt("Logical value `true`."),
+      args: [],
+      returns: ["BOOLEAN"],
+      compute: function () {
+          return true;
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
   // XOR
   // -----------------------------------------------------------------------------
   const XOR = {
@@ -12754,12 +12904,14 @@
   var logical = /*#__PURE__*/Object.freeze({
     __proto__: null,
     AND: AND,
+    FALSE: FALSE,
     IF: IF,
     IFERROR: IFERROR,
     IFNA: IFNA,
     IFS: IFS,
     NOT: NOT,
     OR: OR,
+    TRUE: TRUE,
     XOR: XOR
   });
 
@@ -13946,7 +14098,6 @@
    * is useful for the composer, which needs to be able to work with incomplete
    * formulas.
    */
-  const functions$3 = functionRegistry.content;
   const POSTFIX_UNARY_OPERATORS = ["%"];
   const OPERATORS = "+,-,*,/,:,=,<>,>=,>,<=,<,^,&".split(",").concat(POSTFIX_UNARY_OPERATORS);
   function tokenize(str, locale = DEFAULT_LOCALE) {
@@ -14077,17 +14228,11 @@
       }
       if (result.length) {
           const value = result;
-          const isFunction = value.toUpperCase() in functions$3;
-          if (isFunction) {
-              return { type: "FUNCTION", value };
-          }
           const isReference = rangeReference.test(value);
           if (isReference) {
               return { type: "REFERENCE", value };
           }
-          else {
-              return { type: "SYMBOL", value };
-          }
+          return { type: "SYMBOL", value };
       }
       return null;
   }
@@ -14187,9 +14332,6 @@
               return { type: "NUMBER", value: parseNumber(current.value, DEFAULT_LOCALE) };
           case "STRING":
               return { type: "STRING", value: removeStringQuotes(current.value) };
-          case "FUNCTION":
-              const args = parseFunctionArgs(tokens);
-              return { type: "FUNCALL", value: current.value, args };
           case "INVALID_REFERENCE":
               throw new InvalidReferenceError();
           case "REFERENCE":
@@ -14206,13 +14348,15 @@
                   value: current.value,
               };
           case "SYMBOL":
-              if (["TRUE", "FALSE"].includes(current.value.toUpperCase())) {
-                  return { type: "BOOLEAN", value: current.value.toUpperCase() === "TRUE" };
+              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 };
               }
-              if (current.value) {
-                  if (functionRegex.test(current.value) && tokens[0]?.type === "LEFT_PAREN") {
-                      throw new UnknownFunctionError(current.value);
-                  }
+              const upperCaseValue = value.toUpperCase();
+              if (upperCaseValue === "TRUE" || upperCaseValue === "FALSE") {
+                  return { type: "BOOLEAN", value: upperCaseValue === "TRUE" };
               }
               throw new BadExpressionError(_lt("Invalid formula"));
           case "LEFT_PAREN":
@@ -14314,36 +14458,60 @@
    * to nodes of a specific type.
    * Useful if you want to convert some part of a formula.
    *
-   * e.g.
-   * ```ts
+   * @example
    * convertAstNodes(ast, "FUNCALL", convertFormulaToExcel)
    *
    * function convertFormulaToExcel(ast: ASTFuncall) {
    *   // ...
    *   return modifiedAst
    * }
-   * ```
    */
   function convertAstNodes(ast, type, fn) {
-      if (type === ast.type) {
-          ast = fn(ast);
+      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) => convertAstNodes(child, type, fn)),
+                  args: ast.args.map((child) => mapAst(child, fn)),
               };
           case "UNARY_OPERATION":
               return {
                   ...ast,
-                  operand: convertAstNodes(ast.operand, type, fn),
+                  operand: mapAst(ast.operand, fn),
               };
           case "BIN_OPERATION":
               return {
                   ...ast,
-                  right: convertAstNodes(ast.right, type, fn),
-                  left: convertAstNodes(ast.left, type, fn),
+                  right: mapAst(ast.right, fn),
+                  left: mapAst(ast.left, fn),
               };
           default:
               return ast;
@@ -14613,6 +14781,9 @@
               const { args } = ast;
               const functionName = ast.value.toUpperCase();
               const functionDefinition = functions$2[functionName];
+              if (!functionDefinition) {
+                  throw new UnknownFunctionError(ast.value);
+              }
               assertEnoughArgs(ast);
               const compiledArgs = [];
               for (let i = 0; i < args.length; i++) {
@@ -14871,7 +15042,7 @@
               functionStarted = "";
           }
           switch (token.type) {
-              case "FUNCTION":
+              case "SYMBOL":
                   functionStarted = token.value;
                   break;
               case "LEFT_PAREN":
@@ -14908,6 +15079,17 @@
       return mapParentFunction(mapParenthesis(enrichTokens(tokens)));
   }
 
+  const functions$1 = functionRegistry.content;
+  function isExportableToExcel(tokens) {
+      try {
+          const nonExportableFunctions = iterateAstNodes(parseTokens(tokens)).filter((ast) => ast.type === "FUNCALL" && !functions$1[ast.value.toUpperCase()]?.isExported);
+          return nonExportableFunctions.length === 0;
+      }
+      catch (error) {
+          return false;
+      }
+  }
+
   function isValidLocale(locale) {
       if (!(locale &&
           typeof locale === "object" &&
@@ -15127,6 +15309,8 @@
   function createAction(item) {
       const name = item.name;
       const children = item.children;
+      const description = item.description;
+      const icon = item.icon;
       return {
           id: item.id || uuidGenerator$2.uuidv4(),
           name: typeof name === "function" ? name : () => name,
@@ -15144,8 +15328,8 @@
               : () => [],
           isReadonlyAllowed: item.isReadonlyAllowed || false,
           separator: item.separator || false,
-          icon: item.icon || "",
-          description: item.description || "",
+          icon: typeof icon === "function" ? icon : () => icon || "",
+          description: typeof description === "function" ? description : () => description || "",
           textColor: item.textColor,
           sequence: item.sequence || 0,
       };
@@ -16611,7 +16795,7 @@
   function convertDateFormatForMoment(format) {
       format = format.replace(/y/g, "Y");
       format = format.replace(/d/g, "D");
-      // "m" before "h" == month, "m" after "h" == minute
+      // "m" before "h" === month, "m" after "h" === minute
       const indexH = format.indexOf("h");
       if (indexH >= 0) {
           format = format.slice(0, indexH).replace(/m/g, "M") + format.slice(indexH);
@@ -17465,6 +17649,7 @@
                   env.model.dispatch("SELECT_FIGURE", { id: figureId });
                   env.openSidePanel("ChartPanel");
               },
+              icon: "o-spreadsheet-Icon.EDIT",
           },
           getCopyMenuItem(figureId, env),
           getCutMenuItem(figureId, env),
@@ -17480,8 +17665,14 @@
               id: "reset_size",
               name: _lt("Reset size"),
               sequence: 4,
-              execute: () => {
-                  const size = env.model.getters.getImageSize(figureId);
+              execute: async () => {
+                  const imagePath = env.model.getters.getImagePath(figureId);
+                  const size = env.model.getters.getImageSize(figureId) ??
+                      (await env.imageProvider?.getImageOriginalSize(imagePath));
+                  if (!env.model.getters.getImageSize(figureId)) {
+                      const image = env.model.getters.getImage(figureId);
+                      image.size = size;
+                  }
                   const { height, width } = getMaxFigureSize(env.model.getters, size);
                   env.model.dispatch("UPDATE_FIGURE", {
                       sheetId: env.model.getters.getActiveSheetId(),
@@ -17490,6 +17681,7 @@
                       width,
                   });
               },
+              icon: "o-spreadsheet-Icon.REFRESH",
           },
           getDeleteMenuItem(figureId, onFigureDeleted, env),
       ];
@@ -17506,6 +17698,7 @@
               env.model.dispatch("COPY");
               await env.clipboard.write(env.model.getters.getClipboardContent());
           },
+          icon: "o-spreadsheet-Icon.COPY",
       };
   }
   function getCutMenuItem(figureId, env) {
@@ -17519,6 +17712,7 @@
               env.model.dispatch("CUT");
               await env.clipboard.write(env.model.getters.getClipboardContent());
           },
+          icon: "o-spreadsheet-Icon.CUT",
       };
   }
   function getDeleteMenuItem(figureId, onFigureDeleted, env) {
@@ -17533,6 +17727,7 @@
               });
               onFigureDeleted();
           },
+          icon: "o-spreadsheet-Icon.DELETE",
       };
   }
 
@@ -18600,7 +18795,7 @@
   };
   const categorieFunctionAll = {
       name: _lt("All"),
-      children: allFunctionListMenuBuilder(),
+      children: [allFunctionListMenuBuilder],
   };
   function allFunctionListMenuBuilder() {
       const fnNames = functionRegistry.getKeys();
@@ -18932,7 +19127,10 @@
   };
   const formatNumberNumber = {
       name: _lt("Number"),
-      description: "1,000.12",
+      description: (env) => formatValue(1000.12, {
+          format: "#,##0.00",
+          locale: env.model.getters.getLocale(),
+      }),
       execute: (env) => setFormatter(env, "#,##0.00"),
       isActive: (env) => isFormatSelected(env, "#,##0.00"),
   };
@@ -18943,21 +19141,34 @@
   };
   const formatNumberPercent = {
       name: _lt("Percent"),
-      description: "10.12%",
+      description: (env) => formatValue(0.1012, {
+          format: "0.00%",
+          locale: env.model.getters.getLocale(),
+      }),
       execute: FORMAT_PERCENT_ACTION,
       isActive: (env) => isFormatSelected(env, "0.00%"),
   };
   const formatNumberCurrency = {
       name: _lt("Currency"),
-      description: "$1,000.12",
-      execute: (env) => setFormatter(env, "[$$]#,##0.00"),
-      isActive: (env) => isFormatSelected(env, "[$$]#,##0.00"),
+      description: (env) => formatValue(1000.12, {
+          format: env.model.config.defaultCurrencyFormat,
+          locale: env.model.getters.getLocale(),
+      }),
+      execute: (env) => setFormatter(env, env.model.config.defaultCurrencyFormat),
+      isActive: (env) => isFormatSelected(env, env.model.config.defaultCurrencyFormat),
   };
   const formatNumberCurrencyRounded = {
       name: _lt("Currency rounded"),
-      description: "$1,000",
-      execute: (env) => setFormatter(env, "[$$]#,##0"),
-      isActive: (env) => isFormatSelected(env, "[$$]#,##0"),
+      description: (env) => formatValue(1000, {
+          format: roundFormat(env.model.config.defaultCurrencyFormat),
+          locale: env.model.getters.getLocale(),
+      }),
+      execute: (env) => setFormatter(env, roundFormat(env.model.config.defaultCurrencyFormat)),
+      isActive: (env) => isFormatSelected(env, roundFormat(env.model.config.defaultCurrencyFormat)),
+      isVisible: (env) => {
+          const currencyFormat = env.model.config.defaultCurrencyFormat;
+          return currencyFormat !== roundFormat(currencyFormat);
+      },
   };
   const formatCustomCurrency = {
       name: _lt("Custom currency"),
@@ -18966,19 +19177,37 @@
   };
   const formatNumberDate = {
       name: _lt("Date"),
-      description: "9/26/2008",
+      description: (env) => {
+          const locale = env.model.getters.getLocale();
+          return formatValue(parseLiteral("9/26/2023", DEFAULT_LOCALE), {
+              format: locale.dateFormat,
+              locale,
+          });
+      },
       execute: (env) => setFormatter(env, env.model.getters.getLocale().dateFormat),
       isActive: (env) => isFormatSelected(env, env.model.getters.getLocale().dateFormat),
   };
   const formatNumberTime = {
       name: _lt("Time"),
-      description: "10:43:00 PM",
+      description: (env) => {
+          const locale = env.model.getters.getLocale();
+          return formatValue(parseLiteral("9/26/2023 10:43:00 PM", DEFAULT_LOCALE), {
+              format: locale.timeFormat,
+              locale,
+          });
+      },
       execute: (env) => setFormatter(env, env.model.getters.getLocale().timeFormat),
       isActive: (env) => isFormatSelected(env, env.model.getters.getLocale().timeFormat),
   };
   const formatNumberDateTime = {
       name: _lt("Date time"),
-      description: "9/26/2008 22:43:00",
+      description: (env) => {
+          const locale = env.model.getters.getLocale();
+          return formatValue(parseLiteral("9/26/2023 22:43:00", DEFAULT_LOCALE), {
+              format: locale.dateFormat + " " + locale.timeFormat,
+              locale,
+          });
+      },
       execute: (env) => {
           const locale = env.model.getters.getLocale();
           setFormatter(env, locale.dateFormat + " " + locale.timeFormat);
@@ -19050,7 +19279,7 @@
   };
   const formatAlignmentHorizontal = {
       name: _lt("Horizontal align"),
-      icon: "o-spreadsheet-Icon.ALIGN_LEFT",
+      icon: (env) => getHorizontalAlignmentIcon(env),
   };
   const formatAlignmentLeft = {
       name: _lt("Left"),
@@ -19075,46 +19304,50 @@
   };
   const formatAlignmentVertical = {
       name: _lt("Vertical align"),
-      icon: "o-spreadsheet-Icon.ALIGN_MIDDLE",
+      icon: (env) => getVerticalAlignmentIcon(env),
   };
   const formatAlignmentTop = {
       name: _lt("Top"),
       execute: (env) => setStyle(env, { verticalAlign: "top" }),
-      isActive: (env) => (env.model.getters.getCurrentStyle().verticalAlign || DEFAULT_VERTICAL_ALIGN) === "top",
+      isActive: (env) => getVerticalAlign(env) === "top",
       icon: "o-spreadsheet-Icon.ALIGN_TOP",
   };
   const formatAlignmentMiddle = {
       name: _lt("Middle"),
       execute: (env) => setStyle(env, { verticalAlign: "middle" }),
-      isActive: (env) => (env.model.getters.getCurrentStyle().verticalAlign || DEFAULT_VERTICAL_ALIGN) === "middle",
+      isActive: (env) => getVerticalAlign(env) === "middle",
       icon: "o-spreadsheet-Icon.ALIGN_MIDDLE",
   };
   const formatAlignmentBottom = {
       name: _lt("Bottom"),
       execute: (env) => setStyle(env, { verticalAlign: "bottom" }),
-      isActive: (env) => (env.model.getters.getCurrentStyle().verticalAlign || DEFAULT_VERTICAL_ALIGN) === "bottom",
+      isActive: (env) => getVerticalAlign(env) === "bottom",
       icon: "o-spreadsheet-Icon.ALIGN_BOTTOM",
   };
-  const formatWrapping = {
+  const formatWrappingIcon = {
       name: _lt("Wrapping"),
       icon: "o-spreadsheet-Icon.WRAPPING_OVERFLOW",
   };
+  const formatWrapping = {
+      name: _lt("Wrapping"),
+      icon: (env) => getWrapModeIcon(env),
+  };
   const formatWrappingOverflow = {
       name: _lt("Overflow"),
       execute: (env) => setStyle(env, { wrapping: "overflow" }),
-      isActive: (env) => (env.model.getters.getCurrentStyle().wrapping || "overflow") === "overflow",
+      isActive: (env) => getWrappingMode(env) === "overflow",
       icon: "o-spreadsheet-Icon.WRAPPING_OVERFLOW",
   };
   const formatWrappingWrap = {
       name: _lt("Wrap"),
       execute: (env) => setStyle(env, { wrapping: "wrap" }),
-      isActive: (env) => env.model.getters.getCurrentStyle().wrapping === "wrap",
+      isActive: (env) => getWrappingMode(env) === "wrap",
       icon: "o-spreadsheet-Icon.WRAPPING_WRAP",
   };
   const formatWrappingClip = {
       name: _lt("Clip"),
       execute: (env) => setStyle(env, { wrapping: "clip" }),
-      isActive: (env) => env.model.getters.getCurrentStyle().wrapping === "clip",
+      isActive: (env) => getWrappingMode(env) === "clip",
       icon: "o-spreadsheet-Icon.WRAPPING_CLIP",
   };
   const textColor = {
@@ -19130,14 +19363,6 @@
       execute: OPEN_CF_SIDEPANEL_ACTION,
       icon: "o-spreadsheet-Icon.CONDITIONAL_FORMAT",
   };
-  const paintFormat = {
-      name: _lt("Paint Format"),
-      execute: (env) => env.model.dispatch("ACTIVATE_PAINT_FORMAT", {
-          target: env.model.getters.getSelectedZones(),
-      }),
-      icon: "o-spreadsheet-Icon.PAINT_FORMAT",
-      isActive: (env) => env.model.getters.isPaintingFormat(),
-  };
   const clearFormat = {
       name: _lt("Clear formatting"),
       description: "Ctrl+<",
@@ -19177,6 +19402,53 @@
       }
       const cell = env.model.getters.getActiveCell();
       return cell.defaultAlign;
+  }
+  function getVerticalAlign(env) {
+      const style = env.model.getters.getCurrentStyle();
+      if (style.verticalAlign) {
+          return style.verticalAlign;
+      }
+      return DEFAULT_VERTICAL_ALIGN;
+  }
+  function getWrappingMode(env) {
+      const style = env.model.getters.getCurrentStyle();
+      if (style.wrapping) {
+          return style.wrapping;
+      }
+      return DEFAULT_WRAPPING_MODE;
+  }
+  function getHorizontalAlignmentIcon(env) {
+      const horizontalAlign = getHorizontalAlign(env);
+      switch (horizontalAlign) {
+          case "right":
+              return "o-spreadsheet-Icon.ALIGN_RIGHT";
+          case "center":
+              return "o-spreadsheet-Icon.ALIGN_CENTER";
+          default:
+              return "o-spreadsheet-Icon.ALIGN_LEFT";
+      }
+  }
+  function getVerticalAlignmentIcon(env) {
+      const verticalAlign = getVerticalAlign(env);
+      switch (verticalAlign) {
+          case "top":
+              return "o-spreadsheet-Icon.ALIGN_TOP";
+          case "middle":
+              return "o-spreadsheet-Icon.ALIGN_MIDDLE";
+          default:
+              return "o-spreadsheet-Icon.ALIGN_BOTTOM";
+      }
+  }
+  function getWrapModeIcon(env) {
+      const wrapMode = getWrappingMode(env);
+      switch (wrapMode) {
+          case "wrap":
+              return "o-spreadsheet-Icon.WRAPPING_WRAP";
+          case "clip":
+              return "o-spreadsheet-Icon.WRAPPING_CLIP";
+          default:
+              return "o-spreadsheet-Icon.WRAPPING_OVERFLOW";
+      }
   }
 
   var ACTION_FORMAT = /*#__PURE__*/Object.freeze({
@@ -19208,6 +19480,7 @@
     formatAlignmentTop: formatAlignmentTop,
     formatAlignmentMiddle: formatAlignmentMiddle,
     formatAlignmentBottom: formatAlignmentBottom,
+    formatWrappingIcon: formatWrappingIcon,
     formatWrapping: formatWrapping,
     formatWrappingOverflow: formatWrappingOverflow,
     formatWrappingWrap: formatWrappingWrap,
@@ -19215,7 +19488,6 @@
     textColor: textColor,
     fillColor: fillColor,
     formatCF: formatCF,
-    paintFormat: paintFormat,
     clearFormat: clearFormat
   });
 
@@ -19978,7 +20250,7 @@
       separator: true,
   })
       .addChild("format_wrapping", ["format"], {
-      ...formatWrapping,
+      ...formatWrappingIcon,
       sequence: 80,
       separator: true,
   })
@@ -22268,17 +22540,45 @@
       }
       get formatProposals() {
           const currency = this.availableCurrencies[this.state.selectedCurrencyIndex];
-          const proposalBases = this.initProposalBases(currency.decimalPlaces);
-          const firstPosition = currency.position;
-          const secondPosition = currency.position === "before" ? "after" : "before";
+          const position = currency.position;
+          const opposite = currency.position === "before" ? "after" : "before";
           const symbol = this.state.currencySymbol.trim() ? this.state.currencySymbol : "";
           const code = this.state.currencyCode.trim() ? this.state.currencyCode : "";
-          return code || symbol
-              ? [
-                  ...this.createFormatProposals(proposalBases, symbol, code, firstPosition),
-                  ...this.createFormatProposals(proposalBases, symbol, code, secondPosition),
-              ]
-              : [];
+          const decimalPlaces = currency.decimalPlaces;
+          if (!symbol && !code) {
+              return [];
+          }
+          const simple = symbol ? createCurrencyFormat({ symbol, position, decimalPlaces }) : "";
+          const rounded = simple ? roundFormat(simple) : "";
+          const simpleWithCode = createCurrencyFormat({ symbol, position, decimalPlaces, code });
+          const roundedWithCode = roundFormat(simpleWithCode);
+          const simpleOpposite = symbol
+              ? createCurrencyFormat({ symbol, position: opposite, decimalPlaces })
+              : "";
+          const roundedOpposite = simpleOpposite ? roundFormat(simpleOpposite) : "";
+          const simpleOppositeWithCode = createCurrencyFormat({
+              symbol,
+              position: opposite,
+              decimalPlaces,
+              code,
+          });
+          const roundedOppositeWithCode = roundFormat(simpleOppositeWithCode);
+          const formats = new Set([
+              rounded,
+              simple,
+              roundedWithCode,
+              simpleWithCode,
+              roundedOpposite,
+              simpleOpposite,
+              roundedOppositeWithCode,
+              simpleOppositeWithCode,
+          ]);
+          return [...formats]
+              .filter((format) => format !== "")
+              .map((format) => ({
+              format,
+              example: formatValue(1000.0, { format, locale: this.env.model.getters.getLocale() }),
+          }));
       }
       get isSameFormat() {
           const selectedFormat = this.formatProposals[this.state.selectedFormatIndex];
@@ -22335,41 +22635,6 @@
       initAvailableCurrencies() {
           this.state.selectedCurrencyIndex = 0;
       }
-      initProposalBases(decimalPlaces) {
-          const result = [{ format: "#,##0", example: "1,000" }];
-          const decimalRepresentation = decimalPlaces ? "." + "0".repeat(decimalPlaces) : "";
-          if (decimalRepresentation) {
-              result.push({
-                  format: "#,##0" + decimalRepresentation,
-                  example: "1,000" + decimalRepresentation,
-              });
-          }
-          return result;
-      }
-      createFormatProposals(proposalBases, symbol, code, position) {
-          let formatProposals = [];
-          // 1 - add proposal with symbol and without code
-          if (symbol) {
-              for (let base of proposalBases) {
-                  formatProposals.push(this.createFormatProposal(position, base.example, base.format, symbol));
-              }
-          }
-          // 2 - if code exist --> add more proposal with symbol and with code
-          if (code) {
-              for (let base of proposalBases) {
-                  const expression = (position === "after" ? " " : "") + code + " " + symbol;
-                  formatProposals.push(this.createFormatProposal(position, base.example, base.format, expression));
-              }
-          }
-          return formatProposals;
-      }
-      createFormatProposal(position, baseExample, formatBase, expression) {
-          const formatExpression = "[$" + expression + "]";
-          return {
-              example: position === "before" ? expression + baseExample : baseExample + expression,
-              format: position === "before" ? formatExpression + formatBase : formatBase + formatExpression,
-          };
-      }
       getCommonFormat() {
           const selectedZones = this.env.model.getters.getSelectedZones();
           const sheetId = this.env.model.getters.getActiveSheetId();
@@ -23172,7 +23437,7 @@
               selection.removeAllRanges();
               selection.addRange(range);
           }
-          if (start == end && start === 0) {
+          if (start === end && start === 0) {
               range.setStart(this.el, 0);
               range.setEnd(this.el, 0);
           }
@@ -23425,7 +23690,7 @@
                   }, 0);
               }
           }
-          if (nodeToFind.nodeName === "P" && !isFirstParagraph && nodeToFind.textContent == "") {
+          if (nodeToFind.nodeName === "P" && !isFirstParagraph && nodeToFind.textContent === "") {
               usedCharacters++;
           }
           return usedCharacters;
@@ -23534,7 +23799,7 @@
       argToFocus: Number,
   };
 
-  const functions$1 = functionRegistry.content;
+  const functions = functionRegistry.content;
   const ASSISTANT_WIDTH = 300;
   const selectionIndicatorClass = "selector-flag";
   const selectionIndicatorColor = "#a9a9a9";
@@ -23568,10 +23833,6 @@
       padding-right: 3px;
       outline: none;
 
-      &.unfocusable {
-        pointer-events: none;
-      }
-
       p {
         margin-bottom: 0px;
 
@@ -23819,7 +24080,10 @@
           }
       }
       showAutocomplete(searchTerm) {
-          if (!this.env.model.getters.getCurrentContent().startsWith("=")) {
+          const searchTermUpperCase = searchTerm.toUpperCase();
+          if (!this.env.model.getters.getCurrentContent().startsWith("=") ||
+              searchTermUpperCase === "TRUE" ||
+              searchTermUpperCase === "FALSE") {
               return;
           }
           this.autoCompleteState.showProvider = true;
@@ -23937,7 +24201,6 @@
               switch (token.type) {
                   case "OPERATOR":
                   case "NUMBER":
-                  case "FUNCTION":
                   case "ARG_SEPARATOR":
                   case "STRING":
                       result.push({ value: token.value, color: tokenColors[token.type] || "#000" });
@@ -23947,10 +24210,14 @@
                       result.push({ value: token.value, color: this.rangeColor(xc, sheetName) || "#000" });
                       break;
                   case "SYMBOL":
-                      let value = token.value;
-                      if (["TRUE", "FALSE"].includes(value.toUpperCase())) {
+                      const value = token.value;
+                      const upperCaseValue = value.toUpperCase();
+                      if (upperCaseValue === "TRUE" || upperCaseValue === "FALSE") {
                           result.push({ value: token.value, color: tokenColors.NUMBER });
                       }
+                      else if (upperCaseValue in functionRegistry.content) {
+                          result.push({ value: token.value, color: tokenColors.FUNCTION });
+                      }
                       else {
                           result.push({ value: token.value, color: "#000" });
                       }
@@ -24046,25 +24313,28 @@
           this.autoCompleteState.showProvider = false;
           this.functionDescriptionState.showDescription = false;
           if (content.startsWith("=")) {
-              const tokenAtCursor = this.env.model.getters.getTokenAtCursor();
-              if (tokenAtCursor) {
-                  const { xc } = splitReference(tokenAtCursor.value);
-                  if (tokenAtCursor.type === "FUNCTION" ||
-                      (tokenAtCursor.type === "SYMBOL" && !rangeReference.test(xc))) {
-                      // initialize Autocomplete Dropdown
-                      this.showAutocomplete(tokenAtCursor.value);
-                  }
-                  else if (tokenAtCursor.functionContext && tokenAtCursor.type !== "UNKNOWN") {
-                      // initialize Formula Assistant
-                      const tokenContext = tokenAtCursor.functionContext;
-                      const parentFunction = tokenContext.parent.toUpperCase();
-                      const description = functions$1[parentFunction];
-                      const argPosition = tokenContext.argPosition;
-                      this.functionDescriptionState.functionName = parentFunction;
-                      this.functionDescriptionState.functionDescription = description;
-                      this.functionDescriptionState.argToFocus = description.getArgToFocus(argPosition + 1) - 1;
-                      this.functionDescriptionState.showDescription = true;
-                  }
+              const token = this.env.model.getters.getTokenAtCursor();
+              if (!token) {
+                  return;
+              }
+              if (token.type === "SYMBOL") {
+                  // initialize Autocomplete Dropdown
+                  this.showAutocomplete(token.value);
+                  return;
+              }
+              const tokenContext = token.functionContext;
+              const parentFunction = tokenContext?.parent.toUpperCase();
+              if (tokenContext &&
+                  parentFunction &&
+                  parentFunction in functions &&
+                  token.type !== "UNKNOWN") {
+                  // initialize Formula Assistant
+                  const description = functions[parentFunction];
+                  const argPosition = tokenContext.argPosition;
+                  this.functionDescriptionState.functionName = parentFunction;
+                  this.functionDescriptionState.functionDescription = description;
+                  this.functionDescriptionState.argToFocus = description.getArgToFocus(argPosition + 1) - 1;
+                  this.functionDescriptionState.showDescription = true;
               }
           }
       }
@@ -24967,6 +25237,14 @@
       };
   }
 
+  const CURSOR_SVG = /*xml*/ `
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="14" height="16"><path d="M6.5.4c1.3-.8 2.9-.1 3.8 1.4l2.9 5.1c.2.4.9 1.6-.4 2.3l-1.6.9 1.8 3.1c.2.4.1 1-.2 1.2l-1.6 1c-.3.1-.9 0-1.1-.4l-1.8-3.1-1.6 1c-.6.4-1.7 0-2.2-.8L0 4.3"/><path fill="#fff" d="M9.1 2a1.4 1.1 60 0 0-1.7-.6L5.5 2.5l.9 1.6-1 .6-.9-1.6-.6.4 1.8 3.1-1.3.7-1.8-3.1-1 .6 3.8 6.6 6.8-3.98M3.9 8.8 10.82 5l.795 1.4-6.81 3.96"/></svg>
+`;
+  css /* scss */ `
+  .o-paint-format-cursor {
+    cursor: url("data:image/svg+xml,${encodeURIComponent(CURSOR_SVG)}"), auto;
+  }
+`;
   function useCellHovered(env, gridRef, callback) {
       let hoveredPosition = {
           col: undefined,
@@ -25090,6 +25368,12 @@
           }
           return this.gridOverlay.el;
       }
+      get style() {
+          return this.props.gridOverlayDimensions;
+      }
+      get isPaintingFormat() {
+          return this.env.model.getters.isPaintingFormat();
+      }
       onMouseDown(ev) {
           if (ev.button > 0) {
               // not main button, probably a context menu
@@ -26267,6 +26551,9 @@
               else if (this.menuState.isOpen) {
                   this.closeMenu();
               }
+              else if (this.env.model.getters.isPaintingFormat()) {
+                  this.env.model.dispatch("CANCEL_PAINT_FORMAT");
+              }
               else {
                   this.env.model.dispatch("CLEAN_CLIPBOARD_HIGHLIGHT");
               }
@@ -26764,7 +27051,12 @@
   };
   const RELATIONSHIP_NSR = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
   const HEIGHT_FACTOR = 0.75; // 100px => 75 u
-  const WIDTH_FACTOR = 0.1317; // 100px => 13.17 u
+  /**
+   * Excel says its default column width is 8.43 characters (64px)
+   * which makes WIDTH_FACTOR = 0.1317, but it doesn't work well
+   * 0.143 is a value from dev's experiments.
+   */
+  const WIDTH_FACTOR = 0.143;
   /** unit : maximum number of characters a column can hold at the standard font size. What. */
   const EXCEL_DEFAULT_COL_WIDTH = 8.43;
   /** unit : points */
@@ -27281,7 +27573,7 @@
       64: "000000",
       65: "FFFFFF", // system background
   };
-  const IMAGE_MIMETYPE_EXTENSION_MAPPING = {
+  const IMAGE_MIMETYPE_TO_EXTENSION_MAPPING = {
       "image/avif": "avif",
       "image/bmp": "bmp",
       "image/gif": "gif",
@@ -27290,6 +27582,17 @@
       "image/png": "png",
       "image/tiff": "tiff",
       "image/webp": "webp",
+  };
+  const IMAGE_EXTENSION_TO_MIMETYPE_MAPPING = {
+      avif: "image/avif",
+      bmp: "image/bmp",
+      gif: "image/gif",
+      ico: "image/vnd.microsoft.icon",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      tiff: "image/tiff",
+      webp: "image/webp",
+      jpg: "image/jpeg",
   };
 
   /**
@@ -27453,8 +27756,8 @@
                   throw new Error("Multiple escaped blocks in format");
               }
               convertedFormat = convertedFormat.replace(/"(.*)"/g, "[$$$1]"); // replace '"..."' by '[$...]'
-              convertedFormat = convertedFormat.replace(/_.{1}/g, ""); // _ == ignore width of next char for align purposes. Not supported ATM
-              convertedFormat = convertedFormat.replace(/\*.{1}/g, ""); // * == repeat next character enough to fill the line. Not supported ATM
+              convertedFormat = convertedFormat.replace(/_.{1}/g, ""); // _ === ignore width of next char for align purposes. Not supported ATM
+              convertedFormat = convertedFormat.replace(/\*.{1}/g, ""); // * === repeat next character enough to fill the line. Not supported ATM
               convertedFormat = convertedFormat.replace(/\\ /g, " "); // unescape spaces
               convertedFormat = convertedFormat.replace(/\\./g, (match) => match[1]); // unescape other characters
               if (isXlsxDateFormat(convertedFormat)) {
@@ -28093,20 +28396,35 @@
           convertEMUToDotValue(figure.anchors[0].rowOffset);
       const y2 = getRowPosition(figure.anchors[1].row, sheetData) +
           convertEMUToDotValue(figure.anchors[1].rowOffset);
-      const width = x2 - x1;
-      const height = y2 - y1;
-      const chartData = convertChartData(figure.data);
-      if (!chartData)
-          return undefined;
-      return {
-          id: id,
-          x: x1,
-          y: y1,
-          width: width,
-          height: height,
-          tag: "chart",
-          data: convertChartData(figure.data),
-      };
+      const figureData = { id, x: x1, y: y1 };
+      if (isChartData(figure.data)) {
+          return {
+              ...figureData,
+              width: x2 - x1,
+              height: y2 - y1,
+              tag: "chart",
+              data: convertChartData(figure.data),
+          };
+      }
+      else if (isImageData(figure.data)) {
+          return {
+              ...figureData,
+              width: convertEMUToDotValue(figure.data.size.cx),
+              height: convertEMUToDotValue(figure.data.size.cy),
+              tag: "image",
+              data: {
+                  path: figure.data.imageSrc,
+                  mimetype: figure.data.mimetype,
+              },
+          };
+      }
+      return undefined;
+  }
+  function isChartData(data) {
+      return "dataSets" in data;
+  }
+  function isImageData(data) {
+      return "imageSrc" in data;
   }
   function convertChartData(chartData) {
       const dataSetsHaveTitle = chartData.dataSets[0].label !== undefined;
@@ -28731,29 +29049,26 @@
       return new XMLString(concat(str));
   }
   /**
-   * Removes the namespace of all the xml tags in the string.
+   * Removes the escaped namespace of all the xml tags in the string.
    *
-   * Eg. : "ns:test a" => "test a"
+   * Eg. : "NAMESPACEnsNAMESPACEtest a" => "test a"
    */
-  function removeNamespaces(query) {
-      return query.replace(/[a-z0-9]+:(?=[a-z0-9]+)/gi, "");
+  function removeTagEscapedNamespaces(tag) {
+      return tag.replace(/NAMESPACE.*NAMESPACE(.*)/, "$1");
   }
   /**
-   * Escape the namespace's colons of all the xml tags in the string.
+   * Encase the namespaces in the element's tags with NAMESPACE string
    *
-   * Eg. : "ns:test a" => "ns\\:test a"
-   */
-  function escapeNamespaces(query) {
-      return query.replace(/([a-z0-9]+):(?=[a-z0-9]+)/gi, "$1\\:");
-  }
-  /**
-   * Return true if the querySelector ignores the namespaces when searching for a tag in the DOM.
+   * e.g. <x:foo> becomes <NAMESPACExNAMESPACEFoo>
    *
-   * Should return true if it's running on a browser, and false if it's running on jest (jsdom).
+   * That's useful because namespaces aren't supported by the HTML specification, so it's arbitrary whether a HTML parser/querySelector
+   * implementation will support namespaces in the tags or not.
    */
-  function areNamespaceIgnoredByQuerySelector() {
-      const doc = new DOMParser().parseFromString("<t:test xmlns:t='a'/>", "text/xml");
-      return doc.querySelector("test") !== null;
+  function escapeTagNamespaces(str) {
+      return str.replaceAll(/(<\/?)([a-zA-Z0-9]+):([a-zA-Z0-9]+)/g, "$1" + "NAMESPACE" + "$2" + "NAMESPACE" + "$3");
+  }
+  function escapeQueryNameSpaces(query) {
+      return query.replaceAll(/([a-zA-Z0-9]+):([a-zA-Z0-9]+)/g, "NAMESPACE" + "$1" + "NAMESPACE" + "$2");
   }
 
   class AttributeValue {
@@ -28783,14 +29098,20 @@
       // The xml file we are currently parsing. We should have one Extractor class by XLSXImportFile, but
       // the XLSXImportFile contains both the main .xml file, and the .rels file
       currentFile = undefined;
-      // If the parser querySelector() implementation ignores tag namespaces or not
-      areNamespaceIgnored;
+      /**
+       * /!\ Important : There should be no namespaces in the tags of the XML files.
+       *
+       * This class use native querySelector and querySelectorAll, that's used for HTML (not XML). These aren't supposed to
+       * handled namespaces, as they are not supported by the HTML specification. Some implementations (most browsers) do
+       * actually support namespaces, but some don't (e.g. jsdom).
+       *
+       * The namespace should be escaped as with NAMESPACE string (eg. <t:foo> => <NAMESPACEtNAMESPACEfoo>).
+       */
       constructor(rootFile, xlsxStructure, warningManager) {
           this.rootFile = rootFile;
           this.currentFile = rootFile.file.fileName;
           this.xlsxFileStructure = xlsxStructure;
           this.warningManager = warningManager;
-          this.areNamespaceIgnored = areNamespaceIgnoredByQuerySelector();
           this.relationships = {};
           if (rootFile.rels) {
               this.extractRelationships(rootFile.rels).map((rel) => {
@@ -28813,9 +29134,13 @@
       /**
        * Get the list of all the XLSX files in the XLSX file structure
        */
-      getListOfFiles() {
-          const files = Object.values(this.xlsxFileStructure).flat().filter(isDefined$1);
-          return files;
+      getListOfXMLFiles() {
+          const XMLFiles = Object.entries(this.xlsxFileStructure)
+              .filter(([key]) => key !== "images")
+              .map(([_, value]) => value)
+              .flat()
+              .filter(isDefined$1);
+          return XMLFiles;
       }
       /**
        * Return an array containing the return value of the given function applied to all the XML elements
@@ -28987,43 +29312,38 @@
           return color;
       }
       /**
-       * Returns the xlsx file targeted by a relationship.
+       * Returns the xml file targeted by a relationship.
        */
       getTargetXmlFile(relationship) {
           if (!relationship)
               throw new Error("Undefined target file");
-          let target = relationship.target;
-          target = target.replace("../", "");
-          target = target.replace("./", "");
+          const target = this.processRelationshipTargetName(relationship.target);
           // Use "endsWith" because targets are relative paths, and we know the files by their absolute path.
-          const f = this.getListOfFiles().find((f) => f.file.fileName.endsWith(target));
+          const f = this.getListOfXMLFiles().find((f) => f.file.fileName.endsWith(target));
           if (!f || !f.file)
               throw new Error("Cannot find target file");
           return f;
       }
       /**
-       * Wrapper of querySelector, but we'll remove the namespaces from the query if areNamespacesIgnored is true.
-       *
-       * Why we need to do this :
-       *  - For an XML "<t:test />"
-       *  - on Jest(jsdom) : xml.querySelector("test") == null, xml.querySelector("t\\:test") == <t:test />
-       *  - on Browser : xml.querySelector("test") == <t:test />, xml.querySelector("t\\:test") == null
+       * Returns the image parameters targeted by a relationship.
        */
+      getTargetImageFile(relationship) {
+          if (!relationship)
+              throw new Error("Undefined target file");
+          const target = this.processRelationshipTargetName(relationship.target);
+          // Use "endsWith" because targets are relative paths, and we know the files by their absolute path.
+          const f = this.xlsxFileStructure.images.find((f) => f.fileName.endsWith(target));
+          if (!f)
+              throw new Error("Cannot find target file");
+          return f;
+      }
       querySelector(element, query) {
-          query = this.areNamespaceIgnored ? removeNamespaces(query) : escapeNamespaces(query);
-          return element.querySelector(query);
+          const escapedQuery = escapeQueryNameSpaces(query);
+          return element.querySelector(escapedQuery);
       }
-      /**
-       * Wrapper of querySelectorAll, but we'll remove the namespaces from the query if areNamespacesIgnored is true.
-       *
-       * Why we need to do this :
-       *  - For an XML "<t:test />"
-       *  - on Jest(jsdom) : xml.querySelectorAll("test") == [], xml.querySelectorAll("t\\:test") == [<t:test />]
-       *  - on Browser : xml.querySelectorAll("test") == [<t:test />], xml.querySelectorAll("t\\:test") == []
-       */
       querySelectorAll(element, query) {
-          query = this.areNamespaceIgnored ? removeNamespaces(query) : escapeNamespaces(query);
-          return element.querySelectorAll(query);
+          const escapedQuery = escapeQueryNameSpaces(query);
+          return element.querySelectorAll(escapedQuery);
       }
       /**
        * Get a color from its id in the Theme's colorScheme.
@@ -29047,6 +29367,10 @@
                   return clrScheme[colorId].value;
           }
       }
+      /** Remove signs of relative path. */
+      processRelationshipTargetName(targetName) {
+          return targetName.replace(/\.+\//, "");
+      }
   }
 
   /**
@@ -29259,7 +29583,7 @@
               throw new Error("Missing plot area in the chart definition.");
           }
           for (let child of plotAreaElement.children) {
-              const tag = removeNamespaces(child.tagName);
+              const tag = removeTagEscapedNamespaces(child.tagName);
               if (XLSX_CHART_TYPES.some((chartType) => chartType === tag)) {
                   return tag;
               }
@@ -29271,20 +29595,21 @@
   class XlsxFigureExtractor extends XlsxBaseExtractor {
       extractFigures() {
           return this.mapOnElements({ parent: this.rootFile.file.xml, query: "xdr:wsDr", children: true }, (figureElement) => {
-              const anchorType = removeNamespaces(figureElement.tagName);
+              const anchorType = removeTagEscapedNamespaces(figureElement.tagName);
               if (anchorType !== "twoCellAnchor") {
                   throw new Error("Only twoCellAnchor are supported for xlsx drawings.");
               }
               const chartElement = this.querySelector(figureElement, "c:chart");
-              if (!chartElement) {
-                  throw new Error("Only chart figures are currently supported.");
+              const imageElement = this.querySelector(figureElement, "a:blip");
+              if (!chartElement && !imageElement) {
+                  throw new Error("Only chart and image figures are currently supported.");
               }
               return {
                   anchors: [
                       this.extractFigureAnchor("xdr:from", figureElement),
                       this.extractFigureAnchor("xdr:to", figureElement),
                   ],
-                  data: this.extractChart(chartElement),
+                  data: chartElement ? this.extractChart(chartElement) : this.extractImage(figureElement),
               };
           });
       }
@@ -29309,6 +29634,24 @@
           }
           return chartDefinition;
       }
+      extractImage(figureElement) {
+          const imageElement = this.querySelector(figureElement, "a:blip");
+          const imageId = this.extractAttr(imageElement, "r:embed", { required: true }).asString();
+          const image = this.getTargetImageFile(this.relationships[imageId]);
+          if (!image) {
+              throw new Error("Unable to extract image");
+          }
+          const shapePropertyElement = this.querySelector(figureElement, "a:xfrm");
+          const extension = image.fileName.split(".").at(-1);
+          return {
+              imageSrc: image.imageSrc,
+              mimetype: extension ? IMAGE_EXTENSION_TO_MIMETYPE_MAPPING[extension] : undefined,
+              size: {
+                  cx: this.extractChildAttr(shapePropertyElement, "a:ext", "cx", { required: true }).asNum(),
+                  cy: this.extractChildAttr(shapePropertyElement, "a:ext", "cy", { required: true }).asNum(),
+              },
+          };
+      }
   }
 
   /**
@@ -29878,13 +30221,22 @@
   class XlsxReader {
       warningManager;
       xmls;
+      images;
       constructor(files) {
           this.warningManager = new XLSXImportWarningManager();
           this.xmls = {};
+          this.images = [];
           for (let key of Object.keys(files)) {
               // Random files can be in xlsx (like a bin file for printer settings)
               if (key.endsWith(".xml") || key.endsWith(".rels")) {
-                  this.xmls[key] = parseXML(new XMLString(files[key]));
+                  const contentString = escapeTagNamespaces(files[key]);
+                  this.xmls[key] = parseXML(new XMLString(contentString));
+              }
+              else if (key.includes("media/image")) {
+                  this.images.push({
+                      fileName: key,
+                      imageSrc: files[key]["imageSrc"],
+                  });
               }
           }
       }
@@ -29938,6 +30290,7 @@
               tables: getXLSXFilesOfType(CONTENT_TYPES.table, this.xmls),
               pivots: getXLSXFilesOfType(CONTENT_TYPES.pivot, this.xmls),
               externalLinks: getXLSXFilesOfType(CONTENT_TYPES.externalLink, this.xmls),
+              images: this.images,
           };
           if (!xlsxFileStructure.workbook.rels) {
               throw Error(_lt("Cannot find workbook relations file"));
@@ -30944,7 +31297,7 @@
       }
       /**
        * Set the borders of a cell.
-       * It overrides the current border if override == true.
+       * It overrides the current border if override === true.
        */
       setBorder(sheetId, col, row, border, override = true) {
           if (override || !this.borders?.[sheetId]?.[col]?.[row]?.vertical) {
@@ -32214,7 +32567,9 @@
           const numHeader = this.getters.getNumberRows(sheetId);
           let gridHeight = 0;
           for (let i = 0; i < numHeader; i++) {
-              gridHeight += this.getters.getRowSize(sheetId, i);
+              // TODO : since the row size is an UI value now, this doesn't work anymore. Using the default cell height is
+              // a temporary solution at best, but is broken.
+              gridHeight += this.getters.getUserRowSize(sheetId, i) || DEFAULT_CELL_HEIGHT;
           }
           const figures = this.getters.getFigures(sheetId);
           for (const figure of figures) {
@@ -32640,33 +32995,15 @@
   }
 
   class HeaderSizePlugin extends CorePlugin {
-      static getters = ["getRowSize", "getColSize"];
+      static getters = ["getUserRowSize", "getColSize"];
       sizes = {};
       handle(cmd) {
           switch (cmd.type) {
               case "CREATE_SHEET": {
-                  const computedSizes = this.computeSheetSizes(cmd.sheetId);
-                  const sizes = {
-                      COL: computedSizes.COL.map((size) => ({
-                          manualSize: undefined,
-                          computedSize: lazy(size),
-                      })),
-                      ROW: computedSizes.ROW.map((size) => ({
-                          manualSize: undefined,
-                          computedSize: lazy(size),
-                      })),
-                  };
-                  this.history.update("sizes", cmd.sheetId, sizes);
+                  this.history.update("sizes", cmd.sheetId, { COL: [], ROW: [] });
                   break;
               }
               case "DUPLICATE_SHEET":
-                  // make sure the values are computed in case the original sheet is deleted
-                  for (const row of this.sizes[cmd.sheetId].ROW) {
-                      row.computedSize();
-                  }
-                  for (const col of this.sizes[cmd.sheetId].COL) {
-                      col.computedSize();
-                  }
                   this.history.update("sizes", cmd.sheetIdTo, deepCopy(this.sizes[cmd.sheetId]));
                   break;
               case "DELETE_SHEET":
@@ -32675,21 +33012,8 @@
                   this.history.update("sizes", sizes);
                   break;
               case "REMOVE_COLUMNS_ROWS": {
-                  let sizes = [...this.sizes[cmd.sheetId][cmd.dimension]];
-                  for (let headerIndex of [...cmd.elements].sort((a, b) => b - a)) {
-                      sizes.splice(headerIndex, 1);
-                  }
-                  const min = Math.min(...cmd.elements);
-                  sizes = sizes.map((size, row) => {
-                      if (cmd.dimension === "ROW" && row >= min) {
-                          // invalidate sizes
-                          return {
-                              manualSize: size.manualSize,
-                              computedSize: lazy(() => this.getRowTallestCellSize(cmd.sheetId, row)),
-                          };
-                      }
-                      return size;
-                  });
+                  const arr = this.sizes[cmd.sheetId][cmd.dimension];
+                  const sizes = removeIndexesFromArray(arr, cmd.elements);
                   this.history.update("sizes", cmd.sheetId, cmd.dimension, sizes);
                   break;
               }
@@ -32698,51 +33022,18 @@
                   const addIndex = getAddHeaderStartIndex(cmd.position, cmd.base);
                   const baseSize = sizes[cmd.base];
                   sizes.splice(addIndex, 0, ...Array(cmd.quantity).fill(baseSize));
-                  sizes = sizes.map((size, row) => {
-                      if (cmd.dimension === "ROW" && row > cmd.base + cmd.quantity) {
-                          // invalidate sizes
-                          return {
-                              manualSize: size.manualSize,
-                              computedSize: lazy(() => this.getRowTallestCellSize(cmd.sheetId, row)),
-                          };
-                      }
-                      return size;
-                  });
                   this.history.update("sizes", cmd.sheetId, cmd.dimension, sizes);
                   break;
               }
               case "RESIZE_COLUMNS_ROWS":
-                  for (let el of cmd.elements) {
-                      if (cmd.dimension === "ROW") {
-                          const height = this.getRowTallestCellSize(cmd.sheetId, el);
-                          const size = height;
-                          this.history.update("sizes", cmd.sheetId, cmd.dimension, el, {
-                              manualSize: cmd.size || undefined,
-                              computedSize: lazy(size),
-                          });
+                  if (cmd.dimension === "ROW") {
+                      for (const el of cmd.elements) {
+                          this.history.update("sizes", cmd.sheetId, cmd.dimension, el, cmd.size || undefined);
                       }
-                      else {
-                          this.history.update("sizes", cmd.sheetId, cmd.dimension, el, {
-                              manualSize: cmd.size || undefined,
-                              computedSize: lazy(cmd.size || DEFAULT_CELL_WIDTH),
-                          });
-                      }
-                  }
-                  break;
-              case "UPDATE_CELL":
-                  if (!this.sizes[cmd.sheetId]?.["ROW"]?.[cmd.row]?.manualSize) {
-                      const { sheetId, row } = cmd;
-                      this.history.update("sizes", sheetId, "ROW", row, "computedSize", lazy(() => this.getRowTallestCellSize(sheetId, row)));
                   }
-                  break;
-              case "ADD_MERGE":
-              case "REMOVE_MERGE":
-                  for (let target of cmd.target) {
-                      for (let row of range(target.top, target.bottom + 1)) {
-                          const rowHeight = this.getRowTallestCellSize(cmd.sheetId, row);
-                          if (rowHeight !== this.getRowSize(cmd.sheetId, row)) {
-                              this.history.update("sizes", cmd.sheetId, "ROW", row, "computedSize", lazy(rowHeight));
-                          }
+                  else {
+                      for (const el of cmd.elements) {
+                          this.history.update("sizes", cmd.sheetId, cmd.dimension, el, cmd.size || undefined);
                       }
                   }
                   break;
@@ -32750,94 +33041,29 @@
           return;
       }
       getColSize(sheetId, index) {
-          return this.getHeaderSize(sheetId, "COL", index);
-      }
-      getRowSize(sheetId, index) {
-          return this.getHeaderSize(sheetId, "ROW", index);
+          return Math.round(this.sizes[sheetId]?.["COL"][index] || DEFAULT_CELL_WIDTH);
       }
-      getHeaderSize(sheetId, dimension, index) {
-          return Math.round(this.sizes[sheetId]?.[dimension][index]?.manualSize ||
-              this.sizes[sheetId]?.[dimension][index]?.computedSize() ||
-              this.getDefaultHeaderSize(dimension));
-      }
-      computeSheetSizes(sheetId) {
-          const sizes = { COL: [], ROW: [] };
-          for (let col of range(0, this.getters.getNumberCols(sheetId))) {
-              sizes.COL.push(this.getHeaderSize(sheetId, "COL", col));
-          }
-          for (let row of range(0, this.getters.getNumberRows(sheetId))) {
-              let rowSize = this.sizes[sheetId]?.["ROW"]?.[row].manualSize;
-              if (!rowSize) {
-                  const height = this.getRowTallestCellSize(sheetId, row);
-                  rowSize = height;
-              }
-              sizes.ROW.push(rowSize);
-          }
-          return sizes;
-      }
-      getDefaultHeaderSize(dimension) {
-          return dimension === "COL" ? DEFAULT_CELL_WIDTH : DEFAULT_CELL_HEIGHT;
-      }
-      /**
-       * Return the height the cell should have in the sheet, which is either DEFAULT_CELL_HEIGHT if the cell is in a multi-row
-       * merge, or the height of the cell computed based on its font size.
-       */
-      getCellHeight(position) {
-          const merge = this.getters.getMerge(position);
-          if (merge && merge.bottom !== merge.top) {
-              return DEFAULT_CELL_HEIGHT;
-          }
-          const cell = this.getters.getCell(position);
-          return getDefaultCellHeight(cell);
-      }
-      /**
-       * Get the tallest cell of a row and its size.
-       *
-       * The tallest cell of the row correspond to the cell with the biggest font size,
-       * and that is not part of a multi-line merge.
-       */
-      getRowTallestCellSize(sheetId, row) {
-          const cellIds = this.getters.getRowCells(sheetId, row);
-          let maxHeight = 0;
-          for (let i = 0; i < cellIds.length; i++) {
-              const cell = this.getters.getCellById(cellIds[i]);
-              if (!cell)
-                  continue;
-              const position = this.getters.getCellPosition(cell.id);
-              const cellHeight = this.getCellHeight(position);
-              if (cellHeight > maxHeight && cellHeight > DEFAULT_CELL_HEIGHT) {
-                  maxHeight = cellHeight;
-              }
-          }
-          if (maxHeight <= DEFAULT_CELL_HEIGHT) {
-              return DEFAULT_CELL_HEIGHT;
-          }
-          return maxHeight;
+      getUserRowSize(sheetId, index) {
+          const rowSize = this.sizes[sheetId]?.["ROW"][index];
+          return rowSize ? Math.round(rowSize) : undefined;
       }
       import(data) {
           for (let sheet of data.sheets) {
-              const manualSizes = { COL: [], ROW: [] };
+              const sizes = {
+                  COL: Array(sheet.colNumber).fill(undefined),
+                  ROW: Array(sheet.rowNumber).fill(undefined),
+              };
               for (let [rowIndex, row] of Object.entries(sheet.rows)) {
                   if (row.size) {
-                      manualSizes["ROW"][rowIndex] = row.size;
+                      sizes["ROW"][rowIndex] = row.size;
                   }
               }
               for (let [colIndex, col] of Object.entries(sheet.cols)) {
                   if (col.size) {
-                      manualSizes["COL"][colIndex] = col.size;
-                  }
-              }
-              const computedSizes = this.computeSheetSizes(sheet.id);
-              this.sizes[sheet.id] = {
-                  COL: computedSizes.COL.map((size, i) => ({
-                      manualSize: manualSizes.COL[i],
-                      computedSize: lazy(size),
-                  })),
-                  ROW: computedSizes.ROW.map((size, i) => ({
-                      manualSize: manualSizes.ROW[i],
-                      computedSize: lazy(size),
-                  })),
-              };
+                      sizes["COL"][colIndex] = col.size;
+                  }
+              }
+              this.sizes[sheet.id] = sizes;
           }
           return;
       }
@@ -32858,9 +33084,12 @@
               if (sheet.rows === undefined) {
                   sheet.rows = {};
               }
-              for (let row of range(0, this.getters.getNumberRows(sheet.id))) {
-                  if (exportDefaults || this.sizes[sheet.id]["ROW"][row]?.manualSize) {
-                      sheet.rows[row] = { ...sheet.rows[row], size: this.getRowSize(sheet.id, row) };
+              for (const row of range(0, this.getters.getNumberRows(sheet.id))) {
+                  if (exportDefaults || this.sizes[sheet.id]["ROW"][row]) {
+                      sheet.rows[row] = {
+                          ...sheet.rows[row],
+                          size: this.getUserRowSize(sheet.id, row) ?? DEFAULT_CELL_HEIGHT,
+                      };
                   }
               }
               // Export col sizes
@@ -32868,7 +33097,7 @@
                   sheet.cols = {};
               }
               for (let col of range(0, this.getters.getNumberCols(sheet.id))) {
-                  if (exportDefaults || this.sizes[sheet.id]["COL"][col]?.manualSize) {
+                  if (exportDefaults || this.sizes[sheet.id]["COL"][col]) {
                       sheet.cols[col] = { ...sheet.cols[col], size: this.getColSize(sheet.id, col) };
                   }
               }
@@ -33088,7 +33317,7 @@
       handle(cmd) {
           switch (cmd.type) {
               case "CREATE_IMAGE":
-                  this.addFigure(cmd.figureId, cmd.sheetId, cmd.position, cmd.size);
+                  this.addImage(cmd.figureId, cmd.sheetId, cmd.position, cmd.size);
                   this.history.update("images", cmd.sheetId, cmd.figureId, cmd.definition);
                   this.syncedImages.add(cmd.definition.path);
                   break;
@@ -33152,7 +33381,7 @@
       // ---------------------------------------------------------------------------
       // Private
       // ---------------------------------------------------------------------------
-      addFigure(id, sheetId, position, size) {
+      addImage(id, sheetId, position, size) {
           const figure = {
               id,
               x: position.x,
@@ -35659,7 +35888,6 @@
       }
   }
 
-  const functions = functionRegistry.content;
   //#region
   // ---------------------------------------------------------------------------
   // INTRODUCTION
@@ -35881,9 +36109,7 @@
               let isExported = true;
               const formulaCell = this.getCorrespondingFormulaCell(position);
               if (formulaCell) {
-                  isExported = formulaCell.compiledFormula.tokens
-                      .filter((tk) => tk.type === "FUNCTION")
-                      .every((tk) => functions[tk.value.toUpperCase()].isExported);
+                  isExported = isExportableToExcel(formulaCell.compiledFormula.tokens);
                   isFormula = isExported;
                   if (!isExported) {
                       newContent = value.toString();
@@ -36427,7 +36653,7 @@
                   case "ContainsText":
                       return cell.value.toString().indexOf(values[0].toString()) > -1;
                   case "NotContains":
-                      return !cell.value || cell.value.toString().indexOf(values[0].toString()) == -1;
+                      return !cell.value || cell.value.toString().indexOf(values[0].toString()) === -1;
                   case "GreaterThan":
                       return cell.value > values[0];
                   case "GreaterThanOrEqual":
@@ -36454,6 +36680,156 @@
       };
   }
 
+  class UIRowSizePlugin extends UIPlugin {
+      static getters = ["getRowSize"];
+      tallestCellInRow = {};
+      ctx = document.createElement("canvas").getContext("2d");
+      handle(cmd) {
+          switch (cmd.type) {
+              case "START":
+                  for (const sheetId of this.getters.getSheetIds()) {
+                      this.initializeSheet(sheetId);
+                  }
+                  break;
+              case "CREATE_SHEET": {
+                  this.initializeSheet(cmd.sheetId);
+                  break;
+              }
+              case "DUPLICATE_SHEET": {
+                  const tallestCells = deepCopy(this.tallestCellInRow[cmd.sheetId]);
+                  this.history.update("tallestCellInRow", cmd.sheetIdTo, tallestCells);
+                  break;
+              }
+              case "DELETE_SHEET":
+                  const tallestCells = { ...this.tallestCellInRow };
+                  delete tallestCells[cmd.sheetId];
+                  this.history.update("tallestCellInRow", tallestCells);
+                  break;
+              case "REMOVE_COLUMNS_ROWS": {
+                  if (cmd.dimension === "COL") {
+                      return;
+                  }
+                  const tallestCells = removeIndexesFromArray(this.tallestCellInRow[cmd.sheetId], cmd.elements);
+                  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;
+                      if (cmd.dimension === "ROW") {
+                          for (const row of cmd.elements) {
+                              const tallestCell = this.getRowTallestCell(sheetId, row);
+                              this.history.update("tallestCellInRow", sheetId, row, tallestCell);
+                          }
+                      }
+                      else {
+                          // Recompute row heights on col size change, they might have changed because of wrapped text
+                          for (const row of range(0, this.getters.getNumberRows(sheetId))) {
+                              for (const col of cmd.elements) {
+                                  this.updateRowSizeForCellChange(sheetId, row, col);
+                              }
+                          }
+                      }
+                  }
+                  break;
+              case "UPDATE_CELL":
+                  this.updateRowSizeForCellChange(cmd.sheetId, cmd.row, cmd.col);
+                  break;
+              case "ADD_MERGE":
+              case "REMOVE_MERGE":
+                  for (const target of cmd.target) {
+                      for (const position of positions(target)) {
+                          this.updateRowSizeForCellChange(cmd.sheetId, position.row, position.col);
+                      }
+                  }
+          }
+          return;
+      }
+      getRowSize(sheetId, row) {
+          return Math.round(this.getters.getUserRowSize(sheetId, row) ??
+              this.tallestCellInRow[sheetId][row]?.size ??
+              DEFAULT_CELL_HEIGHT);
+      }
+      updateRowSizeForCellChange(sheetId, row, col) {
+          const tallestCellInRow = this.tallestCellInRow[sheetId]?.[row];
+          if (tallestCellInRow?.cell.col === col) {
+              const newTallestCell = this.getRowTallestCell(sheetId, row);
+              this.history.update("tallestCellInRow", sheetId, row, newTallestCell);
+          }
+          const updatedCellHeight = this.getCellHeight({ sheetId, col, row });
+          if (updatedCellHeight <= DEFAULT_CELL_HEIGHT) {
+              return;
+          }
+          if ((!tallestCellInRow && updatedCellHeight > DEFAULT_CELL_HEIGHT) ||
+              (tallestCellInRow && updatedCellHeight > tallestCellInRow.size)) {
+              const newTallestCell = { cell: { sheetId, col, row }, size: updatedCellHeight };
+              this.history.update("tallestCellInRow", sheetId, row, newTallestCell);
+          }
+      }
+      initializeSheet(sheetId) {
+          const tallestCells = [];
+          for (let row = 0; row < this.getters.getNumberRows(sheetId); row++) {
+              const tallestCell = this.getRowTallestCell(sheetId, row);
+              tallestCells.push(tallestCell);
+          }
+          this.history.update("tallestCellInRow", sheetId, tallestCells);
+      }
+      /**
+       * Return the height the cell should have in the sheet, which is either DEFAULT_CELL_HEIGHT if the cell is in a multi-row
+       * merge, or the height of the cell computed based on its style/content.
+       */
+      getCellHeight(position) {
+          if (this.isInMultiRowMerge(position)) {
+              return DEFAULT_CELL_HEIGHT;
+          }
+          const cell = this.getters.getCell(position);
+          const colSize = this.getters.getColSize(position.sheetId, position.col);
+          return getDefaultCellHeight(this.ctx, cell, colSize);
+      }
+      isInMultiRowMerge(position) {
+          const merge = this.getters.getMerge(position);
+          return !!merge && merge.bottom !== merge.top;
+      }
+      /**
+       * Get the tallest cell of a row and its size.
+       */
+      getRowTallestCell(sheetId, row) {
+          const userRowSize = this.getters.getUserRowSize(sheetId, row);
+          if (userRowSize !== undefined) {
+              return undefined;
+          }
+          const cellIds = this.getters.getRowCells(sheetId, row);
+          let maxHeight = 0;
+          let tallestCell = undefined;
+          for (let i = 0; i < cellIds.length; i++) {
+              const cell = this.getters.getCellById(cellIds[i]);
+              if (!cell) {
+                  continue;
+              }
+              const position = this.getters.getCellPosition(cell.id);
+              const cellHeight = this.getCellHeight(position);
+              if (cellHeight > maxHeight && cellHeight > DEFAULT_CELL_HEIGHT) {
+                  maxHeight = cellHeight;
+                  tallestCell = { cell: position, size: cellHeight };
+              }
+          }
+          if (tallestCell && tallestCell.size > DEFAULT_CELL_HEIGHT) {
+              return tallestCell;
+          }
+          return undefined;
+      }
+  }
+
   /**
    * This plugin manage the autofill.
    *
@@ -39887,10 +40263,8 @@
                   }
                   updateCellCommands.push(newCellValues);
               }
-              for (const cmd of updateCellCommands) {
-                  this.dispatch("UPDATE_CELL", cmd);
-              }
           }
+          updateCellCommands.forEach((cmdPayload) => this.dispatch("UPDATE_CELL", cmdPayload));
       }
       /**
        * Return the distances between main merge cells in the zone.
@@ -39991,24 +40365,28 @@
       // Getters
       // ---------------------------------------------------------------------------
       getCellWidth(position) {
-          const text = this.getCellText(position);
           const style = this.getters.getCellComputedStyle(position);
-          const multiLineText = text.split(NEWLINE);
-          let contentWidth = Math.max(...multiLineText.map((line) => this.getTextWidth(line, style)));
+          let contentWidth = 0;
+          const content = this.getters.getEvaluatedCell(position).formattedValue;
+          if (content) {
+              const multiLineText = splitTextToWidth(this.ctx, content, style, undefined);
+              contentWidth += Math.max(...multiLineText.map((line) => computeTextWidth(this.ctx, line, style)));
+          }
           const icon = this.getters.getConditionalIcon(position);
           if (icon) {
-              contentWidth += computeIconWidth(this.getters.getCellStyle(position));
+              contentWidth += computeIconWidth(style);
           }
           const isFilterHeader = this.getters.isFilterHeader(position);
           if (isFilterHeader) {
               contentWidth += ICON_EDGE_LENGTH + FILTER_ICON_MARGIN;
           }
-          if (contentWidth > 0) {
-              contentWidth += 2 * PADDING_AUTORESIZE_HORIZONTAL;
-              if (this.getters.getCellStyle(position).wrapping === "wrap") {
-                  const colWidth = this.getters.getColSize(this.getters.getActiveSheetId(), position.col);
-                  return Math.min(colWidth, contentWidth);
-              }
+          if (contentWidth === 0) {
+              return 0;
+          }
+          contentWidth += 2 * PADDING_AUTORESIZE_HORIZONTAL;
+          if (style.wrapping === "wrap") {
+              const colWidth = this.getters.getColSize(this.getters.getActiveSheetId(), position.col);
+              return Math.min(colWidth, contentWidth);
           }
           return contentWidth;
       }
@@ -40031,56 +40409,7 @@
       getCellMultiLineText(position, width) {
           const style = this.getters.getCellStyle(position);
           const text = this.getters.getCellText(position, this.getters.shouldShowFormulas());
-          const brokenText = [];
-          for (const line of text.split("\n")) {
-              const words = line.split(" ");
-              if (!width) {
-                  brokenText.push(line);
-                  continue;
-              }
-              let textLine = "";
-              let availableWidth = width;
-              for (let word of words) {
-                  const splitWord = this.splitWordToSpecificWidth(this.ctx, word, width, style);
-                  const lastPart = splitWord.pop();
-                  const lastPartWidth = computeTextWidth(this.ctx, lastPart, style);
-                  // At this step: "splitWord" is an array composed of parts of word whose
-                  // length is at most equal to "width".
-                  // Last part contains the end of the word.
-                  // Note that: When word length is less than width, then lastPart is equal
-                  // to word and splitWord is empty
-                  if (splitWord.length) {
-                      if (textLine !== "") {
-                          brokenText.push(textLine);
-                          textLine = "";
-                          availableWidth = width;
-                      }
-                      splitWord.forEach((wordPart) => {
-                          brokenText.push(wordPart);
-                      });
-                      textLine = lastPart;
-                      availableWidth = width - lastPartWidth;
-                  }
-                  else {
-                      // here "lastPart" is equal to "word" and the "word" size is smaller than "width"
-                      const _word = textLine === "" ? lastPart : " " + lastPart;
-                      const wordWidth = computeTextWidth(this.ctx, _word, style);
-                      if (wordWidth <= availableWidth) {
-                          textLine += _word;
-                          availableWidth -= wordWidth;
-                      }
-                      else {
-                          brokenText.push(textLine);
-                          textLine = lastPart;
-                          availableWidth = width - lastPartWidth;
-                      }
-                  }
-              }
-              if (textLine !== "") {
-                  brokenText.push(textLine);
-              }
-          }
-          return brokenText;
+          return splitTextToWidth(this.ctx, text, style, width);
       }
       /**
        * Returns the size, start and end coordinates of a column on an unfolded sheet
@@ -40139,26 +40468,6 @@
           const sizes = cellsPositions.map((position) => this.getCellWidth({ sheetId, ...position }));
           return Math.max(0, ...sizes);
       }
-      splitWordToSpecificWidth(ctx, word, width, style) {
-          const wordWidth = computeTextWidth(ctx, word, style);
-          if (wordWidth <= width) {
-              return [word];
-          }
-          const splitWord = [];
-          let wordPart = "";
-          for (let l of word) {
-              const wordPartWidth = computeTextWidth(ctx, wordPart + l, style);
-              if (wordPartWidth > width) {
-                  splitWord.push(wordPart);
-                  wordPart = l;
-              }
-              else {
-                  wordPart += l;
-              }
-          }
-          splitWord.push(wordPart);
-          return splitWord;
-      }
       /**
        * Check that any "sheetId" in the command matches an existing
        * sheet.
@@ -41150,7 +41459,7 @@
               .join("\n") || "\t");
       }
       getHTMLContent() {
-          if (this.cells.length == 1 && this.cells[0].length == 1) {
+          if (this.cells.length === 1 && this.cells[0].length === 1) {
               return this.getters.getCellText(this.cells[0][0].position);
           }
           let htmlTable = '<table border="1" style="border-collapse:collapse">';
@@ -41475,7 +41784,7 @@
       status = "invisible";
       state;
       lastPasteState;
-      _isPaintingFormat = false;
+      paintFormatStatus = "inactive";
       originSheetId;
       // ---------------------------------------------------------------------------
       // Command Handling
@@ -41490,7 +41799,7 @@
                   if (!this.state) {
                       return 24 /* CommandResult.EmptyClipboard */;
                   }
-                  const pasteOption = cmd.pasteOption || (this._isPaintingFormat ? "onlyFormat" : undefined);
+                  const pasteOption = cmd.pasteOption || (this.paintFormatStatus !== "inactive" ? "onlyFormat" : undefined);
                   return this.state.isPasteAllowed(cmd.target, { pasteOption });
               case "PASTE_FROM_OS_CLIPBOARD": {
                   const state = new ClipboardOsState(cmd.text, this.getters, this.dispatch, this.selection);
@@ -41506,6 +41815,11 @@
                   const state = this.getClipboardStateForCopyCells(cut, "CUT");
                   return state.isPasteAllowed(paste);
               }
+              case "ACTIVATE_PAINT_FORMAT": {
+                  if (this.paintFormatStatus !== "inactive") {
+                      return 95 /* CommandResult.AlreadyInPaintingFormatMode */;
+                  }
+              }
           }
           return 0 /* CommandResult.Success */;
       }
@@ -41522,11 +41836,13 @@
                   if (!this.state) {
                       break;
                   }
-                  const pasteOption = cmd.pasteOption || (this._isPaintingFormat ? "onlyFormat" : undefined);
-                  this._isPaintingFormat = false;
+                  const pasteOption = cmd.pasteOption || (this.paintFormatStatus !== "inactive" ? "onlyFormat" : undefined);
                   this.state.paste(cmd.target, { pasteOption, shouldPasteCF: true, selectTarget: true });
                   this.lastPasteState = this.state;
-                  this.status = "invisible";
+                  if (this.paintFormatStatus === "oneOff") {
+                      this.paintFormatStatus = "inactive";
+                      this.status = "invisible";
+                  }
                   break;
               case "CLEAN_CLIPBOARD_HIGHLIGHT":
                   this.status = "invisible";
@@ -41594,8 +41910,13 @@
               case "ACTIVATE_PAINT_FORMAT": {
                   const zones = this.getters.getSelectedZones();
                   this.state = this.getClipboardStateForCopyCells(zones, "COPY");
-                  this._isPaintingFormat = true;
                   this.status = "visible";
+                  if (cmd.persistent) {
+                      this.paintFormatStatus = "persistent";
+                  }
+                  else {
+                      this.paintFormatStatus = "oneOff";
+                  }
                   break;
               }
               case "DELETE_SHEET":
@@ -41607,6 +41928,11 @@
                       this.status = "invisible";
                   }
                   break;
+              case "CANCEL_PAINT_FORMAT": {
+                  this.paintFormatStatus = "inactive";
+                  this.status = "invisible";
+                  break;
+              }
               default:
                   if (isCoreCommand(cmd)) {
                       this.status = "invisible";
@@ -41637,7 +41963,7 @@
           return this.state ? this.state.operation === "CUT" : false;
       }
       isPaintingFormat() {
-          return this._isPaintingFormat;
+          return this.paintFormatStatus !== "inactive";
       }
       // ---------------------------------------------------------------------------
       // Private methods
@@ -44272,6 +44598,7 @@
       .add("evaluation", EvaluationPlugin)
       .add("evaluation_chart", EvaluationChartPlugin)
       .add("evaluation_cf", EvaluationConditionalFormatPlugin)
+      .add("row_size", UIRowSizePlugin)
       .add("custom_colors", CustomColorsPlugin);
 
   const clickableCellRegistry = new Registry();
@@ -44289,7 +44616,7 @@
       async requestImage() {
           const file = await this.getImageFromUser();
           const path = await this.fileStore.upload(file);
-          const size = await this.getImageSize(path);
+          const size = await this.getImageOriginalSize(path);
           return { path, size, mimetype: file.type };
       }
       getImageFromUser() {
@@ -44308,7 +44635,7 @@
               input.click();
           });
       }
-      getImageSize(path) {
+      getImageOriginalSize(path) {
           return new Promise((resolve, reject) => {
               const image = new Image();
               image.src = path;
@@ -45527,11 +45854,11 @@
       }
       get title() {
           const name = this.actionButton.name(this.env);
-          const description = this.actionButton.description;
+          const description = this.actionButton.description(this.env);
           return name + (description ? ` (${description})` : "");
       }
       get iconTitle() {
-          return this.actionButton.icon;
+          return this.actionButton.icon(this.env);
       }
       onClick(ev) {
           if (this.isEnabled) {
@@ -45793,6 +46120,10 @@
       top: 20%;
     }
   }
+
+  .user-select-text {
+    user-select: text;
+  }
 `;
   class TopBarComposer extends owl.Component {
       static template = "o-spreadsheet-TopBarComposer";
@@ -45912,6 +46243,27 @@
       class: String,
   };
 
+  class PaintFormatButton extends owl.Component {
+      static template = "o-spreadsheet-PaintFormatButton";
+      get isActive() {
+          return this.env.model.getters.isPaintingFormat();
+      }
+      onDblClick() {
+          this.env.model.dispatch("ACTIVATE_PAINT_FORMAT", { persistent: true });
+      }
+      togglePaintFormat() {
+          if (this.isActive) {
+              this.env.model.dispatch("CANCEL_PAINT_FORMAT");
+          }
+          else {
+              this.env.model.dispatch("ACTIVATE_PAINT_FORMAT", { persistent: false });
+          }
+      }
+  }
+  PaintFormatButton.props = {
+      class: { type: String, optional: true },
+  };
+
   // -----------------------------------------------------------------------------
   // TopBar
   // -----------------------------------------------------------------------------
@@ -46012,6 +46364,7 @@
           TopBarComposer,
           FontSizeEditor,
           ActionButton,
+          PaintFormatButton,
           BorderEditorWidget,
       };
       state = owl.useState({
@@ -47864,7 +48217,7 @@
               : "nextCluster";
           while (true) {
               const nextCellPosition = this.getNextCellPosition(currentPosition, dim, dir);
-              // Break if nextPosition == currentPosition, which happens if there's no next valid position
+              // Break if nextPosition === currentPosition, which happens if there's no next valid position
               if (currentPosition.col === nextCellPosition.col &&
                   currentPosition.row === nextCellPosition.row) {
                   break;
@@ -48831,6 +49184,8 @@
           ["name", `Image ${imageId}`],
           ["title", "Image"],
       ];
+      const cx = convertDotValueToEMU(figure.width);
+      const cy = convertDotValueToEMU(figure.height);
       return escapeXml /*xml*/ `
     <xdr:twoCellAnchor editAs="oneCell">
       <xdr:from>
@@ -48857,6 +49212,9 @@
           </a:stretch>
         </xdr:blipFill>
         <xdr:spPr>
+          <a:xfrm>
+            <a:ext cx="${cx}" cy="${cy}" />
+          </a:xfrm>
           <a:prstGeom prst="rect">
             <a:avLst/>
           </a:prstGeom>
@@ -49376,7 +49734,7 @@
               const mimeType = image.data.mimetype;
               if (mimeType === undefined)
                   continue;
-              const extension = IMAGE_MIMETYPE_EXTENSION_MAPPING[mimeType];
+              const extension = IMAGE_MIMETYPE_TO_EXTENSION_MAPPING[mimeType];
               // only support exporting images with mimetypes specified in the mapping
               if (extension === undefined)
                   continue;
@@ -49512,7 +49870,7 @@
   function createContentTypes(files) {
       const overrideNodes = [];
       // hard-code supported image mimetypes
-      const imageDefaultNodes = Object.entries(IMAGE_MIMETYPE_EXTENSION_MAPPING).map(([mimetype, extension]) => createDefaultXMLElement(extension, mimetype));
+      const imageDefaultNodes = Object.entries(IMAGE_MIMETYPE_TO_EXTENSION_MAPPING).map(([mimetype, extension]) => createDefaultXMLElement(extension, mimetype));
       for (const file of files) {
           if ("contentType" in file && file.contentType) {
               overrideNodes.push(createOverride("/" + file.path, CONTENT_TYPES[file.contentType]));
@@ -49773,6 +50131,7 @@
               ...config,
               mode: config.mode || "normal",
               custom: config.custom || {},
+              defaultCurrencyFormat: config.defaultCurrencyFormat || "[$$]#,##0.00",
               external: this.setupExternalConfig(config.external || {}),
               transportService,
               client,
@@ -50070,6 +50429,7 @@
       numberToLetters,
       UuidGenerator,
       formatValue,
+      createCurrencyFormat,
       computeTextWidth,
       createEmptyWorkbookData,
       createEmptySheet,
@@ -50142,6 +50502,7 @@
   exports.invalidateCFEvaluationCommands = invalidateCFEvaluationCommands;
   exports.invalidateDependenciesCommands = invalidateDependenciesCommands;
   exports.invalidateEvaluationCommands = invalidateEvaluationCommands;
+  exports.iterateAstNodes = iterateAstNodes;
   exports.links = links;
   exports.load = load;
   exports.parse = parse;
@@ -50154,9 +50515,9 @@
   Object.defineProperty(exports, '__esModule', { value: true });
 
 
-  __info__.version = '16.4.0-alpha.6';
-  __info__.date = '2023-06-28T11:40:12.377Z';
-  __info__.hash = '7d15d3c';
+  __info__.version = '16.4.0';
+  __info__.date = '2023-07-24T06:26:19.494Z';
+  __info__.hash = '4eb614c';
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);