@odoo/o-spreadsheet 17.4.0-alpha.5 → 17.4.0-alpha.6

package/dist/o-spreadsheet.iife.js

@@ -3,9 +3,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.4.0-alpha.5
- * @date 2024-06-14T10:01:40.605Z
- * @hash 9ceed96
+ * @version 17.4.0-alpha.6
+ * @date 2024-06-19T13:46:27.157Z
+ * @hash a4f22e4
  */
 
 (function (exports, owl) {
@@ -6201,7 +6201,7 @@
           };
       }
       isPasteAllowed(sheetId, target, content, clipboardOptions) {
-          if (!("cells" in content)) {
+          if (!content.cells) {
               return "Success" /* CommandResult.Success */;
           }
           if (clipboardOptions?.isCutOperation && clipboardOptions?.pasteOption !== undefined) {
@@ -6215,6 +6215,17 @@
                   return "WrongPasteSelection" /* CommandResult.WrongPasteSelection */;
               }
           }
+          const clipboardHeight = content.cells.length;
+          const clipboardWidth = content.cells[0].length;
+          for (const zone of getPasteZones(target, content.cells)) {
+              if (this.getters.doesIntersectMerge(sheetId, zone)) {
+                  if (target.length > 1 ||
+                      !this.getters.isSingleCellOrMerge(sheetId, target[0]) ||
+                      clipboardHeight * clipboardWidth !== 1) {
+                      return "WillRemoveExistingMerge" /* CommandResult.WillRemoveExistingMerge */;
+                  }
+              }
+          }
           return "Success" /* CommandResult.Success */;
       }
       /**
@@ -6454,13 +6465,22 @@
           }
           const { rowsIndexes, columnsIndexes } = data;
           const sheetId = data.sheetId;
-          const cellPositions = rowsIndexes.map((row) => columnsIndexes.map((col) => ({ col, row, sheetId })));
-          return {
-              cellPositions,
-          };
+          const cfRules = [];
+          for (const row of rowsIndexes) {
+              const cfRuleInRow = [];
+              for (const col of columnsIndexes) {
+                  const cfRules = Array.from(this.getters.getRulesByCell(sheetId, col, row));
+                  cfRuleInRow.push({
+                      position: { col, row, sheetId },
+                      rules: cfRules,
+                  });
+              }
+              cfRules.push(cfRuleInRow);
+          }
+          return { cfRules };
       }
       paste(target, clippedContent, options) {
-          if (!clippedContent?.cellPositions ||
+          if (!clippedContent?.cfRules ||
               options?.pasteOption === "asValue" ||
               !("zones" in target) ||
               !target.zones.length) {
@@ -6469,7 +6489,7 @@
           const zones = target.zones;
           const sheetId = target.sheetId;
           if (!options?.isCutOperation) {
-              this.pasteFromCopy(sheetId, zones, clippedContent.cellPositions);
+              this.pasteFromCopy(sheetId, zones, clippedContent.cfRules, options);
           }
           else {
               this.pasteFromCut(sheetId, zones, clippedContent);
@@ -6477,12 +6497,12 @@
       }
       pasteFromCut(sheetId, target, content) {
           const selection = target[0];
-          this.pasteZone(sheetId, selection.left, selection.top, content.cellPositions, {
+          this.pasteZone(sheetId, selection.left, selection.top, content.cfRules, {
               isCutOperation: true,
           });
       }
-      pasteZone(sheetId, col, row, positions, clipboardOptions) {
-          for (const [r, rowCells] of positions.entries()) {
+      pasteZone(sheetId, col, row, cfRules, clipboardOptions) {
+          for (const [r, rowCells] of cfRules.entries()) {
               for (const [c, origin] of rowCells.entries()) {
                   const position = { col: col + c, row: row + r, sheetId };
                   this.pasteCf(origin, position, clipboardOptions?.isCutOperation);
@@ -6490,23 +6510,21 @@
           }
       }
       pasteCf(origin, target, isCutOperation) {
-          const zone = positionToZone(target);
-          for (const rule of this.getters.getConditionalFormats(origin.sheetId)) {
-              for (const range of rule.ranges) {
-                  if (isInside(origin.col, origin.row, this.getters.getRangeFromSheetXC(origin.sheetId, range).zone)) {
-                      const toRemoveZones = [];
-                      if (isCutOperation) {
-                          //remove from current rule
-                          toRemoveZones.push(positionToZone(origin));
-                      }
-                      if (origin.sheetId === target.sheetId) {
-                          this.adaptCFRules(origin.sheetId, rule, [zone], toRemoveZones);
-                      }
-                      else {
-                          this.adaptCFRules(origin.sheetId, rule, [], toRemoveZones);
-                          const cfToCopyTo = this.getCFToCopyTo(target.sheetId, rule);
-                          this.adaptCFRules(target.sheetId, cfToCopyTo, [zone], []);
-                      }
+          if (origin?.rules && origin.rules.length > 0) {
+              const zone = positionToZone(target);
+              for (const rule of origin.rules) {
+                  const toRemoveZones = [];
+                  if (isCutOperation) {
+                      //remove from current rule
+                      toRemoveZones.push(positionToZone(origin.position));
+                  }
+                  if (origin.position.sheetId === target.sheetId) {
+                      this.adaptCFRules(origin.position.sheetId, rule, [zone], toRemoveZones);
+                  }
+                  else {
+                      this.adaptCFRules(origin.position.sheetId, rule, [], toRemoveZones);
+                      const cfToCopyTo = this.getCFToCopyTo(target.sheetId, rule);
+                      this.adaptCFRules(target.sheetId, cfToCopyTo, [zone], []);
                   }
               }
           }
@@ -6549,13 +6567,20 @@
           }
           const { rowsIndexes, columnsIndexes } = data;
           const sheetId = data.sheetId;
-          const cellPositions = rowsIndexes.map((row) => columnsIndexes.map((col) => ({ col, row, sheetId })));
-          return {
-              cellPositions,
-          };
+          const dvRules = [];
+          for (const row of rowsIndexes) {
+              const dvRuleInRow = [];
+              for (const col of columnsIndexes) {
+                  const position = { sheetId, col, row };
+                  const rule = this.getters.getValidationRuleForCell(position);
+                  dvRuleInRow.push({ position, rule });
+              }
+              dvRules.push(dvRuleInRow);
+          }
+          return { dvRules };
       }
       paste(target, clippedContent, options) {
-          if (!clippedContent?.cellPositions) {
+          if (!clippedContent?.dvRules) {
               return;
           }
           if (options?.pasteOption) {
@@ -6567,7 +6592,7 @@
           const zones = target.zones;
           const sheetId = target.sheetId;
           if (!options?.isCutOperation) {
-              this.pasteFromCopy(sheetId, zones, clippedContent.cellPositions);
+              this.pasteFromCopy(sheetId, zones, clippedContent.dvRules);
           }
           else {
               this.pasteFromCut(sheetId, zones, clippedContent);
@@ -6575,12 +6600,12 @@
       }
       pasteFromCut(sheetId, target, content) {
           const selection = target[0];
-          this.pasteZone(sheetId, selection.left, selection.top, content.cellPositions, {
+          this.pasteZone(sheetId, selection.left, selection.top, content.dvRules, {
               isCutOperation: true,
           });
       }
-      pasteZone(sheetId, col, row, positions, clipboardOptions) {
-          for (const [r, rowCells] of positions.entries()) {
+      pasteZone(sheetId, col, row, dvRules, clipboardOptions) {
+          for (const [r, rowCells] of dvRules.entries()) {
               for (const [c, origin] of rowCells.entries()) {
                   const position = { col: col + c, row: row + r, sheetId };
                   this.pasteDataValidation(origin, position, clipboardOptions?.isCutOperation);
@@ -6588,41 +6613,43 @@
           }
       }
       pasteDataValidation(origin, target, isCutOperation) {
-          const rule = this.getters.getValidationRuleForCell(origin);
-          if (!rule) {
-              const targetRule = this.getters.getValidationRuleForCell(target);
-              if (targetRule) {
-                  // Remove the data validation rule on the target cell
-                  this.adaptDataValidationRule(target.sheetId, targetRule, [], [positionToZone(target)]);
-              }
-              return;
-          }
-          const zone = positionToZone(target);
-          for (const range of rule.ranges) {
-              if (isInside(origin.col, origin.row, range.zone)) {
-                  const toRemoveZone = [];
-                  if (isCutOperation) {
-                      toRemoveZone.push(positionToZone(origin));
-                  }
-                  if (origin.sheetId === target.sheetId) {
-                      this.adaptDataValidationRule(origin.sheetId, rule, [zone], toRemoveZone);
+          if (origin) {
+              const zone = positionToZone(target);
+              const rule = origin.rule;
+              if (!rule) {
+                  const targetRule = this.getters.getValidationRuleForCell(target);
+                  if (targetRule) {
+                      // Remove the data validation rule on the target cell
+                      this.adaptDataValidationRule(target.sheetId, targetRule, [], [zone]);
                   }
-                  else {
-                      this.adaptDataValidationRule(origin.sheetId, rule, [], toRemoveZone);
-                      const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
-                      this.adaptDataValidationRule(target.sheetId, copyToRule, [zone], []);
+                  return;
+              }
+              const toRemoveZone = [];
+              if (isCutOperation) {
+                  toRemoveZone.push(positionToZone(origin.position));
+              }
+              if (origin.position.sheetId === target.sheetId) {
+                  const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule, false);
+                  this.adaptDataValidationRule(origin.position.sheetId, copyToRule, [zone], toRemoveZone);
+              }
+              else {
+                  const originRule = this.getters.getValidationRuleForCell(origin.position);
+                  if (originRule) {
+                      this.adaptDataValidationRule(origin.position.sheetId, originRule, [], toRemoveZone);
                   }
+                  const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
+                  this.adaptDataValidationRule(target.sheetId, copyToRule, [zone], []);
               }
           }
       }
-      getDataValidationRuleToCopyTo(targetSheetId, originRule) {
+      getDataValidationRuleToCopyTo(targetSheetId, originRule, newId = true) {
           const ruleInTargetSheet = this.getters
               .getDataValidationRules(targetSheetId)
               .find((rule) => deepEquals(originRule.criterion, rule.criterion) &&
               originRule.isBlocking === rule.isBlocking);
           return ruleInTargetSheet
               ? ruleInTargetSheet
-              : { ...originRule, id: this.uuidGenerator.uuidv4(), ranges: [] };
+              : { ...originRule, id: newId ? this.uuidGenerator.uuidv4() : originRule.id, ranges: [] };
       }
       /**
        * Add or remove XCs to a given data validation rule.
@@ -6714,69 +6741,63 @@
   }
 
   class MergeClipboardHandler extends AbstractCellClipboardHandler {
-      isPasteAllowed(sheetId, target, content) {
-          if (!("cells" in content)) {
-              return "Success" /* CommandResult.Success */;
+      copy(data) {
+          if (!data.zones.length) {
+              return;
           }
-          const clipboardHeight = content.cells.length;
-          const clipboardWidth = content.cells[0].length;
-          for (const zone of getPasteZones(target, content.cells)) {
-              if (this.getters.doesIntersectMerge(sheetId, zone)) {
-                  if (target.length > 1 ||
-                      !this.getters.isSingleCellOrMerge(sheetId, target[0]) ||
-                      clipboardHeight * clipboardWidth !== 1) {
-                      return "WillRemoveExistingMerge" /* CommandResult.WillRemoveExistingMerge */;
-                  }
+          const sheetId = this.getters.getActiveSheetId();
+          const { rowsIndexes, columnsIndexes } = data;
+          const merges = [];
+          for (const row of rowsIndexes) {
+              const mergesInRow = [];
+              for (const col of columnsIndexes) {
+                  const position = { col, row, sheetId };
+                  mergesInRow.push(this.getters.getMerge(position));
               }
+              merges.push(mergesInRow);
           }
-          return "Success" /* CommandResult.Success */;
+          return { merges };
       }
       /**
        * Paste the clipboard content in the given target
        */
       paste(target, content, options) {
-          if (options?.isCutOperation || !("zones" in target) || !target.zones.length) {
+          if (!content.merges ||
+              options?.isCutOperation ||
+              !("zones" in target) ||
+              !target.zones.length) {
               return;
           }
-          this.pasteFromCopy(target.sheetId, target.zones, content.cells, options);
+          this.pasteFromCopy(target.sheetId, target.zones, content.merges, options);
       }
-      pasteZone(sheetId, col, row, cells) {
-          for (const [r, rowCells] of cells.entries()) {
-              for (const [c, origin] of rowCells.entries()) {
-                  if (!origin.position) {
-                      continue;
-                  }
+      pasteZone(sheetId, col, row, merges) {
+          for (const [r, rowMerges] of merges.entries()) {
+              for (const [c, originMerge] of rowMerges.entries()) {
                   const position = { col: col + c, row: row + r, sheetId };
-                  this.pasteMergeIfExist(origin.position, position);
+                  this.pasteMerge(originMerge, position);
               }
           }
       }
-      /**
-       * If the origin position given is the top left of a merge, merge the target
-       * position.
-       */
-      pasteMergeIfExist(origin, target) {
-          let { sheetId, col, row } = origin;
-          const { col: mainCellColOrigin, row: mainCellRowOrigin } = this.getters.getMainCellPosition(origin);
-          if (mainCellColOrigin === col && mainCellRowOrigin === row) {
-              const merge = this.getters.getMerge(origin);
-              if (!merge) {
-                  return;
-              }
-              ({ sheetId, col, row } = target);
-              this.dispatch("ADD_MERGE", {
-                  sheetId,
-                  force: true,
-                  target: [
-                      {
-                          left: col,
-                          top: row,
-                          right: col + merge.right - merge.left,
-                          bottom: row + merge.bottom - merge.top,
-                      },
-                  ],
-              });
+      pasteMerge(originMerge, target) {
+          if (!originMerge) {
+              return;
+          }
+          if (this.getters.isInMerge(target)) {
+              return;
           }
+          const { sheetId, col, row } = target;
+          this.dispatch("ADD_MERGE", {
+              sheetId,
+              force: true,
+              target: [
+                  {
+                      left: col,
+                      top: row,
+                      right: col + originMerge.right - originMerge.left,
+                      bottom: row + originMerge.bottom - originMerge.top,
+                  },
+              ],
+          });
       }
   }
 
@@ -7756,6 +7777,486 @@
       };
   }
 
+  function boolAnd(args) {
+      let foundBoolean = false;
+      let acc = true;
+      conditionalVisitBoolean(args, (arg) => {
+          foundBoolean = true;
+          acc = acc && arg;
+          return acc;
+      });
+      return {
+          foundBoolean,
+          result: acc,
+      };
+  }
+  function boolOr(args) {
+      let foundBoolean = false;
+      let acc = false;
+      conditionalVisitBoolean(args, (arg) => {
+          foundBoolean = true;
+          acc = acc || arg;
+          return !acc;
+      });
+      return {
+          foundBoolean,
+          result: acc,
+      };
+  }
+
+  function sum(values, locale) {
+      return reduceNumbers(values, (acc, a) => acc + a, 0, locale);
+  }
+  function countUnique(args) {
+      return reduceAny(args, (acc, a) => (isDataNonEmpty(a) ? acc.add(a?.value) : acc), new Set()).size;
+  }
+
+  function assertSameNumberOfElements(...args) {
+      const dims = args[0].length;
+      args.forEach((arg, i) => assert(() => arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
+  }
+  function average(values, locale) {
+      let count = 0;
+      const sum = reduceNumbers(values, (acc, a) => {
+          count += 1;
+          return acc + a;
+      }, 0, locale);
+      assertNotZero(count);
+      return sum / count;
+  }
+  function countNumbers(values, locale) {
+      let count = 0;
+      for (let n of values) {
+          if (isMatrix(n)) {
+              for (let i of n) {
+                  for (let j of i) {
+                      if (typeof j.value === "number") {
+                          count += 1;
+                      }
+                  }
+              }
+          }
+          else {
+              const value = n?.value;
+              if (!isEvaluationError(value) &&
+                  (typeof value !== "string" || isNumber(value, locale) || parseDateTime(value, locale))) {
+                  count += 1;
+              }
+          }
+      }
+      return count;
+  }
+  function countAny(values) {
+      return reduceAny(values, (acc, a) => (a !== undefined && a.value !== null ? acc + 1 : acc), 0);
+  }
+  function max(values, locale) {
+      const result = reduceNumbers(values, (acc, a) => (acc < a ? a : acc), -Infinity, locale);
+      return result === -Infinity ? 0 : result;
+  }
+  function min(values, locale) {
+      const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity, locale);
+      return result === Infinity ? 0 : result;
+  }
+
+  const pivotTimeAdapterRegistry = new Registry();
+  function pivotTimeAdapter(granularity) {
+      return pivotTimeAdapterRegistry.get(granularity);
+  }
+  /**
+   * The Time Adapter: Managing Time Periods for Pivot Functions
+   *
+   * Overview:
+   * A time adapter is responsible for managing time periods associated with pivot functions.
+   * Each type of period (day, week, month, quarter, etc.) has its own dedicated adapter.
+   * The adapter's primary role is to normalize period values between spreadsheet functions,
+   * and the pivot.
+   * By normalizing the period value, it can be stored consistently in the pivot.
+   *
+   * Normalization Process:
+   * When working with functions in the spreadsheet, the time adapter normalizes
+   * the provided period to facilitate accurate lookup of values in the pivot.
+   * For instance, if the spreadsheet function represents a day period as a number generated
+   * by the DATE function (DATE(2023, 12, 25)), the time adapter will normalize it accordingly.
+   *
+   */
+  /**
+   * Normalized value: "12/25/2023"
+   *
+   * Note: Those two format are equivalent:
+   * - "MM/dd/yyyy" (luxon format)
+   * - "mm/dd/yyyy" (spreadsheet format)
+   **/
+  const dayAdapter = {
+      normalizeFunctionValue(value) {
+          const date = toNumber(value, DEFAULT_LOCALE);
+          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/dd/yyyy" });
+      },
+      getFormat(locale) {
+          return (locale ?? DEFAULT_LOCALE).dateFormat;
+      },
+      formatValue(normalizedValue, locale) {
+          locale = locale ?? DEFAULT_LOCALE;
+          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
+          return formatValue(value, { locale, format: this.getFormat(locale) });
+      },
+      toCellValue(normalizedValue) {
+          return toNumber(normalizedValue, DEFAULT_LOCALE);
+      },
+  };
+  /**
+   * normalizes day of month number
+   */
+  const dayOfMonthAdapter = {
+      normalizeFunctionValue(value) {
+          const day = toNumber(value, DEFAULT_LOCALE);
+          if (day < 1 || day > 31) {
+              throw new EvaluationError(_t("%s is not a valid day of month (it should be a number between 1 and 31)", day));
+          }
+          return day;
+      },
+      getFormat() {
+          return "0";
+      },
+      formatValue(normalizedValue, locale) {
+          locale = locale ?? DEFAULT_LOCALE;
+          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
+          return formatValue(value, { locale, format: this.getFormat(locale) });
+      },
+      toCellValue(normalizedValue) {
+          return toNumber(normalizedValue, DEFAULT_LOCALE);
+      },
+  };
+  /**
+   * Normalized value: "2/2023" for week 2 of 2023
+   */
+  const weekAdapter = {
+      normalizeFunctionValue(value) {
+          const [week, year] = value.split("/");
+          return `${Number(week)}/${Number(year)}`;
+      },
+      getFormat() {
+          return undefined;
+      },
+      formatValue(normalizedValue) {
+          const [week, year] = normalizedValue.split("/");
+          return _t("W%(week)s %(year)s", { week, year });
+      },
+      toCellValue(normalizedValue) {
+          return this.formatValue(normalizedValue);
+      },
+  };
+  /**
+   * normalizes iso week number
+   */
+  const isoWeekNumberAdapter = {
+      normalizeFunctionValue(value) {
+          const isoWeek = toNumber(value, DEFAULT_LOCALE);
+          if (isoWeek < 0 || isoWeek > 53) {
+              throw new EvaluationError(_t("%s is not a valid week (it should be a number between 0 and 53)", isoWeek));
+          }
+          return isoWeek;
+      },
+      getFormat() {
+          return "0";
+      },
+      formatValue(normalizedValue, locale) {
+          locale = locale ?? DEFAULT_LOCALE;
+          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
+          return formatValue(value, { locale, format: this.getFormat(locale) });
+      },
+      toCellValue(normalizedValue) {
+          return toNumber(normalizedValue, DEFAULT_LOCALE);
+      },
+  };
+  /**
+   * normalized month value is a string formatted as "MM/yyyy" (luxon format)
+   * e.g. "01/2020" for January 2020
+   */
+  const monthAdapter = {
+      normalizeFunctionValue(value) {
+          const date = toNumber(value, DEFAULT_LOCALE);
+          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/yyyy" });
+      },
+      getFormat() {
+          return "mmmm yyyy";
+      },
+      formatValue(normalizedValue, locale) {
+          locale = locale ?? DEFAULT_LOCALE;
+          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
+          return formatValue(value, { locale, format: this.getFormat(locale) });
+      },
+      toCellValue(normalizedValue) {
+          return toNumber(normalizedValue, DEFAULT_LOCALE);
+      },
+  };
+  /**
+   * normalizes month number
+   */
+  const monthNumberAdapter = {
+      normalizeFunctionValue(value) {
+          const month = toNumber(value, DEFAULT_LOCALE);
+          if (month < 1 || month > 12) {
+              throw new EvaluationError(_t("%s is not a valid month (it should be a number between 1 and 12)", month));
+          }
+          return month;
+      },
+      getFormat() {
+          return "0";
+      },
+      formatValue(normalizedValue, locale) {
+          locale = locale ?? DEFAULT_LOCALE;
+          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
+          return formatValue(value, { locale, format: this.getFormat(locale) });
+      },
+      toCellValue(normalizedValue) {
+          return MONTHS[toNumber(normalizedValue, DEFAULT_LOCALE) - 1].toString();
+      },
+  };
+  /**
+   * normalized quarter value is "quarter/year"
+   * e.g. "1/2020" for Q1 2020
+   */
+  const quarterAdapter = {
+      normalizeFunctionValue(value) {
+          const [quarter, year] = value.split("/");
+          return `${quarter}/${year}`;
+      },
+      getFormat() {
+          return undefined;
+      },
+      formatValue(normalizedValue) {
+          const [quarter, year] = normalizedValue.split("/");
+          return _t("Q%(quarter)s %(year)s", { quarter, year });
+      },
+      toCellValue(normalizedValue) {
+          return this.formatValue(normalizedValue);
+      },
+  };
+  /**
+   * normalizes quarter number
+   */
+  const quarterNumberAdapter = {
+      normalizeFunctionValue(value) {
+          const quarter = toNumber(value, DEFAULT_LOCALE);
+          if (quarter < 1 || quarter > 4) {
+              throw new EvaluationError(_t("%s is not a valid quarter (it should be a number between 1 and 4)", quarter));
+          }
+          return quarter;
+      },
+      getFormat() {
+          return "0";
+      },
+      formatValue(normalizedValue, locale) {
+          locale = locale ?? DEFAULT_LOCALE;
+          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
+          return formatValue(value, { locale, format: this.getFormat(locale) });
+      },
+      toCellValue(normalizedValue) {
+          return toNumber(normalizedValue, DEFAULT_LOCALE);
+      },
+  };
+  const yearAdapter = {
+      normalizeFunctionValue(value) {
+          return toNumber(value, DEFAULT_LOCALE);
+      },
+      getFormat() {
+          return "0";
+      },
+      formatValue(normalizedValue, locale) {
+          locale = locale ?? DEFAULT_LOCALE;
+          return formatValue(normalizedValue, { locale, format: "0" });
+      },
+      toCellValue(normalizedValue) {
+          return toNumber(normalizedValue, DEFAULT_LOCALE);
+      },
+  };
+  pivotTimeAdapterRegistry
+      .add("day", dayAdapter)
+      .add("week", weekAdapter)
+      .add("month", monthAdapter)
+      .add("quarter", quarterAdapter)
+      .add("year", yearAdapter)
+      .add("day_of_month", dayOfMonthAdapter)
+      .add("iso_week_number", isoWeekNumberAdapter)
+      .add("month_number", monthNumberAdapter)
+      .add("quarter_number", quarterNumberAdapter)
+      .add("year_number", yearAdapter);
+
+  const AGGREGATOR_NAMES = {
+      count: _t("Count"),
+      count_distinct: _t("Count Distinct"),
+      bool_and: _t("Boolean And"),
+      bool_or: _t("Boolean Or"),
+      max: _t("Maximum"),
+      min: _t("Minimum"),
+      avg: _t("Average"),
+      sum: _t("Sum"),
+  };
+  const NUMBER_CHAR_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
+  const AGGREGATORS_BY_FIELD_TYPE = {
+      integer: NUMBER_CHAR_AGGREGATORS,
+      char: NUMBER_CHAR_AGGREGATORS,
+      boolean: ["count_distinct", "count", "bool_and", "bool_or"],
+  };
+  const AGGREGATORS = {};
+  for (const type in AGGREGATORS_BY_FIELD_TYPE) {
+      AGGREGATORS[type] = {};
+      for (const aggregator of AGGREGATORS_BY_FIELD_TYPE[type]) {
+          AGGREGATORS[type][aggregator] = AGGREGATOR_NAMES[aggregator];
+      }
+  }
+  const AGGREGATORS_FN = {
+      count: {
+          fn: (args) => countAny([args]),
+          format: () => "0",
+      },
+      count_distinct: {
+          fn: (args) => countUnique([args]),
+          format: () => "0",
+      },
+      bool_and: {
+          fn: (args) => boolAnd([args]).result,
+          format: () => undefined,
+      },
+      bool_or: {
+          fn: (args) => boolOr([args]).result,
+          format: () => undefined,
+      },
+      max: {
+          fn: (args, locale) => max([args], locale),
+          format: inferFormat,
+      },
+      min: {
+          fn: (args, locale) => min([args], locale),
+          format: inferFormat,
+      },
+      avg: {
+          fn: (args, locale) => average([args], locale),
+          format: inferFormat,
+      },
+      sum: {
+          fn: (args, locale) => sum([args], locale),
+          format: inferFormat,
+      },
+  };
+  function makePivotFormulaFromPivotCell(pivotFormulaId, pivotCell) {
+      switch (pivotCell.type) {
+          case "HEADER":
+              return makePivotFormula("PIVOT.HEADER", [pivotFormulaId, ...flatPivotDomain(pivotCell.domain)].filter(isDefined));
+          case "MEASURE_HEADER":
+              return makePivotFormula("PIVOT.HEADER", [pivotFormulaId, ...flatPivotDomain(pivotCell.domain), "measure", pivotCell.measure].filter(isDefined));
+          case "VALUE":
+              return makePivotFormula("PIVOT.VALUE", [pivotFormulaId, pivotCell.measure, ...flatPivotDomain(pivotCell.domain)].filter(isDefined));
+          case "EMPTY":
+              return "";
+      }
+  }
+  /**
+   * Build a pivot formula expression
+   */
+  function makePivotFormula(formula, args) {
+      return `=${formula}(${args
+        .map((arg) => {
+        const stringIsNumber = typeof arg == "string" && !isNaN(Number(arg)) && Number(arg).toString() === arg;
+        const convertToNumber = typeof arg == "number" || stringIsNumber;
+        return convertToNumber ? `${arg}` : `"${arg.toString().replace(/"/g, '\\"')}"`;
+    })
+        .join(",")})`;
+  }
+  /**
+   * Given an object of form {"1": {...}, "2": {...}, ...} get the maximum ID used
+   * in this object
+   * If the object has no keys, return 0
+   *
+   */
+  function getMaxObjectId(o) {
+      const keys = Object.keys(o);
+      if (!keys.length) {
+          return 0;
+      }
+      const nums = keys.map((id) => parseInt(id, 10));
+      const max = Math.max(...nums);
+      return max;
+  }
+  const ALL_PERIODS = {
+      year: _t("Year"),
+      quarter: _t("Quarter"),
+      month: _t("Month"),
+      week: _t("Week"),
+      day: _t("Day"),
+      year_number: _t("Year"),
+      quarter_number: _t("Quarter"),
+      month_number: _t("Month"),
+      iso_week_number: _t("Week"),
+      day_of_month: _t("Day of Month"),
+  };
+  const DATE_FIELDS = ["date", "datetime"];
+  /**
+   * Parse a dimension string into a pivot dimension definition.
+   * e.g "create_date:month" => { name: "create_date", granularity: "month" }
+   */
+  function parseDimension(dimension) {
+      const [name, granularity] = dimension.split(":");
+      if (granularity) {
+          return { name, granularity };
+      }
+      return { name };
+  }
+  function isDateField(field) {
+      return DATE_FIELDS.includes(field.type);
+  }
+  function toPivotDomain(domainStr) {
+      if (domainStr.length % 2 !== 0) {
+          throw new Error("Invalid domain: odd number of elements");
+      }
+      const domain = [];
+      for (let i = 0; i < domainStr.length - 1; i += 2) {
+          domain.push({ field: domainStr[i], value: domainStr[i + 1] });
+      }
+      return domain;
+  }
+  function flatPivotDomain(domain) {
+      return domain.flatMap((arg) => [arg.field, arg.value]);
+  }
+  /**
+   * Parses the value defining a pivot group in a PIVOT formula
+   * e.g. given the following formula PIVOT.VALUE("1", "stage_id", "42", "status", "won"),
+   * the two group values are "42" and "won".
+   */
+  function toNormalizedPivotValue(dimension, groupValue) {
+      if (groupValue === null || groupValue === "null") {
+          return null;
+      }
+      const groupValueString = typeof groupValue === "boolean"
+          ? toString(groupValue).toLocaleLowerCase()
+          : toString(groupValue);
+      if (!pivotNormalizationValueRegistry.contains(dimension.type)) {
+          throw new EvaluationError(_t("Field %(field)s is not supported because of its type (%(type)s)", {
+              field: dimension.displayName,
+              type: dimension.type,
+          }));
+      }
+      // represents a field which is not set (=False server side)
+      if (groupValueString === "false") {
+          return false;
+      }
+      const normalizer = pivotNormalizationValueRegistry.get(dimension.type);
+      return normalizer(groupValueString, dimension.granularity);
+  }
+  function normalizeDateTime(value, granularity) {
+      if (!granularity) {
+          throw "";
+      }
+      return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
+  }
+  const pivotNormalizationValueRegistry = new Registry();
+  pivotNormalizationValueRegistry
+      .add("date", normalizeDateTime)
+      .add("datetime", normalizeDateTime)
+      .add("integer", (value) => toNumber(value, DEFAULT_LOCALE))
+      .add("boolean", (value) => toBoolean(value))
+      .add("char", (value) => toString(value));
+
   /**
    * Change the reference types inside the given token, if the token represent a range or a cell
    *
@@ -7954,6 +8455,11 @@
   const ChartTerms = {
       Series: _t("Series"),
       BackgroundColor: _t("Background color"),
+      StackedBarChart: _t("Stacked bar chart"),
+      StackedLineChart: _t("Stacked line chart"),
+      CumulativeData: _t("Cumulative data"),
+      TreatLabelsAsText: _t("Treat labels as text"),
+      AggregatedChart: _t("Aggregate"),
       Errors: {
           Unexpected: _t("The chart definition is invalid for an unknown reason"),
           // BASIC CHART ERRORS (LINE | BAR | PIE)
@@ -8886,6 +9392,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
       const color = highlight.color || HIGHLIGHT_COLOR;
       const { ctx } = renderingContext;
+      ctx.save();
       if (!highlight.noBorder) {
           if (highlight.dashed) {
               ctx.setLineDash([5, 3]);
@@ -8905,6 +9412,7 @@ stores.inject(MyMetaStore, storeInstance);
           ctx.fillStyle = setColorAlpha(toHex(color), highlight.fillAlpha ?? 0.12);
           ctx.fillRect(x, y, width, height);
       }
+      ctx.restore();
   }
 
   class HighlightStore extends SpreadsheetStore {
@@ -9435,8 +9943,20 @@ stores.inject(MyMetaStore, storeInstance);
       replaceSelectedRange(zone) {
           const ref = this.getZoneReference(zone);
           const currentToken = this.tokenAtCursor;
-          const start = currentToken?.type === "REFERENCE" ? currentToken.start : this.selectionStart;
-          this.replaceText(ref, start, this.selectionEnd);
+          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.parenIndex === currentToken.parenIndex);
+              const functionToken = this.currentTokens[leftParenthesisIndex - 1];
+              if (functionToken === undefined) {
+                  return;
+              }
+              replaceStart = functionToken.start;
+          }
+          this.replaceText(ref, replaceStart, this.selectionEnd);
       }
       /**
        * Replace the reference of the old zone by the new one.
@@ -9456,10 +9976,8 @@ stores.inject(MyMetaStore, storeInstance);
               const refRange = this.getters.getRangeFromSheetXC(activeSheetId, xc);
               return isEqual(this.getters.expandZone(activeSheetId, refRange.zone), oldZone);
           });
-          // this function assumes that the previous range is always found because
-          // it's called when changing a highlight, which exists by definition
           if (!previousRefToken) {
-              throw new Error("Previous range not found");
+              return;
           }
           const previousRange = this.getters.getRangeFromSheetXC(activeSheetId, previousRefToken.value);
           this.selectionStart = previousRefToken.start;
@@ -9471,6 +9989,17 @@ stores.inject(MyMetaStore, storeInstance);
       getZoneReference(zone) {
           const inputSheetId = this.currentEditedCell.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 = makePivotFormulaFromPivotCell(formulaPivotId, pivotCell);
+                  return formula.slice(1); // strip leading =
+              }
+          }
           const range = this.getters.getRangeFromZone(sheetId, zone);
           return this.getters.getSelectionRangeString(range, inputSheetId);
       }
@@ -9573,19 +10102,35 @@ stores.inject(MyMetaStore, storeInstance);
               const colorIndex = this.colorIndexByRange[rangeString];
               return colors$1[colorIndex % colors$1.length];
           };
-          return this.getReferencedRanges().map((range) => {
+          const highlights = [];
+          for (const range of this.getReferencedRanges()) {
               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;
-              return {
+              highlights.push({
                   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
@@ -9844,8 +10389,14 @@ stores.inject(MyMetaStore, storeInstance);
           owl.useEffect(() => {
               const runtime = this.chartRuntime;
               if (!deepEquals(runtime, this.currentRuntime, "ignoreFunctions")) {
+                  if (runtime.chartJsConfig.type !== this.currentRuntime.chartJsConfig.type) {
+                      this.chart?.destroy();
+                      this.createChart(deepCopy(runtime.chartJsConfig));
+                  }
+                  else {
+                      this.updateChartJs(deepCopy(runtime));
+                  }
                   this.currentRuntime = runtime;
-                  this.updateChartJs(deepCopy(runtime));
               }
           });
       }
@@ -10213,6 +10764,9 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function getDefinedAxis(definition) {
       let useLeftAxis = false, useRightAxis = false;
+      if ("horizontal" in definition && definition.horizontal) {
+          return { useLeftAxis: true, useRightAxis: false };
+      }
       for (const design of definition.dataSets || []) {
           if (design.yAxisId === "y1") {
               useRightAxis = true;
@@ -11780,13 +12334,6 @@ stores.inject(MyMetaStore, storeInstance);
     FORMAT_LARGE_NUMBER: FORMAT_LARGE_NUMBER
   });
 
-  function sum(values, locale) {
-      return reduceNumbers(values, (acc, a) => acc + a, 0, locale);
-  }
-  function countUnique(args) {
-      return reduceAny(args, (acc, a) => (isDataNonEmpty(a) ? acc.add(a?.value) : acc), new Set()).size;
-  }
-
   const DEFAULT_FACTOR = 1;
   const DEFAULT_MODE = 0;
   const DEFAULT_PLACES = 0;
@@ -12900,53 +13447,6 @@ stores.inject(MyMetaStore, storeInstance);
     TRUNC: TRUNC
   });
 
-  function assertSameNumberOfElements(...args) {
-      const dims = args[0].length;
-      args.forEach((arg, i) => assert(() => arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
-  }
-  function average(values, locale) {
-      let count = 0;
-      const sum = reduceNumbers(values, (acc, a) => {
-          count += 1;
-          return acc + a;
-      }, 0, locale);
-      assertNotZero(count);
-      return sum / count;
-  }
-  function countNumbers(values, locale) {
-      let count = 0;
-      for (let n of values) {
-          if (isMatrix(n)) {
-              for (let i of n) {
-                  for (let j of i) {
-                      if (typeof j.value === "number") {
-                          count += 1;
-                      }
-                  }
-              }
-          }
-          else {
-              const value = n?.value;
-              if (!isEvaluationError(value) &&
-                  (typeof value !== "string" || isNumber(value, locale) || parseDateTime(value, locale))) {
-                  count += 1;
-              }
-          }
-      }
-      return count;
-  }
-  function countAny(values) {
-      return reduceAny(values, (acc, a) => (a !== undefined && a.value !== null ? acc + 1 : acc), 0);
-  }
-  function max(values, locale) {
-      const result = reduceNumbers(values, (acc, a) => (acc < a ? a : acc), -Infinity, locale);
-      return result === -Infinity ? 0 : result;
-  }
-  function min(values, locale) {
-      const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity, locale);
-      return result === Infinity ? 0 : result;
-  }
-
   function filterAndFlatData(dataY, dataX) {
       const _flatDataY = [];
       const _flatDataX = [];
@@ -13502,7 +14002,7 @@ stores.inject(MyMetaStore, storeInstance);
   // LINEST
   // -----------------------------------------------------------------------------
   const LINEST = {
-      description: _t("Compute the intercept of the linear regression."),
+      description: _t("Given partial data about a linear trend, calculates various parameters about the ideal linear trend using the least-squares method."),
       args: [
           arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
           arg("data_x (range<number>, default={1;2;3;...})", _t("The range representing the array or matrix of independent data.")),
@@ -13518,7 +14018,7 @@ stores.inject(MyMetaStore, storeInstance);
   // LOGEST
   // -----------------------------------------------------------------------------
   const LOGEST = {
-      description: _t("Compute the intercept of the linear regression."),
+      description: _t("Given partial data about an exponential growth curve, calculates various parameters about the best fit ideal exponential growth curve."),
       args: [
           arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
           arg("data_x (range<number>, optional, default={1;2;3;...})", _t("The range representing the array or matrix of independent data.")),
@@ -17921,33 +18421,6 @@ stores.inject(MyMetaStore, storeInstance);
     NA: NA
   });
 
-  function boolAnd(args) {
-      let foundBoolean = false;
-      let acc = true;
-      conditionalVisitBoolean(args, (arg) => {
-          foundBoolean = true;
-          acc = acc && arg;
-          return acc;
-      });
-      return {
-          foundBoolean,
-          result: acc,
-      };
-  }
-  function boolOr(args) {
-      let foundBoolean = false;
-      let acc = false;
-      conditionalVisitBoolean(args, (arg) => {
-          foundBoolean = true;
-          acc = acc || arg;
-          return !acc;
-      });
-      return {
-          foundBoolean,
-          result: acc,
-      };
-  }
-
   // -----------------------------------------------------------------------------
   // AND
   // -----------------------------------------------------------------------------
@@ -18145,393 +18618,6 @@ stores.inject(MyMetaStore, storeInstance);
     XOR: XOR
   });
 
-  const pivotTimeAdapterRegistry = new Registry();
-  function pivotTimeAdapter(granularity) {
-      return pivotTimeAdapterRegistry.get(granularity);
-  }
-  /**
-   * The Time Adapter: Managing Time Periods for Pivot Functions
-   *
-   * Overview:
-   * A time adapter is responsible for managing time periods associated with pivot functions.
-   * Each type of period (day, week, month, quarter, etc.) has its own dedicated adapter.
-   * The adapter's primary role is to normalize period values between spreadsheet functions,
-   * and the pivot.
-   * By normalizing the period value, it can be stored consistently in the pivot.
-   *
-   * Normalization Process:
-   * When working with functions in the spreadsheet, the time adapter normalizes
-   * the provided period to facilitate accurate lookup of values in the pivot.
-   * For instance, if the spreadsheet function represents a day period as a number generated
-   * by the DATE function (DATE(2023, 12, 25)), the time adapter will normalize it accordingly.
-   *
-   */
-  /**
-   * Normalized value: "12/25/2023"
-   *
-   * Note: Those two format are equivalent:
-   * - "MM/dd/yyyy" (luxon format)
-   * - "mm/dd/yyyy" (spreadsheet format)
-   **/
-  const dayAdapter = {
-      normalizeFunctionValue(value) {
-          const date = toNumber(value, DEFAULT_LOCALE);
-          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/dd/yyyy" });
-      },
-      getFormat(locale) {
-          return (locale ?? DEFAULT_LOCALE).dateFormat;
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * normalizes day of month number
-   */
-  const dayOfMonthAdapter = {
-      normalizeFunctionValue(value) {
-          const day = toNumber(value, DEFAULT_LOCALE);
-          if (day < 1 || day > 31) {
-              throw new EvaluationError(_t("%s is not a valid day of month (it should be a number between 1 and 31)", day));
-          }
-          return day;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * Normalized value: "2/2023" for week 2 of 2023
-   */
-  const weekAdapter = {
-      normalizeFunctionValue(value) {
-          const [week, year] = value.split("/");
-          return `${Number(week)}/${Number(year)}`;
-      },
-      getFormat() {
-          return undefined;
-      },
-      formatValue(normalizedValue) {
-          const [week, year] = normalizedValue.split("/");
-          return _t("W%(week)s %(year)s", { week, year });
-      },
-      toCellValue(normalizedValue) {
-          return this.formatValue(normalizedValue);
-      },
-  };
-  /**
-   * normalizes iso week number
-   */
-  const isoWeekNumberAdapter = {
-      normalizeFunctionValue(value) {
-          const isoWeek = toNumber(value, DEFAULT_LOCALE);
-          if (isoWeek < 0 || isoWeek > 53) {
-              throw new EvaluationError(_t("%s is not a valid week (it should be a number between 0 and 53)", isoWeek));
-          }
-          return isoWeek;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * normalized month value is a string formatted as "MM/yyyy" (luxon format)
-   * e.g. "01/2020" for January 2020
-   */
-  const monthAdapter = {
-      normalizeFunctionValue(value) {
-          const date = toNumber(value, DEFAULT_LOCALE);
-          return formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/yyyy" });
-      },
-      getFormat() {
-          return "mmmm yyyy";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  /**
-   * normalizes month number
-   */
-  const monthNumberAdapter = {
-      normalizeFunctionValue(value) {
-          const month = toNumber(value, DEFAULT_LOCALE);
-          if (month < 1 || month > 12) {
-              throw new EvaluationError(_t("%s is not a valid month (it should be a number between 1 and 12)", month));
-          }
-          return month;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return MONTHS[toNumber(normalizedValue, DEFAULT_LOCALE) - 1].toString();
-      },
-  };
-  /**
-   * normalized quarter value is "quarter/year"
-   * e.g. "1/2020" for Q1 2020
-   */
-  const quarterAdapter = {
-      normalizeFunctionValue(value) {
-          const [quarter, year] = value.split("/");
-          return `${quarter}/${year}`;
-      },
-      getFormat() {
-          return undefined;
-      },
-      formatValue(normalizedValue) {
-          const [quarter, year] = normalizedValue.split("/");
-          return _t("Q%(quarter)s %(year)s", { quarter, year });
-      },
-      toCellValue(normalizedValue) {
-          return this.formatValue(normalizedValue);
-      },
-  };
-  /**
-   * normalizes quarter number
-   */
-  const quarterNumberAdapter = {
-      normalizeFunctionValue(value) {
-          const quarter = toNumber(value, DEFAULT_LOCALE);
-          if (quarter < 1 || quarter > 4) {
-              throw new EvaluationError(_t("%s is not a valid quarter (it should be a number between 1 and 4)", quarter));
-          }
-          return quarter;
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          const value = toNumber(normalizedValue, DEFAULT_LOCALE);
-          return formatValue(value, { locale, format: this.getFormat(locale) });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  const yearAdapter = {
-      normalizeFunctionValue(value) {
-          return toNumber(value, DEFAULT_LOCALE);
-      },
-      getFormat() {
-          return "0";
-      },
-      formatValue(normalizedValue, locale) {
-          locale = locale ?? DEFAULT_LOCALE;
-          return formatValue(normalizedValue, { locale, format: "0" });
-      },
-      toCellValue(normalizedValue) {
-          return toNumber(normalizedValue, DEFAULT_LOCALE);
-      },
-  };
-  pivotTimeAdapterRegistry
-      .add("day", dayAdapter)
-      .add("week", weekAdapter)
-      .add("month", monthAdapter)
-      .add("quarter", quarterAdapter)
-      .add("year", yearAdapter)
-      .add("day_of_month", dayOfMonthAdapter)
-      .add("iso_week_number", isoWeekNumberAdapter)
-      .add("month_number", monthNumberAdapter)
-      .add("quarter_number", quarterNumberAdapter)
-      .add("year_number", yearAdapter);
-
-  const AGGREGATOR_NAMES = {
-      count: _t("Count"),
-      count_distinct: _t("Count Distinct"),
-      bool_and: _t("Boolean And"),
-      bool_or: _t("Boolean Or"),
-      max: _t("Maximum"),
-      min: _t("Minimum"),
-      avg: _t("Average"),
-      sum: _t("Sum"),
-  };
-  const NUMBER_CHAR_AGGREGATORS = ["max", "min", "avg", "sum", "count_distinct", "count"];
-  const AGGREGATORS_BY_FIELD_TYPE = {
-      integer: NUMBER_CHAR_AGGREGATORS,
-      char: NUMBER_CHAR_AGGREGATORS,
-      boolean: ["count_distinct", "count", "bool_and", "bool_or"],
-  };
-  const AGGREGATORS = {};
-  for (const type in AGGREGATORS_BY_FIELD_TYPE) {
-      AGGREGATORS[type] = {};
-      for (const aggregator of AGGREGATORS_BY_FIELD_TYPE[type]) {
-          AGGREGATORS[type][aggregator] = AGGREGATOR_NAMES[aggregator];
-      }
-  }
-  const AGGREGATORS_FN = {
-      count: {
-          fn: (args) => countAny([args]),
-          format: () => "0",
-      },
-      count_distinct: {
-          fn: (args) => countUnique([args]),
-          format: () => "0",
-      },
-      bool_and: {
-          fn: (args) => boolAnd([args]).result,
-          format: () => undefined,
-      },
-      bool_or: {
-          fn: (args) => boolOr([args]).result,
-          format: () => undefined,
-      },
-      max: {
-          fn: (args, locale) => max([args], locale),
-          format: inferFormat,
-      },
-      min: {
-          fn: (args, locale) => min([args], locale),
-          format: inferFormat,
-      },
-      avg: {
-          fn: (args, locale) => average([args], locale),
-          format: inferFormat,
-      },
-      sum: {
-          fn: (args, locale) => sum([args], locale),
-          format: inferFormat,
-      },
-  };
-  /**
-   * Build a pivot formula expression
-   */
-  function makePivotFormula(formula, args) {
-      return `=${formula}(${args
-        .map((arg) => {
-        const stringIsNumber = typeof arg == "string" && !isNaN(Number(arg)) && Number(arg).toString() === arg;
-        const convertToNumber = typeof arg == "number" || stringIsNumber;
-        return convertToNumber ? `${arg}` : `"${arg.toString().replace(/"/g, '\\"')}"`;
-    })
-        .join(",")})`;
-  }
-  /**
-   * Given an object of form {"1": {...}, "2": {...}, ...} get the maximum ID used
-   * in this object
-   * If the object has no keys, return 0
-   *
-   */
-  function getMaxObjectId(o) {
-      const keys = Object.keys(o);
-      if (!keys.length) {
-          return 0;
-      }
-      const nums = keys.map((id) => parseInt(id, 10));
-      const max = Math.max(...nums);
-      return max;
-  }
-  const ALL_PERIODS = {
-      year: _t("Year"),
-      quarter: _t("Quarter"),
-      month: _t("Month"),
-      week: _t("Week"),
-      day: _t("Day"),
-      year_number: _t("Year"),
-      quarter_number: _t("Quarter"),
-      month_number: _t("Month"),
-      iso_week_number: _t("Week"),
-      day_of_month: _t("Day of Month"),
-  };
-  const DATE_FIELDS = ["date", "datetime"];
-  /**
-   * Parse a dimension string into a pivot dimension definition.
-   * e.g "create_date:month" => { name: "create_date", granularity: "month" }
-   */
-  function parseDimension(dimension) {
-      const [name, granularity] = dimension.split(":");
-      if (granularity) {
-          return { name, granularity };
-      }
-      return { name };
-  }
-  function isDateField(field) {
-      return DATE_FIELDS.includes(field.type);
-  }
-  function toPivotDomain(domainStr) {
-      if (domainStr.length % 2 !== 0) {
-          throw new Error("Invalid domain: odd number of elements");
-      }
-      const domain = [];
-      for (let i = 0; i < domainStr.length - 1; i += 2) {
-          domain.push({ field: domainStr[i], value: domainStr[i + 1] });
-      }
-      return domain;
-  }
-  function flatPivotDomain(domain) {
-      return domain.flatMap((arg) => [arg.field, arg.value]);
-  }
-  /**
-   * Parses the value defining a pivot group in a PIVOT formula
-   * e.g. given the following formula PIVOT.VALUE("1", "stage_id", "42", "status", "won"),
-   * the two group values are "42" and "won".
-   */
-  function toNormalizedPivotValue(dimension, groupValue) {
-      if (groupValue === null || groupValue === "null") {
-          return null;
-      }
-      const groupValueString = typeof groupValue === "boolean"
-          ? toString(groupValue).toLocaleLowerCase()
-          : toString(groupValue);
-      if (!pivotNormalizationValueRegistry.contains(dimension.type)) {
-          throw new EvaluationError(_t("Field %(field)s is not supported because of its type (%(type)s)", {
-              field: dimension.displayName,
-              type: dimension.type,
-          }));
-      }
-      // represents a field which is not set (=False server side)
-      if (groupValueString === "false") {
-          return false;
-      }
-      const normalizer = pivotNormalizationValueRegistry.get(dimension.type);
-      return normalizer(groupValueString, dimension.granularity);
-  }
-  function normalizeDateTime(value, granularity) {
-      if (!granularity) {
-          throw "";
-      }
-      return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
-  }
-  const pivotNormalizationValueRegistry = new Registry();
-  pivotNormalizationValueRegistry
-      .add("date", normalizeDateTime)
-      .add("datetime", normalizeDateTime)
-      .add("integer", (value) => toNumber(value, DEFAULT_LOCALE))
-      .add("boolean", (value) => toBoolean(value))
-      .add("char", (value) => toString(value));
-
   /**
    * Get the pivot ID from the formula pivot ID.
    */
@@ -19108,14 +19194,10 @@ stores.inject(MyMetaStore, storeInstance);
                           result[col].push({ value: "" });
                           break;
                       case "HEADER":
-                          const domain = pivotCell.domain;
-                          const lastNode = domain.at(-1);
-                          if (lastNode?.field === "measure") {
-                              result[col].push(pivot.getPivotMeasureValue(toString(lastNode.value), domain));
-                          }
-                          else {
-                              result[col].push(pivot.getPivotHeaderValueAndFormat(domain));
-                          }
+                          result[col].push(pivot.getPivotHeaderValueAndFormat(pivotCell.domain));
+                          break;
+                      case "MEASURE_HEADER":
+                          result[col].push(pivot.getPivotMeasureValue(pivotCell.measure, pivotCell.domain));
                           break;
                       case "VALUE":
                           result[col].push(pivot.getPivotCellValueAndFormat(pivotCell.measure, pivotCell.domain));
@@ -20154,6 +20236,8 @@ stores.inject(MyMetaStore, storeInstance);
    * a child element.
    */
   function isChildEvent(parent, ev) {
+      if (!parent)
+          return false;
       return !!ev.target && parent.contains(ev.target);
   }
   function gridOverlayPosition() {
@@ -22693,7 +22777,8 @@ stores.inject(MyMetaStore, storeInstance);
   /**
    * Get a default chart js configuration
    */
-  function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale, truncateLabels }) {
+  function getDefaultChartJsRuntime(chart, labels, fontColor, args) {
+      const { format, locale, truncateLabels, horizontalChart } = args;
       const chartTitle = chart.title.text ? chart.title : { ...chart.title, content: "" };
       const options = {
           // https://www.chartjs.org/docs/latest/general/responsive.html
@@ -22737,8 +22822,11 @@ stores.inject(MyMetaStore, storeInstance);
                   callbacks: {
                       label: function (tooltipItem) {
                           const xLabel = tooltipItem.dataset?.label || tooltipItem.label;
-                          // tooltipItem.parsed.y can be an object or a number for pie charts
-                          const yLabel = tooltipItem.parsed.y ?? tooltipItem.parsed;
+                          // tooltipItem.parsed can be an object or a number for pie charts
+                          let yLabel = horizontalChart ? tooltipItem.parsed.x : tooltipItem.parsed.y;
+                          if (!yLabel) {
+                              yLabel = tooltipItem.parsed;
+                          }
                           const toolTipFormat = !format && Math.abs(yLabel) >= 1000 ? "#,##" : format;
                           const yLabelStr = formatValue(yLabel, { format: toolTipFormat, locale });
                           return xLabel ? `${xLabel}: ${yLabelStr}` : yLabelStr;
@@ -22912,6 +23000,7 @@ stores.inject(MyMetaStore, storeInstance);
       dataSetsHaveTitle;
       dataSetDesign;
       axesDesign;
+      horizontal;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -22923,6 +23012,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
           this.dataSetDesign = definition.dataSets;
           this.axesDesign = definition.axesDesign;
+          this.horizontal = definition.horizontal;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -22994,6 +23084,7 @@ stores.inject(MyMetaStore, storeInstance);
               stacked: this.stacked,
               aggregated: this.aggregated,
               axesDesign: this.axesDesign,
+              horizontal: this.horizontal,
           };
       }
       getDefinitionForExcel() {
@@ -23025,7 +23116,10 @@ stores.inject(MyMetaStore, storeInstance);
   }
   function getBarConfiguration(chart, labels, localeFormat) {
       const fontColor = chartFontColor(chart.background);
-      const config = getDefaultChartJsRuntime(chart, labels, fontColor, localeFormat);
+      const config = getDefaultChartJsRuntime(chart, labels, fontColor, {
+          ...localeFormat,
+          horizontalChart: chart.horizontal,
+      });
       const legend = {
           labels: { color: fontColor },
       };
@@ -23039,16 +23133,10 @@ stores.inject(MyMetaStore, storeInstance);
       config.options.layout = {
           padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
       };
-      config.options.scales = {
-          x: {
-              ticks: {
-                  padding: 5,
-                  color: fontColor,
-              },
-              title: getChartAxisTitleRuntime(chart.axesDesign?.x),
-          },
-      };
-      const yAxis = {
+      config.options.indexAxis = chart.horizontal ? "y" : "x";
+      config.options.scales = {};
+      const labelsAxis = { ticks: { padding: 5, color: fontColor } };
+      const valuesAxis = {
           beginAtZero: true, // the origin of the y axis is always zero
           ticks: {
               color: fontColor,
@@ -23064,7 +23152,10 @@ stores.inject(MyMetaStore, storeInstance);
               },
           },
       };
+      const xAxis = chart.horizontal ? valuesAxis : labelsAxis;
+      const yAxis = chart.horizontal ? labelsAxis : valuesAxis;
       const { useLeftAxis, useRightAxis } = getDefinedAxis(chart.getDefinition());
+      config.options.scales.x = { ...xAxis, title: getChartAxisTitleRuntime(chart.axesDesign?.x) };
       if (useLeftAxis) {
           config.options.scales.y = {
               ...yAxis,
@@ -23131,7 +23222,7 @@ stores.inject(MyMetaStore, storeInstance);
               const label = definition.dataSets[index].label;
               dataset.label = label;
           }
-          if (definition.dataSets?.[index]?.yAxisId) {
+          if (definition.dataSets?.[index]?.yAxisId && !chart.horizontal) {
               dataset["yAxisID"] = definition.dataSets[index].yAxisId;
           }
       }
@@ -24122,6 +24213,7 @@ stores.inject(MyMetaStore, storeInstance);
       type = "pie";
       aggregated;
       dataSetsHaveTitle;
+      isDoughnut;
       constructor(definition, sheetId, getters) {
           super(definition, sheetId, getters);
           this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24130,6 +24222,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.legendPosition = definition.legendPosition;
           this.aggregated = definition.aggregated;
           this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
+          this.isDoughnut = definition.isDoughnut;
       }
       static transformDefinition(definition, executed) {
           return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24147,6 +24240,7 @@ stores.inject(MyMetaStore, storeInstance);
               type: "pie",
               labelRange: context.auxiliaryRange || undefined,
               aggregated: context.aggregated ?? false,
+              isDoughnut: false,
           };
       }
       getDefinition() {
@@ -24177,6 +24271,7 @@ stores.inject(MyMetaStore, storeInstance);
                   : undefined,
               title: this.title,
               aggregated: this.aggregated,
+              isDoughnut: this.isDoughnut,
           };
       }
       copyForSheetId(sheetId) {
@@ -24311,6 +24406,141 @@ stores.inject(MyMetaStore, storeInstance);
           };
           config.data.datasets.push(dataset);
       }
+      if (chart.isDoughnut) {
+          config.type = "doughnut";
+      }
+      return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
+  }
+
+  class PyramidChart extends AbstractChart {
+      dataSets;
+      labelRange;
+      background;
+      legendPosition;
+      aggregated;
+      type = "pyramid";
+      dataSetsHaveTitle;
+      dataSetDesign;
+      axesDesign;
+      horizontal = true;
+      stacked = true;
+      constructor(definition, sheetId, getters) {
+          super(definition, sheetId, getters);
+          this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle).slice(0, 2);
+          this.labelRange = createValidRange(getters, sheetId, definition.labelRange);
+          this.background = definition.background;
+          this.legendPosition = definition.legendPosition;
+          this.aggregated = definition.aggregated;
+          this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
+          this.dataSetDesign = definition.dataSets;
+          this.axesDesign = definition.axesDesign;
+      }
+      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,
+              aggregated: context.aggregated ?? false,
+              legendPosition: context.legendPosition ?? "top",
+              title: context.title || { text: "" },
+              type: "pyramid",
+              labelRange: context.auxiliaryRange || undefined,
+              axesDesign: context.axesDesign,
+              horizontal: true,
+              stacked: true,
+          };
+      }
+      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 PyramidChart(definition, sheetId, this.getters);
+      }
+      copyInSheetId(sheetId) {
+          const definition = this.getDefinitionWithSpecificDataSets(this.dataSets, this.labelRange, sheetId);
+          return new PyramidChart(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: "pyramid",
+              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,
+              aggregated: this.aggregated,
+              axesDesign: this.axesDesign,
+              horizontal: true,
+              stacked: true,
+          };
+      }
+      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 PyramidChart(definition, this.sheetId, this.getters);
+      }
+  }
+  function createPyramidChartRuntime(chart, getters) {
+      const barDef = { ...chart.getDefinition(), type: "bar" };
+      const barChart = new BarChart(barDef, chart.sheetId, getters);
+      const barRuntime = createBarChartRuntime(barChart, getters);
+      const config = barRuntime.chartJsConfig;
+      let datasets = config.data?.datasets;
+      if (datasets && datasets[0]) {
+          datasets[0].data = datasets[0].data.map((value) => (value > 0 ? value : 0));
+      }
+      if (datasets && datasets[1]) {
+          datasets[1].data = datasets[1].data.map((value) => (value > 0 ? -value : 0));
+      }
+      const scales = config.options.scales;
+      const scalesXCallback = scales.x.ticks.callback;
+      scales.x.ticks.callback = (value) => scalesXCallback(Math.abs(value));
+      const tooltipLabelCallback = config.options.plugins.tooltip.callbacks.label;
+      config.options.plugins.tooltip.callbacks.label = (item) => {
+          const tooltipItem = { ...item, parsed: { y: item.parsed.y, x: Math.abs(item.parsed.x) } };
+          return tooltipLabelCallback(tooltipItem);
+      };
       return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
   }
 
@@ -24753,7 +24983,6 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: BarChart.validateChartDefinition,
       transformDefinition: BarChart.transformDefinition,
       getChartDefinitionFromContextCreation: BarChart.getDefinitionFromContextCreation,
-      name: _t("Bar"),
       sequence: 10,
   });
   chartRegistry.add("combo", {
@@ -24763,7 +24992,6 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: ComboChart.validateChartDefinition,
       transformDefinition: ComboChart.transformDefinition,
       getChartDefinitionFromContextCreation: ComboChart.getDefinitionFromContextCreation,
-      name: _t("Combo"),
       sequence: 15,
   });
   chartRegistry.add("line", {
@@ -24773,7 +25001,6 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: LineChart.validateChartDefinition,
       transformDefinition: LineChart.transformDefinition,
       getChartDefinitionFromContextCreation: LineChart.getDefinitionFromContextCreation,
-      name: _t("Line"),
       sequence: 20,
   });
   chartRegistry.add("pie", {
@@ -24783,7 +25010,6 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: PieChart.validateChartDefinition,
       transformDefinition: PieChart.transformDefinition,
       getChartDefinitionFromContextCreation: PieChart.getDefinitionFromContextCreation,
-      name: _t("Pie"),
       sequence: 30,
   });
   chartRegistry.add("scorecard", {
@@ -24793,7 +25019,6 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: ScorecardChart$1.validateChartDefinition,
       transformDefinition: ScorecardChart$1.transformDefinition,
       getChartDefinitionFromContextCreation: ScorecardChart$1.getDefinitionFromContextCreation,
-      name: _t("Scorecard"),
       sequence: 40,
   });
   chartRegistry.add("gauge", {
@@ -24803,7 +25028,6 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: GaugeChart.validateChartDefinition,
       transformDefinition: GaugeChart.transformDefinition,
       getChartDefinitionFromContextCreation: GaugeChart.getDefinitionFromContextCreation,
-      name: _t("Gauge"),
       sequence: 50,
   });
   chartRegistry.add("scatter", {
@@ -24813,7 +25037,6 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: ScatterChart.validateChartDefinition,
       transformDefinition: ScatterChart.transformDefinition,
       getChartDefinitionFromContextCreation: ScatterChart.getDefinitionFromContextCreation,
-      name: _t("Scatter"),
       sequence: 60,
   });
   chartRegistry.add("waterfall", {
@@ -24823,9 +25046,17 @@ stores.inject(MyMetaStore, storeInstance);
       validateChartDefinition: WaterfallChart.validateChartDefinition,
       transformDefinition: WaterfallChart.transformDefinition,
       getChartDefinitionFromContextCreation: WaterfallChart.getDefinitionFromContextCreation,
-      name: _t("Waterfall"),
       sequence: 70,
   });
+  chartRegistry.add("pyramid", {
+      match: (type) => type === "pyramid",
+      createChart: (definition, sheetId, getters) => new PyramidChart(definition, sheetId, getters),
+      getChartRuntime: createPyramidChartRuntime,
+      validateChartDefinition: PyramidChart.validateChartDefinition,
+      transformDefinition: PyramidChart.transformDefinition,
+      getChartDefinitionFromContextCreation: PyramidChart.getDefinitionFromContextCreation,
+      sequence: 80,
+  });
   const chartComponentRegistry = new Registry();
   chartComponentRegistry.add("line", ChartJsComponent);
   chartComponentRegistry.add("bar", ChartJsComponent);
@@ -24835,6 +25066,130 @@ stores.inject(MyMetaStore, storeInstance);
   chartComponentRegistry.add("scatter", ChartJsComponent);
   chartComponentRegistry.add("scorecard", ScorecardChart);
   chartComponentRegistry.add("waterfall", ChartJsComponent);
+  chartComponentRegistry.add("pyramid", ChartJsComponent);
+  const chartCategories = {
+      line: _t("Line"),
+      column: _t("Column"),
+      bar: _t("Bar"),
+      pie: _t("Pie"),
+      misc: _t("Miscellaneous"),
+  };
+  const chartSubtypeRegistry = new Registry();
+  chartSubtypeRegistry
+      .add("line", {
+      matcher: (definition) => definition.type === "line" && !definition.stacked,
+      displayName: _t("Line"),
+      chartType: "line",
+      chartSubtype: "line",
+      subtypeDefinition: { stacked: false },
+      category: "line",
+      preview: "o-spreadsheet-ChartPreview.LINE_CHART",
+  })
+      .add("stacked_line", {
+      matcher: (definition) => definition.type === "line" && definition.stacked,
+      displayName: _t("Stacked Line"),
+      chartType: "line",
+      chartSubtype: "stacked_line",
+      subtypeDefinition: { stacked: true },
+      category: "line",
+      preview: "o-spreadsheet-ChartPreview.STACKED_AREA_CHART",
+  })
+      .add("scatter", {
+      displayName: _t("Scatter"),
+      chartType: "scatter",
+      chartSubtype: "scatter",
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.SCATTER_CHART",
+  })
+      .add("column", {
+      matcher: (definition) => definition.type === "bar" && !definition.stacked && !definition.horizontal,
+      displayName: _t("Column"),
+      chartType: "bar",
+      chartSubtype: "column",
+      subtypeDefinition: { stacked: false, horizontal: false },
+      category: "column",
+      preview: "o-spreadsheet-ChartPreview.COLUMN_CHART",
+  })
+      .add("stacked_column", {
+      matcher: (definition) => definition.type === "bar" && definition.stacked && !definition.horizontal,
+      displayName: _t("Stacked Column"),
+      chartType: "bar",
+      chartSubtype: "stacked_column",
+      subtypeDefinition: { stacked: true, horizontal: false },
+      category: "column",
+      preview: "o-spreadsheet-ChartPreview.STACKED_COLUMN_CHART",
+  })
+      .add("bar", {
+      matcher: (definition) => definition.type === "bar" && !definition.stacked && !!definition.horizontal,
+      displayName: _t("Bar"),
+      chartType: "bar",
+      chartSubtype: "bar",
+      subtypeDefinition: { horizontal: true, stacked: false },
+      category: "bar",
+      preview: "o-spreadsheet-ChartPreview.BAR_CHART",
+  })
+      .add("stacked_bar", {
+      matcher: (definition) => definition.type === "bar" && definition.stacked && !!definition.horizontal,
+      displayName: _t("Stacked Bar"),
+      chartType: "bar",
+      chartSubtype: "stacked_bar",
+      subtypeDefinition: { horizontal: true, stacked: true },
+      category: "bar",
+      preview: "o-spreadsheet-ChartPreview.STACKED_BAR_CHART",
+  })
+      .add("combo", {
+      displayName: _t("Combo"),
+      chartSubtype: "combo",
+      chartType: "combo",
+      category: "line",
+      preview: "o-spreadsheet-ChartPreview.COMBO_CHART",
+  })
+      .add("pie", {
+      matcher: (definition) => definition.type === "pie" && !definition.isDoughnut,
+      displayName: _t("Pie"),
+      chartSubtype: "pie",
+      chartType: "pie",
+      subtypeDefinition: { isDoughnut: false },
+      category: "pie",
+      preview: "o-spreadsheet-ChartPreview.PIE_CHART",
+  })
+      .add("doughnut", {
+      matcher: (definition) => definition.type === "pie" && !!definition.isDoughnut,
+      displayName: _t("Doughnut"),
+      chartSubtype: "doughnut",
+      chartType: "pie",
+      subtypeDefinition: { isDoughnut: true },
+      category: "pie",
+      preview: "o-spreadsheet-ChartPreview.DOUGHNUT_CHART",
+  })
+      .add("gauge", {
+      displayName: _t("Gauge"),
+      chartSubtype: "gauge",
+      chartType: "gauge",
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.GAUGE_CHART",
+  })
+      .add("scorecard", {
+      displayName: _t("Scorecard"),
+      chartSubtype: "scorecard",
+      chartType: "scorecard",
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.SCORECARD_CHART",
+  })
+      .add("waterfall", {
+      displayName: _t("Waterfall"),
+      chartSubtype: "waterfall",
+      chartType: "waterfall",
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.WATERFALL_CHART",
+  })
+      .add("pyramid", {
+      displayName: _t("Population Pyramid"),
+      chartSubtype: "pyramid",
+      chartType: "pyramid",
+      category: "misc",
+      preview: "o-spreadsheet-ChartPreview.POPULATION_PYRAMID_CHART",
+  });
 
   /**
    * Registry intended to support usual currencies. It is mainly used to create
@@ -26691,20 +27046,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
       return transformation.transformDefinition(definition, executed);
   }
-  /**
-   * Get an empty definition based on the given context and the given type
-   */
-  function getChartDefinitionFromContextCreation(context, type) {
-      const chartClass = chartRegistry.get(type);
-      return chartClass.getChartDefinitionFromContextCreation(context);
-  }
-  function getChartTypes() {
-      const result = {};
-      for (const key of chartRegistry.getKeys()) {
-          result[key] = chartRegistry.get(key).name;
-      }
-      return result;
-  }
   /**
    * Return a "smart" chart definition in the given zone. The definition is "smart" because it will
    * use the best type of chart to display the data of the zone.
@@ -28164,6 +28505,40 @@ stores.inject(MyMetaStore, storeInstance);
       },
       icon: "o-spreadsheet-Icon.PIVOT",
   };
+  const FIX_FORMULAS = {
+      name: _t("Convert to individual formulas"),
+      execute(env) {
+          const position = env.model.getters.getActivePosition();
+          const cell = env.model.getters.getCorrespondingFormulaCell(position);
+          const pivotId = env.model.getters.getPivotIdFromPosition(position);
+          if (!cell || !pivotId) {
+              return;
+          }
+          const { sheetId, col, row } = env.model.getters.getCellPosition(cell.id);
+          const pivot = env.model.getters.getPivot(pivotId);
+          pivot.init();
+          if (!pivot.isValid()) {
+              return;
+          }
+          env.model.dispatch("INSERT_PIVOT", {
+              sheetId,
+              col,
+              row,
+              pivotId,
+              table: pivot.getTableStructure().export(),
+          });
+      },
+      isVisible: (env) => {
+          const position = env.model.getters.getActivePosition();
+          const pivotId = env.model.getters.getPivotIdFromPosition(position);
+          if (!pivotId) {
+              return false;
+          }
+          const pivot = env.model.getters.getPivot(pivotId);
+          return pivot.isValid() && env.model.getters.isSpillPivotFormula(position);
+      },
+      icon: "o-spreadsheet-Icon.PIVOT",
+  };
 
   //------------------------------------------------------------------------------
   // Context Menu Registry
@@ -28262,6 +28637,10 @@ stores.inject(MyMetaStore, storeInstance);
       name: INSERT_LINK_NAME,
       sequence: 150,
       separator: true,
+  })
+      .add("pivot_fix_formulas", {
+      ...FIX_FORMULAS,
+      sequence: 155,
   })
       .add("pivot_properties", {
       ...pivotProperties,
@@ -30484,6 +30863,7 @@ stores.inject(MyMetaStore, storeInstance);
       });
       dataSeriesRanges = [];
       labelRange;
+      chartTerms = ChartTerms;
       setup() {
           this.dataSeriesRanges = this.props.definition.dataSets;
           this.labelRange = this.props.definition.labelRange;
@@ -30508,7 +30888,7 @@ stores.inject(MyMetaStore, storeInstance);
           return [
               {
                   name: "aggregated",
-                  label: _t("Aggregate"),
+                  label: this.chartTerms.AggregatedChart,
                   value: this.props.definition.aggregated ?? false,
                   onChange: this.onUpdateAggregated.bind(this),
               },
@@ -30584,9 +30964,6 @@ stores.inject(MyMetaStore, storeInstance);
 
   class BarConfigPanel extends GenericChartConfigPanel {
       static template = "o-spreadsheet-BarConfigPanel";
-      get stackedLabel() {
-          return _t("Stacked barchart");
-      }
       onUpdateStacked(stacked) {
           this.props.updateChart(this.props.figureId, {
               stacked,
@@ -31576,6 +31953,9 @@ stores.inject(MyMetaStore, storeInstance);
               return "left";
           return dataSets[this.state.index].yAxisId === "y1" ? "right" : "left";
       }
+      get canHaveTwoVerticalAxis() {
+          return "horizontal" in this.props.definition ? !this.props.definition.horizontal : true;
+      }
       updateDataSeriesLabel(ev) {
           const label = ev.target.value;
           const dataSets = this.props.definition.dataSets;
@@ -31740,19 +32120,13 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return false;
       }
-      get stackedLabel() {
-          return _t("Stacked linechart");
-      }
-      get cumulativeLabel() {
-          return _t("Cumulative data");
-      }
       getLabelRangeOptions() {
           const options = super.getLabelRangeOptions();
           if (this.canTreatLabelsAsText) {
               options.push({
                   name: "labelsAsText",
                   value: this.props.definition.labelsAsText,
-                  label: _t("Treat labels as text"),
+                  label: this.chartTerms.TreatLabelsAsText,
                   onChange: this.onUpdateLabelsAsText.bind(this),
               });
           }
@@ -31819,7 +32193,7 @@ stores.inject(MyMetaStore, storeInstance);
               options.push({
                   name: "labelsAsText",
                   value: this.props.definition.labelsAsText,
-                  label: _t("Treat labels as text"),
+                  label: this.chartTerms.TreatLabelsAsText,
                   onChange: this.onUpdateLabelsAsText.bind(this),
               });
           }
@@ -32026,8 +32400,106 @@ stores.inject(MyMetaStore, storeInstance);
       .add("waterfall", {
       configuration: GenericChartConfigPanel,
       design: WaterfallChartDesignPanel,
+  })
+      .add("pyramid", {
+      configuration: GenericChartConfigPanel,
+      design: ChartWithAxisDesignPanel,
   });
 
+  css /* scss */ `
+  .o-section .o-type-selector {
+    height: 30px;
+    padding-left: 30px;
+  }
+  .o-type-selector-preview {
+    left: 5px;
+    top: 3px;
+    .o-chart-preview {
+      width: 24px;
+      height: 24px;
+    }
+  }
+
+  .o-popover .o-chart-select-popover {
+    box-sizing: border-box;
+    background: #fff;
+    .o-chart-type-item {
+      cursor: pointer;
+      padding: 3px 6px;
+      margin: 1px 2px;
+      &.selected,
+      &:hover {
+        background: #f5f5f5;
+        border: 1px solid #ccc;
+        padding: 2px 5px;
+      }
+      .o-chart-preview {
+        width: 48px;
+        height: 48px;
+      }
+    }
+  }
+`;
+  class ChartTypePicker extends owl.Component {
+      static template = "o-spreadsheet-ChartTypePicker";
+      static components = { Section, Popover };
+      static props = { figureId: String, chartPanelStore: Object };
+      categories = chartCategories;
+      chartTypeByCategories = {};
+      popoverRef = owl.useRef("popoverRef");
+      selectRef = owl.useRef("selectRef");
+      state = owl.useState({ popoverProps: undefined, popoverStyle: "" });
+      setup() {
+          owl.useExternalListener(window, "pointerdown", this.onExternalClick, { capture: true });
+          for (const subtypeProperties of chartSubtypeRegistry.getAll()) {
+              if (this.chartTypeByCategories[subtypeProperties.category]) {
+                  this.chartTypeByCategories[subtypeProperties.category].push(subtypeProperties);
+              }
+              else {
+                  this.chartTypeByCategories[subtypeProperties.category] = [subtypeProperties];
+              }
+          }
+      }
+      onExternalClick(ev) {
+          if (isChildEvent(this.popoverRef.el?.parentElement, ev) ||
+              isChildEvent(this.selectRef.el, ev)) {
+              return;
+          }
+          this.closePopover();
+      }
+      onTypeChange(type) {
+          this.props.chartPanelStore.changeChartType(this.props.figureId, type);
+          this.closePopover();
+      }
+      getChartDefinition(figureId) {
+          return this.env.model.getters.getChartDefinition(figureId);
+      }
+      getSelectedChartSubtypeProperties() {
+          const definition = this.getChartDefinition(this.props.figureId);
+          const matchedChart = chartSubtypeRegistry
+              .getAll()
+              .find((c) => c.matcher?.(definition) || false);
+          return matchedChart || chartSubtypeRegistry.get(definition.type);
+      }
+      onPointerDown(ev) {
+          if (this.state.popoverProps) {
+              this.closePopover();
+              return;
+          }
+          const target = ev.currentTarget;
+          const { bottom, right, width } = target.getBoundingClientRect();
+          this.state.popoverProps = {
+              anchorRect: { x: right, y: bottom, width: 0, height: 0 },
+              positioning: "TopRight",
+              verticalOffset: 0,
+          };
+          this.state.popoverStyle = cssPropertiesToCss({ width: `${width}px` });
+      }
+      closePopover() {
+          this.state.popoverProps = undefined;
+      }
+  }
+
   class MainChartPanelStore extends SpreadsheetStore {
       mutators = ["activatePanel", "changeChartType"];
       panel = "configuration";
@@ -32035,7 +32507,7 @@ stores.inject(MyMetaStore, storeInstance);
       activatePanel(panel) {
           this.panel = panel;
       }
-      changeChartType(figureId, type) {
+      changeChartType(figureId, newDisplayType) {
           this.creationContext = {
               ...this.creationContext,
               ...this.getters.getContextCreationChart(figureId),
@@ -32044,13 +32516,25 @@ stores.inject(MyMetaStore, storeInstance);
           if (!sheetId) {
               return;
           }
-          const definition = getChartDefinitionFromContextCreation(this.creationContext, type);
+          const definition = this.getChartDefinitionFromContextCreation(figureId, newDisplayType);
           this.model.dispatch("UPDATE_CHART", {
               definition,
               id: figureId,
               sheetId,
           });
       }
+      getChartDefinitionFromContextCreation(figureId, newDisplayType) {
+          const newChartInfo = chartSubtypeRegistry.get(newDisplayType);
+          const ChartClass = chartRegistry.get(newChartInfo.chartType);
+          const contextCreation = {
+              ...this.creationContext,
+              ...this.getters.getContextCreationChart(figureId),
+          };
+          return {
+              ...ChartClass.getChartDefinitionFromContextCreation(contextCreation),
+              ...newChartInfo.subtypeDefinition,
+          };
+      }
   }
 
   css /* scss */ `
@@ -32079,7 +32563,7 @@ stores.inject(MyMetaStore, storeInstance);
 `;
   class ChartPanel extends owl.Component {
       static template = "o-spreadsheet-ChartPanel";
-      static components = { Section };
+      static components = { Section, ChartTypePicker };
       static props = { onCloseSidePanel: Function, figureId: String };
       store;
       get figureId() {
@@ -32139,9 +32623,6 @@ stores.inject(MyMetaStore, storeInstance);
       getChartDefinition(figureId) {
           return this.env.model.getters.getChartDefinition(figureId);
       }
-      get chartTypes() {
-          return getChartTypes();
-      }
   }
 
   css /* scss */ `
@@ -35215,9 +35696,17 @@ stores.inject(MyMetaStore, storeInstance);
       }
       getPivotCell(col, row, includeTotal = true) {
           const colHeadersHeight = this.columns.length;
-          if (row <= colHeadersHeight - 1) {
+          if (col > 0 && row === colHeadersHeight - 1) {
               const domain = this.getColHeaderDomain(col, row);
-              return domain ? { type: "HEADER", domain } : { type: "EMPTY" };
+              if (!domain) {
+                  return EMPTY_PIVOT_CELL;
+              }
+              const measure = domain.at(-1)?.value.toString() || "";
+              return { type: "MEASURE_HEADER", domain: domain.slice(0, -1), measure };
+          }
+          else if (row <= colHeadersHeight - 1) {
+              const domain = this.getColHeaderDomain(col, row);
+              return domain ? { type: "HEADER", domain } : EMPTY_PIVOT_CELL;
           }
           else if (col === 0) {
               const rowIndex = row - colHeadersHeight;
@@ -35227,7 +35716,7 @@ stores.inject(MyMetaStore, storeInstance);
           else {
               const rowIndex = row - colHeadersHeight;
               if (!includeTotal && this.isTotalRow(rowIndex)) {
-                  return { type: "EMPTY" };
+                  return EMPTY_PIVOT_CELL;
               }
               const domain = [...this.getRowDomain(rowIndex), ...this.getColDomain(col)];
               const measure = this.getColMeasure(col);
@@ -35281,6 +35770,7 @@ stores.inject(MyMetaStore, storeInstance);
           };
       }
   }
+  const EMPTY_PIVOT_CELL = { type: "EMPTY" };
 
   /**
    * This function converts a list of data entry into a spreadsheet pivot table.
@@ -35478,6 +35968,9 @@ stores.inject(MyMetaStore, storeInstance);
       if (!(granularity in MAP_VALUE_DIMENSION_DATE)) {
           throw new Error(`Unknown date granularity: ${granularity}`);
       }
+      if (value === null) {
+          return null;
+      }
       if (!MAP_VALUE_DIMENSION_DATE[granularity].set.has(value)) {
           MAP_VALUE_DIMENSION_DATE[granularity].set.add(value);
           const date = toJsDate(value, locale);
@@ -35708,14 +36201,17 @@ stores.inject(MyMetaStore, storeInstance);
           if (dimension.type === "date") {
               const adapter = pivotTimeAdapter(dimension.granularity);
               return {
-                  value: adapter.toCellValue(toNormalizedPivotValue(dimension, lastNode.value)),
+                  value: lastNode.value !== "null"
+                      ? adapter.toCellValue(toNormalizedPivotValue(dimension, lastNode.value))
+                      : _t("(Undefined)"),
                   format: adapter.getFormat(this.getters.getLocale()),
               };
           }
           if (!finalCell) {
               return { value: "" };
           }
-          if (finalCell.value === null) {
+          // Value can be null but stringified (e.g. an empty date, as for now every date is stringified)
+          if (finalCell.value === null || finalCell.value === `${null}`) {
               return { value: _t("(Undefined)") };
           }
           return {
@@ -35737,10 +36233,15 @@ stores.inject(MyMetaStore, storeInstance);
           if (!operator) {
               throw new Error(`Aggregator ${aggregator} does not exist`);
           }
-          return {
-              value: values.length ? operator.fn([values], this.getters.getLocale()) : "",
-              format: operator.format(values[0]),
-          };
+          try {
+              return {
+                  value: values.length ? operator.fn([values], this.getters.getLocale()) : "",
+                  format: operator.format(values[0]),
+              };
+          }
+          catch (e) {
+              return handleError(e, aggregator.toUpperCase());
+          }
       }
       getPossibleFieldValues(dimension) {
           const values = [];
@@ -51107,12 +51608,12 @@ stores.inject(MyMetaStore, storeInstance);
           for (let col = 0; col < pivotCells.length; col++) {
               for (let row = 0; row < pivotCells[col].length; row++) {
                   const pivotCell = pivotCells[col][row];
-                  const cellPosition = {
+                  this.dispatch("UPDATE_CELL", {
                       sheetId: position.sheetId,
                       col: position.col + col,
                       row: position.row + row,
-                  };
-                  this.addPivotFormula(cellPosition, formulaId, pivotCell);
+                      content: makePivotFormulaFromPivotCell(formulaId, pivotCell),
+                  });
               }
           }
       }
@@ -51142,21 +51643,6 @@ stores.inject(MyMetaStore, storeInstance);
               });
           }
       }
-      addPivotFormula(position, formulaId, pivotCell) {
-          let content = undefined;
-          switch (pivotCell.type) {
-              case "HEADER":
-                  content = makePivotFormula("PIVOT.HEADER", [formulaId, ...flatPivotDomain(pivotCell.domain)].filter(isDefined));
-                  break;
-              case "VALUE":
-                  content = makePivotFormula("PIVOT.VALUE", [formulaId, pivotCell.measure, ...flatPivotDomain(pivotCell.domain)].filter(isDefined));
-                  break;
-          }
-          this.dispatch("UPDATE_CELL", {
-              ...position,
-              content,
-          });
-      }
       getPivotCore(pivotId) {
           const pivot = this.pivots[pivotId];
           if (!pivot) {
@@ -52821,7 +53307,6 @@ stores.inject(MyMetaStore, storeInstance);
           if (!this.blockedArrayFormulas.has(position)) {
               this.invalidateSpreading(position);
           }
-          this.spreadingRelations.removeNode(position);
           const cell = this.getters.getCell(position);
           if (cell === undefined) {
               return EMPTY_CELL;
@@ -52863,6 +53348,7 @@ stores.inject(MyMetaStore, storeInstance);
           this.assertSheetHasEnoughSpaceToSpreadFormulaResult(formulaPosition, formulaReturn);
           const nbColumns = formulaReturn.length;
           const nbRows = formulaReturn[0].length;
+          this.spreadingRelations.removeNode(formulaPosition);
           forEachSpreadPositionInMatrix(nbColumns, nbRows, this.updateSpreadRelation(formulaPosition));
           this.assertNoMergedCellsInSpreadZone(formulaPosition, formulaReturn);
           forEachSpreadPositionInMatrix(nbColumns, nbRows, this.checkCollision(formulaPosition));
@@ -54390,9 +54876,10 @@ stores.inject(MyMetaStore, storeInstance);
           "getPivot",
           "getFirstPivotFunction",
           "getPivotIdFromPosition",
-          "getPivotDomainArgsFromPosition",
+          "getPivotCellFromPosition",
           "isPivotUnused",
           "areDomainArgsFieldsValid",
+          "isSpillPivotFormula",
       ];
       pivots = {};
       unusedPivots;
@@ -54471,6 +54958,14 @@ stores.inject(MyMetaStore, storeInstance);
           }
           return undefined;
       }
+      isSpillPivotFormula(position) {
+          const cell = this.getters.getCorrespondingFormulaCell(position);
+          if (cell && cell.isFormula) {
+              const pivotFunction = this.getFirstPivotFunction(cell.compiledFormula.tokens);
+              return pivotFunction?.functionName === "PIVOT";
+          }
+          return false;
+      }
       getFirstPivotFunction(tokens) {
           const pivotFunction = getFirstPivotFunction(tokens);
           if (!pivotFunction) {
@@ -54504,29 +54999,29 @@ stores.inject(MyMetaStore, storeInstance);
        * If the cell is the result of PIVOT, the result is the domain of the cell
        * as if it was the individual pivot formula
        */
-      getPivotDomainArgsFromPosition(position) {
+      getPivotCellFromPosition(position) {
           const cell = this.getters.getCorrespondingFormulaCell(position);
           if (!cell || !cell.isFormula || getNumberOfPivotFunctions(cell.compiledFormula.tokens) === 0) {
-              return undefined;
+              return EMPTY_PIVOT_CELL;
           }
           const mainPosition = this.getters.getCellPosition(cell.id);
           const result = this.getters.getFirstPivotFunction(cell.compiledFormula.tokens);
           if (!result) {
-              return undefined;
+              return EMPTY_PIVOT_CELL;
           }
           const { functionName, args } = result;
           if (functionName === "PIVOT") {
               const formulaId = args[0];
               if (!formulaId) {
-                  return undefined;
+                  return EMPTY_PIVOT_CELL;
               }
               const pivotId = this.getters.getPivotId(formulaId.toString());
               if (!pivotId) {
-                  return undefined;
+                  return EMPTY_PIVOT_CELL;
               }
               const pivot = this.getPivot(pivotId);
               if (!pivot.isValid()) {
-                  return undefined;
+                  return EMPTY_PIVOT_CELL;
               }
               const includeTotal = args[2] === false ? false : undefined;
               const includeColumnHeaders = args[3] === false ? false : undefined;
@@ -54535,22 +55030,28 @@ stores.inject(MyMetaStore, storeInstance);
                   .getPivotCells(includeTotal, includeColumnHeaders);
               const pivotCol = position.col - mainPosition.col;
               const pivotRow = position.row - mainPosition.row;
-              const pivotCell = pivotCells[pivotCol][pivotRow];
-              if (pivotCell.type === "EMPTY") {
-                  return undefined;
-              }
-              let domain = pivotCell.domain;
-              if (domain.at(-1)?.field === "measure") {
-                  domain = domain.slice(0, -1);
-              }
-              return { domainArgs: domain, isHeader: pivotCell.type === "HEADER" };
+              return pivotCells[pivotCol][pivotRow];
           }
-          let domain = toPivotDomain(args.slice(functionName === "PIVOT.VALUE" ? 2 : 1).map((x) => `${x}`));
-          if (domain.at(-1)?.field === "measure") {
-              domain = domain.slice(0, -1);
+          if (functionName === "PIVOT.HEADER" && args.at(-2) === "measure") {
+              const domain = toPivotDomain(args.slice(1, -2).map((x) => `${x}`));
+              return {
+                  type: "MEASURE_HEADER",
+                  domain,
+                  measure: args.at(-1)?.toString() || "",
+              };
+          }
+          else if (functionName === "PIVOT.HEADER") {
+              return {
+                  type: "HEADER",
+                  domain: toPivotDomain(args.slice(1).map((x) => `${x}`)),
+              };
           }
-          const isHeader = functionName === "PIVOT.HEADER";
-          return { domainArgs: domain, isHeader };
+          const [measure, ...domainArgs] = args.slice(1);
+          return {
+              type: "VALUE",
+              domain: toPivotDomain(domainArgs.map((x) => `${x}`)),
+              measure: measure?.toString() || "",
+          };
       }
       getPivot(pivotId) {
           return this.pivots[pivotId];
@@ -63833,6 +64334,9 @@ stores.inject(MyMetaStore, storeInstance);
       getBackToDefault() {
           this.stream.getBackToDefault();
       }
+      getAnchor() {
+          return this.anchor;
+      }
       modifyAnchor(anchor, mode, options) {
           const sheetId = this.getters.getActiveSheetId();
           anchor = {
@@ -66796,6 +67300,7 @@ stores.inject(MyMetaStore, storeInstance);
       chartSidePanelComponentRegistry,
       chartComponentRegistry,
       chartRegistry,
+      chartSubtypeRegistry,
       topbarMenuRegistry,
       topbarComponentRegistry,
       clickableCellRegistry,
@@ -66904,6 +67409,7 @@ stores.inject(MyMetaStore, storeInstance);
       GaugeChartDesignPanel,
       ScorecardChartConfigPanel,
       ScorecardChartDesignPanel,
+      ChartTypePicker,
       FigureComponent,
       Menu,
       Popover,
@@ -66953,6 +67459,7 @@ stores.inject(MyMetaStore, storeInstance);
       DEFAULT_LOCALE,
       HIGHLIGHT_COLOR,
       PIVOT_TABLE_CONFIG,
+      ChartTerms,
   };
 
   exports.AbstractCellClipboardHandler = AbstractCellClipboardHandler;
@@ -67001,9 +67508,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = tokenize;
 
 
-  __info__.version = "17.4.0-alpha.5";
-  __info__.date = "2024-06-14T10:01:40.605Z";
-  __info__.hash = "9ceed96";
+  __info__.version = "17.4.0-alpha.6";
+  __info__.date = "2024-06-19T13:46:27.157Z";
+  __info__.hash = "a4f22e4";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);