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

package/dist/o-spreadsheet.cjs.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
  */
 
 'use strict';
@@ -6202,7 +6202,7 @@ class CellClipboardHandler extends AbstractCellClipboardHandler {
         };
     }
     isPasteAllowed(sheetId, target, content, clipboardOptions) {
-        if (!("cells" in content)) {
+        if (!content.cells) {
             return "Success" /* CommandResult.Success */;
         }
         if (clipboardOptions?.isCutOperation && clipboardOptions?.pasteOption !== undefined) {
@@ -6216,6 +6216,17 @@ class CellClipboardHandler extends AbstractCellClipboardHandler {
                 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 */;
     }
     /**
@@ -6455,13 +6466,22 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
         }
         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) {
@@ -6470,7 +6490,7 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
         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);
@@ -6478,12 +6498,12 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
     }
     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);
@@ -6491,23 +6511,21 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
         }
     }
     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], []);
                 }
             }
         }
@@ -6550,13 +6568,20 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
         }
         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) {
@@ -6568,7 +6593,7 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
         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);
@@ -6576,12 +6601,12 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
     }
     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);
@@ -6589,41 +6614,43 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
         }
     }
     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.
@@ -6715,69 +6742,63 @@ class ImageClipboardHandler extends AbstractFigureClipboardHandler {
 }
 
 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,
+                },
+            ],
+        });
     }
 }
 
@@ -7757,6 +7778,486 @@ function errorCell(value, message) {
     };
 }
 
+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
  *
@@ -7955,6 +8456,11 @@ const CellIsOperators = {
 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)
@@ -8887,6 +9393,7 @@ function drawHighlight(renderingContext, highlight, rect) {
     }
     const color = highlight.color || HIGHLIGHT_COLOR;
     const { ctx } = renderingContext;
+    ctx.save();
     if (!highlight.noBorder) {
         if (highlight.dashed) {
             ctx.setLineDash([5, 3]);
@@ -8906,6 +9413,7 @@ function drawHighlight(renderingContext, highlight, rect) {
         ctx.fillStyle = setColorAlpha(toHex(color), highlight.fillAlpha ?? 0.12);
         ctx.fillRect(x, y, width, height);
     }
+    ctx.restore();
 }
 
 class HighlightStore extends SpreadsheetStore {
@@ -9436,8 +9944,20 @@ class ComposerStore extends SpreadsheetStore {
     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.
@@ -9457,10 +9977,8 @@ class ComposerStore extends SpreadsheetStore {
             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;
@@ -9472,6 +9990,17 @@ class ComposerStore extends SpreadsheetStore {
     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);
     }
@@ -9574,19 +10103,35 @@ class ComposerStore extends SpreadsheetStore {
             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
@@ -9845,8 +10390,14 @@ class ChartJsComponent extends owl.Component {
         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));
             }
         });
     }
@@ -10214,6 +10765,9 @@ function getChartAxisTitleRuntime(design) {
 }
 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;
@@ -11781,13 +12335,6 @@ var misc = /*#__PURE__*/Object.freeze({
   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;
@@ -12901,53 +13448,6 @@ var math = /*#__PURE__*/Object.freeze({
   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 = [];
@@ -13503,7 +14003,7 @@ const LARGE = {
 // 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.")),
@@ -13519,7 +14019,7 @@ const LINEST = {
 // 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.")),
@@ -17922,33 +18422,6 @@ var info = /*#__PURE__*/Object.freeze({
   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
 // -----------------------------------------------------------------------------
@@ -18146,393 +18619,6 @@ var logical = /*#__PURE__*/Object.freeze({
   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.
  */
@@ -19109,14 +19195,10 @@ const PIVOT = {
                         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));
@@ -20155,6 +20237,8 @@ const MODIFIER_KEYS = ["Shift", "Control", "Alt", "Meta"];
  * a child element.
  */
 function isChildEvent(parent, ev) {
+    if (!parent)
+        return false;
     return !!ev.target && parent.contains(ev.target);
 }
 function gridOverlayPosition() {
@@ -22694,7 +22778,8 @@ function truncateLabel(label) {
 /**
  * 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
@@ -22738,8 +22823,11 @@ function getDefaultChartJsRuntime(chart, labels, fontColor, { format, locale, tr
                 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;
@@ -22913,6 +23001,7 @@ class BarChart extends AbstractChart {
     dataSetsHaveTitle;
     dataSetDesign;
     axesDesign;
+    horizontal;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -22924,6 +23013,7 @@ class BarChart extends AbstractChart {
         this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
         this.dataSetDesign = definition.dataSets;
         this.axesDesign = definition.axesDesign;
+        this.horizontal = definition.horizontal;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -22995,6 +23085,7 @@ class BarChart extends AbstractChart {
             stacked: this.stacked,
             aggregated: this.aggregated,
             axesDesign: this.axesDesign,
+            horizontal: this.horizontal,
         };
     }
     getDefinitionForExcel() {
@@ -23026,7 +23117,10 @@ class BarChart extends AbstractChart {
 }
 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 },
     };
@@ -23040,16 +23134,10 @@ function getBarConfiguration(chart, labels, localeFormat) {
     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,
@@ -23065,7 +23153,10 @@ function getBarConfiguration(chart, labels, localeFormat) {
             },
         },
     };
+    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,
@@ -23132,7 +23223,7 @@ function createBarChartRuntime(chart, getters) {
             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;
         }
     }
@@ -24123,6 +24214,7 @@ class PieChart extends AbstractChart {
     type = "pie";
     aggregated;
     dataSetsHaveTitle;
+    isDoughnut;
     constructor(definition, sheetId, getters) {
         super(definition, sheetId, getters);
         this.dataSets = createDataSets(getters, definition.dataSets, sheetId, definition.dataSetsHaveTitle);
@@ -24131,6 +24223,7 @@ class PieChart extends AbstractChart {
         this.legendPosition = definition.legendPosition;
         this.aggregated = definition.aggregated;
         this.dataSetsHaveTitle = definition.dataSetsHaveTitle;
+        this.isDoughnut = definition.isDoughnut;
     }
     static transformDefinition(definition, executed) {
         return transformChartDefinitionWithDataSetsWithZone(definition, executed);
@@ -24148,6 +24241,7 @@ class PieChart extends AbstractChart {
             type: "pie",
             labelRange: context.auxiliaryRange || undefined,
             aggregated: context.aggregated ?? false,
+            isDoughnut: false,
         };
     }
     getDefinition() {
@@ -24178,6 +24272,7 @@ class PieChart extends AbstractChart {
                 : undefined,
             title: this.title,
             aggregated: this.aggregated,
+            isDoughnut: this.isDoughnut,
         };
     }
     copyForSheetId(sheetId) {
@@ -24312,6 +24407,141 @@ function createPieChartRuntime(chart, getters) {
         };
         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 };
 }
 
@@ -24754,7 +24984,6 @@ chartRegistry.add("bar", {
     validateChartDefinition: BarChart.validateChartDefinition,
     transformDefinition: BarChart.transformDefinition,
     getChartDefinitionFromContextCreation: BarChart.getDefinitionFromContextCreation,
-    name: _t("Bar"),
     sequence: 10,
 });
 chartRegistry.add("combo", {
@@ -24764,7 +24993,6 @@ chartRegistry.add("combo", {
     validateChartDefinition: ComboChart.validateChartDefinition,
     transformDefinition: ComboChart.transformDefinition,
     getChartDefinitionFromContextCreation: ComboChart.getDefinitionFromContextCreation,
-    name: _t("Combo"),
     sequence: 15,
 });
 chartRegistry.add("line", {
@@ -24774,7 +25002,6 @@ chartRegistry.add("line", {
     validateChartDefinition: LineChart.validateChartDefinition,
     transformDefinition: LineChart.transformDefinition,
     getChartDefinitionFromContextCreation: LineChart.getDefinitionFromContextCreation,
-    name: _t("Line"),
     sequence: 20,
 });
 chartRegistry.add("pie", {
@@ -24784,7 +25011,6 @@ chartRegistry.add("pie", {
     validateChartDefinition: PieChart.validateChartDefinition,
     transformDefinition: PieChart.transformDefinition,
     getChartDefinitionFromContextCreation: PieChart.getDefinitionFromContextCreation,
-    name: _t("Pie"),
     sequence: 30,
 });
 chartRegistry.add("scorecard", {
@@ -24794,7 +25020,6 @@ chartRegistry.add("scorecard", {
     validateChartDefinition: ScorecardChart$1.validateChartDefinition,
     transformDefinition: ScorecardChart$1.transformDefinition,
     getChartDefinitionFromContextCreation: ScorecardChart$1.getDefinitionFromContextCreation,
-    name: _t("Scorecard"),
     sequence: 40,
 });
 chartRegistry.add("gauge", {
@@ -24804,7 +25029,6 @@ chartRegistry.add("gauge", {
     validateChartDefinition: GaugeChart.validateChartDefinition,
     transformDefinition: GaugeChart.transformDefinition,
     getChartDefinitionFromContextCreation: GaugeChart.getDefinitionFromContextCreation,
-    name: _t("Gauge"),
     sequence: 50,
 });
 chartRegistry.add("scatter", {
@@ -24814,7 +25038,6 @@ chartRegistry.add("scatter", {
     validateChartDefinition: ScatterChart.validateChartDefinition,
     transformDefinition: ScatterChart.transformDefinition,
     getChartDefinitionFromContextCreation: ScatterChart.getDefinitionFromContextCreation,
-    name: _t("Scatter"),
     sequence: 60,
 });
 chartRegistry.add("waterfall", {
@@ -24824,9 +25047,17 @@ chartRegistry.add("waterfall", {
     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);
@@ -24836,6 +25067,130 @@ chartComponentRegistry.add("gauge", GaugeChartComponent);
 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
@@ -26692,20 +27047,6 @@ function transformDefinition(definition, executed) {
     }
     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.
@@ -28165,6 +28506,40 @@ const pivotProperties = {
     },
     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
@@ -28263,6 +28638,10 @@ cellMenuRegistry
     name: INSERT_LINK_NAME,
     sequence: 150,
     separator: true,
+})
+    .add("pivot_fix_formulas", {
+    ...FIX_FORMULAS,
+    sequence: 155,
 })
     .add("pivot_properties", {
     ...pivotProperties,
@@ -30485,6 +30864,7 @@ class GenericChartConfigPanel extends owl.Component {
     });
     dataSeriesRanges = [];
     labelRange;
+    chartTerms = ChartTerms;
     setup() {
         this.dataSeriesRanges = this.props.definition.dataSets;
         this.labelRange = this.props.definition.labelRange;
@@ -30509,7 +30889,7 @@ class GenericChartConfigPanel extends owl.Component {
         return [
             {
                 name: "aggregated",
-                label: _t("Aggregate"),
+                label: this.chartTerms.AggregatedChart,
                 value: this.props.definition.aggregated ?? false,
                 onChange: this.onUpdateAggregated.bind(this),
             },
@@ -30585,9 +30965,6 @@ class GenericChartConfigPanel extends owl.Component {
 
 class BarConfigPanel extends GenericChartConfigPanel {
     static template = "o-spreadsheet-BarConfigPanel";
-    get stackedLabel() {
-        return _t("Stacked barchart");
-    }
     onUpdateStacked(stacked) {
         this.props.updateChart(this.props.figureId, {
             stacked,
@@ -31577,6 +31954,9 @@ class ChartWithAxisDesignPanel extends owl.Component {
             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;
@@ -31741,19 +32121,13 @@ class LineConfigPanel extends GenericChartConfigPanel {
         }
         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),
             });
         }
@@ -31820,7 +32194,7 @@ class ScatterConfigPanel extends GenericChartConfigPanel {
             options.push({
                 name: "labelsAsText",
                 value: this.props.definition.labelsAsText,
-                label: _t("Treat labels as text"),
+                label: this.chartTerms.TreatLabelsAsText,
                 onChange: this.onUpdateLabelsAsText.bind(this),
             });
         }
@@ -32027,8 +32401,106 @@ chartSidePanelComponentRegistry
     .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";
@@ -32036,7 +32508,7 @@ class MainChartPanelStore extends SpreadsheetStore {
     activatePanel(panel) {
         this.panel = panel;
     }
-    changeChartType(figureId, type) {
+    changeChartType(figureId, newDisplayType) {
         this.creationContext = {
             ...this.creationContext,
             ...this.getters.getContextCreationChart(figureId),
@@ -32045,13 +32517,25 @@ class MainChartPanelStore extends SpreadsheetStore {
         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 */ `
@@ -32080,7 +32564,7 @@ css /* scss */ `
 `;
 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() {
@@ -32140,9 +32624,6 @@ class ChartPanel extends owl.Component {
     getChartDefinition(figureId) {
         return this.env.model.getters.getChartDefinition(figureId);
     }
-    get chartTypes() {
-        return getChartTypes();
-    }
 }
 
 css /* scss */ `
@@ -35216,9 +35697,17 @@ class SpreadsheetPivotTable {
     }
     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;
@@ -35228,7 +35717,7 @@ class SpreadsheetPivotTable {
         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);
@@ -35282,6 +35771,7 @@ class SpreadsheetPivotTable {
         };
     }
 }
+const EMPTY_PIVOT_CELL = { type: "EMPTY" };
 
 /**
  * This function converts a list of data entry into a spreadsheet pivot table.
@@ -35479,6 +35969,9 @@ function createDate(dimension, value, locale) {
     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);
@@ -35709,14 +36202,17 @@ class SpreadsheetPivot {
         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 {
@@ -35738,10 +36234,15 @@ class SpreadsheetPivot {
         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 = [];
@@ -51108,12 +51609,12 @@ class PivotCorePlugin extends CorePlugin {
         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),
+                });
             }
         }
     }
@@ -51143,21 +51644,6 @@ class PivotCorePlugin extends CorePlugin {
             });
         }
     }
-    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) {
@@ -52822,7 +53308,6 @@ class Evaluator {
         if (!this.blockedArrayFormulas.has(position)) {
             this.invalidateSpreading(position);
         }
-        this.spreadingRelations.removeNode(position);
         const cell = this.getters.getCell(position);
         if (cell === undefined) {
             return EMPTY_CELL;
@@ -52864,6 +53349,7 @@ class Evaluator {
         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));
@@ -54391,9 +54877,10 @@ class PivotUIPlugin extends UIPlugin {
         "getPivot",
         "getFirstPivotFunction",
         "getPivotIdFromPosition",
-        "getPivotDomainArgsFromPosition",
+        "getPivotCellFromPosition",
         "isPivotUnused",
         "areDomainArgsFieldsValid",
+        "isSpillPivotFormula",
     ];
     pivots = {};
     unusedPivots;
@@ -54472,6 +54959,14 @@ class PivotUIPlugin extends UIPlugin {
         }
         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) {
@@ -54505,29 +55000,29 @@ class PivotUIPlugin extends UIPlugin {
      * 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;
@@ -54536,22 +55031,28 @@ class PivotUIPlugin extends UIPlugin {
                 .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];
@@ -63834,6 +64335,9 @@ class SelectionStreamProcessorImpl {
     getBackToDefault() {
         this.stream.getBackToDefault();
     }
+    getAnchor() {
+        return this.anchor;
+    }
     modifyAnchor(anchor, mode, options) {
         const sheetId = this.getters.getActiveSheetId();
         anchor = {
@@ -66797,6 +67301,7 @@ const registries = {
     chartSidePanelComponentRegistry,
     chartComponentRegistry,
     chartRegistry,
+    chartSubtypeRegistry,
     topbarMenuRegistry,
     topbarComponentRegistry,
     clickableCellRegistry,
@@ -66905,6 +67410,7 @@ const components = {
     GaugeChartDesignPanel,
     ScorecardChartConfigPanel,
     ScorecardChartDesignPanel,
+    ChartTypePicker,
     FigureComponent,
     Menu,
     Popover,
@@ -66954,6 +67460,7 @@ const constants = {
     DEFAULT_LOCALE,
     HIGHLIGHT_COLOR,
     PIVOT_TABLE_CONFIG,
+    ChartTerms,
 };
 
 exports.AbstractCellClipboardHandler = AbstractCellClipboardHandler;
@@ -67002,6 +67509,6 @@ exports.tokenColors = tokenColors;
 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";