@odoo/o-spreadsheet 18.1.0-alpha.6 → 18.1.0-alpha.8

package/dist/o-spreadsheet.iife.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 18.1.0-alpha.6
- * @date 2024-11-28T09:06:59.527Z
- * @hash 875c901
+ * @version 18.1.0-alpha.8
+ * @date 2024-12-19T07:49:54.421Z
+ * @hash 87a1567
  */
 
 (function (exports, owl) {
@@ -171,10 +171,13 @@
   const ALERT_INFO_BORDER = "#98DBE2";
   const ALERT_INFO_TEXT_COLOR = "#09414A";
   const BADGE_SELECTED_COLOR = "#E6F2F3";
-  const DEFAULT_CHART_PADDING = 20;
-  const DEFAULT_CHART_FONT_SIZE = 22;
-  const SCORECARD_GAUGE_CHART_PADDING = 10;
-  const SCORECARD_GAUGE_CHART_FONT_SIZE = 14;
+  const CHART_PADDING$1 = 20;
+  const CHART_PADDING_BOTTOM = 10;
+  const CHART_PADDING_TOP = 15;
+  const CHART_TITLE_FONT_SIZE = 16;
+  const CHART_AXIS_TITLE_FONT_SIZE = 12;
+  const SCORECARD_CHART_TITLE_FONT_SIZE = 14;
+  const PIVOT_TOKEN_COLOR = "#F28C28";
   // Color picker defaults as upper case HEX to match `toHex`helper
   const COLOR_PICKER_DEFAULTS = [
       "#000000",
@@ -263,7 +266,6 @@
   const MIN_COL_WIDTH = 5;
   const HEADER_HEIGHT = 26;
   const HEADER_WIDTH = 48;
-  const TOPBAR_HEIGHT = 63;
   const TOPBAR_TOOLBAR_HEIGHT = 34;
   const BOTTOMBAR_HEIGHT = 36;
   const DEFAULT_CELL_WIDTH = 96;
@@ -334,8 +336,8 @@
   const DEBOUNCE_TIME = 200;
   const MESSAGE_VERSION = 1;
   // Sheets
-  const FORBIDDEN_SHEET_CHARS = ["'", "*", "?", "/", "\\", "[", "]"];
-  const FORBIDDEN_IN_EXCEL_REGEX = /'|\*|\?|\/|\\|\[|\]/;
+  const FORBIDDEN_SHEETNAME_CHARS = ["'", "*", "?", "/", "\\", "[", "]"];
+  const FORBIDDEN_SHEETNAME_CHARS_IN_EXCEL_REGEX = /'|\*|\?|\/|\\|\[|\]/;
   // Cells
   const FORMULA_REF_IDENTIFIER = "|";
   // Components
@@ -388,6 +390,7 @@
   //------------------------------------------------------------------------------
   // Miscellaneous
   //------------------------------------------------------------------------------
+  const sanitizeSheetNameRegex = new RegExp(FORBIDDEN_SHEETNAME_CHARS_IN_EXCEL_REGEX, "g");
   /**
    * Remove quotes from a quoted string
    * ```js
@@ -483,6 +486,10 @@
       }
       return symbolName;
   }
+  /** Replace the excel-excluded characters of a sheetName */
+  function sanitizeSheetName(sheetName, replacementChar = " ") {
+      return sheetName.replace(sanitizeSheetNameRegex, replacementChar);
+  }
   function clip(val, min, max) {
       return val < min ? min : val > max ? max : val;
   }
@@ -782,6 +789,7 @@
    * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes
    */
   const whiteSpaceSpecialCharacters = [
+      " ",
       "\t",
       "\f",
       "\v",
@@ -796,17 +804,15 @@
       String.fromCharCode(parseInt("3000", 16)),
       String.fromCharCode(parseInt("feff", 16)),
   ];
-  const whiteSpaceRegexp = new RegExp(whiteSpaceSpecialCharacters.join("|") + "|(\r\n|\r|\n)", "g");
+  const whiteSpaceRegexp = new RegExp(whiteSpaceSpecialCharacters.join("|"), "g");
+  const newLineRegexp = /(\r\n|\r)/g;
   /**
-   * Replace all the special spaces in a string (non-breaking, tabs, ...) by normal spaces, and all the
-   * different newlines types by \n.
+   * Replace all different newlines characters by \n
    */
-  function replaceSpecialSpaces(text) {
+  function replaceNewLines(text) {
       if (!text)
           return "";
-      if (!whiteSpaceRegexp.test(text))
-          return text;
-      return text.replace(whiteSpaceRegexp, (match, newLine) => (newLine ? NEWLINE : " "));
+      return text.replace(newLineRegexp, NEWLINE);
   }
   /**
    * Determine if the numbers are consecutive.
@@ -972,7 +978,7 @@
 
   const RBA_REGEX = /rgba?\(|\s+|\)/gi;
   const HEX_MATCH = /^#([A-F\d]{2}){3,4}$/;
-  const colors$1 = [
+  const colors = [
       "#eb6d00",
       "#0074d9",
       "#ad8e00",
@@ -995,6 +1001,12 @@
   function colorNumberString(color) {
       return toHex(color.toString(16).padStart(6, "0"));
   }
+  function colorToNumber(color) {
+      if (typeof color === "number") {
+          return color;
+      }
+      return Number.parseInt(toHex(color).slice(1), 16);
+  }
   /**
    * Converts any CSS color value to a standardized hex6 value.
    * Accepts: hex3, hex6, hex8, rgb[1] and rgba[1].
@@ -1345,9 +1357,9 @@
       "#056BD9", // Blue #3
       "#155193", // Blue #4
       "#A76DBC", // Violet #1
-      "#7F4295", // Violet #1
-      "#6D2387", // Violet #1
-      "#4F1565", // Violet #1
+      "#7F4295", // Violet #2
+      "#6D2387", // Violet #3
+      "#4F1565", // Violet #4
       "#EA6175", // Red #1
       "#CE4257", // Red #2
       "#982738", // Red #3
@@ -1373,6 +1385,81 @@
       "#C08A16", // Yellow #3
       "#936A12", // Yellow #4
   ];
+  // Same as above but with alternating colors
+  const ALTERNATING_COLORS_MD = [
+      "#4EA7F2", // Blue    #1
+      "#43C5B1", // Teal    #1
+      "#EA6175", // Red     #1
+      "#F4A261", // Orange  #1
+      "#8481DD", // Purple  #1
+      "#FFD86D", // Yellow  #1
+      "#3188E6", // Blue    #2
+      "#00A78D", // Teal    #2
+      "#CE4257", // Red     #2
+      "#F48935", // Orange  #2
+      "#5752D1", // Purple  #2
+      "#FFBC2C", // Yellow  #2
+  ];
+  const ALTERNATING_COLORS_LG = [
+      "#4EA7F2", // Blue    #1
+      "#A76DBC", // Violet  #1
+      "#EA6175", // Red     #1
+      "#43C5B1", // Teal    #1
+      "#F4A261", // Orange  #1
+      "#8481DD", // Purple  #1
+      "#A4A8B6", // Gray    #1
+      "#FFD86D", // Yellow  #1
+      "#3188E6", // Blue    #2
+      "#7F4295", // Violet  #2
+      "#CE4257", // Red     #2
+      "#00A78D", // Teal    #2
+      "#F48935", // Orange  #2
+      "#5752D1", // Purple  #2
+      "#7E8290", // Gray    #2
+      "#FFBC2C", // Yellow  #2
+      "#056BD9", // Blue    #3
+      "#6D2387", // Violet  #3
+      "#982738", // Red     #3
+      "#0E8270", // Teal    #3
+      "#BE5D10", // Orange  #3
+      "#3A3580", // Purple  #3
+      "#545B70", // Gray    #3
+      "#C08A16", // Yellow  #3
+  ];
+  const ALTERNATING_COLORS_XL = [
+      "#4EA7F2", // Blue    #1
+      "#A76DBC", // Violet  #1
+      "#EA6175", // Red     #1
+      "#43C5B1", // Teal    #1
+      "#F4A261", // Orange  #1
+      "#8481DD", // Purple  #1
+      "#A4A8B6", // Grey    #1
+      "#FFD86D", // Yellow  #1
+      "#3188E6", // Blue    #2
+      "#7F4295", // Violet  #2
+      "#CE4257", // Red     #2
+      "#00A78D", // Teal    #2
+      "#F48935", // Orange  #2
+      "#5752D1", // Purple  #2
+      "#7E8290", // Grey    #2
+      "#FFBC2C", // Yellow  #2
+      "#056BD9", // Blue    #3
+      "#6D2387", // Violet  #3
+      "#982738", // Red     #3
+      "#0E8270", // Teal    #3
+      "#BE5D10", // Orange  #3
+      "#3A3580", // Purple  #3
+      "#545B70", // Grey    #3
+      "#C08A16", // Yellow  #3
+      "#155193", // Blue    #4
+      "#4F1565", // Violet  #4
+      "#791B29", // Red     #4
+      "#105F53", // Teal    #4
+      "#7D380D", // Orange  #4
+      "#26235F", // Purple  #4
+      "#3F4250", // Grey    #4
+      "#936A12", // Yellow  #4
+  ];
   function getNthColor(index, palette) {
       return palette[index % palette.length];
   }
@@ -1390,6 +1477,20 @@
           return COLORS_XL;
       }
   }
+  function getAlternatingColorsPalette(quantity) {
+      if (quantity <= 6) {
+          return COLORS_SM;
+      }
+      else if (quantity <= 12) {
+          return ALTERNATING_COLORS_MD;
+      }
+      else if (quantity <= 24) {
+          return ALTERNATING_COLORS_LG;
+      }
+      else {
+          return ALTERNATING_COLORS_XL;
+      }
+  }
   class ColorGenerator {
       preferredColors;
       currentColorIndex = 0;
@@ -1404,6 +1505,62 @@
               : getNthColor(this.currentColorIndex++, this.palette);
       }
   }
+  class AlternatingColorGenerator extends ColorGenerator {
+      constructor(paletteSize, preferredColors = []) {
+          super(paletteSize, preferredColors);
+          this.palette = getAlternatingColorsPalette(paletteSize).filter((c) => !preferredColors.includes(c));
+      }
+  }
+  /**
+   * Returns a function that maps a value to a color using a color scale defined by the given
+   * color/threshold values pairs.
+   */
+  function getColorScale(colorScalePoints) {
+      if (colorScalePoints.length < 2) {
+          throw new Error("Color scale must have at least 2 points");
+      }
+      const sortedColorScalePoints = [...colorScalePoints.sort((a, b) => a.value - b.value)];
+      const thresholds = [];
+      for (let i = 1; i < sortedColorScalePoints.length; i++) {
+          const minColor = colorToNumber(sortedColorScalePoints[i - 1].color);
+          const maxColor = colorToNumber(sortedColorScalePoints[i].color);
+          thresholds.push({
+              min: sortedColorScalePoints[i - 1].value,
+              max: sortedColorScalePoints[i].value,
+              minColor,
+              maxColor,
+              colorDiff: computeColorDiffUnits(sortedColorScalePoints[i - 1].value, sortedColorScalePoints[i].value, minColor, maxColor),
+          });
+      }
+      return (value) => {
+          if (value < thresholds[0].min) {
+              return colorNumberString(thresholds[0].minColor);
+          }
+          for (const threshold of thresholds) {
+              if (value >= threshold.min && value <= threshold.max) {
+                  return colorNumberString(colorCell(value, threshold.min, threshold.minColor, threshold.colorDiff));
+              }
+          }
+          return colorNumberString(thresholds[thresholds.length - 1].maxColor);
+      };
+  }
+  function computeColorDiffUnits(minValue, maxValue, minColor, maxColor) {
+      const deltaValue = maxValue - minValue;
+      const deltaColorR = ((minColor >> 16) % 256) - ((maxColor >> 16) % 256);
+      const deltaColorG = ((minColor >> 8) % 256) - ((maxColor >> 8) % 256);
+      const deltaColorB = (minColor % 256) - (maxColor % 256);
+      const colorDiffUnitR = deltaColorR / deltaValue;
+      const colorDiffUnitG = deltaColorG / deltaValue;
+      const colorDiffUnitB = deltaColorB / deltaValue;
+      return [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB];
+  }
+  function colorCell(value, minValue, minColor, colorDiffUnit) {
+      const [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB] = colorDiffUnit;
+      const r = Math.round(((minColor >> 16) % 256) - colorDiffUnitR * (value - minValue));
+      const g = Math.round(((minColor >> 8) % 256) - colorDiffUnitG * (value - minValue));
+      const b = Math.round((minColor % 256) - colorDiffUnitB * (value - minValue));
+      return (r << 16) | (g << 8) | b;
+  }
 
   //------------------------------------------------------------------------------
   // Coordinate
@@ -3275,6 +3432,7 @@
   ]);
   const invalidateChartEvaluationCommands = new Set([
       "EVALUATE_CELLS",
+      "EVALUATE_CHARTS",
       "UPDATE_CELL",
       "UNHIDE_COLUMNS_ROWS",
       "HIDE_COLUMNS_ROWS",
@@ -3311,6 +3469,7 @@
       "RESIZE_SHEETVIEW",
       "SET_VIEWPORT_OFFSET",
       "EVALUATE_CELLS",
+      "EVALUATE_CHARTS",
       "SET_FORMULA_VISIBILITY",
       "UPDATE_FILTER",
   ]);
@@ -6515,7 +6674,7 @@
   const POSTFIX_UNARY_OPERATORS = ["%"];
   const OPERATORS = "+,-,*,/,:,=,<>,>=,>,<=,<,^,&".split(",").concat(POSTFIX_UNARY_OPERATORS);
   function tokenize(str, locale = DEFAULT_LOCALE) {
-      str = replaceSpecialSpaces(str);
+      str = replaceNewLines(str);
       const chars = new TokenizingChars(str);
       const result = [];
       while (!chars.isOver()) {
@@ -6662,12 +6821,12 @@
       if (length) {
           return { type: "SPACE", value: NEWLINE.repeat(length) };
       }
-      while (chars.current === " ") {
-          length++;
-          chars.shift();
+      let spaces = "";
+      while (chars.current && chars.current.match(whiteSpaceRegexp)) {
+          spaces += chars.shift();
       }
-      if (length) {
-          return { type: "SPACE", value: " ".repeat(length) };
+      if (spaces) {
+          return { type: "SPACE", value: spaces };
       }
       return null;
   }
@@ -7526,6 +7685,16 @@
       }
       return domainToString([...domain.slice(0, index), ...domain.slice(index + 1)]);
   }
+  function sortPivotTree(tree, baseDomain, sortFn) {
+      const sortedTree = [...tree];
+      const domain = [...baseDomain];
+      sortedTree.sort((node1, node2) => sortFn([...domain, node1], [...domain, node2]));
+      for (const node of tree) {
+          const children = sortPivotTree(node.children, [...domain, node], sortFn);
+          node.children = children;
+      }
+      return sortedTree;
+  }
 
   const pivotTimeAdapterRegistry = new Registry();
   function pivotTimeAdapter(granularity) {
@@ -8036,6 +8205,29 @@
           format: `${"    ".repeat(indent)}${format}* `,
       };
   }
+  function isSortedColumnValid(sortedColumn, pivot) {
+      try {
+          if (!pivot.getMeasure(sortedColumn.measure)) {
+              return false;
+          }
+          const columns = pivot.definition.columns;
+          for (let i = 0; i < sortedColumn.domain.length; i++) {
+              if (columns[i].nameWithGranularity !== sortedColumn.domain[i].field) {
+                  return false;
+              }
+              const possibleValues = pivot
+                  .getPossibleFieldValues(columns[i])
+                  .map((v) => v.value);
+              if (!possibleValues.includes(sortedColumn.domain[i].value)) {
+                  return false;
+              }
+          }
+          return true;
+      }
+      catch (e) {
+          return false;
+      }
+  }
 
   class CellClipboardHandler extends AbstractCellClipboardHandler {
       isCutAllowed(data) {
@@ -9515,6 +9707,12 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return relativeLuminance(backgroundColor) < 0.3 ? "#FFFFFF" : "#000000";
   }
+  function chartMutedFontColor(backgroundColor) {
+      if (!backgroundColor) {
+          return "#666666";
+      }
+      return relativeLuminance(backgroundColor) < 0.3 ? "#C8C8C8" : "#666666";
+  }
   function checkDataset(definition) {
       if (definition.dataSets) {
           const invalidRanges = definition.dataSets.find((range) => !rangeReference.test(range.dataRange)) !== undefined;
@@ -9650,8 +9848,8 @@ stores.inject(MyMetaStore, storeInstance);
       const yMin = chart.chartArea.top;
       const textsPositions = {};
       for (const dataset of chart._metasets) {
-          if (dataset.xAxisID === TREND_LINE_XAXIS_ID) {
-              return; // ignore trend lines
+          if (dataset.xAxisID === TREND_LINE_XAXIS_ID || dataset.hidden) {
+              continue;
           }
           for (let i = 0; i < dataset._parsed.length; i++) {
               const parsedValue = dataset._parsed[i];
@@ -10098,7 +10296,7 @@ stores.inject(MyMetaStore, storeInstance);
   function drawScoreChart(structure, canvas) {
       const ctx = canvas.getContext("2d");
       canvas.width = structure.canvas.width;
-      const availableWidth = canvas.width - DEFAULT_CHART_PADDING;
+      const availableWidth = canvas.width - CHART_PADDING$1 * 2;
       canvas.height = structure.canvas.height;
       ctx.fillStyle = structure.canvas.backgroundColor;
       ctx.fillRect(0, 0, structure.canvas.width, structure.canvas.height);
@@ -10233,10 +10431,9 @@ stores.inject(MyMetaStore, storeInstance);
   }
 
   /* Padding at the border of the chart */
-  const CHART_PADDING = SCORECARD_GAUGE_CHART_PADDING;
+  const CHART_PADDING = 10;
   const BOTTOM_PADDING_RATIO = 0.05;
   /* Maximum font sizes of each element */
-  const CHART_TITLE_FONT_SIZE = SCORECARD_GAUGE_CHART_FONT_SIZE;
   const KEY_VALUE_FONT_SIZE = 32;
   const BASELINE_MAX_FONT_SIZE = 16;
   function formatBaselineDescr(baselineDescr, baseline) {
@@ -10308,7 +10505,7 @@ stores.inject(MyMetaStore, storeInstance);
                       : this.height - (this.height - titleHeight - baselineHeight) / 2 - CHART_PADDING,
               },
           };
-          const minimalBaselinePosition = baselineArrowSize + DEFAULT_CHART_PADDING;
+          const minimalBaselinePosition = baselineArrowSize + CHART_PADDING * 2;
           if (structure.baseline.position.x < minimalBaselinePosition) {
               structure.baseline.position.x = minimalBaselinePosition;
           }
@@ -10388,7 +10585,7 @@ stores.inject(MyMetaStore, storeInstance);
           return this.runtime.background;
       }
       get secondaryFontColor() {
-          return relativeLuminance(this.backgroundColor) > 0.3 ? "#525252" : "#C8C8C8";
+          return chartMutedFontColor(this.backgroundColor);
       }
       getTextDimensions(text, font) {
           this.context.font = font;
@@ -10414,7 +10611,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return {
               title: {
-                  font: getDefaultContextFont(CHART_TITLE_FONT_SIZE, this.runtime.title.bold, this.runtime.title.italic),
+                  font: getDefaultContextFont(this.runtime.title.fontSize ?? SCORECARD_CHART_TITLE_FONT_SIZE, this.runtime.title.bold, this.runtime.title.italic),
                   color: this.runtime.title.color ?? this.secondaryFontColor,
               },
               keyValue: {
@@ -14639,7 +14836,7 @@ stores.inject(MyMetaStore, storeInstance);
       CellValueType.boolean,
   ];
   function cellsSortingCriterion(sortingOrder) {
-      const inverse = sortingOrder === "ascending" ? 1 : -1;
+      const inverse = sortingOrder === "asc" ? 1 : -1;
       return (left, right) => {
           if (left.type === CellValueType.empty) {
               return right.type === CellValueType.empty ? 0 : 1;
@@ -14731,7 +14928,7 @@ stores.inject(MyMetaStore, storeInstance);
       const sortColumns = [];
       const nRows = matrix.length;
       for (let i = 0; i < criteria.length; i += 2) {
-          sortingOrders.push(toBoolean(toScalar(criteria[i + 1])?.value) ? "ascending" : "descending");
+          sortingOrders.push(toBoolean(toScalar(criteria[i + 1])?.value) ? "asc" : "desc");
           const sortColumn = criteria[i];
           if (isMatrix(sortColumn) && (sortColumn.length > 1 || sortColumn[0].length > 1)) {
               assert(() => sortColumn.length === 1 && sortColumn[0].length === nRows, _t("Wrong size for %s. Expected a range of size 1x%s. Got %sx%s.", `sort_column${i + 1}`, nRows, sortColumn.length, sortColumn[0].length));
@@ -14748,12 +14945,12 @@ stores.inject(MyMetaStore, storeInstance);
       if (sortColumns.length === 0) {
           for (let i = 0; i < matrix[0].length; i++) {
               sortColumns.push(matrix.map((row) => row[i].value));
-              sortingOrders.push("ascending");
+              sortingOrders.push("asc");
           }
       }
       const sortingCriteria = {
-          descending: cellsSortingCriterion("descending"),
-          ascending: cellsSortingCriterion("ascending"),
+          desc: cellsSortingCriterion("desc"),
+          asc: cellsSortingCriterion("asc"),
       };
       const indexes = range(0, matrix.length);
       indexes.sort((a, b) => {
@@ -20477,20 +20674,8 @@ stores.inject(MyMetaStore, storeInstance);
       replaceSelectedRange(zone) {
           const ref = this.getZoneReference(zone);
           const currentToken = this.tokenAtCursor;
-          let replaceStart = this.selectionStart;
-          if (currentToken?.type === "REFERENCE") {
-              replaceStart = currentToken.start;
-          }
-          else if (currentToken?.type === "RIGHT_PAREN") {
-              // match left parenthesis
-              const leftParenthesisIndex = this.currentTokens.findIndex((token) => token.type === "LEFT_PAREN" && token.parenthesesCode === currentToken.parenthesesCode);
-              const functionToken = this.currentTokens[leftParenthesisIndex - 1];
-              if (functionToken === undefined) {
-                  return;
-              }
-              replaceStart = functionToken.start;
-          }
-          this.replaceText(ref, replaceStart, this.selectionEnd);
+          const start = currentToken?.type === "REFERENCE" ? currentToken.start : this.selectionStart;
+          this.replaceText(ref, start, this.selectionEnd);
       }
       /**
        * Replace the reference of the old zone by the new one.
@@ -20523,17 +20708,6 @@ stores.inject(MyMetaStore, storeInstance);
       getZoneReference(zone) {
           const inputSheetId = this.sheetId;
           const sheetId = this.getters.getActiveSheetId();
-          if (zone.top === zone.bottom && zone.left === zone.right) {
-              const position = { sheetId, col: zone.left, row: zone.top };
-              const pivotId = this.getters.getPivotIdFromPosition(position);
-              const pivotCell = this.getters.getPivotCellFromPosition(position);
-              const cell = this.getters.getCell(position);
-              if (pivotId && pivotCell.type !== "EMPTY" && !cell?.isFormula) {
-                  const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
-                  const formula = createPivotFormula(formulaPivotId, pivotCell);
-                  return localizeFormula(formula, this.getters.getLocale()).slice(1); // strip leading =
-              }
-          }
           const range = this.getters.getRangeFromZone(sheetId, zone);
           return this.getters.getSelectionRangeString(range, inputSheetId);
       }
@@ -20704,37 +20878,21 @@ stores.inject(MyMetaStore, storeInstance);
           const editionSheetId = this.sheetId;
           const rangeColor = (rangeString) => {
               const colorIndex = this.colorIndexByRange[rangeString];
-              return colors$1[colorIndex % colors$1.length];
+              return colors[colorIndex % colors.length];
           };
-          const highlights = [];
-          for (const range of this.getReferencedRanges()) {
+          return this.getReferencedRanges().map((range) => {
               const rangeString = this.getters.getRangeString(range, editionSheetId);
               const { numberOfRows, numberOfCols } = zoneToDimension(range.zone);
               const zone = numberOfRows * numberOfCols === 1
                   ? this.getters.expandZone(range.sheetId, range.zone)
                   : range.zone;
-              highlights.push({
+              return {
                   zone,
                   color: rangeColor(rangeString),
                   sheetId: range.sheetId,
                   interactive: true,
-              });
-          }
-          const activeSheetId = this.getters.getActiveSheetId();
-          const selectionZone = this.model.selection.getAnchor().zone;
-          const isSelectionHightlighted = highlights.find((highlight) => highlight.sheetId === activeSheetId && isEqual(highlight.zone, selectionZone));
-          if (this.editionMode === "selecting" && !isSelectionHightlighted) {
-              highlights.push({
-                  zone: selectionZone,
-                  color: "#445566",
-                  sheetId: activeSheetId,
-                  dashed: true,
-                  interactive: false,
-                  noFill: true,
-                  thinLine: true,
-              });
-          }
-          return highlights;
+              };
+          });
       }
       /**
        * Return ranges currently referenced in the composer
@@ -20962,6 +21120,7 @@ stores.inject(MyMetaStore, storeInstance);
                   return error;
               },
               isBadExpression: true,
+              normalizedFormula: tokens.map((t) => t.value).join(""),
           };
       }
   }
@@ -21089,6 +21248,7 @@ stores.inject(MyMetaStore, storeInstance);
           symbols,
           tokens,
           isBadExpression: false,
+          normalizedFormula: cacheKey,
       };
       return compiledFormula;
   }
@@ -21235,7 +21395,7 @@ stores.inject(MyMetaStore, storeInstance);
 
   const PIVOT_FUNCTIONS = ["PIVOT.VALUE", "PIVOT.HEADER", "PIVOT"];
   /**
-   * Create a proposal entry for the compose autowcomplete
+   * Create a proposal entry for the composer autocomplete
    * to insert a field name string in a formula.
    */
   function makeFieldProposal(field, granularity) {
@@ -21353,6 +21513,7 @@ stores.inject(MyMetaStore, storeInstance);
                   description: definition.name,
                   htmlContent: [{ value: str, color: tokenColors.NUMBER }],
                   fuzzySearchKey: str + definition.name,
+                  alwaysExpanded: true,
               };
           })
               .filter(isDefined);
@@ -22018,14 +22179,8 @@ stores.inject(MyMetaStore, storeInstance);
   const GAUGE_LABELS_FONT_SIZE = 12;
   const GAUGE_DEFAULT_VALUE_FONT_SIZE = 80;
   const GAUGE_BACKGROUND_COLOR = "#F3F2F1";
-  const GAUGE_TEXT_COLOR = "#666666";
-  const GAUGE_TEXT_COLOR_HIGH_CONTRAST = "#C8C8C8";
-  const GAUGE_INFLECTION_MARKER_COLOR = "#666666aa";
   const GAUGE_INFLECTION_LABEL_BOTTOM_MARGIN = 6;
   const GAUGE_TITLE_SECTION_HEIGHT = 25;
-  const GAUGE_TITLE_FONT_SIZE = SCORECARD_GAUGE_CHART_FONT_SIZE;
-  const GAUGE_TITLE_PADDING_LEFT = SCORECARD_GAUGE_CHART_PADDING;
-  const GAUGE_TITLE_PADDING_TOP = SCORECARD_GAUGE_CHART_PADDING;
   function drawGaugeChart(canvas, runtime) {
       const canvasBoundingRect = canvas.getBoundingClientRect();
       canvas.width = canvasBoundingRect.width;
@@ -22084,7 +22239,7 @@ stores.inject(MyMetaStore, storeInstance);
           ctx.translate(rectX + width / 2 - 0.5, rectY + height - 0.5); // -0.5 for sharper lines. see RendererPlugin.drawBorders comment
           ctx.rotate(Math.PI / 2 - inflectionValue.rotation);
           ctx.lineWidth = 2;
-          ctx.strokeStyle = GAUGE_INFLECTION_MARKER_COLOR;
+          ctx.strokeStyle = chartMutedFontColor(config.backgroundColor) + "aa";
           ctx.beginPath();
           ctx.moveTo(0, -(height - config.gauge.arcWidth));
           ctx.lineTo(0, -height - 3);
@@ -22138,22 +22293,22 @@ stores.inject(MyMetaStore, storeInstance);
           x: gaugeRect.x + gaugeRect.width - gaugeArcWidth / 2,
           y: gaugeRect.y + gaugeRect.height + GAUGE_LABELS_FONT_SIZE,
       };
-      const textColor = getContrastedTextColor(runtime.background);
+      const textColor = chartMutedFontColor(runtime.background);
       const inflectionValues = getInflectionValues(runtime, gaugeRect, textColor, ctx);
       let x = 0, titleWidth = 0, titleHeight = 0;
       if (runtime.title.text) {
-          ({ width: titleWidth, height: titleHeight } = computeTextDimension(ctx, runtime.title.text, { ...runtime.title, fontSize: GAUGE_TITLE_FONT_SIZE }, "px"));
+          ({ width: titleWidth, height: titleHeight } = computeTextDimension(ctx, runtime.title.text, { fontSize: CHART_TITLE_FONT_SIZE, ...runtime.title }, "px"));
       }
       switch (runtime.title.align) {
           case "right":
-              x = boundingRect.width - titleWidth - GAUGE_TITLE_PADDING_LEFT;
+              x = boundingRect.width - titleWidth - CHART_PADDING$1;
               break;
           case "center":
               x = (boundingRect.width - titleWidth) / 2;
               break;
           case "left":
           default:
-              x = GAUGE_TITLE_PADDING_LEFT;
+              x = CHART_PADDING$1;
               break;
       }
       return {
@@ -22161,10 +22316,10 @@ stores.inject(MyMetaStore, storeInstance);
           height: boundingRect.height,
           title: {
               label: runtime.title.text ?? "",
-              fontSize: GAUGE_TITLE_FONT_SIZE,
+              fontSize: runtime.title.fontSize ?? CHART_TITLE_FONT_SIZE,
               textPosition: {
                   x,
-                  y: GAUGE_TITLE_PADDING_TOP + titleHeight / 2,
+                  y: CHART_PADDING_TOP + titleHeight / 2,
               },
               color: runtime.title.color ?? textColor,
               bold: runtime.title.bold,
@@ -22281,11 +22436,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return runtime.colors.at(-1);
   }
-  function getContrastedTextColor(backgroundColor) {
-      return relativeLuminance(backgroundColor) > 0.3
-          ? GAUGE_TEXT_COLOR
-          : GAUGE_TEXT_COLOR_HIGH_CONTRAST;
-  }
   function getSegmentsOfRectangle(rectangle) {
       return [
           { start: rectangle.topLeft, end: rectangle.topRight },
@@ -26999,13 +27149,12 @@ stores.inject(MyMetaStore, storeInstance);
       versionFrom: "7",
       migrate(data) {
           const namesTaken = [];
-          const globalForbiddenInExcel = new RegExp(FORBIDDEN_IN_EXCEL_REGEX, "g");
           for (let sheet of data.sheets || []) {
               if (!sheet.name) {
                   continue;
               }
               const oldName = sheet.name;
-              const escapedName = oldName.replace(globalForbiddenInExcel, "_");
+              const escapedName = sanitizeSheetName(oldName, "_");
               let i = 1;
               let newName = escapedName;
               while (namesTaken.includes(newName)) {
@@ -27758,6 +27907,19 @@ stores.inject(MyMetaStore, storeInstance);
           ["GaugeLowerInflectionPointNaN" /* CommandResult.GaugeLowerInflectionPointNaN */]: _t("The lower inflection point value must be a number"),
           ["GaugeUpperInflectionPointNaN" /* CommandResult.GaugeUpperInflectionPointNaN */]: _t("The upper inflection point value must be a number"),
       },
+      GeoChart: {
+          ColorScales: {
+              blues: _t("Blues"),
+              cividis: _t("Cividis"),
+              greens: _t("Greens"),
+              greys: _t("Greys"),
+              oranges: _t("Oranges"),
+              purples: _t("Purples"),
+              rainbow: _t("Rainbow"),
+              reds: _t("Reds"),
+              viridis: _t("Viridis"),
+          },
+      },
   };
   const CustomCurrencyTerms = {
       Custom: _t("Custom"),
@@ -28161,6 +28323,26 @@ stores.inject(MyMetaStore, storeInstance);
           locale: getters.getLocale(),
       };
   }
+  function getGeoChartData(definition, dataSets, labelRange, getters) {
+      const labelValues = getChartLabelValues(getters, dataSets, labelRange);
+      let labels = labelValues.formattedValues;
+      if (definition.dataSetsHaveTitle) {
+          labels.shift();
+      }
+      let dataSetsValues = getChartDatasetValues(getters, dataSets);
+      ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
+      const format = getChartDatasetFormat(getters, dataSets, "left") ||
+          getChartDatasetFormat(getters, dataSets, "right");
+      return {
+          dataSetsValues,
+          axisFormats: { y: format },
+          labels,
+          locale: getters.getLocale(),
+          availableRegions: getters.getGeoChartAvailableRegions(),
+          geoFeatureNameToId: getters.geoFeatureNameToId,
+          getGeoJsonFeatures: getters.getGeoJsonFeatures,
+      };
+  }
   function getTrendDatasetForBarChart(config, data) {
       const filteredValues = [];
       const filteredLabels = [];
@@ -28241,37 +28423,45 @@ stores.inject(MyMetaStore, storeInstance);
       const labelRange = labelMax - labelMin;
       const normalizedLabels = labels.map((v) => (v - labelMin) / labelRange);
       const normalizedNewLabels = newLabels.map((v) => (v - labelMin) / labelRange);
-      switch (config.type) {
-          case "polynomial": {
-              const order = config.order ?? 2;
-              if (order === 1) {
-                  return predictLinearValues([values], [normalizedLabels], [normalizedNewLabels], true)[0];
-              }
-              const coeffs = polynomialRegression(values, normalizedLabels, order, true).flat();
-              return normalizedNewLabels.map((v) => evaluatePolynomial(coeffs, v, order));
-          }
-          case "exponential": {
-              const positiveLogValues = [];
-              const filteredLabels = [];
-              for (let i = 0; i < values.length; i++) {
-                  if (values[i] > 0) {
-                      positiveLogValues.push(Math.log(values[i]));
-                      filteredLabels.push(normalizedLabels[i]);
+      try {
+          switch (config.type) {
+              case "polynomial": {
+                  const order = config.order;
+                  if (!order) {
+                      return Array.from({ length: newLabels.length }, () => NaN);
+                  }
+                  if (order === 1) {
+                      return predictLinearValues([values], [normalizedLabels], [normalizedNewLabels], true)[0];
+                  }
+                  const coeffs = polynomialRegression(values, normalizedLabels, order, true).flat();
+                  return normalizedNewLabels.map((v) => evaluatePolynomial(coeffs, v, order));
+              }
+              case "exponential": {
+                  const positiveLogValues = [];
+                  const filteredLabels = [];
+                  for (let i = 0; i < values.length; i++) {
+                      if (values[i] > 0) {
+                          positiveLogValues.push(Math.log(values[i]));
+                          filteredLabels.push(normalizedLabels[i]);
+                      }
+                  }
+                  if (!filteredLabels.length) {
+                      return Array.from({ length: newLabels.length }, () => NaN);
                   }
+                  return expM(predictLinearValues([positiveLogValues], [filteredLabels], [normalizedNewLabels], true))[0];
               }
-              if (!filteredLabels.length) {
-                  return [];
+              case "logarithmic": {
+                  return predictLinearValues([values], logM([normalizedLabels]), logM([normalizedNewLabels]), true)[0];
               }
-              return expM(predictLinearValues([positiveLogValues], [filteredLabels], [normalizedNewLabels], true))[0];
-          }
-          case "logarithmic": {
-              return predictLinearValues([values], logM([normalizedLabels]), logM([normalizedNewLabels]), true)[0];
-          }
-          case "trailingMovingAverage": {
-              return getMovingAverageValues(values, config.window);
+              case "trailingMovingAverage": {
+                  return getMovingAverageValues(values, config.window);
+              }
+              default:
+                  return Array.from({ length: newLabels.length }, () => NaN);
           }
-          default:
-              return [];
+      }
+      catch (e) {
+          return Array.from({ length: newLabels.length }, () => NaN);
       }
   }
   function getChartAxisType(chart, labelRange, getters) {
@@ -28705,6 +28895,43 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return datasets;
   }
+  function getGeoChartDatasets(definition, args) {
+      const { availableRegions, dataSetsValues, labels } = args;
+      const regionName = definition.region || availableRegions[0]?.id;
+      const features = regionName ? args.getGeoJsonFeatures(regionName) : undefined;
+      const dataset = {
+          outline: features,
+          showOutline: !!features,
+          data: [],
+      };
+      if (features && regionName) {
+          const labelsAndValues = {};
+          if (dataSetsValues[0]) {
+              for (let i = 0; i < dataSetsValues[0].data.length; i++) {
+                  if (!labels[i] || dataSetsValues[0].data[i] === undefined) {
+                      continue;
+                  }
+                  const featureId = args.geoFeatureNameToId(regionName, labels[i]);
+                  if (featureId) {
+                      labelsAndValues[featureId] = { value: dataSetsValues[0].data[i], label: labels[i] };
+                  }
+              }
+          }
+          for (const feature of features) {
+              if (!feature.id) {
+                  continue;
+              }
+              dataset.data.push({
+                  feature: {
+                      ...feature,
+                      properties: { name: labelsAndValues[feature.id]?.label },
+                  },
+                  value: labelsAndValues[feature.id]?.value,
+              });
+          }
+      }
+      return [dataset];
+  }
   function getTrendingLineDataSet(dataset, config, data) {
       const defaultBorderColor = colorToRGBA(dataset.backgroundColor);
       defaultBorderColor.a = 1;
@@ -28742,54 +28969,16 @@ stores.inject(MyMetaStore, storeInstance);
       return new ColorGenerator(dataSetsSize, definition.dataSets?.map((ds) => ds.backgroundColor) || []);
   }
 
-  function getCommonChartLayout(definition) {
-      // TODO FIXME: this is unused ATM. All the charts should probably use this instead oh whatever padding they are using now
-      // also look into how DEFAULT_CHART_PADDING is used in scorecards, it look strange
+  function getChartLayout(definition) {
       return {
           padding: {
-              left: DEFAULT_CHART_PADDING,
-              right: DEFAULT_CHART_PADDING,
-              top: definition.title?.text ? DEFAULT_CHART_PADDING / 2 : DEFAULT_CHART_PADDING + 5,
-              bottom: DEFAULT_CHART_PADDING,
+              left: CHART_PADDING$1,
+              right: CHART_PADDING$1,
+              top: CHART_PADDING_TOP,
+              bottom: CHART_PADDING_BOTTOM,
           },
       };
   }
-  function getBarChartLayout(definition) {
-      return {
-          padding: computeChartPadding({
-              displayTitle: !!definition.title?.text,
-              displayLegend: definition.legendPosition === "top",
-          }),
-      };
-  }
-  function getLineChartLayout(definition) {
-      return {
-          padding: computeChartPadding({
-              displayTitle: !!definition.title?.text,
-              displayLegend: definition.legendPosition === "top",
-          }),
-      };
-  }
-  function getPieChartLayout(definition) {
-      return {
-          padding: { left: 20, right: 20, top: definition.title ? 10 : 25, bottom: 10 },
-      };
-  }
-  function getWaterfallChartLayout(definition) {
-      return {
-          padding: { left: 20, right: 20, top: definition.title ? 10 : 25, bottom: 10 },
-      };
-  }
-  function computeChartPadding({ displayTitle, displayLegend, }) {
-      let top = 25;
-      if (displayTitle) {
-          top = 0;
-      }
-      else if (displayLegend) {
-          top = 10;
-      }
-      return { left: 20, right: 20, top, bottom: 10 };
-  }
 
   function getLegendDisplayOptions(definition, args) {
       return {
@@ -28847,11 +29036,12 @@ stores.inject(MyMetaStore, storeInstance);
       return {
           ...INTERACTIVE_LEGEND_CONFIG,
           ...getLegendDisplayOptions(definition),
-          labels: {
-              color: chartFontColor(definition.background),
-              boxHeight: 6,
-              usePointStyle: true,
-          },
+          ...getCustomLegendLabels(chartFontColor(definition.background), {
+              pointStyle: "circle",
+              // the stroke is the border around the circle, so increasing its size with the chart's color reduce the size of the circle
+              strokeStyle: definition.background || "#ffffff",
+              lineWidth: 8,
+          }),
       };
   }
   function getComboChartLegend(definition, args) {
@@ -28940,10 +29130,10 @@ stores.inject(MyMetaStore, storeInstance);
           target.style.cursor = "default";
       },
       onClick: (event, legendItem, legend) => {
-          if (!legend.legendItems) {
+          const index = legendItem.datasetIndex;
+          if (!legend.legendItems || index === undefined) {
               return;
           }
-          const index = legend.legendItems.indexOf(legendItem);
           if (legend.chart.isDatasetVisible(index)) {
               legend.chart.hide(index);
           }
@@ -28959,15 +29149,29 @@ stores.inject(MyMetaStore, storeInstance);
           labels: {
               color: fontColor,
               usePointStyle: true,
-              generateLabels: (chart) => chart.data.datasets.map((dataset, index) => ({
-                  text: dataset.label ?? "",
-                  fontColor,
-                  strokeStyle: dataset.borderColor,
-                  fillStyle: dataset.backgroundColor,
-                  hidden: !chart.isDatasetVisible(index),
-                  pointStyle: dataset.type === "line" ? "line" : "rect",
-                  ...legendLabelConfig,
-              })),
+              generateLabels: (chart) => chart.data.datasets.map((dataset, index) => {
+                  if (dataset["xAxisID"] === TREND_LINE_XAXIS_ID) {
+                      return {
+                          text: dataset.label ?? "",
+                          fontColor,
+                          strokeStyle: dataset.borderColor,
+                          hidden: !chart.isDatasetVisible(index),
+                          pointStyle: "line",
+                          datasetIndex: index,
+                          lineWidth: 3,
+                      };
+                  }
+                  return {
+                      text: dataset.label ?? "",
+                      fontColor,
+                      strokeStyle: dataset.borderColor,
+                      fillStyle: dataset.backgroundColor,
+                      hidden: !chart.isDatasetVisible(index),
+                      pointStyle: dataset.type === "line" ? "line" : "rect",
+                      datasetIndex: index,
+                      ...legendLabelConfig,
+                  };
+              }),
           },
       };
   }
@@ -29105,6 +29309,44 @@ stores.inject(MyMetaStore, storeInstance);
           },
       };
   }
+  function getGeoChartScales(definition, args) {
+      const { locale, axisFormats, availableRegions } = args;
+      const geoLegendPosition = legendPositionToGeoLegendPosition(definition.legendPosition);
+      const region = definition.region
+          ? availableRegions.find((r) => r.id === definition.region)
+          : availableRegions[0];
+      const format = axisFormats?.y || axisFormats?.y1;
+      return {
+          projection: {
+              // projection: region?.defaultProjection,
+              projection: getGeoChartProjection(region?.defaultProjection || "mercator"),
+              axis: "x",
+          },
+          color: {
+              axis: "x",
+              display: definition.legendPosition !== "none",
+              border: { color: GRAY_300 },
+              grid: { color: GRAY_300 },
+              ticks: {
+                  color: chartFontColor(definition.background),
+                  callback: formatTickValue({ locale, format }),
+              },
+              legend: {
+                  position: geoLegendPosition,
+                  align: geoLegendPosition.includes("right") ? "left" : "right",
+                  margin: getLegendMargin(definition),
+              },
+              interpolate: getRuntimeColorScale(definition),
+              missing: definition.missingValueColor || "#ffffff",
+          },
+      };
+  }
+  function getGeoChartProjection(projection) {
+      if (projection === "conicConformal") {
+          return window.ChartGeo.geoConicConformal().rotate([100, 0]); // Centered on the US
+      }
+      return projection;
+  }
   function getChartAxisTitleRuntime(design) {
       if (design?.title?.text) {
           const { text, color, align, italic, bold } = design.title;
@@ -29115,6 +29357,7 @@ stores.inject(MyMetaStore, storeInstance);
               font: {
                   style: italic ? "italic" : "normal",
                   weight: bold ? "bold" : "normal",
+                  size: design.title.fontSize ?? CHART_AXIS_TITLE_FONT_SIZE,
               },
               align: align === "left" ? "start" : align === "right" ? "end" : "center",
           };
@@ -29167,6 +29410,44 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
   }
+  function getRuntimeColorScale(definition) {
+      if (!definition.colorScale || typeof definition.colorScale === "string") {
+          return definition.colorScale || "oranges";
+      }
+      const scaleColors = [{ value: 0, color: definition.colorScale.minColor }];
+      if (definition.colorScale.midColor) {
+          scaleColors.push({ value: 0.5, color: definition.colorScale.midColor });
+      }
+      scaleColors.push({ value: 1, color: definition.colorScale.maxColor });
+      return getColorScale(scaleColors);
+  }
+  function getLegendMargin(definition) {
+      switch (definition.legendPosition) {
+          case "top":
+          case "right":
+              const hasTitle = !!definition.title.text;
+              const topMargin = hasTitle ? CHART_PADDING_TOP + 30 : CHART_PADDING_TOP;
+              return { top: topMargin, left: CHART_PADDING$1, right: CHART_PADDING$1 };
+          case "bottom":
+          case "left":
+          case "none":
+              return { left: CHART_PADDING$1, right: CHART_PADDING$1, bottom: CHART_PADDING_BOTTOM };
+      }
+  }
+  function legendPositionToGeoLegendPosition(position) {
+      switch (position) {
+          case "top":
+              return "top-left";
+          case "right":
+              return "top-right";
+          case "bottom":
+              return "bottom-right";
+          case "left":
+              return "bottom-left";
+          case "none":
+              return "bottom-left";
+      }
+  }
 
   function getChartShowValues(definition, args) {
       const { axisFormats, locale } = args;
@@ -29180,17 +29461,22 @@ stores.inject(MyMetaStore, storeInstance);
 
   function getChartTitle(definition) {
       const chartTitle = definition.title;
-      const fontColor = chartFontColor(definition.background);
+      const fontColor = chartMutedFontColor(definition.background);
       return {
           display: !!chartTitle.text,
           text: _t(chartTitle.text),
           color: chartTitle?.color ?? fontColor,
           align: chartTitle.align === "center" ? "center" : chartTitle.align === "right" ? "end" : "start",
           font: {
-              size: DEFAULT_CHART_FONT_SIZE,
+              size: definition.title.fontSize ?? CHART_TITLE_FONT_SIZE,
               weight: chartTitle.bold ? "bold" : "normal",
               style: chartTitle.italic ? "italic" : "normal",
           },
+          padding: {
+              // Disable title top/left/right padding to use the chart padding instead.
+              // The legend already has a top padding, so bottom padding is useless for the title there.
+              bottom: definition.legendPosition === "top" ? 0 : CHART_PADDING$1,
+          },
       };
   }
 
@@ -29321,6 +29607,25 @@ stores.inject(MyMetaStore, storeInstance);
           },
       };
   }
+  function getGeoChartTooltip(definition, args) {
+      const { locale, axisFormats } = args;
+      const format = axisFormats?.y || axisFormats?.y1;
+      return {
+          filter: function (tooltipItem) {
+              return tooltipItem.raw.value !== undefined;
+          },
+          callbacks: {
+              label: function (tooltipItem) {
+                  const rawItem = tooltipItem.raw;
+                  const xLabel = rawItem.feature.properties.name;
+                  const yLabel = rawItem.value;
+                  const toolTipFormat = !format && Math.abs(yLabel) >= 1000 ? "#,##" : format;
+                  const yLabelStr = formatValue(yLabel, { format: toolTipFormat, locale });
+                  return xLabel ? `${xLabel}: ${yLabelStr}` : yLabelStr;
+              },
+          },
+      };
+  }
   function calculatePercentage(dataset, dataIndex) {
       const numericData = dataset.filter((value) => typeof value === "number");
       const total = numericData.reduce((sum, value) => sum + value, 0);
@@ -29337,26 +29642,27 @@ stores.inject(MyMetaStore, storeInstance);
     canChartParseLabels: canChartParseLabels,
     getBarChartData: getBarChartData,
     getBarChartDatasets: getBarChartDatasets,
-    getBarChartLayout: getBarChartLayout,
     getBarChartLegend: getBarChartLegend,
     getBarChartScales: getBarChartScales,
     getBarChartTooltip: getBarChartTooltip,
     getChartLabelFormat: getChartLabelFormat,
+    getChartLayout: getChartLayout,
     getChartShowValues: getChartShowValues,
     getChartTitle: getChartTitle,
     getComboChartDatasets: getComboChartDatasets,
     getComboChartLegend: getComboChartLegend,
-    getCommonChartLayout: getCommonChartLayout,
     getData: getData,
+    getGeoChartData: getGeoChartData,
+    getGeoChartDatasets: getGeoChartDatasets,
+    getGeoChartScales: getGeoChartScales,
+    getGeoChartTooltip: getGeoChartTooltip,
     getLineChartData: getLineChartData,
     getLineChartDatasets: getLineChartDatasets,
-    getLineChartLayout: getLineChartLayout,
     getLineChartLegend: getLineChartLegend,
     getLineChartScales: getLineChartScales,
     getLineChartTooltip: getLineChartTooltip,
     getPieChartData: getPieChartData,
     getPieChartDatasets: getPieChartDatasets,
-    getPieChartLayout: getPieChartLayout,
     getPieChartLegend: getPieChartLegend,
     getPieChartTooltip: getPieChartTooltip,
     getPyramidChartData: getPyramidChartData,
@@ -29372,7 +29678,6 @@ stores.inject(MyMetaStore, storeInstance);
     getScatterChartScales: getScatterChartScales,
     getTrendDatasetForBarChart: getTrendDatasetForBarChart,
     getTrendDatasetForLineChart: getTrendDatasetForLineChart,
-    getWaterfallChartLayout: getWaterfallChartLayout,
     getWaterfallChartLegend: getWaterfallChartLegend,
     getWaterfallChartScales: getWaterfallChartScales,
     getWaterfallChartTooltip: getWaterfallChartTooltip,
@@ -29520,7 +29825,7 @@ stores.inject(MyMetaStore, storeInstance);
           options: {
               ...CHART_COMMON_OPTIONS,
               indexAxis: chart.horizontal ? "y" : "x",
-              layout: getBarChartLayout(definition),
+              layout: getChartLayout(),
               scales: getBarChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -29672,7 +29977,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getBarChartLayout(definition),
+              layout: getChartLayout(),
               scales: getBarChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -29924,6 +30229,133 @@ stores.inject(MyMetaStore, storeInstance);
       return clip(value, minValue, maxValue);
   }
 
+  class GeoChart extends AbstractChart {
+      dataSets;
+      labelRange;
+      background;
+      legendPosition;
+      type = "geo";
+      dataSetsHaveTitle;
+      dataSetDesign;
+      colorScale;
+      missingValueColor;
+      region;
+      constructor(definition, sheetId, getters) {
+          super(definition, sheetId, getters);
+          this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
+          this.labelRange = createValidRange(getters, sheetId, definition.labelRange);
+          this.background = definition.background;
+          this.legendPosition = definition.legendPosition;
+          this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
+          this.dataSetDesign = definition.dataSets;
+          this.colorScale = definition.colorScale;
+          this.missingValueColor = definition.missingValueColor;
+          this.region = definition.region;
+      }
+      static transformDefinition(definition, executed) {
+          return transformChartDefinitionWithDataSetsWithZone(definition, executed);
+      }
+      static validateChartDefinition(validator, definition) {
+          return validator.checkValidations(definition, checkDataset, checkLabelRange);
+      }
+      static getDefinitionFromContextCreation(context) {
+          return {
+              background: context.background,
+              dataSets: context.range ?? [],
+              dataSetsHaveTitle: context.dataSetsHaveTitle ?? false,
+              legendPosition: context.legendPosition ?? "top",
+              title: context.title || { text: "" },
+              type: "geo",
+              labelRange: context.auxiliaryRange || undefined,
+              aggregated: context.aggregated,
+          };
+      }
+      getContextCreation() {
+          const range = [];
+          for (const [i, dataSet] of this.dataSets.entries()) {
+              range.push({
+                  ...this.dataSetDesign?.[i],
+                  dataRange: this.getters.getRangeString(dataSet.dataRange, this.sheetId),
+              });
+          }
+          return {
+              ...this,
+              range,
+              auxiliaryRange: this.labelRange
+                  ? this.getters.getRangeString(this.labelRange, this.sheetId)
+                  : undefined,
+          };
+      }
+      copyForSheetId(sheetId) {
+          const dataSets = copyDataSetsWithNewSheetId(this.sheetId, sheetId, this.dataSets);
+          const labelRange = copyLabelRangeWithNewSheetId(this.sheetId, sheetId, this.labelRange);
+          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange, sheetId);
+          return new GeoChart(definition, sheetId, this.getters);
+      }
+      copyInSheetId(sheetId) {
+          const definition = this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange, sheetId);
+          return new GeoChart(definition, sheetId, this.getters);
+      }
+      getDefinition() {
+          return this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange);
+      }
+      getDefinitionWithSpecificDataSets(dataSets, labelRange, targetSheetId) {
+          const ranges = [];
+          for (const [i, dataSet] of dataSets.entries()) {
+              ranges.push({
+                  ...this.dataSetDesign?.[i],
+                  dataRange: this.getters.getRangeString(dataSet.dataRange, targetSheetId || this.sheetId),
+              });
+          }
+          return {
+              type: "geo",
+              dataSetsHaveTitle: dataSets.length ? Boolean(dataSets[0].labelCell) : false,
+              background: this.background,
+              dataSets: ranges,
+              legendPosition: this.legendPosition,
+              labelRange: labelRange
+                  ? this.getters.getRangeString(labelRange, targetSheetId || this.sheetId)
+                  : undefined,
+              title: this.title,
+              colorScale: this.colorScale,
+              missingValueColor: this.missingValueColor,
+              region: this.region,
+          };
+      }
+      getDefinitionForExcel() {
+          return undefined;
+      }
+      updateRanges(applyChange) {
+          const { dataSets, labelRange, isStale } = updateChartRangesWithDataSets(this.getters, applyChange, this.dataSets, this.labelRange);
+          if (!isStale) {
+              return this;
+          }
+          const definition = this.getDefinitionWithSpecificDataSets(dataSets, labelRange);
+          return new GeoChart(definition, this.sheetId, this.getters);
+      }
+  }
+  function createGeoChartRuntime(chart, getters) {
+      const definition = chart.getDefinition();
+      const chartData = getGeoChartData(definition, chart.dataSets, chart.labelRange, getters);
+      const config = {
+          type: "choropleth",
+          data: {
+              datasets: getGeoChartDatasets(definition, chartData),
+          },
+          options: {
+              ...CHART_COMMON_OPTIONS,
+              layout: getChartLayout(),
+              scales: getGeoChartScales(definition, chartData),
+              plugins: {
+                  title: getChartTitle(definition),
+                  tooltip: getGeoChartTooltip(definition, chartData),
+                  legend: { display: false },
+              },
+          },
+      };
+      return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
+  }
+
   class LineChart extends AbstractChart {
       dataSets;
       labelRange;
@@ -30073,7 +30505,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getLineChartLayout(definition),
+              layout: getChartLayout(),
               scales: getLineChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -30208,7 +30640,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getPieChartLayout(definition),
+              layout: getChartLayout(),
               plugins: {
                   title: getChartTitle(definition),
                   legend: getPieChartLegend(definition, chartData),
@@ -30345,7 +30777,7 @@ stores.inject(MyMetaStore, storeInstance);
           options: {
               ...CHART_COMMON_OPTIONS,
               indexAxis: "y",
-              layout: getBarChartLayout(definition),
+              layout: getChartLayout(),
               scales: getPyramidChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -30494,7 +30926,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getBarChartLayout(definition),
+              layout: getChartLayout(),
               scales: getRadarChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -30647,7 +31079,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getLineChartLayout(definition),
+              layout: getChartLayout(),
               scales: getScatterChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -30808,7 +31240,7 @@ stores.inject(MyMetaStore, storeInstance);
           },
           options: {
               ...CHART_COMMON_OPTIONS,
-              layout: getWaterfallChartLayout(definition),
+              layout: getChartLayout(),
               scales: getWaterfallChartScales(definition, chartData),
               plugins: {
                   title: getChartTitle(definition),
@@ -30917,6 +31349,15 @@ stores.inject(MyMetaStore, storeInstance);
       getChartDefinitionFromContextCreation: RadarChart.getDefinitionFromContextCreation,
       sequence: 80,
   });
+  chartRegistry.add("geo", {
+      match: (type) => type === "geo",
+      createChart: (definition, sheetId, getters) => new GeoChart(definition, sheetId, getters),
+      getChartRuntime: createGeoChartRuntime,
+      validateChartDefinition: GeoChart.validateChartDefinition,
+      transformDefinition: GeoChart.transformDefinition,
+      getChartDefinitionFromContextCreation: GeoChart.getDefinitionFromContextCreation,
+      sequence: 90,
+  });
   const chartComponentRegistry = new Registry();
   chartComponentRegistry.add("line", ChartJsComponent);
   chartComponentRegistry.add("bar", ChartJsComponent);
@@ -30928,6 +31369,7 @@ stores.inject(MyMetaStore, storeInstance);
   chartComponentRegistry.add("waterfall", ChartJsComponent);
   chartComponentRegistry.add("pyramid", ChartJsComponent);
   chartComponentRegistry.add("radar", ChartJsComponent);
+  chartComponentRegistry.add("geo", ChartJsComponent);
   const chartCategories = {
       line: _t("Line"),
       column: _t("Column"),
@@ -31087,6 +31529,13 @@ stores.inject(MyMetaStore, storeInstance);
       subtypeDefinition: { fillArea: true },
       category: "misc",
       preview: "o-spreadsheet-ChartPreview.FILLED_RADAR_CHART",
+  })
+      .add("geo", {
+      displayName: _t("Geo Chart"),
+      chartSubtype: "geo",
+      chartType: "geo",
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.GEO_CHART",
   });
 
   /**
@@ -31937,18 +32386,66 @@ stores.inject(MyMetaStore, storeInstance);
       },
   };
 
-  css /*SCSS*/ `
-  .o-filter-menu-value {
-    padding: 4px;
-    line-height: 20px;
-    height: 28px;
-    .o-filter-menu-value-checked {
-      width: 20px;
+  const CHECK_SVG = /*xml*/ `
+<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'>
+  <path fill='none' stroke='#FFF' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/>
+</svg>
+`;
+  const CHECKBOX_WIDTH = 14;
+  css /* scss */ `
+  label.o-checkbox {
+    input {
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      border-radius: 0;
+      width: ${CHECKBOX_WIDTH}px;
+      height: ${CHECKBOX_WIDTH}px;
+      vertical-align: top;
+      box-sizing: border-box;
+      outline: none;
+      border: 1px solid ${GRAY_300};
+      cursor: pointer;
+
+      &:hover {
+        border-color: ${ACTION_COLOR};
+      }
+
+      &:checked {
+        background: url("data:image/svg+xml,${encodeURIComponent(CHECK_SVG)}");
+        background-color: ${ACTION_COLOR};
+        border-color: ${ACTION_COLOR};
+      }
+
+      &:focus {
+        outline: none;
+        box-shadow: 0 0 0 0.25rem rgba(113, 75, 103, 0.25);
+        border-color: ${ACTION_COLOR};
+      }
     }
   }
 `;
+  class Checkbox extends owl.Component {
+      static template = "o-spreadsheet.Checkbox";
+      static props = {
+          label: { type: String, optional: true },
+          value: { type: Boolean, optional: true },
+          className: { type: String, optional: true },
+          name: { type: String, optional: true },
+          title: { type: String, optional: true },
+          disabled: { type: Boolean, optional: true },
+          onChange: Function,
+      };
+      static defaultProps = { value: false };
+      onChange(ev) {
+          const value = ev.target.checked;
+          this.props.onChange(value);
+      }
+  }
+
   class FilterMenuValueItem extends owl.Component {
       static template = "o-spreadsheet-FilterMenuValueItem";
+      static components = { Checkbox };
       static props = {
           value: String,
           isChecked: Boolean,
@@ -31986,8 +32483,6 @@ stores.inject(MyMetaStore, storeInstance);
     .o-filter-menu-item {
       display: flex;
       box-sizing: border-box;
-      height: ${MENU_ITEM_HEIGHT}px;
-      padding: 4px 4px 4px 0px;
       cursor: pointer;
       user-select: none;
 
@@ -31996,14 +32491,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
     }
 
-    input {
-      box-sizing: border-box;
-      margin-bottom: 5px;
-      border: 1px solid #949494;
-      height: 24px;
-      padding-right: 28px;
-    }
-
     .o-search-icon {
       right: 5px;
       top: 3px;
@@ -32020,19 +32507,12 @@ stores.inject(MyMetaStore, storeInstance);
       display: flex;
       flex-direction: row;
       margin-bottom: 4px;
-
-      .o-filter-menu-action-text {
-        cursor: pointer;
-        margin-right: 10px;
-        color: blue;
-        text-decoration: underline;
-      }
     }
 
     .o-filter-menu-list {
       flex: auto;
       overflow-y: auto;
-      border: 1px solid #949494;
+      border: 1px solid ${GRAY_300};
 
       .o-filter-menu-no-values {
         color: #949494;
@@ -33118,6 +33598,7 @@ stores.inject(MyMetaStore, storeInstance);
     adaptChartRange: adaptChartRange,
     chartFactory: chartFactory,
     chartFontColor: chartFontColor,
+    chartMutedFontColor: chartMutedFontColor,
     chartRuntimeFactory: chartRuntimeFactory,
     chartToImage: chartToImage,
     checkDataset: checkDataset,
@@ -34223,6 +34704,21 @@ stores.inject(MyMetaStore, storeInstance);
       isReadonlyAllowed: true,
       icon: "o-spreadsheet-Icon.PIVOT",
   };
+  const pivotSortingAsc = {
+      name: _t("Ascending"),
+      execute: (env) => sortPivot(env, "asc"),
+      isActive: (env) => isPivotSortMenuItemActive(env, "asc"),
+  };
+  const pivotSortingDesc = {
+      name: _t("Descending"),
+      execute: (env) => sortPivot(env, "desc"),
+      isActive: (env) => isPivotSortMenuItemActive(env, "desc"),
+  };
+  const noPivotSorting = {
+      name: _t("No sorting"),
+      execute: (env) => sortPivot(env, "none"),
+      isActive: (env) => isPivotSortMenuItemActive(env, "none"),
+  };
   const FIX_FORMULAS = {
       name: _t("Convert to individual formulas"),
       execute(env) {
@@ -34259,6 +34755,66 @@ stores.inject(MyMetaStore, storeInstance);
       },
       icon: "o-spreadsheet-Icon.PIVOT",
   };
+  function canSortPivot(env) {
+      const position = env.model.getters.getActivePosition();
+      const pivotId = env.model.getters.getPivotIdFromPosition(position);
+      if (!pivotId ||
+          !env.model.getters.isExistingPivot(pivotId) ||
+          !env.model.getters.isSpillPivotFormula(position)) {
+          return false;
+      }
+      const pivot = env.model.getters.getPivot(pivotId);
+      if (!pivot.isValid()) {
+          return false;
+      }
+      const pivotCell = env.model.getters.getPivotCellFromPosition(position);
+      return pivotCell.type === "VALUE" || pivotCell.type === "MEASURE_HEADER";
+  }
+  function sortPivot(env, order) {
+      const position = env.model.getters.getActivePosition();
+      const pivotId = env.model.getters.getPivotIdFromPosition(position);
+      const pivotCell = env.model.getters.getPivotCellFromPosition(position);
+      if (pivotCell.type === "EMPTY" || pivotCell.type === "HEADER" || !pivotId) {
+          return;
+      }
+      if (order === "none") {
+          env.model.dispatch("UPDATE_PIVOT", {
+              pivotId: pivotId,
+              pivot: {
+                  ...env.model.getters.getPivotCoreDefinition(pivotId),
+                  sortedColumn: undefined,
+              },
+          });
+          return;
+      }
+      const pivot = env.model.getters.getPivot(pivotId);
+      const colDomain = domainToColRowDomain(pivot, pivotCell.domain).colDomain;
+      env.model.dispatch("UPDATE_PIVOT", {
+          pivotId: pivotId,
+          pivot: {
+              ...env.model.getters.getPivotCoreDefinition(pivotId),
+              sortedColumn: { domain: colDomain, order, measure: pivotCell.measure },
+          },
+      });
+  }
+  function isPivotSortMenuItemActive(env, order) {
+      const position = env.model.getters.getActivePosition();
+      const pivotId = env.model.getters.getPivotIdFromPosition(position);
+      const pivotCell = env.model.getters.getPivotCellFromPosition(position);
+      if (pivotCell.type === "EMPTY" || pivotCell.type === "HEADER" || !pivotId) {
+          return false;
+      }
+      const pivot = env.model.getters.getPivot(pivotId);
+      const colDomain = domainToColRowDomain(pivot, pivotCell.domain).colDomain;
+      const sortedColumn = pivot.definition.sortedColumn;
+      if (order === "none") {
+          return !sortedColumn;
+      }
+      if (!sortedColumn || sortedColumn.order !== order) {
+          return false;
+      }
+      return sortedColumn.measure === pivotCell.measure && deepEquals(sortedColumn.domain, colDomain);
+  }
 
   //------------------------------------------------------------------------------
   // Context Menu Registry
@@ -34357,14 +34913,33 @@ stores.inject(MyMetaStore, storeInstance);
       name: INSERT_LINK_NAME,
       sequence: 150,
       separator: true,
+  })
+      .add("pivot_sorting", {
+      name: _t("Sort pivot"),
+      sequence: 155,
+      icon: "o-spreadsheet-Icon.SORT_RANGE",
+      isVisible: canSortPivot,
   })
       .add("pivot_fix_formulas", {
       ...FIX_FORMULAS,
-      sequence: 155,
+      sequence: 160,
   })
       .add("pivot_properties", {
       ...pivotProperties,
       sequence: 170,
+      separator: true,
+  })
+      .addChild("pivot_sorting_asc", ["pivot_sorting"], {
+      ...pivotSortingAsc,
+      sequence: 10,
+  })
+      .addChild("pivot_sorting_desc", ["pivot_sorting"], {
+      ...pivotSortingDesc,
+      sequence: 20,
+  })
+      .addChild("pivot_sorting_none", ["pivot_sorting"], {
+      ...noPivotSorting,
+      sequence: 30,
   });
 
   const sortRange = {
@@ -34377,7 +34952,7 @@ stores.inject(MyMetaStore, storeInstance);
       execute: (env) => {
           const { anchor, zones } = env.model.getters.getSelection();
           const sheetId = env.model.getters.getActiveSheetId();
-          interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "ascending");
+          interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "asc");
       },
       icon: "o-spreadsheet-Icon.SORT_ASCENDING",
   };
@@ -34405,7 +34980,7 @@ stores.inject(MyMetaStore, storeInstance);
       execute: (env) => {
           const { anchor, zones } = env.model.getters.getSelection();
           const sheetId = env.model.getters.getActiveSheetId();
-          interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "descending");
+          interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "desc");
       },
       icon: "o-spreadsheet-Icon.SORT_DESCENDING",
   };
@@ -34888,6 +35463,227 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class PositionMap {
+      map = {};
+      constructor(entries = []) {
+          for (const [position, value] of entries) {
+              this.set(position, value);
+          }
+      }
+      set({ sheetId, col, row }, value) {
+          const map = this.map;
+          if (!map[sheetId]) {
+              map[sheetId] = {};
+          }
+          if (!map[sheetId][col]) {
+              map[sheetId][col] = {};
+          }
+          map[sheetId][col][row] = value;
+      }
+      get({ sheetId, col, row }) {
+          return this.map[sheetId]?.[col]?.[row];
+      }
+      getSheet(sheetId) {
+          return this.map[sheetId];
+      }
+      has({ sheetId, col, row }) {
+          return this.map[sheetId]?.[col]?.[row] !== undefined;
+      }
+      delete({ sheetId, col, row }) {
+          delete this.map[sheetId]?.[col]?.[row];
+      }
+      keys() {
+          const map = this.map;
+          const keys = [];
+          for (const sheetId in map) {
+              for (const col in map[sheetId]) {
+                  for (const row in map[sheetId][col]) {
+                      keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
+                  }
+              }
+          }
+          return keys;
+      }
+      keysForSheet(sheetId) {
+          const map = this.map[sheetId];
+          if (!map) {
+              return [];
+          }
+          const keys = [];
+          for (const col in map) {
+              for (const row in map[col]) {
+                  keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
+              }
+          }
+          return keys;
+      }
+      *entries() {
+          const map = this.map;
+          for (const position of this.keys()) {
+              const { sheetId, col, row } = position;
+              yield [position, map[sheetId][col][row]];
+          }
+      }
+  }
+
+  class FormulaFingerprintStore extends SpreadsheetStore {
+      mutators = ["enable", "disable"];
+      isInvalidated = false;
+      fingerprintColors = {
+          [DATA_FINGERPRINT]: "#D9D9D9",
+      };
+      isEnabled = false;
+      colors = new PositionMap();
+      handle(cmd) {
+          if (isCoreCommand(cmd) && this.isEnabled) {
+              this.isInvalidated = true;
+          }
+          switch (cmd.type) {
+              case "UNDO":
+              case "REDO":
+              case "ACTIVATE_SHEET":
+                  if (this.isEnabled) {
+                      this.isInvalidated = true;
+                  }
+                  break;
+          }
+      }
+      finalize() {
+          if (this.isInvalidated) {
+              this.isInvalidated = false;
+              this.computeFingerprints();
+          }
+      }
+      enable() {
+          this.isEnabled = true;
+          this.computeFingerprints();
+      }
+      disable() {
+          this.isEnabled = false;
+          this.colors = new PositionMap();
+      }
+      computeFingerprints() {
+          this.colors = new PositionMap();
+          const fingerprints = new PositionMap();
+          const allFingerprints = new Set();
+          const activeSheetId = this.getters.getActiveSheetId();
+          const cells = this.getters.getCells(activeSheetId);
+          for (const cellId in cells) {
+              const fingerprint = this.computeFingerprint(cells[cellId]);
+              if (!fingerprint) {
+                  continue;
+              }
+              allFingerprints.add(fingerprint);
+              const position = this.getters.getCellPosition(cellId);
+              fingerprints.set(position, fingerprint);
+          }
+          this.assignColors(allFingerprints);
+          for (const [position, fingerprint] of fingerprints.entries()) {
+              const color = this.fingerprintColors[fingerprint];
+              this.colors.set(position, color);
+              this.colorSpreadZone(position, color);
+          }
+      }
+      colorSpreadZone(position, fingerprintColor) {
+          const spreadZone = this.getters.getSpreadZone(position);
+          if (!spreadZone) {
+              return;
+          }
+          const sheetId = position.sheetId;
+          for (let row = spreadZone.top; row <= spreadZone.bottom; row++) {
+              for (let col = spreadZone.left; col <= spreadZone.right; col++) {
+                  const spreadPosition = { sheetId, col, row };
+                  this.colors.set(spreadPosition, fingerprintColor);
+              }
+          }
+      }
+      assignColors(fingerprints) {
+          const colors = new AlternatingColorGenerator(fingerprints.size);
+          Object.keys(this.fingerprintColors).forEach(() => colors.next());
+          for (const fingerprint of fingerprints) {
+              if (!this.fingerprintColors[fingerprint]) {
+                  this.fingerprintColors[fingerprint] = setColorAlpha(colors.next(), 0.8);
+              }
+          }
+      }
+      computeFingerprint(cell) {
+          const position = this.getters.getCellPosition(cell.id);
+          if (cell.isFormula) {
+              return this.computeFormulaFingerprint(position, cell);
+          }
+          else {
+              return this.getLiteralFingerprint(position);
+          }
+      }
+      computeFormulaFingerprint(position, cell) {
+          const dependencies = cell.compiledFormula.dependencies;
+          const colCellOffset = position.col;
+          const rowCellOffset = position.row;
+          const positionSheetIndex = this.getters.getSheetIds().indexOf(position.sheetId);
+          // As an optimization, we do not build each reference vector individually
+          // to sum them up, but instead we directly add each component to the resulting
+          // vector. This is equivalent to summing up all reference vectors.
+          const fingerprintVector = {
+              dx: 0,
+              dy: 0,
+              dSheet: 0,
+          };
+          for (const range of dependencies) {
+              const zone = range.zone;
+              const [left, right] = range.parts;
+              const rangeSheetIndex = this.getters.getSheetIds().indexOf(range.sheetId);
+              fingerprintVector.dSheet = rangeSheetIndex - positionSheetIndex;
+              // in relative mode, we offset the col and row by the cell's position
+              // in absolute mode, we offset the col and row relative to the sheet
+              const isLeftUnbounded = range.isFullRow && !range.unboundedZone.hasHeader;
+              const isTopUnbounded = range.isFullCol && !range.unboundedZone.hasHeader;
+              const leftOffset = isLeftUnbounded || left?.colFixed ? 0 : colCellOffset;
+              const topOffset = isTopUnbounded || left?.rowFixed ? 0 : rowCellOffset;
+              const isRightFixed = (!right && left?.colFixed) || right?.colFixed;
+              const isBottomFixed = (!right && left.rowFixed) || right?.rowFixed;
+              const isRightUnbounded = range.unboundedZone.right === undefined;
+              const isBottomUnbounded = range.unboundedZone.bottom === undefined;
+              const rightOffset = isRightUnbounded || isRightFixed ? 0 : colCellOffset;
+              const bottomOffset = isBottomUnbounded || isBottomFixed ? 0 : rowCellOffset;
+              const referenceZone = reorderZone({
+                  top: zone.top - topOffset,
+                  left: zone.left - leftOffset,
+                  right: zone.right - rightOffset,
+                  bottom: zone.bottom - bottomOffset,
+              });
+              for (let dy = referenceZone.top; dy <= referenceZone.bottom; dy++) {
+                  for (let dx = referenceZone.left; dx <= referenceZone.right; dx++) {
+                      fingerprintVector.dx += dx;
+                      fingerprintVector.dy += dy;
+                  }
+              }
+          }
+          // removes the index placeholders from the normalized formula
+          // =|N0|+|N1|+|N0| -> =|N|+|N|+|N|
+          const normalizedFormula = cell.compiledFormula.normalizedFormula.replace(/(|\w)(\d)(|)/g, "$1$3");
+          return hash(fingerprintVector) + normalizedFormula;
+      }
+      getLiteralFingerprint(position) {
+          const evaluatedCell = this.getters.getEvaluatedCell(position);
+          switch (evaluatedCell.type) {
+              case CellValueType.number:
+              case CellValueType.boolean:
+                  return DATA_FINGERPRINT;
+              case CellValueType.text:
+              case CellValueType.empty:
+              case CellValueType.error:
+                  return undefined;
+          }
+      }
+  }
+  function hash(vector) {
+      return Object.entries(vector)
+          .sort(([a], [b]) => a.localeCompare(b))
+          .map(([_, value]) => value)
+          .join(",");
+  }
+  const DATA_FINGERPRINT = "DATA_FINGERPRINT";
+
   const hideCols = {
       name: HIDE_COLUMNS_NAME,
       execute: (env) => {
@@ -35059,6 +35855,19 @@ stores.inject(MyMetaStore, storeInstance);
           return env.model.getters.getGridLinesVisibility(sheetId);
       },
   };
+  const irregularityMap = {
+      name: _t("Irregularity map"),
+      execute: (env) => {
+          const fingerprintStore = env.getStore(FormulaFingerprintStore);
+          if (fingerprintStore.isEnabled) {
+              fingerprintStore.disable();
+          }
+          else {
+              fingerprintStore.enable();
+          }
+      },
+      icon: "o-spreadsheet-Icon.IRREGULARITY_MAP",
+  };
   const viewFormulas = {
       name: _t("Formulas"),
       isActive: (env) => env.model.getters.shouldShowFormulas(),
@@ -35676,6 +36485,11 @@ stores.inject(MyMetaStore, storeInstance);
       .addChild("view_formulas", ["view", "show"], {
       ...viewFormulas,
       sequence: 10,
+  })
+      .addChild("view_irregularity_map", ["view"], {
+      ...irregularityMap,
+      sequence: 40,
+      separator: true,
   })
       // ---------------------------------------------------------------------
       // INSERT MENU ITEMS
@@ -35978,62 +36792,6 @@ stores.inject(MyMetaStore, storeInstance);
   }
   const otRegistry = new OTRegistry();
 
-  const CHECK_SVG = /*xml*/ `
-<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 20 20'>
-  <path fill='none' stroke='#FFF' stroke-linecap='round' stroke-linejoin='round' stroke-width='3' d='m6 10 3 3 6-6'/>
-</svg>
-`;
-  const CHECKBOX_WIDTH = 14;
-  css /* scss */ `
-  label.o-checkbox {
-    input {
-      appearance: none;
-      -webkit-appearance: none;
-      -moz-appearance: none;
-      border-radius: 0;
-      width: ${CHECKBOX_WIDTH}px;
-      height: ${CHECKBOX_WIDTH}px;
-      vertical-align: top;
-      box-sizing: border-box;
-      outline: none;
-      border: 1px solid ${GRAY_300};
-
-      &:hover {
-        border-color: ${ACTION_COLOR};
-      }
-
-      &:checked {
-        background: url("data:image/svg+xml,${encodeURIComponent(CHECK_SVG)}");
-        background-color: ${ACTION_COLOR};
-        border-color: ${ACTION_COLOR};
-      }
-
-      &:focus {
-        outline: none;
-        box-shadow: 0 0 0 0.25rem rgba(113, 75, 103, 0.25);
-        border-color: ${ACTION_COLOR};
-      }
-    }
-  }
-`;
-  class Checkbox extends owl.Component {
-      static template = "o-spreadsheet.Checkbox";
-      static props = {
-          label: { type: String, optional: true },
-          value: { type: Boolean, optional: true },
-          className: { type: String, optional: true },
-          name: { type: String, optional: true },
-          title: { type: String, optional: true },
-          disabled: { type: Boolean, optional: true },
-          onChange: Function,
-      };
-      static defaultProps = { value: false };
-      onChange(ev) {
-          const value = ev.target.checked;
-          this.props.onChange(value);
-      }
-  }
-
   class Section extends owl.Component {
       static template = "o_spreadsheet.Section";
       static props = {
@@ -37410,6 +38168,95 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  css /* scss */ `
+  .o-font-size-editor {
+    height: calc(100% - 4px);
+    input.o-font-size {
+      outline-color: ${SELECTION_BORDER_COLOR};
+      height: 20px;
+      width: 23px;
+    }
+  }
+  .o-text-options > div {
+    cursor: pointer;
+    line-height: 26px;
+    padding: 3px 12px;
+    &:hover {
+      background-color: rgba(0, 0, 0, 0.08);
+    }
+  }
+`;
+  class FontSizeEditor extends owl.Component {
+      static template = "o-spreadsheet-FontSizeEditor";
+      static props = {
+          currentFontSize: Number,
+          onFontSizeChanged: Function,
+          onToggle: { type: Function, optional: true },
+          class: String,
+      };
+      static components = { Popover };
+      fontSizes = FONT_SIZES;
+      dropdown = owl.useState({ isOpen: false });
+      inputRef = owl.useRef("inputFontSize");
+      rootEditorRef = owl.useRef("FontSizeEditor");
+      fontSizeListRef = owl.useRef("fontSizeList");
+      setup() {
+          owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
+      }
+      get popoverProps() {
+          const { x, y, width, height } = this.rootEditorRef.el.getBoundingClientRect();
+          return {
+              anchorRect: { x, y, width, height },
+              positioning: "BottomLeft",
+              verticalOffset: 0,
+          };
+      }
+      onExternalClick(ev) {
+          if (!isChildEvent(this.fontSizeListRef.el, ev) && !isChildEvent(this.rootEditorRef.el, ev)) {
+              this.closeFontList();
+          }
+      }
+      toggleFontList() {
+          const isOpen = this.dropdown.isOpen;
+          if (!isOpen) {
+              this.props.onToggle?.();
+              this.inputRef.el.focus();
+          }
+          else {
+              this.closeFontList();
+          }
+      }
+      closeFontList() {
+          this.dropdown.isOpen = false;
+      }
+      setSize(fontSizeStr) {
+          const fontSize = clip(Math.floor(parseFloat(fontSizeStr)), 1, 400);
+          this.props.onFontSizeChanged(fontSize);
+          this.closeFontList();
+      }
+      setSizeFromInput(ev) {
+          this.setSize(ev.target.value);
+      }
+      setSizeFromList(fontSizeStr) {
+          this.setSize(fontSizeStr);
+      }
+      onInputFocused(ev) {
+          this.dropdown.isOpen = true;
+          ev.target.select();
+      }
+      onInputKeydown(ev) {
+          if (ev.key === "Enter" || ev.key === "Escape") {
+              this.closeFontList();
+              const target = ev.target;
+              // In the case of a ESCAPE key, we get the previous font size back
+              if (ev.key === "Escape") {
+                  target.value = `${this.props.currentFontSize}`;
+              }
+              this.props.onToggle?.();
+          }
+      }
+  }
+
   css /* scss */ `
   .o-chart-title-designer {
     > span {
@@ -37444,7 +38291,7 @@ stores.inject(MyMetaStore, storeInstance);
 `;
   class ChartTitle extends owl.Component {
       static template = "o-spreadsheet.ChartTitle";
-      static components = { Section, ColorPickerWidget };
+      static components = { Section, ColorPickerWidget, FontSizeEditor };
       static props = {
           title: { type: String, optional: true },
           updateTitle: Function,
@@ -37453,7 +38300,8 @@ stores.inject(MyMetaStore, storeInstance);
           toggleBold: { type: Function, optional: true },
           updateAlignment: { type: Function, optional: true },
           updateColor: { type: Function, optional: true },
-          style: { type: Object, optional: true },
+          style: Object,
+          onFontSizeChanged: Function,
       };
       static defaultProps = {
           title: "",
@@ -37468,6 +38316,9 @@ stores.inject(MyMetaStore, storeInstance);
       updateTitle(ev) {
           this.props.updateTitle(ev.target.value);
       }
+      updateFontSize(fontSize) {
+          this.props.onFontSizeChanged(fontSize);
+      }
       toggleDropdownTool(tool, ev) {
           const isOpen = this.state.activeTool === tool;
           this.closeMenus();
@@ -37510,6 +38361,7 @@ stores.inject(MyMetaStore, storeInstance);
           return {
               color: "",
               align: "center",
+              fontSize: CHART_AXIS_TITLE_FONT_SIZE,
               ...axisDesign.title,
           };
       }
@@ -37527,6 +38379,17 @@ stores.inject(MyMetaStore, storeInstance);
           };
           this.props.updateChart(this.props.figureId, { axesDesign });
       }
+      updateAxisTitleFontSize(fontSize) {
+          const axesDesign = this.props.definition.axesDesign ?? {};
+          axesDesign[this.state.currentAxis] = {
+              ...axesDesign[this.state.currentAxis],
+              title: {
+                  ...(axesDesign[this.state.currentAxis]?.title ?? {}),
+                  fontSize,
+              },
+          };
+          this.props.updateChart(this.props.figureId, { axesDesign });
+      }
       toggleBoldAxisTitle() {
           const axesDesign = this.props.definition.axesDesign ?? {};
           const title = axesDesign[this.state.currentAxis]?.title ?? {};
@@ -37646,8 +38509,12 @@ stores.inject(MyMetaStore, storeInstance);
           figureId: String,
           definition: Object,
           updateChart: Function,
+          defaultChartTitleFontSize: { type: Number, optional: true },
           slots: { type: Object, optional: true },
       };
+      static defaultProps = {
+          defaultChartTitleFontSize: CHART_TITLE_FONT_SIZE,
+      };
       state;
       setup() {
           this.state = owl.useState({
@@ -37673,6 +38540,7 @@ stores.inject(MyMetaStore, storeInstance);
       get titleStyle() {
           return {
               align: "left",
+              fontSize: this.props.defaultChartTitleFontSize,
               ...this.title,
           };
       }
@@ -37681,6 +38549,10 @@ stores.inject(MyMetaStore, storeInstance);
           this.props.updateChart(this.props.figureId, { title });
           this.state.activeTool = "";
       }
+      updateChartTitleFontSize(fontSize) {
+          const title = { ...this.title, fontSize };
+          this.props.updateChart(this.props.figureId, { title });
+      }
       toggleBoldChartTitle() {
           let title = this.title;
           title = { ...title, bold: !title.bold };
@@ -37888,7 +38760,7 @@ stores.inject(MyMetaStore, storeInstance);
               case "polynomial":
                   config = {
                       type: "polynomial",
-                      order: type === "linear" ? 1 : 2,
+                      order: type === "linear" ? 1 : this.getMaxPolynomialDegree(index),
                   };
                   break;
               case "exponential":
@@ -38159,6 +39031,104 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class GeoChartRegionSelectSection extends owl.Component {
+      static template = "o-spreadsheet-GeoChartRegionSelectSection";
+      static components = { Section };
+      static props = {
+          figureId: String,
+          definition: Object,
+          updateChart: Function,
+      };
+      updateSelectedRegion(ev) {
+          const value = ev.target.value;
+          this.props.updateChart(this.props.figureId, { region: value });
+      }
+      get availableRegions() {
+          return this.env.model.getters.getGeoChartAvailableRegions();
+      }
+      get selectedRegion() {
+          return this.props.definition.region || this.availableRegions[0]?.id;
+      }
+  }
+
+  class GeoChartConfigPanel extends GenericChartConfigPanel {
+      static template = "o-spreadsheet-GeoChartConfigPanel";
+      static components = { ...GenericChartConfigPanel.components, GeoChartRegionSelectSection };
+      get dataRanges() {
+          return this.getDataSeriesRanges().slice(0, 1);
+      }
+      onDataSeriesConfirmed() {
+          this.dataSeriesRanges = spreadRange(this.env.model.getters, this.dataSeriesRanges).slice(0, 1);
+          this.state.datasetDispatchResult = this.props.updateChart(this.props.figureId, {
+              dataSets: this.dataSeriesRanges,
+          });
+      }
+      getLabelRangeOptions() {
+          return [
+              {
+                  name: "dataSetsHaveTitle",
+                  label: this.dataSetsHaveTitleLabel,
+                  value: this.props.definition.dataSetsHaveTitle,
+                  onChange: this.onUpdateDataSetsHaveTitle.bind(this),
+              },
+          ];
+      }
+  }
+
+  const DEFAULT_CUSTOM_COLOR_SCALE = {
+      minColor: "#FFF5EB",
+      midColor: "#FD8D3C",
+      maxColor: "#7F2704",
+  };
+  class GeoChartDesignPanel extends ChartWithAxisDesignPanel {
+      static template = "o-spreadsheet-GeoChartDesignPanel";
+      static components = { ...ChartWithAxisDesignPanel.components, RoundColorPicker };
+      colorScalesChoices = ChartTerms.GeoChart.ColorScales;
+      updateColorScaleType(ev) {
+          const value = ev.target.value;
+          value === "custom"
+              ? this.updateColorScale(DEFAULT_CUSTOM_COLOR_SCALE)
+              : this.updateColorScale(value);
+      }
+      updateColorScale(colorScale) {
+          this.props.updateChart(this.props.figureId, { colorScale });
+      }
+      updateMissingValueColor(color) {
+          this.props.updateChart(this.props.figureId, { missingValueColor: color });
+      }
+      updateLegendPosition(ev) {
+          const value = ev.target.value;
+          this.props.updateChart(this.props.figureId, { legendPosition: value });
+      }
+      get selectedColorScale() {
+          return typeof this.props.definition.colorScale === "object"
+              ? "custom"
+              : this.props.definition.colorScale || "oranges";
+      }
+      get selectedMissingValueColor() {
+          return this.props.definition.missingValueColor || "#ffffff";
+      }
+      get customColorScale() {
+          if (typeof this.props.definition.colorScale === "object") {
+              return this.props.definition.colorScale;
+          }
+          return undefined;
+      }
+      getCustomColorScaleColor(color) {
+          return this.customColorScale?.[color] ?? "";
+      }
+      setCustomColorScaleColor(colorType, color) {
+          if (!color && colorType !== "midColor") {
+              color = "#fff";
+          }
+          const customColorScale = this.customColorScale;
+          if (!customColorScale) {
+              return;
+          }
+          this.updateColorScale({ ...customColorScale, [colorType]: color });
+      }
+  }
+
   class LineConfigPanel extends GenericChartConfigPanel {
       static template = "o-spreadsheet-LineConfigPanel";
       get canTreatLabelsAsText() {
@@ -38348,6 +39318,9 @@ stores.inject(MyMetaStore, storeInstance);
       get humanizeNumbersLabel() {
           return _t("Humanize numbers");
       }
+      get defaultScorecardTitleFontSize() {
+          return SCORECARD_CHART_TITLE_FONT_SIZE;
+      }
       updateHumanizeNumbers(humanize) {
           this.props.updateChart(this.props.figureId, { humanize });
       }
@@ -38469,6 +39442,10 @@ stores.inject(MyMetaStore, storeInstance);
       .add("radar", {
       configuration: GenericChartConfigPanel,
       design: RadarChartDesignPanel,
+  })
+      .add("geo", {
+      configuration: GeoChartConfigPanel,
+      design: GeoChartDesignPanel,
   });
 
   css /* scss */ `
@@ -39811,6 +40788,15 @@ stores.inject(MyMetaStore, storeInstance);
       confirmEdition(content) {
           this.args().onConfirm(content);
       }
+      getTokenColor(token) {
+          if (token.type === "SYMBOL") {
+              const matchedColor = this.args().getContextualColoredSymbolToken?.(token);
+              if (matchedColor) {
+                  return matchedColor;
+              }
+          }
+          return super.getTokenColor(token);
+      }
   }
 
   css /* scss */ `
@@ -39823,7 +40809,7 @@ stores.inject(MyMetaStore, storeInstance);
       border-color: ${GRAY_300};
 
       &.active {
-        border-color: ${SELECTION_BORDER_COLOR};
+        border-color: ${ACTION_COLOR};
       }
 
       &.o-invalid {
@@ -39848,6 +40834,7 @@ stores.inject(MyMetaStore, storeInstance);
           placeholder: { type: String, optional: true },
           class: { type: String, optional: true },
           invalid: { type: Boolean, optional: true },
+          getContextualColoredSymbolToken: { type: Function, optional: true },
       };
       static components = { Composer };
       static defaultProps = {
@@ -39864,6 +40851,7 @@ stores.inject(MyMetaStore, storeInstance);
               content: this.props.composerContent,
               contextualAutocomplete: this.props.contextualAutocomplete,
               defaultRangeSheetId: this.props.defaultRangeSheetId,
+              getContextualColoredSymbolToken: this.props.getContextualColoredSymbolToken,
           }));
           this.standaloneComposerStore = standaloneComposerStore;
           this.composerInterface = {
@@ -40779,7 +41767,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           const point = this.state.rules.colorScale[target];
           if (point) {
-              point.color = Number.parseInt(color.slice(1), 16);
+              point.color = colorToNumber(color);
           }
           this.updateConditionalFormat({ rule: this.state.rules.colorScale });
           this.closeMenus();
@@ -40924,6 +41912,9 @@ stores.inject(MyMetaStore, storeInstance);
           return [this.state.rules.dataBar.rangeValues || ""];
       }
       updateDataBarColor(color) {
+          if (!isColorValid(color)) {
+              return;
+          }
           this.state.rules.dataBar.color = Number.parseInt(color.slice(1), 16);
           this.updateConditionalFormat({ rule: this.state.rules.dataBar });
       }
@@ -43424,7 +44415,7 @@ stores.inject(MyMetaStore, storeInstance);
                   return {
                       text: text,
                       description: measure.displayName,
-                      htmlContent: [{ value: text, color: tokenColors.FUNCTION }],
+                      htmlContent: [{ value: text, color: PIVOT_TOKEN_COLOR }],
                       fuzzySearchKey: measure.displayName + text + measure.fieldName,
                   };
               });
@@ -43433,7 +44424,7 @@ stores.inject(MyMetaStore, storeInstance);
                   return {
                       text: text,
                       description: dimension.displayName,
-                      htmlContent: [{ value: text, color: tokenColors.FUNCTION }],
+                      htmlContent: [{ value: text, color: PIVOT_TOKEN_COLOR }],
                       fuzzySearchKey: dimension.displayName + text + dimension.fieldName,
                   };
               });
@@ -43513,6 +44504,76 @@ stores.inject(MyMetaStore, storeInstance);
               measure: this.props.measure,
           });
       }
+      getColoredSymbolToken(token) {
+          if (token.type !== "SYMBOL") {
+              return undefined;
+          }
+          const tokenValue = unquote(token.value, "'");
+          if (this.props.definition.columns.some((col) => col.nameWithGranularity === tokenValue) ||
+              this.props.definition.rows.some((row) => row.nameWithGranularity === tokenValue) ||
+              this.props.definition.measures.some((measure) => measure.id === tokenValue && measure.id !== this.props.measure.id)) {
+              return PIVOT_TOKEN_COLOR;
+          }
+          return undefined;
+      }
+  }
+
+  css /* scss */ `
+  .o-pivot-sort {
+    .o-sort-card {
+      width: fit-content;
+      background-color: ${GRAY_100};
+      border: 1px solid ${GRAY_300};
+
+      .o-sort-value {
+        color: ${PRIMARY_BUTTON_BG};
+      }
+    }
+  }
+`;
+  class PivotSortSection extends owl.Component {
+      static template = "o-spreadsheet-PivotSortSection";
+      static components = {
+          Section,
+      };
+      static props = {
+          definition: Object,
+          pivotId: String,
+      };
+      get hasValidSort() {
+          const pivot = this.env.model.getters.getPivot(this.props.pivotId);
+          return (!!this.props.definition.sortedColumn &&
+              isSortedColumnValid(this.props.definition.sortedColumn, pivot));
+      }
+      get sortDescription() {
+          const sortOrder = this.props.definition.sortedColumn?.order === "asc" ? _t("ascending") : _t("descending");
+          return _t("Sorted on column (%(ascOrDesc)s):", {
+              ascOrDesc: sortOrder,
+          });
+      }
+      get sortValuesAndFields() {
+          const sortedColumn = this.props.definition.sortedColumn;
+          if (!sortedColumn) {
+              return [];
+          }
+          const pivot = this.env.model.getters.getPivot(this.props.pivotId);
+          const locale = this.env.model.getters.getLocale();
+          const currentDomain = [];
+          const sortValues = [];
+          for (const domainItem of sortedColumn.domain) {
+              currentDomain.push(domainItem);
+              const { value, format } = pivot.getPivotHeaderValueAndFormat(currentDomain);
+              const label = formatValue(value, { format, locale });
+              const field = pivot.definition.getDimension(domainItem.field);
+              sortValues.push({ field: getFieldDisplayName(field), value: label });
+          }
+          if (sortedColumn.domain.length === 0) {
+              sortValues.push({ value: _t("Total") });
+          }
+          const measureLabel = pivot.getMeasure(sortedColumn.measure).displayName;
+          sortValues.push({ value: measureLabel, field: _t("Measure") });
+          return sortValues;
+      }
   }
 
   css /* scss */ `
@@ -43528,6 +44589,7 @@ stores.inject(MyMetaStore, storeInstance);
           PivotDimensionOrder,
           PivotDimensionGranularity,
           PivotMeasureEditor,
+          PivotSortSection,
       };
       static props = {
           definition: Object,
@@ -43684,9 +44746,13 @@ stores.inject(MyMetaStore, storeInstance);
       }
       updateMeasure(measure, newMeasure) {
           const { measures } = this.props.definition;
-          this.props.onDimensionsUpdated({
+          const update = {
               measures: measures.map((m) => (m.id === measure.id ? newMeasure : m)),
-          });
+          };
+          if (this.props.definition.sortedColumn?.measure === measure.id) {
+              update.sortedColumn = { ...this.props.definition.sortedColumn, measure: newMeasure.id };
+          }
+          this.props.onDimensionsUpdated(update);
       }
       getMeasureId(fieldName, aggregator) {
           const baseId = fieldName + (aggregator ? `:${aggregator}` : "");
@@ -43842,10 +44908,12 @@ stores.inject(MyMetaStore, storeInstance);
       measures;
       columns;
       rows;
+      sortedColumn;
       constructor(definition, fields) {
           this.measures = definition.measures.map((measure) => createMeasure(fields, measure));
           this.columns = definition.columns.map((dimension) => createPivotDimension(fields, dimension));
           this.rows = definition.rows.map((dimension) => createPivotDimension(fields, dimension));
+          this.sortedColumn = definition.sortedColumn;
       }
       getDimension(nameWithGranularity) {
           const dimension = this.columns.find((d) => d.nameWithGranularity === nameWithGranularity) ||
@@ -43999,6 +45067,7 @@ stores.inject(MyMetaStore, storeInstance);
       pivotCells = {};
       rowTree;
       colTree;
+      isSorted = false;
       constructor(columns, rows, measures, fieldsType) {
           this.columns = columns.map((row) => {
               // offset in the pivot table
@@ -44172,6 +45241,7 @@ stores.inject(MyMetaStore, storeInstance);
                   value,
                   field: row.fields[rowDepth],
                   children: [],
+                  type: this.fieldsType[fieldName] || "char",
                   width: 0, // not used
               };
               treesAtDepth[depth].push(node);
@@ -44194,6 +45264,7 @@ stores.inject(MyMetaStore, storeInstance);
                       field: leaf.fields[depth],
                       children: [],
                       width: leaf.width,
+                      type: this.fieldsType[fieldName] || "char",
                   };
                   if (treesAtDepth[depth]?.at(-1)?.value !== value) {
                       treesAtDepth[depth + 1] = [];
@@ -44212,6 +45283,35 @@ stores.inject(MyMetaStore, storeInstance);
               fieldsType: this.fieldsType,
           };
       }
+      sort(measure, sortedColumn, getValue) {
+          if (this.isSorted) {
+              return;
+          }
+          const getSortValue = (measure, domain) => {
+              const rawValue = getValue(measure, domain).value;
+              return typeof rawValue === "number" ? rawValue : -Infinity;
+          };
+          const sortColDomain = sortedColumn.domain;
+          const sortFn = (rowDomain1, rowDomain2) => {
+              const value1 = getSortValue(measure, [...rowDomain1, ...sortColDomain]);
+              const value2 = getSortValue(measure, [...rowDomain2, ...sortColDomain]);
+              return sortedColumn.order === "asc" ? value1 - value2 : value2 - value1;
+          };
+          const sortedRowTree = sortPivotTree(this.rowTree(), [], sortFn);
+          this.rowTree = lazy(sortedRowTree);
+          this.rows = [...this.rowTreeToRows(sortedRowTree), this.rows[this.rows.length - 1]];
+          this.isSorted = true;
+      }
+      rowTreeToRows(tree, parentRow) {
+          return tree.flatMap((node) => {
+              const row = {
+                  indent: parentRow ? parentRow.indent + 1 : 0,
+                  fields: [...(parentRow?.fields || []), node.field],
+                  values: [...(parentRow?.values || []), node.value],
+              };
+              return [row, ...this.rowTreeToRows(node.children, row)];
+          });
+      }
   }
   const EMPTY_PIVOT_CELL = { type: "EMPTY" };
 
@@ -44289,6 +45389,7 @@ stores.inject(MyMetaStore, storeInstance);
               value: groups[key]?.[0]?.[column.nameWithGranularity]?.value ?? null,
               field: colName,
               children: dataEntriesToColumnsTree(groups[key] || [], columns, index + 1),
+              type: column.type,
               width: 0,
           };
       });
@@ -45154,6 +46255,7 @@ stores.inject(MyMetaStore, storeInstance);
                   format: measure.format,
                   display: measure.display,
               })),
+              sortedColumn: this.shouldKeepSortedColumn(definition) ? definition.sortedColumn : undefined,
           };
           if (!this.draft && deepEquals(coreDefinition, cleanedDefinition)) {
               return;
@@ -45212,6 +46314,19 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return granularitiesPerFields;
       }
+      /**
+       * Check if we want to keep the sorted column when updating the pivot definition. We should remove it if either
+       * the measure is not in the new definition or the columns have changed.
+       */
+      shouldKeepSortedColumn(newDefinition) {
+          const { sortedColumn } = newDefinition;
+          if (!sortedColumn) {
+              return true;
+          }
+          const oldDefinition = this.getters.getPivotCoreDefinition(this.pivotId);
+          return (newDefinition.measures.find((measure) => measure.id === sortedColumn.measure) &&
+              deepEquals(oldDefinition.columns, newDefinition.columns));
+      }
   }
 
   class PivotSpreadsheetSidePanel extends owl.Component {
@@ -46313,6 +47428,7 @@ stores.inject(MyMetaStore, storeInstance);
     }
   }
 `;
+  const DEFAULT_TABLE_STYLE_COLOR = "#3C78D8";
   class TableStyleEditorPanel extends owl.Component {
       static template = "o-spreadsheet-TableStyleEditorPanel";
       static components = { Section, RoundColorPicker, TableStylePreview };
@@ -46331,7 +47447,7 @@ stores.inject(MyMetaStore, storeInstance);
               : null;
           return {
               pickerOpened: false,
-              primaryColor: editedStyle?.primaryColor || "#3C78D8",
+              primaryColor: editedStyle?.primaryColor || DEFAULT_TABLE_STYLE_COLOR,
               selectedTemplateName: editedStyle?.templateName || "lightColoredText",
               styleName: editedStyle?.displayName || this.env.model.getters.getNewCustomTableStyleName(),
           };
@@ -46340,7 +47456,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.state.pickerOpened = !this.state.pickerOpened;
       }
       onColorPicked(color) {
-          this.state.primaryColor = color;
+          this.state.primaryColor = isColorValid(color) ? color : DEFAULT_TABLE_STYLE_COLOR;
           this.state.pickerOpened = false;
       }
       onTemplatePicked(templateName) {
@@ -47956,6 +49072,7 @@ stores.inject(MyMetaStore, storeInstance);
           draggedFigure: undefined,
           horizontalSnap: undefined,
           verticalSnap: undefined,
+          cancelDnd: undefined,
       });
       setup() {
           owl.onMounted(() => {
@@ -47968,12 +49085,28 @@ stores.inject(MyMetaStore, storeInstance);
               // new rendering
               this.render();
           });
+          owl.onWillUpdateProps(() => {
+              const sheetId = this.env.model.getters.getActiveSheetId();
+              const draggedFigureId = this.dnd.draggedFigure?.id;
+              if (draggedFigureId && !this.env.model.getters.getFigure(sheetId, draggedFigureId)) {
+                  if (this.dnd.cancelDnd) {
+                      this.dnd.cancelDnd();
+                  }
+                  this.dnd.draggedFigure = undefined;
+                  this.dnd.horizontalSnap = undefined;
+                  this.dnd.verticalSnap = undefined;
+                  this.dnd.cancelDnd = undefined;
+              }
+          });
       }
       getVisibleFigures() {
           const visibleFigures = this.env.model.getters.getVisibleFigures();
           if (this.dnd.draggedFigure &&
               !visibleFigures.some((figure) => figure.id === this.dnd.draggedFigure?.id)) {
-              visibleFigures.push(this.env.model.getters.getFigure(this.env.model.getters.getActiveSheetId(), this.dnd.draggedFigure?.id));
+              const draggedFigure = this.env.model.getters.getFigure(this.env.model.getters.getActiveSheetId(), this.dnd.draggedFigure?.id);
+              if (draggedFigure) {
+                  visibleFigures.push(draggedFigure);
+              }
           }
           return visibleFigures;
       }
@@ -48092,7 +49225,7 @@ stores.inject(MyMetaStore, storeInstance);
               this.dnd.verticalSnap = undefined;
               this.env.model.dispatch("UPDATE_FIGURE", { sheetId, id: figure.id, x, y });
           };
-          startDnd(onMouseMove, onMouseUp);
+          this.dnd.cancelDnd = startDnd(onMouseMove, onMouseUp);
       }
       /**
        * Initialize the resize of a figure with mouse movements
@@ -48140,7 +49273,7 @@ stores.inject(MyMetaStore, storeInstance);
               this.dnd.horizontalSnap = undefined;
               this.dnd.verticalSnap = undefined;
           };
-          startDnd(onMouseMove, onMouseUp);
+          this.dnd.cancelDnd = startDnd(onMouseMove, onMouseUp);
       }
       getOtherFigures(figId) {
           return this.getVisibleFigures().filter((f) => f.id !== figId);
@@ -49247,9 +50380,11 @@ stores.inject(MyMetaStore, storeInstance);
   class GridRenderer {
       getters;
       renderer;
+      fingerprints;
       constructor(get) {
           this.getters = get(ModelStore).getters;
           this.renderer = get(RendererStore);
+          this.fingerprints = get(FormulaFingerprintStore);
           this.renderer.register(this);
       }
       get renderingLayers() {
@@ -49727,14 +50862,22 @@ stores.inject(MyMetaStore, storeInstance);
           const showFormula = this.getters.shouldShowFormulas();
           const { x, y, width, height } = this.getters.getVisibleRect(zone);
           const { verticalAlign } = this.getters.getCellStyle(position);
+          let style = this.getters.getCellComputedStyle(position);
+          if (this.fingerprints.isEnabled) {
+              const fingerprintColor = this.fingerprints.colors.get(position);
+              style = { ...style, fillColor: fingerprintColor };
+          }
+          const dataBarFill = this.fingerprints.isEnabled
+              ? undefined
+              : this.getters.getConditionalDataBar(position);
           const box = {
               x,
               y,
               width,
               height,
               border: this.getters.getCellComputedBorder(position) || undefined,
-              style: this.getters.getCellComputedStyle(position),
-              dataBarFill: this.getters.getConditionalDataBar(position),
+              style,
+              dataBarFill,
               verticalAlign,
               isError: (cell.type === CellValueType.error && !!cell.message) ||
                   this.getters.isDataValidationInvalid(position),
@@ -49759,7 +50902,6 @@ stores.inject(MyMetaStore, storeInstance);
           box.hasIcon = this.getters.doesCellHaveGridIcon(position);
           const headerIconWidth = box.hasIcon ? GRID_ICON_EDGE_LENGTH + GRID_ICON_MARGIN : 0;
           /** Content */
-          const style = this.getters.getCellComputedStyle(position);
           const wrapping = style.wrapping || "overflow";
           const wrapText = wrapping === "wrap" && !showFormula;
           const maxWidth = width - 2 * MIN_CELL_TEXT_MARGIN;
@@ -51737,62 +52879,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  class PositionMap {
-      map = {};
-      constructor(entries = []) {
-          for (const [position, value] of entries) {
-              this.set(position, value);
-          }
-      }
-      set({ sheetId, col, row }, value) {
-          const map = this.map;
-          if (!map[sheetId]) {
-              map[sheetId] = {};
-          }
-          if (!map[sheetId][col]) {
-              map[sheetId][col] = {};
-          }
-          map[sheetId][col][row] = value;
-      }
-      get({ sheetId, col, row }) {
-          return this.map[sheetId]?.[col]?.[row];
-      }
-      getSheet(sheetId) {
-          return this.map[sheetId];
-      }
-      has({ sheetId, col, row }) {
-          return this.map[sheetId]?.[col]?.[row] !== undefined;
-      }
-      delete({ sheetId, col, row }) {
-          delete this.map[sheetId]?.[col]?.[row];
-      }
-      keys() {
-          const map = this.map;
-          const keys = [];
-          for (const sheetId in map) {
-              for (const col in map[sheetId]) {
-                  for (const row in map[sheetId][col]) {
-                      keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
-                  }
-              }
-          }
-          return keys;
-      }
-      keysForSheet(sheetId) {
-          const map = this.map[sheetId];
-          if (!map) {
-              return [];
-          }
-          const keys = [];
-          for (const col in map) {
-              for (const row in map[col]) {
-                  keys.push({ sheetId, col: parseInt(col), row: parseInt(row) });
-              }
-          }
-          return keys;
-      }
-  }
-
   /**
    * Core Plugin
    *
@@ -51887,7 +52973,7 @@ stores.inject(MyMetaStore, storeInstance);
               for (let col = zone.left; col <= zone.right; col++) {
                   for (let row = zone.top; row <= zone.bottom; row++) {
                       const cell = this.getters.getCell({ sheetId, col, row });
-                      if (cell) {
+                      if (cell?.isFormula || cell?.content) {
                           this.dispatch("UPDATE_CELL", {
                               sheetId: sheetId,
                               content: "",
@@ -51923,7 +53009,6 @@ stores.inject(MyMetaStore, storeInstance);
           for (let zone of recomputeZones(zones)) {
               for (let col = zone.left; col <= zone.right; col++) {
                   for (let row = zone.top; row <= zone.bottom; row++) {
-                      // commandHelpers.updateCell(sheetId, col, row, { style: undefined});
                       this.dispatch("UPDATE_CELL", {
                           sheetId,
                           col,
@@ -52232,7 +53317,7 @@ stores.inject(MyMetaStore, storeInstance);
           const before = this.getters.getCell({ sheetId, col, row });
           const hasContent = "content" in after || "formula" in after;
           // Compute the new cell properties
-          const afterContent = hasContent ? replaceSpecialSpaces(after?.content) : before?.content || "";
+          const afterContent = hasContent ? replaceNewLines(after?.content) : before?.content || "";
           let style;
           if (after.style !== undefined) {
               style = after.style || undefined;
@@ -55177,6 +56262,9 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
       getUnboundedZone(sheetId, zone) {
+          if (zone.bottom === undefined || zone.right === undefined) {
+              return zone;
+          }
           const isFullRow = zone.left === 0 && zone.right === this.getNumberCols(sheetId) - 1;
           const isFullCol = zone.top === 0 && zone.bottom === this.getNumberRows(sheetId) - 1;
           return {
@@ -55342,7 +56430,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (orderedSheetIds.find((id) => sheets[id]?.name.toLowerCase() === name && id !== cmd.sheetId)) {
               return "DuplicatedSheetName" /* CommandResult.DuplicatedSheetName */;
           }
-          if (FORBIDDEN_IN_EXCEL_REGEX.test(name)) {
+          if (FORBIDDEN_SHEETNAME_CHARS_IN_EXCEL_REGEX.test(name)) {
               return "ForbiddenCharactersInSheetName" /* CommandResult.ForbiddenCharactersInSheetName */;
           }
           return "Success" /* CommandResult.Success */;
@@ -59460,66 +60548,25 @@ stores.inject(MyMetaStore, storeInstance);
               return;
           }
           const zone = this.getters.getRangeFromSheetXC(sheetId, range).zone;
-          const colorCellArgs = [];
+          const colorThresholds = [{ value: minValue, color: rule.minimum.color }];
           if (rule.midpoint && midValue) {
-              colorCellArgs.push({
-                  minValue,
-                  minColor: rule.minimum.color,
-                  colorDiffUnit: this.computeColorDiffUnits(minValue, midValue, rule.minimum.color, rule.midpoint.color),
-              });
-              colorCellArgs.push({
-                  minValue: midValue,
-                  minColor: rule.midpoint.color,
-                  colorDiffUnit: this.computeColorDiffUnits(midValue, maxValue, rule.midpoint.color, rule.maximum.color),
-              });
-          }
-          else {
-              colorCellArgs.push({
-                  minValue,
-                  minColor: rule.minimum.color,
-                  colorDiffUnit: this.computeColorDiffUnits(minValue, maxValue, rule.minimum.color, rule.maximum.color),
-              });
+              colorThresholds.push({ value: midValue, color: rule.midpoint.color });
           }
+          colorThresholds.push({ value: maxValue, color: rule.maximum.color });
+          const colorScale = getColorScale(colorThresholds);
           for (let row = zone.top; row <= zone.bottom; row++) {
               for (let col = zone.left; col <= zone.right; col++) {
                   const cell = this.getters.getEvaluatedCell({ sheetId, col, row });
                   if (cell.type === CellValueType.number) {
                       const value = clip(cell.value, minValue, maxValue);
-                      let color;
-                      if (colorCellArgs.length === 2 && midValue) {
-                          color =
-                              value <= midValue
-                                  ? this.colorCell(value, colorCellArgs[0].minValue, colorCellArgs[0].minColor, colorCellArgs[0].colorDiffUnit)
-                                  : this.colorCell(value, colorCellArgs[1].minValue, colorCellArgs[1].minColor, colorCellArgs[1].colorDiffUnit);
-                      }
-                      else {
-                          color = this.colorCell(value, colorCellArgs[0].minValue, colorCellArgs[0].minColor, colorCellArgs[0].colorDiffUnit);
-                      }
                       if (!computedStyle[col])
                           computedStyle[col] = [];
                       computedStyle[col][row] = computedStyle[col]?.[row] || {};
-                      computedStyle[col][row].fillColor = colorNumberString(color);
+                      computedStyle[col][row].fillColor = colorScale(value);
                   }
               }
           }
       }
-      computeColorDiffUnits(minValue, maxValue, minColor, maxColor) {
-          const deltaValue = maxValue - minValue;
-          const deltaColorR = ((minColor >> 16) % 256) - ((maxColor >> 16) % 256);
-          const deltaColorG = ((minColor >> 8) % 256) - ((maxColor >> 8) % 256);
-          const deltaColorB = (minColor % 256) - (maxColor % 256);
-          const colorDiffUnitR = deltaColorR / deltaValue;
-          const colorDiffUnitG = deltaColorG / deltaValue;
-          const colorDiffUnitB = deltaColorB / deltaValue;
-          return [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB];
-      }
-      colorCell(value, minValue, minColor, colorDiffUnit) {
-          const [colorDiffUnitR, colorDiffUnitG, colorDiffUnitB] = colorDiffUnit;
-          const r = Math.round(((minColor >> 16) % 256) - colorDiffUnitR * (value - minValue));
-          const g = Math.round(((minColor >> 8) % 256) - colorDiffUnitG * (value - minValue));
-          const b = Math.round((minColor % 256) - colorDiffUnitB * (value - minValue));
-          return (r << 16) | (g << 8) | b;
-      }
       /**
        * Execute the predicate to know if a conditional formatting rule should be applied to a cell
        */
@@ -60145,7 +61192,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           getValuesToAggregate(measure, domain) {
               const { rowDomain, colDomain } = domainToColRowDomain(this, domain);
-              const table = this.getTableStructure();
+              const table = super.getTableStructure();
               const values = [];
               if (colDomain.length === 0 &&
                   rowDomain.length < this.definition.rows.length &&
@@ -60579,6 +61626,21 @@ stores.inject(MyMetaStore, storeInstance);
               }
               throw new Error(`Value ${result.value} is not a number`);
           }
+          getTableStructure() {
+              const table = super.getTableStructure();
+              this.sortTableStructure(table);
+              return table;
+          }
+          sortTableStructure(table) {
+              if (!this.definition.sortedColumn || table.isSorted) {
+                  return;
+              }
+              const measure = this.definition.sortedColumn.measure;
+              const isSortValid = isSortedColumnValid(this.definition.sortedColumn, this);
+              if (isSortValid) {
+                  table.sort(measure, this.definition.sortedColumn, (measure, domain) => this._getPivotCellValueAndFormat(measure, domain));
+              }
+          }
       }
       return PivotPresentationLayer;
   }
@@ -60750,11 +61812,13 @@ stores.inject(MyMetaStore, storeInstance);
               return EMPTY_PIVOT_CELL;
           }
           if (functionName === "PIVOT") {
-              const includeTotal = args[2] === false ? false : undefined;
-              const includeColumnHeaders = args[3] === false ? false : undefined;
+              const includeTotal = toScalar(args[2]);
+              const shouldIncludeTotal = includeTotal === undefined ? true : toBoolean(includeTotal);
+              const includeColumnHeaders = toScalar(args[3]);
+              const shouldIncludeColumnHeaders = includeColumnHeaders === undefined ? true : toBoolean(includeColumnHeaders);
               const pivotCells = pivot
                   .getTableStructure()
-                  .getPivotCells(includeTotal, includeColumnHeaders);
+                  .getPivotCells(shouldIncludeTotal, shouldIncludeColumnHeaders);
               const pivotCol = position.col - mainPosition.col;
               const pivotRow = position.row - mainPosition.row;
               return pivotCells[pivotCol][pivotRow];
@@ -62352,23 +63416,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  function randomChoice(arr) {
-      return arr[Math.floor(Math.random() * arr.length)];
-  }
-  const colors = [
-      "#ff851b",
-      "#0074d9",
-      "#7fdbff",
-      "#b10dc9",
-      "#39cccc",
-      "#f012be",
-      "#3d9970",
-      "#111111",
-      "#ff4136",
-      "#aaaaaa",
-      "#85144b",
-      "#001f3f",
-  ];
   class CollaborativePlugin extends UIPlugin {
       static getters = [
           "getClientsToDisplay",
@@ -62377,7 +63424,7 @@ stores.inject(MyMetaStore, storeInstance);
           "isFullySynchronized",
       ];
       static layers = ["Selection"];
-      availableColors = new Set(colors);
+      availableColors = new AlternatingColorGenerator(12);
       colors = {};
       session;
       constructor(config) {
@@ -62388,14 +63435,6 @@ stores.inject(MyMetaStore, storeInstance);
           return (position.row < this.getters.getNumberRows(position.sheetId) &&
               position.col < this.getters.getNumberCols(position.sheetId));
       }
-      chooseNewColor() {
-          if (this.availableColors.size === 0) {
-              this.availableColors = new Set(colors);
-          }
-          const color = randomChoice([...this.availableColors.values()]);
-          this.availableColors.delete(color);
-          return color;
-      }
       getClient() {
           return this.session.getClient();
       }
@@ -62430,7 +63469,7 @@ stores.inject(MyMetaStore, storeInstance);
                   this.isPositionValid(client.position)) {
                   const position = client.position;
                   if (!this.colors[client.id]) {
-                      this.colors[client.id] = this.chooseNewColor();
+                      this.colors[client.id] = this.availableColors.next();
                   }
                   const color = this.colors[client.id];
                   clients.push({ ...client, position, color });
@@ -62667,7 +63706,7 @@ stores.inject(MyMetaStore, storeInstance);
                   for (let row = zone.top; row <= zone.bottom; row++) {
                       const position = { sheetId, col, row };
                       const pivotCell = this.getters.getPivotCellFromPosition(position);
-                      if (pivotCell.type === "VALUE") {
+                      if (this.isSpilledPivotValueFormula(position, pivotCell)) {
                           measurePositions.push(position);
                           const pivotId = this.getters.getPivotIdFromPosition(position) || "";
                           measuresByPivotId[pivotId] ??= new Set();
@@ -62704,6 +63743,10 @@ stores.inject(MyMetaStore, storeInstance);
               format,
           });
       }
+      isSpilledPivotValueFormula(position, pivotCell) {
+          const cell = this.getters.getCell(position);
+          return pivotCell.type === "VALUE" && !cell?.isFormula;
+      }
       /**
        * This function allows to adjust the quantity of decimal places after a decimal
        * point on cells containing number value. It does this by changing the cells
@@ -62754,6 +63797,69 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  class GeoFeaturePlugin extends UIPlugin {
+      static getters = [
+          "getGeoJsonFeatures",
+          "geoFeatureNameToId",
+          "getGeoChartAvailableRegions",
+      ];
+      geoJsonService;
+      geoJsonCache = {};
+      constructor(config) {
+          super(config);
+          this.geoJsonService = config.external.geoJsonService;
+      }
+      getGeoChartAvailableRegions() {
+          if (!this.geoJsonService) {
+              console.error("No geoJsonService provided to the model");
+              return [];
+          }
+          return this.geoJsonService.getAvailableRegions() || [];
+      }
+      getGeoJsonFeatures(region) {
+          if (!this.geoJsonService) {
+              console.error("No geoJsonService provided to the model");
+              return;
+          }
+          const cachedGeoJson = this.geoJsonCache[region];
+          if (cachedGeoJson instanceof Promise) {
+              return undefined;
+          }
+          if (cachedGeoJson !== undefined) {
+              return cachedGeoJson ?? undefined;
+          }
+          this.geoJsonCache[region] = new Promise(async (resolve) => {
+              const json = await this.geoJsonService?.getTopoJson(region);
+              this.geoJsonCache[region] = this.convertToGeoJson(json);
+              this.dispatch("EVALUATE_CHARTS");
+              resolve();
+          });
+          return undefined;
+      }
+      geoFeatureNameToId(region, featureName) {
+          if (!this.geoJsonService) {
+              console.error("No geoJsonService provided to the model");
+              return;
+          }
+          return this.geoJsonService.geoFeatureNameToId(region, featureName);
+      }
+      convertToGeoJson(json) {
+          if (!json) {
+              return null;
+          }
+          // TopoJSON
+          if (json.type === "Topology") {
+              const features = window.ChartGeo.topojson.feature(json, Object.values(json.objects)[0]);
+              return features.type === "FeatureCollection" ? features.features : [features];
+          }
+          // GeoJSON
+          else if (json.type === "FeatureCollection") {
+              return json.features;
+          }
+          throw new Error("Invalid TopoJSON");
+      }
+  }
+
   class HeaderVisibilityUIPlugin extends UIPlugin {
       static getters = [
           "getNextVisibleCellPosition",
@@ -62908,7 +64014,7 @@ stores.inject(MyMetaStore, storeInstance);
       getPivotDuplicateSheetName(pivotName) {
           let i = 1;
           const names = this.getters.getSheetIds().map((id) => this.getters.getSheetName(id));
-          const sanitizedName = pivotName.replace(new RegExp(FORBIDDEN_IN_EXCEL_REGEX, "g"), " ");
+          const sanitizedName = sanitizeSheetName(pivotName);
           let name = sanitizedName;
           while (names.includes(name)) {
               name = `${sanitizedName} (${i})`;
@@ -64291,10 +65397,13 @@ stores.inject(MyMetaStore, storeInstance);
               case "RESIZE_TABLE": {
                   const table = this.getters.getCoreTableMatchingTopLeft(cmd.sheetId, cmd.zone);
                   this.dispatch("UPDATE_TABLE", { ...cmd });
-                  if (!table || !table.config.automaticAutofill)
+                  if (!table)
                       return;
-                  const oldTableZone = table.range.zone;
                   const newTableZone = this.getters.getRangeFromRangeData(cmd.newTableRange).zone;
+                  this.selection.selectCell(newTableZone.right, newTableZone.bottom);
+                  if (!table.config.automaticAutofill)
+                      return;
+                  const oldTableZone = table.range.zone;
                   if (newTableZone.bottom >= oldTableZone.bottom) {
                       for (let col = newTableZone.left; col <= newTableZone.right; col++) {
                           const autofillSource = { col, row: oldTableZone.bottom, sheetId: cmd.sheetId };
@@ -65500,15 +66609,23 @@ stores.inject(MyMetaStore, storeInstance);
           handler.paste({ zones: pasteTarget, sheetId }, data, { isCutOperation: true });
           const toRemove = isBasedBefore ? cmd.elements.map((el) => el + thickness) : cmd.elements;
           let currentIndex = cmd.base;
+          const resizingGroups = {};
           for (const element of toRemove) {
               const size = this.getters.getHeaderSize(cmd.sheetId, cmd.dimension, element);
+              const currentSize = this.getters.getHeaderSize(cmd.sheetId, cmd.dimension, currentIndex);
+              if (size != currentSize) {
+                  resizingGroups[size] ??= [];
+                  resizingGroups[size].push(currentIndex);
+                  currentIndex += 1;
+              }
+          }
+          for (const size in resizingGroups) {
               this.dispatch("RESIZE_COLUMNS_ROWS", {
                   dimension: cmd.dimension,
                   sheetId: cmd.sheetId,
-                  size,
-                  elements: [currentIndex],
+                  size: parseInt(size, 10),
+                  elements: resizingGroups[size],
               });
-              currentIndex += 1;
           }
           this.dispatch("REMOVE_COLUMNS_ROWS", {
               dimension: cmd.dimension,
@@ -66090,6 +67207,7 @@ stores.inject(MyMetaStore, storeInstance);
                   break;
               case "DELETE_SHEET":
                   this.cleanViewports();
+                  this.sheetsWithDirtyViewports.delete(cmd.sheetId);
                   break;
               case "ACTIVATE_SHEET":
                   this.sheetsWithDirtyViewports.add(cmd.sheetIdTo);
@@ -66740,7 +67858,8 @@ stores.inject(MyMetaStore, storeInstance);
       .add("data_cleanup", DataCleanupPlugin)
       .add("table_autofill", TableAutofillPlugin)
       .add("table_ui_resize", TableResizeUI)
-      .add("datavalidation_insert", DataValidationInsertionPlugin);
+      .add("datavalidation_insert", DataValidationInsertionPlugin)
+      .add("geo_features", GeoFeaturePlugin);
   // Plugins which have a state, but which should not be shared in collaborative
   const statefulUIPluginRegistry = new Registry()
       .add("selection", GridSelectionPlugin)
@@ -66984,7 +68103,7 @@ stores.inject(MyMetaStore, storeInstance);
           env.raiseError(_t("A sheet with the name %s already exists. Please select another name.", name), errorCallback);
       }
       else if (result.reasons.includes("ForbiddenCharactersInSheetName" /* CommandResult.ForbiddenCharactersInSheetName */)) {
-          env.raiseError(_t("Some used characters are not allowed in a sheet name (Forbidden characters are %s).", FORBIDDEN_SHEET_CHARS.join(" ")), errorCallback);
+          env.raiseError(_t("Some used characters are not allowed in a sheet name (Forbidden characters are %s).", FORBIDDEN_SHEETNAME_CHARS.join(" ")), errorCallback);
       }
   }
 
@@ -68214,7 +69333,7 @@ stores.inject(MyMetaStore, storeInstance);
       setup() {
           owl.onWillUpdateProps((nextProps) => {
               if (nextProps.action !== this.props.action) {
-                  this.actionButton = createAction(this.props.action);
+                  this.actionButton = createAction(nextProps.action);
               }
           });
       }
@@ -68484,8 +69603,8 @@ stores.inject(MyMetaStore, storeInstance);
   .o-topbar-composer {
     height: fit-content;
     margin-top: -1px;
+    margin-bottom: -1px;
     border: 1px solid;
-    z-index: ${ComponentsImportance.TopBarComposer};
     font-family: ${DEFAULT_FONT};
 
     .o-composer:empty:not(:focus):not(.active)::before {
@@ -68543,6 +69662,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return cssPropertiesToCss({
               "border-color": SELECTION_BORDER_COLOR,
+              "z-index": String(ComponentsImportance.TopBarComposer),
           });
       }
       onFocus(selection) {
@@ -68550,88 +69670,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
-  css /* scss */ `
-  .o-font-size-editor {
-    height: calc(100% - 4px);
-    input.o-font-size {
-      outline-color: ${SELECTION_BORDER_COLOR};
-      height: 20px;
-      width: 23px;
-    }
-  }
-  .o-text-options > div {
-    cursor: pointer;
-    line-height: 26px;
-    padding: 3px 12px;
-    &:hover {
-      background-color: rgba(0, 0, 0, 0.08);
-    }
-  }
-`;
-  class FontSizeEditor extends owl.Component {
-      static template = "o-spreadsheet-FontSizeEditor";
-      static props = {
-          onToggle: Function,
-          dropdownStyle: String,
-          class: String,
-      };
-      static components = {};
-      fontSizes = FONT_SIZES;
-      dropdown = owl.useState({ isOpen: false });
-      inputRef = owl.useRef("inputFontSize");
-      rootEditorRef = owl.useRef("FontSizeEditor");
-      setup() {
-          owl.useExternalListener(window, "click", this.onExternalClick, { capture: true });
-      }
-      onExternalClick(ev) {
-          if (!isChildEvent(this.rootEditorRef.el, ev)) {
-              this.closeFontList();
-          }
-      }
-      get currentFontSize() {
-          return this.env.model.getters.getCurrentStyle().fontSize || DEFAULT_FONT_SIZE;
-      }
-      toggleFontList() {
-          const isOpen = this.dropdown.isOpen;
-          if (!isOpen) {
-              this.props.onToggle();
-              this.inputRef.el.focus();
-          }
-          else {
-              this.closeFontList();
-          }
-      }
-      closeFontList() {
-          this.dropdown.isOpen = false;
-      }
-      setSize(fontSizeStr) {
-          const fontSize = clip(Math.floor(parseFloat(fontSizeStr)), 1, 400);
-          setStyle(this.env, { fontSize });
-          this.closeFontList();
-      }
-      setSizeFromInput(ev) {
-          this.setSize(ev.target.value);
-      }
-      setSizeFromList(fontSizeStr) {
-          this.setSize(fontSizeStr);
-      }
-      onInputFocused(ev) {
-          this.dropdown.isOpen = true;
-          ev.target.select();
-      }
-      onInputKeydown(ev) {
-          if (ev.key === "Enter" || ev.key === "Escape") {
-              this.closeFontList();
-              const target = ev.target;
-              // In the case of a ESCAPE key, we get the previous font size back
-              if (ev.key === "Escape") {
-                  target.value = `${this.currentFontSize}`;
-              }
-              this.props.onToggle();
-          }
-      }
-  }
-
   class TableDropdownButton extends owl.Component {
       static template = "o-spreadsheet-TableDropdownButton";
       static components = { TableStylesPopover, ActionButton };
@@ -68733,6 +69771,15 @@ stores.inject(MyMetaStore, storeInstance);
       }
     }
 
+    .irregularity-map {
+      border-top: 1px solid ${SEPARATOR_COLOR};
+      height: ${TOPBAR_TOOLBAR_HEIGHT}px;
+
+      .alert-info {
+        border-left: 3px solid ${ALERT_INFO_BORDER};
+      }
+    }
+
     .o-topbar-composer {
       flex-grow: 1;
     }
@@ -68800,9 +69847,6 @@ stores.inject(MyMetaStore, storeInstance);
           onClick: Function,
           dropdownMaxHeight: Number,
       };
-      get dropdownStyle() {
-          return `max-height:${this.props.dropdownMaxHeight}px`;
-      }
       static components = {
           ColorPickerWidget,
           ColorPicker,
@@ -68829,8 +69873,10 @@ stores.inject(MyMetaStore, storeInstance);
       formatNumberMenuItemSpec = formatNumberMenuItemSpec;
       isntToolbarMenu = false;
       composerFocusStore;
+      fingerprints;
       setup() {
           this.composerFocusStore = useStore(ComposerFocusStore);
+          this.fingerprints = useStore(FormulaFingerprintStore);
           owl.useExternalListener(window, "click", this.onExternalClick);
           owl.onWillStart(() => this.updateCellState());
           owl.onWillUpdateProps(() => this.updateCellState());
@@ -68840,6 +69886,9 @@ stores.inject(MyMetaStore, storeInstance);
               .getAllOrdered()
               .filter((item) => !item.isVisible || item.isVisible(this.env));
       }
+      get currentFontSize() {
+          return this.env.model.getters.getCurrentStyle().fontSize || DEFAULT_FONT_SIZE;
+      }
       onExternalClick(ev) {
           // TODO : manage click events better. We need this piece of code
           // otherwise the event opening the menu would close it on the same frame.
@@ -68918,6 +69967,9 @@ stores.inject(MyMetaStore, storeInstance);
           setStyle(this.env, { [target]: color });
           this.onClick();
       }
+      setFontSize(fontSize) {
+          setStyle(this.env, { fontSize });
+      }
   }
 
   function instantiateClipboard() {
@@ -69295,7 +70347,7 @@ stores.inject(MyMetaStore, storeInstance);
               properties["grid-template-rows"] = `auto`;
           }
           else {
-              properties["grid-template-rows"] = `${TOPBAR_HEIGHT}px auto ${BOTTOMBAR_HEIGHT + 1}px`;
+              properties["grid-template-rows"] = `max-content auto ${BOTTOMBAR_HEIGHT + 1}px`;
           }
           properties["grid-template-columns"] = `auto ${this.sidePanel.panelSize}px`;
           return cssPropertiesToCss(properties);
@@ -70373,9 +71425,6 @@ stores.inject(MyMetaStore, storeInstance);
       getBackToDefault() {
           this.stream.getBackToDefault();
       }
-      getAnchor() {
-          return this.anchor;
-      }
       modifyAnchor(anchor, mode, options) {
           const sheetId = this.getters.getActiveSheetId();
           anchor = {
@@ -70918,12 +71967,11 @@ stores.inject(MyMetaStore, storeInstance);
       // <manualLayout/> to manually position the chart in the figure container
       let title = escapeXml ``;
       if (chart.data.title?.text) {
-          const color = chart.data.title.color
-              ? toXlsxHexColor(chart.data.title.color)
-              : chart.data.fontColor;
+          const titleColor = toXlsxHexColor(chartMutedFontColor(chart.data.backgroundColor));
+          const fontSize = chart.data.title.fontSize ?? CHART_TITLE_FONT_SIZE;
           title = escapeXml /*xml*/ `
       <c:title>
-        ${insertText(chart.data.title.text, color, DEFAULT_CHART_FONT_SIZE, chart.data.title)}
+        ${insertText(chart.data.title.text, titleColor, fontSize, chart.data.title)}
         <c:overlay val="0" />
       </c:title>
     `;
@@ -71013,7 +72061,7 @@ stores.inject(MyMetaStore, storeInstance);
     </a:ln>
   `;
   }
-  function insertText(text, fontColor = "000000", fontsize = DEFAULT_CHART_FONT_SIZE, style = {}) {
+  function insertText(text, fontColor = "000000", fontsize = CHART_TITLE_FONT_SIZE, style = {}) {
       return escapeXml /*xml*/ `
     <c:tx>
       <c:rich>
@@ -71514,6 +72562,7 @@ stores.inject(MyMetaStore, storeInstance);
       // Each Axis present inside a graph needs to be identified by an unsigned integer in order to be referenced by its crossAxis.
       // I.e. x-axis, will reference y-axis and vice-versa.
       const color = title?.color ? toXlsxHexColor(title.color) : defaultFontColor;
+      const fontSize = title?.fontSize ?? CHART_AXIS_TITLE_FONT_SIZE;
       return escapeXml /*xml*/ `
     <${axisName}>
       <c:axId val="${axId}"/>
@@ -71529,7 +72578,7 @@ stores.inject(MyMetaStore, storeInstance);
       <c:minorTickMark val="none" />
       <c:numFmt formatCode="General" sourceLinked="1" />
       <c:title>
-        ${insertText(title?.text ?? "", color, 10, title)}
+        ${insertText(title?.text ?? "", color, fontSize, title)}
       </c:title>
       ${insertTextProperties(10, defaultFontColor)}
     </${axisName}>
@@ -73307,6 +74356,7 @@ stores.inject(MyMetaStore, storeInstance);
               session: this.session,
               defaultCurrency: this.config.defaultCurrency,
               customColors: this.config.customColors || [],
+              external: this.config.external,
           };
       }
       // ---------------------------------------------------------------------------
@@ -73538,7 +74588,6 @@ stores.inject(MyMetaStore, storeInstance);
       MIN_COL_WIDTH,
       HEADER_HEIGHT,
       HEADER_WIDTH,
-      TOPBAR_HEIGHT,
       BOTTOMBAR_HEIGHT,
       DEFAULT_CELL_WIDTH,
       DEFAULT_CELL_HEIGHT,
@@ -73640,6 +74689,7 @@ stores.inject(MyMetaStore, storeInstance);
       createPivotFormula,
       areDomainArgsFieldsValid,
       splitReference,
+      sanitizeSheetName,
   };
   const links = {
       isMarkdownLink,
@@ -73778,9 +74828,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.1.0-alpha.6";
-  __info__.date = "2024-11-28T09:06:59.527Z";
-  __info__.hash = "875c901";
+  __info__.version = "18.1.0-alpha.8";
+  __info__.date = "2024-12-19T07:49:54.421Z";
+  __info__.hash = "87a1567";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);