@odoo/o-spreadsheet 17.0.56 → 17.0.58

package/dist/o-spreadsheet.cjs.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.0.56
- * @date 2025-04-04T08:36:58.258Z
- * @hash c484787
+ * @version 17.0.58
+ * @date 2025-04-18T16:20:26.099Z
+ * @hash 88d92de
  */
 
 'use strict';
@@ -2003,6 +2003,7 @@ const coreTypes = new Set([
     "CLEAR_FORMATTING",
     "SET_BORDER",
     "SET_ZONE_BORDERS",
+    "SET_BORDERS_ON_TARGET",
     /** CHART */
     "CREATE_CHART",
     "UPDATE_CHART",
@@ -4817,7 +4818,7 @@ function transformZone(zone, executed) {
     if (executed.type === "ADD_COLUMNS_ROWS") {
         return expandZoneOnInsertion(zone, executed.dimension === "COL" ? "left" : "top", executed.base, executed.position, executed.quantity);
     }
-    return { ...zone };
+    return zone;
 }
 function transformRangeData(range, executed) {
     const deletedSheet = executed.type === "DELETE_SHEET" && executed.sheetId;
@@ -7618,6 +7619,12 @@ function tokenizeString(chars) {
     }
     return null;
 }
+/**
+  - \p{L} is for any letter (from any language)
+  - \p{N} is for any number
+  - the u flag at the end is for unicode, which enables the `\p{...}` syntax
+ */
+const unicodeSymbolCharRegexp = /\p{L}|\p{N}|_|\.|!|\$/u;
 const SYMBOL_CHARS = new Set("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.!$");
 /**
  * A "Symbol" is just basically any word-like element that can appear in a
@@ -7658,7 +7665,8 @@ function tokenizeSymbol(chars) {
             };
         }
     }
-    while (chars.current && SYMBOL_CHARS.has(chars.current)) {
+    while (chars.current &&
+        (SYMBOL_CHARS.has(chars.current) || chars.current.match(unicodeSymbolCharRegexp))) {
         result += chars.shift();
     }
     if (result.length) {
@@ -34685,6 +34693,15 @@ class BordersPlugin extends CorePlugin {
             case "SET_BORDER":
                 this.setBorder(cmd.sheetId, cmd.col, cmd.row, cmd.border);
                 break;
+            case "SET_BORDERS_ON_TARGET":
+                for (const zone of cmd.target) {
+                    for (let row = zone.top; row <= zone.bottom; row++) {
+                        for (let col = zone.left; col <= zone.right; col++) {
+                            this.setBorder(cmd.sheetId, col, row, cmd.border);
+                        }
+                    }
+                }
+                break;
             case "SET_ZONE_BORDERS":
                 if (cmd.border) {
                     const target = cmd.target.map((zone) => this.getters.expandZone(cmd.sheetId, zone));
@@ -36691,6 +36708,353 @@ class ChartPlugin extends CorePlugin {
     }
 }
 
+/**
+ * ####################################################
+ * # INTRODUCTION
+ * ####################################################
+ *
+ * This file contain the function recomputeZones.
+ * This function try to recompute in a performant way
+ * an ensemble of zones possibly overlapping to avoid
+ * overlapping and to reduce the number of zones.
+ *
+ * It also allows to remove some zones from the ensemble.
+ *
+ * In the following example, 2 zones are overlapping.
+ * Applying recomputeZones will return zones without
+ * overlapping:
+ *
+ * ["B3:D4", "D2:E3"]         ["B3:C4", "D2:D4", "E2:E3"]
+ *
+ *      A B C D E                    A B C D E
+ *    1       ___                  1       ___
+ *    2   ___|_  |                 2   ___| | |
+ *    3  |   |_|_|      --->       3  |   | |_|
+ *    4  |_____|                   4  |___|_|
+ *    6                            6
+ *    7                            7
+ *
+ *
+ * In the following example, 2 zones are contiguous.
+ * Applying recomputeZones will return only one zone:
+ *
+ *  ["B2:B3", "C2:D3"]               ["B2:D3"]
+ *
+ *       A B C D E                   A B C D E
+ *     1   _ ___                   1   _____
+ *     2  | |   |        --->      2  |     |
+ *     3  |_|___|                  3  |_____|
+ *     4                           4
+ *
+ *
+ * In the following example, we want to remove a zone
+ * from the ensemble. Applying recomputeZones will
+ * return the ensemble without the zone to remove:
+ *
+ *    remove ["C3:D3"]           ["B2:B4", "C2:D2",
+ *                                "C4:D4", "E2:E4"]
+ *
+ *       A B C D E F                 A B C D E F
+ *     1   _______                 1   _______
+ *     2  |       |       --->     2  | |___| |
+ *     3  |  xxx  |                3  | |___| |
+ *     4  |_______|                4  |_|___|_|
+ *     5                           5
+ *
+ *
+ * The exercise seems simple when we have only 2 zones.
+ * But with n zones and in a performant way, we want to
+ * avoid comparing each zone with all the others.
+ *
+ *
+ * ####################################################
+ * # Methodological approach
+ * ####################################################
+ *
+ * The methodological approach to avoid comparing each
+ * zone with all the others is to use a data structure
+ * that allow to quickly find which zones are
+ * overlapping with any other given zone.
+ *
+ * Here the idea is to profile the zones at the columns level.
+ *
+ * To do that, we propose to use a data structure
+ * composed of 2 parts:
+ * - profilesStartingPosition: a sorted number array
+ * indicating on which columns a new profile begins.
+ * - profiles: a map where the key is a column
+ * position (from profilesStartingPosition) and the
+ * value is a sorted number array representing a
+ * profile.
+ *
+ *
+ * See the following example:    here profileStartingPosition
+ *                               corresponds to [A,C,E,G,K]
+ *    A B C D E F G H I J K      so with number [0,2,4,6,10]
+ *  1    '   '   '       '
+ *  2    '   '   '_______'       here profile correspond
+ *  3    '___'   |_______|       for A to []
+ *  4    |   |                   for C to [3, 5]
+ *  5    |___|                   for E to []
+ *  6                            for G to [2, 3]
+ *  7                            for K to []
+ *
+ *
+ * Now we can easily find which zones are overlapping
+ * with a given zone. Suppose we want to add a new zone
+ * D5:H6 to the ensemble:
+ *
+ *                              With a binary search of left and right
+ *    A B C D E F G H I J K     on profilesStartingPosition, we can
+ *  1    '   '   '       '      find the indexes of the profiles on which
+ *  2    '   '   '_______'      to apply a modification.
+ *  3    '___'   |_______|
+ *  4    |  _|_______           Here we will:
+ *  5    |_|_|       |          - add a new profile in D   --> become [3, 6]
+ *  6      |_________|          - modify the profile in E  --> become [4, 6]
+ *  7                           - modify the profile in G  --> become [2, 3, 4, 6]
+ *                              - add a new profile in I   --> become [8, 10]
+ *
+ *  See below the result:
+ *
+ *                              Note the particularity of the profile
+ *    A B C D E F G H I J K     for G: it will correspond to [2, 3, 4, 6]
+ *  1    ' ' '   '   '   '
+ *  2    ' ' '   '___'___'      To know how to modify the profile (add a
+ *  3    '_'_'   |___|___|      zone or remove it) we do a binary
+ *  4    | | |___ ___           search of the top and bottom value on the
+ *  5    |_| |   |   |          profile array. Depending on the result index
+ *  6      |_|___|___|          parity (odd or even), because zone boundaries
+ *  7                           go by pairs, we know if we are in a zone or
+ *                              not and how operate.
+ */
+/**
+ * Recompute the zone without the cells in toRemoveZones and avoid overlapping.
+ * This compute is particularly useful because after this function:
+ * - you will find coordinate of a cell only once among all the zones
+ * - the number of zones will be reduced to the minimum
+ */
+function futureRecomputeZones(zones, zonesToRemove = []) {
+    const profilesStartingPosition = [0];
+    const profiles = new Map([[0, []]]);
+    modifyProfiles(profilesStartingPosition, profiles, zones, false);
+    modifyProfiles(profilesStartingPosition, profiles, zonesToRemove, true);
+    return constructZonesFromProfiles(profilesStartingPosition, profiles);
+}
+function modifyProfiles(// export for testing only
+profilesStartingPosition, profiles, zones, toRemove = false) {
+    for (const zone of zones) {
+        const leftValue = zone.left;
+        const rightValue = zone.right === undefined ? undefined : zone.right + 1;
+        const leftIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, leftValue, true, 0);
+        const rightIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, rightValue, false, leftIndex);
+        for (let i = leftIndex; i <= rightIndex; i++) {
+            const profile = profiles.get(profilesStartingPosition[i]);
+            modifyProfile(profile, zone, toRemove);
+        }
+        // maybe this part cost in performance, and maybe it's not necessary (depending on the use case). To be checked
+        removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex);
+    }
+}
+function findIndexAndCreateProfile(profilesStartingPosition, profiles, value, searchLeft, startIndex) {
+    if (value === undefined) {
+        // this is only the case when the value correspond to a bottom value that could be undefined
+        return profilesStartingPosition.length - 1;
+    }
+    const predecessorIndex = binaryPredecessorSearch(profilesStartingPosition, value, startIndex);
+    if (value != profilesStartingPosition[predecessorIndex]) {
+        // mean that the value is not ending/starting at the same position as the previous/next profile
+        // --> it's a new profile
+        // --> we need to add it
+        profilesStartingPosition.splice(predecessorIndex + 1, 0, value);
+        // suppose the               we want to add the       for the left value
+        // following profile         following zone:          'C', the predecessor index
+        //   for B: [1, 3]                "C3:D4"             correspond to 'B'.
+        //                                                    The next line code will
+        //       A B C D                A B C D               copy the profile of 'B'
+        //     1  '___'               1  '___'                to 'C'. In the rest of the
+        //     2  |   |       --->    2  |  _|_               process the 'modifyProfile'
+        //     3  |___|               3  |_|_| |              function will adapt the waiting
+        //     4                      4    |___|              'C' profile [1, 3] to the
+        //                                                    correct 'C' profile [1, 4]
+        profiles.set(value, [...profiles.get(profilesStartingPosition[predecessorIndex])]);
+        return searchLeft ? predecessorIndex + 1 : predecessorIndex;
+    }
+    return searchLeft ? predecessorIndex : predecessorIndex - 1;
+}
+/**
+ *  Suppose the following        Suppose we want to add          We want to have the
+ *  profile:                     the following zone:             following profile:
+ *
+ *       A B C D E F                  A B C D E F                     A B C D E F
+ *     1    '___'                   1    '   '                      1    '___'
+ *     2    |___|                   2    '___'                      2    |   |
+ *     3    '   '                   3    |   |                      3    |   |
+ *     4    '___'          -->      4    |   |            -->       4    |   |
+ *     6    |   |                   6    |___|                      6    |   |
+ *     7    |___|                   7                               7    |___|
+ *     8                            8                               8
+ *
+ *  the profile for 'C'          the top zone correspond        Here [2, 3, 5, 8] with [3, 7]
+ *  corresponds to:              to 3 and the bottom zone       would be merged into [2, 8]
+ *   ____  ____                  correspond to 6
+ *  [2, 3, 5, 8]                 would be the profile:          The difficulty of modify profile
+ *                                ____                          is to know what must be deleted
+ *  Note that the 'filled        [3, 7]                         and what must be added to the
+ *  zone' are always between                                    existing profile.
+ *  an even index and its
+ *  next index
+ *
+ */
+function modifyProfile(profile, zone, toRemove = false) {
+    const topValue = zone.top;
+    const bottomValue = zone.bottom === undefined ? undefined : zone.bottom + 1;
+    const newPoints = [];
+    // Case we want to add a zone to the profile:
+    // - If the top predecessor index `topPredIndex` is even, it means the top of the zone is already positioned on a filled zone
+    // so we don't need to add it to the profile. we can keep in reference the index of the predecessor.
+    // - If it is odd, it means the top of the zone must be the beginning of a filled zone.
+    // so we can keep the index of the top position
+    // Case we want to remove a zone from the profile: it's the opposite of the previous case
+    const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, false);
+    if ((topPredIndex % 2 !== 0 && !toRemove) || (topPredIndex % 2 === 0 && toRemove)) {
+        newPoints.push(topValue);
+    }
+    if (bottomValue === undefined) {
+        // The following two code lines will not impact the final result,
+        // but they will impact the intermediate profile.
+        // We keep them for performance reason
+        profile.splice(topPredIndex + 1);
+        profile.push(...newPoints);
+        return;
+    }
+    // Case we want to add a zone to the profile:
+    // - If the bottom successor index `bottomSuccIndex` is even, it means the bottom of the zone must be the ending of a filled zone
+    // so we can keep the index of the bottom position.
+    // - If it is odd, it means the bottom of the zone is already positioned on a filled zone
+    // so we don't need to add it to the profile. we can keep in reference the index of the successor
+    // Case we want to remove a zone from the profile: it's the opposite of the previous case
+    const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, false);
+    if ((bottomSuccIndex % 2 === 0 && !toRemove) || (bottomSuccIndex % 2 !== 0 && toRemove)) {
+        newPoints.push(bottomValue);
+    }
+    // add the top and bottom value to the profile and
+    // remove all information between the top and bottom index
+    profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
+}
+function removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex) {
+    const start = leftIndex - 1 === -1 ? 0 : leftIndex - 1;
+    const end = rightIndex === profilesStartingPosition.length - 1 ? rightIndex : rightIndex + 1;
+    for (let i = end; i > start; i--) {
+        if (deepEqualsArray(profiles.get(profilesStartingPosition[i]), profiles.get(profilesStartingPosition[i - 1]))) {
+            profiles.delete(profilesStartingPosition[i]);
+            profilesStartingPosition.splice(i, 1);
+        }
+    }
+}
+function constructZonesFromProfiles(profilesStartingPosition, profiles) {
+    const mergedZone = [];
+    let pendingZones = [];
+    for (let colIndex = 0; colIndex < profilesStartingPosition.length; colIndex++) {
+        const left = profilesStartingPosition[colIndex];
+        const profile = profiles.get(left);
+        if (!profile || profile.length === 0) {
+            mergedZone.push(...pendingZones);
+            pendingZones = [];
+            continue;
+        }
+        let right = profilesStartingPosition[colIndex + 1];
+        if (right !== undefined) {
+            right--;
+        }
+        const nextPendingZones = [];
+        for (let i = 0; i < profile.length; i += 2) {
+            const top = profile[i];
+            let bottom = profile[i + 1];
+            if (bottom !== undefined) {
+                bottom--;
+            }
+            const profileZone = {
+                top,
+                left,
+                bottom,
+                right,
+                hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
+            };
+            let findCorrespondingZone = false;
+            for (let j = pendingZones.length - 1; j >= 0; j--) {
+                const pendingZone = pendingZones[j];
+                if (pendingZone.top === profileZone.top && pendingZone.bottom === profileZone.bottom) {
+                    pendingZone.right = profileZone.right;
+                    pendingZones.splice(j, 1);
+                    nextPendingZones.push(pendingZone);
+                    findCorrespondingZone = true;
+                    break;
+                }
+            }
+            if (!findCorrespondingZone) {
+                nextPendingZones.push(profileZone);
+            }
+        }
+        mergedZone.push(...pendingZones);
+        pendingZones = nextPendingZones;
+    }
+    mergedZone.push(...pendingZones);
+    return mergedZone;
+}
+function binaryPredecessorSearch(arr, val, start = 0, matchEqual = true) {
+    let end = arr.length - 1;
+    let result = -1;
+    while (start <= end) {
+        const mid = Math.floor((start + end) / 2);
+        if (arr[mid] === val && matchEqual) {
+            return mid;
+        }
+        else if (arr[mid] < val) {
+            result = mid;
+            start = mid + 1;
+        }
+        else {
+            end = mid - 1;
+        }
+    }
+    return result;
+}
+function binarySuccessorSearch(arr, val, start = 0, matchEqual = true) {
+    let end = arr.length - 1;
+    let result = arr.length;
+    while (start <= end) {
+        const mid = Math.floor((start + end) / 2);
+        if (arr[mid] === val && matchEqual) {
+            return mid;
+        }
+        else if (arr[mid] > val) {
+            result = mid;
+            end = mid - 1;
+        }
+        else {
+            start = mid + 1;
+        }
+    }
+    return result;
+}
+/**
+ * Compares two arrays.
+ * For performance reasons, this function is to be preferred
+ * to 'deepEquals' in the case we know that the inputs are arrays.
+ */
+function deepEqualsArray(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; i++) {
+        if (!deepEquals(arr1[i], arr2[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+
 // -----------------------------------------------------------------------------
 // Constants
 // -----------------------------------------------------------------------------
@@ -36860,10 +37224,12 @@ class ConditionalFormatPlugin extends CorePlugin {
         const replaceIndex = rules.findIndex((c) => c.id === cf.id);
         let currentRanges = [];
         if (replaceIndex > -1) {
-            currentRanges = rules[replaceIndex].ranges;
+            currentRanges = rules[replaceIndex].ranges.map(toUnboundedZone);
         }
         currentRanges = currentRanges.concat(toAdd);
-        return recomputeZones(currentRanges, toRemove);
+        // Remove the zones first in case the same position is in toAdd and toRemove
+        const withRemovedZones = futureRecomputeZones(currentRanges, toRemove);
+        return futureRecomputeZones([...toAdd, ...withRemovedZones], []);
     }
     // ---------------------------------------------------------------------------
     // Private
@@ -40598,353 +40964,6 @@ class CompilationParametersBuilder {
     }
 }
 
-/**
- * ####################################################
- * # INTRODUCTION
- * ####################################################
- *
- * This file contain the function recomputeZones.
- * This function try to recompute in a performant way
- * an ensemble of zones possibly overlapping to avoid
- * overlapping and to reduce the number of zones.
- *
- * It also allows to remove some zones from the ensemble.
- *
- * In the following example, 2 zones are overlapping.
- * Applying recomputeZones will return zones without
- * overlapping:
- *
- * ["B3:D4", "D2:E3"]         ["B3:C4", "D2:D4", "E2:E3"]
- *
- *      A B C D E                    A B C D E
- *    1       ___                  1       ___
- *    2   ___|_  |                 2   ___| | |
- *    3  |   |_|_|      --->       3  |   | |_|
- *    4  |_____|                   4  |___|_|
- *    6                            6
- *    7                            7
- *
- *
- * In the following example, 2 zones are contiguous.
- * Applying recomputeZones will return only one zone:
- *
- *  ["B2:B3", "C2:D3"]               ["B2:D3"]
- *
- *       A B C D E                   A B C D E
- *     1   _ ___                   1   _____
- *     2  | |   |        --->      2  |     |
- *     3  |_|___|                  3  |_____|
- *     4                           4
- *
- *
- * In the following example, we want to remove a zone
- * from the ensemble. Applying recomputeZones will
- * return the ensemble without the zone to remove:
- *
- *    remove ["C3:D3"]           ["B2:B4", "C2:D2",
- *                                "C4:D4", "E2:E4"]
- *
- *       A B C D E F                 A B C D E F
- *     1   _______                 1   _______
- *     2  |       |       --->     2  | |___| |
- *     3  |  xxx  |                3  | |___| |
- *     4  |_______|                4  |_|___|_|
- *     5                           5
- *
- *
- * The exercise seems simple when we have only 2 zones.
- * But with n zones and in a performant way, we want to
- * avoid comparing each zone with all the others.
- *
- *
- * ####################################################
- * # Methodological approach
- * ####################################################
- *
- * The methodological approach to avoid comparing each
- * zone with all the others is to use a data structure
- * that allow to quickly find which zones are
- * overlapping with any other given zone.
- *
- * Here the idea is to profile the zones at the columns level.
- *
- * To do that, we propose to use a data structure
- * composed of 2 parts:
- * - profilesStartingPosition: a sorted number array
- * indicating on which columns a new profile begins.
- * - profiles: a map where the key is a column
- * position (from profilesStartingPosition) and the
- * value is a sorted number array representing a
- * profile.
- *
- *
- * See the following example:    here profileStartingPosition
- *                               corresponds to [A,C,E,G,K]
- *    A B C D E F G H I J K      so with number [0,2,4,6,10]
- *  1    '   '   '       '
- *  2    '   '   '_______'       here profile correspond
- *  3    '___'   |_______|       for A to []
- *  4    |   |                   for C to [3, 5]
- *  5    |___|                   for E to []
- *  6                            for G to [2, 3]
- *  7                            for K to []
- *
- *
- * Now we can easily find which zones are overlapping
- * with a given zone. Suppose we want to add a new zone
- * D5:H6 to the ensemble:
- *
- *                              With a binary search of left and right
- *    A B C D E F G H I J K     on profilesStartingPosition, we can
- *  1    '   '   '       '      find the indexes of the profiles on which
- *  2    '   '   '_______'      to apply a modification.
- *  3    '___'   |_______|
- *  4    |  _|_______           Here we will:
- *  5    |_|_|       |          - add a new profile in D   --> become [3, 6]
- *  6      |_________|          - modify the profile in E  --> become [4, 6]
- *  7                           - modify the profile in G  --> become [2, 3, 4, 6]
- *                              - add a new profile in I   --> become [8, 10]
- *
- *  See below the result:
- *
- *                              Note the particularity of the profile
- *    A B C D E F G H I J K     for G: it will correspond to [2, 3, 4, 6]
- *  1    ' ' '   '   '   '
- *  2    ' ' '   '___'___'      To know how to modify the profile (add a
- *  3    '_'_'   |___|___|      zone or remove it) we do a binary
- *  4    | | |___ ___           search of the top and bottom value on the
- *  5    |_| |   |   |          profile array. Depending on the result index
- *  6      |_|___|___|          parity (odd or even), because zone boundaries
- *  7                           go by pairs, we know if we are in a zone or
- *                              not and how operate.
- */
-/**
- * Recompute the zone without the cells in toRemoveZones and avoid overlapping.
- * This compute is particularly useful because after this function:
- * - you will find coordinate of a cell only once among all the zones
- * - the number of zones will be reduced to the minimum
- */
-function futureRecomputeZones(zones, zonesToRemove = []) {
-    const profilesStartingPosition = [0];
-    const profiles = new Map([[0, []]]);
-    modifyProfiles(profilesStartingPosition, profiles, zones, false);
-    modifyProfiles(profilesStartingPosition, profiles, zonesToRemove, true);
-    return constructZonesFromProfiles(profilesStartingPosition, profiles);
-}
-function modifyProfiles(// export for testing only
-profilesStartingPosition, profiles, zones, toRemove = false) {
-    for (const zone of zones) {
-        const leftValue = zone.left;
-        const rightValue = zone.right === undefined ? undefined : zone.right + 1;
-        const leftIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, leftValue, true, 0);
-        const rightIndex = findIndexAndCreateProfile(profilesStartingPosition, profiles, rightValue, false, leftIndex);
-        for (let i = leftIndex; i <= rightIndex; i++) {
-            const profile = profiles.get(profilesStartingPosition[i]);
-            modifyProfile(profile, zone, toRemove);
-        }
-        // maybe this part cost in performance, and maybe it's not necessary (depending on the use case). To be checked
-        removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex);
-    }
-}
-function findIndexAndCreateProfile(profilesStartingPosition, profiles, value, searchLeft, startIndex) {
-    if (value === undefined) {
-        // this is only the case when the value correspond to a bottom value that could be undefined
-        return profilesStartingPosition.length - 1;
-    }
-    const predecessorIndex = binaryPredecessorSearch(profilesStartingPosition, value, startIndex);
-    if (value != profilesStartingPosition[predecessorIndex]) {
-        // mean that the value is not ending/starting at the same position as the previous/next profile
-        // --> it's a new profile
-        // --> we need to add it
-        profilesStartingPosition.splice(predecessorIndex + 1, 0, value);
-        // suppose the               we want to add the       for the left value
-        // following profile         following zone:          'C', the predecessor index
-        //   for B: [1, 3]                "C3:D4"             correspond to 'B'.
-        //                                                    The next line code will
-        //       A B C D                A B C D               copy the profile of 'B'
-        //     1  '___'               1  '___'                to 'C'. In the rest of the
-        //     2  |   |       --->    2  |  _|_               process the 'modifyProfile'
-        //     3  |___|               3  |_|_| |              function will adapt the waiting
-        //     4                      4    |___|              'C' profile [1, 3] to the
-        //                                                    correct 'C' profile [1, 4]
-        profiles.set(value, [...profiles.get(profilesStartingPosition[predecessorIndex])]);
-        return searchLeft ? predecessorIndex + 1 : predecessorIndex;
-    }
-    return searchLeft ? predecessorIndex : predecessorIndex - 1;
-}
-/**
- *  Suppose the following        Suppose we want to add          We want to have the
- *  profile:                     the following zone:             following profile:
- *
- *       A B C D E F                  A B C D E F                     A B C D E F
- *     1    '___'                   1    '   '                      1    '___'
- *     2    |___|                   2    '___'                      2    |   |
- *     3    '   '                   3    |   |                      3    |   |
- *     4    '___'          -->      4    |   |            -->       4    |   |
- *     6    |   |                   6    |___|                      6    |   |
- *     7    |___|                   7                               7    |___|
- *     8                            8                               8
- *
- *  the profile for 'C'          the top zone correspond        Here [2, 3, 5, 8] with [3, 7]
- *  corresponds to:              to 3 and the bottom zone       would be merged into [2, 8]
- *   ____  ____                  correspond to 6
- *  [2, 3, 5, 8]                 would be the profile:          The difficulty of modify profile
- *                                ____                          is to know what must be deleted
- *  Note that the 'filled        [3, 7]                         and what must be added to the
- *  zone' are always between                                    existing profile.
- *  an even index and its
- *  next index
- *
- */
-function modifyProfile(profile, zone, toRemove = false) {
-    const topValue = zone.top;
-    const bottomValue = zone.bottom === undefined ? undefined : zone.bottom + 1;
-    const newPoints = [];
-    // Case we want to add a zone to the profile:
-    // - If the top predecessor index `topPredIndex` is even, it means the top of the zone is already positioned on a filled zone
-    // so we don't need to add it to the profile. we can keep in reference the index of the predecessor.
-    // - If it is odd, it means the top of the zone must be the beginning of a filled zone.
-    // so we can keep the index of the top position
-    // Case we want to remove a zone from the profile: it's the opposite of the previous case
-    const topPredIndex = binaryPredecessorSearch(profile, topValue, 0, false);
-    if ((topPredIndex % 2 !== 0 && !toRemove) || (topPredIndex % 2 === 0 && toRemove)) {
-        newPoints.push(topValue);
-    }
-    if (bottomValue === undefined) {
-        // The following two code lines will not impact the final result,
-        // but they will impact the intermediate profile.
-        // We keep them for performance reason
-        profile.splice(topPredIndex + 1);
-        profile.push(...newPoints);
-        return;
-    }
-    // Case we want to add a zone to the profile:
-    // - If the bottom successor index `bottomSuccIndex` is even, it means the bottom of the zone must be the ending of a filled zone
-    // so we can keep the index of the bottom position.
-    // - If it is odd, it means the bottom of the zone is already positioned on a filled zone
-    // so we don't need to add it to the profile. we can keep in reference the index of the successor
-    // Case we want to remove a zone from the profile: it's the opposite of the previous case
-    const bottomSuccIndex = binarySuccessorSearch(profile, bottomValue, 0, false);
-    if ((bottomSuccIndex % 2 === 0 && !toRemove) || (bottomSuccIndex % 2 !== 0 && toRemove)) {
-        newPoints.push(bottomValue);
-    }
-    // add the top and bottom value to the profile and
-    // remove all information between the top and bottom index
-    profile.splice(topPredIndex + 1, bottomSuccIndex - topPredIndex - 1, ...newPoints);
-}
-function removeContiguousProfiles(profilesStartingPosition, profiles, leftIndex, rightIndex) {
-    const start = leftIndex - 1 === -1 ? 0 : leftIndex - 1;
-    const end = rightIndex === profilesStartingPosition.length - 1 ? rightIndex : rightIndex + 1;
-    for (let i = end; i > start; i--) {
-        if (deepEqualsArray(profiles.get(profilesStartingPosition[i]), profiles.get(profilesStartingPosition[i - 1]))) {
-            profiles.delete(profilesStartingPosition[i]);
-            profilesStartingPosition.splice(i, 1);
-        }
-    }
-}
-function constructZonesFromProfiles(profilesStartingPosition, profiles) {
-    const mergedZone = [];
-    let pendingZones = [];
-    for (let colIndex = 0; colIndex < profilesStartingPosition.length; colIndex++) {
-        const left = profilesStartingPosition[colIndex];
-        const profile = profiles.get(left);
-        if (!profile || profile.length === 0) {
-            mergedZone.push(...pendingZones);
-            pendingZones = [];
-            continue;
-        }
-        let right = profilesStartingPosition[colIndex + 1];
-        if (right !== undefined) {
-            right--;
-        }
-        const nextPendingZones = [];
-        for (let i = 0; i < profile.length; i += 2) {
-            const top = profile[i];
-            let bottom = profile[i + 1];
-            if (bottom !== undefined) {
-                bottom--;
-            }
-            const profileZone = {
-                top,
-                left,
-                bottom,
-                right,
-                hasHeader: (bottom === undefined && top !== 0) || (right === undefined && left !== 0),
-            };
-            let findCorrespondingZone = false;
-            for (let j = pendingZones.length - 1; j >= 0; j--) {
-                const pendingZone = pendingZones[j];
-                if (pendingZone.top === profileZone.top && pendingZone.bottom === profileZone.bottom) {
-                    pendingZone.right = profileZone.right;
-                    pendingZones.splice(j, 1);
-                    nextPendingZones.push(pendingZone);
-                    findCorrespondingZone = true;
-                    break;
-                }
-            }
-            if (!findCorrespondingZone) {
-                nextPendingZones.push(profileZone);
-            }
-        }
-        mergedZone.push(...pendingZones);
-        pendingZones = nextPendingZones;
-    }
-    mergedZone.push(...pendingZones);
-    return mergedZone;
-}
-function binaryPredecessorSearch(arr, val, start = 0, matchEqual = true) {
-    let end = arr.length - 1;
-    let result = -1;
-    while (start <= end) {
-        const mid = Math.floor((start + end) / 2);
-        if (arr[mid] === val && matchEqual) {
-            return mid;
-        }
-        else if (arr[mid] < val) {
-            result = mid;
-            start = mid + 1;
-        }
-        else {
-            end = mid - 1;
-        }
-    }
-    return result;
-}
-function binarySuccessorSearch(arr, val, start = 0, matchEqual = true) {
-    let end = arr.length - 1;
-    let result = arr.length;
-    while (start <= end) {
-        const mid = Math.floor((start + end) / 2);
-        if (arr[mid] === val && matchEqual) {
-            return mid;
-        }
-        else if (arr[mid] > val) {
-            result = mid;
-            end = mid - 1;
-        }
-        else {
-            start = mid + 1;
-        }
-    }
-    return result;
-}
-/**
- * Compares two arrays.
- * For performance reasons, this function is to be preferred
- * to 'deepEquals' in the case we know that the inputs are arrays.
- */
-function deepEqualsArray(arr1, arr2) {
-    if (arr1.length !== arr2.length) {
-        return false;
-    }
-    for (let i = 0; i < arr1.length; i++) {
-        if (!deepEquals(arr1[i], arr2[i])) {
-            return false;
-        }
-    }
-    return true;
-}
-
 function quickselect(arr, k, left, right, compare) {
     quickselectStep(arr, k, left || 0, right || (arr.length - 1), compare || defaultCompare);
 }
@@ -43541,25 +43560,6 @@ class AutofillPlugin extends UIPlugin {
             case "AUTOFILL_AUTO":
                 this.autofillAuto();
                 break;
-            case "AUTOFILL_CELL":
-                this.autoFillMerge(cmd.originCol, cmd.originRow, cmd.col, cmd.row);
-                const sheetId = this.getters.getActiveSheetId();
-                this.dispatch("UPDATE_CELL", {
-                    sheetId,
-                    col: cmd.col,
-                    row: cmd.row,
-                    style: cmd.style || null,
-                    content: cmd.content || "",
-                    format: cmd.format || "",
-                });
-                this.dispatch("SET_BORDER", {
-                    sheetId,
-                    col: cmd.col,
-                    row: cmd.row,
-                    border: cmd.border,
-                });
-                this.autofillCF(cmd.originCol, cmd.originRow, cmd.col, cmd.row);
-                this.autofillDV(cmd.originCol, cmd.originRow, cmd.col, cmd.row);
         }
     }
     // ---------------------------------------------------------------------------
@@ -43583,6 +43583,7 @@ class AutofillPlugin extends UIPlugin {
         }
         const source = this.getters.getSelectedZone();
         const target = this.autofillZone;
+        const autofillCellsData = [];
         switch (this.direction) {
             case "down" /* DIRECTION.DOWN */:
                 for (let col = source.left; col <= source.right; col++) {
@@ -43592,7 +43593,7 @@ class AutofillPlugin extends UIPlugin {
                     }
                     const generator = this.createGenerator(xcs);
                     for (let row = target.top; row <= target.bottom; row++) {
-                        this.computeNewCell(generator, col, row, apply);
+                        autofillCellsData.push(this.computeNewCell(generator, col, row));
                     }
                 }
                 break;
@@ -43604,7 +43605,7 @@ class AutofillPlugin extends UIPlugin {
                     }
                     const generator = this.createGenerator(xcs);
                     for (let row = target.bottom; row >= target.top; row--) {
-                        this.computeNewCell(generator, col, row, apply);
+                        autofillCellsData.push(this.computeNewCell(generator, col, row));
                     }
                 }
                 break;
@@ -43616,7 +43617,7 @@ class AutofillPlugin extends UIPlugin {
                     }
                     const generator = this.createGenerator(xcs);
                     for (let col = target.right; col >= target.left; col--) {
-                        this.computeNewCell(generator, col, row, apply);
+                        autofillCellsData.push(this.computeNewCell(generator, col, row));
                     }
                 }
                 break;
@@ -43628,12 +43629,26 @@ class AutofillPlugin extends UIPlugin {
                     }
                     const generator = this.createGenerator(xcs);
                     for (let col = target.left; col <= target.right; col++) {
-                        this.computeNewCell(generator, col, row, apply);
+                        autofillCellsData.push(this.computeNewCell(generator, col, row));
                     }
                 }
                 break;
         }
         if (apply) {
+            const bordersZones = {};
+            const cfNewRanges = {};
+            const dvNewZones = {};
+            const sheetId = this.getters.getActiveSheetId();
+            for (const data of autofillCellsData) {
+                this.collectBordersData(data, bordersZones);
+                this.autofillMerge(sheetId, data);
+                this.autofillCell(sheetId, data);
+                this.collectConditionalFormatsData(sheetId, data, cfNewRanges);
+                this.collectDataValidationsData(sheetId, data, dvNewZones);
+            }
+            this.autofillBorders(sheetId, bordersZones);
+            this.autofillConditionalFormats(sheetId, cfNewRanges);
+            this.autofillDataValidations(sheetId, dvNewZones);
             this.autofillZone = undefined;
             this.selection.resizeAnchorZone(this.direction, this.steps);
             this.lastCellSelected = {};
@@ -43642,6 +43657,95 @@ class AutofillPlugin extends UIPlugin {
             this.tooltip = undefined;
         }
     }
+    collectBordersData(data, bordersPositions) {
+        const key = JSON.stringify(data.border);
+        if (!(key in bordersPositions)) {
+            bordersPositions[key] = [];
+        }
+        bordersPositions[key].push(positionToZone({ col: data.col, row: data.row }));
+    }
+    collectConditionalFormatsData(sheetId, data, cfNewRanges) {
+        const { originCol, originRow, col, row } = data;
+        const cfsAtOrigin = this.getters.getRulesByCell(sheetId, originCol, originRow);
+        const xc = toXC(col, row);
+        for (const cf of cfsAtOrigin) {
+            if (!(cf.id in cfNewRanges)) {
+                cfNewRanges[cf.id] = [];
+            }
+            cfNewRanges[cf.id].push(xc);
+        }
+    }
+    collectDataValidationsData(sheetId, data, dvNewZones) {
+        const { originCol, originRow, col, row } = data;
+        const cellPosition = { sheetId, col: originCol, row: originRow };
+        const dvsAtOrigin = this.getters.getValidationRuleForCell(cellPosition);
+        if (!dvsAtOrigin) {
+            return;
+        }
+        if (!(dvsAtOrigin.id in dvNewZones)) {
+            dvNewZones[dvsAtOrigin.id] = [];
+        }
+        dvNewZones[dvsAtOrigin.id].push(positionToZone({ col, row }));
+    }
+    autofillCell(sheetId, data) {
+        this.dispatch("UPDATE_CELL", {
+            sheetId,
+            col: data.col,
+            row: data.row,
+            content: data.content || "",
+            style: data.style || null,
+            format: data.format || "",
+        });
+        // Still usefull in odoo ATM to autofill field sync
+        this.dispatch("AUTOFILL_CELL", data);
+    }
+    autofillBorders(sheetId, bordersPositions) {
+        for (const stringifiedBorder in bordersPositions) {
+            const border = stringifiedBorder === "undefined" ? undefined : JSON.parse(stringifiedBorder);
+            this.dispatch("SET_BORDERS_ON_TARGET", {
+                sheetId,
+                border,
+                target: futureRecomputeZones(bordersPositions[stringifiedBorder]),
+            });
+        }
+    }
+    autofillConditionalFormats(sheetId, cfNewRanges) {
+        for (const cfId in cfNewRanges) {
+            const changes = cfNewRanges[cfId];
+            const cf = this.getters.getConditionalFormats(sheetId).find((cf) => cf.id === cfId);
+            if (!cf) {
+                continue;
+            }
+            const newCfZones = this.getters.getAdaptedCfRanges(sheetId, cf, changes.map(toZone), []);
+            if (newCfZones) {
+                this.dispatch("ADD_CONDITIONAL_FORMAT", {
+                    cf: {
+                        id: cf.id,
+                        rule: cf.rule,
+                        stopIfTrue: cf.stopIfTrue,
+                    },
+                    ranges: newCfZones.map((xc) => this.getters.getRangeDataFromZone(sheetId, xc)),
+                    sheetId,
+                });
+            }
+        }
+    }
+    autofillDataValidations(sheetId, dvNewZones) {
+        for (const dvId in dvNewZones) {
+            const changes = dvNewZones[dvId];
+            const dvOrigin = this.getters.getDataValidationRule(sheetId, dvId);
+            if (!dvOrigin) {
+                continue;
+            }
+            const dvRangesXcs = dvOrigin.ranges.map((range) => range.zone);
+            const newDvRanges = futureRecomputeZones(dvRangesXcs.concat(changes), []);
+            this.dispatch("ADD_DATA_VALIDATION_RULE", {
+                rule: dvOrigin,
+                ranges: newDvRanges.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
+                sheetId,
+            });
+        }
+    }
     /**
      * Select a cell which becomes the last cell of the autofillZone
      */
@@ -43708,22 +43812,20 @@ class AutofillPlugin extends UIPlugin {
     /**
      * Generate the next cell
      */
-    computeNewCell(generator, col, row, apply) {
+    computeNewCell(generator, col, row) {
         const { cellData, tooltip, origin } = generator.next();
         const { content, style, border, format } = cellData;
         this.tooltip = tooltip;
-        if (apply) {
-            this.dispatch("AUTOFILL_CELL", {
-                originCol: origin.col,
-                originRow: origin.row,
-                col,
-                row,
-                content,
-                style,
-                border,
-                format,
-            });
-        }
+        return {
+            originCol: origin.col,
+            originRow: origin.row,
+            col,
+            row,
+            content,
+            style,
+            border,
+            format,
+        };
     }
     /**
      * Get the rule associated to the current cell
@@ -43791,8 +43893,8 @@ class AutofillPlugin extends UIPlugin {
             ? position[first].value
             : position[second].value;
     }
-    autoFillMerge(originCol, originRow, col, row) {
-        const sheetId = this.getters.getActiveSheetId();
+    autofillMerge(sheetId, data) {
+        const { originCol, originRow, col, row } = data;
         const position = { sheetId, col, row };
         const originPosition = { sheetId, col: originCol, row: originRow };
         if (this.getters.isInMerge(position) && !this.getters.isInMerge(originPosition)) {
@@ -43819,35 +43921,6 @@ class AutofillPlugin extends UIPlugin {
             });
         }
     }
-    autofillCF(originCol, originRow, col, row) {
-        const sheetId = this.getters.getActiveSheetId();
-        const cfOrigin = this.getters.getRulesByCell(sheetId, originCol, originRow);
-        for (const cf of cfOrigin) {
-            const newCfRanges = this.getters.getAdaptedCfRanges(sheetId, cf, [toXC(col, row)], []);
-            if (newCfRanges) {
-                this.dispatch("ADD_CONDITIONAL_FORMAT", {
-                    cf: deepCopy(cf),
-                    ranges: newCfRanges.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-                    sheetId,
-                });
-            }
-        }
-    }
-    autofillDV(originCol, originRow, col, row) {
-        const sheetId = this.getters.getActiveSheetId();
-        const cellPosition = { sheetId, col: originCol, row: originRow };
-        const dvOrigin = this.getters.getValidationRuleForCell(cellPosition);
-        if (!dvOrigin) {
-            return;
-        }
-        const dvRangesXcs = dvOrigin.ranges.map((range) => this.getters.getRangeString(range, sheetId));
-        const newDvRanges = recomputeZones(dvRangesXcs.concat(toXC(col, row)), []);
-        this.dispatch("ADD_DATA_VALIDATION_RULE", {
-            rule: dvOrigin,
-            ranges: newDvRanges.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-            sheetId,
-        });
-    }
     // ---------------------------------------------------------------------------
     // Grid rendering
     // ---------------------------------------------------------------------------
@@ -44345,10 +44418,8 @@ function mergeTransformation(toTransform, executed) {
     }
     const target = [];
     for (const zone1 of toTransform.target) {
-        for (const zone2 of executed.target) {
-            if (!overlap(zone1, zone2)) {
-                target.push({ ...zone1 });
-            }
+        if (executed.target.every((zone2) => !overlap(zone1, zone2))) {
+            target.push(zone1);
         }
     }
     if (target.length) {
@@ -45234,6 +45305,9 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
     copiedTables;
     zones;
     uuidGenerator = new UuidGenerator();
+    queuedBordersToAdd = {};
+    queuedCFChanges = {};
+    queuedDVChanges = {};
     constructor(zones, operation, getters, dispatch, selection) {
         super(operation, getters, dispatch, selection);
         if (!zones.length) {
@@ -45343,6 +45417,8 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
      * Paste the clipboard content in the given target
      */
     paste(target, options) {
+        this.queuedCFChanges = {};
+        this.queuedDVChanges = {};
         if (this.operation === "COPY") {
             this.pasteFromCopy(target, options);
         }
@@ -45355,6 +45431,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
         if (options?.selectTarget) {
             this.selectPastedZone(width, height, isCutOperation, target);
         }
+        this.executeQueuedChanges(this.getters.getActiveSheetId());
     }
     pasteFromCopy(target, options) {
         if (target.length === 1) {
@@ -45529,7 +45606,11 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
             left: targetBorders?.left || originBorders?.left,
             right: targetBorders?.right || originBorders?.right,
         };
-        this.dispatch("SET_BORDER", { sheetId, col, row, border });
+        const borderKey = JSON.stringify(border);
+        if (!this.queuedBordersToAdd[borderKey]) {
+            this.queuedBordersToAdd[borderKey] = [];
+        }
+        this.queuedBordersToAdd[borderKey].push(positionToZone(target));
         if (clipboardOption?.pasteOption === "onlyFormat") {
             this.dispatch("UPDATE_CELL", {
                 ...target,
@@ -45675,7 +45756,8 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
         }
     }
     pasteCf(origin, target) {
-        const xc = toXC(target.col, target.row);
+        const zone = positionToZone(target);
+        const originZone = positionToZone(origin);
         for (let rule of this.getters.getConditionalFormats(origin.sheetId)) {
             for (let range of rule.ranges) {
                 if (isInside(origin.col, origin.row, this.getters.getRangeFromSheetXC(origin.sheetId, range).zone)) {
@@ -45683,15 +45765,15 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
                     const toRemoveRange = [];
                     if (this.operation === "CUT") {
                         //remove from current rule
-                        toRemoveRange.push(toXC(origin.col, origin.row));
+                        toRemoveRange.push(originZone);
                     }
                     if (origin.sheetId === target.sheetId) {
-                        this.adaptCFRules(origin.sheetId, cf, [xc], toRemoveRange);
+                        this.adaptCFRules(origin.sheetId, cf, [zone], toRemoveRange);
                     }
                     else {
                         this.adaptCFRules(origin.sheetId, cf, [], toRemoveRange);
                         const cfToCopyTo = this.getCFToCopyTo(target.sheetId, cf);
-                        this.adaptCFRules(target.sheetId, cfToCopyTo, [xc], []);
+                        this.adaptCFRules(target.sheetId, cfToCopyTo, [zone], []);
                     }
                 }
             }
@@ -45701,79 +45783,130 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
      * Add or remove cells to a given conditional formatting rule.
      */
     adaptCFRules(sheetId, cf, toAdd, toRemove) {
-        const newRangesXC = this.getters.getAdaptedCfRanges(sheetId, cf, toAdd, toRemove);
-        if (!newRangesXC) {
-            return;
+        if (!this.queuedCFChanges[sheetId]) {
+            this.queuedCFChanges[sheetId] = [];
         }
-        if (newRangesXC.length === 0) {
-            this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
-            return;
+        const queuedChange = this.queuedCFChanges[sheetId].find((queued) => queued.cf.id === cf.id);
+        if (!queuedChange) {
+            this.queuedCFChanges[sheetId].push({ toAdd, toRemove, cf });
+        }
+        else {
+            queuedChange.toAdd.push(...toAdd);
+            queuedChange.toRemove.push(...toRemove);
         }
-        this.dispatch("ADD_CONDITIONAL_FORMAT", {
-            cf: {
-                id: cf.id,
-                rule: cf.rule,
-                stopIfTrue: cf.stopIfTrue,
-            },
-            ranges: newRangesXC.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-            sheetId,
-        });
     }
     getCFToCopyTo(targetSheetId, originCF) {
-        const cfInTarget = this.getters
+        let targetCF = this.getters
             .getConditionalFormats(targetSheetId)
             .find((cf) => cf.stopIfTrue === originCF.stopIfTrue && deepEquals(cf.rule, originCF.rule));
-        return cfInTarget
-            ? cfInTarget
-            : { ...originCF, id: this.uuidGenerator.smallUuid(), ranges: [] };
+        const queuedCfs = this.queuedCFChanges[targetSheetId];
+        if (!targetCF && queuedCfs) {
+            targetCF = queuedCfs.find((queued) => queued.cf.stopIfTrue === originCF.stopIfTrue && deepEquals(queued.cf.rule, originCF.rule))?.cf;
+        }
+        return targetCF ? targetCF : { ...originCF, id: this.uuidGenerator.smallUuid(), ranges: [] };
     }
     pasteDataValidation(origin, target) {
         const rule = this.getters.getValidationRuleForCell(origin);
+        const originZone = positionToZone(origin);
         if (!rule) {
             return;
         }
-        const xc = toXC(target.col, target.row);
+        const zone = positionToZone(target);
         for (const range of rule.ranges) {
             if (isInside(origin.col, origin.row, range.zone)) {
                 const toRemoveRange = [];
                 if (this.operation === "CUT") {
-                    toRemoveRange.push(toXC(origin.col, origin.row));
+                    toRemoveRange.push(originZone);
                 }
                 if (origin.sheetId === target.sheetId) {
-                    this.adaptDataValidationRule(origin.sheetId, rule, [xc], toRemoveRange);
+                    const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
+                    this.adaptDataValidationRule(origin.sheetId, copyToRule, [zone], toRemoveRange);
                 }
                 else {
-                    this.adaptDataValidationRule(origin.sheetId, rule, [], toRemoveRange);
-                    let copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
-                    this.adaptDataValidationRule(target.sheetId, copyToRule, [xc], []);
+                    const originRule = this.getters.getValidationRuleForCell(origin);
+                    if (originRule) {
+                        this.adaptDataValidationRule(origin.sheetId, originRule, [], toRemoveRange);
+                    }
+                    const copyToRule = this.getDataValidationRuleToCopyTo(target.sheetId, rule);
+                    this.adaptDataValidationRule(target.sheetId, copyToRule, [zone], []);
                 }
             }
         }
     }
     getDataValidationRuleToCopyTo(targetSheetId, originRule) {
-        const ruleInTargetSheet = this.getters
+        let targetRule = this.getters
             .getDataValidationRules(targetSheetId)
             .find((rule) => deepEquals(originRule.criterion, rule.criterion) &&
             originRule.isBlocking === rule.isBlocking);
-        return ruleInTargetSheet
-            ? ruleInTargetSheet
-            : { ...originRule, id: this.uuidGenerator.smallUuid(), ranges: [] };
+        const queuedRules = this.queuedDVChanges[targetSheetId];
+        if (!targetRule && queuedRules) {
+            targetRule = queuedRules.find((queued) => deepEquals(originRule.criterion, queued.rule.criterion) &&
+                originRule.isBlocking === queued.rule.isBlocking)?.rule;
+        }
+        return targetRule || { ...originRule, id: this.uuidGenerator.smallUuid(), ranges: [] };
     }
     /**
      * Add or remove XCs to a given data validation rule.
      */
     adaptDataValidationRule(sheetId, rule, toAdd, toRemove) {
-        const dvRangesXcs = rule.ranges.map((range) => this.getters.getRangeString(range, sheetId));
-        const newRangesXC = recomputeZones([...dvRangesXcs, ...toAdd], toRemove);
-        if (newRangesXC.length === 0) {
-            this.dispatch("REMOVE_DATA_VALIDATION_RULE", { sheetId, id: rule.id });
-            return;
+        if (!this.queuedDVChanges[sheetId]) {
+            this.queuedDVChanges[sheetId] = [];
         }
-        this.dispatch("ADD_DATA_VALIDATION_RULE", {
-            rule,
-            ranges: newRangesXC.map((xc) => this.getters.getRangeDataFromXc(sheetId, xc)),
-            sheetId,
-        });
+        const queuedChange = this.queuedDVChanges[sheetId].find((queued) => queued.rule.id === rule.id);
+        if (!queuedChange) {
+            this.queuedDVChanges[sheetId].push({ toAdd, toRemove, rule: deepCopy(rule) });
+        }
+        else {
+            queuedChange.toAdd.push(...toAdd);
+            queuedChange.toRemove.push(...toRemove);
+        }
+    }
+    executeQueuedChanges(pasteSheetTarget) {
+        for (const sheetId in this.queuedCFChanges) {
+            for (const { toAdd, toRemove, cf } of this.queuedCFChanges[sheetId]) {
+                const newRangesXc = this.getters.getAdaptedCfRanges(sheetId, cf, toAdd, toRemove);
+                if (!newRangesXc) {
+                    continue;
+                }
+                if (newRangesXc.length === 0) {
+                    this.dispatch("REMOVE_CONDITIONAL_FORMAT", { id: cf.id, sheetId });
+                    continue;
+                }
+                this.dispatch("ADD_CONDITIONAL_FORMAT", {
+                    cf: {
+                        id: cf.id,
+                        rule: cf.rule,
+                        stopIfTrue: cf.stopIfTrue,
+                    },
+                    ranges: newRangesXc.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
+                    sheetId,
+                });
+            }
+        }
+        for (const sheetId in this.queuedDVChanges) {
+            for (const { toAdd, toRemove, rule: dv } of this.queuedDVChanges[sheetId]) {
+                // Remove the zones first in case the same position is in toAdd and toRemove
+                const dvZones = dv.ranges.map((range) => range.zone);
+                const withRemovedZones = futureRecomputeZones(dvZones, toRemove);
+                const newDvZones = futureRecomputeZones([...withRemovedZones, ...toAdd], []);
+                if (newDvZones.length === 0) {
+                    this.dispatch("REMOVE_DATA_VALIDATION_RULE", { sheetId, id: dv.id });
+                    continue;
+                }
+                this.dispatch("ADD_DATA_VALIDATION_RULE", {
+                    rule: { id: dv.id, criterion: dv.criterion, isBlocking: dv.isBlocking },
+                    ranges: newDvZones.map((zone) => this.getters.getRangeDataFromZone(sheetId, zone)),
+                    sheetId,
+                });
+            }
+        }
+        for (const borderKey in this.queuedBordersToAdd) {
+            const zones = this.queuedBordersToAdd[borderKey];
+            const border = JSON.parse(borderKey);
+            const target = futureRecomputeZones(zones, []);
+            this.dispatch("SET_BORDERS_ON_TARGET", { sheetId: pasteSheetTarget, target, border });
+        }
+        this.queuedBordersToAdd = {};
     }
 }
 
@@ -58121,6 +58254,6 @@ exports.setTranslationMethod = setTranslationMethod;
 exports.tokenize = tokenize;
 
 
-__info__.version = "17.0.56";
-__info__.date = "2025-04-04T08:36:58.258Z";
-__info__.hash = "c484787";
+__info__.version = "17.0.58";
+__info__.date = "2025-04-18T16:20:26.099Z";
+__info__.hash = "88d92de";