@odoo/o-spreadsheet 16.4.0-alpha.4 → 16.4.0-alpha.5

package/dist/o-spreadsheet.esm.js

@@ -750,12 +750,20 @@ function getDefaultCellHeight(cell) {
     return computeTextLinesHeight(fontSize, numberOfLines) + 2 * PADDING_AUTORESIZE_VERTICAL;
 }
 function computeTextWidth(context, text, style) {
-    context.save();
-    context.font = computeTextFont(style);
-    const textWidth = context.measureText(text).width;
-    context.restore();
-    return textWidth;
+    const font = computeTextFont(style);
+    if (!textWidthCache[font]) {
+        textWidthCache[font] = {};
+    }
+    if (textWidthCache[font][text] === undefined) {
+        context.save();
+        context.font = font;
+        const textWidth = context.measureText(text).width;
+        context.restore();
+        textWidthCache[font][text] = textWidth;
+    }
+    return textWidthCache[font][text];
 }
+const textWidthCache = {};
 function fontSizeInPixels(fontSize) {
     return Math.round((fontSize * 96) / 72);
 }
@@ -1063,10 +1071,17 @@ function removeFalsyAttributes(obj) {
 function toLowerCase(str) {
     return str ? str.toLowerCase() : "";
 }
-function transpose2dArray(matrix) {
+function transpose2dArray(matrix, callback = (val) => val) {
     if (!matrix.length)
-        return matrix;
-    return matrix[0].map((_, i) => matrix.map((row) => row[i]));
+        return [];
+    const transposed = Array(matrix[0].length);
+    for (let i = 0; i < matrix[0].length; i++) {
+        transposed[i] = Array(matrix.length);
+        for (let j = 0; j < matrix.length; j++) {
+            transposed[i][j] = callback(matrix[j][i]);
+        }
+    }
+    return transposed;
 }
 /**
  * Equivalent to "\s" in regexp, minus the new lines characters
@@ -3704,6 +3719,290 @@ function detectLink(value) {
     return undefined;
 }
 
+var CellValueType;
+(function (CellValueType) {
+    CellValueType["boolean"] = "boolean";
+    CellValueType["number"] = "number";
+    CellValueType["text"] = "text";
+    CellValueType["empty"] = "empty";
+    CellValueType["error"] = "error";
+})(CellValueType || (CellValueType = {}));
+
+var ClipboardMIMEType;
+(function (ClipboardMIMEType) {
+    ClipboardMIMEType["PlainText"] = "text/plain";
+    ClipboardMIMEType["Html"] = "text/html";
+})(ClipboardMIMEType || (ClipboardMIMEType = {}));
+
+function isSheetDependent(cmd) {
+    return "sheetId" in cmd;
+}
+function isGridDependent(cmd) {
+    return "dimension" in cmd && "sheetId" in cmd;
+}
+function isTargetDependent(cmd) {
+    return "target" in cmd && "sheetId" in cmd;
+}
+function isRangeDependant(cmd) {
+    return "ranges" in cmd;
+}
+function isPositionDependent(cmd) {
+    return "col" in cmd && "row" in cmd && "sheetId" in cmd;
+}
+const invalidateEvaluationCommands = new Set([
+    "RENAME_SHEET",
+    "DELETE_SHEET",
+    "CREATE_SHEET",
+    "ADD_COLUMNS_ROWS",
+    "REMOVE_COLUMNS_ROWS",
+    "UNDO",
+    "REDO",
+    "ADD_MERGE",
+]);
+const invalidateDependenciesCommands = new Set([
+    ...invalidateEvaluationCommands,
+    "MOVE_RANGES",
+]);
+const invalidateCFEvaluationCommands = new Set([
+    ...invalidateEvaluationCommands,
+    "DUPLICATE_SHEET",
+    "EVALUATE_CELLS",
+    "ADD_CONDITIONAL_FORMAT",
+    "REMOVE_CONDITIONAL_FORMAT",
+    "MOVE_CONDITIONAL_FORMAT",
+]);
+const readonlyAllowedCommands = new Set([
+    "START",
+    "ACTIVATE_SHEET",
+    "COPY",
+    "PREPARE_SELECTION_INPUT_EXPANSION",
+    "STOP_SELECTION_INPUT",
+    "RESIZE_SHEETVIEW",
+    "SET_VIEWPORT_OFFSET",
+    "SELECT_SEARCH_NEXT_MATCH",
+    "SELECT_SEARCH_PREVIOUS_MATCH",
+    "REFRESH_SEARCH",
+    "UPDATE_SEARCH",
+    "CLEAR_SEARCH",
+    "EVALUATE_CELLS",
+    "SET_CURRENT_CONTENT",
+    "SET_FORMULA_VISIBILITY",
+    "OPEN_CELL_POPOVER",
+    "CLOSE_CELL_POPOVER",
+    "UPDATE_FILTER",
+]);
+const coreTypes = new Set([
+    /** CELLS */
+    "UPDATE_CELL",
+    "UPDATE_CELL_POSITION",
+    "CLEAR_CELL",
+    "DELETE_CONTENT",
+    /** GRID SHAPE */
+    "ADD_COLUMNS_ROWS",
+    "REMOVE_COLUMNS_ROWS",
+    "RESIZE_COLUMNS_ROWS",
+    "HIDE_COLUMNS_ROWS",
+    "UNHIDE_COLUMNS_ROWS",
+    "SET_GRID_LINES_VISIBILITY",
+    "UNFREEZE_COLUMNS",
+    "UNFREEZE_ROWS",
+    "FREEZE_COLUMNS",
+    "FREEZE_ROWS",
+    "UNFREEZE_COLUMNS_ROWS",
+    /** MERGE */
+    "ADD_MERGE",
+    "REMOVE_MERGE",
+    /** SHEETS MANIPULATION */
+    "CREATE_SHEET",
+    "DELETE_SHEET",
+    "DUPLICATE_SHEET",
+    "MOVE_SHEET",
+    "RENAME_SHEET",
+    "HIDE_SHEET",
+    "SHOW_SHEET",
+    /** RANGES MANIPULATION */
+    "MOVE_RANGES",
+    /** CONDITIONAL FORMAT */
+    "ADD_CONDITIONAL_FORMAT",
+    "REMOVE_CONDITIONAL_FORMAT",
+    "MOVE_CONDITIONAL_FORMAT",
+    /** FIGURES */
+    "CREATE_FIGURE",
+    "DELETE_FIGURE",
+    "UPDATE_FIGURE",
+    /** FORMATTING */
+    "SET_FORMATTING",
+    "CLEAR_FORMATTING",
+    "SET_BORDER",
+    "SET_ZONE_BORDERS",
+    /** CHART */
+    "CREATE_CHART",
+    "UPDATE_CHART",
+    /** FILTERS */
+    "CREATE_FILTER_TABLE",
+    "REMOVE_FILTER_TABLE",
+    /** IMAGE */
+    "CREATE_IMAGE",
+]);
+function isCoreCommand(cmd) {
+    return coreTypes.has(cmd.type);
+}
+function canExecuteInReadonly(cmd) {
+    return readonlyAllowedCommands.has(cmd.type);
+}
+/**
+ * Holds the result of a command dispatch.
+ * The command may have been successfully dispatched or cancelled
+ * for one or more reasons.
+ */
+class DispatchResult {
+    reasons;
+    constructor(results = []) {
+        if (!Array.isArray(results)) {
+            results = [results];
+        }
+        results = [...new Set(results)];
+        this.reasons = results.filter((result) => result !== 0 /* CommandResult.Success */);
+    }
+    /**
+     * Static helper which returns a successful DispatchResult
+     */
+    static get Success() {
+        return new DispatchResult();
+    }
+    get isSuccessful() {
+        return this.reasons.length === 0;
+    }
+    /**
+     * Check if the dispatch has been cancelled because of
+     * the given reason.
+     */
+    isCancelledBecause(reason) {
+        return this.reasons.includes(reason);
+    }
+}
+var CommandResult;
+(function (CommandResult) {
+    CommandResult[CommandResult["Success"] = 0] = "Success";
+    CommandResult[CommandResult["CancelledForUnknownReason"] = 1] = "CancelledForUnknownReason";
+    CommandResult[CommandResult["WillRemoveExistingMerge"] = 2] = "WillRemoveExistingMerge";
+    CommandResult[CommandResult["MergeIsDestructive"] = 3] = "MergeIsDestructive";
+    CommandResult[CommandResult["CellIsMerged"] = 4] = "CellIsMerged";
+    CommandResult[CommandResult["InvalidTarget"] = 5] = "InvalidTarget";
+    CommandResult[CommandResult["EmptyUndoStack"] = 6] = "EmptyUndoStack";
+    CommandResult[CommandResult["EmptyRedoStack"] = 7] = "EmptyRedoStack";
+    CommandResult[CommandResult["NotEnoughElements"] = 8] = "NotEnoughElements";
+    CommandResult[CommandResult["NotEnoughSheets"] = 9] = "NotEnoughSheets";
+    CommandResult[CommandResult["MissingSheetName"] = 10] = "MissingSheetName";
+    CommandResult[CommandResult["UnchangedSheetName"] = 11] = "UnchangedSheetName";
+    CommandResult[CommandResult["DuplicatedSheetName"] = 12] = "DuplicatedSheetName";
+    CommandResult[CommandResult["DuplicatedSheetId"] = 13] = "DuplicatedSheetId";
+    CommandResult[CommandResult["ForbiddenCharactersInSheetName"] = 14] = "ForbiddenCharactersInSheetName";
+    CommandResult[CommandResult["WrongSheetMove"] = 15] = "WrongSheetMove";
+    CommandResult[CommandResult["WrongSheetPosition"] = 16] = "WrongSheetPosition";
+    CommandResult[CommandResult["InvalidAnchorZone"] = 17] = "InvalidAnchorZone";
+    CommandResult[CommandResult["SelectionOutOfBound"] = 18] = "SelectionOutOfBound";
+    CommandResult[CommandResult["TargetOutOfSheet"] = 19] = "TargetOutOfSheet";
+    CommandResult[CommandResult["WrongCutSelection"] = 20] = "WrongCutSelection";
+    CommandResult[CommandResult["WrongPasteSelection"] = 21] = "WrongPasteSelection";
+    CommandResult[CommandResult["WrongPasteOption"] = 22] = "WrongPasteOption";
+    CommandResult[CommandResult["WrongFigurePasteOption"] = 23] = "WrongFigurePasteOption";
+    CommandResult[CommandResult["EmptyClipboard"] = 24] = "EmptyClipboard";
+    CommandResult[CommandResult["EmptyRange"] = 25] = "EmptyRange";
+    CommandResult[CommandResult["InvalidRange"] = 26] = "InvalidRange";
+    CommandResult[CommandResult["InvalidZones"] = 27] = "InvalidZones";
+    CommandResult[CommandResult["InvalidSheetId"] = 28] = "InvalidSheetId";
+    CommandResult[CommandResult["InvalidFigureId"] = 29] = "InvalidFigureId";
+    CommandResult[CommandResult["InputAlreadyFocused"] = 30] = "InputAlreadyFocused";
+    CommandResult[CommandResult["MaximumRangesReached"] = 31] = "MaximumRangesReached";
+    CommandResult[CommandResult["InvalidChartDefinition"] = 32] = "InvalidChartDefinition";
+    CommandResult[CommandResult["InvalidDataSet"] = 33] = "InvalidDataSet";
+    CommandResult[CommandResult["InvalidLabelRange"] = 34] = "InvalidLabelRange";
+    CommandResult[CommandResult["InvalidScorecardKeyValue"] = 35] = "InvalidScorecardKeyValue";
+    CommandResult[CommandResult["InvalidScorecardBaseline"] = 36] = "InvalidScorecardBaseline";
+    CommandResult[CommandResult["InvalidGaugeDataRange"] = 37] = "InvalidGaugeDataRange";
+    CommandResult[CommandResult["EmptyGaugeRangeMin"] = 38] = "EmptyGaugeRangeMin";
+    CommandResult[CommandResult["GaugeRangeMinNaN"] = 39] = "GaugeRangeMinNaN";
+    CommandResult[CommandResult["EmptyGaugeRangeMax"] = 40] = "EmptyGaugeRangeMax";
+    CommandResult[CommandResult["GaugeRangeMaxNaN"] = 41] = "GaugeRangeMaxNaN";
+    CommandResult[CommandResult["GaugeRangeMinBiggerThanRangeMax"] = 42] = "GaugeRangeMinBiggerThanRangeMax";
+    CommandResult[CommandResult["GaugeLowerInflectionPointNaN"] = 43] = "GaugeLowerInflectionPointNaN";
+    CommandResult[CommandResult["GaugeUpperInflectionPointNaN"] = 44] = "GaugeUpperInflectionPointNaN";
+    CommandResult[CommandResult["GaugeLowerBiggerThanUpper"] = 45] = "GaugeLowerBiggerThanUpper";
+    CommandResult[CommandResult["InvalidAutofillSelection"] = 46] = "InvalidAutofillSelection";
+    CommandResult[CommandResult["WrongComposerSelection"] = 47] = "WrongComposerSelection";
+    CommandResult[CommandResult["MinBiggerThanMax"] = 48] = "MinBiggerThanMax";
+    CommandResult[CommandResult["LowerBiggerThanUpper"] = 49] = "LowerBiggerThanUpper";
+    CommandResult[CommandResult["MidBiggerThanMax"] = 50] = "MidBiggerThanMax";
+    CommandResult[CommandResult["MinBiggerThanMid"] = 51] = "MinBiggerThanMid";
+    CommandResult[CommandResult["FirstArgMissing"] = 52] = "FirstArgMissing";
+    CommandResult[CommandResult["SecondArgMissing"] = 53] = "SecondArgMissing";
+    CommandResult[CommandResult["MinNaN"] = 54] = "MinNaN";
+    CommandResult[CommandResult["MidNaN"] = 55] = "MidNaN";
+    CommandResult[CommandResult["MaxNaN"] = 56] = "MaxNaN";
+    CommandResult[CommandResult["ValueUpperInflectionNaN"] = 57] = "ValueUpperInflectionNaN";
+    CommandResult[CommandResult["ValueLowerInflectionNaN"] = 58] = "ValueLowerInflectionNaN";
+    CommandResult[CommandResult["MinInvalidFormula"] = 59] = "MinInvalidFormula";
+    CommandResult[CommandResult["MidInvalidFormula"] = 60] = "MidInvalidFormula";
+    CommandResult[CommandResult["MaxInvalidFormula"] = 61] = "MaxInvalidFormula";
+    CommandResult[CommandResult["ValueUpperInvalidFormula"] = 62] = "ValueUpperInvalidFormula";
+    CommandResult[CommandResult["ValueLowerInvalidFormula"] = 63] = "ValueLowerInvalidFormula";
+    CommandResult[CommandResult["InvalidSortZone"] = 64] = "InvalidSortZone";
+    CommandResult[CommandResult["WaitingSessionConfirmation"] = 65] = "WaitingSessionConfirmation";
+    CommandResult[CommandResult["MergeOverlap"] = 66] = "MergeOverlap";
+    CommandResult[CommandResult["TooManyHiddenElements"] = 67] = "TooManyHiddenElements";
+    CommandResult[CommandResult["Readonly"] = 68] = "Readonly";
+    CommandResult[CommandResult["InvalidViewportSize"] = 69] = "InvalidViewportSize";
+    CommandResult[CommandResult["InvalidScrollingDirection"] = 70] = "InvalidScrollingDirection";
+    CommandResult[CommandResult["FigureDoesNotExist"] = 71] = "FigureDoesNotExist";
+    CommandResult[CommandResult["InvalidConditionalFormatId"] = 72] = "InvalidConditionalFormatId";
+    CommandResult[CommandResult["InvalidCellPopover"] = 73] = "InvalidCellPopover";
+    CommandResult[CommandResult["EmptyTarget"] = 74] = "EmptyTarget";
+    CommandResult[CommandResult["InvalidFreezeQuantity"] = 75] = "InvalidFreezeQuantity";
+    CommandResult[CommandResult["FrozenPaneOverlap"] = 76] = "FrozenPaneOverlap";
+    CommandResult[CommandResult["ValuesNotChanged"] = 77] = "ValuesNotChanged";
+    CommandResult[CommandResult["InvalidFilterZone"] = 78] = "InvalidFilterZone";
+    CommandResult[CommandResult["FilterOverlap"] = 79] = "FilterOverlap";
+    CommandResult[CommandResult["FilterNotFound"] = 80] = "FilterNotFound";
+    CommandResult[CommandResult["MergeInFilter"] = 81] = "MergeInFilter";
+    CommandResult[CommandResult["NonContinuousTargets"] = 82] = "NonContinuousTargets";
+    CommandResult[CommandResult["DuplicatedFigureId"] = 83] = "DuplicatedFigureId";
+    CommandResult[CommandResult["InvalidSelectionStep"] = 84] = "InvalidSelectionStep";
+    CommandResult[CommandResult["DuplicatedChartId"] = 85] = "DuplicatedChartId";
+    CommandResult[CommandResult["ChartDoesNotExist"] = 86] = "ChartDoesNotExist";
+    CommandResult[CommandResult["InvalidHeaderIndex"] = 87] = "InvalidHeaderIndex";
+    CommandResult[CommandResult["InvalidQuantity"] = 88] = "InvalidQuantity";
+    CommandResult[CommandResult["MoreThanOneColumnSelected"] = 89] = "MoreThanOneColumnSelected";
+    CommandResult[CommandResult["EmptySplitSeparator"] = 90] = "EmptySplitSeparator";
+    CommandResult[CommandResult["SplitWillOverwriteContent"] = 91] = "SplitWillOverwriteContent";
+    CommandResult[CommandResult["NoSplitSeparatorInSelection"] = 92] = "NoSplitSeparatorInSelection";
+    CommandResult[CommandResult["NoActiveSheet"] = 93] = "NoActiveSheet";
+})(CommandResult || (CommandResult = {}));
+
+const borderStyles = ["thin", "medium", "thick", "dashed", "dotted"];
+function isMatrix(x) {
+    return Array.isArray(x) && Array.isArray(x[0]);
+}
+var DIRECTION;
+(function (DIRECTION) {
+    DIRECTION["UP"] = "up";
+    DIRECTION["DOWN"] = "down";
+    DIRECTION["LEFT"] = "left";
+    DIRECTION["RIGHT"] = "right";
+})(DIRECTION || (DIRECTION = {}));
+
+var LAYERS;
+(function (LAYERS) {
+    LAYERS[LAYERS["Background"] = 0] = "Background";
+    LAYERS[LAYERS["Highlights"] = 1] = "Highlights";
+    LAYERS[LAYERS["Clipboard"] = 2] = "Clipboard";
+    LAYERS[LAYERS["Search"] = 3] = "Search";
+    LAYERS[LAYERS["Chart"] = 4] = "Chart";
+    LAYERS[LAYERS["Autofill"] = 5] = "Autofill";
+    LAYERS[LAYERS["Selection"] = 6] = "Selection";
+    LAYERS[LAYERS["Headers"] = 7] = "Headers";
+})(LAYERS || (LAYERS = {}));
+
 // HELPERS
 const SORT_TYPES_ORDER = ["number", "string", "boolean", "undefined"];
 function assert(condition, message) {
@@ -3745,6 +4044,9 @@ function strictToNumber(value) {
     }
     return toNumber(value);
 }
+function toInteger(value) {
+    return Math.trunc(toNumber(value));
+}
 function strictToInteger(value) {
     return Math.trunc(strictToNumber(value));
 }
@@ -3847,16 +4149,25 @@ function visitNumbers(args, cb) {
 // -----------------------------------------------------------------------------
 // REDUCE FUNCTIONS
 // -----------------------------------------------------------------------------
-function reduceArgs(args, cellCb, dataCb, initialValue) {
+function reduceArgs(args, cellCb, dataCb, initialValue, dir = "rowFirst") {
     let val = initialValue;
     for (let arg of args) {
         if (Array.isArray(arg)) {
             // arg is ref to a Cell/Range
-            const lenRow = arg.length;
-            const lenCol = arg[0].length;
-            for (let y = 0; y < lenCol; y++) {
-                for (let x = 0; x < lenRow; x++) {
-                    val = cellCb(val, arg[x][y]);
+            const numberOfCols = arg.length;
+            const numberOfRows = arg[0].length;
+            if (dir === "rowFirst") {
+                for (let row = 0; row < numberOfRows; row++) {
+                    for (let col = 0; col < numberOfCols; col++) {
+                        val = cellCb(val, arg[col][row]);
+                    }
+                }
+            }
+            else {
+                for (let col = 0; col < numberOfCols; col++) {
+                    for (let row = 0; row < numberOfRows; row++) {
+                        val = cellCb(val, arg[col][row]);
+                    }
                 }
             }
         }
@@ -3867,8 +4178,8 @@ function reduceArgs(args, cellCb, dataCb, initialValue) {
     }
     return val;
 }
-function reduceAny(args, cb, initialValue) {
-    return reduceArgs(args, cb, cb, initialValue);
+function reduceAny(args, cb, initialValue, dir = "rowFirst") {
+    return reduceArgs(args, cb, cb, initialValue, dir);
 }
 function reduceNumbers(args, cb, initialValue) {
     return reduceArgs(args, (acc, ArgValue) => {
@@ -4245,290 +4556,57 @@ function compareCellValues(left, right) {
         }
     }
     return typeOrder;
-}
-
-var CellValueType;
-(function (CellValueType) {
-    CellValueType["boolean"] = "boolean";
-    CellValueType["number"] = "number";
-    CellValueType["text"] = "text";
-    CellValueType["empty"] = "empty";
-    CellValueType["error"] = "error";
-})(CellValueType || (CellValueType = {}));
-
-var ClipboardMIMEType;
-(function (ClipboardMIMEType) {
-    ClipboardMIMEType["PlainText"] = "text/plain";
-    ClipboardMIMEType["Html"] = "text/html";
-})(ClipboardMIMEType || (ClipboardMIMEType = {}));
-
-function isSheetDependent(cmd) {
-    return "sheetId" in cmd;
-}
-function isGridDependent(cmd) {
-    return "dimension" in cmd && "sheetId" in cmd;
 }
-function isTargetDependent(cmd) {
-    return "target" in cmd && "sheetId" in cmd;
-}
-function isRangeDependant(cmd) {
-    return "ranges" in cmd;
+function matrixMap(matrix, fn) {
+    let result = new Array(matrix.length);
+    for (let i = 0; i < matrix.length; i++) {
+        result[i] = new Array(matrix[i].length);
+        for (let j = 0; j < matrix[i].length; j++) {
+            result[i][j] = fn(matrix[i][j]);
+        }
+    }
+    return result;
 }
-function isPositionDependent(cmd) {
-    return "col" in cmd && "row" in cmd && "sheetId" in cmd;
+function toCellValueMatrix(values) {
+    return matrixMap(values, toCellValue);
 }
-const invalidateEvaluationCommands = new Set([
-    "RENAME_SHEET",
-    "DELETE_SHEET",
-    "CREATE_SHEET",
-    "ADD_COLUMNS_ROWS",
-    "REMOVE_COLUMNS_ROWS",
-    "UNDO",
-    "REDO",
-    "ADD_MERGE",
-]);
-const invalidateDependenciesCommands = new Set([
-    ...invalidateEvaluationCommands,
-    "MOVE_RANGES",
-]);
-const invalidateCFEvaluationCommands = new Set([
-    ...invalidateEvaluationCommands,
-    "DUPLICATE_SHEET",
-    "EVALUATE_CELLS",
-    "ADD_CONDITIONAL_FORMAT",
-    "REMOVE_CONDITIONAL_FORMAT",
-    "MOVE_CONDITIONAL_FORMAT",
-]);
-const readonlyAllowedCommands = new Set([
-    "START",
-    "ACTIVATE_SHEET",
-    "COPY",
-    "PREPARE_SELECTION_INPUT_EXPANSION",
-    "STOP_SELECTION_INPUT",
-    "RESIZE_SHEETVIEW",
-    "SET_VIEWPORT_OFFSET",
-    "SELECT_SEARCH_NEXT_MATCH",
-    "SELECT_SEARCH_PREVIOUS_MATCH",
-    "REFRESH_SEARCH",
-    "UPDATE_SEARCH",
-    "CLEAR_SEARCH",
-    "EVALUATE_CELLS",
-    "SET_CURRENT_CONTENT",
-    "SET_FORMULA_VISIBILITY",
-    "OPEN_CELL_POPOVER",
-    "CLOSE_CELL_POPOVER",
-    "UPDATE_FILTER",
-]);
-const coreTypes = new Set([
-    /** CELLS */
-    "UPDATE_CELL",
-    "UPDATE_CELL_POSITION",
-    "CLEAR_CELL",
-    "DELETE_CONTENT",
-    /** GRID SHAPE */
-    "ADD_COLUMNS_ROWS",
-    "REMOVE_COLUMNS_ROWS",
-    "RESIZE_COLUMNS_ROWS",
-    "HIDE_COLUMNS_ROWS",
-    "UNHIDE_COLUMNS_ROWS",
-    "SET_GRID_LINES_VISIBILITY",
-    "UNFREEZE_COLUMNS",
-    "UNFREEZE_ROWS",
-    "FREEZE_COLUMNS",
-    "FREEZE_ROWS",
-    "UNFREEZE_COLUMNS_ROWS",
-    /** MERGE */
-    "ADD_MERGE",
-    "REMOVE_MERGE",
-    /** SHEETS MANIPULATION */
-    "CREATE_SHEET",
-    "DELETE_SHEET",
-    "DUPLICATE_SHEET",
-    "MOVE_SHEET",
-    "RENAME_SHEET",
-    "HIDE_SHEET",
-    "SHOW_SHEET",
-    /** RANGES MANIPULATION */
-    "MOVE_RANGES",
-    /** CONDITIONAL FORMAT */
-    "ADD_CONDITIONAL_FORMAT",
-    "REMOVE_CONDITIONAL_FORMAT",
-    "MOVE_CONDITIONAL_FORMAT",
-    /** FIGURES */
-    "CREATE_FIGURE",
-    "DELETE_FIGURE",
-    "UPDATE_FIGURE",
-    /** FORMATTING */
-    "SET_FORMATTING",
-    "CLEAR_FORMATTING",
-    "SET_BORDER",
-    "SET_ZONE_BORDERS",
-    /** CHART */
-    "CREATE_CHART",
-    "UPDATE_CHART",
-    /** FILTERS */
-    "CREATE_FILTER_TABLE",
-    "REMOVE_FILTER_TABLE",
-    /** IMAGE */
-    "CREATE_IMAGE",
-]);
-function isCoreCommand(cmd) {
-    return coreTypes.has(cmd.type);
+function toCellValue(value) {
+    if (value === null || value === undefined)
+        return 0;
+    if (typeof value === "number")
+        return value;
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "boolean")
+        return value;
+    return String(value);
 }
-function canExecuteInReadonly(cmd) {
-    return readonlyAllowedCommands.has(cmd.type);
+function toMatrixArgValue(values) {
+    if (isMatrix(values))
+        return values;
+    return [[values === null ? 0 : values]];
 }
 /**
- * Holds the result of a command dispatch.
- * The command may have been successfully dispatched or cancelled
- * for one or more reasons.
+ * Flatten an array of items, where each item can be a single value or a 2D array, and apply the
+ * callback to each element.
+ *
+ * The 2D array are flattened row first.
  */
-class DispatchResult {
-    reasons;
-    constructor(results = []) {
-        if (!Array.isArray(results)) {
-            results = [results];
+function flattenRowFirst(items, callback) {
+    const flattened = [];
+    for (const item of items) {
+        if (!Array.isArray(item)) {
+            flattened.push(callback(item));
+            continue;
+        }
+        for (let row = 0; row < item[0].length; row++) {
+            for (let col = 0; col < item.length; col++) {
+                flattened.push(callback(item[col][row]));
+            }
         }
-        results = [...new Set(results)];
-        this.reasons = results.filter((result) => result !== 0 /* CommandResult.Success */);
-    }
-    /**
-     * Static helper which returns a successful DispatchResult
-     */
-    static get Success() {
-        return new DispatchResult();
-    }
-    get isSuccessful() {
-        return this.reasons.length === 0;
-    }
-    /**
-     * Check if the dispatch has been cancelled because of
-     * the given reason.
-     */
-    isCancelledBecause(reason) {
-        return this.reasons.includes(reason);
     }
-}
-var CommandResult;
-(function (CommandResult) {
-    CommandResult[CommandResult["Success"] = 0] = "Success";
-    CommandResult[CommandResult["CancelledForUnknownReason"] = 1] = "CancelledForUnknownReason";
-    CommandResult[CommandResult["WillRemoveExistingMerge"] = 2] = "WillRemoveExistingMerge";
-    CommandResult[CommandResult["MergeIsDestructive"] = 3] = "MergeIsDestructive";
-    CommandResult[CommandResult["CellIsMerged"] = 4] = "CellIsMerged";
-    CommandResult[CommandResult["InvalidTarget"] = 5] = "InvalidTarget";
-    CommandResult[CommandResult["EmptyUndoStack"] = 6] = "EmptyUndoStack";
-    CommandResult[CommandResult["EmptyRedoStack"] = 7] = "EmptyRedoStack";
-    CommandResult[CommandResult["NotEnoughElements"] = 8] = "NotEnoughElements";
-    CommandResult[CommandResult["NotEnoughSheets"] = 9] = "NotEnoughSheets";
-    CommandResult[CommandResult["MissingSheetName"] = 10] = "MissingSheetName";
-    CommandResult[CommandResult["DuplicatedSheetName"] = 11] = "DuplicatedSheetName";
-    CommandResult[CommandResult["DuplicatedSheetId"] = 12] = "DuplicatedSheetId";
-    CommandResult[CommandResult["ForbiddenCharactersInSheetName"] = 13] = "ForbiddenCharactersInSheetName";
-    CommandResult[CommandResult["WrongSheetMove"] = 14] = "WrongSheetMove";
-    CommandResult[CommandResult["WrongSheetPosition"] = 15] = "WrongSheetPosition";
-    CommandResult[CommandResult["InvalidAnchorZone"] = 16] = "InvalidAnchorZone";
-    CommandResult[CommandResult["SelectionOutOfBound"] = 17] = "SelectionOutOfBound";
-    CommandResult[CommandResult["TargetOutOfSheet"] = 18] = "TargetOutOfSheet";
-    CommandResult[CommandResult["WrongCutSelection"] = 19] = "WrongCutSelection";
-    CommandResult[CommandResult["WrongPasteSelection"] = 20] = "WrongPasteSelection";
-    CommandResult[CommandResult["WrongPasteOption"] = 21] = "WrongPasteOption";
-    CommandResult[CommandResult["WrongFigurePasteOption"] = 22] = "WrongFigurePasteOption";
-    CommandResult[CommandResult["EmptyClipboard"] = 23] = "EmptyClipboard";
-    CommandResult[CommandResult["EmptyRange"] = 24] = "EmptyRange";
-    CommandResult[CommandResult["InvalidRange"] = 25] = "InvalidRange";
-    CommandResult[CommandResult["InvalidZones"] = 26] = "InvalidZones";
-    CommandResult[CommandResult["InvalidSheetId"] = 27] = "InvalidSheetId";
-    CommandResult[CommandResult["InvalidFigureId"] = 28] = "InvalidFigureId";
-    CommandResult[CommandResult["InputAlreadyFocused"] = 29] = "InputAlreadyFocused";
-    CommandResult[CommandResult["MaximumRangesReached"] = 30] = "MaximumRangesReached";
-    CommandResult[CommandResult["InvalidChartDefinition"] = 31] = "InvalidChartDefinition";
-    CommandResult[CommandResult["InvalidDataSet"] = 32] = "InvalidDataSet";
-    CommandResult[CommandResult["InvalidLabelRange"] = 33] = "InvalidLabelRange";
-    CommandResult[CommandResult["InvalidScorecardKeyValue"] = 34] = "InvalidScorecardKeyValue";
-    CommandResult[CommandResult["InvalidScorecardBaseline"] = 35] = "InvalidScorecardBaseline";
-    CommandResult[CommandResult["InvalidGaugeDataRange"] = 36] = "InvalidGaugeDataRange";
-    CommandResult[CommandResult["EmptyGaugeRangeMin"] = 37] = "EmptyGaugeRangeMin";
-    CommandResult[CommandResult["GaugeRangeMinNaN"] = 38] = "GaugeRangeMinNaN";
-    CommandResult[CommandResult["EmptyGaugeRangeMax"] = 39] = "EmptyGaugeRangeMax";
-    CommandResult[CommandResult["GaugeRangeMaxNaN"] = 40] = "GaugeRangeMaxNaN";
-    CommandResult[CommandResult["GaugeRangeMinBiggerThanRangeMax"] = 41] = "GaugeRangeMinBiggerThanRangeMax";
-    CommandResult[CommandResult["GaugeLowerInflectionPointNaN"] = 42] = "GaugeLowerInflectionPointNaN";
-    CommandResult[CommandResult["GaugeUpperInflectionPointNaN"] = 43] = "GaugeUpperInflectionPointNaN";
-    CommandResult[CommandResult["GaugeLowerBiggerThanUpper"] = 44] = "GaugeLowerBiggerThanUpper";
-    CommandResult[CommandResult["InvalidAutofillSelection"] = 45] = "InvalidAutofillSelection";
-    CommandResult[CommandResult["WrongComposerSelection"] = 46] = "WrongComposerSelection";
-    CommandResult[CommandResult["MinBiggerThanMax"] = 47] = "MinBiggerThanMax";
-    CommandResult[CommandResult["LowerBiggerThanUpper"] = 48] = "LowerBiggerThanUpper";
-    CommandResult[CommandResult["MidBiggerThanMax"] = 49] = "MidBiggerThanMax";
-    CommandResult[CommandResult["MinBiggerThanMid"] = 50] = "MinBiggerThanMid";
-    CommandResult[CommandResult["FirstArgMissing"] = 51] = "FirstArgMissing";
-    CommandResult[CommandResult["SecondArgMissing"] = 52] = "SecondArgMissing";
-    CommandResult[CommandResult["MinNaN"] = 53] = "MinNaN";
-    CommandResult[CommandResult["MidNaN"] = 54] = "MidNaN";
-    CommandResult[CommandResult["MaxNaN"] = 55] = "MaxNaN";
-    CommandResult[CommandResult["ValueUpperInflectionNaN"] = 56] = "ValueUpperInflectionNaN";
-    CommandResult[CommandResult["ValueLowerInflectionNaN"] = 57] = "ValueLowerInflectionNaN";
-    CommandResult[CommandResult["MinInvalidFormula"] = 58] = "MinInvalidFormula";
-    CommandResult[CommandResult["MidInvalidFormula"] = 59] = "MidInvalidFormula";
-    CommandResult[CommandResult["MaxInvalidFormula"] = 60] = "MaxInvalidFormula";
-    CommandResult[CommandResult["ValueUpperInvalidFormula"] = 61] = "ValueUpperInvalidFormula";
-    CommandResult[CommandResult["ValueLowerInvalidFormula"] = 62] = "ValueLowerInvalidFormula";
-    CommandResult[CommandResult["InvalidSortZone"] = 63] = "InvalidSortZone";
-    CommandResult[CommandResult["WaitingSessionConfirmation"] = 64] = "WaitingSessionConfirmation";
-    CommandResult[CommandResult["MergeOverlap"] = 65] = "MergeOverlap";
-    CommandResult[CommandResult["TooManyHiddenElements"] = 66] = "TooManyHiddenElements";
-    CommandResult[CommandResult["Readonly"] = 67] = "Readonly";
-    CommandResult[CommandResult["InvalidViewportSize"] = 68] = "InvalidViewportSize";
-    CommandResult[CommandResult["InvalidScrollingDirection"] = 69] = "InvalidScrollingDirection";
-    CommandResult[CommandResult["FigureDoesNotExist"] = 70] = "FigureDoesNotExist";
-    CommandResult[CommandResult["InvalidConditionalFormatId"] = 71] = "InvalidConditionalFormatId";
-    CommandResult[CommandResult["InvalidCellPopover"] = 72] = "InvalidCellPopover";
-    CommandResult[CommandResult["EmptyTarget"] = 73] = "EmptyTarget";
-    CommandResult[CommandResult["InvalidFreezeQuantity"] = 74] = "InvalidFreezeQuantity";
-    CommandResult[CommandResult["FrozenPaneOverlap"] = 75] = "FrozenPaneOverlap";
-    CommandResult[CommandResult["ValuesNotChanged"] = 76] = "ValuesNotChanged";
-    CommandResult[CommandResult["InvalidFilterZone"] = 77] = "InvalidFilterZone";
-    CommandResult[CommandResult["FilterOverlap"] = 78] = "FilterOverlap";
-    CommandResult[CommandResult["FilterNotFound"] = 79] = "FilterNotFound";
-    CommandResult[CommandResult["MergeInFilter"] = 80] = "MergeInFilter";
-    CommandResult[CommandResult["NonContinuousTargets"] = 81] = "NonContinuousTargets";
-    CommandResult[CommandResult["DuplicatedFigureId"] = 82] = "DuplicatedFigureId";
-    CommandResult[CommandResult["InvalidSelectionStep"] = 83] = "InvalidSelectionStep";
-    CommandResult[CommandResult["DuplicatedChartId"] = 84] = "DuplicatedChartId";
-    CommandResult[CommandResult["ChartDoesNotExist"] = 85] = "ChartDoesNotExist";
-    CommandResult[CommandResult["InvalidHeaderIndex"] = 86] = "InvalidHeaderIndex";
-    CommandResult[CommandResult["InvalidQuantity"] = 87] = "InvalidQuantity";
-    CommandResult[CommandResult["MoreThanOneColumnSelected"] = 88] = "MoreThanOneColumnSelected";
-    CommandResult[CommandResult["EmptySplitSeparator"] = 89] = "EmptySplitSeparator";
-    CommandResult[CommandResult["SplitWillOverwriteContent"] = 90] = "SplitWillOverwriteContent";
-    CommandResult[CommandResult["NoSplitSeparatorInSelection"] = 91] = "NoSplitSeparatorInSelection";
-    CommandResult[CommandResult["NoActiveSheet"] = 92] = "NoActiveSheet";
-})(CommandResult || (CommandResult = {}));
-
-const borderStyles = ["thin", "medium", "thick", "dashed", "dotted"];
-function isMatrix(x) {
-    return Array.isArray(x) && Array.isArray(x[0]);
-}
-var DIRECTION;
-(function (DIRECTION) {
-    DIRECTION["UP"] = "up";
-    DIRECTION["DOWN"] = "down";
-    DIRECTION["LEFT"] = "left";
-    DIRECTION["RIGHT"] = "right";
-})(DIRECTION || (DIRECTION = {}));
-
-var LAYERS;
-(function (LAYERS) {
-    LAYERS[LAYERS["Background"] = 0] = "Background";
-    LAYERS[LAYERS["Highlights"] = 1] = "Highlights";
-    LAYERS[LAYERS["Clipboard"] = 2] = "Clipboard";
-    LAYERS[LAYERS["Search"] = 3] = "Search";
-    LAYERS[LAYERS["Chart"] = 4] = "Chart";
-    LAYERS[LAYERS["Autofill"] = 5] = "Autofill";
-    LAYERS[LAYERS["Selection"] = 6] = "Selection";
-    LAYERS[LAYERS["Headers"] = 7] = "Headers";
-})(LAYERS || (LAYERS = {}));
+    return flattened;
+}
 
 function evaluateLiteral(content, format) {
     return createEvaluatedCell(parseLiteral(content || ""), format);
@@ -5109,10 +5187,10 @@ class FilterMenu extends Component {
         this.state.selectedValue = value.string;
     }
     selectAll() {
-        this.state.values.forEach((value) => (value.checked = true));
+        this.displayedValues.forEach((value) => (value.checked = true));
     }
     clearAll() {
-        this.state.values.forEach((value) => (value.checked = false));
+        this.displayedValues.forEach((value) => (value.checked = false));
     }
     get filterTable() {
         const sheetId = this.env.model.getters.getActiveSheetId();
@@ -6575,11 +6653,11 @@ function checkDataset(definition) {
     if (definition.dataSets) {
         const invalidRanges = definition.dataSets.find((range) => !rangeReference.test(range)) !== undefined;
         if (invalidRanges) {
-            return 32 /* CommandResult.InvalidDataSet */;
+            return 33 /* CommandResult.InvalidDataSet */;
         }
         const zones = definition.dataSets.map(toUnboundedZone);
         if (zones.some((zone) => zone.top !== zone.bottom && isFullRow(zone))) {
-            return 32 /* CommandResult.InvalidDataSet */;
+            return 33 /* CommandResult.InvalidDataSet */;
         }
     }
     return 0 /* CommandResult.Success */;
@@ -6588,7 +6666,7 @@ function checkLabelRange(definition) {
     if (definition.labelRange) {
         const invalidLabels = !rangeReference.test(definition.labelRange || "");
         if (invalidLabels) {
-            return 33 /* CommandResult.InvalidLabelRange */;
+            return 34 /* CommandResult.InvalidLabelRange */;
         }
     }
     return 0 /* CommandResult.Success */;
@@ -6674,24 +6752,24 @@ function getChartPositionAtCenterOfViewport(getters, chartSize) {
 
 const CfTerms = {
     Errors: {
-        [25 /* CommandResult.InvalidRange */]: _lt("The range is invalid"),
-        [51 /* CommandResult.FirstArgMissing */]: _lt("The argument is missing. Please provide a value"),
-        [52 /* CommandResult.SecondArgMissing */]: _lt("The second argument is missing. Please provide a value"),
-        [53 /* CommandResult.MinNaN */]: _lt("The minpoint must be a number"),
-        [54 /* CommandResult.MidNaN */]: _lt("The midpoint must be a number"),
-        [55 /* CommandResult.MaxNaN */]: _lt("The maxpoint must be a number"),
-        [56 /* CommandResult.ValueUpperInflectionNaN */]: _lt("The first value must be a number"),
-        [57 /* CommandResult.ValueLowerInflectionNaN */]: _lt("The second value must be a number"),
-        [47 /* CommandResult.MinBiggerThanMax */]: _lt("Minimum must be smaller then Maximum"),
-        [50 /* CommandResult.MinBiggerThanMid */]: _lt("Minimum must be smaller then Midpoint"),
-        [49 /* CommandResult.MidBiggerThanMax */]: _lt("Midpoint must be smaller then Maximum"),
-        [48 /* CommandResult.LowerBiggerThanUpper */]: _lt("Lower inflection point must be smaller than upper inflection point"),
-        [58 /* CommandResult.MinInvalidFormula */]: _lt("Invalid Minpoint formula"),
-        [60 /* CommandResult.MaxInvalidFormula */]: _lt("Invalid Maxpoint formula"),
-        [59 /* CommandResult.MidInvalidFormula */]: _lt("Invalid Midpoint formula"),
-        [61 /* CommandResult.ValueUpperInvalidFormula */]: _lt("Invalid upper inflection point formula"),
-        [62 /* CommandResult.ValueLowerInvalidFormula */]: _lt("Invalid lower inflection point formula"),
-        [24 /* CommandResult.EmptyRange */]: _lt("A range needs to be defined"),
+        [26 /* CommandResult.InvalidRange */]: _lt("The range is invalid"),
+        [52 /* CommandResult.FirstArgMissing */]: _lt("The argument is missing. Please provide a value"),
+        [53 /* CommandResult.SecondArgMissing */]: _lt("The second argument is missing. Please provide a value"),
+        [54 /* CommandResult.MinNaN */]: _lt("The minpoint must be a number"),
+        [55 /* CommandResult.MidNaN */]: _lt("The midpoint must be a number"),
+        [56 /* CommandResult.MaxNaN */]: _lt("The maxpoint must be a number"),
+        [57 /* CommandResult.ValueUpperInflectionNaN */]: _lt("The first value must be a number"),
+        [58 /* CommandResult.ValueLowerInflectionNaN */]: _lt("The second value must be a number"),
+        [48 /* CommandResult.MinBiggerThanMax */]: _lt("Minimum must be smaller then Maximum"),
+        [51 /* CommandResult.MinBiggerThanMid */]: _lt("Minimum must be smaller then Midpoint"),
+        [50 /* CommandResult.MidBiggerThanMax */]: _lt("Midpoint must be smaller then Maximum"),
+        [49 /* CommandResult.LowerBiggerThanUpper */]: _lt("Lower inflection point must be smaller than upper inflection point"),
+        [59 /* CommandResult.MinInvalidFormula */]: _lt("Invalid Minpoint formula"),
+        [61 /* CommandResult.MaxInvalidFormula */]: _lt("Invalid Maxpoint formula"),
+        [60 /* CommandResult.MidInvalidFormula */]: _lt("Invalid Midpoint formula"),
+        [62 /* CommandResult.ValueUpperInvalidFormula */]: _lt("Invalid upper inflection point formula"),
+        [63 /* CommandResult.ValueLowerInvalidFormula */]: _lt("Invalid lower inflection point formula"),
+        [25 /* CommandResult.EmptyRange */]: _lt("A range needs to be defined"),
         Unexpected: _lt("The rule is invalid for an unknown reason"),
     },
     ColorScale: _lt("Color scale"),
@@ -6718,20 +6796,20 @@ const ChartTerms = {
     Errors: {
         Unexpected: _lt("The chart definition is invalid for an unknown reason"),
         // BASIC CHART ERRORS (LINE | BAR | PIE)
-        [32 /* CommandResult.InvalidDataSet */]: _lt("The dataset is invalid"),
-        [33 /* CommandResult.InvalidLabelRange */]: _lt("Labels are invalid"),
+        [33 /* CommandResult.InvalidDataSet */]: _lt("The dataset is invalid"),
+        [34 /* CommandResult.InvalidLabelRange */]: _lt("Labels are invalid"),
         // SCORECARD CHART ERRORS
-        [34 /* CommandResult.InvalidScorecardKeyValue */]: _lt("The key value is invalid"),
-        [35 /* CommandResult.InvalidScorecardBaseline */]: _lt("The baseline value is invalid"),
+        [35 /* CommandResult.InvalidScorecardKeyValue */]: _lt("The key value is invalid"),
+        [36 /* CommandResult.InvalidScorecardBaseline */]: _lt("The baseline value is invalid"),
         // GAUGE CHART ERRORS
-        [36 /* CommandResult.InvalidGaugeDataRange */]: _lt("The data range is invalid"),
-        [37 /* CommandResult.EmptyGaugeRangeMin */]: _lt("A minimum range limit value is needed"),
-        [38 /* CommandResult.GaugeRangeMinNaN */]: _lt("The minimum range limit value must be a number"),
-        [39 /* CommandResult.EmptyGaugeRangeMax */]: _lt("A maximum range limit value is needed"),
-        [40 /* CommandResult.GaugeRangeMaxNaN */]: _lt("The maximum range limit value must be a number"),
-        [41 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */]: _lt("Minimum range limit must be smaller than maximum range limit"),
-        [42 /* CommandResult.GaugeLowerInflectionPointNaN */]: _lt("The lower inflection point value must be a number"),
-        [43 /* CommandResult.GaugeUpperInflectionPointNaN */]: _lt("The upper inflection point value must be a number"),
+        [37 /* CommandResult.InvalidGaugeDataRange */]: _lt("The data range is invalid"),
+        [38 /* CommandResult.EmptyGaugeRangeMin */]: _lt("A minimum range limit value is needed"),
+        [39 /* CommandResult.GaugeRangeMinNaN */]: _lt("The minimum range limit value must be a number"),
+        [40 /* CommandResult.EmptyGaugeRangeMax */]: _lt("A maximum range limit value is needed"),
+        [41 /* CommandResult.GaugeRangeMaxNaN */]: _lt("The maximum range limit value must be a number"),
+        [42 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */]: _lt("Minimum range limit must be smaller than maximum range limit"),
+        [43 /* CommandResult.GaugeLowerInflectionPointNaN */]: _lt("The lower inflection point value must be a number"),
+        [44 /* CommandResult.GaugeUpperInflectionPointNaN */]: _lt("The upper inflection point value must be a number"),
     },
 };
 const CustomCurrencyTerms = {
@@ -6741,9 +6819,9 @@ const MergeErrorMessage = _lt("Merged cells are preventing this operation. Unmer
 const SplitToColumnsTerms = {
     Errors: {
         Unexpected: _lt("Cannot split the selection for an unknown reason"),
-        [91 /* CommandResult.NoSplitSeparatorInSelection */]: _lt("There is no match for the selected separator in the selection"),
-        [88 /* CommandResult.MoreThanOneColumnSelected */]: _lt("Only a selection from a single column can be split"),
-        [90 /* CommandResult.SplitWillOverwriteContent */]: _lt("Splitting will overwrite existing content"),
+        [92 /* CommandResult.NoSplitSeparatorInSelection */]: _lt("There is no match for the selected separator in the selection"),
+        [89 /* CommandResult.MoreThanOneColumnSelected */]: _lt("Only a selection from a single column can be split"),
+        [91 /* CommandResult.SplitWillOverwriteContent */]: _lt("Splitting will overwrite existing content"),
     },
 };
 
@@ -7147,7 +7225,7 @@ function createBarChartRuntime(chart, getters) {
 
 function isDataRangeValid(definition) {
     return definition.dataRange && !rangeReference.test(definition.dataRange)
-        ? 36 /* CommandResult.InvalidGaugeDataRange */
+        ? 37 /* CommandResult.InvalidGaugeDataRange */
         : 0 /* CommandResult.Success */;
 }
 function checkRangeLimits(check, batchValidations) {
@@ -7179,7 +7257,7 @@ function checkInflectionPointsValue(check, batchValidations) {
 function checkRangeMinBiggerThanRangeMax(definition) {
     if (definition.sectionRule) {
         if (Number(definition.sectionRule.rangeMin) >= Number(definition.sectionRule.rangeMax)) {
-            return 41 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */;
+            return 42 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */;
         }
     }
     return 0 /* CommandResult.Success */;
@@ -7188,9 +7266,9 @@ function checkEmpty(value, valueName) {
     if (value === "") {
         switch (valueName) {
             case "rangeMin":
-                return 37 /* CommandResult.EmptyGaugeRangeMin */;
+                return 38 /* CommandResult.EmptyGaugeRangeMin */;
             case "rangeMax":
-                return 39 /* CommandResult.EmptyGaugeRangeMax */;
+                return 40 /* CommandResult.EmptyGaugeRangeMax */;
         }
     }
     return 0 /* CommandResult.Success */;
@@ -7199,13 +7277,13 @@ function checkNaN(value, valueName) {
     if (isNaN(value)) {
         switch (valueName) {
             case "rangeMin":
-                return 38 /* CommandResult.GaugeRangeMinNaN */;
+                return 39 /* CommandResult.GaugeRangeMinNaN */;
             case "rangeMax":
-                return 40 /* CommandResult.GaugeRangeMaxNaN */;
+                return 41 /* CommandResult.GaugeRangeMaxNaN */;
             case "lowerInflectionPointValue":
-                return 42 /* CommandResult.GaugeLowerInflectionPointNaN */;
+                return 43 /* CommandResult.GaugeLowerInflectionPointNaN */;
             case "upperInflectionPointValue":
-                return 43 /* CommandResult.GaugeUpperInflectionPointNaN */;
+                return 44 /* CommandResult.GaugeUpperInflectionPointNaN */;
         }
     }
     return 0 /* CommandResult.Success */;
@@ -7981,12 +8059,12 @@ function createPieChartRuntime(chart, getters) {
 
 function checkKeyValue(definition) {
     return definition.keyValue && !rangeReference.test(definition.keyValue)
-        ? 34 /* CommandResult.InvalidScorecardKeyValue */
+        ? 35 /* CommandResult.InvalidScorecardKeyValue */
         : 0 /* CommandResult.Success */;
 }
 function checkBaseline(definition) {
     return definition.baseline && !rangeReference.test(definition.baseline)
-        ? 35 /* CommandResult.InvalidScorecardBaseline */
+        ? 36 /* CommandResult.InvalidScorecardBaseline */
         : 0 /* CommandResult.Success */;
 }
 class ScorecardChart extends AbstractChart {
@@ -8486,13 +8564,22 @@ function inverseUnhideColumnsRows(cmd) {
     ];
 }
 
+function interactiveCut(env) {
+    const result = env.model.dispatch("CUT");
+    if (!result.isSuccessful) {
+        if (result.isCancelledBecause(20 /* CommandResult.WrongCutSelection */)) {
+            env.raiseError(_lt("This operation is not allowed with multiple selections."));
+        }
+    }
+}
+
 const AddMergeInteractiveContent = {
     MergeIsDestructive: _lt("Merging these cells will only preserve the top-leftmost value. Merge anyway?"),
     MergeInFilter: _lt("You can't merge cells inside of an existing filter."),
 };
 function interactiveAddMerge(env, sheetId, target) {
     const result = env.model.dispatch("ADD_MERGE", { sheetId, target });
-    if (result.isCancelledBecause(80 /* CommandResult.MergeInFilter */)) {
+    if (result.isCancelledBecause(81 /* CommandResult.MergeInFilter */)) {
         env.raiseError(AddMergeInteractiveContent.MergeInFilter);
     }
     else if (result.isCancelledBecause(3 /* CommandResult.MergeIsDestructive */)) {
@@ -8502,279 +8589,6 @@ function interactiveAddMerge(env, sheetId, target) {
     }
 }
 
-/**
- * Create a function used to create a Chart based on the definition
- */
-function chartFactory(getters) {
-    const builders = chartRegistry.getAll().sort((a, b) => a.sequence - b.sequence);
-    function createChart(id, definition, sheetId) {
-        const builder = builders.find((builder) => builder.match(definition.type));
-        if (!builder) {
-            throw new Error(`No builder for this chart: ${definition.type}`);
-        }
-        return builder.createChart(definition, sheetId, getters);
-    }
-    return createChart;
-}
-/**
- * Create a function used to create a Chart Runtime based on the chart class
- * instance
- */
-function chartRuntimeFactory(getters) {
-    const builders = chartRegistry.getAll().sort((a, b) => a.sequence - b.sequence);
-    function createRuntimeChart(chart) {
-        const builder = builders.find((builder) => builder.match(chart.type));
-        if (!builder) {
-            throw new Error("No runtime builder for this chart.");
-        }
-        return builder.getChartRuntime(chart, getters);
-    }
-    return createRuntimeChart;
-}
-/**
- * Validate the chart definition given in arguments
- */
-function validateChartDefinition(validator, definition) {
-    const validators = chartRegistry.getAll().find((validator) => validator.match(definition.type));
-    if (!validators) {
-        throw new Error("Unknown chart type.");
-    }
-    return validators.validateChartDefinition(validator, definition);
-}
-/**
- * Get a new chart definition transformed with the executed command. This
- * functions will be called during operational transform process
- */
-function transformDefinition(definition, executed) {
-    const transformation = chartRegistry.getAll().find((factory) => factory.match(definition.type));
-    if (!transformation) {
-        throw new Error("Unknown chart type.");
-    }
-    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.
- *
- * It will also try to find labels and datasets in the range, and try to find title for the datasets.
- *
- * The type of chart will be :
- * - If the zone is a single non-empty cell, returns a scorecard
- * - If the all the labels are numbers/date, returns a line chart
- * - Else returns a bar chart
- */
-function getSmartChartDefinition(zone, getters) {
-    let dataSetZone = zone;
-    if (zone.left !== zone.right) {
-        dataSetZone = { ...zone, left: zone.left + 1 };
-    }
-    const dataSets = [zoneToXc(dataSetZone)];
-    const sheetId = getters.getActiveSheetId();
-    const topLeftCell = getters.getCell({ sheetId, col: zone.left, row: zone.top });
-    if (getZoneArea(zone) === 1 && topLeftCell?.content) {
-        return {
-            type: "scorecard",
-            title: "",
-            background: topLeftCell.style?.fillColor || undefined,
-            keyValue: zoneToXc(zone),
-            baselineMode: DEFAULT_SCORECARD_BASELINE_MODE,
-            baselineColorUp: DEFAULT_SCORECARD_BASELINE_COLOR_UP,
-            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 (zone.left !== zone.right) {
-        labelRangeXc = zoneToXc({
-            ...zone,
-            right: zone.left,
-        });
-    }
-    // Only display legend for several datasets.
-    const newLegendPos = dataSetZone.right === dataSetZone.left ? "none" : "top";
-    const labelRange = labelRangeXc ? getters.getRangeFromSheetXC(sheetId, labelRangeXc) : undefined;
-    if (canChartParseLabels(labelRange, getters)) {
-        return {
-            title,
-            dataSets,
-            labelsAsText: false,
-            stacked: false,
-            aggregated: false,
-            labelRange: labelRangeXc,
-            type: "line",
-            dataSetsHaveTitle,
-            verticalAxisPosition: "left",
-            legendPosition: newLegendPos,
-        };
-    }
-    return {
-        title,
-        dataSets,
-        labelRange: labelRangeXc,
-        type: "bar",
-        stacked: false,
-        aggregated: false,
-        dataSetsHaveTitle,
-        verticalAxisPosition: "left",
-        legendPosition: newLegendPos,
-    };
-}
-
-const SORT_TYPES = [
-    CellValueType.number,
-    CellValueType.error,
-    CellValueType.text,
-    CellValueType.boolean,
-];
-function sortCells(cells, sortDirection, emptyCellAsZero) {
-    const cellsWithIndex = cells.map((cell, index) => ({
-        index,
-        type: cell.type,
-        value: cell.value,
-    }));
-    let emptyCells = cellsWithIndex.filter((x) => x.type === CellValueType.empty);
-    let nonEmptyCells = cellsWithIndex.filter((x) => x.type !== CellValueType.empty);
-    if (emptyCellAsZero) {
-        nonEmptyCells.push(...emptyCells.map((emptyCell) => ({ ...emptyCell, type: CellValueType.number, value: 0 })));
-        emptyCells = [];
-    }
-    const inverse = sortDirection === "descending" ? -1 : 1;
-    return nonEmptyCells
-        .sort((left, right) => {
-        let typeOrder = SORT_TYPES.indexOf(left.type) - SORT_TYPES.indexOf(right.type);
-        if (typeOrder === 0) {
-            if (left.type === CellValueType.text || left.type === CellValueType.error) {
-                typeOrder = left.value.localeCompare(right.value);
-            }
-            else
-                typeOrder = left.value - right.value;
-        }
-        return inverse * typeOrder;
-    })
-        .concat(emptyCells);
-}
-function interactiveSortSelection(env, sheetId, anchor, zone, sortDirection) {
-    let result = DispatchResult.Success;
-    //several columns => bypass the contiguity check
-    let multiColumns = zone.right > zone.left;
-    if (env.model.getters.doesIntersectMerge(sheetId, zone)) {
-        multiColumns = false;
-        let table;
-        for (let row = zone.top; row <= zone.bottom; row++) {
-            table = [];
-            for (let col = zone.left; col <= zone.right; col++) {
-                let merge = env.model.getters.getMerge({ sheetId, col, row });
-                if (merge && !table.includes(merge.id.toString())) {
-                    table.push(merge.id.toString());
-                }
-            }
-            if (table.length >= 2) {
-                multiColumns = true;
-                break;
-            }
-        }
-    }
-    const { col, row } = anchor;
-    if (multiColumns) {
-        result = env.model.dispatch("SORT_CELLS", { sheetId, col, row, zone, sortDirection });
-    }
-    else {
-        // check contiguity
-        const contiguousZone = env.model.getters.getContiguousZone(sheetId, zone);
-        if (isEqual(contiguousZone, zone)) {
-            // merge as it is
-            result = env.model.dispatch("SORT_CELLS", {
-                sheetId,
-                col,
-                row,
-                zone,
-                sortDirection,
-            });
-        }
-        else {
-            env.askConfirmation(_lt("We found data next to your selection. Since this data was not selected, it will not be sorted. Do you want to extend your selection?"), () => {
-                zone = contiguousZone;
-                result = env.model.dispatch("SORT_CELLS", {
-                    sheetId,
-                    col,
-                    row,
-                    zone,
-                    sortDirection,
-                });
-            }, () => {
-                result = env.model.dispatch("SORT_CELLS", {
-                    sheetId,
-                    col,
-                    row,
-                    zone,
-                    sortDirection,
-                });
-            });
-        }
-    }
-    if (result.isCancelledBecause(63 /* CommandResult.InvalidSortZone */)) {
-        const { col, row } = anchor;
-        env.model.selection.selectZone({ cell: { col, row }, zone });
-        env.raiseError(_lt("Cannot sort. To sort, select only cells or only merges that have the same size."));
-    }
-}
-
-function interactiveCut(env) {
-    const result = env.model.dispatch("CUT");
-    if (!result.isSuccessful) {
-        if (result.isCancelledBecause(19 /* CommandResult.WrongCutSelection */)) {
-            env.raiseError(_lt("This operation is not allowed with multiple selections."));
-        }
-    }
-}
-
-const AddFilterInteractiveContent = {
-    filterOverlap: _lt("You cannot create overlapping filters."),
-    nonContinuousTargets: _lt("A filter can only be created on a continuous selection."),
-    mergeInFilter: _lt("You can't create a filter over a range that contains a merge."),
-};
-function interactiveAddFilter(env, sheetId, target) {
-    const result = env.model.dispatch("CREATE_FILTER_TABLE", { target, sheetId });
-    if (result.isCancelledBecause(78 /* CommandResult.FilterOverlap */)) {
-        env.raiseError(AddFilterInteractiveContent.filterOverlap);
-    }
-    else if (result.isCancelledBecause(80 /* CommandResult.MergeInFilter */)) {
-        env.raiseError(AddFilterInteractiveContent.mergeInFilter);
-    }
-    else if (result.isCancelledBecause(81 /* CommandResult.NonContinuousTargets */)) {
-        env.raiseError(AddFilterInteractiveContent.nonContinuousTargets);
-    }
-}
-
 const PasteInteractiveContent = {
     wrongPasteSelection: _lt("This operation is not allowed with multiple selections."),
     willRemoveExistingMerge: _lt("This operation is not possible due to a merge. Please remove the merges first than try again."),
@@ -8783,16 +8597,16 @@ const PasteInteractiveContent = {
 };
 function handlePasteResult(env, result) {
     if (!result.isSuccessful) {
-        if (result.reasons.includes(20 /* CommandResult.WrongPasteSelection */)) {
+        if (result.reasons.includes(21 /* CommandResult.WrongPasteSelection */)) {
             env.raiseError(PasteInteractiveContent.wrongPasteSelection);
         }
         else if (result.reasons.includes(2 /* CommandResult.WillRemoveExistingMerge */)) {
             env.raiseError(PasteInteractiveContent.willRemoveExistingMerge);
         }
-        else if (result.reasons.includes(22 /* CommandResult.WrongFigurePasteOption */)) {
+        else if (result.reasons.includes(23 /* CommandResult.WrongFigurePasteOption */)) {
             env.raiseError(PasteInteractiveContent.wrongFigurePasteOption);
         }
-        else if (result.reasons.includes(75 /* CommandResult.FrozenPaneOverlap */)) {
+        else if (result.reasons.includes(76 /* CommandResult.FrozenPaneOverlap */)) {
             env.raiseError(PasteInteractiveContent.frozenPaneOverlap);
         }
     }
@@ -8801,34 +8615,161 @@ function interactivePaste(env, target, pasteOption) {
     const result = env.model.dispatch("PASTE", { target, pasteOption });
     handlePasteResult(env, result);
 }
-function interactivePasteFromOS(env, target, text) {
-    const result = env.model.dispatch("PASTE_FROM_OS_CLIPBOARD", { target, text });
+function interactivePasteFromOS(env, target, text, pasteOption) {
+    const result = env.model.dispatch("PASTE_FROM_OS_CLIPBOARD", { target, text, pasteOption });
     handlePasteResult(env, result);
 }
 
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-function getColumnsNumber(env) {
-    const activeCols = env.model.getters.getActiveCols();
-    if (activeCols.size) {
-        return activeCols.size;
+/**
+ * Create a function used to create a Chart based on the definition
+ */
+function chartFactory(getters) {
+    const builders = chartRegistry.getAll().sort((a, b) => a.sequence - b.sequence);
+    function createChart(id, definition, sheetId) {
+        const builder = builders.find((builder) => builder.match(definition.type));
+        if (!builder) {
+            throw new Error(`No builder for this chart: ${definition.type}`);
+        }
+        return builder.createChart(definition, sheetId, getters);
     }
-    else {
-        const zone = env.model.getters.getSelectedZones()[0];
-        return zone.right - zone.left + 1;
+    return createChart;
+}
+/**
+ * Create a function used to create a Chart Runtime based on the chart class
+ * instance
+ */
+function chartRuntimeFactory(getters) {
+    const builders = chartRegistry.getAll().sort((a, b) => a.sequence - b.sequence);
+    function createRuntimeChart(chart) {
+        const builder = builders.find((builder) => builder.match(chart.type));
+        if (!builder) {
+            throw new Error("No runtime builder for this chart.");
+        }
+        return builder.getChartRuntime(chart, getters);
     }
+    return createRuntimeChart;
 }
-function getRowsNumber(env) {
-    const activeRows = env.model.getters.getActiveRows();
-    if (activeRows.size) {
-        return activeRows.size;
+/**
+ * Validate the chart definition given in arguments
+ */
+function validateChartDefinition(validator, definition) {
+    const validators = chartRegistry.getAll().find((validator) => validator.match(definition.type));
+    if (!validators) {
+        throw new Error("Unknown chart type.");
     }
-    else {
-        const zone = env.model.getters.getSelectedZones()[0];
-        return zone.bottom - zone.top + 1;
+    return validators.validateChartDefinition(validator, definition);
+}
+/**
+ * Get a new chart definition transformed with the executed command. This
+ * functions will be called during operational transform process
+ */
+function transformDefinition(definition, executed) {
+    const transformation = chartRegistry.getAll().find((factory) => factory.match(definition.type));
+    if (!transformation) {
+        throw new Error("Unknown chart type.");
+    }
+    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.
+ *
+ * It will also try to find labels and datasets in the range, and try to find title for the datasets.
+ *
+ * The type of chart will be :
+ * - If the zone is a single non-empty cell, returns a scorecard
+ * - If the all the labels are numbers/date, returns a line chart
+ * - Else returns a bar chart
+ */
+function getSmartChartDefinition(zone, getters) {
+    let dataSetZone = zone;
+    if (zone.left !== zone.right) {
+        dataSetZone = { ...zone, left: zone.left + 1 };
+    }
+    const dataSets = [zoneToXc(dataSetZone)];
+    const sheetId = getters.getActiveSheetId();
+    const topLeftCell = getters.getCell({ sheetId, col: zone.left, row: zone.top });
+    if (getZoneArea(zone) === 1 && topLeftCell?.content) {
+        return {
+            type: "scorecard",
+            title: "",
+            background: topLeftCell.style?.fillColor || undefined,
+            keyValue: zoneToXc(zone),
+            baselineMode: DEFAULT_SCORECARD_BASELINE_MODE,
+            baselineColorUp: DEFAULT_SCORECARD_BASELINE_COLOR_UP,
+            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 (zone.left !== zone.right) {
+        labelRangeXc = zoneToXc({
+            ...zone,
+            right: zone.left,
+        });
+    }
+    // Only display legend for several datasets.
+    const newLegendPos = dataSetZone.right === dataSetZone.left ? "none" : "top";
+    const labelRange = labelRangeXc ? getters.getRangeFromSheetXC(sheetId, labelRangeXc) : undefined;
+    if (canChartParseLabels(labelRange, getters)) {
+        return {
+            title,
+            dataSets,
+            labelsAsText: false,
+            stacked: false,
+            aggregated: false,
+            labelRange: labelRangeXc,
+            type: "line",
+            dataSetsHaveTitle,
+            verticalAxisPosition: "left",
+            legendPosition: newLegendPos,
+        };
+    }
+    return {
+        title,
+        dataSets,
+        labelRange: labelRangeXc,
+        type: "bar",
+        stacked: false,
+        aggregated: false,
+        dataSetsHaveTitle,
+        verticalAxisPosition: "left",
+        legendPosition: newLegendPos,
+    };
+}
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
 function setFormatter(env, format) {
     env.model.dispatch("SET_FORMATTING", {
         sheetId: env.model.getters.getActiveSheetId(),
@@ -8846,16 +8787,6 @@ function setStyle(env, style) {
 //------------------------------------------------------------------------------
 // Simple actions
 //------------------------------------------------------------------------------
-const UNDO_ACTION = (env) => env.model.dispatch("REQUEST_UNDO");
-const REDO_ACTION = (env) => env.model.dispatch("REQUEST_REDO");
-const COPY_ACTION = async (env) => {
-    env.model.dispatch("COPY");
-    await env.clipboard.write(env.model.getters.getClipboardContent());
-};
-const CUT_ACTION = async (env) => {
-    interactiveCut(env);
-    await env.clipboard.write(env.model.getters.getClipboardContent());
-};
 const PASTE_ACTION = async (env) => paste$1(env);
 const PASTE_VALUE_ACTION = async (env) => paste$1(env, "onlyValue");
 async function paste$1(env, pasteOption) {
@@ -8865,11 +8796,14 @@ async function paste$1(env, pasteOption) {
         case "ok":
             const target = env.model.getters.getSelectedZones();
             if (osClipboard && osClipboard.content !== spreadsheetClipboard) {
-                interactivePasteFromOS(env, target, osClipboard.content);
+                interactivePasteFromOS(env, target, osClipboard.content, pasteOption);
             }
             else {
                 interactivePaste(env, target, pasteOption);
             }
+            if (env.model.getters.isCutOperation() && pasteOption !== "onlyValue") {
+                await env.clipboard.write({ [ClipboardMIMEType.PlainText]: "" });
+            }
             break;
         case "notImplemented":
             env.raiseError(_lt("Pasting from the context menu is not supported in this browser. Use keyboard shortcuts ctrl+c / ctrl+v instead."));
@@ -8879,22 +8813,7 @@ async function paste$1(env, pasteOption) {
             break;
     }
 }
-const PASTE_FORMAT_ACTION = (env) => interactivePaste(env, env.model.getters.getSelectedZones(), "onlyFormat");
-const DELETE_CONTENT_ACTION = (env) => env.model.dispatch("DELETE_CONTENT", {
-    sheetId: env.model.getters.getActiveSheetId(),
-    target: env.model.getters.getSelectedZones(),
-});
-const SET_FORMULA_VISIBILITY_ACTION = (env) => env.model.dispatch("SET_FORMULA_VISIBILITY", { show: !env.model.getters.shouldShowFormulas() });
-const SET_GRID_LINES_VISIBILITY_ACTION = (env) => {
-    const sheetId = env.model.getters.getActiveSheetId();
-    env.model.dispatch("SET_GRID_LINES_VISIBILITY", {
-        sheetId,
-        areGridLinesVisible: !env.model.getters.getGridLinesVisibility(sheetId),
-    });
-};
-const IS_NOT_CUT_OPERATION = (env) => {
-    return !env.model.getters.isCutOperation();
-};
+const PASTE_FORMAT_ACTION = (env) => paste$1(env, "onlyFormat");
 //------------------------------------------------------------------------------
 // Grid manipulations
 //------------------------------------------------------------------------------
@@ -9036,48 +8955,6 @@ const NOT_ALL_VISIBLE_COLS_SELECTED = (env) => {
     const selectedCols = env.model.getters.getElementsFromSelection("COL");
     return env.model.getters.canRemoveHeaders(sheetId, "COL", selectedCols);
 };
-const INSERT_CELL_SHIFT_DOWN = (env) => {
-    const zone = env.model.getters.getSelectedZone();
-    const result = env.model.dispatch("INSERT_CELL", { zone, shiftDimension: "ROW" });
-    handlePasteResult(env, result);
-};
-const INSERT_CELL_SHIFT_RIGHT = (env) => {
-    const zone = env.model.getters.getSelectedZone();
-    const result = env.model.dispatch("INSERT_CELL", { zone, shiftDimension: "COL" });
-    handlePasteResult(env, result);
-};
-const DELETE_CELL_SHIFT_UP = (env) => {
-    const zone = env.model.getters.getSelectedZone();
-    const result = env.model.dispatch("DELETE_CELL", { zone, shiftDimension: "ROW" });
-    handlePasteResult(env, result);
-};
-const DELETE_CELL_SHIFT_LEFT = (env) => {
-    const zone = env.model.getters.getSelectedZone();
-    const result = env.model.dispatch("DELETE_CELL", { zone, shiftDimension: "COL" });
-    handlePasteResult(env, result);
-};
-const MENU_INSERT_ROWS_NAME = (env) => {
-    const number = getRowsNumber(env);
-    return number === 1 ? _lt("Insert row") : _lt("Insert %s rows", number.toString());
-};
-const MENU_INSERT_ROWS_BEFORE_NAME = (env) => {
-    const number = getRowsNumber(env);
-    if (number === 1) {
-        return _lt("Row above");
-    }
-    return _lt("%s Rows above", number.toString());
-};
-const ROW_INSERT_ROWS_BEFORE_NAME = (env) => {
-    const number = getRowsNumber(env);
-    return number === 1 ? _lt("Insert row above") : _lt("Insert %s rows above", number.toString());
-};
-const CELL_INSERT_ROWS_BEFORE_NAME = (env) => {
-    const number = getRowsNumber(env);
-    if (number === 1) {
-        return _lt("Insert row");
-    }
-    return _lt("Insert %s rows", number.toString());
-};
 const INSERT_ROWS_BEFORE_ACTION = (env) => {
     const activeRows = env.model.getters.getActiveRows();
     let row;
@@ -9099,17 +8976,6 @@ const INSERT_ROWS_BEFORE_ACTION = (env) => {
         dimension: "ROW",
     });
 };
-const MENU_INSERT_ROWS_AFTER_NAME = (env) => {
-    const number = getRowsNumber(env);
-    if (number === 1) {
-        return _lt("Row below");
-    }
-    return _lt("%s Rows below", number.toString());
-};
-const ROW_INSERT_ROWS_AFTER_NAME = (env) => {
-    const number = getRowsNumber(env);
-    return number === 1 ? _lt("Insert row below") : _lt("Insert %s rows below", number.toString());
-};
 const INSERT_ROWS_AFTER_ACTION = (env) => {
     const activeRows = env.model.getters.getActiveRows();
     let row;
@@ -9131,30 +8997,6 @@ const INSERT_ROWS_AFTER_ACTION = (env) => {
         dimension: "ROW",
     });
 };
-const MENU_INSERT_COLUMNS_BEFORE_NAME = (env) => {
-    const number = getColumnsNumber(env);
-    if (number === 1) {
-        return _lt("Column left");
-    }
-    return _lt("%s Columns left", number.toString());
-};
-const MENU_INSERT_COLUMNS_NAME = (env) => {
-    const number = getColumnsNumber(env);
-    return number === 1 ? _lt("Insert column") : _lt("Insert %s columns", number.toString());
-};
-const COLUMN_INSERT_COLUMNS_BEFORE_NAME = (env) => {
-    const number = getColumnsNumber(env);
-    return number === 1
-        ? _lt("Insert column left")
-        : _lt("Insert %s columns left", number.toString());
-};
-const CELL_INSERT_COLUMNS_BEFORE_NAME = (env) => {
-    const number = getColumnsNumber(env);
-    if (number === 1) {
-        return _lt("Insert column");
-    }
-    return _lt("Insert %s columns", number.toString());
-};
 const INSERT_COLUMNS_BEFORE_ACTION = (env) => {
     const activeCols = env.model.getters.getActiveCols();
     let column;
@@ -9176,19 +9018,6 @@ const INSERT_COLUMNS_BEFORE_ACTION = (env) => {
         quantity,
     });
 };
-const MENU_INSERT_COLUMNS_AFTER_NAME = (env) => {
-    const number = getColumnsNumber(env);
-    if (number === 1) {
-        return _lt("Column right");
-    }
-    return _lt("%s Columns right", number.toString());
-};
-const COLUMN_INSERT_COLUMNS_AFTER_NAME = (env) => {
-    const number = getColumnsNumber(env);
-    return number === 1
-        ? _lt("Insert column right")
-        : _lt("Insert %s columns right", number.toString());
-};
 const INSERT_COLUMNS_AFTER_ACTION = (env) => {
     const activeCols = env.model.getters.getActiveCols();
     let column;
@@ -9224,30 +9053,6 @@ const HIDE_COLUMNS_NAME = (env) => {
         return _lt("Hide columns");
     }
 };
-const HIDE_COLUMNS_ACTION = (env) => {
-    const columns = env.model.getters.getElementsFromSelection("COL");
-    env.model.dispatch("HIDE_COLUMNS_ROWS", {
-        sheetId: env.model.getters.getActiveSheetId(),
-        dimension: "COL",
-        elements: columns,
-    });
-};
-const UNHIDE_ALL_COLUMNS_ACTION = (env) => {
-    const sheetId = env.model.getters.getActiveSheetId();
-    env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
-        sheetId,
-        dimension: "COL",
-        elements: Array.from(Array(env.model.getters.getNumberCols(sheetId)).keys()),
-    });
-};
-const UNHIDE_COLUMNS_ACTION = (env) => {
-    const columns = env.model.getters.getElementsFromSelection("COL");
-    env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
-        sheetId: env.model.getters.getActiveSheetId(),
-        dimension: "COL",
-        elements: columns,
-    });
-};
 const HIDE_ROWS_NAME = (env) => {
     const rows = env.model.getters.getElementsFromSelection("ROW");
     let first = rows[0];
@@ -9262,40 +9067,6 @@ const HIDE_ROWS_NAME = (env) => {
         return _lt("Hide rows");
     }
 };
-const HIDE_ROWS_ACTION = (env) => {
-    const rows = env.model.getters.getElementsFromSelection("ROW");
-    env.model.dispatch("HIDE_COLUMNS_ROWS", {
-        sheetId: env.model.getters.getActiveSheetId(),
-        dimension: "ROW",
-        elements: rows,
-    });
-};
-const UNHIDE_ALL_ROWS_ACTION = (env) => {
-    const sheetId = env.model.getters.getActiveSheetId();
-    env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
-        sheetId,
-        dimension: "ROW",
-        elements: Array.from(Array(env.model.getters.getNumberRows(sheetId)).keys()),
-    });
-};
-const UNHIDE_ROWS_ACTION = (env) => {
-    const columns = env.model.getters.getElementsFromSelection("ROW");
-    env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
-        sheetId: env.model.getters.getActiveSheetId(),
-        dimension: "ROW",
-        elements: columns,
-    });
-};
-//------------------------------------------------------------------------------
-// Sheets
-//------------------------------------------------------------------------------
-const CREATE_SHEET_ACTION = (env) => {
-    const activeSheetId = env.model.getters.getActiveSheetId();
-    const position = env.model.getters.getSheetIds().indexOf(activeSheetId) + 1;
-    const sheetId = env.model.uuidGenerator.uuidv4();
-    env.model.dispatch("CREATE_SHEET", { sheetId, position });
-    env.model.dispatch("ACTIVATE_SHEET", { sheetIdFrom: activeSheetId, sheetIdTo: sheetId });
-};
 //------------------------------------------------------------------------------
 // Charts
 //------------------------------------------------------------------------------
@@ -9354,37 +9125,13 @@ const CREATE_IMAGE = async (env) => {
 //------------------------------------------------------------------------------
 // Style/Format
 //------------------------------------------------------------------------------
-const FORMAT_AUTOMATIC_ACTION = (env) => setFormatter(env, "");
-const FORMAT_NUMBER_ACTION = (env) => setFormatter(env, "#,##0.00");
 const FORMAT_PERCENT_ACTION = (env) => setFormatter(env, "0.00%");
-const FORMAT_CURRENCY_ACTION = (env) => setFormatter(env, "[$$]#,##0.00");
-const FORMAT_CURRENCY_ROUNDED_ACTION = (env) => setFormatter(env, "[$$]#,##0");
-const FORMAT_DATE_ACTION = (env) => setFormatter(env, "m/d/yyyy");
-const FORMAT_TIME_ACTION = (env) => setFormatter(env, "hh:mm:ss a");
-const FORMAT_DATE_TIME_ACTION = (env) => setFormatter(env, "m/d/yyyy hh:mm:ss");
-const FORMAT_DURATION_ACTION = (env) => setFormatter(env, "hhhh:mm:ss");
-const FORMAT_BOLD_ACTION = (env) => setStyle(env, { bold: !env.model.getters.getCurrentStyle().bold });
-const FORMAT_ITALIC_ACTION = (env) => setStyle(env, { italic: !env.model.getters.getCurrentStyle().italic });
-const FORMAT_STRIKETHROUGH_ACTION = (env) => setStyle(env, { strikethrough: !env.model.getters.getCurrentStyle().strikethrough });
-const FORMAT_UNDERLINE_ACTION = (env) => setStyle(env, { underline: !env.model.getters.getCurrentStyle().underline });
-const FORMAT_CLEARFORMAT_ACTION = (env) => {
-    env.model.dispatch("CLEAR_FORMATTING", {
-        sheetId: env.model.getters.getActiveSheetId(),
-        target: env.model.getters.getSelectedZones(),
-    });
-};
 //------------------------------------------------------------------------------
 // Side panel
 //------------------------------------------------------------------------------
 const OPEN_CF_SIDEPANEL_ACTION = (env) => {
     env.openSidePanel("ConditionalFormatting", { selection: env.model.getters.getSelectedZones() });
 };
-const OPEN_FAR_SIDEPANEL_ACTION = (env) => {
-    env.openSidePanel("FindAndReplace", {});
-};
-const OPEN_CUSTOM_CURRENCY_SIDEPANEL_ACTION = (env) => {
-    env.openSidePanel("CustomCurrency", {});
-};
 const INSERT_LINK = (env) => {
     let { col, row } = env.model.getters.getActivePosition();
     env.model.dispatch("OPEN_CELL_POPOVER", { col, row, popoverType: "LinkEditor" });
@@ -9392,40 +9139,14 @@ const INSERT_LINK = (env) => {
 //------------------------------------------------------------------------------
 // Filters action
 //------------------------------------------------------------------------------
-const FILTERS_CREATE_FILTER_TABLE = (env) => {
-    const sheetId = env.model.getters.getActiveSheetId();
-    const selection = env.model.getters.getSelection().zones;
-    interactiveAddFilter(env, sheetId, selection);
-};
-const FILTERS_REMOVE_FILTER_TABLE = (env) => {
-    const sheetId = env.model.getters.getActiveSheetId();
-    env.model.dispatch("REMOVE_FILTER_TABLE", {
-        sheetId,
-        target: env.model.getters.getSelectedZones(),
-    });
-};
 const SELECTION_CONTAINS_FILTER = (env) => {
     const sheetId = env.model.getters.getActiveSheetId();
     const selectedZones = env.model.getters.getSelectedZones();
     return env.model.getters.doesZonesContainFilter(sheetId, selectedZones);
 };
-const SELECTION_IS_CONTINUOUS = (env) => {
-    const selectedZones = env.model.getters.getSelectedZones();
-    return areZonesContinuous(...selectedZones);
-};
 //------------------------------------------------------------------------------
 // Sorting action
 //------------------------------------------------------------------------------
-const SORT_CELLS_ASCENDING = (env) => {
-    const { anchor, zones } = env.model.getters.getSelection();
-    const sheetId = env.model.getters.getActiveSheetId();
-    interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "ascending");
-};
-const SORT_CELLS_DESCENDING = (env) => {
-    const { anchor, zones } = env.model.getters.getSelection();
-    const sheetId = env.model.getters.getActiveSheetId();
-    interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "descending");
-};
 const IS_ONLY_ONE_RANGE = (env) => {
     return env.model.getters.getSelectedZones().length === 1;
 };
@@ -9433,14 +9154,14 @@ const IS_ONLY_ONE_RANGE = (env) => {
 const undo = {
     name: _lt("Undo"),
     description: "Ctrl+Z",
-    execute: UNDO_ACTION,
+    execute: (env) => env.model.dispatch("REQUEST_UNDO"),
     isEnabled: (env) => env.model.getters.canUndo(),
     icon: "o-spreadsheet-Icon.UNDO",
 };
 const redo = {
     name: _lt("Redo"),
     description: "Ctrl+Y",
-    execute: REDO_ACTION,
+    execute: (env) => env.model.dispatch("REQUEST_REDO"),
     isEnabled: (env) => env.model.getters.canRedo(),
     icon: "o-spreadsheet-Icon.REDO",
 };
@@ -9448,13 +9169,19 @@ const copy = {
     name: _lt("Copy"),
     description: "Ctrl+C",
     isReadonlyAllowed: true,
-    execute: COPY_ACTION,
+    execute: async (env) => {
+        env.model.dispatch("COPY");
+        await env.clipboard.write(env.model.getters.getClipboardContent());
+    },
     icon: "o-spreadsheet-Icon.COPY",
 };
 const cut = {
     name: _lt("Cut"),
     description: "Ctrl+X",
-    execute: CUT_ACTION,
+    execute: async (env) => {
+        interactiveCut(env);
+        await env.clipboard.write(env.model.getters.getClipboardContent());
+    },
     icon: "o-spreadsheet-Icon.CUT",
 };
 const paste = {
@@ -9465,7 +9192,9 @@ const paste = {
 };
 const pasteSpecial = {
     name: _lt("Paste special"),
-    isVisible: IS_NOT_CUT_OPERATION,
+    isVisible: (env) => {
+        return !env.model.getters.isCutOperation();
+    },
     icon: "o-spreadsheet-Icon.PASTE",
 };
 const pasteSpecialValue = {
@@ -9481,12 +9210,17 @@ const findAndReplace = {
     name: _lt("Find and replace"),
     description: "Ctrl+H",
     isReadonlyAllowed: true,
-    execute: OPEN_FAR_SIDEPANEL_ACTION,
+    execute: (env) => {
+        env.openSidePanel("FindAndReplace", {});
+    },
     icon: "o-spreadsheet-Icon.FIND_AND_REPLACE",
 };
 const deleteValues = {
     name: _lt("Delete values"),
-    execute: DELETE_CONTENT_ACTION,
+    execute: (env) => env.model.dispatch("DELETE_CONTENT", {
+        sheetId: env.model.getters.getActiveSheetId(),
+        target: env.model.getters.getSelectedZones(),
+    }),
 };
 const deleteRows = {
     name: REMOVE_ROWS_NAME,
@@ -9520,11 +9254,19 @@ const deleteCells = {
 };
 const deleteCellShiftUp = {
     name: _lt("Delete cell and shift up"),
-    execute: DELETE_CELL_SHIFT_UP,
+    execute: (env) => {
+        const zone = env.model.getters.getSelectedZone();
+        const result = env.model.dispatch("DELETE_CELL", { zone, shiftDimension: "ROW" });
+        handlePasteResult(env, result);
+    },
 };
 const deleteCellShiftLeft = {
     name: _lt("Delete cell and shift left"),
-    execute: DELETE_CELL_SHIFT_LEFT,
+    execute: (env) => {
+        const zone = env.model.getters.getSelectedZone();
+        const result = env.model.dispatch("DELETE_CELL", { zone, shiftDimension: "COL" });
+        handlePasteResult(env, result);
+    },
 };
 const mergeCells = {
     name: _lt("Merge cells"),
@@ -9609,9 +9351,9 @@ const ARG_TYPES = [
     "META",
 ];
 function arg(definition, description = "") {
-    return makeArg(`${definition} ${description}`);
+    return makeArg(definition, description);
 }
-function makeArg(str) {
+function makeArg(str, description) {
     let parts = str.match(ARG_REGEXP);
     let name = parts[1].trim();
     let types = [];
@@ -9641,7 +9383,6 @@ function makeArg(str) {
             defaultValue = param.trim().slice(8);
         }
     }
-    let description = parts[3].trim();
     const result = {
         name,
         description,
@@ -9755,6 +9496,740 @@ function validateArguments(args) {
     }
 }
 
+function assertSingleColOrRow(errorStr, arg) {
+    assert(() => arg.length === 1 || arg[0].length === 1, errorStr);
+}
+function assertSameDimensions(errorStr, ...args) {
+    if (args.every(isMatrix)) {
+        const cols = args[0].length;
+        const rows = args[0][0].length;
+        for (const arg of args) {
+            assert(() => arg.length === cols && arg[0].length === rows, errorStr);
+        }
+        return;
+    }
+    if (args.some((arg) => Array.isArray(arg) && (arg.length !== 1 || arg[0].length !== 1))) {
+        throw new Error(errorStr);
+    }
+}
+function assertPositive(errorStr, arg) {
+    assert(() => arg > 0, errorStr);
+}
+function assertSquareMatrix(errorStr, arg) {
+    assert(() => arg.length === arg[0].length, errorStr);
+}
+function isNumberMatrix(arg) {
+    return arg.every((row) => row.every((val) => typeof val === "number"));
+}
+
+function getUnitMatrix(n) {
+    const matrix = Array(n);
+    for (let i = 0; i < n; i++) {
+        matrix[i] = Array(n).fill(0);
+        matrix[i][i] = 1;
+    }
+    return matrix;
+}
+/**
+ * Invert a matrix and compute its determinant using Gaussian Elimination.
+ *
+ * The Matrix should be a square matrix, and should be indexed [col][row] instead of the
+ * standard mathematical indexing [row][col].
+ */
+function invertMatrix(M) {
+    // Use Gaussian Elimination to calculate the inverse:
+    // (1) 'augment' the matrix (left) by the identity (on the right)
+    // (2) Turn the matrix on the left into the identity using elementary row operations
+    // (3) The matrix on the right becomes the inverse (was the identity matrix)
+    //
+    // There are 3 elementary row operations:
+    // (a) Swap 2 rows. This multiply the determinant by -1.
+    // (b) Multiply a row by a scalar. This multiply the determinant by that scalar.
+    // (c) Add to a row a multiple of another row. This does not change the determinant.
+    if (M.length !== M[0].length) {
+        throw new Error(`Function [[FUNCTION_NAME]] invert matrix error, only square matrices are invertible`);
+    }
+    let determinant = 1;
+    const dim = M.length;
+    const I = getUnitMatrix(dim);
+    const C = M.map((row) => row.slice());
+    // Perform elementary row operations
+    for (let pivot = 0; pivot < dim; pivot++) {
+        let diagonalElement = C[pivot][pivot];
+        // if we have a 0 on the diagonal we'll need to swap with a lower row
+        if (diagonalElement == 0) {
+            //look through every row below the i'th row
+            for (let row = pivot + 1; row < dim; row++) {
+                //if the ii'th row has a non-0 in the i'th col, swap it with that row
+                if (C[pivot][row] != 0) {
+                    swapMatrixRows(C, pivot, row);
+                    swapMatrixRows(I, pivot, row);
+                    determinant *= -1;
+                    break;
+                }
+            }
+            diagonalElement = C[pivot][pivot];
+            //if it's still 0, matrix isn't invertible
+            if (diagonalElement === 0) {
+                return { determinant: 0 };
+            }
+        }
+        // Scale this row down by e (so we have a 1 on the diagonal)
+        for (let col = 0; col < dim; col++) {
+            C[col][pivot] = C[col][pivot] / diagonalElement;
+            I[col][pivot] = I[col][pivot] / diagonalElement;
+        }
+        determinant *= diagonalElement;
+        // Subtract a multiple of the current row from ALL of
+        // the other rows so that there will be 0's in this column in the
+        // rows above and below this one
+        for (let row = 0; row < dim; row++) {
+            if (row == pivot) {
+                continue;
+            }
+            // We want to change this element to 0
+            const e = C[pivot][row];
+            // Subtract (the row above(or below) scaled by e) from (the
+            // current row) but start at the i'th column and assume all the
+            // stuff left of diagonal is 0 (which it should be if we made this
+            // algorithm correctly)
+            for (let col = 0; col < dim; col++) {
+                C[col][row] -= e * C[col][pivot];
+                I[col][row] -= e * I[col][pivot];
+            }
+        }
+    }
+    // We've done all operations, C should be the identity matrix I should be the inverse
+    return { inverted: I, determinant };
+}
+function swapMatrixRows(matrix, row1, row2) {
+    for (let i = 0; i < matrix.length; i++) {
+        const tmp = matrix[i][row1];
+        matrix[i][row1] = matrix[i][row2];
+        matrix[i][row2] = tmp;
+    }
+}
+/**
+ * Matrix multiplication of 2 matrices.
+ * ex: matrix1 : n x l, matrix2 : m x n => result : m x l
+ *
+ * Note: we use indexing [col][row] instead of the standard mathematical notation [row][col]
+ */
+function multiplyMatrices(matrix1, matrix2) {
+    if (matrix1.length !== matrix2[0].length) {
+        throw new Error(_lt("Cannot multiply matrices : incompatible matrices size."));
+    }
+    const rowsM1 = matrix1[0].length;
+    const colsM2 = matrix2.length;
+    const n = matrix1.length;
+    const result = Array(colsM2);
+    for (let col = 0; col < colsM2; col++) {
+        result[col] = Array(rowsM1);
+        for (let row = 0; row < rowsM1; row++) {
+            let sum = 0;
+            for (let k = 0; k < n; k++) {
+                sum += matrix1[k][row] * matrix2[col][k];
+            }
+            result[col][row] = sum;
+        }
+    }
+    return result;
+}
+
+// -----------------------------------------------------------------------------
+// ARRAY_CONSTRAIN
+// -----------------------------------------------------------------------------
+const ARRAY_CONSTRAIN = {
+    description: _lt("Returns a result array constrained to a specific width and height."),
+    args: [
+        arg("input_range (any, range<any>)", _lt("The range to constrain.")),
+        arg("rows (number)", _lt("The number of rows in the constrained array.")),
+        arg("columns (number)", _lt("The number of columns in the constrained array.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (array, rows, columns) {
+        const _array = toMatrixArgValue(array);
+        const _rowsArg = toInteger(rows);
+        const _columnsArg = toInteger(columns);
+        assertPositive(_lt("The rows argument (%s) must be strictly positive.", _rowsArg.toString()), _rowsArg);
+        assertPositive(_lt("The columns argument (%s) must be strictly positive.", _rowsArg.toString()), _columnsArg);
+        const _rows = Math.min(_rowsArg, _array[0].length);
+        const _columns = Math.min(_columnsArg, _array.length);
+        const result = Array(_columns);
+        for (let col = 0; col < _columns; col++) {
+            result[col] = Array(_rows);
+            for (let row = 0; row < _rows; row++) {
+                result[col][row] = toCellValue(_array[col][row]);
+            }
+        }
+        return result;
+    },
+    isExported: false,
+};
+// -----------------------------------------------------------------------------
+// CHOOSECOLS
+// -----------------------------------------------------------------------------
+const CHOOSECOLS = {
+    description: _lt("Creates a new array from the selected columns in the existing range."),
+    args: [
+        arg("array (any, range<any>)", _lt("The array that contains the columns to be returned.")),
+        arg("col_num (number, range<number>)", _lt("The first column index of the columns to be returned.")),
+        arg("col_num2 (number, range<number>, repeating)", _lt("The columns indexes of the columns to be returned.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (array, ...columns) {
+        const _array = toMatrixArgValue(array);
+        const _columns = flattenRowFirst(columns, toInteger);
+        assert(() => _columns.every((col) => col > 0 && col <= _array.length), _lt("The columns arguments must be between 1 and %s (got %s).", _array.length.toString(), (_columns.find((col) => col <= 0 || col > _array.length) || 0).toString()));
+        const result = Array(_columns.length);
+        for (let i = 0; i < _columns.length; i++) {
+            const colIndex = _columns[i] - 1; // -1 because columns arguments are 1-indexed
+            result[i] = _array[colIndex];
+        }
+        return toCellValueMatrix(result);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// CHOOSEROWS
+// -----------------------------------------------------------------------------
+const CHOOSEROWS = {
+    description: _lt("Creates a new array from the selected rows in the existing range."),
+    args: [
+        arg("array (any, range<any>)", _lt("The array that contains the rows to be returned.")),
+        arg("row_num (number, range<number>)", _lt("The first row index of the rows to be returned.")),
+        arg("row_num2 (number, range<number>, repeating)", _lt("The rows indexes of the rows to be returned.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (array, ...rows) {
+        const _array = toMatrixArgValue(array);
+        const _rows = flattenRowFirst(rows, toInteger);
+        assert(() => _rows.every((row) => row > 0 && row <= _array[0].length), _lt("The rows arguments must be between 1 and %s (got %s).", _array[0].length.toString(), (_rows.find((row) => row <= 0 || row > _array[0].length) || 0).toString()));
+        const result = Array(_array.length);
+        for (let col = 0; col < _array.length; col++) {
+            result[col] = Array(_rows.length);
+            for (let row = 0; row < _rows.length; row++) {
+                const rowIndex = _rows[row] - 1; // -1 because rows arguments are 1-indexed
+                result[col][row] = toCellValue(_array[col][rowIndex]);
+            }
+        }
+        return result;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// EXPAND
+// -----------------------------------------------------------------------------
+const EXPAND = {
+    description: _lt("Expands or pads an array to specified row and column dimensions."),
+    args: [
+        arg("array (any, range<any>)", _lt("The array to expand.")),
+        arg("rows (number)", _lt("The number of rows in the expanded array. If missing, rows will not be expanded.")),
+        arg("columns (number, optional)", _lt("The number of columns in the expanded array. If missing, columns will not be expanded.")),
+        arg("pad_with (any, default=0)", _lt("The value with which to pad.")), // @compatibility: on Excel, pad with #N/A
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (array, rows, columns, padWith = 0) {
+        const _array = toMatrixArgValue(array);
+        const _rows = toInteger(rows);
+        const _columns = columns !== undefined ? toInteger(columns) : _array.length;
+        const _padWith = padWith !== undefined && padWith !== null ? padWith : 0; // TODO : Replace with #N/A errors once it's supported
+        assert(() => _rows >= _array[0].length, _lt("The rows arguments (%s) must be greater or equal than the number of rows of the array.", _rows.toString()));
+        assert(() => _columns >= _array.length, _lt("The columns arguments (%s) must be greater or equal than the number of columns of the array.", _columns.toString()));
+        const result = [];
+        for (let col = 0; col < _columns; col++) {
+            result[col] = [];
+            for (let row = 0; row < _rows; row++) {
+                if (col >= _array.length || row >= _array[col].length) {
+                    result[col][row] = _padWith;
+                }
+                else {
+                    result[col][row] = _array[col][row] ?? 0;
+                }
+            }
+        }
+        return result;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// FLATTEN
+// -----------------------------------------------------------------------------
+const FLATTEN = {
+    description: _lt("Flattens all the values from one or more ranges into a single column."),
+    args: [
+        arg("range (any, range<any>)", _lt("The first range to flatten.")),
+        arg("range2 (any, range<any>, repeating)", _lt("Additional ranges to flatten.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    compute: function (...ranges) {
+        return [flattenRowFirst(ranges, toCellValue)];
+    },
+    isExported: false,
+};
+// -----------------------------------------------------------------------------
+// FREQUENCY
+// -----------------------------------------------------------------------------
+const FREQUENCY = {
+    description: _lt("Calculates the frequency distribution of a range."),
+    args: [
+        arg("data (range<number>)", _lt("The array of ranges containing the values to be counted.")),
+        arg("classes (number, range<number>)", _lt("The range containing the set of classes.")),
+    ],
+    returns: ["RANGE<NUMBER>"],
+    compute: function (data, classes) {
+        const _data = flattenRowFirst([data], (val) => val).filter((val) => typeof val === "number");
+        const _classes = flattenRowFirst([classes], (val) => val).filter((val) => typeof val === "number");
+        /**
+         * Returns the frequency distribution of the data in the classes, ie. the number of elements in the range
+         * between each classes.
+         *
+         * For example:
+         * - data = [1, 3, 2, 5, 4]
+         * - classes = [3, 5, 1]
+         *
+         * The result will be:
+         * - 2 ==> number of elements 1 > el >= 3
+         * - 2 ==> number of elements 3 > el >= 5
+         * - 1 ==> number of elements <= 1
+         * - 0 ==> number of elements > 5
+         *
+         * @compatibility: GSheet sort the input classes. We do the implemntation of Excel, where we kee the classes unsorted.
+         */
+        const sortedClasses = _classes
+            .map((value, index) => ({ initialIndex: index, value, count: 0 }))
+            .sort((a, b) => a.value - b.value);
+        sortedClasses.push({ initialIndex: sortedClasses.length, value: Infinity, count: 0 });
+        const sortedData = _data.sort((a, b) => a - b);
+        let index = 0;
+        for (const val of sortedData) {
+            while (val > sortedClasses[index].value && index < sortedClasses.length - 1) {
+                index++;
+            }
+            sortedClasses[index].count++;
+        }
+        const result = sortedClasses
+            .sort((a, b) => a.initialIndex - b.initialIndex)
+            .map((val) => val.count);
+        return [result];
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// HSTACK
+// -----------------------------------------------------------------------------
+const HSTACK = {
+    description: _lt("Appends ranges horizontally and in sequence to return a larger array."),
+    args: [
+        arg("range1 (any, range<any>)", _lt("The first range to be appended.")),
+        arg("range2 (any, range<any>, repeating)", _lt("Additional ranges to add to range1.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (...ranges) {
+        const _ranges = ranges.map((range) => toMatrixArgValue(range));
+        const nRows = Math.max(..._ranges.map((range) => range[0].length));
+        const colArray = [];
+        for (const range of _ranges) {
+            for (const col of range) {
+                //TODO: fill with #N/A for unavailable values instead of zeroes
+                const paddedCol = Array(nRows).fill(0);
+                for (let i = 0; i < col.length; i++) {
+                    paddedCol[i] = toCellValue(col[i]);
+                }
+                colArray.push(paddedCol);
+            }
+        }
+        return colArray;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// MDETERM
+// -----------------------------------------------------------------------------
+const MDETERM = {
+    description: _lt("Returns the matrix determinant of a square matrix."),
+    args: [
+        arg("square_matrix (number, range<number>)", _lt("An range with an equal number of rows and columns representing a matrix whose determinant will be calculated.")),
+    ],
+    returns: ["NUMBER"],
+    compute: function (matrix) {
+        const _matrix = toMatrixArgValue(matrix);
+        assertSquareMatrix(_lt("The argument square_matrix must have the same number of columns and rows."), _matrix);
+        if (!isNumberMatrix(_matrix)) {
+            throw new Error(_lt("The argument square_matrix must be a matrix of numbers."));
+        }
+        const { determinant } = invertMatrix(_matrix);
+        return determinant;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// MINVERSE
+// -----------------------------------------------------------------------------
+const MINVERSE = {
+    description: _lt("Returns the multiplicative inverse of a square matrix."),
+    args: [
+        arg("square_matrix (number, range<number>)", _lt("An range with an equal number of rows and columns representing a matrix whose multiplicative inverse will be calculated.")),
+    ],
+    returns: ["RANGE<NUMBER>"],
+    compute: function (matrix) {
+        const _matrix = toMatrixArgValue(matrix);
+        assertSquareMatrix(_lt("The argument square_matrix must have the same number of columns and rows."), _matrix);
+        if (!isNumberMatrix(_matrix)) {
+            throw new Error(_lt("The argument square_matrix must be a matrix of numbers."));
+        }
+        const { inverted } = invertMatrix(_matrix);
+        if (!inverted) {
+            throw new Error(_lt("The matrix is not invertible."));
+        }
+        return inverted;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// MMULT
+// -----------------------------------------------------------------------------
+const MMULT = {
+    description: _lt("Calculates the matrix product of two matrices."),
+    args: [
+        arg("matrix1 (number, range<number>)", _lt("The first matrix in the matrix multiplication operation.")),
+        arg("matrix2 (number, range<number>)", _lt("The second matrix in the matrix multiplication operation.")),
+    ],
+    returns: ["RANGE<NUMBER>"],
+    compute: function (matrix1, matrix2) {
+        const _matrix1 = toMatrixArgValue(matrix1);
+        const _matrix2 = toMatrixArgValue(matrix2);
+        assert(() => _matrix1.length === _matrix2[0].length, _lt("In [[FUNCTION_NAME]], the number of columns of the first matrix (%s) must be equal to the \
+        number of rows of the second matrix (%s).", _matrix1.length.toString(), _matrix2[0].length.toString()));
+        if (!isNumberMatrix(_matrix1) || !isNumberMatrix(_matrix2)) {
+            throw new Error(_lt("The arguments matrix1 and matrix2 must be matrices of numbers."));
+        }
+        return multiplyMatrices(_matrix1, _matrix2);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// SUMPRODUCT
+// -----------------------------------------------------------------------------
+const SUMPRODUCT = {
+    description: _lt("Calculates the sum of the products of corresponding entries in equal-sized ranges."),
+    args: [
+        arg("range1 (number, range<number>)", _lt("The first range whose entries will be multiplied with corresponding entries in the other ranges.")),
+        arg("range2 (number, range<number>, repeating)", _lt("The other range whose entries will be multiplied with corresponding entries in the other ranges.")),
+    ],
+    returns: ["NUMBER"],
+    compute: function (...args) {
+        assertSameDimensions(_lt("All the ranges must have the same dimensions."), ...args);
+        const _args = args.map(toMatrixArgValue);
+        let result = 0;
+        for (let i = 0; i < _args[0].length; i++) {
+            for (let j = 0; j < _args[0][i].length; j++) {
+                if (!_args.every((range) => typeof range[i][j] === "number")) {
+                    continue;
+                }
+                let product = 1;
+                for (const range of _args) {
+                    product *= toNumber(range[i][j]);
+                }
+                result += product;
+            }
+        }
+        return result;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// SUMX2MY2
+// -----------------------------------------------------------------------------
+/**
+ * Return the sum of the callback applied to each pair of values in the two arrays.
+ *
+ * Ignore the pairs X,Y where one of the value isn't a number. Throw an error if no pair of numbers is found.
+ */
+function getSumXAndY(arrayX, arrayY, cb) {
+    assertSameDimensions("The arguments array_x and array_y must have the same dimensions.", arrayX, arrayY);
+    const _arrayX = toMatrixArgValue(arrayX);
+    const _arrayY = toMatrixArgValue(arrayY);
+    let validPairFound = false;
+    let result = 0;
+    for (const i in _arrayX) {
+        for (const j in _arrayX[i]) {
+            const arrayXValue = _arrayX[i][j];
+            const arrayYValue = _arrayY[i][j];
+            if (typeof arrayXValue !== "number" || typeof arrayYValue !== "number") {
+                continue;
+            }
+            validPairFound = true;
+            result += cb(arrayXValue, arrayYValue);
+        }
+    }
+    if (!validPairFound) {
+        throw new Error("The arguments array_x and array_y must contain at least one pair of numbers.");
+    }
+    return result;
+}
+const SUMX2MY2 = {
+    description: _lt("Calculates the sum of the difference of the squares of the values in two array."),
+    args: [
+        arg("array_x (number, range<number>)", _lt("The array or range of values whose squares will be reduced by the squares of corresponding entries in array_y and added together.")),
+        arg("array_y (number, range<number>)", _lt("The array or range of values whose squares will be subtracted from the squares of corresponding entries in array_x and added together.")),
+    ],
+    returns: ["NUMBER"],
+    compute: function (arrayX, arrayY) {
+        return getSumXAndY(arrayX, arrayY, (x, y) => x ** 2 - y ** 2);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// SUMX2PY2
+// -----------------------------------------------------------------------------
+const SUMX2PY2 = {
+    description: _lt("Calculates the sum of the sum of the squares of the values in two array."),
+    args: [
+        arg("array_x (number, range<number>)", _lt("The array or range of values whose squares will be added to the squares of corresponding entries in array_y and added together.")),
+        arg("array_y (number, range<number>)", _lt("The array or range of values whose squares will be added to the squares of corresponding entries in array_x and added together.")),
+    ],
+    returns: ["NUMBER"],
+    compute: function (arrayX, arrayY) {
+        return getSumXAndY(arrayX, arrayY, (x, y) => x ** 2 + y ** 2);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// SUMXMY2
+// -----------------------------------------------------------------------------
+const SUMXMY2 = {
+    description: _lt("Calculates the sum of squares of the differences of values in two array."),
+    args: [
+        arg("array_x (number, range<number>)", _lt("The array or range of values that will be reduced by corresponding entries in array_y, squared, and added together.")),
+        arg("array_y (number, range<number>)", _lt("The array or range of values that will be subtracted from corresponding entries in array_x, the result squared, and all such results added together.")),
+    ],
+    returns: ["NUMBER"],
+    compute: function (arrayX, arrayY) {
+        return getSumXAndY(arrayX, arrayY, (x, y) => (x - y) ** 2);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// TOCOL
+// -----------------------------------------------------------------------------
+const TO_COL_ROW_DEFAULT_IGNORE = 0;
+const TO_COL_ROW_DEFAULT_SCAN = false;
+const TO_COL_ROW_ARGS = [
+    arg("array (any, range<any>)", _lt("The array which will be transformed.")),
+    arg(`ignore (number, default=${TO_COL_ROW_DEFAULT_IGNORE})`, _lt("The control to ignore blanks and errors. 0 (default) is to keep all values, 1 is to ignore blanks, 2 is to ignore errors, and 3 is to ignore blanks and errors.")),
+    arg(`scan_by_column (number, default=${TO_COL_ROW_DEFAULT_SCAN})`, _lt("Whether the array should be scanned by column. True scans the array by column and false (default) \
+      scans the array by row.")),
+];
+const TOCOL = {
+    description: _lt("Transforms a range of cells into a single column."),
+    args: TO_COL_ROW_ARGS,
+    returns: ["RANGE<ANY>"],
+    //TODO compute format
+    compute: function (array, ignore = TO_COL_ROW_DEFAULT_IGNORE, scanByColumn = TO_COL_ROW_DEFAULT_SCAN) {
+        const _array = toMatrixArgValue(array);
+        const _ignore = toInteger(ignore);
+        const _scanByColumn = toBoolean(scanByColumn);
+        assert(() => _ignore >= 0 && _ignore <= 3, _lt("Argument ignore must be between 0 and 3"));
+        const mappedFn = (acc, item) => {
+            // TODO : implement ignore value 2 (ignore error) & 3 (ignore blanks and errors) once we can have errors in
+            // the array w/o crashing
+            if ((_ignore === 1 || _ignore === 3) && (item === undefined || item === null)) {
+                return acc;
+            }
+            acc.push(toCellValue(item));
+            return acc;
+        };
+        const result = reduceAny([_array], mappedFn, [], _scanByColumn ? "colFirst" : "rowFirst");
+        if (result.length === 0) {
+            throw new NotAvailableError(_lt("No results for the given arguments of TOCOL."));
+        }
+        return [result];
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// TOROW
+// -----------------------------------------------------------------------------
+const TOROW = {
+    description: _lt("Transforms a range of cells into a single row."),
+    args: TO_COL_ROW_ARGS,
+    returns: ["RANGE<ANY>"],
+    //TODO compute format
+    compute: function (array, ignore = TO_COL_ROW_DEFAULT_IGNORE, scanByColumn = TO_COL_ROW_DEFAULT_SCAN) {
+        const _array = toMatrixArgValue(array);
+        const _ignore = toInteger(ignore);
+        const _scanByColumn = toBoolean(scanByColumn);
+        assert(() => _ignore >= 0 && _ignore <= 3, _lt("Argument ignore must be between 0 and 3"));
+        const mappedFn = (acc, item) => {
+            // TODO : implement ignore value 2 (ignore error) & 3 (ignore blanks and errors) once we can have errors in
+            // the array w/o crashing
+            if ((_ignore === 1 || _ignore === 3) && (item === undefined || item === null)) {
+                return acc;
+            }
+            acc.push([toCellValue(item)]);
+            return acc;
+        };
+        const result = reduceAny([_array], mappedFn, [], _scanByColumn ? "colFirst" : "rowFirst");
+        if (result.length === 0 || result[0].length === 0) {
+            throw new NotAvailableError(_lt("No results for the given arguments of TOROW."));
+        }
+        return result;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// TRANSPOSE
+// -----------------------------------------------------------------------------
+const TRANSPOSE = {
+    description: _lt("Transposes the rows and columns of a range."),
+    args: [arg("range (any, range<any>)", _lt("The range to be transposed."))],
+    returns: ["RANGE<ANY>"],
+    computeFormat: (values) => {
+        if (!values.format) {
+            return undefined;
+        }
+        if (!isMatrix(values.format)) {
+            return values.format;
+        }
+        return transpose2dArray(values.format);
+    },
+    compute: function (values) {
+        const _values = toMatrixArgValue(values);
+        return transpose2dArray(_values, toCellValue);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// VSTACK
+// -----------------------------------------------------------------------------
+const VSTACK = {
+    description: _lt("Appends ranges vertically and in sequence to return a larger array."),
+    args: [
+        arg("range1 (any, range<any>)", _lt("The first range to be appended.")),
+        arg("range2 (any, range<any>, repeating)", _lt("Additional ranges to add to range1.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (...ranges) {
+        const _ranges = ranges.map((range) => toMatrixArgValue(range));
+        const nCols = Math.max(..._ranges.map((range) => range.length));
+        const nRows = _ranges.reduce((acc, range) => acc + range[0].length, 0);
+        const result = Array(nCols)
+            .fill([])
+            .map(() => Array(nRows).fill(0)); // TODO fill with #N/A
+        let currentRow = 0;
+        for (const range of _ranges) {
+            for (let col = 0; col < range.length; col++) {
+                for (let row = 0; row < range[col].length; row++) {
+                    result[col][currentRow + row] = toCellValue(range[col][row]);
+                }
+            }
+            currentRow += range[0].length;
+        }
+        return result;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// WRAPCOLS
+// -----------------------------------------------------------------------------
+const WRAPCOLS = {
+    description: _lt("Wraps the provided row or column of cells by columns after a specified number of elements to form a new array."),
+    args: [
+        arg("range (any, range<any>)", _lt("The range to wrap.")),
+        arg("wrap_count (number)", _lt("The maximum number of cells for each column, rounded down to the nearest whole number.")),
+        arg("pad_with  (any, default=0)", // TODO : replace with #N/A
+        _lt("The value with which to fill the extra cells in the range.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (range, wrapCount, padWith = 0) {
+        const _range = toMatrixArgValue(range);
+        const nOfRows = toInteger(wrapCount);
+        const _padWith = padWith === null ? 0 : padWith;
+        assertSingleColOrRow(_lt("Argument range must be a single row or column."), _range);
+        const values = _range.flat();
+        const nOfCols = Math.ceil(values.length / nOfRows);
+        const result = Array(nOfCols);
+        for (let col = 0; col < nOfCols; col++) {
+            result[col] = Array(nOfRows).fill(_padWith);
+            for (let row = 0; row < nOfRows; row++) {
+                const index = col * nOfRows + row;
+                if (index < values.length) {
+                    result[col][row] = toCellValue(values[index]);
+                }
+            }
+        }
+        return result;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// WRAPROWS
+// -----------------------------------------------------------------------------
+const WRAPROWS = {
+    description: _lt("Wraps the provided row or column of cells by rows after a specified number of elements to form a new array."),
+    args: [
+        arg("range (any, range<any>)", _lt("The range to wrap.")),
+        arg("wrap_count (number)", _lt("The maximum number of cells for each row, rounded down to the nearest whole number.")),
+        arg("pad_with  (any, default=0)", // TODO : replace with #N/A
+        _lt("The value with which to fill the extra cells in the range.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (range, wrapCount, padWith = 0) {
+        const _range = toMatrixArgValue(range);
+        const nOfCols = toInteger(wrapCount);
+        const _padWith = padWith === null ? 0 : padWith;
+        assertSingleColOrRow(_lt("Argument range must be a single row or column."), _range);
+        const values = _range.flat();
+        const nOfRows = Math.ceil(values.length / nOfCols);
+        const result = Array(nOfCols)
+            .fill([])
+            .map(() => Array(nOfRows).fill(_padWith));
+        for (let row = 0; row < nOfRows; row++) {
+            for (let col = 0; col < nOfCols; col++) {
+                const index = row * nOfCols + col;
+                if (index < values.length) {
+                    result[col][row] = toCellValue(values[index]);
+                }
+            }
+        }
+        return result;
+    },
+    isExported: true,
+};
+
+var array = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  ARRAY_CONSTRAIN: ARRAY_CONSTRAIN,
+  CHOOSECOLS: CHOOSECOLS,
+  CHOOSEROWS: CHOOSEROWS,
+  EXPAND: EXPAND,
+  FLATTEN: FLATTEN,
+  FREQUENCY: FREQUENCY,
+  HSTACK: HSTACK,
+  MDETERM: MDETERM,
+  MINVERSE: MINVERSE,
+  MMULT: MMULT,
+  SUMPRODUCT: SUMPRODUCT,
+  SUMX2MY2: SUMX2MY2,
+  SUMX2PY2: SUMX2PY2,
+  SUMXMY2: SUMXMY2,
+  TOCOL: TOCOL,
+  TOROW: TOROW,
+  TRANSPOSE: TRANSPOSE,
+  VSTACK: VSTACK,
+  WRAPCOLS: WRAPCOLS,
+  WRAPROWS: WRAPROWS
+});
+
 // -----------------------------------------------------------------------------
 // FORMAT.LARGE.NUMBER
 // -----------------------------------------------------------------------------
@@ -10410,6 +10885,22 @@ const MOD = {
     isExported: true,
 };
 // -----------------------------------------------------------------------------
+// MUNIT
+// -----------------------------------------------------------------------------
+const MUNIT = {
+    description: _lt("Returns a n x n unit matrix, where n is the input dimension."),
+    args: [
+        arg("dimension (number)", _lt("An integer specifying the dimension size of the unit matrix. It must be positive.")),
+    ],
+    returns: ["RANGE<NUMBER>"],
+    compute: function (n) {
+        const _n = toInteger(n);
+        assertPositive(_lt("The argument dimension must be positive"), _n);
+        return getUnitMatrix(_n);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
 // ODD
 // -----------------------------------------------------------------------------
 const ODD = {
@@ -10508,6 +10999,47 @@ const RAND = {
     isExported: true,
 };
 // -----------------------------------------------------------------------------
+// RANDARRAY
+// -----------------------------------------------------------------------------
+const RANDARRAY = {
+    description: _lt("Returns a grid of random numbers between 0 inclusive and 1 exclusive."),
+    args: [
+        arg("rows (number, default=1)", _lt("The number of rows to be returned.")),
+        arg("columns (number, default=1)", _lt("The number of columns to be returned.")),
+        arg("min (number, default=0)", _lt("The minimum number you would like returned.")),
+        arg("max (number, default=1)", _lt("The maximum number you would like returned.")),
+        arg("whole_number (number, default=FALSE)", _lt("Return a whole number or a decimal value.")),
+    ],
+    returns: ["RANGE<NUMBER>"],
+    compute: function (rows = 1, columns = 1, min = 0, max = 1, whole_number = false) {
+        const _cols = toInteger(columns);
+        const _rows = toInteger(rows);
+        const _min = toNumber(min);
+        const _max = toNumber(max);
+        const _whole_number = toBoolean(whole_number);
+        assertPositive(_lt("The number columns (%s) must be positive.", _cols.toString()), _cols);
+        assertPositive(_lt("The number rows (%s) must be positive.", _rows.toString()), _rows);
+        assert(() => _min <= _max, _lt("The maximum (%s) must be greater than or equal to the minimum (%s).", _max.toString(), _min.toString()));
+        if (_whole_number) {
+            assert(() => Number.isInteger(_min) && Number.isInteger(_max), _lt("The maximum (%s) and minimum (%s) must be integers when whole_number is TRUE.", _max.toString(), _min.toString()));
+        }
+        const result = Array(_cols);
+        for (let col = 0; col < _cols; col++) {
+            result[col] = Array(_rows);
+            for (let row = 0; row < _rows; row++) {
+                if (!_whole_number) {
+                    result[col][row] = _min + Math.random() * (_max - _min);
+                }
+                else {
+                    result[col][row] = Math.floor(Math.random() * (_max - _min + 1) + _min);
+                }
+            }
+        }
+        return result;
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
 // RANDBETWEEN
 // -----------------------------------------------------------------------------
 const RANDBETWEEN = {
@@ -10837,11 +11369,13 @@ var math = /*#__PURE__*/Object.freeze({
   ISODD: ISODD,
   LN: LN,
   MOD: MOD,
+  MUNIT: MUNIT,
   ODD: ODD,
   PI: PI,
   POWER: POWER,
   PRODUCT: PRODUCT,
   RAND: RAND,
+  RANDARRAY: RANDARRAY,
   RANDBETWEEN: RANDBETWEEN,
   ROUND: ROUND,
   ROUNDDOWN: ROUNDDOWN,
@@ -12868,6 +13402,89 @@ var engineering = /*#__PURE__*/Object.freeze({
   DELTA: DELTA
 });
 
+// -----------------------------------------------------------------------------
+// FILTER
+// -----------------------------------------------------------------------------
+const FILTER = {
+    description: _lt("Returns a filtered version of the source range, returning only rows or columns that meet the specified conditions."),
+    // TODO modify args description when vectorization on formulas is available
+    args: [
+        arg("range (any, range<any>)", _lt("The data to be filtered.")),
+        arg("condition1 (boolean, range<boolean>)", _lt("A column or row containing true or false values corresponding to the first column or row of range.")),
+        arg("condition2 (boolean, range<boolean>, repeating)", _lt("Additional column or row containing true or false values.")),
+    ],
+    returns: ["RANGE<ANY>"],
+    //TODO computeFormat
+    compute: function (range, ...conditions) {
+        let _range = toMatrixArgValue(range);
+        const _conditionsMatrices = conditions.map((cond) => toMatrixArgValue(cond));
+        _conditionsMatrices.map((c) => assertSingleColOrRow(_lt("The arguments condition must be a single column or row."), c));
+        assertSameDimensions(_lt("The arguments conditions must have the same dimensions."), ..._conditionsMatrices);
+        const _conditions = _conditionsMatrices.map((c) => c.flat());
+        const mode = _conditionsMatrices[0].length === 1 ? "row" : "col";
+        _range = mode === "row" ? transpose2dArray(_range) : _range;
+        assert(() => _conditions.every((cond) => cond.length === _range.length), _lt(`FILTER has mismatched sizes on the range and conditions.`));
+        const results = [];
+        for (let i = 0; i < _range.length; i++) {
+            const row = _range[i];
+            if (_conditions.every((c) => c[i])) {
+                results.push(row);
+            }
+        }
+        if (!results.length) {
+            throw new NotAvailableError(_lt("No match found in FILTER evaluation"));
+        }
+        return toCellValueMatrix(mode === "row" ? transpose2dArray(results) : results);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
+// UNIQUE
+// -----------------------------------------------------------------------------
+const UNIQUE = {
+    description: _lt("Unique rows in the provided source range."),
+    args: [
+        arg("range (any, range<any>)", _lt("The data to filter by unique entries.")),
+        arg("by_column (boolean, default=FALSE)", _lt("Whether to filter the data by columns or by rows.")),
+        arg("exactly_once (boolean, default=FALSE)", _lt("Whether to return only entries with no duplicates.")),
+    ],
+    returns: ["RANGE<NUMBER>"],
+    // TODO computeFormat
+    compute: function (range, byColumn, exactlyOnce) {
+        if (!isMatrix(range)) {
+            return toCellValue(range);
+        }
+        const _byColumn = toBoolean(byColumn) || false;
+        const _exactlyOnce = toBoolean(exactlyOnce) || false;
+        if (!_byColumn)
+            range = transpose2dArray(range);
+        const map = new Map();
+        for (const row of range) {
+            const key = JSON.stringify(row);
+            const occurrence = map.get(key);
+            if (!occurrence) {
+                map.set(key, { val: row, count: 1 });
+            }
+            else {
+                occurrence.count++;
+            }
+        }
+        const results = _exactlyOnce
+            ? [...map.values()].filter((v) => v.count === 1).map((v) => v.val)
+            : [...map.values()].map((v) => v.val);
+        if (!results.length)
+            throw new Error(_lt("No unique values found"));
+        return toCellValueMatrix(_byColumn ? results : transpose2dArray(results));
+    },
+    isExported: true,
+};
+
+var filter = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  FILTER: FILTER,
+  UNIQUE: UNIQUE
+});
+
 /** Assert maturity date > settlement date */
 function assertMaturityAndSettlementDatesAreValid(settlement, maturity) {
     assert(() => settlement < maturity, _lt("The maturity (%s) must be strictly greater than the settlement (%s).", maturity.toString(), settlement.toString()));
@@ -15563,13 +16180,16 @@ const XLOOKUP = {
         const _searchMode = Math.trunc(toNumber(searchMode));
         const _searchKey = normalizeValue(searchKey);
         assert(() => lookupRange.length === 1 || lookupRange[0].length === 1, _lt("lookup_range should be either a single row or single column."));
-        assert(() => returnRange.length === 1 || returnRange[0].length === 1, _lt("return_range should be either a single row or single column."));
-        assert(() => returnRange.length === lookupRange.length &&
-            returnRange[0].length === lookupRange[0].length, _lt("return_range should have the same dimensions as lookup_range."));
         assert(() => [-1, 1, -2, 2].includes(_searchMode), _lt("searchMode should be a value in [-1, 1, -2, 2]."));
         assert(() => [-1, 0, 1].includes(_matchMode), _lt("matchMode should be a value in [-1, 0, 1]."));
-        const getElement = lookupRange.length === 1 ? getNormalizedValueFromColumnRange : getNormalizedValueFromRowRange;
-        const rangeLen = lookupRange.length === 1 ? lookupRange[0].length : lookupRange.length;
+        const lookupDirection = lookupRange.length === 1 ? "col" : "row";
+        assert(() => lookupDirection === "col"
+            ? returnRange[0].length === lookupRange[0].length
+            : returnRange.length === lookupRange.length, _lt("return_range should have the same dimensions as lookup_range."));
+        const getElement = lookupDirection === "col"
+            ? getNormalizedValueFromColumnRange
+            : getNormalizedValueFromRowRange;
+        const rangeLen = lookupDirection === "col" ? lookupRange[0].length : lookupRange.length;
         const mode = _matchMode === 0 ? "strict" : _matchMode === 1 ? "nextGreater" : "nextSmaller";
         const reverseSearch = _searchMode === -1;
         let index;
@@ -15581,7 +16201,7 @@ const XLOOKUP = {
             index = linearSearch(lookupRange, _searchKey, mode, rangeLen, getElement, reverseSearch);
         }
         if (index !== -1) {
-            return (lookupRange.length === 1 ? returnRange[0][index] : returnRange[index][0]);
+            return toCellValueMatrix(lookupDirection === "col" ? returnRange.map((col) => [col[index]]) : [returnRange[index]]);
         }
         const _defaultValue = defaultValue?.();
         assertAvailable(_defaultValue, searchKey);
@@ -16122,6 +16742,36 @@ const SEARCH = {
     isExported: true,
 };
 // -----------------------------------------------------------------------------
+// SPLIT
+// -----------------------------------------------------------------------------
+const SPLIT_DEFAULT_SPLIT_BY_EACH = true;
+const SPLIT_DEFAULT_REMOVE_EMPTY_TEXT = true;
+const SPLIT = {
+    description: _lt("Split text by specific character delimiter(s)."),
+    args: [
+        arg("text (string)", _lt("The text to divide.")),
+        arg("delimiter (string)", _lt("The character or characters to use to split text.")),
+        arg(`split_by_each (boolean, default=${SPLIT_DEFAULT_SPLIT_BY_EACH}})`, _lt("Whether or not to divide text around each character contained in delimiter.")),
+        arg(`remove_empty_text (boolean, default=${SPLIT_DEFAULT_REMOVE_EMPTY_TEXT})`, _lt("Whether or not to remove empty text messages from the split results. The default behavior is to treat \
+        consecutive delimiters as one (if TRUE). If FALSE, empty cells values are added between consecutive delimiters.")),
+    ],
+    returns: ["RANGE<STRING>"],
+    compute: function (text, delimiter, splitByEach = SPLIT_DEFAULT_SPLIT_BY_EACH, removeEmptyText = SPLIT_DEFAULT_REMOVE_EMPTY_TEXT) {
+        const _text = toString(text);
+        const _delimiter = escapeRegExp(toString(delimiter));
+        const _splitByEach = toBoolean(splitByEach);
+        const _removeEmptyText = toBoolean(removeEmptyText);
+        assert(() => _delimiter.length > 0, _lt("The _delimiter (%s) must be not be empty.", _delimiter));
+        const regex = _splitByEach ? new RegExp(`[${_delimiter}]`, "g") : new RegExp(_delimiter, "g");
+        let result = _text.split(regex);
+        if (_removeEmptyText) {
+            result = result.filter((text) => text !== "");
+        }
+        return transpose2dArray([result]);
+    },
+    isExported: true,
+};
+// -----------------------------------------------------------------------------
 // SUBSTITUTE
 // -----------------------------------------------------------------------------
 const SUBSTITUTE = {
@@ -16230,6 +16880,7 @@ var text = /*#__PURE__*/Object.freeze({
   REPLACE: REPLACE,
   RIGHT: RIGHT,
   SEARCH: SEARCH,
+  SPLIT: SPLIT,
   SUBSTITUTE: SUBSTITUTE,
   TEXTJOIN: TEXTJOIN,
   TRIM: TRIM,
@@ -16263,8 +16914,10 @@ var web = /*#__PURE__*/Object.freeze({
 });
 
 const categories = [
+    { name: _lt("Array"), functions: array },
     { name: _lt("Database"), functions: database },
     { name: _lt("Date"), functions: date },
+    { name: _lt("Filter"), functions: filter },
     { name: _lt("Financial"), functions: financial },
     { name: _lt("Info"), functions: info },
     { name: _lt("Lookup"), functions: lookup },
@@ -16337,14 +16990,20 @@ for (let category of categories) {
 }
 
 const insertRow = {
-    name: MENU_INSERT_ROWS_NAME,
+    name: (env) => {
+        const number = getRowsNumber(env);
+        return number === 1 ? _lt("Insert row") : _lt("Insert %s rows", number.toString());
+    },
     isVisible: (env) => isConsecutive(env.model.getters.getActiveRows()) &&
         IS_ONLY_ONE_RANGE(env) &&
         env.model.getters.getActiveCols().size === 0,
     icon: "o-spreadsheet-Icon.INSERT_ROW",
 };
 const rowInsertRowBefore = {
-    name: ROW_INSERT_ROWS_BEFORE_NAME,
+    name: (env) => {
+        const number = getRowsNumber(env);
+        return number === 1 ? _lt("Insert row above") : _lt("Insert %s rows above", number.toString());
+    },
     execute: INSERT_ROWS_BEFORE_ACTION,
     isVisible: (env) => isConsecutive(env.model.getters.getActiveRows()) &&
         IS_ONLY_ONE_RANGE(env) &&
@@ -16353,17 +17012,32 @@ const rowInsertRowBefore = {
 };
 const topBarInsertRowsBefore = {
     ...rowInsertRowBefore,
-    name: MENU_INSERT_ROWS_BEFORE_NAME,
+    name: (env) => {
+        const number = getRowsNumber(env);
+        if (number === 1) {
+            return _lt("Row above");
+        }
+        return _lt("%s Rows above", number.toString());
+    },
 };
 const cellInsertRowsBefore = {
     ...rowInsertRowBefore,
-    name: CELL_INSERT_ROWS_BEFORE_NAME,
+    name: (env) => {
+        const number = getRowsNumber(env);
+        if (number === 1) {
+            return _lt("Insert row");
+        }
+        return _lt("Insert %s rows", number.toString());
+    },
     isVisible: IS_ONLY_ONE_RANGE,
     icon: "o-spreadsheet-Icon.INSERT_ROW_BEFORE",
 };
 const rowInsertRowsAfter = {
     execute: INSERT_ROWS_AFTER_ACTION,
-    name: ROW_INSERT_ROWS_AFTER_NAME,
+    name: (env) => {
+        const number = getRowsNumber(env);
+        return number === 1 ? _lt("Insert row below") : _lt("Insert %s rows below", number.toString());
+    },
     isVisible: (env) => isConsecutive(env.model.getters.getActiveRows()) &&
         IS_ONLY_ONE_RANGE(env) &&
         env.model.getters.getActiveCols().size === 0,
@@ -16371,17 +17045,31 @@ const rowInsertRowsAfter = {
 };
 const topBarInsertRowsAfter = {
     ...rowInsertRowsAfter,
-    name: MENU_INSERT_ROWS_AFTER_NAME,
+    name: (env) => {
+        const number = getRowsNumber(env);
+        if (number === 1) {
+            return _lt("Row below");
+        }
+        return _lt("%s Rows below", number.toString());
+    },
 };
 const insertCol = {
-    name: MENU_INSERT_COLUMNS_NAME,
+    name: (env) => {
+        const number = getColumnsNumber(env);
+        return number === 1 ? _lt("Insert column") : _lt("Insert %s columns", number.toString());
+    },
     isVisible: (env) => isConsecutive(env.model.getters.getActiveCols()) &&
         IS_ONLY_ONE_RANGE(env) &&
         env.model.getters.getActiveRows().size === 0,
     icon: "o-spreadsheet-Icon.INSERT_COL",
 };
 const colInsertColsBefore = {
-    name: COLUMN_INSERT_COLUMNS_BEFORE_NAME,
+    name: (env) => {
+        const number = getColumnsNumber(env);
+        return number === 1
+            ? _lt("Insert column left")
+            : _lt("Insert %s columns left", number.toString());
+    },
     execute: INSERT_COLUMNS_BEFORE_ACTION,
     isVisible: (env) => isConsecutive(env.model.getters.getActiveCols()) &&
         IS_ONLY_ONE_RANGE(env) &&
@@ -16390,16 +17078,33 @@ const colInsertColsBefore = {
 };
 const topBarInsertColsBefore = {
     ...colInsertColsBefore,
-    name: MENU_INSERT_COLUMNS_BEFORE_NAME,
+    name: (env) => {
+        const number = getColumnsNumber(env);
+        if (number === 1) {
+            return _lt("Column left");
+        }
+        return _lt("%s Columns left", number.toString());
+    },
 };
 const cellInsertColsBefore = {
     ...colInsertColsBefore,
-    name: CELL_INSERT_COLUMNS_BEFORE_NAME,
+    name: (env) => {
+        const number = getColumnsNumber(env);
+        if (number === 1) {
+            return _lt("Insert column");
+        }
+        return _lt("Insert %s columns", number.toString());
+    },
     isVisible: IS_ONLY_ONE_RANGE,
     icon: "o-spreadsheet-Icon.INSERT_COL_BEFORE",
 };
 const colInsertColsAfter = {
-    name: COLUMN_INSERT_COLUMNS_AFTER_NAME,
+    name: (env) => {
+        const number = getColumnsNumber(env);
+        return number === 1
+            ? _lt("Insert column right")
+            : _lt("Insert %s columns right", number.toString());
+    },
     execute: INSERT_COLUMNS_AFTER_ACTION,
     isVisible: (env) => isConsecutive(env.model.getters.getActiveCols()) &&
         IS_ONLY_ONE_RANGE(env) &&
@@ -16408,7 +17113,13 @@ const colInsertColsAfter = {
 };
 const topBarInsertColsAfter = {
     ...colInsertColsAfter,
-    name: MENU_INSERT_COLUMNS_AFTER_NAME,
+    name: (env) => {
+        const number = getColumnsNumber(env);
+        if (number === 1) {
+            return _lt("Column right");
+        }
+        return _lt("%s Columns right", number.toString());
+    },
     execute: INSERT_COLUMNS_AFTER_ACTION,
 };
 const insertCell = {
@@ -16420,13 +17131,21 @@ const insertCell = {
 };
 const insertCellShiftDown = {
     name: _lt("Insert cells and shift down"),
-    execute: INSERT_CELL_SHIFT_DOWN,
+    execute: (env) => {
+        const zone = env.model.getters.getSelectedZone();
+        const result = env.model.dispatch("INSERT_CELL", { zone, shiftDimension: "ROW" });
+        handlePasteResult(env, result);
+    },
     isVisible: (env) => env.model.getters.getActiveRows().size === 0 && env.model.getters.getActiveCols().size === 0,
     icon: "o-spreadsheet-Icon.INSERT_CELL_SHIFT_DOWN",
 };
 const insertCellShiftRight = {
     name: _lt("Insert cells and shift right"),
-    execute: INSERT_CELL_SHIFT_RIGHT,
+    execute: (env) => {
+        const zone = env.model.getters.getSelectedZone();
+        const result = env.model.dispatch("INSERT_CELL", { zone, shiftDimension: "COL" });
+        handlePasteResult(env, result);
+    },
     isVisible: (env) => env.model.getters.getActiveRows().size === 0 && env.model.getters.getActiveCols().size === 0,
     icon: "o-spreadsheet-Icon.INSERT_CELL_SHIFT_RIGHT",
 };
@@ -16492,7 +17211,13 @@ const insertLink = {
 };
 const insertSheet = {
     name: _lt("Insert sheet"),
-    execute: CREATE_SHEET_ACTION,
+    execute: (env) => {
+        const activeSheetId = env.model.getters.getActiveSheetId();
+        const position = env.model.getters.getSheetIds().indexOf(activeSheetId) + 1;
+        const sheetId = env.model.uuidGenerator.uuidv4();
+        env.model.dispatch("CREATE_SHEET", { sheetId, position });
+        env.model.dispatch("ACTIVATE_SHEET", { sheetIdFrom: activeSheetId, sheetIdTo: sheetId });
+    },
     icon: "o-spreadsheet-Icon.INSERT_SHEET",
 };
 function createFormulaFunctions(fnNames) {
@@ -16503,6 +17228,26 @@ function createFormulaFunctions(fnNames) {
             execute: (env) => env.startCellEdition(`=${fnName}(`),
         };
     });
+}
+function getRowsNumber(env) {
+    const activeRows = env.model.getters.getActiveRows();
+    if (activeRows.size) {
+        return activeRows.size;
+    }
+    else {
+        const zone = env.model.getters.getSelectedZones()[0];
+        return zone.bottom - zone.top + 1;
+    }
+}
+function getColumnsNumber(env) {
+    const activeCols = env.model.getters.getActiveCols();
+    if (activeCols.size) {
+        return activeCols.size;
+    }
+    else {
+        const zone = env.model.getters.getSelectedZones()[0];
+        return zone.right - zone.left + 1;
+    }
 }
 
 //------------------------------------------------------------------------------
@@ -16593,6 +17338,123 @@ cellMenuRegistry
     separator: true,
 });
 
+const SORT_TYPES = [
+    CellValueType.number,
+    CellValueType.error,
+    CellValueType.text,
+    CellValueType.boolean,
+];
+function sortCells(cells, sortDirection, emptyCellAsZero) {
+    const cellsWithIndex = cells.map((cell, index) => ({
+        index,
+        type: cell.type,
+        value: cell.value,
+    }));
+    let emptyCells = cellsWithIndex.filter((x) => x.type === CellValueType.empty);
+    let nonEmptyCells = cellsWithIndex.filter((x) => x.type !== CellValueType.empty);
+    if (emptyCellAsZero) {
+        nonEmptyCells.push(...emptyCells.map((emptyCell) => ({ ...emptyCell, type: CellValueType.number, value: 0 })));
+        emptyCells = [];
+    }
+    const inverse = sortDirection === "descending" ? -1 : 1;
+    return nonEmptyCells
+        .sort((left, right) => {
+        let typeOrder = SORT_TYPES.indexOf(left.type) - SORT_TYPES.indexOf(right.type);
+        if (typeOrder === 0) {
+            if (left.type === CellValueType.text || left.type === CellValueType.error) {
+                typeOrder = left.value.localeCompare(right.value);
+            }
+            else
+                typeOrder = left.value - right.value;
+        }
+        return inverse * typeOrder;
+    })
+        .concat(emptyCells);
+}
+function interactiveSortSelection(env, sheetId, anchor, zone, sortDirection) {
+    let result = DispatchResult.Success;
+    //several columns => bypass the contiguity check
+    let multiColumns = zone.right > zone.left;
+    if (env.model.getters.doesIntersectMerge(sheetId, zone)) {
+        multiColumns = false;
+        let table;
+        for (let row = zone.top; row <= zone.bottom; row++) {
+            table = [];
+            for (let col = zone.left; col <= zone.right; col++) {
+                let merge = env.model.getters.getMerge({ sheetId, col, row });
+                if (merge && !table.includes(merge.id.toString())) {
+                    table.push(merge.id.toString());
+                }
+            }
+            if (table.length >= 2) {
+                multiColumns = true;
+                break;
+            }
+        }
+    }
+    const { col, row } = anchor;
+    if (multiColumns) {
+        result = env.model.dispatch("SORT_CELLS", { sheetId, col, row, zone, sortDirection });
+    }
+    else {
+        // check contiguity
+        const contiguousZone = env.model.getters.getContiguousZone(sheetId, zone);
+        if (isEqual(contiguousZone, zone)) {
+            // merge as it is
+            result = env.model.dispatch("SORT_CELLS", {
+                sheetId,
+                col,
+                row,
+                zone,
+                sortDirection,
+            });
+        }
+        else {
+            env.askConfirmation(_lt("We found data next to your selection. Since this data was not selected, it will not be sorted. Do you want to extend your selection?"), () => {
+                zone = contiguousZone;
+                result = env.model.dispatch("SORT_CELLS", {
+                    sheetId,
+                    col,
+                    row,
+                    zone,
+                    sortDirection,
+                });
+            }, () => {
+                result = env.model.dispatch("SORT_CELLS", {
+                    sheetId,
+                    col,
+                    row,
+                    zone,
+                    sortDirection,
+                });
+            });
+        }
+    }
+    if (result.isCancelledBecause(64 /* CommandResult.InvalidSortZone */)) {
+        const { col, row } = anchor;
+        env.model.selection.selectZone({ cell: { col, row }, zone });
+        env.raiseError(_lt("Cannot sort. To sort, select only cells or only merges that have the same size."));
+    }
+}
+
+const AddFilterInteractiveContent = {
+    filterOverlap: _lt("You cannot create overlapping filters."),
+    nonContinuousTargets: _lt("A filter can only be created on a continuous selection."),
+    mergeInFilter: _lt("You can't create a filter over a range that contains a merge."),
+};
+function interactiveAddFilter(env, sheetId, target) {
+    const result = env.model.dispatch("CREATE_FILTER_TABLE", { target, sheetId });
+    if (result.isCancelledBecause(79 /* CommandResult.FilterOverlap */)) {
+        env.raiseError(AddFilterInteractiveContent.filterOverlap);
+    }
+    else if (result.isCancelledBecause(81 /* CommandResult.MergeInFilter */)) {
+        env.raiseError(AddFilterInteractiveContent.mergeInFilter);
+    }
+    else if (result.isCancelledBecause(82 /* CommandResult.NonContinuousTargets */)) {
+        env.raiseError(AddFilterInteractiveContent.nonContinuousTargets);
+    }
+}
+
 const sortRange = {
     name: _lt("Sort range"),
     isVisible: IS_ONLY_ONE_RANGE,
@@ -16600,24 +17462,45 @@ const sortRange = {
 };
 const sortAscending = {
     name: _lt("Ascending (A ⟶ Z)"),
-    execute: SORT_CELLS_ASCENDING,
+    execute: (env) => {
+        const { anchor, zones } = env.model.getters.getSelection();
+        const sheetId = env.model.getters.getActiveSheetId();
+        interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "ascending");
+    },
     icon: "o-spreadsheet-Icon.SORT_ASCENDING",
 };
 const sortDescending = {
     name: _lt("Descending (Z ⟶ A)"),
-    execute: SORT_CELLS_DESCENDING,
+    execute: (env) => {
+        const { anchor, zones } = env.model.getters.getSelection();
+        const sheetId = env.model.getters.getActiveSheetId();
+        interactiveSortSelection(env, sheetId, anchor.cell, zones[0], "descending");
+    },
     icon: "o-spreadsheet-Icon.SORT_DESCENDING",
 };
 const addDataFilter = {
     name: _lt("Create filter"),
-    execute: FILTERS_CREATE_FILTER_TABLE,
+    execute: (env) => {
+        const sheetId = env.model.getters.getActiveSheetId();
+        const selection = env.model.getters.getSelection().zones;
+        interactiveAddFilter(env, sheetId, selection);
+    },
     isVisible: (env) => !SELECTION_CONTAINS_FILTER(env),
-    isEnabled: (env) => SELECTION_IS_CONTINUOUS(env),
+    isEnabled: (env) => {
+        const selectedZones = env.model.getters.getSelectedZones();
+        return areZonesContinuous(...selectedZones);
+    },
     icon: "o-spreadsheet-Icon.MENU_FILTER_ICON",
 };
 const removeDataFilter = {
     name: _lt("Remove filter"),
-    execute: FILTERS_REMOVE_FILTER_TABLE,
+    execute: (env) => {
+        const sheetId = env.model.getters.getActiveSheetId();
+        env.model.dispatch("REMOVE_FILTER_TABLE", {
+            sheetId,
+            target: env.model.getters.getSelectedZones(),
+        });
+    },
     isVisible: SELECTION_CONTAINS_FILTER,
     icon: "o-spreadsheet-Icon.MENU_FILTER_ICON",
 };
@@ -16631,13 +17514,13 @@ const splitToColumns = {
 
 const formatNumberAutomatic = {
     name: _lt("Automatic"),
-    execute: FORMAT_AUTOMATIC_ACTION,
+    execute: (env) => setFormatter(env, ""),
     isActive: (env) => isAutomaticFormatSelected(env),
 };
 const formatNumberNumber = {
     name: _lt("Number"),
     description: "1,000.12",
-    execute: FORMAT_NUMBER_ACTION,
+    execute: (env) => setFormatter(env, "#,##0.00"),
     isActive: (env) => isFormatSelected(env, "#,##0.00"),
 };
 const formatPercent = {
@@ -16654,42 +17537,42 @@ const formatNumberPercent = {
 const formatNumberCurrency = {
     name: _lt("Currency"),
     description: "$1,000.12",
-    execute: FORMAT_CURRENCY_ACTION,
+    execute: (env) => setFormatter(env, "[$$]#,##0.00"),
     isActive: (env) => isFormatSelected(env, "[$$]#,##0.00"),
 };
 const formatNumberCurrencyRounded = {
     name: _lt("Currency rounded"),
     description: "$1,000",
-    execute: FORMAT_CURRENCY_ROUNDED_ACTION,
+    execute: (env) => setFormatter(env, "[$$]#,##0"),
     isActive: (env) => isFormatSelected(env, "[$$]#,##0"),
 };
 const formatCustomCurrency = {
     name: _lt("Custom currency"),
     isVisible: (env) => env.loadCurrencies !== undefined,
-    execute: OPEN_CUSTOM_CURRENCY_SIDEPANEL_ACTION,
+    execute: (env) => env.openSidePanel("CustomCurrency", {}),
 };
 const formatNumberDate = {
     name: _lt("Date"),
     description: "9/26/2008",
-    execute: FORMAT_DATE_ACTION,
+    execute: (env) => setFormatter(env, "m/d/yyyy"),
     isActive: (env) => isFormatSelected(env, "m/d/yyyy"),
 };
 const formatNumberTime = {
     name: _lt("Time"),
     description: "10:43:00 PM",
-    execute: FORMAT_TIME_ACTION,
+    execute: (env) => setFormatter(env, "hh:mm:ss a"),
     isActive: (env) => isFormatSelected(env, "hh:mm:ss a"),
 };
 const formatNumberDateTime = {
     name: _lt("Date time"),
     description: "9/26/2008 22:43:00",
-    execute: FORMAT_DATE_TIME_ACTION,
+    execute: (env) => setFormatter(env, "m/d/yyyy hh:mm:ss"),
     isActive: (env) => isFormatSelected(env, "m/d/yyyy hh:mm:ss"),
 };
 const formatNumberDuration = {
     name: _lt("Duration"),
     description: "27:51:38",
-    execute: FORMAT_DURATION_ACTION,
+    execute: (env) => setFormatter(env, "hhhh:mm:ss"),
     isActive: (env) => isFormatSelected(env, "hhhh:mm:ss"),
 };
 const incraseDecimalPlaces = {
@@ -16713,27 +17596,27 @@ const decraseDecimalPlaces = {
 const formatBold = {
     name: _lt("Bold"),
     description: "Ctrl+B",
-    execute: FORMAT_BOLD_ACTION,
+    execute: (env) => setStyle(env, { bold: !env.model.getters.getCurrentStyle().bold }),
     icon: "o-spreadsheet-Icon.BOLD",
     isActive: (env) => !!env.model.getters.getCurrentStyle().bold,
 };
 const formatItalic = {
     name: _lt("Italic"),
     description: "Ctrl+I",
-    execute: FORMAT_ITALIC_ACTION,
+    execute: (env) => setStyle(env, { italic: !env.model.getters.getCurrentStyle().italic }),
     icon: "o-spreadsheet-Icon.ITALIC",
     isActive: (env) => !!env.model.getters.getCurrentStyle().italic,
 };
 const formatUnderline = {
     name: _lt("Underline"),
     description: "Ctrl+U",
-    execute: FORMAT_UNDERLINE_ACTION,
+    execute: (env) => setStyle(env, { underline: !env.model.getters.getCurrentStyle().underline }),
     icon: "o-spreadsheet-Icon.UNDERLINE",
     isActive: (env) => !!env.model.getters.getCurrentStyle().underline,
 };
 const formatStrikethrough = {
     name: _lt("Strikethrough"),
-    execute: FORMAT_STRIKETHROUGH_ACTION,
+    execute: (env) => setStyle(env, { strikethrough: !env.model.getters.getCurrentStyle().strikethrough }),
     icon: "o-spreadsheet-Icon.STRIKE",
     isActive: (env) => !!env.model.getters.getCurrentStyle().strikethrough,
 };
@@ -16839,7 +17722,10 @@ const paintFormat = {
 const clearFormat = {
     name: _lt("Clear formatting"),
     description: "Ctrl+<",
-    execute: FORMAT_CLEARFORMAT_ACTION,
+    execute: (env) => env.model.dispatch("CLEAR_FORMATTING", {
+        sheetId: env.model.getters.getActiveSheetId(),
+        target: env.model.getters.getSelectedZones(),
+    }),
     icon: "o-spreadsheet-Icon.CLEAR_FORMAT",
 };
 function fontSizeMenuBuilder() {
@@ -16918,20 +17804,34 @@ function interactiveFreezeColumnsRows(env, dimension, base) {
     const sheetId = env.model.getters.getActiveSheetId();
     const cmd = dimension === "COL" ? "FREEZE_COLUMNS" : "FREEZE_ROWS";
     const result = env.model.dispatch(cmd, { sheetId, quantity: base });
-    if (result.isCancelledBecause(65 /* CommandResult.MergeOverlap */)) {
+    if (result.isCancelledBecause(66 /* CommandResult.MergeOverlap */)) {
         env.raiseError(MergeErrorMessage);
     }
 }
 
 const hideCols = {
     name: HIDE_COLUMNS_NAME,
-    execute: HIDE_COLUMNS_ACTION,
+    execute: (env) => {
+        const columns = env.model.getters.getElementsFromSelection("COL");
+        env.model.dispatch("HIDE_COLUMNS_ROWS", {
+            sheetId: env.model.getters.getActiveSheetId(),
+            dimension: "COL",
+            elements: columns,
+        });
+    },
     isVisible: NOT_ALL_VISIBLE_COLS_SELECTED,
     icon: "o-spreadsheet-Icon.HIDE_COL",
 };
 const unhideCols = {
     name: _lt("Unhide columns"),
-    execute: UNHIDE_COLUMNS_ACTION,
+    execute: (env) => {
+        const columns = env.model.getters.getElementsFromSelection("COL");
+        env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
+            sheetId: env.model.getters.getActiveSheetId(),
+            dimension: "COL",
+            elements: columns,
+        });
+    },
     isVisible: (env) => {
         const hiddenCols = env.model.getters
             .getHiddenColsGroups(env.model.getters.getActiveSheetId())
@@ -16942,18 +17842,39 @@ const unhideCols = {
 };
 const unhideAllCols = {
     name: _lt("Unhide all columns"),
-    execute: UNHIDE_ALL_COLUMNS_ACTION,
+    execute: (env) => {
+        const sheetId = env.model.getters.getActiveSheetId();
+        env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
+            sheetId,
+            dimension: "COL",
+            elements: Array.from(Array(env.model.getters.getNumberCols(sheetId)).keys()),
+        });
+    },
     isVisible: (env) => env.model.getters.getHiddenColsGroups(env.model.getters.getActiveSheetId()).length > 0,
 };
 const hideRows = {
     name: HIDE_ROWS_NAME,
-    execute: HIDE_ROWS_ACTION,
+    execute: (env) => {
+        const rows = env.model.getters.getElementsFromSelection("ROW");
+        env.model.dispatch("HIDE_COLUMNS_ROWS", {
+            sheetId: env.model.getters.getActiveSheetId(),
+            dimension: "ROW",
+            elements: rows,
+        });
+    },
     isVisible: NOT_ALL_VISIBLE_ROWS_SELECTED,
     icon: "o-spreadsheet-Icon.HIDE_ROW",
 };
 const unhideRows = {
     name: _lt("Unhide rows"),
-    execute: UNHIDE_ROWS_ACTION,
+    execute: (env) => {
+        const columns = env.model.getters.getElementsFromSelection("ROW");
+        env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
+            sheetId: env.model.getters.getActiveSheetId(),
+            dimension: "ROW",
+            elements: columns,
+        });
+    },
     isVisible: (env) => {
         const hiddenRows = env.model.getters
             .getHiddenRowsGroups(env.model.getters.getActiveSheetId())
@@ -16964,7 +17885,14 @@ const unhideRows = {
 };
 const unhideAllRows = {
     name: _lt("Unhide all rows"),
-    execute: UNHIDE_ALL_ROWS_ACTION,
+    execute: (env) => {
+        const sheetId = env.model.getters.getActiveSheetId();
+        env.model.dispatch("UNHIDE_COLUMNS_ROWS", {
+            sheetId,
+            dimension: "ROW",
+            elements: Array.from(Array(env.model.getters.getNumberRows(sheetId)).keys()),
+        });
+    },
     isVisible: (env) => env.model.getters.getHiddenRowsGroups(env.model.getters.getActiveSheetId()).length > 0,
 };
 const unFreezePane = {
@@ -17038,12 +17966,18 @@ const viewGridlines = {
     name: (env) => env.model.getters.getGridLinesVisibility(env.model.getters.getActiveSheetId())
         ? _lt("Hide gridlines")
         : _lt("Show gridlines"),
-    execute: SET_GRID_LINES_VISIBILITY_ACTION,
+    execute: (env) => {
+        const sheetId = env.model.getters.getActiveSheetId();
+        env.model.dispatch("SET_GRID_LINES_VISIBILITY", {
+            sheetId,
+            areGridLinesVisible: !env.model.getters.getGridLinesVisibility(sheetId),
+        });
+    },
     icon: "o-spreadsheet-Icon.SHOW_HIDE_GRID",
 };
 const viewFormulas = {
     name: (env) => env.model.getters.shouldShowFormulas() ? _lt("Hide formulas") : _lt("Show formulas"),
-    execute: SET_FORMULA_VISIBILITY_ACTION,
+    execute: (env) => env.model.dispatch("SET_FORMULA_VISIBILITY", { show: !env.model.getters.shouldShowFormulas() }),
     isReadonlyAllowed: true,
     icon: "o-spreadsheet-Icon.SHOW_HIDE_FORMULA",
 };
@@ -18007,10 +18941,10 @@ class LineBarPieConfigPanel extends Component {
         return cancelledReasons.map((error) => ChartTerms.Errors[error] || ChartTerms.Errors.Unexpected);
     }
     get isDatasetInvalid() {
-        return !!this.state.datasetDispatchResult?.isCancelledBecause(32 /* CommandResult.InvalidDataSet */);
+        return !!this.state.datasetDispatchResult?.isCancelledBecause(33 /* CommandResult.InvalidDataSet */);
     }
     get isLabelInvalid() {
-        return !!this.state.labelsDispatchResult?.isCancelledBecause(33 /* CommandResult.InvalidLabelRange */);
+        return !!this.state.labelsDispatchResult?.isCancelledBecause(34 /* CommandResult.InvalidLabelRange */);
     }
     onUpdateDataSetsHaveTitle(ev) {
         this.props.updateChart(this.props.figureId, {
@@ -18641,12 +19575,14 @@ class LineBarPieDesignPanel extends Component {
     static template = "o-spreadsheet-LineBarPieDesignPanel";
     static components = { ColorPickerWidget };
     state = useState({
+        title: "",
         fillColorTool: false,
     });
     onClick(ev) {
         this.state.fillColorTool = false;
     }
     setup() {
+        this.state.title = _t(this.props.definition.title);
         useExternalListener(window, "click", this.onClick);
     }
     toggleColorPicker() {
@@ -18657,9 +19593,9 @@ class LineBarPieDesignPanel extends Component {
             background: color,
         });
     }
-    updateTitle(ev) {
+    updateTitle() {
         this.props.updateChart(this.props.figureId, {
-            title: ev.target.value,
+            title: this.state.title,
         });
     }
     updateSelect(attr, ev) {
@@ -18691,7 +19627,7 @@ class GaugeChartConfigPanel extends Component {
         return cancelledReasons.map((error) => ChartTerms.Errors[error] || ChartTerms.Errors.Unexpected);
     }
     get isDataRangeInvalid() {
-        return !!this.state.dataRangeDispatchResult?.isCancelledBecause(36 /* CommandResult.InvalidGaugeDataRange */);
+        return !!this.state.dataRangeDispatchResult?.isCancelledBecause(37 /* CommandResult.InvalidGaugeDataRange */);
     }
     onDataRangeChanged(ranges) {
         this.dataRange = ranges[0];
@@ -18750,11 +19686,13 @@ class GaugeChartDesignPanel extends Component {
     static template = "o-spreadsheet-GaugeChartDesignPanel";
     static components = { ColorPickerWidget, SidePanelErrors };
     state = useState({
+        title: "",
         openedMenu: undefined,
         sectionRuleDispatchResult: undefined,
         sectionRule: deepCopy(this.props.definition.sectionRule),
     });
     setup() {
+        this.state.title = _t(this.props.definition.title);
         useExternalListener(window, "click", this.closeMenus);
     }
     get designErrorMessages() {
@@ -18767,31 +19705,31 @@ class GaugeChartDesignPanel extends Component {
             background: color,
         });
     }
-    updateTitle(ev) {
+    updateTitle() {
         this.props.updateChart(this.props.figureId, {
-            title: ev.target.value,
+            title: this.state.title,
         });
     }
     isRangeMinInvalid() {
-        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(37 /* CommandResult.EmptyGaugeRangeMin */) ||
-            this.state.sectionRuleDispatchResult?.isCancelledBecause(38 /* CommandResult.GaugeRangeMinNaN */) ||
-            this.state.sectionRuleDispatchResult?.isCancelledBecause(41 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */));
+        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(38 /* CommandResult.EmptyGaugeRangeMin */) ||
+            this.state.sectionRuleDispatchResult?.isCancelledBecause(39 /* CommandResult.GaugeRangeMinNaN */) ||
+            this.state.sectionRuleDispatchResult?.isCancelledBecause(42 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */));
     }
     isRangeMaxInvalid() {
-        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(39 /* CommandResult.EmptyGaugeRangeMax */) ||
-            this.state.sectionRuleDispatchResult?.isCancelledBecause(40 /* CommandResult.GaugeRangeMaxNaN */) ||
-            this.state.sectionRuleDispatchResult?.isCancelledBecause(41 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */));
+        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(40 /* CommandResult.EmptyGaugeRangeMax */) ||
+            this.state.sectionRuleDispatchResult?.isCancelledBecause(41 /* CommandResult.GaugeRangeMaxNaN */) ||
+            this.state.sectionRuleDispatchResult?.isCancelledBecause(42 /* CommandResult.GaugeRangeMinBiggerThanRangeMax */));
     }
     // ---------------------------------------------------------------------------
     // COLOR_SECTION_TEMPLATE
     // ---------------------------------------------------------------------------
     get isLowerInflectionPointInvalid() {
-        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(42 /* CommandResult.GaugeLowerInflectionPointNaN */) ||
-            this.state.sectionRuleDispatchResult?.isCancelledBecause(44 /* CommandResult.GaugeLowerBiggerThanUpper */));
+        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(43 /* CommandResult.GaugeLowerInflectionPointNaN */) ||
+            this.state.sectionRuleDispatchResult?.isCancelledBecause(45 /* CommandResult.GaugeLowerBiggerThanUpper */));
     }
     get isUpperInflectionPointInvalid() {
-        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(43 /* CommandResult.GaugeUpperInflectionPointNaN */) ||
-            this.state.sectionRuleDispatchResult?.isCancelledBecause(44 /* CommandResult.GaugeLowerBiggerThanUpper */));
+        return !!(this.state.sectionRuleDispatchResult?.isCancelledBecause(44 /* CommandResult.GaugeUpperInflectionPointNaN */) ||
+            this.state.sectionRuleDispatchResult?.isCancelledBecause(45 /* CommandResult.GaugeLowerBiggerThanUpper */));
     }
     updateSectionColor(target, color) {
         const sectionRule = deepCopy(this.state.sectionRule);
@@ -18874,10 +19812,10 @@ class ScorecardChartConfigPanel extends Component {
         return cancelledReasons.map((error) => ChartTerms.Errors[error] || ChartTerms.Errors.Unexpected);
     }
     get isKeyValueInvalid() {
-        return !!this.state.keyValueDispatchResult?.isCancelledBecause(34 /* CommandResult.InvalidScorecardKeyValue */);
+        return !!this.state.keyValueDispatchResult?.isCancelledBecause(35 /* CommandResult.InvalidScorecardKeyValue */);
     }
     get isBaselineInvalid() {
-        return !!this.state.keyValueDispatchResult?.isCancelledBecause(35 /* CommandResult.InvalidScorecardBaseline */);
+        return !!this.state.keyValueDispatchResult?.isCancelledBecause(36 /* CommandResult.InvalidScorecardBaseline */);
     }
     onKeyValueRangeChanged(ranges) {
         this.keyValue = ranges[0];
@@ -18922,14 +19860,16 @@ class ScorecardChartDesignPanel extends Component {
     static template = "o-spreadsheet-ScorecardChartDesignPanel";
     static components = { ColorPickerWidget };
     state = useState({
+        title: "",
         openedColorPicker: undefined,
     });
     setup() {
+        this.state.title = _t(this.props.definition.title);
         useExternalListener(window, "click", this.closeMenus);
     }
-    updateTitle(ev) {
+    updateTitle() {
         this.props.updateChart(this.props.figureId, {
-            title: ev.target.value,
+            title: this.state.title,
         });
     }
     updateBaselineDescr(ev) {
@@ -19551,7 +20491,7 @@ class ConditionalFormattingPanel extends Component {
         return this.env.model.getters.getConditionalFormats(this.env.model.getters.getActiveSheetId());
     }
     get isRangeValid() {
-        return this.state.errors.includes(24 /* CommandResult.EmptyRange */);
+        return this.state.errors.includes(25 /* CommandResult.EmptyRange */);
     }
     errorMessage(error) {
         return CfTerms.Errors[error] || CfTerms.Errors.Unexpected;
@@ -19610,7 +20550,7 @@ class ConditionalFormattingPanel extends Component {
         if (this.state.currentCF) {
             const invalidRanges = this.state.currentCF.ranges.some((xc) => !xc.match(rangeReference));
             if (invalidRanges) {
-                this.state.errors = [25 /* CommandResult.InvalidRange */];
+                this.state.errors = [26 /* CommandResult.InvalidRange */];
                 return;
             }
             const sheetId = this.env.model.getters.getActiveSheetId();
@@ -19765,10 +20705,10 @@ class ConditionalFormattingPanel extends Component {
      * Cell Is Rule
      ****************************************************************************/
     get isValue1Invalid() {
-        return !!this.state.errors?.includes(51 /* CommandResult.FirstArgMissing */);
+        return !!this.state.errors?.includes(52 /* CommandResult.FirstArgMissing */);
     }
     get isValue2Invalid() {
-        return !!this.state.errors?.includes(52 /* CommandResult.SecondArgMissing */);
+        return !!this.state.errors?.includes(53 /* CommandResult.SecondArgMissing */);
     }
     toggleStyle(tool) {
         const style = this.state.rules.cellIs.style;
@@ -19785,17 +20725,17 @@ class ConditionalFormattingPanel extends Component {
     isValueInvalid(threshold) {
         switch (threshold) {
             case "minimum":
-                return (this.state.errors.includes(58 /* CommandResult.MinInvalidFormula */) ||
-                    this.state.errors.includes(50 /* CommandResult.MinBiggerThanMid */) ||
-                    this.state.errors.includes(47 /* CommandResult.MinBiggerThanMax */) ||
-                    this.state.errors.includes(53 /* CommandResult.MinNaN */));
+                return (this.state.errors.includes(59 /* CommandResult.MinInvalidFormula */) ||
+                    this.state.errors.includes(51 /* CommandResult.MinBiggerThanMid */) ||
+                    this.state.errors.includes(48 /* CommandResult.MinBiggerThanMax */) ||
+                    this.state.errors.includes(54 /* CommandResult.MinNaN */));
             case "midpoint":
-                return (this.state.errors.includes(59 /* CommandResult.MidInvalidFormula */) ||
-                    this.state.errors.includes(54 /* CommandResult.MidNaN */) ||
-                    this.state.errors.includes(49 /* CommandResult.MidBiggerThanMax */));
+                return (this.state.errors.includes(60 /* CommandResult.MidInvalidFormula */) ||
+                    this.state.errors.includes(55 /* CommandResult.MidNaN */) ||
+                    this.state.errors.includes(50 /* CommandResult.MidBiggerThanMax */));
             case "maximum":
-                return (this.state.errors.includes(60 /* CommandResult.MaxInvalidFormula */) ||
-                    this.state.errors.includes(55 /* CommandResult.MaxNaN */));
+                return (this.state.errors.includes(61 /* CommandResult.MaxInvalidFormula */) ||
+                    this.state.errors.includes(56 /* CommandResult.MaxNaN */));
             default:
                 return false;
         }
@@ -19843,13 +20783,13 @@ class ConditionalFormattingPanel extends Component {
     isInflectionPointInvalid(inflectionPoint) {
         switch (inflectionPoint) {
             case "lowerInflectionPoint":
-                return (this.state.errors.includes(57 /* CommandResult.ValueLowerInflectionNaN */) ||
-                    this.state.errors.includes(62 /* CommandResult.ValueLowerInvalidFormula */) ||
-                    this.state.errors.includes(48 /* CommandResult.LowerBiggerThanUpper */));
+                return (this.state.errors.includes(58 /* CommandResult.ValueLowerInflectionNaN */) ||
+                    this.state.errors.includes(63 /* CommandResult.ValueLowerInvalidFormula */) ||
+                    this.state.errors.includes(49 /* CommandResult.LowerBiggerThanUpper */));
             case "upperInflectionPoint":
-                return (this.state.errors.includes(56 /* CommandResult.ValueUpperInflectionNaN */) ||
-                    this.state.errors.includes(61 /* CommandResult.ValueUpperInvalidFormula */) ||
-                    this.state.errors.includes(48 /* CommandResult.LowerBiggerThanUpper */));
+                return (this.state.errors.includes(57 /* CommandResult.ValueUpperInflectionNaN */) ||
+                    this.state.errors.includes(62 /* CommandResult.ValueUpperInvalidFormula */) ||
+                    this.state.errors.includes(49 /* CommandResult.LowerBiggerThanUpper */));
             default:
                 return true;
         }
@@ -20159,7 +21099,7 @@ const SplitToColumnsInteractiveContent = {
 };
 function interactiveSplitToColumns(env, separator, addNewColumns) {
     let result = env.model.dispatch("SPLIT_TEXT_INTO_COLUMNS", { separator, addNewColumns });
-    if (result.isCancelledBecause(90 /* CommandResult.SplitWillOverwriteContent */)) {
+    if (result.isCancelledBecause(91 /* CommandResult.SplitWillOverwriteContent */)) {
         env.askConfirmation(SplitToColumnsInteractiveContent.SplitIsDestructive, () => {
             result = env.model.dispatch("SPLIT_TEXT_INTO_COLUMNS", {
                 separator,
@@ -20223,8 +21163,8 @@ class SplitIntoColumnsPanel extends Component {
         const errors = new Set();
         for (const reason of cancelledReasons) {
             switch (reason) {
-                case 90 /* CommandResult.SplitWillOverwriteContent */:
-                case 89 /* CommandResult.EmptySplitSeparator */:
+                case 91 /* CommandResult.SplitWillOverwriteContent */:
+                case 90 /* CommandResult.EmptySplitSeparator */:
                     break;
                 default:
                     errors.add(SplitToColumnsTerms.Errors[reason] || SplitToColumnsTerms.Errors.Unexpected);
@@ -20239,8 +21179,8 @@ class SplitIntoColumnsPanel extends Component {
             addNewColumns: this.state.addNewColumns,
             force: false,
         }).reasons;
-        if (cancelledReasons.includes(90 /* CommandResult.SplitWillOverwriteContent */)) {
-            warnings.push(SplitToColumnsTerms.Errors[90 /* CommandResult.SplitWillOverwriteContent */]);
+        if (cancelledReasons.includes(91 /* CommandResult.SplitWillOverwriteContent */)) {
+            warnings.push(SplitToColumnsTerms.Errors[91 /* CommandResult.SplitWillOverwriteContent */]);
         }
         return warnings;
     }
@@ -20893,6 +21833,13 @@ class ContentEditableHelper {
         const element = focusedNode instanceof HTMLElement ? focusedNode : focusedNode.parentElement;
         element?.scrollIntoView({ block: "nearest" });
     }
+    /**
+     * remove the current selection of the user
+     * */
+    removeSelection() {
+        let selection = window.getSelection();
+        selection.removeAllRanges();
+    }
     removeAll() {
         if (this.el) {
             while (this.el.firstChild) {
@@ -21379,6 +22326,21 @@ class Composer extends Component {
         this.autoCompleteState.values = values.slice(0, 10);
         this.autoCompleteState.selectedIndex = 0;
     }
+    /**
+     * This is required to ensure the content helper selection is
+     * properly updated on "onclick" events. Depending on the browser,
+     * the callback onClick from the composer will be executed before
+     * the selection was updated in the dom, which means we capture an
+     * wrong selection which is then forced upon the content helper on
+     * patchContent.
+     */
+    onMousedown(ev) {
+        if (ev.button > 0) {
+            // not main button, probably a context menu
+            return;
+        }
+        this.contentHelper.removeSelection();
+    }
     onClick() {
         if (this.env.model.getters.isReadonly()) {
             return;
@@ -21391,6 +22353,29 @@ class Composer extends Component {
         this.env.model.dispatch("CHANGE_COMPOSER_CURSOR_SELECTION", newSelection);
         this.processTokenAtCursor();
     }
+    onDblClick() {
+        if (this.env.model.getters.isReadonly()) {
+            return;
+        }
+        const composerContent = this.env.model.getters.getCurrentContent();
+        const isValidFormula = composerContent.startsWith("=");
+        if (isValidFormula) {
+            const tokens = this.env.model.getters.getCurrentTokens();
+            const currentSelection = this.contentHelper.getCurrentSelection();
+            if (currentSelection.start === currentSelection.end)
+                return;
+            const currentSelectedText = composerContent.substring(currentSelection.start, currentSelection.end);
+            const token = tokens.filter((token) => token.value.includes(currentSelectedText) &&
+                token.start <= currentSelection.start &&
+                token.end >= currentSelection.end)[0];
+            if (token.type === "REFERENCE") {
+                this.env.model.dispatch("CHANGE_COMPOSER_CURSOR_SELECTION", {
+                    start: token.start,
+                    end: token.end,
+                });
+            }
+        }
+    }
     // ---------------------------------------------------------------------------
     // Private
     // ---------------------------------------------------------------------------
@@ -21419,7 +22404,7 @@ class Composer extends Component {
      */
     getContentLines() {
         let value = this.env.model.getters.getCurrentContent();
-        const isValidFormula = value.startsWith("=") && this.env.model.getters.getCurrentTokens().length > 0;
+        const isValidFormula = value.startsWith("=");
         if (value === "") {
             return [];
         }
@@ -24128,7 +25113,7 @@ class Grid extends Component {
         }
         ev.preventDefault();
     }
-    paste(ev) {
+    async paste(ev) {
         if (!this.gridEl.contains(document.activeElement)) {
             return;
         }
@@ -24148,6 +25133,9 @@ class Grid extends Component {
             else {
                 interactivePasteFromOS(this.env, target, content);
             }
+            if (this.env.model.getters.isCutOperation()) {
+                await this.env.clipboard.write({ [ClipboardMIMEType.PlainText]: "" });
+            }
         }
     }
     displayWarningCopyPasteNotSupported() {
@@ -30087,9 +31075,9 @@ class CellPlugin extends CorePlugin {
     checkCellOutOfSheet(sheetId, col, row) {
         const sheet = this.getters.tryGetSheet(sheetId);
         if (!sheet)
-            return 27 /* CommandResult.InvalidSheetId */;
+            return 28 /* CommandResult.InvalidSheetId */;
         const sheetZone = this.getters.getSheetZone(sheetId);
-        return isInside(col, row, sheetZone) ? 0 /* CommandResult.Success */ : 18 /* CommandResult.TargetOutOfSheet */;
+        return isInside(col, row, sheetZone) ? 0 /* CommandResult.Success */ : 19 /* CommandResult.TargetOutOfSheet */;
     }
 }
 class FormulaCellWithDependencies {
@@ -30312,13 +31300,13 @@ class ChartPlugin extends CorePlugin {
     }
     checkChartDuplicate(cmd) {
         return this.getters.getFigureSheetId(cmd.id)
-            ? 84 /* CommandResult.DuplicatedChartId */
+            ? 85 /* CommandResult.DuplicatedChartId */
             : 0 /* CommandResult.Success */;
     }
     checkChartExists(cmd) {
         return this.getters.getFigureSheetId(cmd.id)
             ? 0 /* CommandResult.Success */
-            : 85 /* CommandResult.ChartDoesNotExist */;
+            : 86 /* CommandResult.ChartDoesNotExist */;
     }
 }
 
@@ -30527,18 +31515,18 @@ class ConditionalFormatPlugin extends CorePlugin {
     }
     checkValidReordering(cfId, direction, sheetId) {
         if (!this.cfRules[sheetId])
-            return 27 /* CommandResult.InvalidSheetId */;
+            return 28 /* CommandResult.InvalidSheetId */;
         const ruleIndex = this.cfRules[sheetId].findIndex((cf) => cf.id === cfId);
         if (ruleIndex === -1)
-            return 71 /* CommandResult.InvalidConditionalFormatId */;
+            return 72 /* CommandResult.InvalidConditionalFormatId */;
         const cfIndex2 = direction === "up" ? ruleIndex - 1 : ruleIndex + 1;
         if (cfIndex2 < 0 || cfIndex2 >= this.cfRules[sheetId].length) {
-            return 71 /* CommandResult.InvalidConditionalFormatId */;
+            return 72 /* CommandResult.InvalidConditionalFormatId */;
         }
         return 0 /* CommandResult.Success */;
     }
     checkEmptyRange(cmd) {
-        return cmd.ranges.length ? 0 /* CommandResult.Success */ : 24 /* CommandResult.EmptyRange */;
+        return cmd.ranges.length ? 0 /* CommandResult.Success */ : 25 /* CommandResult.EmptyRange */;
     }
     checkCFRule(cmd) {
         const rule = cmd.cf.rule;
@@ -30574,10 +31562,10 @@ class ConditionalFormatPlugin extends CorePlugin {
                 const errors = [];
                 const isEmpty = (value) => value === undefined || value === "";
                 if (expectedNumber >= 1 && isEmpty(rule.values[0])) {
-                    errors.push(51 /* CommandResult.FirstArgMissing */);
+                    errors.push(52 /* CommandResult.FirstArgMissing */);
                 }
                 if (expectedNumber >= 2 && isEmpty(rule.values[1])) {
-                    errors.push(52 /* CommandResult.SecondArgMissing */);
+                    errors.push(53 /* CommandResult.SecondArgMissing */);
                 }
                 return errors.length ? errors : 0 /* CommandResult.Success */;
             }
@@ -30589,15 +31577,15 @@ class ConditionalFormatPlugin extends CorePlugin {
             (threshold.value === "" || isNaN(threshold.value))) {
             switch (thresholdName) {
                 case "min":
-                    return 53 /* CommandResult.MinNaN */;
+                    return 54 /* CommandResult.MinNaN */;
                 case "max":
-                    return 55 /* CommandResult.MaxNaN */;
+                    return 56 /* CommandResult.MaxNaN */;
                 case "mid":
-                    return 54 /* CommandResult.MidNaN */;
+                    return 55 /* CommandResult.MidNaN */;
                 case "upperInflectionPoint":
-                    return 56 /* CommandResult.ValueUpperInflectionNaN */;
+                    return 57 /* CommandResult.ValueUpperInflectionNaN */;
                 case "lowerInflectionPoint":
-                    return 57 /* CommandResult.ValueLowerInflectionNaN */;
+                    return 58 /* CommandResult.ValueLowerInflectionNaN */;
             }
         }
         return 0 /* CommandResult.Success */;
@@ -30611,15 +31599,15 @@ class ConditionalFormatPlugin extends CorePlugin {
         catch (error) {
             switch (thresholdName) {
                 case "min":
-                    return 58 /* CommandResult.MinInvalidFormula */;
+                    return 59 /* CommandResult.MinInvalidFormula */;
                 case "max":
-                    return 60 /* CommandResult.MaxInvalidFormula */;
+                    return 61 /* CommandResult.MaxInvalidFormula */;
                 case "mid":
-                    return 59 /* CommandResult.MidInvalidFormula */;
+                    return 60 /* CommandResult.MidInvalidFormula */;
                 case "upperInflectionPoint":
-                    return 61 /* CommandResult.ValueUpperInvalidFormula */;
+                    return 62 /* CommandResult.ValueUpperInvalidFormula */;
                 case "lowerInflectionPoint":
-                    return 62 /* CommandResult.ValueLowerInvalidFormula */;
+                    return 63 /* CommandResult.ValueLowerInvalidFormula */;
             }
         }
         return 0 /* CommandResult.Success */;
@@ -30636,7 +31624,7 @@ class ConditionalFormatPlugin extends CorePlugin {
         if (["number", "percentage", "percentile"].includes(rule.lowerInflectionPoint.type) &&
             rule.lowerInflectionPoint.type === rule.upperInflectionPoint.type &&
             Number(minValue) > Number(maxValue)) {
-            return 48 /* CommandResult.LowerBiggerThanUpper */;
+            return 49 /* CommandResult.LowerBiggerThanUpper */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -30646,7 +31634,7 @@ class ConditionalFormatPlugin extends CorePlugin {
         if (["number", "percentage", "percentile"].includes(rule.minimum.type) &&
             rule.minimum.type === rule.maximum.type &&
             stringToNumber(minValue) >= stringToNumber(maxValue)) {
-            return 47 /* CommandResult.MinBiggerThanMax */;
+            return 48 /* CommandResult.MinBiggerThanMax */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -30657,7 +31645,7 @@ class ConditionalFormatPlugin extends CorePlugin {
             ["number", "percentage", "percentile"].includes(rule.midpoint.type) &&
             rule.midpoint.type === rule.maximum.type &&
             stringToNumber(midValue) >= stringToNumber(maxValue)) {
-            return 49 /* CommandResult.MidBiggerThanMax */;
+            return 50 /* CommandResult.MidBiggerThanMax */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -30668,7 +31656,7 @@ class ConditionalFormatPlugin extends CorePlugin {
             ["number", "percentage", "percentile"].includes(rule.midpoint.type) &&
             rule.minimum.type === rule.midpoint.type &&
             stringToNumber(minValue) >= stringToNumber(midValue)) {
-            return 50 /* CommandResult.MinBiggerThanMid */;
+            return 51 /* CommandResult.MinBiggerThanMid */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -30798,13 +31786,13 @@ class FigurePlugin extends CorePlugin {
     }
     checkFigureExists(sheetId, figureId) {
         if (this.figures[sheetId]?.[figureId] === undefined) {
-            return 70 /* CommandResult.FigureDoesNotExist */;
+            return 71 /* CommandResult.FigureDoesNotExist */;
         }
         return 0 /* CommandResult.Success */;
     }
     checkFigureDuplicate(figureId) {
         if (Object.values(this.figures).find((sheet) => sheet?.[figureId])) {
-            return 82 /* CommandResult.DuplicatedFigureId */;
+            return 83 /* CommandResult.DuplicatedFigureId */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -30916,12 +31904,12 @@ class FiltersPlugin extends CorePlugin {
         switch (cmd.type) {
             case "CREATE_FILTER_TABLE":
                 if (!areZonesContinuous(...cmd.target)) {
-                    return 81 /* CommandResult.NonContinuousTargets */;
+                    return 82 /* CommandResult.NonContinuousTargets */;
                 }
                 const zone = union(...cmd.target);
                 const checkFilterOverlap = () => {
                     if (this.getFilterTables(cmd.sheetId).some((filter) => overlap(filter.zone, zone))) {
-                        return 78 /* CommandResult.FilterOverlap */;
+                        return 79 /* CommandResult.FilterOverlap */;
                     }
                     return 0 /* CommandResult.Success */;
                 };
@@ -30929,7 +31917,7 @@ class FiltersPlugin extends CorePlugin {
                     const mergesInTarget = this.getters.getMergesInZone(cmd.sheetId, zone);
                     for (let merge of mergesInTarget) {
                         if (overlap(zone, merge)) {
-                            return 80 /* CommandResult.MergeInFilter */;
+                            return 81 /* CommandResult.MergeInFilter */;
                         }
                     }
                     return 0 /* CommandResult.Success */;
@@ -30939,7 +31927,7 @@ class FiltersPlugin extends CorePlugin {
                 for (let merge of cmd.target) {
                     for (let filterTable of this.getFilterTables(cmd.sheetId)) {
                         if (overlap(filterTable.zone, merge)) {
-                            return 80 /* CommandResult.MergeInFilter */;
+                            return 81 /* CommandResult.MergeInFilter */;
                         }
                     }
                 }
@@ -30958,7 +31946,14 @@ class FiltersPlugin extends CorePlugin {
                 this.history.update("tables", filterTables);
                 break;
             case "DUPLICATE_SHEET":
-                this.history.update("tables", cmd.sheetIdTo, deepCopy(this.tables[cmd.sheetId]));
+                const tables = {};
+                for (const filterTable of Object.values(this.tables[cmd.sheetId] || {})) {
+                    if (filterTable) {
+                        const newFilterTable = deepCopy(filterTable);
+                        tables[newFilterTable.id] = newFilterTable;
+                    }
+                }
+                this.history.update("tables", cmd.sheetIdTo, tables);
                 break;
             case "ADD_COLUMNS_ROWS":
                 this.onAddColumnsRows(cmd);
@@ -31410,7 +32405,7 @@ class HeaderVisibilityPlugin extends CorePlugin {
         switch (cmd.type) {
             case "HIDE_COLUMNS_ROWS": {
                 if (!this.getters.tryGetSheet(cmd.sheetId)) {
-                    return 27 /* CommandResult.InvalidSheetId */;
+                    return 28 /* CommandResult.InvalidSheetId */;
                 }
                 const hiddenGroup = cmd.dimension === "COL"
                     ? this.getHiddenColsGroups(cmd.sheetId)
@@ -31420,10 +32415,10 @@ class HeaderVisibilityPlugin extends CorePlugin {
                     : this.getters.getNumberRows(cmd.sheetId);
                 const hiddenElements = new Set((hiddenGroup || []).flat().concat(cmd.elements));
                 if (hiddenElements.size >= elements) {
-                    return 66 /* CommandResult.TooManyHiddenElements */;
+                    return 67 /* CommandResult.TooManyHiddenElements */;
                 }
                 else if (Math.min(...cmd.elements) < 0 || Math.max(...cmd.elements) > elements) {
-                    return 86 /* CommandResult.InvalidHeaderIndex */;
+                    return 87 /* CommandResult.InvalidHeaderIndex */;
                 }
                 else {
                     return 0 /* CommandResult.Success */;
@@ -31431,7 +32426,7 @@ class HeaderVisibilityPlugin extends CorePlugin {
             }
             case "REMOVE_COLUMNS_ROWS":
                 if (!this.getters.tryGetSheet(cmd.sheetId)) {
-                    return 27 /* CommandResult.InvalidSheetId */;
+                    return 28 /* CommandResult.InvalidSheetId */;
                 }
                 if (!this.canRemoveHeaders(cmd.sheetId, cmd.dimension, cmd.elements)) {
                     return 8 /* CommandResult.NotEnoughElements */;
@@ -31599,7 +32594,7 @@ class ImagePlugin extends CorePlugin {
         switch (cmd.type) {
             case "CREATE_IMAGE":
                 if (this.getters.getFigure(cmd.sheetId, cmd.figureId)) {
-                    return 28 /* CommandResult.InvalidFigureId */;
+                    return 29 /* CommandResult.InvalidFigureId */;
                 }
                 return 0 /* CommandResult.Success */;
             default:
@@ -31987,7 +32982,7 @@ class MergePlugin extends CorePlugin {
         for (const zone of target) {
             for (const zone2 of target) {
                 if (zone !== zone2 && overlap(zone, zone2)) {
-                    return 65 /* CommandResult.MergeOverlap */;
+                    return 66 /* CommandResult.MergeOverlap */;
                 }
             }
         }
@@ -32001,7 +32996,7 @@ class MergePlugin extends CorePlugin {
         for (const zone of target) {
             if ((zone.left < xSplit && zone.right >= xSplit) ||
                 (zone.top < ySplit && zone.bottom >= ySplit)) {
-                return 75 /* CommandResult.FrozenPaneOverlap */;
+                return 76 /* CommandResult.FrozenPaneOverlap */;
             }
         }
         return 0 /* CommandResult.Success */;
@@ -32195,7 +33190,7 @@ class RangeAdapter {
     // ---------------------------------------------------------------------------
     allowDispatch(cmd) {
         if (cmd.type === "MOVE_RANGES") {
-            return cmd.target.length === 1 ? 0 /* CommandResult.Success */ : 26 /* CommandResult.InvalidZones */;
+            return cmd.target.length === 1 ? 0 /* CommandResult.Success */ : 27 /* CommandResult.InvalidZones */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -32620,7 +33615,7 @@ class SheetPlugin extends CorePlugin {
                     return 0 /* CommandResult.Success */;
                 }
                 catch (e) {
-                    return 14 /* CommandResult.WrongSheetMove */;
+                    return 15 /* CommandResult.WrongSheetMove */;
                 }
             case "RENAME_SHEET":
                 return this.isRenameAllowed(cmd);
@@ -32633,10 +33628,10 @@ class SheetPlugin extends CorePlugin {
                     ? this.getNumberCols(cmd.sheetId)
                     : this.getNumberRows(cmd.sheetId);
                 if (cmd.base < 0 || cmd.base > elements) {
-                    return 86 /* CommandResult.InvalidHeaderIndex */;
+                    return 87 /* CommandResult.InvalidHeaderIndex */;
                 }
                 else if (cmd.quantity <= 0) {
-                    return 87 /* CommandResult.InvalidQuantity */;
+                    return 88 /* CommandResult.InvalidQuantity */;
                 }
                 return 0 /* CommandResult.Success */;
             case "REMOVE_COLUMNS_ROWS": {
@@ -32644,7 +33639,7 @@ class SheetPlugin extends CorePlugin {
                     ? this.getNumberCols(cmd.sheetId)
                     : this.getNumberRows(cmd.sheetId);
                 if (Math.min(...cmd.elements) < 0 || Math.max(...cmd.elements) > elements) {
-                    return 86 /* CommandResult.InvalidHeaderIndex */;
+                    return 87 /* CommandResult.InvalidHeaderIndex */;
                 }
                 else {
                     return 0 /* CommandResult.Success */;
@@ -32971,12 +33966,12 @@ class SheetPlugin extends CorePlugin {
      */
     checkZonesExistInSheet(sheetId, zones) {
         if (!zones.every(isZoneValid))
-            return 25 /* CommandResult.InvalidRange */;
+            return 26 /* CommandResult.InvalidRange */;
         if (zones.length) {
             const sheetZone = this.getSheetZone(sheetId);
             return zones.every((zone) => isZoneInside(zone, sheetZone))
                 ? 0 /* CommandResult.Success */
-                : 18 /* CommandResult.TargetOutOfSheet */;
+                : 19 /* CommandResult.TargetOutOfSheet */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -33083,38 +34078,42 @@ class SheetPlugin extends CorePlugin {
         throw new Error(_lt("There is not enough visible sheets"));
     }
     checkSheetName(cmd) {
+        const originalSheetName = this.getters.tryGetSheetName(cmd.sheetId);
+        if (originalSheetName !== undefined && cmd.name === originalSheetName) {
+            return 11 /* CommandResult.UnchangedSheetName */;
+        }
         const { orderedSheetIds, sheets } = this;
         const name = cmd.name && cmd.name.trim().toLowerCase();
-        if (orderedSheetIds.find((id) => sheets[id]?.name.toLowerCase() === name)) {
-            return 11 /* CommandResult.DuplicatedSheetName */;
+        if (orderedSheetIds.find((id) => sheets[id]?.name.toLowerCase() === name && id !== cmd.sheetId)) {
+            return 12 /* CommandResult.DuplicatedSheetName */;
         }
         if (FORBIDDEN_IN_EXCEL_REGEX.test(name)) {
-            return 13 /* CommandResult.ForbiddenCharactersInSheetName */;
+            return 14 /* CommandResult.ForbiddenCharactersInSheetName */;
         }
         return 0 /* CommandResult.Success */;
     }
     checkSheetPosition(cmd) {
         const { orderedSheetIds } = this;
         if (cmd.position > orderedSheetIds.length || cmd.position < 0) {
-            return 15 /* CommandResult.WrongSheetPosition */;
+            return 16 /* CommandResult.WrongSheetPosition */;
         }
         return 0 /* CommandResult.Success */;
     }
     checkRowFreezeQuantity(cmd) {
         return cmd.quantity >= 1 && cmd.quantity < this.getNumberRows(cmd.sheetId)
             ? 0 /* CommandResult.Success */
-            : 74 /* CommandResult.InvalidFreezeQuantity */;
+            : 75 /* CommandResult.InvalidFreezeQuantity */;
     }
     checkColFreezeQuantity(cmd) {
         return cmd.quantity >= 1 && cmd.quantity < this.getNumberCols(cmd.sheetId)
             ? 0 /* CommandResult.Success */
-            : 74 /* CommandResult.InvalidFreezeQuantity */;
+            : 75 /* CommandResult.InvalidFreezeQuantity */;
     }
     checkRowFreezeOverlapMerge(cmd) {
         const merges = this.getters.getMerges(cmd.sheetId);
         for (let merge of merges) {
             if (merge.top < cmd.quantity && cmd.quantity <= merge.bottom) {
-                return 65 /* CommandResult.MergeOverlap */;
+                return 66 /* CommandResult.MergeOverlap */;
             }
         }
         return 0 /* CommandResult.Success */;
@@ -33123,7 +34122,7 @@ class SheetPlugin extends CorePlugin {
         const merges = this.getters.getMerges(cmd.sheetId);
         for (let merge of merges) {
             if (merge.left < cmd.quantity && cmd.quantity <= merge.right) {
-                return 65 /* CommandResult.MergeOverlap */;
+                return 66 /* CommandResult.MergeOverlap */;
             }
         }
         return 0 /* CommandResult.Success */;
@@ -33139,8 +34138,8 @@ class SheetPlugin extends CorePlugin {
         const oldName = sheet.name;
         this.history.update("sheets", sheet.id, "name", name.trim());
         const sheetIdsMapName = Object.assign({}, this.sheetIdsMapName);
-        sheetIdsMapName[name] = sheet.id;
         delete sheetIdsMapName[oldName];
+        sheetIdsMapName[name] = sheet.id;
         this.history.update("sheetIdsMapName", sheetIdsMapName);
     }
     hideSheet(sheetId) {
@@ -33434,10 +34433,10 @@ class SheetPlugin extends CorePlugin {
      */
     checkSheetExists(cmd) {
         if (cmd.type !== "CREATE_SHEET" && "sheetId" in cmd && this.sheets[cmd.sheetId] === undefined) {
-            return 27 /* CommandResult.InvalidSheetId */;
+            return 28 /* CommandResult.InvalidSheetId */;
         }
         else if (cmd.type === "CREATE_SHEET" && this.sheets[cmd.sheetId] !== undefined) {
-            return 12 /* CommandResult.DuplicatedSheetId */;
+            return 13 /* CommandResult.DuplicatedSheetId */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -34998,7 +35997,7 @@ class AutofillPlugin extends UIPlugin {
                 if (this.lastCellSelected.col !== undefined && this.lastCellSelected.row !== undefined) {
                     return 0 /* CommandResult.Success */;
                 }
-                return 45 /* CommandResult.InvalidAutofillSelection */;
+                return 46 /* CommandResult.InvalidAutofillSelection */;
             case "AUTOFILL_AUTO":
                 const zone = this.getters.getSelectedZone();
                 return zone.top === zone.bottom
@@ -35615,7 +36614,7 @@ class CellPopoverPlugin extends UIPlugin {
                     cellPopoverRegistry.get(cmd.popoverType);
                 }
                 catch (error) {
-                    return 72 /* CommandResult.InvalidCellPopover */;
+                    return 73 /* CommandResult.InvalidCellPopover */;
                 }
                 return 0 /* CommandResult.Success */;
             default:
@@ -37745,12 +38744,12 @@ class SelectionInputPlugin extends UIPlugin {
             case "ADD_RANGE":
             case "ADD_EMPTY_RANGE":
                 if (this.inputHasSingleRange && this.ranges.length === 1) {
-                    return 30 /* CommandResult.MaximumRangesReached */;
+                    return 31 /* CommandResult.MaximumRangesReached */;
                 }
                 break;
             case "CHANGE_RANGE":
                 if (this.inputHasSingleRange && cmd.value.split(",").length > 1) {
-                    return 30 /* CommandResult.MaximumRangesReached */;
+                    return 31 /* CommandResult.MaximumRangesReached */;
                 }
                 break;
         }
@@ -37979,7 +38978,7 @@ class SelectionInputsManagerPlugin extends UIPlugin {
             case "FOCUS_RANGE":
                 const index = this.currentInput?.getIndex(cmd.rangeId);
                 if (this.focusedInputId === cmd.id && this.currentInput?.focusedRangeIndex === index) {
-                    return 29 /* CommandResult.InputAlreadyFocused */;
+                    return 30 /* CommandResult.InputAlreadyFocused */;
                 }
                 break;
         }
@@ -38111,7 +39110,7 @@ class SortPlugin extends UIPlugin {
         /*Test the presence of single cells*/
         const singleCells = positions(zone).some(({ col, row }) => !this.getters.isInMerge({ sheetId, col, row }));
         if (singleCells) {
-            return 63 /* CommandResult.InvalidSortZone */;
+            return 64 /* CommandResult.InvalidSortZone */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -38130,7 +39129,7 @@ class SortPlugin extends UIPlugin {
             ];
             return widthCurrent === widthFirst && heightCurrent === heightFirst;
         })) {
-            return 63 /* CommandResult.InvalidSortZone */;
+            return 64 /* CommandResult.InvalidSortZone */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -38623,7 +39622,7 @@ class SheetUIPlugin extends UIPlugin {
      */
     checkSheetExists(cmd) {
         if ("sheetId" in cmd && this.getters.tryGetSheet(cmd.sheetId) === undefined) {
-            return 27 /* CommandResult.InvalidSheetId */;
+            return 28 /* CommandResult.InvalidSheetId */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -38635,7 +39634,7 @@ class SheetUIPlugin extends UIPlugin {
         const sheetId = "sheetId" in cmd ? cmd.sheetId : this.getters.tryGetActiveSheetId();
         const zones = this.getters.getCommandZones(cmd);
         if (!sheetId && zones.length > 0) {
-            return 92 /* CommandResult.NoActiveSheet */;
+            return 93 /* CommandResult.NoActiveSheet */;
         }
         if (sheetId && zones.length > 0) {
             return this.getters.checkZonesExistInSheet(sheetId, zones);
@@ -39117,13 +40116,13 @@ class SplitToColumnsPlugin extends UIPlugin {
     }
     checkSingleColSelected() {
         if (!this.getters.isSingleColSelected()) {
-            return 88 /* CommandResult.MoreThanOneColumnSelected */;
+            return 89 /* CommandResult.MoreThanOneColumnSelected */;
         }
         return 0 /* CommandResult.Success */;
     }
     checkNonEmptySelector(cmd) {
         if (cmd.separator === "") {
-            return 89 /* CommandResult.EmptySplitSeparator */;
+            return 90 /* CommandResult.EmptySplitSeparator */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -39134,7 +40133,7 @@ class SplitToColumnsPlugin extends UIPlugin {
         const selection = this.getters.getSelectedZones()[0];
         const splitted = this.getSplittedCols(selection, cmd.separator);
         if (this.willSplittedColsOverwriteContent(selection, splitted)) {
-            return 90 /* CommandResult.SplitWillOverwriteContent */;
+            return 91 /* CommandResult.SplitWillOverwriteContent */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -39145,7 +40144,7 @@ class SplitToColumnsPlugin extends UIPlugin {
                 return 0 /* CommandResult.Success */;
             }
         }
-        return 91 /* CommandResult.NoSplitSeparatorInSelection */;
+        return 92 /* CommandResult.NoSplitSeparatorInSelection */;
     }
 }
 
@@ -39260,7 +40259,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
     }
     isCutAllowed(target) {
         if (target.length !== 1) {
-            return 19 /* CommandResult.WrongCutSelection */;
+            return 20 /* CommandResult.WrongCutSelection */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -39268,13 +40267,13 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
         const sheetId = this.getters.getActiveSheetId();
         if (this.operation === "CUT" && clipboardOption?.pasteOption !== undefined) {
             // cannot paste only format or only value if the previous operation is a CUT
-            return 21 /* CommandResult.WrongPasteOption */;
+            return 22 /* CommandResult.WrongPasteOption */;
         }
         if (target.length > 1) {
             // cannot paste if we have a clipped zone larger than a cell and multiple
             // zones selected
             if (this.cells.length > 1 || this.cells[0].length > 1) {
-                return 20 /* CommandResult.WrongPasteSelection */;
+                return 21 /* CommandResult.WrongPasteSelection */;
             }
         }
         const clipboardHeight = this.cells.length;
@@ -39292,7 +40291,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
         for (const zone of this.getPasteZones(target)) {
             if ((zone.left < xSplit && zone.right >= xSplit) ||
                 (zone.top < ySplit && zone.bottom >= ySplit)) {
-                return 75 /* CommandResult.FrozenPaneOverlap */;
+                return 76 /* CommandResult.FrozenPaneOverlap */;
             }
         }
         return 0 /* CommandResult.Success */;
@@ -39360,6 +40359,13 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
             });
         }
         this.pasteCopiedTables(target);
+        this.cells.forEach((row) => {
+            row.forEach((c) => {
+                if (c.cell) {
+                    c.cell = undefined;
+                }
+            });
+        });
     }
     /**
      * The clipped zone is copied as many times as it fits in the target.
@@ -39592,7 +40598,9 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
         return (this.cells
             .map((cells) => {
             return cells
-                .map((c) => c.cell ? this.getters.getCellText(c.position, this.getters.shouldShowFormulas()) : "")
+                .map((c) => this.getters.shouldShowFormulas() && c.cell?.isFormula
+                ? c.cell?.content || ""
+                : c.evaluatedCell?.formattedValue || "")
                 .join("\t");
         })
             .join("\n") || "\t");
@@ -39723,10 +40731,10 @@ class ClipboardFigureState {
     }
     isPasteAllowed(target, option) {
         if (target.length === 0) {
-            return 73 /* CommandResult.EmptyTarget */;
+            return 74 /* CommandResult.EmptyTarget */;
         }
         if (option?.pasteOption !== undefined) {
-            return 22 /* CommandResult.WrongFigurePasteOption */;
+            return 23 /* CommandResult.WrongFigurePasteOption */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -39828,7 +40836,10 @@ class ClipboardOsState extends ClipboardCellsAbstractState {
         }
         return 0 /* CommandResult.Success */;
     }
-    paste(target) {
+    paste(target, clipboardOption) {
+        if (clipboardOption?.pasteOption === "onlyFormat") {
+            return;
+        }
         const values = this.values;
         const pasteZone = this.getPasteZone(target);
         const { left: activeCol, top: activeRow } = pasteZone;
@@ -39889,6 +40900,7 @@ class ClipboardPlugin extends UIPlugin {
     state;
     lastPasteState;
     _isPaintingFormat = false;
+    originSheetId;
     // ---------------------------------------------------------------------------
     // Command Handling
     // ---------------------------------------------------------------------------
@@ -39900,13 +40912,13 @@ class ClipboardPlugin extends UIPlugin {
                 return state.isCutAllowed(zones);
             case "PASTE":
                 if (!this.state) {
-                    return 23 /* CommandResult.EmptyClipboard */;
+                    return 24 /* CommandResult.EmptyClipboard */;
                 }
                 const pasteOption = cmd.pasteOption || (this._isPaintingFormat ? "onlyFormat" : undefined);
                 return this.state.isPasteAllowed(cmd.target, { pasteOption });
             case "PASTE_FROM_OS_CLIPBOARD": {
                 const state = new ClipboardOsState(cmd.text, this.getters, this.dispatch, this.selection);
-                return state.isPasteAllowed(cmd.target);
+                return state.isPasteAllowed(cmd.target, { pasteOption: cmd.pasteOption });
             }
             case "INSERT_CELL": {
                 const { cut, paste } = this.getInsertCellsTargets(cmd.zone, cmd.shiftDimension);
@@ -39928,6 +40940,7 @@ class ClipboardPlugin extends UIPlugin {
                 const zones = ("cutTarget" in cmd && cmd.cutTarget) || this.getters.getSelectedZones();
                 this.state = this.getClipboardState(zones, cmd.type);
                 this.status = "visible";
+                this.originSheetId = this.getters.getActiveSheetId();
                 break;
             case "PASTE":
                 if (!this.state) {
@@ -39936,9 +40949,6 @@ class ClipboardPlugin extends UIPlugin {
                 const pasteOption = cmd.pasteOption || (this._isPaintingFormat ? "onlyFormat" : undefined);
                 this._isPaintingFormat = false;
                 this.state.paste(cmd.target, { pasteOption, shouldPasteCF: true, selectTarget: true });
-                if (this.state.operation === "CUT") {
-                    this.state = undefined;
-                }
                 this.lastPasteState = this.state;
                 this.status = "invisible";
                 break;
@@ -39993,7 +41003,7 @@ class ClipboardPlugin extends UIPlugin {
             }
             case "PASTE_FROM_OS_CLIPBOARD":
                 this.state = new ClipboardOsState(cmd.text, this.getters, this.dispatch, this.selection);
-                this.state.paste(cmd.target);
+                this.state.paste(cmd.target, { pasteOption: cmd.pasteOption });
                 this.lastPasteState = this.state;
                 this.status = "invisible";
                 break;
@@ -40012,6 +41022,15 @@ class ClipboardPlugin extends UIPlugin {
                 this.status = "visible";
                 break;
             }
+            case "DELETE_SHEET":
+                if (this.state?.operation !== "CUT") {
+                    return;
+                }
+                if (this.originSheetId === cmd.sheetId) {
+                    this.state = undefined;
+                    this.status = "invisible";
+                }
+                break;
             default:
                 if (isCoreCommand(cmd)) {
                     this.status = "invisible";
@@ -40470,7 +41489,7 @@ class EditionPlugin extends UIPlugin {
     validateSelection(length, start, end) {
         return start >= 0 && start <= length && end >= 0 && end <= length
             ? 0 /* CommandResult.Success */
-            : 46 /* CommandResult.WrongComposerSelection */;
+            : 47 /* CommandResult.WrongComposerSelection */;
     }
     onColumnsRemoved(cmd) {
         if (cmd.elements.includes(this.col) && this.mode !== "inactive") {
@@ -40846,7 +41865,7 @@ class FilterEvaluationPlugin extends UIPlugin {
         switch (cmd.type) {
             case "UPDATE_FILTER":
                 if (!this.getters.getFilterId(cmd)) {
-                    return 79 /* CommandResult.FilterNotFound */;
+                    return 80 /* CommandResult.FilterNotFound */;
                 }
                 break;
         }
@@ -40987,6 +42006,7 @@ class FilterEvaluationPlugin extends UIPlugin {
     }
     exportForExcel(data) {
         for (const sheetData of data.sheets) {
+            const sheetId = sheetData.id;
             for (const tableData of sheetData.filterTables) {
                 const tableZone = toZone(tableData.range);
                 const filters = [];
@@ -41002,20 +42022,20 @@ class FilterEvaluationPlugin extends UIPlugin {
                     if (!filter)
                         continue;
                     const valuesInFilterZone = filter.filteredZone
-                        ? positions(filter.filteredZone)
-                            .map(({ col, row }) => this.getters.getEvaluatedCell({ sheetId: sheetData.id, col, row }))
-                            .filter((cell) => cell.type !== CellValueType.empty)
-                            .map((cell) => cell.formattedValue)
+                        ? positions(filter.filteredZone).map((position) => this.getters.getEvaluatedCell({ sheetId, ...position }).formattedValue)
                         : [];
-                    // In xlsx, filtered values = values that are displayed, not values that are hidden
-                    const xlsxFilteredValues = valuesInFilterZone.filter((val) => !filteredValues.includes(val));
-                    filters.push({ colId: i, filteredValues: [...new Set(xlsxFilteredValues)] });
-                    // In xlsx, filter header should ALWAYS be a string and should be unique
-                    const headerPosition = {
-                        col: filter.col,
-                        row: filter.zoneWithHeaders.top,
-                        sheetId: sheetData.id,
-                    };
+                    if (filteredValues.length) {
+                        const xlsxDisplayedValues = valuesInFilterZone
+                            .filter((val) => val)
+                            .filter((val) => !filteredValues.includes(val));
+                        filters.push({
+                            colId: i,
+                            displayedValues: [...new Set(xlsxDisplayedValues)],
+                            displayBlanks: !filteredValues.includes("") && valuesInFilterZone.some((val) => !val),
+                        });
+                    }
+                    // In xlsx, filter header should ALWAYS be a string and should be unique in the table
+                    const headerPosition = { col: filter.col, row: filter.zoneWithHeaders.top, sheetId };
                     const headerString = this.getters.getEvaluatedCell(headerPosition).formattedValue;
                     const headerName = this.getUniqueColNameForExcel(i, headerString, headerNames);
                     headerNames.push(headerName);
@@ -41134,7 +42154,7 @@ class GridSelectionPlugin extends UIPlugin {
                     break;
                 }
                 catch (error) {
-                    return 27 /* CommandResult.InvalidSheetId */;
+                    return 28 /* CommandResult.InvalidSheetId */;
                 }
             case "MOVE_COLUMNS_ROWS":
                 return this.isMoveElementAllowed(cmd);
@@ -42437,7 +43457,7 @@ class SheetViewPlugin extends UIPlugin {
     }
     checkPositiveDimension(cmd) {
         if (cmd.width < 0 || cmd.height < 0) {
-            return 68 /* CommandResult.InvalidViewportSize */;
+            return 69 /* CommandResult.InvalidViewportSize */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -42447,7 +43467,7 @@ class SheetViewPlugin extends UIPlugin {
             cmd.gridOffsetY === this.gridOffsetY &&
             cmd.width === width &&
             cmd.height === height) {
-            return 76 /* CommandResult.ValuesNotChanged */;
+            return 77 /* CommandResult.ValuesNotChanged */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -42455,7 +43475,7 @@ class SheetViewPlugin extends UIPlugin {
         const pane = this.getMainInternalViewport(this.getters.getActiveSheetId());
         if ((!pane.canScrollHorizontally && offsetX > 0) ||
             (!pane.canScrollVertically && offsetY > 0)) {
-            return 69 /* CommandResult.InvalidScrollingDirection */;
+            return 70 /* CommandResult.InvalidScrollingDirection */;
         }
         return 0 /* CommandResult.Success */;
     }
@@ -42882,17 +43902,14 @@ Ripple.props = {
 };
 
 function interactiveRenameSheet(env, sheetId, name, errorCallback) {
-    const originalSheetName = env.model.getters.getSheetName(sheetId);
-    if (name === null || name === originalSheetName)
-        return;
     const result = env.model.dispatch("RENAME_SHEET", { sheetId, name });
     if (result.reasons.includes(10 /* CommandResult.MissingSheetName */)) {
         env.raiseError(_lt("The sheet name cannot be empty."), errorCallback);
     }
-    else if (result.reasons.includes(11 /* CommandResult.DuplicatedSheetName */)) {
+    else if (result.reasons.includes(12 /* CommandResult.DuplicatedSheetName */)) {
         env.raiseError(_lt("A sheet with the name %s already exists. Please select another name.", name), errorCallback);
     }
-    else if (result.reasons.includes(13 /* CommandResult.ForbiddenCharactersInSheetName */)) {
+    else if (result.reasons.includes(14 /* CommandResult.ForbiddenCharactersInSheetName */)) {
         env.raiseError(_lt("Some used characters are not allowed in a sheet name (Forbidden characters are %s).", FORBIDDEN_SHEET_CHARS.join(" ")), errorCallback);
     }
 }
@@ -44221,11 +45238,9 @@ TopBarComposer.props = {
     onComposerContentFocused: Function,
 };
 
-// -----------------------------------------------------------------------------
-// TopBar
-// -----------------------------------------------------------------------------
 css /* scss */ `
   .o-font-size-editor {
+    height: calc(100% - 4px);
     input.o-font-size {
       outline-color: ${SELECTION_BORDER_COLOR};
       height: 20px;
@@ -44238,13 +45253,13 @@ css /* scss */ `
     input::-webkit-inner-spin-button {
       -webkit-appearance: none;
     }
-
-    .o-text-options > div {
-      line-height: 26px;
-      padding: 3px 12px;
-      &:hover {
-        background-color: rgba(0, 0, 0, 0.08);
-      }
+  }
+  .o-text-options > div {
+    cursor: pointer;
+    line-height: 26px;
+    padding: 3px 12px;
+    &:hover {
+      background-color: rgba(0, 0, 0, 0.08);
     }
   }
 `;
@@ -44309,6 +45324,7 @@ class FontSizeEditor extends Component {
 FontSizeEditor.props = {
     onToggle: Function,
     dropdownStyle: String,
+    class: String,
 };
 
 // -----------------------------------------------------------------------------
@@ -45881,7 +46897,7 @@ class SelectionStreamProcessorImpl {
      */
     moveAnchorCell(direction, step = 1) {
         if (step !== "end" && step <= 0) {
-            return new DispatchResult(83 /* CommandResult.InvalidSelectionStep */);
+            return new DispatchResult(84 /* CommandResult.InvalidSelectionStep */);
         }
         const { col, row } = this.getNextAvailablePosition(direction, step);
         return this.selectCell(col, row);
@@ -45927,7 +46943,7 @@ class SelectionStreamProcessorImpl {
      */
     resizeAnchorZone(direction, step = 1) {
         if (step !== "end" && step <= 0) {
-            return new DispatchResult(83 /* CommandResult.InvalidSelectionStep */);
+            return new DispatchResult(84 /* CommandResult.InvalidSelectionStep */);
         }
         const sheetId = this.getters.getActiveSheetId();
         const anchor = this.anchor;
@@ -46121,20 +47137,20 @@ class SelectionStreamProcessorImpl {
     checkAnchorZone(anchor) {
         const { cell, zone } = anchor;
         if (!isInside(cell.col, cell.row, zone)) {
-            return 16 /* CommandResult.InvalidAnchorZone */;
+            return 17 /* CommandResult.InvalidAnchorZone */;
         }
         const { left, right, top, bottom } = zone;
         const sheetId = this.getters.getActiveSheetId();
         const refCol = this.getters.findVisibleHeader(sheetId, "COL", left, right);
         const refRow = this.getters.findVisibleHeader(sheetId, "ROW", top, bottom);
         if (refRow === undefined || refCol === undefined) {
-            return 17 /* CommandResult.SelectionOutOfBound */;
+            return 18 /* CommandResult.SelectionOutOfBound */;
         }
         return 0 /* CommandResult.Success */;
     }
     checkAnchorZoneOrThrow(anchor) {
         const result = this.checkAnchorZone(anchor);
-        if (result === 16 /* CommandResult.InvalidAnchorZone */) {
+        if (result === 17 /* CommandResult.InvalidAnchorZone */) {
             throw new Error(_t("The provided anchor is invalid. The cell must be part of the zone."));
         }
     }
@@ -47477,15 +48493,10 @@ function addAutoFilter(table) {
   `;
 }
 function addFilterColumns(table) {
-    const tableZone = toZone(table.range);
     const columns = [];
-    for (const i of range(0, zoneToDimension(tableZone).numberOfCols)) {
-        const filter = table.filters[i];
-        if (!filter || !filter.filteredValues.length) {
-            continue;
-        }
+    for (const filter of table.filters) {
         const colXml = escapeXml /*xml*/ `
-      <filterColumn ${formatAttributes([["colId", i]])}>
+      <filterColumn ${formatAttributes([["colId", filter.colId]])}>
         ${addFilter(filter)}
       </filterColumn>
       `;
@@ -47494,9 +48505,10 @@ function addFilterColumns(table) {
     return columns;
 }
 function addFilter(filter) {
-    const filterValues = filter.filteredValues.map((val) => escapeXml /*xml*/ `<filter ${formatAttributes([["val", val]])}/>`);
+    const filterValues = filter.displayedValues.map((val) => escapeXml /*xml*/ `<filter ${formatAttributes([["val", val]])}/>`);
+    const filterAttributes = filter.displayBlanks ? [["blank", 1]] : [];
     return escapeXml /*xml*/ `
-  <filters>
+  <filters ${formatAttributes(filterAttributes)}>
       ${joinXmlNodes(filterValues)}
   </filters>
 `;
@@ -47615,8 +48627,13 @@ function addHyperlinks(construct, data, sheetIndex) {
                 const sheetId = parseSheetUrl(url);
                 const sheet = data.sheets.find((sheet) => sheet.id === sheetId);
                 const location = sheet ? `${sheet.name}!A1` : INCORRECT_RANGE_STRING;
+                const hyperlinkAttributes = [
+                    ["display", label],
+                    ["location", location],
+                    ["ref", xc],
+                ];
                 linkNodes.push(escapeXml /*xml*/ `
-          <hyperlink display="${label}" location="${location}" ref="${xc}"/>
+          <hyperlink ${formatAttributes(hyperlinkAttributes)}/>
         `);
             }
             else {
@@ -47625,8 +48642,12 @@ function addHyperlinks(construct, data, sheetIndex) {
                     type: XLSX_RELATION_TYPE.hyperlink,
                     targetMode: "External",
                 });
+                const hyperlinkAttributes = [
+                    ["r:id", linkRelId],
+                    ["ref", xc],
+                ];
                 linkNodes.push(escapeXml /*xml*/ `
-          <hyperlink r:id="${linkRelId}" ref="${xc}"/>
+          <hyperlink ${formatAttributes(hyperlinkAttributes)}/>
         `);
             }
         }
@@ -48250,10 +49271,10 @@ class Model extends EventBus {
         const command = createCommand(type, payload);
         let status = this.status;
         if (this.getters.isReadonly() && !canExecuteInReadonly(command)) {
-            return new DispatchResult(67 /* CommandResult.Readonly */);
+            return new DispatchResult(68 /* CommandResult.Readonly */);
         }
         if (!this.session.canApplyOptimisticUpdate()) {
-            return new DispatchResult(64 /* CommandResult.WaitingSessionConfirmation */);
+            return new DispatchResult(65 /* CommandResult.WaitingSessionConfirmation */);
         }
         switch (status) {
             case 0 /* Status.Ready */:
@@ -48504,6 +49525,6 @@ function addFunction(functionName, functionDescription) {
 export { AbstractChart, CommandResult, CorePlugin, DispatchResult, EvaluationError, Model, Registry, Revision, SPREADSHEET_DIMENSIONS, Spreadsheet, UIPlugin, __info__, addFunction, astToFormula, compile, components, convertAstNodes, coreTypes, findCellInNewZone, functionCache, helpers, invalidateCFEvaluationCommands, invalidateDependenciesCommands, invalidateEvaluationCommands, links, load, parse, readonlyAllowedCommands, registries, setDefaultSheetViewSize, setTranslationMethod, tokenize };
 
 
-__info__.version = '16.4.0-alpha.4';
-__info__.date = '2023-06-12T13:55:29.711Z';
-__info__.hash = '251a52e';
+__info__.version = '16.4.0-alpha.5';
+__info__.date = '2023-06-26T14:35:24.001Z';
+__info__.hash = '3b0b6f1';