@odoo/o-spreadsheet 18.1.0-alpha.7 → 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.7
- * @date 2024-12-05T10:40:26.512Z
- * @hash 7b1c39b
+ * @version 18.1.0-alpha.8
+ * @date 2024-12-19T07:49:54.421Z
+ * @hash 87a1567
  */
 
 (function (exports, owl) {
@@ -266,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;
@@ -790,6 +789,7 @@
    * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Character_Classes
    */
   const whiteSpaceSpecialCharacters = [
+      " ",
       "\t",
       "\f",
       "\v",
@@ -804,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.
@@ -980,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",
@@ -1003,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].
@@ -1353,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
@@ -1381,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];
   }
@@ -1398,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;
@@ -1412,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
@@ -3283,6 +3432,7 @@
   ]);
   const invalidateChartEvaluationCommands = new Set([
       "EVALUATE_CELLS",
+      "EVALUATE_CHARTS",
       "UPDATE_CELL",
       "UNHIDE_COLUMNS_ROWS",
       "HIDE_COLUMNS_ROWS",
@@ -3319,6 +3469,7 @@
       "RESIZE_SHEETVIEW",
       "SET_VIEWPORT_OFFSET",
       "EVALUATE_CELLS",
+      "EVALUATE_CHARTS",
       "SET_FORMULA_VISIBILITY",
       "UPDATE_FILTER",
   ]);
@@ -6523,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()) {
@@ -6670,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;
   }
@@ -7534,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) {
@@ -8044,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) {
@@ -14652,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;
@@ -14744,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));
@@ -14761,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) => {
@@ -20490,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.
@@ -20536,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);
       }
@@ -20717,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
@@ -20975,6 +21120,7 @@ stores.inject(MyMetaStore, storeInstance);
                   return error;
               },
               isBadExpression: true,
+              normalizedFormula: tokens.map((t) => t.value).join(""),
           };
       }
   }
@@ -21102,6 +21248,7 @@ stores.inject(MyMetaStore, storeInstance);
           symbols,
           tokens,
           isBadExpression: false,
+          normalizedFormula: cacheKey,
       };
       return compiledFormula;
   }
@@ -21366,6 +21513,7 @@ stores.inject(MyMetaStore, storeInstance);
                   description: definition.name,
                   htmlContent: [{ value: str, color: tokenColors.NUMBER }],
                   fuzzySearchKey: str + definition.name,
+                  alwaysExpanded: true,
               };
           })
               .filter(isDefined);
@@ -27759,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"),
@@ -28162,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 = [];
@@ -28714,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;
@@ -29091,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;
@@ -29154,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;
@@ -29313,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);
@@ -29339,6 +29652,10 @@ stores.inject(MyMetaStore, storeInstance);
     getComboChartDatasets: getComboChartDatasets,
     getComboChartLegend: getComboChartLegend,
     getData: getData,
+    getGeoChartData: getGeoChartData,
+    getGeoChartDatasets: getGeoChartDatasets,
+    getGeoChartScales: getGeoChartScales,
+    getGeoChartTooltip: getGeoChartTooltip,
     getLineChartData: getLineChartData,
     getLineChartDatasets: getLineChartDatasets,
     getLineChartLegend: getLineChartLegend,
@@ -29912,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;
@@ -30905,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);
@@ -30916,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"),
@@ -31075,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",
   });
 
   /**
@@ -31925,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,
@@ -31974,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;
 
@@ -31984,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;
@@ -32008,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;
@@ -34212,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) {
@@ -34248,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
@@ -34346,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 = {
@@ -34366,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",
   };
@@ -34394,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",
   };
@@ -34877,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) => {
@@ -35048,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(),
@@ -35665,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
@@ -35967,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 = {
@@ -38262,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() {
@@ -38575,6 +39442,10 @@ stores.inject(MyMetaStore, storeInstance);
       .add("radar", {
       configuration: GenericChartConfigPanel,
       design: RadarChartDesignPanel,
+  })
+      .add("geo", {
+      configuration: GeoChartConfigPanel,
+      design: GeoChartDesignPanel,
   });
 
   css /* scss */ `
@@ -39938,7 +40809,7 @@ stores.inject(MyMetaStore, storeInstance);
       border-color: ${GRAY_300};
 
       &.active {
-        border-color: ${SELECTION_BORDER_COLOR};
+        border-color: ${ACTION_COLOR};
       }
 
       &.o-invalid {
@@ -40896,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();
@@ -41041,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 });
       }
@@ -43644,6 +44518,64 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  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 */ `
   .add-calculated-measure {
     cursor: pointer;
@@ -43657,6 +44589,7 @@ stores.inject(MyMetaStore, storeInstance);
           PivotDimensionOrder,
           PivotDimensionGranularity,
           PivotMeasureEditor,
+          PivotSortSection,
       };
       static props = {
           definition: Object,
@@ -43813,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}` : "");
@@ -43971,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) ||
@@ -44128,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
@@ -44301,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);
@@ -44323,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] = [];
@@ -44341,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" };
 
@@ -44418,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,
           };
       });
@@ -45283,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;
@@ -45341,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 {
@@ -46442,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 };
@@ -46460,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(),
           };
@@ -46469,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) {
@@ -48085,6 +49072,7 @@ stores.inject(MyMetaStore, storeInstance);
           draggedFigure: undefined,
           horizontalSnap: undefined,
           verticalSnap: undefined,
+          cancelDnd: undefined,
       });
       setup() {
           owl.onMounted(() => {
@@ -48097,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;
       }
@@ -48221,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
@@ -48269,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);
@@ -49376,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() {
@@ -49856,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),
@@ -49888,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;
@@ -51866,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
    *
@@ -52360,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;
@@ -55305,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 {
@@ -59588,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
        */
@@ -60273,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 &&
@@ -60707,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;
   }
@@ -62482,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",
@@ -62507,7 +63424,7 @@ stores.inject(MyMetaStore, storeInstance);
           "isFullySynchronized",
       ];
       static layers = ["Selection"];
-      availableColors = new Set(colors);
+      availableColors = new AlternatingColorGenerator(12);
       colors = {};
       session;
       constructor(config) {
@@ -62518,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();
       }
@@ -62560,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 });
@@ -62797,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();
@@ -62834,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
@@ -62884,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",
@@ -64421,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 };
@@ -65630,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,
@@ -66220,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);
@@ -66870,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)
@@ -68614,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 {
@@ -68673,6 +69662,7 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return cssPropertiesToCss({
               "border-color": SELECTION_BORDER_COLOR,
+              "z-index": String(ComponentsImportance.TopBarComposer),
           });
       }
       onFocus(selection) {
@@ -68781,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;
     }
@@ -68874,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());
@@ -69346,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);
@@ -70424,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 = {
@@ -73358,6 +74356,7 @@ stores.inject(MyMetaStore, storeInstance);
               session: this.session,
               defaultCurrency: this.config.defaultCurrency,
               customColors: this.config.customColors || [],
+              external: this.config.external,
           };
       }
       // ---------------------------------------------------------------------------
@@ -73589,7 +74588,6 @@ stores.inject(MyMetaStore, storeInstance);
       MIN_COL_WIDTH,
       HEADER_HEIGHT,
       HEADER_WIDTH,
-      TOPBAR_HEIGHT,
       BOTTOMBAR_HEIGHT,
       DEFAULT_CELL_WIDTH,
       DEFAULT_CELL_HEIGHT,
@@ -73830,9 +74828,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "18.1.0-alpha.7";
-  __info__.date = "2024-12-05T10:40:26.512Z";
-  __info__.hash = "7b1c39b";
+  __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);