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

package/dist/o-spreadsheet.cjs.js

@@ -1,11 +1,10 @@
 
-// @odoo-module ignore
 /**
  * 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.6
- * @date 2024-06-19T13:46:27.157Z
- * @hash a4f22e4
+ * @version 17.4.0-alpha.8
+ * @date 2024-06-24T19:51:16.144Z
+ * @hash ccd30df
  */
 
 'use strict';
@@ -1904,9 +1903,10 @@ function percentile(values, percent, isInclusive) {
         sortedValues[indexLow] * (indexSup - percentIndex));
 }
 
-// define a mock translation function, when o-spreadsheet runs in standalone it doesn't translate any string
-let _translate = (s) => s;
-let _loaded = () => false;
+const defaultTranslate = (s) => s;
+const defaultLoaded = () => false;
+let _translate = defaultTranslate;
+let _loaded = defaultLoaded;
 function sprintf(s, ...values) {
     if (values.length === 1 && typeof values[0] === "object" && !(values[0] instanceof String)) {
         const valuesDict = values[0];
@@ -1918,7 +1918,8 @@ function sprintf(s, ...values) {
     return s;
 }
 /***
- * Allow to inject a translation function from outside o-spreadsheet.
+ * Allow to inject a translation function from outside o-spreadsheet. This should be called before instantiating
+ * a model.
  * @param tfn the function that will do the translation
  * @param loaded a function that returns true when the translation is loaded
  */
@@ -1926,6 +1927,18 @@ function setTranslationMethod(tfn, loaded = () => true) {
     _translate = tfn;
     _loaded = loaded;
 }
+/**
+ * If no translation function has been set, this will mark the translation are loaded.
+ *
+ * By default, the translations should not be set as loaded, otherwise top-level translated constants will never be
+ * translated. But if by the time the model is instantiated no custom translation function has been set, we can set
+ * the default translation function as loaded so o-spreadsheet can be run in standalone with no translations.
+ */
+function setDefaultTranslationMethod() {
+    if (_translate === defaultTranslate && _loaded === defaultLoaded) {
+        _loaded = () => true;
+    }
+}
 const _t = function (s, ...values) {
     if (!_loaded()) {
         return new LazyTranslatedString(s, values);
@@ -5621,18 +5634,12 @@ class BorderClipboardHandler extends AbstractCellClipboardHandler {
         return { borders };
     }
     paste(target, content, options) {
-        if (!content) {
-            return;
-        }
         const sheetId = target.sheetId;
-        if (options?.pasteOption === "asValue") {
-            return;
-        }
-        if (!("borders" in content) || !("zones" in target) || !target.zones.length) {
+        if (options.pasteOption === "asValue") {
             return;
         }
         const zones = target.zones;
-        if (!options?.isCutOperation) {
+        if (!options.isCutOperation) {
             this.pasteFromCopy(sheetId, zones, content.borders);
         }
         else {
@@ -6143,6 +6150,530 @@ function _localizeFormula(formula, fromLocale, toLocale) {
     return localizedFormula;
 }
 
+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) {
+        return toNumber(value, DEFAULT_LOCALE);
+    },
+    toValueAndFormat(normalizedValue, locale) {
+        return {
+            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            format: (locale ?? DEFAULT_LOCALE).dateFormat,
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        const date = toNumber(normalizedValue, DEFAULT_LOCALE);
+        return `"${formatValue(date, { locale: DEFAULT_LOCALE, format: "mm/dd/yyyy" })}"`;
+    },
+};
+/**
+ * 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;
+    },
+    toValueAndFormat(normalizedValue) {
+        return {
+            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            format: "0",
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `${normalizedValue}`;
+    },
+};
+/**
+ * Normalized value: "2/2023" for week 2 of 2023
+ */
+const weekAdapter = {
+    normalizeFunctionValue(value) {
+        const [week, year] = toString(value).split("/");
+        return `${Number(week)}/${Number(year)}`;
+    },
+    toValueAndFormat(normalizedValue, locale) {
+        const [week, year] = normalizedValue.split("/");
+        return {
+            value: _t("W%(week)s %(year)s", { week, year }),
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `"${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;
+    },
+    toValueAndFormat(normalizedValue) {
+        return {
+            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            format: "0",
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `${normalizedValue}`;
+    },
+};
+/**
+ * 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" });
+    },
+    toValueAndFormat(normalizedValue) {
+        return {
+            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            format: "mmmm yyyy",
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `"${normalizedValue}"`;
+    },
+};
+/**
+ * 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;
+    },
+    toValueAndFormat(normalizedValue) {
+        return {
+            value: MONTHS[toNumber(normalizedValue, DEFAULT_LOCALE) - 1].toString(),
+            format: "0",
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `${normalizedValue}`;
+    },
+};
+/**
+ * normalized quarter value is "quarter/year"
+ * e.g. "1/2020" for Q1 2020
+ */
+const quarterAdapter = {
+    normalizeFunctionValue(value) {
+        const [quarter, year] = toString(value).split("/");
+        return `${quarter}/${year}`;
+    },
+    toValueAndFormat(normalizedValue) {
+        const [quarter, year] = normalizedValue.split("/");
+        return {
+            value: _t("Q%(quarter)s %(year)s", { quarter, year }),
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `"${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;
+    },
+    toValueAndFormat(normalizedValue) {
+        return {
+            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            format: "0",
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `${normalizedValue}`;
+    },
+};
+const yearAdapter = {
+    normalizeFunctionValue(value) {
+        return toNumber(value, DEFAULT_LOCALE);
+    },
+    toValueAndFormat(normalizedValue) {
+        return {
+            value: toNumber(normalizedValue, DEFAULT_LOCALE),
+            format: "0",
+        };
+    },
+    toFunctionValue(normalizedValue) {
+        return `${normalizedValue}`;
+    },
+};
+/**
+ * This function takes an adapter and wraps it with a null handler.
+ * null value means that the value is not set.
+ */
+function nullHandlerDecorator(adapter) {
+    return {
+        normalizeFunctionValue(value) {
+            if (value === null) {
+                return null;
+            }
+            return adapter.normalizeFunctionValue(value);
+        },
+        toValueAndFormat(normalizedValue, locale) {
+            if (normalizedValue === null) {
+                return { value: _t("(Undefined)") }; //TODO Return NA ?
+            }
+            return adapter.toValueAndFormat(normalizedValue, locale);
+        },
+        toFunctionValue(normalizedValue) {
+            if (normalizedValue === null) {
+                return "false"; //TODO Return NA ?
+            }
+            return adapter.toFunctionValue(normalizedValue);
+        },
+    };
+}
+pivotTimeAdapterRegistry
+    .add("day", nullHandlerDecorator(dayAdapter))
+    .add("week", nullHandlerDecorator(weekAdapter))
+    .add("month", nullHandlerDecorator(monthAdapter))
+    .add("quarter", nullHandlerDecorator(quarterAdapter))
+    .add("year", nullHandlerDecorator(yearAdapter))
+    .add("day_of_month", nullHandlerDecorator(dayOfMonthAdapter))
+    .add("iso_week_number", nullHandlerDecorator(isoWeekNumberAdapter))
+    .add("month_number", nullHandlerDecorator(monthNumberAdapter))
+    .add("quarter_number", nullHandlerDecorator(quarterNumberAdapter))
+    .add("year_number", nullHandlerDecorator(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,
+    },
+};
+/**
+ * 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 generatePivotArgs(formulaId, domain, measure) {
+    const args = [formulaId];
+    if (measure) {
+        args.push(`"${measure}"`);
+    }
+    for (const { field, value, type } of domain) {
+        if (field === "measure") {
+            args.push(`"measure"`, `"${value}"`);
+            continue;
+        }
+        const { granularity } = parseDimension(field);
+        const formattedValue = toFunctionPivotValue(value, { type, granularity });
+        args.push(`"${field}"`, formattedValue);
+    }
+    return args;
+}
+/**
+ * Check if the fields in the domain part of
+ * a pivot function are valid according to the pivot definition.
+ * e.g. =PIVOT.VALUE(1,"revenue","country_id",...,"create_date:month",...,"source_id",...)
+ */
+function areDomainArgsFieldsValid(dimensions, definition) {
+    let argIndex = 0;
+    let definitionIndex = 0;
+    const cols = definition.columns.map((col) => col.nameWithGranularity);
+    const rows = definition.rows.map((row) => row.nameWithGranularity);
+    while (dimensions[argIndex] !== undefined && dimensions[argIndex] === rows[definitionIndex]) {
+        argIndex++;
+        definitionIndex++;
+    }
+    definitionIndex = 0;
+    while (dimensions[argIndex] !== undefined && dimensions[argIndex] === cols[definitionIndex]) {
+        argIndex++;
+        definitionIndex++;
+    }
+    return dimensions.length === argIndex;
+}
+function createPivotFormula(formulaId, cell) {
+    switch (cell.type) {
+        case "HEADER":
+            return `=PIVOT.HEADER(${generatePivotArgs(formulaId, cell.domain).join(",")})`;
+        case "VALUE":
+            return `=PIVOT.VALUE(${generatePivotArgs(formulaId, cell.domain, cell.measure).join(",")})`;
+        case "MEASURE_HEADER":
+            return `=PIVOT.HEADER(${generatePivotArgs(formulaId, [
+                ...cell.domain,
+                { field: "measure", value: cell.measure, type: "char" },
+            ]).join(",")})`;
+    }
+    return "";
+}
+/**
+ * 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.toLowerCase() === "false") {
+        return false;
+    }
+    const normalizer = pivotNormalizationValueRegistry.get(dimension.type);
+    return normalizer(groupValueString, dimension.granularity);
+}
+function normalizeDateTime(value, granularity) {
+    if (!granularity) {
+        throw new Error("Missing granularity");
+    }
+    return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
+}
+function toFunctionPivotValue(value, dimension) {
+    if (!pivotToFunctionValueRegistry.contains(dimension.type)) {
+        return `"${value}"`;
+    }
+    return pivotToFunctionValueRegistry.get(dimension.type)(value, dimension.granularity);
+}
+function toFunctionValueDateTime(value, granularity) {
+    if (!granularity) {
+        throw new Error("Missing granularity");
+    }
+    return pivotTimeAdapter(granularity).toFunctionValue(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));
+const pivotToFunctionValueRegistry = new Registry();
+pivotToFunctionValueRegistry
+    .add("date", toFunctionValueDateTime)
+    .add("datetime", toFunctionValueDateTime)
+    .add("integer", (value) => `${toNumber(value, DEFAULT_LOCALE)}`)
+    .add("boolean", (value) => (toBoolean(value) ? "TRUE" : "FALSE"))
+    .add("char", (value) => `"${toString(value).replace(/"/g, '\\"')}"`);
+
 class CellClipboardHandler extends AbstractCellClipboardHandler {
     isCutAllowed(data) {
         if (data.zones.length !== 1) {
@@ -6151,40 +6682,48 @@ class CellClipboardHandler extends AbstractCellClipboardHandler {
         return "Success" /* CommandResult.Success */;
     }
     copy(data) {
-        if (!("zones" in data) || !data.zones.length) {
-            return;
-        }
         const sheetId = data.sheetId;
-        const zones = data.zones;
-        if (!zones.length) {
-            return {
-                cells: [[]],
-                zones: [],
-                sheetId,
-            };
-        }
         const { clippedZones, rowsIndexes, columnsIndexes } = data;
         const clippedCells = [];
+        const isCopyingOneCell = rowsIndexes.length == 1 && columnsIndexes.length == 1;
         for (let row of rowsIndexes) {
             let cellsInRow = [];
             for (let col of columnsIndexes) {
                 const position = { col, row, sheetId };
-                const spreader = this.getters.getArrayFormulaSpreadingOn(position);
                 let cell = this.getters.getCell(position);
                 const evaluatedCell = this.getters.getEvaluatedCell(position);
-                if (spreader && !deepEquals(spreader, position)) {
-                    const isSpreaderCopied = rowsIndexes.includes(spreader.row) && columnsIndexes.includes(spreader.col);
-                    const content = isSpreaderCopied
-                        ? ""
-                        : formatValue(evaluatedCell.value, { locale: this.getters.getLocale() });
-                    cell = {
-                        id: cell?.id || "",
-                        style: cell?.style,
-                        format: evaluatedCell.format,
-                        content,
-                        isFormula: false,
-                        parsedValue: evaluatedCell.value,
-                    };
+                const pivotId = this.getters.getPivotIdFromPosition(position);
+                const spreader = this.getters.getArrayFormulaSpreadingOn(position);
+                if (pivotId) {
+                    if (!deepEquals(spreader, position) || !isCopyingOneCell) {
+                        const pivotCell = this.getters.getPivotCellFromPosition(position);
+                        const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
+                        const pivotFormula = createPivotFormula(formulaPivotId, pivotCell);
+                        cell = {
+                            id: cell?.id || "",
+                            style: cell?.style,
+                            format: evaluatedCell.format,
+                            content: pivotFormula,
+                            isFormula: false,
+                            parsedValue: evaluatedCell.value,
+                        };
+                    }
+                }
+                else {
+                    if (spreader && !deepEquals(spreader, position)) {
+                        const isSpreaderCopied = rowsIndexes.includes(spreader.row) && columnsIndexes.includes(spreader.col);
+                        const content = isSpreaderCopied
+                            ? ""
+                            : formatValue(evaluatedCell.value, { locale: this.getters.getLocale() });
+                        cell = {
+                            id: cell?.id || "",
+                            style: cell?.style,
+                            format: evaluatedCell.format,
+                            content,
+                            isFormula: false,
+                            parsedValue: evaluatedCell.value,
+                        };
+                    }
                 }
                 cellsInRow.push({
                     cell,
@@ -6233,12 +6772,9 @@ class CellClipboardHandler extends AbstractCellClipboardHandler {
      * Paste the clipboard content in the given target
      */
     paste(target, content, options) {
-        if (!("cells" in content) || !("zones" in target) || !target.zones.length) {
-            return;
-        }
         const zones = target.zones;
         const sheetId = target.sheetId;
-        if (!options?.isCutOperation) {
+        if (!options.isCutOperation) {
             this.pasteFromCopy(sheetId, zones, content.cells, options);
         }
         else {
@@ -6408,14 +6944,11 @@ class ChartClipboardHandler extends AbstractFigureClipboardHandler {
         };
     }
     getPasteTarget(sheetId, target, content, options) {
-        if (!content?.copiedFigure || !content?.copiedChart) {
-            return { zones: [], sheetId };
-        }
         const newId = new UuidGenerator().uuidv4();
         return { zones: [], figureId: newId, sheetId };
     }
     paste(target, clippedContent, options) {
-        if (!clippedContent?.copiedFigure || !clippedContent?.copiedChart || !target.figureId) {
+        if (!target.figureId) {
             return;
         }
         const { zones, figureId } = target;
@@ -6439,7 +6972,7 @@ class ChartClipboardHandler extends AbstractFigureClipboardHandler {
             size: { height, width },
             definition: copy.getDefinition(),
         });
-        if (options?.isCutOperation) {
+        if (options.isCutOperation) {
             this.dispatch("DELETE_FIGURE", {
                 sheetId: clippedContent.copiedChart.sheetId,
                 id: clippedContent.copiedFigure.id,
@@ -6481,15 +7014,12 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
         return { cfRules };
     }
     paste(target, clippedContent, options) {
-        if (!clippedContent?.cfRules ||
-            options?.pasteOption === "asValue" ||
-            !("zones" in target) ||
-            !target.zones.length) {
+        if (options.pasteOption === "asValue") {
             return;
         }
         const zones = target.zones;
         const sheetId = target.sheetId;
-        if (!options?.isCutOperation) {
+        if (!options.isCutOperation) {
             this.pasteFromCopy(sheetId, zones, clippedContent.cfRules, options);
         }
         else {
@@ -6563,9 +7093,6 @@ class ConditionalFormatClipboardHandler extends AbstractCellClipboardHandler {
 class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
     uuidGenerator = new UuidGenerator();
     copy(data) {
-        if (!data.zones.length) {
-            return;
-        }
         const { rowsIndexes, columnsIndexes } = data;
         const sheetId = data.sheetId;
         const dvRules = [];
@@ -6581,18 +7108,12 @@ class DataValidationClipboardHandler extends AbstractCellClipboardHandler {
         return { dvRules };
     }
     paste(target, clippedContent, options) {
-        if (!clippedContent?.dvRules) {
-            return;
-        }
-        if (options?.pasteOption) {
-            return;
-        }
-        if (!("zones" in target) || !target.zones.length) {
+        if (options.pasteOption) {
             return;
         }
         const zones = target.zones;
         const sheetId = target.sheetId;
-        if (!options?.isCutOperation) {
+        if (!options.isCutOperation) {
             this.pasteFromCopy(sheetId, zones, clippedContent.dvRules);
         }
         else {
@@ -6691,14 +7212,11 @@ class ImageClipboardHandler extends AbstractFigureClipboardHandler {
         };
     }
     getPasteTarget(sheetId, target, content, options) {
-        if (!content?.copiedFigure || !content?.copiedImage) {
-            return { zones: [], sheetId };
-        }
         const newId = new UuidGenerator().uuidv4();
         return { sheetId, zones: [], figureId: newId };
     }
     paste(target, clippedContent, options) {
-        if (!clippedContent?.copiedFigure || !clippedContent?.copiedImage || !target.figureId) {
+        if (!target.figureId) {
             return;
         }
         const { zones, figureId } = target;
@@ -6722,7 +7240,7 @@ class ImageClipboardHandler extends AbstractFigureClipboardHandler {
             size: { height, width },
             definition: copy,
         });
-        if (options?.isCutOperation) {
+        if (options.isCutOperation) {
             this.dispatch("DELETE_FIGURE", {
                 sheetId: clippedContent.sheetId,
                 id: clippedContent.copiedFigure.id,
@@ -6743,9 +7261,6 @@ class ImageClipboardHandler extends AbstractFigureClipboardHandler {
 
 class MergeClipboardHandler extends AbstractCellClipboardHandler {
     copy(data) {
-        if (!data.zones.length) {
-            return;
-        }
         const sheetId = this.getters.getActiveSheetId();
         const { rowsIndexes, columnsIndexes } = data;
         const merges = [];
@@ -6763,10 +7278,7 @@ class MergeClipboardHandler extends AbstractCellClipboardHandler {
      * Paste the clipboard content in the given target
      */
     paste(target, content, options) {
-        if (!content.merges ||
-            options?.isCutOperation ||
-            !("zones" in target) ||
-            !target.zones.length) {
+        if (options.isCutOperation) {
             return;
         }
         this.pasteFromCopy(target.sheetId, target.zones, content.merges, options);
@@ -6822,9 +7334,6 @@ class TableClipboardHandler extends AbstractCellClipboardHandler {
     copy(data) {
         const sheetId = data.sheetId;
         const { rowsIndexes, columnsIndexes, zones } = data;
-        if (!zones || !rowsIndexes.length || !columnsIndexes.length) {
-            return { tableCells: [[]], sheetId };
-        }
         const copiedTablesIds = new Set();
         const tableCells = [];
         for (let row of rowsIndexes) {
@@ -6880,12 +7389,9 @@ class TableClipboardHandler extends AbstractCellClipboardHandler {
         };
     }
     paste(target, content, options) {
-        if (!content || !content.tableCells) {
-            return;
-        }
         const zones = target.zones;
         const sheetId = target.sheetId;
-        if (!options?.isCutOperation) {
+        if (!options.isCutOperation) {
             this.pasteFromCopy(sheetId, zones, content.tableCells, options);
         }
         else {
@@ -7778,486 +8284,6 @@ 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
  *
@@ -9997,7 +10023,7 @@ class ComposerStore extends SpreadsheetStore {
             const cell = this.getters.getCell(position);
             if (pivotId && pivotCell.type !== "EMPTY" && !cell?.isFormula) {
                 const formulaPivotId = this.getters.getPivotFormulaId(pivotId);
-                const formula = makePivotFormulaFromPivotCell(formulaPivotId, pivotCell);
+                const formula = createPivotFormula(formulaPivotId, pivotCell);
                 return formula.slice(1); // strip leading =
             }
         }
@@ -19089,10 +19115,9 @@ const PIVOT_VALUE = {
     compute: function (formulaId, measureName, ...domainArgs) {
         const _pivotFormulaId = toString(formulaId);
         const _measure = toString(measureName);
-        const _domainArgs = domainArgs.map(toString);
         const pivotId = getPivotId(_pivotFormulaId, this.getters);
         assertMeasureExist(pivotId, _measure, this.getters);
-        assertDomainLength(_domainArgs);
+        assertDomainLength(domainArgs);
         const pivot = this.getters.getPivot(pivotId);
         const coreDefinition = this.getters.getPivotCoreDefinition(pivotId);
         addPivotDependencies(this, coreDefinition);
@@ -19100,15 +19125,14 @@ const PIVOT_VALUE = {
         if (error) {
             return error;
         }
-        const domain = toPivotDomain(_domainArgs);
-        const { value, format } = pivot.getPivotCellValueAndFormat(_measure, domain);
-        if (!value && !this.getters.areDomainArgsFieldsValid(pivotId, domain)) {
+        if (!pivot.areDomainArgsFieldsValid(domainArgs)) {
             return {
                 value: CellErrorType.GenericError,
                 message: _t("Dimensions don't match the pivot definition"),
             };
         }
-        return { value, format };
+        const domain = pivot.parseArgsToPivotDomain(domainArgs);
+        return pivot.getPivotCellValueAndFormat(_measure, domain);
     },
 };
 const PIVOT_HEADER = {
@@ -19120,9 +19144,8 @@ const PIVOT_HEADER = {
     ],
     compute: function (pivotId, ...domainArgs) {
         const _pivotFormulaId = toString(pivotId);
-        const _domainArgs = domainArgs.map(toString);
         const _pivotId = getPivotId(_pivotFormulaId, this.getters);
-        assertDomainLength(_domainArgs);
+        assertDomainLength(domainArgs);
         const pivot = this.getters.getPivot(_pivotId);
         const coreDefinition = this.getters.getPivotCoreDefinition(_pivotId);
         addPivotDependencies(this, coreDefinition);
@@ -19130,14 +19153,14 @@ const PIVOT_HEADER = {
         if (error) {
             return error;
         }
-        const domain = toPivotDomain(_domainArgs);
-        const lastNode = domain.at(-1);
-        if (!this.getters.areDomainArgsFieldsValid(_pivotId, lastNode?.field === "measure" ? domain.slice(0, -1) : domain)) {
+        if (!pivot.areDomainArgsFieldsValid(domainArgs)) {
             return {
                 value: CellErrorType.GenericError,
                 message: _t("Dimensions don't match the pivot definition"),
             };
         }
+        const domain = pivot.parseArgsToPivotDomain(domainArgs);
+        const lastNode = domain.at(-1);
         if (lastNode?.field === "measure") {
             return pivot.getPivotMeasureValue(toString(lastNode.value), domain);
         }
@@ -19154,13 +19177,21 @@ const PIVOT = {
     description: _t("Get a pivot table."),
     args: [
         arg("pivot_id (string)", _t("ID of the pivot.")),
-        arg("row_count (number, optional, default=10000)", _t("number of rows")),
+        arg("row_count (number, optional)", _t("number of rows")),
         arg("include_total (boolean, default=TRUE)", _t("Whether to include total/sub-totals or not.")),
         arg("include_column_titles (boolean, default=TRUE)", _t("Whether to include the column titles or not.")),
+        arg("column_count (number, optional)", _t("number of columns")),
     ],
-    compute: function (pivotFormulaId, rowCount = { value: 10000 }, includeTotal = { value: true }, includeColumnHeaders = { value: true }) {
+    compute: function (pivotFormulaId, rowCount = { value: Number.MAX_VALUE }, includeTotal = { value: true }, includeColumnHeaders = { value: true }, columnCount = { value: Number.MAX_VALUE }) {
         const _pivotFormulaId = toString(pivotFormulaId);
         const _rowCount = toNumber(rowCount, this.locale);
+        if (_rowCount < 0) {
+            throw new EvaluationError(_t("The number of rows must be positive."));
+        }
+        const _columnCount = toNumber(columnCount, this.locale);
+        if (_columnCount < 0) {
+            throw new EvaluationError(_t("The number of columns must be positive."));
+        }
         const _includeColumnHeaders = toBoolean(includeColumnHeaders);
         const _includedTotal = toBoolean(includeTotal);
         const pivotId = getPivotId(_pivotFormulaId, this.getters);
@@ -19176,19 +19207,15 @@ const PIVOT = {
         const cells = table.getPivotCells(_includedTotal, _includeColumnHeaders);
         const headerRows = _includeColumnHeaders ? table.columns.length : 0;
         const pivotTitle = this.getters.getPivotDisplayName(pivotId);
-        if (_rowCount < 0) {
-            throw new EvaluationError(_t("The number of rows must be positive."));
-        }
-        const end = Math.min(headerRows + _rowCount, cells[0].length);
-        if (end === 0) {
+        const tableHeight = Math.min(headerRows + _rowCount, cells[0].length);
+        if (tableHeight === 0) {
             return [[{ value: pivotTitle }]];
         }
-        const tableWidth = cells.length;
-        const tableRows = range(0, end);
+        const tableWidth = Math.min(1 + _columnCount, cells.length);
         const result = [];
         for (const col of range(0, tableWidth)) {
             result[col] = [];
-            for (const row of tableRows) {
+            for (const row of range(0, tableHeight)) {
                 const pivotCell = cells[col][row];
                 switch (pivotCell.type) {
                     case "EMPTY":
@@ -21878,9 +21905,6 @@ autoCompleteProviders.add("pivot_measures", {
         const pivot = this.getters.getPivot(pivotId);
         pivot.init();
         const fields = pivot.getFields();
-        if (!fields) {
-            return [];
-        }
         const definition = this.getters.getPivotCoreDefinition(pivotId);
         return definition.measures
             .map((measure) => {
@@ -21920,9 +21944,6 @@ autoCompleteProviders.add("pivot_group_fields", {
         const pivot = this.getters.getPivot(pivotId);
         pivot.init();
         const fields = pivot.getFields();
-        if (!fields) {
-            return;
-        }
         const { columns, rows } = pivot.definition;
         let args = functionContext.args;
         if (functionContext?.parent.toUpperCase() === "PIVOT.VALUE") {
@@ -27071,7 +27092,7 @@ function getSmartChartDefinition(zone, getters) {
     if (getZoneArea(zone) === 1 && topLeftCell?.content) {
         return {
             type: "scorecard",
-            title: { text: "" },
+            title: {},
             background: topLeftCell.style?.fillColor || undefined,
             keyValue: zoneToXc(zone),
             baselineMode: DEFAULT_SCORECARD_BASELINE_MODE,
@@ -27079,22 +27100,11 @@ function getSmartChartDefinition(zone, getters) {
             baselineColorDown: DEFAULT_SCORECARD_BASELINE_COLOR_DOWN,
         };
     }
-    let title = "";
     const cellsInFirstRow = getters.getEvaluatedCellsInZone(sheetId, {
         ...dataSetZone,
         bottom: dataSetZone.top,
     });
     const dataSetsHaveTitle = !!cellsInFirstRow.find((cell) => cell.type !== CellValueType.empty && cell.type !== CellValueType.number);
-    if (dataSetsHaveTitle) {
-        const texts = cellsInFirstRow
-            .filter((cell) => cell.type !== CellValueType.error && cell.type !== CellValueType.empty)
-            .map((cell) => cell.formattedValue);
-        const lastElement = texts.splice(-1)[0];
-        title = texts.join(", ");
-        if (lastElement) {
-            title += (title ? " " + _t("and") + " " : "") + lastElement;
-        }
-    }
     let labelRangeXc;
     if (!singleColumn) {
         labelRangeXc = zoneToXc({
@@ -27107,7 +27117,7 @@ function getSmartChartDefinition(zone, getters) {
     const labelRange = labelRangeXc ? getters.getRangeFromSheetXC(sheetId, labelRangeXc) : undefined;
     if (canChartParseLabels(labelRange, getters)) {
         return {
-            title: { text: title },
+            title: {},
             dataSets,
             labelsAsText: false,
             stacked: false,
@@ -27123,7 +27133,7 @@ function getSmartChartDefinition(zone, getters) {
     if (singleColumn &&
         getData(getters, _dataSets[0]).every((e) => typeof e === "string" && !isEvaluationError(e))) {
         return {
-            title: { text: "" },
+            title: {},
             dataSets: [{ dataRange }],
             aggregated: true,
             labelRange: dataRange,
@@ -27133,7 +27143,7 @@ function getSmartChartDefinition(zone, getters) {
         };
     }
     return {
-        title: { text: title },
+        title: {},
         dataSets,
         labelRange: labelRangeXc,
         type: "bar",
@@ -34556,6 +34566,7 @@ class FindAndReplaceStore extends SpreadsheetStore {
     currentSearchRegex = null;
     isSearchDirty = false;
     initialShowFormulaState;
+    preserveSelectedMatchIndex = false;
     // fixme: why do we make selectedMatchIndex on top of a selected
     // property in the matches?
     selectedMatchIndex = null;
@@ -34628,6 +34639,10 @@ class FindAndReplaceStore extends SpreadsheetStore {
             case "ACTIVATE_SHEET":
                 this.isSearchDirty = true;
                 break;
+            case "REPLACE_SEARCH":
+                for (const match of cmd.matches) {
+                    this.replaceMatch(match, cmd.searchString, cmd.replaceWith, cmd.searchOptions);
+                }
         }
     }
     finalize() {
@@ -34665,7 +34680,9 @@ class FindAndReplaceStore extends SpreadsheetStore {
      * refresh the matches according to the current search options
      */
     refreshSearch(jumpToMatchSheet = true) {
-        this.selectedMatchIndex = null;
+        if (!this.preserveSelectedMatchIndex) {
+            this.selectedMatchIndex = null;
+        }
         this.findMatches();
         this.selectNextCell(Direction.current, jumpToMatchSheet);
     }
@@ -34764,10 +34781,16 @@ class FindAndReplaceStore extends SpreadsheetStore {
         const selectedMatch = matches[nextIndex];
         // Switch to the sheet where the match is located
         if (jumpToMatchSheet && this.getters.getActiveSheetId() !== selectedMatch.sheetId) {
+            // We set `preserveSelectedMatchIndex` to true to avoid resetting the selected search
+            // index in the `refreshSearch` function when a new sheet is activated. The reason being
+            // that, when we automatically go back to previous sheet while performing a search, the
+            // search index is reset to the first occurrence each time.
+            this.preserveSelectedMatchIndex = true;
             this.model.dispatch("ACTIVATE_SHEET", {
                 sheetIdFrom: this.getters.getActiveSheetId(),
                 sheetIdTo: selectedMatch.sheetId,
             });
+            this.preserveSelectedMatchIndex = false;
             // We do not want to reset the selection at finalize in this case
             this.isSearchDirty = false;
         }
@@ -34801,6 +34824,21 @@ class FindAndReplaceStore extends SpreadsheetStore {
             searchOptions: this.searchOptions,
         });
     }
+    replaceMatch(selectedMatch, searchString, replaceWith, searchOptions) {
+        const cell = this.getters.getCell(selectedMatch);
+        if (!cell?.content) {
+            return;
+        }
+        if (cell?.isFormula && !searchOptions.searchFormulas) {
+            return;
+        }
+        const searchRegex = getSearchRegex(searchString, searchOptions);
+        const replaceRegex = new RegExp(searchRegex.source, searchRegex.flags + "g");
+        const toReplace = this.getters.getCellText(selectedMatch, searchOptions.searchFormulas);
+        const content = toReplace.replace(replaceRegex, replaceWith);
+        const canonicalContent = canonicalizeNumberContent(content, this.getters.getLocale());
+        this.model.dispatch("UPDATE_CELL", { ...selectedMatch, content: canonicalContent });
+    }
     getSearchableString(position) {
         return this.getters.getCellText(position, this.searchOptions.searchFormulas);
     }
@@ -35393,6 +35431,10 @@ class CogWheelMenu extends owl.Component {
             }
         });
     }
+    onClick(item) {
+        item.onClick();
+        this.popover.isOpen = false;
+    }
     get popoverProps() {
         const { x, y, width, height } = this.buttonRef.el.getBoundingClientRect();
         return {
@@ -35435,16 +35477,22 @@ class PivotTitleSection extends owl.Component {
     static components = { CogWheelMenu, Section, EditableName };
     static props = {
         pivotId: String,
+        flipAxis: Function,
     };
     get cogWheelMenuItems() {
         return [
             {
-                name: "Duplicate",
+                name: _t("Flip axes"),
+                icon: "fa-exchange",
+                onClick: this.props.flipAxis,
+            },
+            {
+                name: _t("Duplicate"),
                 icon: "fa-copy",
                 onClick: () => this.duplicatePivot(),
             },
             {
-                name: "Delete",
+                name: _t("Delete"),
                 icon: "fa-trash",
                 onClick: () => this.delete(),
             },
@@ -35552,7 +35600,7 @@ function createMeasure(fields, measure) {
 function createPivotDimension(fields, dimension) {
     const field = fields[dimension.name];
     const type = field?.type ?? "integer";
-    const granularity = field && isDateField(field) ? dimension.granularity ?? "month_number" : undefined;
+    const granularity = field && isDateField(field) ? dimension.granularity : undefined;
     return {
         /**
          * Get the display name of the dimension
@@ -35641,9 +35689,10 @@ class SpreadsheetPivotTable {
     columns;
     rows;
     measures;
+    fieldsType;
     maxIndent;
     pivotCells = {};
-    constructor(columns, rows, measures) {
+    constructor(columns, rows, measures, fieldsType) {
         this.columns = columns.map((row) => {
             // offset in the pivot table
             // starts at 1 because the first column is the row title
@@ -35656,6 +35705,7 @@ class SpreadsheetPivotTable {
         });
         this.rows = rows;
         this.measures = measures;
+        this.fieldsType = fieldsType;
         this.maxIndent = Math.max(...this.rows.map((row) => row.indent));
     }
     /**
@@ -35702,7 +35752,7 @@ class SpreadsheetPivotTable {
             if (!domain) {
                 return EMPTY_PIVOT_CELL;
             }
-            const measure = domain.at(-1)?.value.toString() || "";
+            const measure = domain.at(-1)?.value?.toString() || "";
             return { type: "MEASURE_HEADER", domain: domain.slice(0, -1), measure };
         }
         else if (row <= colHeadersHeight - 1) {
@@ -35734,9 +35784,13 @@ class SpreadsheetPivotTable {
             return undefined;
         }
         for (let i = 0; i < pivotCol.fields.length; i++) {
+            const fieldWithGranularity = pivotCol.fields[i];
+            const { name, granularity } = parseDimension(fieldWithGranularity);
+            const type = this.fieldsType[name] || "char";
             domain.push({
-                field: pivotCol.fields[i],
-                value: pivotCol.values[i],
+                type,
+                field: fieldWithGranularity,
+                value: toNormalizedPivotValue({ displayName: name, type, granularity }, pivotCol.values[i]),
             });
         }
         return domain;
@@ -35748,17 +35802,21 @@ class SpreadsheetPivotTable {
     getColMeasure(col) {
         const domain = this.getColHeaderDomain(col, this.columns.length - 1);
         const measure = domain?.at(-1)?.value;
-        if (measure === undefined) {
-            throw new Error("Measure isd missing");
+        if (measure === undefined || measure === null) {
+            throw new Error("Measure is missing");
         }
         return measure.toString();
     }
     getRowDomain(row) {
         const domain = [];
         for (let i = 0; i < this.rows[row].fields.length; i++) {
+            const fieldWithGranularity = this.rows[row].fields[i];
+            const { name, granularity } = parseDimension(fieldWithGranularity);
+            const type = this.fieldsType[name] || "char";
             domain.push({
-                field: this.rows[row].fields[i],
-                value: this.rows[row].values[i],
+                type,
+                field: fieldWithGranularity,
+                value: toNormalizedPivotValue({ displayName: name, type, granularity }, this.rows[row].values[i]),
             });
         }
         return domain;
@@ -35768,6 +35826,7 @@ class SpreadsheetPivotTable {
             cols: this.columns,
             rows: this.rows,
             measures: this.measures,
+            fieldsType: this.fieldsType,
         };
     }
 }
@@ -35788,7 +35847,14 @@ function dataEntriesToSpreadsheetPivotTable(dataEntries, definition) {
         indent: 0,
     });
     const measureNames = definition.measures.map((m) => m.name);
-    return new SpreadsheetPivotTable(cols, rows, measureNames);
+    const fieldsType = {};
+    for (const columns of definition.columns) {
+        fieldsType[columns.name] = columns.type;
+    }
+    for (const row of definition.rows) {
+        fieldsType[row.name] = row.type;
+    }
+    return new SpreadsheetPivotTable(cols, rows, measureNames, fieldsType);
 }
 // -----------------------------------------------------------------------------
 // ROWS
@@ -35964,41 +36030,42 @@ function compareDimensionValues(dimension, a, b) {
     return dimension.order === "asc" ? a.localeCompare(b) : b.localeCompare(a);
 }
 
+const NULL_SYMBOL = Symbol("NULL");
 function createDate(dimension, value, locale) {
-    const granularity = dimension.granularity || "month_number";
-    if (!(granularity in MAP_VALUE_DIMENSION_DATE)) {
+    const granularity = dimension.granularity;
+    if (!granularity || !(granularity in MAP_VALUE_DIMENSION_DATE)) {
         throw new Error(`Unknown date granularity: ${granularity}`);
     }
-    if (value === null) {
-        return null;
-    }
+    const keyInMap = typeof value === "number" || typeof value === "string" ? value : NULL_SYMBOL;
     if (!MAP_VALUE_DIMENSION_DATE[granularity].set.has(value)) {
         MAP_VALUE_DIMENSION_DATE[granularity].set.add(value);
-        const date = toJsDate(value, locale);
-        let number = 0;
-        switch (granularity) {
-            case "year_number":
-                number = date.getFullYear();
-                break;
-            case "quarter_number":
-                number = Math.floor(date.getMonth() / 3) + 1;
-                break;
-            case "month_number":
-                number = date.getMonth() + 1;
-                break;
-            case "iso_week_number":
-                number = date.getIsoWeek();
-                break;
-            case "day_of_month":
-                number = date.getDate();
-                break;
-            case "day":
-                number = Math.floor(toNumber(value, locale));
-                break;
+        let number = null;
+        if (typeof value === "number" || typeof value === "string") {
+            const date = toJsDate(value, locale);
+            switch (granularity) {
+                case "year_number":
+                    number = date.getFullYear();
+                    break;
+                case "quarter_number":
+                    number = Math.floor(date.getMonth() / 3) + 1;
+                    break;
+                case "month_number":
+                    number = date.getMonth() + 1;
+                    break;
+                case "iso_week_number":
+                    number = date.getIsoWeek();
+                    break;
+                case "day_of_month":
+                    number = date.getDate();
+                    break;
+                case "day":
+                    number = Math.floor(toNumber(value, locale));
+                    break;
+            }
         }
-        MAP_VALUE_DIMENSION_DATE[granularity].values[`${value}`] = toNormalizedPivotValue(dimension, number);
+        MAP_VALUE_DIMENSION_DATE[granularity].values[keyInMap] = toNormalizedPivotValue(dimension, number);
     }
-    return MAP_VALUE_DIMENSION_DATE[granularity].values[`${value}`];
+    return MAP_VALUE_DIMENSION_DATE[granularity].values[keyInMap];
 }
 /**
  * This map is used to cache the different values of a pivot date value
@@ -36180,6 +36247,25 @@ class SpreadsheetPivot {
         }
         return undefined;
     }
+    areDomainArgsFieldsValid(args) {
+        let dimensions = args.filter((_, index) => index % 2 === 0).map(toString);
+        if (dimensions.length && dimensions.at(-1) === "measure") {
+            dimensions = dimensions.slice(0, -1);
+        }
+        return areDomainArgsFieldsValid(dimensions, this.definition);
+    }
+    parseArgsToPivotDomain(args) {
+        const domain = [];
+        for (let i = 0; i < args.length - 1; i += 2) {
+            const fieldWithGranularity = toString(args[i]);
+            const type = this.getTypeOfDimension(fieldWithGranularity);
+            const normalizedValue = fieldWithGranularity === "measure"
+                ? toString(args[i + 1])
+                : toNormalizedPivotValue(this.getDimension(fieldWithGranularity), args[i + 1]);
+            domain.push({ field: fieldWithGranularity, value: normalizedValue, type });
+        }
+        return domain;
+    }
     markAsDirtyForEvaluation() {
         this.needsReevaluation = true;
     }
@@ -36201,18 +36287,12 @@ class SpreadsheetPivot {
         const finalCell = cells[0]?.[dimension.nameWithGranularity];
         if (dimension.type === "date") {
             const adapter = pivotTimeAdapter(dimension.granularity);
-            return {
-                value: lastNode.value !== "null"
-                    ? adapter.toCellValue(toNormalizedPivotValue(dimension, lastNode.value))
-                    : _t("(Undefined)"),
-                format: adapter.getFormat(this.getters.getLocale()),
-            };
+            return adapter.toValueAndFormat(lastNode.value, this.getters.getLocale());
         }
         if (!finalCell) {
             return { value: "" };
         }
-        // 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}`) {
+        if (finalCell.value === null) {
             return { value: _t("(Undefined)") };
         }
         return {
@@ -36263,14 +36343,24 @@ class SpreadsheetPivot {
     getFields() {
         return this.fields;
     }
+    getTypeOfDimension(fieldWithGranularity) {
+        if (fieldWithGranularity === "measure") {
+            return "char";
+        }
+        const { name } = parseDimension(fieldWithGranularity);
+        const type = this.fields[name]?.type;
+        if (!type) {
+            throw new Error(`Field ${name} does not exist`);
+        }
+        return type;
+    }
     filterDataEntriesFromDomain(dataEntries, domain) {
         return domain.reduce((current, acc) => this.filterDataEntriesFromDomainNode(current, acc), dataEntries);
     }
     filterDataEntriesFromDomainNode(dataEntries, domain) {
         const { field, value } = domain;
-        const dimension = this.getDimension(field);
-        return dataEntries.filter((entry) => `${entry[dimension.nameWithGranularity]?.value}` ===
-            `${toNormalizedPivotValue(dimension, value)}`);
+        const { nameWithGranularity } = this.getDimension(field);
+        return dataEntries.filter((entry) => entry[nameWithGranularity]?.value === value);
     }
     getDimension(nameWithGranularity) {
         return this.definition.getDimension(nameWithGranularity);
@@ -36375,7 +36465,7 @@ class SpreadsheetPivot {
             for (const entry of dataEntries) {
                 for (const dimension of dateDimensions) {
                     entry[dimension.nameWithGranularity] = {
-                        value: `${createDate(dimension, entry[dimension.name]?.value || null, this.getters.getLocale())}`,
+                        value: createDate(dimension, entry[dimension.name]?.value || null, this.getters.getLocale()),
                         type: entry[dimension.name]?.type || CellValueType.empty,
                         format: entry[dimension.name]?.format,
                     };
@@ -36422,11 +36512,7 @@ class PivotSidePanelStore extends SpreadsheetStore {
         }
     }
     get fields() {
-        const fields = this.pivot.getFields();
-        if (!fields) {
-            throw new Error("Fields not found");
-        }
-        return fields;
+        return this.pivot.getFields();
     }
     get pivot() {
         return this.getters.getPivot(this.pivotId);
@@ -36660,6 +36746,13 @@ class PivotSpreadsheetSidePanel extends owl.Component {
             this.store.applyUpdate();
         }
     }
+    flipAxis() {
+        const { rows, columns } = this.definition;
+        this.onDimensionsUpdated({
+            rows: columns,
+            columns: rows,
+        });
+    }
     onDimensionsUpdated(definition) {
         this.store.update(definition);
     }
@@ -51531,8 +51624,8 @@ class PivotCorePlugin extends CorePlugin {
             case "INSERT_PIVOT": {
                 const { sheetId, col, row, pivotId, table } = cmd;
                 const position = { sheetId, col, row };
-                const { cols, rows, measures } = table;
-                const spTable = new SpreadsheetPivotTable(cols, rows, measures);
+                const { cols, rows, measures, fieldsType } = table;
+                const spTable = new SpreadsheetPivotTable(cols, rows, measures, fieldsType || {});
                 const formulaId = this.getPivotFormulaId(pivotId);
                 this.insertPivot(position, formulaId, spTable);
                 break;
@@ -51613,7 +51706,7 @@ class PivotCorePlugin extends CorePlugin {
                     sheetId: position.sheetId,
                     col: position.col + col,
                     row: position.row + row,
-                    content: makePivotFormulaFromPivotCell(formulaId, pivotCell),
+                    content: createPivotFormula(formulaId, pivotCell),
                 });
             }
         }
@@ -54879,7 +54972,6 @@ class PivotUIPlugin extends UIPlugin {
         "getPivotIdFromPosition",
         "getPivotCellFromPosition",
         "isPivotUnused",
-        "areDomainArgsFieldsValid",
         "isSpillPivotFormula",
     ];
     pivots = {};
@@ -55011,19 +55103,19 @@ class PivotUIPlugin extends UIPlugin {
             return EMPTY_PIVOT_CELL;
         }
         const { functionName, args } = result;
+        const formulaId = args[0];
+        if (!formulaId) {
+            return EMPTY_PIVOT_CELL;
+        }
+        const pivotId = this.getters.getPivotId(formulaId.toString());
+        if (!pivotId) {
+            return EMPTY_PIVOT_CELL;
+        }
+        const pivot = this.getPivot(pivotId);
+        if (!pivot.isValid()) {
+            return EMPTY_PIVOT_CELL;
+        }
         if (functionName === "PIVOT") {
-            const formulaId = args[0];
-            if (!formulaId) {
-                return EMPTY_PIVOT_CELL;
-            }
-            const pivotId = this.getters.getPivotId(formulaId.toString());
-            if (!pivotId) {
-                return EMPTY_PIVOT_CELL;
-            }
-            const pivot = this.getPivot(pivotId);
-            if (!pivot.isValid()) {
-                return EMPTY_PIVOT_CELL;
-            }
             const includeTotal = args[2] === false ? false : undefined;
             const includeColumnHeaders = args[3] === false ? false : undefined;
             const pivotCells = pivot
@@ -55034,7 +55126,7 @@ class PivotUIPlugin extends UIPlugin {
             return pivotCells[pivotCol][pivotRow];
         }
         if (functionName === "PIVOT.HEADER" && args.at(-2) === "measure") {
-            const domain = toPivotDomain(args.slice(1, -2).map((x) => `${x}`));
+            const domain = pivot.parseArgsToPivotDomain(args.slice(1, -2).map((value) => ({ value })));
             return {
                 type: "MEASURE_HEADER",
                 domain,
@@ -55042,15 +55134,17 @@ class PivotUIPlugin extends UIPlugin {
             };
         }
         else if (functionName === "PIVOT.HEADER") {
+            const domain = pivot.parseArgsToPivotDomain(args.slice(1).map((value) => ({ value })));
             return {
                 type: "HEADER",
-                domain: toPivotDomain(args.slice(1).map((x) => `${x}`)),
+                domain,
             };
         }
         const [measure, ...domainArgs] = args.slice(1);
+        const domain = pivot.parseArgsToPivotDomain(domainArgs.map((value) => ({ value })));
         return {
             type: "VALUE",
-            domain: toPivotDomain(domainArgs.map((x) => `${x}`)),
+            domain,
             measure: measure?.toString() || "",
         };
     }
@@ -55060,32 +55154,6 @@ class PivotUIPlugin extends UIPlugin {
     isPivotUnused(pivotId) {
         return this._getUnusedPivots().includes(pivotId);
     }
-    /**
-     * Check if the fields in the domain part of
-     * a pivot function are valid according to the pivot definition.
-     * e.g. =PIVOT.VALUE(1,"revenue","country_id",...,"create_date:month",...,"source_id",...)
-     */
-    areDomainArgsFieldsValid(pivotId, domain) {
-        const dimensions = domain
-            .map((node) => node.field)
-            .map((name) => (name.startsWith("#") ? name.slice(1) : name));
-        let argIndex = 0;
-        let definitionIndex = 0;
-        const pivot = this.getPivot(pivotId);
-        const definition = pivot.definition;
-        const cols = definition.columns.map((col) => col.nameWithGranularity);
-        const rows = definition.rows.map((row) => row.nameWithGranularity);
-        while (dimensions[argIndex] !== undefined && dimensions[argIndex] === rows[definitionIndex]) {
-            argIndex++;
-            definitionIndex++;
-        }
-        definitionIndex = 0;
-        while (dimensions[argIndex] !== undefined && dimensions[argIndex] === cols[definitionIndex]) {
-            argIndex++;
-            definitionIndex++;
-        }
-        return dimensions.length === argIndex;
-    }
     // ---------------------------------------------------------------------
     // Private
     // ---------------------------------------------------------------------
@@ -56923,43 +56991,6 @@ class DataCleanupPlugin extends UIPlugin {
     }
 }
 
-/**
- * Find and Replace Plugin
- *
- * This plugin is used in combination with the find_and_replace sidePanel
- * It is used to 'highlight' cells that match an input string according to
- * the given searchOptions. The second part of this plugin makes it possible
- * (again with the find_and_replace sidePanel), to replace the values that match
- * the search with a new value.
- */
-class FindAndReplacePlugin extends UIPlugin {
-    static getters = [];
-    handle(cmd) {
-        switch (cmd.type) {
-            case "REPLACE_SEARCH":
-                for (const match of cmd.matches) {
-                    this.replaceMatch(match, cmd.searchString, cmd.replaceWith, cmd.searchOptions);
-                }
-                break;
-        }
-    }
-    replaceMatch(selectedMatch, searchString, replaceWith, searchOptions) {
-        const cell = this.getters.getCell(selectedMatch);
-        if (!cell?.content) {
-            return;
-        }
-        if (cell?.isFormula && !searchOptions.searchFormulas) {
-            return;
-        }
-        const searchRegex = getSearchRegex(searchString, searchOptions);
-        const replaceRegex = new RegExp(searchRegex.source, searchRegex.flags + "g");
-        const toReplace = this.getters.getCellText(selectedMatch, searchOptions.searchFormulas);
-        const content = toReplace.replace(replaceRegex, replaceWith);
-        const canonicalContent = canonicalizeNumberContent(content, this.getters.getLocale());
-        this.dispatch("UPDATE_CELL", { ...selectedMatch, content: canonicalContent });
-    }
-}
-
 class FormatPlugin extends UIPlugin {
     // ---------------------------------------------------------------------------
     // Command Handling
@@ -58605,32 +58636,32 @@ class ClipboardPlugin extends UIPlugin {
         }
     }
     convertOSClipboardData(clipboardData) {
-        const handlers = clipboardHandlersRegistries.figureHandlers
-            .getAll()
-            .map((handler) => new handler(this.getters, this.dispatch));
-        clipboardHandlersRegistries.cellHandlers
-            .getAll()
-            .forEach((handler) => handlers.push(new handler(this.getters, this.dispatch)));
+        const handlers = this.selectClipboardHandlers({ figureId: true }).concat(this.selectClipboardHandlers({}));
         let copiedData = {};
-        for (const handler of handlers) {
+        for (const { handlerName, handler } of handlers) {
             const data = handler.convertOSClipboardData(clipboardData);
-            copiedData = { ...copiedData, ...data };
+            copiedData[handlerName] = data;
+            const minimalKeys = ["sheetId", "cells", "zones", "figureId"];
+            for (const key of minimalKeys) {
+                if (data && key in data) {
+                    copiedData[key] = data[key];
+                }
+            }
         }
         return copiedData;
     }
     selectClipboardHandlers(data) {
-        if ("figureId" in data) {
-            return clipboardHandlersRegistries.figureHandlers
-                .getAll()
-                .map((handler) => new handler(this.getters, this.dispatch));
-        }
-        return clipboardHandlersRegistries.cellHandlers
-            .getAll()
-            .map((handler) => new handler(this.getters, this.dispatch));
+        const handlersRegistry = "figureId" in data
+            ? clipboardHandlersRegistries.figureHandlers
+            : clipboardHandlersRegistries.cellHandlers;
+        return handlersRegistry.getKeys().map((handlerName) => {
+            const Handler = handlersRegistry.get(handlerName);
+            return { handlerName, handler: new Handler(this.getters, this.dispatch) };
+        });
     }
     isCutAllowedOn(zones) {
         const clipboardData = this.getClipboardData(zones);
-        for (const handler of this.selectClipboardHandlers(clipboardData)) {
+        for (const { handler } of this.selectClipboardHandlers(clipboardData)) {
             const result = handler.isCutAllowed(clipboardData);
             if (result !== "Success" /* CommandResult.Success */) {
                 return result;
@@ -58639,7 +58670,7 @@ class ClipboardPlugin extends UIPlugin {
         return "Success" /* CommandResult.Success */;
     }
     isPasteAllowed(target, copiedData, options) {
-        for (const handler of this.selectClipboardHandlers(copiedData)) {
+        for (const { handler } of this.selectClipboardHandlers(copiedData)) {
             const result = handler.isPasteAllowed(this.getters.getActiveSheetId(), target, copiedData, {
                 ...options,
             });
@@ -58667,9 +58698,15 @@ class ClipboardPlugin extends UIPlugin {
     copy(zones) {
         let copiedData = {};
         const clipboardData = this.getClipboardData(zones);
-        for (const handler of this.selectClipboardHandlers(clipboardData)) {
+        for (const { handlerName, handler } of this.selectClipboardHandlers(clipboardData)) {
             const data = handler.copy(clipboardData);
-            copiedData = { ...copiedData, ...data };
+            copiedData[handlerName] = data;
+            const minimalKeys = ["sheetId", "cells", "zones", "figureId"];
+            for (const key of minimalKeys) {
+                if (data && key in data) {
+                    copiedData[key] = data[key];
+                }
+            }
         }
         return copiedData;
     }
@@ -58685,8 +58722,12 @@ class ClipboardPlugin extends UIPlugin {
             zones,
         };
         const handlers = this.selectClipboardHandlers(copiedData);
-        for (const handler of handlers) {
-            const currentTarget = handler.getPasteTarget(sheetId, zones, copiedData, options);
+        for (const { handlerName, handler } of handlers) {
+            const handlerData = copiedData[handlerName];
+            if (!handlerData) {
+                continue;
+            }
+            const currentTarget = handler.getPasteTarget(sheetId, zones, handlerData, options);
             if (currentTarget.figureId) {
                 target.figureId = currentTarget.figureId;
             }
@@ -58702,7 +58743,12 @@ class ClipboardPlugin extends UIPlugin {
         if (zone !== undefined) {
             this.addMissingDimensions(this.getters.getActiveSheetId(), zone.right - zone.left + 1, zone.bottom - zone.top + 1, zone.left, zone.top);
         }
-        handlers.forEach((handler) => handler.paste(target, copiedData, options));
+        handlers.forEach(({ handlerName, handler }) => {
+            const handlerData = copiedData[handlerName];
+            if (handlerData) {
+                handler.paste(target, handlerData, options);
+            }
+        });
         if (!options?.selectTarget) {
             return;
         }
@@ -60774,7 +60820,6 @@ const featurePluginRegistry = new Registry()
     .add("ui_sheet", SheetUIPlugin)
     .add("ui_options", UIOptionsPlugin)
     .add("autofill", AutofillPlugin)
-    .add("find_and_replace", FindAndReplacePlugin)
     .add("sort", SortPlugin)
     .add("automatic_sum", AutomaticSumPlugin)
     .add("format", FormatPlugin)
@@ -66823,6 +66868,7 @@ class Model extends EventBus {
         const start = performance.now();
         console.group("Model creation");
         super();
+        setDefaultTranslationMethod();
         stateUpdateMessages = repairInitialMessages(data, stateUpdateMessages);
         const workbookData = load(data, verboseImport);
         this.state = new StateObserver();
@@ -67318,6 +67364,7 @@ const registries = {
     pivotSidePanelRegistry,
     pivotNormalizationValueRegistry,
     supportedPivotPositionalFormulaRegistry,
+    pivotToFunctionValueRegistry,
 };
 const helpers = {
     arg,
@@ -67363,7 +67410,6 @@ const helpers = {
     expandZoneOnInsertion,
     reduceZoneOnDeletion,
     unquote,
-    makePivotFormula,
     getMaxObjectId,
     getFunctionsFromTokens,
     getFirstPivotFunction,
@@ -67375,10 +67421,10 @@ const helpers = {
     insertTokenAfterLeftParenthesis,
     mergeContiguousZones,
     getPivotHighlights,
-    toPivotDomain,
-    flatPivotDomain,
     pivotTimeAdapter,
     UNDO_REDO_PIVOT_COMMANDS,
+    createPivotFormula,
+    areDomainArgsFieldsValid,
 };
 const links = {
     isMarkdownLink,
@@ -67509,6 +67555,6 @@ exports.tokenColors = tokenColors;
 exports.tokenize = tokenize;
 
 
-__info__.version = "17.4.0-alpha.6";
-__info__.date = "2024-06-19T13:46:27.157Z";
-__info__.hash = "a4f22e4";
+__info__.version = "17.4.0-alpha.8";
+__info__.date = "2024-06-24T19:51:16.144Z";
+__info__.hash = "ccd30df";