handsontable 0.0.0-next-442b0cf-20241209 → 0.0.0-next-ab59106-20241209

package/dist/handsontable.full.js

@@ -25,8 +25,8 @@
  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING FROM
  * USE OR INABILITY TO USE THIS SOFTWARE.
  *
- * Version: 0.0.0-next-442b0cf-20241209
- * Release date: 17/10/2024 (built at 09/12/2024 10:20:53)
+ * Version: 0.0.0-next-ab59106-20241209
+ * Release date: 17/10/2024 (built at 09/12/2024 13:58:21)
  */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
@@ -42502,7 +42502,7 @@ exports.CellRange = _base.CellRange;
 var _registry = __webpack_require__(760);
 var _eventManager = _interopRequireWildcard(__webpack_require__(522));
 var _translations = __webpack_require__(621);
-var _jquery = _interopRequireDefault(__webpack_require__(1083));
+var _jquery = _interopRequireDefault(__webpack_require__(1098));
 var _ghostTable = _interopRequireDefault(__webpack_require__(839));
 var parseTableHelpers = _interopRequireWildcard(__webpack_require__(524));
 var arrayHelpers = _interopRequireWildcard(__webpack_require__(495));
@@ -42676,8 +42676,8 @@ Handsontable.hooks = _hooks.Hooks.getSingleton();
 Handsontable.CellCoords = _src.CellCoords;
 Handsontable.CellRange = _src.CellRange;
 Handsontable.packageName = 'handsontable';
-Handsontable.buildDate = "09/12/2024 10:20:53";
-Handsontable.version = "0.0.0-next-442b0cf-20241209";
+Handsontable.buildDate = "09/12/2024 13:58:21";
+Handsontable.version = "0.0.0-next-ab59106-20241209";
 Handsontable.languages = {
   dictionaryKeys: _registry.dictionaryKeys,
   getLanguageDictionary: _registry.getLanguageDictionary,
@@ -47118,13 +47118,7 @@ function Core(rootElement, userSettings) {
    * @returns {BasePlugin|undefined} The plugin instance or undefined if there is no plugin.
    */
   this.getPlugin = function (pluginName) {
-    const unifiedPluginName = (0, _string.toUpperCaseFirst)(pluginName);
-
-    // Workaround for the UndoRedo plugin which, currently doesn't follow the plugin architecture.
-    if (unifiedPluginName === 'UndoRedo') {
-      return this.undoRedo;
-    }
-    return pluginsRegistry.getItem(unifiedPluginName);
+    return pluginsRegistry.getItem((0, _string.toUpperCaseFirst)(pluginName));
   };
 
   /**
@@ -53970,7 +53964,7 @@ const domMessages = {
 function _injectProductInfo(key, element) {
   const hasValidType = !isEmpty(key);
   const isNonCommercial = typeof key === 'string' && key.toLowerCase() === 'non-commercial-and-evaluation';
-  const hotVersion = "0.0.0-next-442b0cf-20241209";
+  const hotVersion = "0.0.0-next-ab59106-20241209";
   let keyValidityDate;
   let consoleMessageState = 'invalid';
   let domMessageState = 'invalid';
@@ -95479,8 +95473,7 @@ var _default = () => {
      * | `true`  | Enable the [`UndoRedo`](@/api/undoRedo.md) plugin  |
      * | `false` | Disable the [`UndoRedo`](@/api/undoRedo.md) plugin |
      *
-     * By default, the `undo` option is set to `undefined`,
-     * but the [`UndoRedo`](@/api/undoRedo.md) plugin acts as enabled.
+     * By default, the `undo` option is set to `true`,
      * To disable the [`UndoRedo`](@/api/undoRedo.md) plugin completely,
      * set the `undo` option to `false`.
      *
@@ -95498,7 +95491,7 @@ var _default = () => {
      * undo: true,
      * ```
      */
-    undo: undefined,
+    undo: true,
     /**
      * @description
      * The `validator` option sets a [cell validator](@/guides/cell-functions/cell-validator/cell-validator.md) for a cell.
@@ -112266,13 +112259,6 @@ class BasePlugin {
     if (!initializedPlugins) {
       initializedPlugins = (0, _registry.getPluginsNames)();
     }
-
-    // Workaround for the UndoRedo plugin which, currently doesn't follow the plugin architecture.
-    // Without this line the `callOnPluginsReady` callback won't be triggered after all plugin
-    // initialization.
-    if (initializedPlugins.indexOf('UndoRedo') >= 0) {
-      initializedPlugins.splice(initializedPlugins.indexOf('UndoRedo'), 1);
-    }
     if (initializedPlugins.indexOf(this.pluginName) >= 0) {
       initializedPlugins.splice(initializedPlugins.indexOf(this.pluginName), 1);
     }
@@ -112620,8 +112606,6 @@ class GhostTable {
     if (!this.injected) {
       this.injectTable();
     }
-    const isBorderBoxSizing = this.hot.view.getStylesHandler().areCellsBorderBox();
-    const borderCompensation = isBorderBoxSizing ? 0 : 1;
     (0, _array.arrayEach)(this.rows, row => {
       // In cases when the cell's content produces the height with a decimal point, the height
       // needs to be rounded up to make sure that there will be a space for the cell's content.
@@ -112629,9 +112613,7 @@ class GhostTable {
       const {
         height
       } = row.table.getBoundingClientRect();
-
-      // -1 <- reduce border-top from table (if box-sizing is not border-box)
-      callback(row.row, Math.ceil(height) - borderCompensation);
+      callback(row.row, Math.ceil(height));
     });
   }
 
@@ -151067,11 +151049,10 @@ function _onMapInit() {
 
 
 exports.__esModule = true;
-var _undoRedo = _interopRequireWildcard(__webpack_require__(1081));
-exports.UndoRedo = _undoRedo.default;
+var _undoRedo = __webpack_require__(1081);
 exports.PLUGIN_KEY = _undoRedo.PLUGIN_KEY;
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+exports.PLUGIN_PRIORITY = _undoRedo.PLUGIN_PRIORITY;
+exports.UndoRedo = _undoRedo.UndoRedo;
 
 /***/ }),
 /* 1081 */
@@ -151080,22 +151061,35 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
 "use strict";
 
 
+__webpack_require__(201);
+var _interopRequireDefault = __webpack_require__(197);
 exports.__esModule = true;
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
 __webpack_require__(283);
-__webpack_require__(1082);
-__webpack_require__(311);
-__webpack_require__(323);
-__webpack_require__(519);
-__webpack_require__(329);
-__webpack_require__(530);
+__webpack_require__(287);
+__webpack_require__(298);
+__webpack_require__(300);
+__webpack_require__(303);
+__webpack_require__(305);
+__webpack_require__(307);
+__webpack_require__(309);
+var _base = __webpack_require__(837);
 var _hooks = __webpack_require__(511);
-var _array = __webpack_require__(495);
-var _number = __webpack_require__(534);
 var _object = __webpack_require__(499);
-var _utils = __webpack_require__(877);
-var _moves = __webpack_require__(993);
+var _templateLiteralTag = __webpack_require__(494);
+var _console = __webpack_require__(512);
+var _actions = __webpack_require__(1082);
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
 const SHORTCUTS_GROUP = 'undoRedo';
 const PLUGIN_KEY = exports.PLUGIN_KEY = 'undoRedo';
+const PLUGIN_PRIORITY = exports.PLUGIN_PRIORITY = 1000;
+_hooks.Hooks.getSingleton().register('beforeUndo');
+_hooks.Hooks.getSingleton().register('afterUndo');
+_hooks.Hooks.getSingleton().register('beforeRedo');
+_hooks.Hooks.getSingleton().register('afterRedo');
+const deprecationWarns = new Set();
 
 /**
  * @description
@@ -151108,969 +151102,1278 @@ const PLUGIN_KEY = exports.PLUGIN_KEY = 'undoRedo';
  * ```
  * @class UndoRedo
  * @plugin UndoRedo
- * @param {Core} instance The Handsontable instance.
  */
-function UndoRedo(instance) {
-  const plugin = this;
-  this.instance = instance;
-  this.doneActions = [];
-  this.undoneActions = [];
-  this.ignoreNewActions = false;
-  this.enabled = false;
-  instance.addHook('afterChange', function (changes, source) {
-    const changesLen = changes && changes.length;
-    if (!changesLen) {
+var _UndoRedo_brand = /*#__PURE__*/new WeakSet();
+class UndoRedo extends _base.BasePlugin {
+  static get PLUGIN_KEY() {
+    return PLUGIN_KEY;
+  }
+  static get PLUGIN_PRIORITY() {
+    return PLUGIN_PRIORITY;
+  }
+  static get SETTING_KEYS() {
+    return true;
+  }
+
+  /**
+   * The list of registered action do undo.
+   *
+   * @private
+   * @type {Array}
+   */
+
+  constructor(hotInstance) {
+    super(hotInstance);
+    /**
+     * Listens to the data change and if the source is `loadData` then clears the undo and redo history.
+     *
+     * @param {Array} changes The data changes.
+     * @param {string} source The source of the change.
+     */
+    _classPrivateMethodInitSpec(this, _UndoRedo_brand);
+    (0, _defineProperty2.default)(this, "doneActions", []);
+    /**
+     * The list of registered action do redo.
+     *
+     * @private
+     * @type {Array}
+     */
+    (0, _defineProperty2.default)(this, "undoneActions", []);
+    /**
+     * The flag that determines if new actions should be ignored.
+     *
+     * @private
+     * @type {boolean}
+     */
+    (0, _defineProperty2.default)(this, "ignoreNewActions", false);
+    (0, _actions.registerActions)(hotInstance, this);
+  }
+
+  /**
+   * Checks if the plugin is enabled in the handsontable settings. This method is executed in {@link Hooks#beforeInit}
+   * hook and if it returns `true` then the {@link UndoRedo#enablePlugin} method is called.
+   *
+   * @returns {boolean}
+   */
+  isEnabled() {
+    return !!this.hot.getSettings().undo;
+  }
+
+  /**
+   * Enables the plugin functionality for this Handsontable instance.
+   */
+  enablePlugin() {
+    var _this = this;
+    if (this.enabled) {
       return;
     }
-    const hasDifferences = changes.find(change => {
-      const [,, oldValue, newValue] = change;
-      return oldValue !== newValue;
+    this.addHook('afterChange', function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return _assertClassBrand(_UndoRedo_brand, _this, _onAfterChange).call(_this, ...args);
     });
-    if (!hasDifferences) {
-      return;
-    }
-    const wrappedAction = () => {
-      const clonedChanges = changes.reduce((arr, change) => {
-        arr.push([...change]);
-        return arr;
-      }, []);
-      (0, _array.arrayEach)(clonedChanges, change => {
-        change[1] = instance.propToCol(change[1]);
-      });
-      const selected = changesLen > 1 ? this.getSelected() : [[clonedChanges[0][0], clonedChanges[0][1]]];
-      return new UndoRedo.ChangeAction(clonedChanges, selected);
+    this.registerShortcuts();
+    _assertClassBrand(_UndoRedo_brand, this, _exposeAPIToCore).call(this);
+    super.enablePlugin();
+  }
+
+  /**
+   * Disables the plugin functionality for this Handsontable instance.
+   */
+  disablePlugin() {
+    super.disablePlugin();
+    this.clear();
+    this.unregisterShortcuts();
+    _assertClassBrand(_UndoRedo_brand, this, _removeAPIFromCore).call(this);
+  }
+
+  /**
+   * Registers shortcuts responsible for performing undo/redo.
+   *
+   * @private
+   */
+  registerShortcuts() {
+    const shortcutManager = this.hot.getShortcutManager();
+    const gridContext = shortcutManager.getContext('grid');
+    const runOnlyIf = event => {
+      return !event.altKey; // right ALT in some systems triggers ALT+CTR
     };
-    plugin.done(wrappedAction, source);
-  });
-  instance.addHook('afterCreateRow', (index, amount, source) => {
-    plugin.done(() => new UndoRedo.CreateRowAction(index, amount), source);
-  });
-  const getCellMetas = (fromRow, toRow, fromColumn, toColumn) => {
-    const genericKeys = ['visualRow', 'visualCol', 'row', 'col', 'prop'];
-    const genericKeysLength = genericKeys.length;
-    const cellMetas = [];
-    (0, _number.rangeEach)(fromColumn, toColumn, columnIndex => {
-      (0, _number.rangeEach)(fromRow, toRow, rowIndex => {
-        const cellMeta = instance.getCellMeta(rowIndex, columnIndex);
-        if (Object.keys(cellMeta).length !== genericKeysLength) {
-          const uniqueMeta = Object.fromEntries(Object.entries(cellMeta).filter(_ref => {
-            let [key] = _ref;
-            return genericKeys.includes(key) === false;
-          }));
-          cellMetas.push([cellMeta.visualRow, cellMeta.visualCol, uniqueMeta]);
-        }
-      });
-    });
-    return cellMetas;
-  };
-  instance.addHook('beforeRemoveRow', (index, amount, logicRows, source) => {
-    const wrappedAction = () => {
-      const physicalRowIndex = instance.toPhysicalRow(index);
-      const lastRowIndex = physicalRowIndex + amount - 1;
-      const removedData = (0, _object.deepClone)(plugin.instance.getSourceData(physicalRowIndex, 0, physicalRowIndex + amount - 1, plugin.instance.countSourceCols() - 1));
-      return new UndoRedo.RemoveRowAction(physicalRowIndex, removedData, instance.getSettings().fixedRowsBottom, instance.getSettings().fixedRowsTop, instance.rowIndexMapper.getIndexesSequence(), getCellMetas(physicalRowIndex, lastRowIndex, 0, instance.countCols() - 1));
-    };
-    plugin.done(wrappedAction, source);
-  });
-  instance.addHook('afterCreateCol', (index, amount, source) => {
-    plugin.done(() => new UndoRedo.CreateColumnAction(index, amount), source);
-  });
-  instance.addHook('beforeRemoveCol', (index, amount, logicColumns, source) => {
-    const wrappedAction = () => {
-      const originalData = plugin.instance.getSourceDataArray();
-      const columnIndex = (plugin.instance.countCols() + index) % plugin.instance.countCols();
-      const lastColumnIndex = columnIndex + amount - 1;
-      const removedData = [];
-      const headers = [];
-      const indexes = [];
-      (0, _number.rangeEach)(originalData.length - 1, i => {
-        const column = [];
-        const origRow = originalData[i];
-        (0, _number.rangeEach)(columnIndex, lastColumnIndex, j => {
-          column.push(origRow[instance.toPhysicalColumn(j)]);
-        });
-        removedData.push(column);
-      });
-      (0, _number.rangeEach)(amount - 1, i => {
-        indexes.push(instance.toPhysicalColumn(columnIndex + i));
-      });
-      if (Array.isArray(instance.getSettings().colHeaders)) {
-        (0, _number.rangeEach)(amount - 1, i => {
-          headers.push(instance.getSettings().colHeaders[instance.toPhysicalColumn(columnIndex + i)] || null);
-        });
-      }
-      const columnsMap = instance.columnIndexMapper.getIndexesSequence();
-      const rowsMap = instance.rowIndexMapper.getIndexesSequence();
-      return new UndoRedo.RemoveColumnAction(columnIndex, indexes, removedData, headers, columnsMap, rowsMap, instance.getSettings().fixedColumnsStart, getCellMetas(0, instance.countRows(), columnIndex, lastColumnIndex));
+    const config = {
+      runOnlyIf,
+      group: SHORTCUTS_GROUP
     };
-    plugin.done(wrappedAction, source);
-  });
-  instance.addHook('beforeCellAlignment', (stateBefore, range, type, alignment) => {
-    plugin.done(() => new UndoRedo.CellAlignmentAction(stateBefore, range, type, alignment));
-  });
-  instance.addHook('beforeFilter', (conditionsStack, previousConditionsStack) => {
-    plugin.done(() => new UndoRedo.FiltersAction(conditionsStack, previousConditionsStack));
-  });
-  instance.addHook('beforeRowMove', (rows, finalIndex) => {
-    if (rows === false) {
-      return;
-    }
-    plugin.done(() => new UndoRedo.RowMoveAction(rows, finalIndex));
-  });
-  instance.addHook('beforeColumnMove', (columns, finalIndex) => {
-    if (columns === false) {
-      return;
-    }
-    plugin.done(() => new UndoRedo.ColumnMoveAction(columns, finalIndex));
-  });
-  instance.addHook('beforeMergeCells', (cellRange, auto) => {
-    if (auto) {
+    gridContext.addShortcuts([{
+      keys: [['Control/Meta', 'z']],
+      callback: () => {
+        this.undo();
+      }
+    }, {
+      keys: [['Control/Meta', 'y'], ['Control/Meta', 'Shift', 'z']],
+      callback: () => {
+        this.redo();
+      }
+    }], config);
+  }
+
+  /**
+   * Unregister shortcuts responsible for performing undo/redo.
+   *
+   * @private
+   */
+  unregisterShortcuts() {
+    const shortcutManager = this.hot.getShortcutManager();
+    const gridContext = shortcutManager.getContext('grid');
+    gridContext.removeShortcutsByGroup(SHORTCUTS_GROUP);
+  }
+
+  /**
+   * Stash information about performed actions.
+   *
+   * @fires Hooks#beforeUndoStackChange
+   * @fires Hooks#afterUndoStackChange
+   * @fires Hooks#beforeRedoStackChange
+   * @fires Hooks#afterRedoStackChange
+   * @param {Function} wrappedAction The action descriptor wrapped in a closure.
+   * @param {string} [source] Source of the action. It is defined just for more general actions (not related to plugins).
+   */
+  done(wrappedAction, source) {
+    if (this.ignoreNewActions) {
       return;
     }
-    plugin.done(() => new UndoRedo.MergeCellsAction(instance, cellRange));
-  });
-  instance.addHook('afterUnmergeCells', (cellRange, auto) => {
-    if (auto) {
+    const isBlockedByDefault = source === 'UndoRedo.undo' || source === 'UndoRedo.redo' || source === 'auto';
+    if (isBlockedByDefault) {
       return;
     }
-    plugin.done(() => new UndoRedo.UnmergeCellsAction(instance, cellRange));
-  });
-  instance.addHook('beforeColumnSort', (currentSortConfig, destinationSortConfigs, sortPossible) => {
-    if (!sortPossible) {
+    const doneActionsCopy = this.doneActions.slice();
+    const continueAction = this.hot.runHooks('beforeUndoStackChange', doneActionsCopy, source);
+    if (continueAction === false) {
       return;
     }
-    plugin.done(() => new UndoRedo.ColumnSortAction(currentSortConfig, destinationSortConfigs));
-  });
-
-  // TODO: Why this callback is needed? One test doesn't pass after calling method right after plugin creation (outside the callback).
-  instance.addHook('afterInit', () => {
-    plugin.init();
-  });
-}
-
-/**
- * Stash information about performed actions.
- *
- * @function done
- * @memberof UndoRedo#
- * @fires Hooks#beforeUndoStackChange
- * @fires Hooks#afterUndoStackChange
- * @fires Hooks#beforeRedoStackChange
- * @fires Hooks#afterRedoStackChange
- * @param {Function} wrappedAction The action descriptor wrapped in a closure.
- * @param {string} [source] Source of the action. It is defined just for more general actions (not related to plugins).
- */
-UndoRedo.prototype.done = function (wrappedAction, source) {
-  if (this.ignoreNewActions) {
-    return;
-  }
-  const isBlockedByDefault = source === 'UndoRedo.undo' || source === 'UndoRedo.redo' || source === 'auto';
-  if (isBlockedByDefault) {
-    return;
-  }
-  const doneActionsCopy = this.doneActions.slice();
-  const continueAction = this.instance.runHooks('beforeUndoStackChange', doneActionsCopy, source);
-  if (continueAction === false) {
-    return;
+    const newAction = wrappedAction();
+    const undoneActionsCopy = this.undoneActions.slice();
+    this.doneActions.push(newAction);
+    this.hot.runHooks('afterUndoStackChange', doneActionsCopy, this.doneActions.slice());
+    this.hot.runHooks('beforeRedoStackChange', undoneActionsCopy);
+    this.undoneActions.length = 0;
+    this.hot.runHooks('afterRedoStackChange', undoneActionsCopy, this.undoneActions.slice());
   }
-  const newAction = wrappedAction();
-  const undoneActionsCopy = this.undoneActions.slice();
-  this.doneActions.push(newAction);
-  this.instance.runHooks('afterUndoStackChange', doneActionsCopy, this.doneActions.slice());
-  this.instance.runHooks('beforeRedoStackChange', undoneActionsCopy);
-  this.undoneActions.length = 0;
-  this.instance.runHooks('afterRedoStackChange', undoneActionsCopy, this.undoneActions.slice());
-};
 
-/**
- * Undo the last action performed to the table.
- *
- * @function undo
- * @memberof UndoRedo#
- * @fires Hooks#beforeUndoStackChange
- * @fires Hooks#afterUndoStackChange
- * @fires Hooks#beforeRedoStackChange
- * @fires Hooks#afterRedoStackChange
- * @fires Hooks#beforeUndo
- * @fires Hooks#afterUndo
- */
-UndoRedo.prototype.undo = function () {
-  if (this.isUndoAvailable()) {
+  /**
+   * Undo the last action performed to the table.
+   *
+   * @fires Hooks#beforeUndoStackChange
+   * @fires Hooks#afterUndoStackChange
+   * @fires Hooks#beforeRedoStackChange
+   * @fires Hooks#afterRedoStackChange
+   * @fires Hooks#beforeUndo
+   * @fires Hooks#afterUndo
+   */
+  undo() {
+    if (!this.isUndoAvailable()) {
+      return;
+    }
     const doneActionsCopy = this.doneActions.slice();
-    this.instance.runHooks('beforeUndoStackChange', doneActionsCopy);
+    this.hot.runHooks('beforeUndoStackChange', doneActionsCopy);
     const action = this.doneActions.pop();
-    this.instance.runHooks('afterUndoStackChange', doneActionsCopy, this.doneActions.slice());
+    this.hot.runHooks('afterUndoStackChange', doneActionsCopy, this.doneActions.slice());
     const actionClone = (0, _object.deepClone)(action);
-    const continueAction = this.instance.runHooks('beforeUndo', actionClone);
+    const continueAction = this.hot.runHooks('beforeUndo', actionClone);
     if (continueAction === false) {
       return;
     }
     this.ignoreNewActions = true;
-    const that = this;
     const undoneActionsCopy = this.undoneActions.slice();
-    this.instance.runHooks('beforeRedoStackChange', undoneActionsCopy);
-    action.undo(this.instance, () => {
-      that.ignoreNewActions = false;
-      that.undoneActions.push(action);
+    this.hot.runHooks('beforeRedoStackChange', undoneActionsCopy);
+    action.undo(this.hot, () => {
+      this.ignoreNewActions = false;
+      this.undoneActions.push(action);
     });
-    this.instance.runHooks('afterRedoStackChange', undoneActionsCopy, this.undoneActions.slice());
-    this.instance.runHooks('afterUndo', actionClone);
+    this.hot.runHooks('afterRedoStackChange', undoneActionsCopy, this.undoneActions.slice());
+    this.hot.runHooks('afterUndo', actionClone);
   }
-};
 
-/**
- * Redo the previous action performed to the table (used to reverse an undo).
- *
- * @function redo
- * @memberof UndoRedo#
- * @fires Hooks#beforeUndoStackChange
- * @fires Hooks#afterUndoStackChange
- * @fires Hooks#beforeRedoStackChange
- * @fires Hooks#afterRedoStackChange
- * @fires Hooks#beforeRedo
- * @fires Hooks#afterRedo
- */
-UndoRedo.prototype.redo = function () {
-  if (this.isRedoAvailable()) {
+  /**
+   * Redo the previous action performed to the table (used to reverse an undo).
+   *
+   * @fires Hooks#beforeUndoStackChange
+   * @fires Hooks#afterUndoStackChange
+   * @fires Hooks#beforeRedoStackChange
+   * @fires Hooks#afterRedoStackChange
+   * @fires Hooks#beforeRedo
+   * @fires Hooks#afterRedo
+   */
+  redo() {
+    if (!this.isRedoAvailable()) {
+      return;
+    }
     const undoneActionsCopy = this.undoneActions.slice();
-    this.instance.runHooks('beforeRedoStackChange', undoneActionsCopy);
+    this.hot.runHooks('beforeRedoStackChange', undoneActionsCopy);
     const action = this.undoneActions.pop();
-    this.instance.runHooks('afterRedoStackChange', undoneActionsCopy, this.undoneActions.slice());
+    this.hot.runHooks('afterRedoStackChange', undoneActionsCopy, this.undoneActions.slice());
     const actionClone = (0, _object.deepClone)(action);
-    const continueAction = this.instance.runHooks('beforeRedo', actionClone);
+    const continueAction = this.hot.runHooks('beforeRedo', actionClone);
     if (continueAction === false) {
       return;
     }
     this.ignoreNewActions = true;
-    const that = this;
     const doneActionsCopy = this.doneActions.slice();
-    this.instance.runHooks('beforeUndoStackChange', doneActionsCopy);
-    action.redo(this.instance, () => {
-      that.ignoreNewActions = false;
-      that.doneActions.push(action);
+    this.hot.runHooks('beforeUndoStackChange', doneActionsCopy);
+    action.redo(this.hot, () => {
+      this.ignoreNewActions = false;
+      this.doneActions.push(action);
     });
-    this.instance.runHooks('afterUndoStackChange', doneActionsCopy, this.doneActions.slice());
-    this.instance.runHooks('afterRedo', actionClone);
+    this.hot.runHooks('afterUndoStackChange', doneActionsCopy, this.doneActions.slice());
+    this.hot.runHooks('afterRedo', actionClone);
   }
-};
 
-/**
- * Checks if undo action is available.
- *
- * @function isUndoAvailable
- * @memberof UndoRedo#
- * @returns {boolean} Return `true` if undo can be performed, `false` otherwise.
- */
-UndoRedo.prototype.isUndoAvailable = function () {
-  return this.doneActions.length > 0;
-};
+  /**
+   * Checks if undo action is available.
+   *
+   * @returns {boolean} Return `true` if undo can be performed, `false` otherwise.
+   */
+  isUndoAvailable() {
+    return this.doneActions.length > 0;
+  }
 
-/**
- * Checks if redo action is available.
- *
- * @function isRedoAvailable
- * @memberof UndoRedo#
- * @returns {boolean} Return `true` if redo can be performed, `false` otherwise.
- */
-UndoRedo.prototype.isRedoAvailable = function () {
-  return this.undoneActions.length > 0;
-};
+  /**
+   * Checks if redo action is available.
+   *
+   * @returns {boolean} Return `true` if redo can be performed, `false` otherwise.
+   */
+  isRedoAvailable() {
+    return this.undoneActions.length > 0;
+  }
 
+  /**
+   * Clears undo and redo history.
+   */
+  clear() {
+    this.doneActions.length = 0;
+    this.undoneActions.length = 0;
+  }
+  /**
+   * Destroys the plugin instance.
+   */
+  destroy() {
+    this.clear();
+    this.doneActions = null;
+    this.undoneActions = null;
+    super.destroy();
+  }
+}
+exports.UndoRedo = UndoRedo;
+function _onAfterChange(changes, source) {
+  if (source === 'loadData') {
+    this.clear();
+  }
+}
 /**
- * Clears undo history.
- *
- * @function clear
- * @memberof UndoRedo#
+ * Expose the plugin API to the Core. It is for backward compatibility and it should be removed in the future.
  */
-UndoRedo.prototype.clear = function () {
-  this.doneActions.length = 0;
-  this.undoneActions.length = 0;
-};
+function _exposeAPIToCore() {
+  const deprecatedWarn = methodName => {
+    if (!deprecationWarns.has(methodName)) {
+      (0, _console.warn)((0, _templateLiteralTag.toSingleLine)`The "${methodName}" method is deprecated and it will be removed\x20
+          from the Core API in the future. Please use the method from the UndoRedo plugin\x20
+          (e.g. \`hotInstance.getPlugin("undoRedo").${methodName}()\`).`);
+      deprecationWarns.add(methodName);
+    }
+  };
 
+  /**
+   * {@link UndoRedo#undo}.
+   *
+   * @alias undo
+   * @memberof! Core#
+   */
+  this.hot.undo = () => {
+    deprecatedWarn('undo');
+    this.undo();
+  };
+  /**
+   * {@link UndoRedo#redo}.
+   *
+   * @alias redo
+   * @memberof! Core#
+   */
+  this.hot.redo = () => {
+    deprecatedWarn('redo');
+    this.redo();
+  };
+  /**
+   * {@link UndoRedo#isUndoAvailable}.
+   *
+   * @alias isUndoAvailable
+   * @memberof! Core#
+   * @returns {boolean}
+   */
+  this.hot.isUndoAvailable = () => {
+    deprecatedWarn('isUndoAvailable');
+    return this.isUndoAvailable();
+  };
+  /**
+   * {@link UndoRedo#isRedoAvailable}.
+   *
+   * @alias isRedoAvailable
+   * @memberof! Core#
+   * @returns {boolean}
+   */
+  this.hot.isRedoAvailable = () => {
+    deprecatedWarn('isRedoAvailable');
+    return this.isRedoAvailable();
+  };
+  /**
+   * {@link UndoRedo#clear}.
+   *
+   * @alias clearUndo
+   * @memberof! Core#
+   */
+  this.hot.clearUndo = () => {
+    deprecatedWarn('clear');
+    this.clear();
+  };
+  this.hot.undoRedo = this;
+}
 /**
- * Checks if the plugin is enabled.
- *
- * @function isEnabled
- * @memberof UndoRedo#
- * @returns {boolean}
+ * Removes the plugin API from the Core. It is for backward compatibility and it should be removed in the future.
  */
-UndoRedo.prototype.isEnabled = function () {
-  return this.enabled;
-};
+function _removeAPIFromCore() {
+  delete this.hot.undo;
+  delete this.hot.redo;
+  delete this.hot.isUndoAvailable;
+  delete this.hot.isRedoAvailable;
+  delete this.hot.clearUndo;
+  delete this.hot.undoRedo;
+}
 
-/**
- * Enables the plugin.
- *
- * @function enable
- * @memberof UndoRedo#
- */
-UndoRedo.prototype.enable = function () {
-  if (this.isEnabled()) {
-    return;
-  }
-  const hot = this.instance;
-  this.enabled = true;
-  exposeUndoRedoMethods(hot);
-  this.registerShortcuts();
-  hot.addHook('afterChange', onAfterChange);
-};
+/***/ }),
+/* 1082 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-/**
- * Disables the plugin.
- *
- * @function disable
- * @memberof UndoRedo#
- */
-UndoRedo.prototype.disable = function () {
-  if (!this.isEnabled()) {
-    return;
-  }
-  const hot = this.instance;
-  this.enabled = false;
-  removeExposedUndoRedoMethods(hot);
-  this.unregisterShortcuts();
-  hot.removeHook('afterChange', onAfterChange);
-};
+"use strict";
 
-/**
- * Destroys the instance.
+
+exports.__esModule = true;
+exports.registerActions = registerActions;
+__webpack_require__(311);
+__webpack_require__(329);
+var _cellAlignment = __webpack_require__(1083);
+var _columnMove = __webpack_require__(1085);
+var _columnSort = __webpack_require__(1086);
+var _createColumn = __webpack_require__(1087);
+var _createRow = __webpack_require__(1088);
+var _dataChange = __webpack_require__(1089);
+var _filters = __webpack_require__(1090);
+var _mergeCells = __webpack_require__(1091);
+var _removeColumn = __webpack_require__(1092);
+var _removeRow = __webpack_require__(1095);
+var _rowMove = __webpack_require__(1096);
+var _unmergeCells = __webpack_require__(1097);
+/**
+ * Register all undo/redo actions.
  *
- * @function destroy
- * @memberof UndoRedo#
+ * @param {Core} hot The Handsontable instance.
+ * @param {UndoRedo} undoRedoPlugin The undoRedo plugin instance.
  */
-UndoRedo.prototype.destroy = function () {
-  this.clear();
-  this.instance = null;
-  this.doneActions = null;
-  this.undoneActions = null;
-};
-UndoRedo.Action = function () {};
-UndoRedo.Action.prototype.undo = function () {};
-UndoRedo.Action.prototype.redo = function () {};
+function registerActions(hot, undoRedoPlugin) {
+  [_cellAlignment.CellAlignmentAction, _columnMove.ColumnMoveAction, _columnSort.ColumnSortAction, _createColumn.CreateColumnAction, _createRow.CreateRowAction, _dataChange.DataChangeAction, _filters.FiltersAction, _mergeCells.MergeCellsAction, _removeColumn.RemoveColumnAction, _removeRow.RemoveRowAction, _rowMove.RowMoveAction, _unmergeCells.UnmergeCellsAction].forEach(action => action.startRegisteringEvents(hot, undoRedoPlugin));
+}
+
+/***/ }),
+/* 1083 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
+var _utils = __webpack_require__(877);
+var _array = __webpack_require__(495);
 /**
- * Change action.
+ * Action that tracks cell alignment changes.
  *
+ * @class CellAlignmentAction
  * @private
- * @param {Array} changes 2D array containing information about each of the edited cells.
- * @param {number[]} selected The cell selection.
  */
-UndoRedo.ChangeAction = function (changes, selected) {
-  this.changes = changes;
-  this.selected = selected;
-  this.actionType = 'change';
-};
-(0, _object.inherit)(UndoRedo.ChangeAction, UndoRedo.Action);
-UndoRedo.ChangeAction.prototype.undo = function (instance, undoneCallback) {
-  const data = (0, _object.deepClone)(this.changes);
-  const emptyRowsAtTheEnd = instance.countEmptyRows(true);
-  const emptyColsAtTheEnd = instance.countEmptyCols(true);
-  for (let i = 0, len = data.length; i < len; i++) {
-    data[i].splice(3, 1);
-  }
-  instance.addHookOnce('afterChange', undoneCallback);
-  instance.setDataAtCell(data, null, null, 'UndoRedo.undo');
-  for (let i = 0, len = data.length; i < len; i++) {
-    const [row, column] = data[i];
-    if (instance.getSettings().minSpareRows && row + 1 + instance.getSettings().minSpareRows === instance.countRows() && emptyRowsAtTheEnd === instance.getSettings().minSpareRows) {
-      instance.alter('remove_row', parseInt(row + 1, 10), instance.getSettings().minSpareRows);
-      instance.undoRedo.doneActions.pop();
-    }
-    if (instance.getSettings().minSpareCols && column + 1 + instance.getSettings().minSpareCols === instance.countCols() && emptyColsAtTheEnd === instance.getSettings().minSpareCols) {
-      instance.alter('remove_col', parseInt(column + 1, 10), instance.getSettings().minSpareCols);
-      instance.undoRedo.doneActions.pop();
-    }
-  }
-  const selectedLast = instance.getSelectedLast();
-  if (selectedLast !== undefined) {
-    const [changedRow, changedColumn] = data[0];
-    const [selectedRow, selectedColumn] = selectedLast;
-    const firstFullyVisibleRow = instance.getFirstFullyVisibleRow();
-    const firstFullyVisibleColumn = instance.getFirstFullyVisibleColumn();
-    const isInVerticalViewPort = changedRow >= firstFullyVisibleRow;
-    const isInHorizontalViewPort = changedColumn >= firstFullyVisibleColumn;
-    const isInViewport = isInVerticalViewPort && isInHorizontalViewPort;
-    const isChangedSelection = selectedRow !== changedRow || selectedColumn !== changedColumn;
-
-    // Performing scroll only when selection has been changed right after editing a cell.
-    if (isInViewport === false && isChangedSelection === true) {
-      const scrollConfig = {
-        row: changedRow,
-        col: changedColumn
-      };
-      if (isInVerticalViewPort === false) {
-        scrollConfig.verticalSnap = 'top';
-      }
-      if (isInHorizontalViewPort === false) {
-        scrollConfig.horizontalSnap = 'start';
-      }
-      instance.scrollViewportTo(scrollConfig);
-    }
+class CellAlignmentAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      stateBefore,
+      range,
+      type,
+      alignment
+    } = _ref;
+    super();
+    /**
+     * @param {Array} stateBefore The previous state.
+     */
+    (0, _defineProperty2.default)(this, "stateBefore", void 0);
+    /**
+     * @param {object} range The cell range.
+     */
+    (0, _defineProperty2.default)(this, "range", void 0);
+    /**
+     * @param {string} type The type of the alignment ("top", "left", "bottom" or "right").
+     */
+    (0, _defineProperty2.default)(this, "type", void 0);
+    /**
+     * @param {string} alignment The alignment CSS class.
+     */
+    (0, _defineProperty2.default)(this, "alignment", void 0);
+    this.stateBefore = stateBefore;
+    this.range = range;
+    this.type = type;
+    this.alignment = alignment;
   }
-  instance.selectCells(this.selected, false, false);
-};
-UndoRedo.ChangeAction.prototype.redo = function (instance, onFinishCallback) {
-  const data = (0, _object.deepClone)(this.changes);
-  for (let i = 0, len = data.length; i < len; i++) {
-    data[i].splice(2, 1);
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeCellAlignment', (stateBefore, range, type, alignment) => {
+      undoRedoPlugin.done(() => new CellAlignmentAction({
+        stateBefore,
+        range,
+        type,
+        alignment
+      }));
+    });
   }
-  instance.addHookOnce('afterChange', onFinishCallback);
-  instance.setDataAtCell(data, null, null, 'UndoRedo.redo');
-  if (this.selected) {
-    instance.selectCells(this.selected, false, false);
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    (0, _array.arrayEach)(this.range, range => {
+      range.forAll((row, col) => {
+        // Alignment classes should only collected within cell ranges. We skip header coordinates.
+        if (row >= 0 && col >= 0) {
+          hot.setCellMeta(row, col, 'className', this.stateBefore[row][col] || ' htLeft');
+        }
+      });
+    });
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    hot.render();
   }
-};
 
-/**
- * Create row action.
- *
- * @private
- * @param {number} index The visual row index.
- * @param {number} amount The number of created rows.
- */
-UndoRedo.CreateRowAction = function (index, amount) {
-  this.index = index;
-  this.amount = amount;
-  this.actionType = 'insert_row';
-};
-(0, _object.inherit)(UndoRedo.CreateRowAction, UndoRedo.Action);
-UndoRedo.CreateRowAction.prototype.undo = function (instance, undoneCallback) {
-  const rowCount = instance.countRows();
-  const minSpareRows = instance.getSettings().minSpareRows;
-  if (this.index >= rowCount && this.index - minSpareRows < rowCount) {
-    this.index -= minSpareRows; // work around the situation where the needed row was removed due to an 'undo' of a made change
-  }
-  instance.addHookOnce('afterRemoveRow', undoneCallback);
-  instance.alter('remove_row', this.index, this.amount, 'UndoRedo.undo');
-};
-UndoRedo.CreateRowAction.prototype.redo = function (instance, redoneCallback) {
-  instance.addHookOnce('afterCreateRow', redoneCallback);
-  instance.alter('insert_row_above', this.index, this.amount, 'UndoRedo.redo');
-};
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    (0, _utils.align)(this.range, this.type, this.alignment, (row, col) => hot.getCellMeta(row, col), (row, col, key, value) => hot.setCellMeta(row, col, key, value));
+    hot.addHookOnce('afterViewRender', redoneCallback);
+    hot.render();
+  }
+}
+exports.CellAlignmentAction = CellAlignmentAction;
 
-/**
- * Remove row action.
- *
- * @private
- * @param {number} index The visual row index.
- * @param {Array} data The removed data.
- * @param {number} fixedRowsBottom Number of fixed rows on the bottom. Remove row action change it sometimes.
- * @param {number} fixedRowsTop Number of fixed rows on the top. Remove row action change it sometimes.
- * @param {Array} rowIndexesSequence Row index sequence taken from the row index mapper.
- * @param {Array} removedCellMetas List of removed cell metas.
- */
-UndoRedo.RemoveRowAction = function (index, data, fixedRowsBottom, fixedRowsTop, rowIndexesSequence, removedCellMetas) {
-  this.index = index;
-  this.data = data;
-  this.actionType = 'remove_row';
-  this.fixedRowsBottom = fixedRowsBottom;
-  this.fixedRowsTop = fixedRowsTop;
-  this.rowIndexesSequence = rowIndexesSequence;
-  this.removedCellMetas = removedCellMetas;
-};
-(0, _object.inherit)(UndoRedo.RemoveRowAction, UndoRedo.Action);
-UndoRedo.RemoveRowAction.prototype.undo = function (instance, undoneCallback) {
-  const settings = instance.getSettings();
-  const changes = [];
+/***/ }),
+/* 1084 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-  // Changing by the reference as `updateSettings` doesn't work the best.
-  settings.fixedRowsBottom = this.fixedRowsBottom;
-  settings.fixedRowsTop = this.fixedRowsTop;
+"use strict";
 
-  // Prepare the change list to fill the source data.
-  this.data.forEach((dataRow, rowIndexDelta) => {
-    Object.keys(dataRow).forEach(columnProp => {
-      const columnIndex = parseInt(columnProp, 10);
-      changes.push([this.index + rowIndexDelta, isNaN(columnIndex) ? columnProp : columnIndex, dataRow[columnProp]]);
-    });
-  });
-  instance.alter('insert_row_above', this.index, this.data.length, 'UndoRedo.undo');
-  this.removedCellMetas.forEach(_ref2 => {
-    let [rowIndex, columnIndex, cellMeta] = _ref2;
-    instance.setCellMetaObject(rowIndex, columnIndex, cellMeta);
-  });
-  instance.addHookOnce('afterViewRender', undoneCallback);
-  instance.setSourceDataAtCell(changes, null, null, 'UndoRedo.undo');
-  instance.rowIndexMapper.setIndexesSequence(this.rowIndexesSequence);
-};
-UndoRedo.RemoveRowAction.prototype.redo = function (instance, redoneCallback) {
-  instance.addHookOnce('afterRemoveRow', redoneCallback);
-  instance.alter('remove_row', this.index, this.data.length, 'UndoRedo.redo');
-};
 
+exports.__esModule = true;
+__webpack_require__(201);
 /**
- * Create column action.
+ * An abstract class that defines the structure of an undo/redo action.
  *
+ * @class BaseAction
  * @private
- * @param {number} index The visual column index.
- * @param {number} amount The number of created columns.
  */
-UndoRedo.CreateColumnAction = function (index, amount) {
-  this.index = index;
-  this.amount = amount;
-  this.actionType = 'insert_col';
-};
-(0, _object.inherit)(UndoRedo.CreateColumnAction, UndoRedo.Action);
-UndoRedo.CreateColumnAction.prototype.undo = function (instance, undoneCallback) {
-  instance.addHookOnce('afterRemoveCol', undoneCallback);
-  instance.alter('remove_col', this.index, this.amount, 'UndoRedo.undo');
-};
-UndoRedo.CreateColumnAction.prototype.redo = function (instance, redoneCallback) {
-  instance.addHookOnce('afterCreateCol', redoneCallback);
-  instance.alter('insert_col_start', this.index, this.amount, 'UndoRedo.redo');
-};
+class BaseAction {
+  undo() {
+    throw new Error('Not implemented');
+  }
+  redo() {
+    throw new Error('Not implemented');
+  }
+}
+exports.BaseAction = BaseAction;
 
+/***/ }),
+/* 1085 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+__webpack_require__(311);
+__webpack_require__(329);
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
+var _moves = __webpack_require__(993);
 /**
- * Remove column action.
+ * Action that tracks column move changes.
  *
+ * @class ColumnMoveAction
  * @private
- * @param {number} index The visual column index.
- * @param {number[]} indexes The visual column indexes.
- * @param {Array} data The removed data.
- * @param {Array} headers The header values.
- * @param {number[]} columnPositions The column position.
- * @param {number[]} rowPositions The row position.
- * @param {number} fixedColumnsStart Number of fixed columns on the left. Remove column action change it sometimes.
- * @param {Array} removedCellMetas List of removed cell metas.
- */
-UndoRedo.RemoveColumnAction = function (index, indexes, data, headers, columnPositions, rowPositions, fixedColumnsStart, removedCellMetas) {
-  // eslint-disable-line max-len
-  this.index = index;
-  this.indexes = indexes;
-  this.data = data;
-  this.amount = this.data[0].length;
-  this.headers = headers;
-  this.columnPositions = columnPositions.slice(0);
-  this.rowPositions = rowPositions.slice(0);
-  this.actionType = 'remove_col';
-  this.fixedColumnsStart = fixedColumnsStart;
-  this.removedCellMetas = removedCellMetas;
-};
-(0, _object.inherit)(UndoRedo.RemoveColumnAction, UndoRedo.Action);
-UndoRedo.RemoveColumnAction.prototype.undo = function (instance, undoneCallback) {
-  const settings = instance.getSettings();
-
-  // Changing by the reference as `updateSettings` doesn't work the best.
-  settings.fixedColumnsStart = this.fixedColumnsStart;
-  const ascendingIndexes = this.indexes.slice(0).sort();
-  const sortByIndexes = (elem, j, arr) => arr[this.indexes.indexOf(ascendingIndexes[j])];
-  const removedDataLength = this.data.length;
-  const sortedData = [];
-  for (let rowIndex = 0; rowIndex < removedDataLength; rowIndex++) {
-    sortedData.push((0, _array.arrayMap)(this.data[rowIndex], sortByIndexes));
-  }
-  const sortedHeaders = (0, _array.arrayMap)(this.headers, sortByIndexes);
-  const changes = [];
-  instance.alter('insert_col_start', this.indexes[0], this.indexes.length, 'UndoRedo.undo');
-  (0, _array.arrayEach)(instance.getSourceDataArray(), (rowData, rowIndex) => {
-    (0, _array.arrayEach)(ascendingIndexes, (changedIndex, contiquesIndex) => {
-      rowData[changedIndex] = sortedData[rowIndex][contiquesIndex];
-      changes.push([rowIndex, changedIndex, rowData[changedIndex]]);
-    });
-  });
-  instance.setSourceDataAtCell(changes, undefined, undefined, 'UndoRedo.undo');
-  if (typeof this.headers !== 'undefined') {
-    (0, _array.arrayEach)(sortedHeaders, (headerData, columnIndex) => {
-      instance.getSettings().colHeaders[ascendingIndexes[columnIndex]] = headerData;
+ */
+class ColumnMoveAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      columns,
+      finalIndex
+    } = _ref;
+    super();
+    /**
+     * @param {number[]} columns An array with moved columns.
+     */
+    (0, _defineProperty2.default)(this, "columns", void 0);
+    /**
+     * @param {number} finalIndex The destination index.
+     */
+    (0, _defineProperty2.default)(this, "finalColumnIndex", void 0);
+    this.columns = columns.slice();
+    this.finalColumnIndex = finalIndex;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeColumnMove', (columns, finalIndex) => {
+      if (columns === false) {
+        return;
+      }
+      undoRedoPlugin.done(() => new ColumnMoveAction({
+        columns,
+        finalIndex
+      }));
     });
   }
-  this.removedCellMetas.forEach(_ref3 => {
-    let [rowIndex, columnIndex, cellMeta] = _ref3;
-    instance.setCellMetaObject(rowIndex, columnIndex, cellMeta);
-  });
-  instance.batchExecution(() => {
-    // Restore row sequence in a case when all columns are removed. the original
-    // row sequence is lost in that case.
-    instance.rowIndexMapper.setIndexesSequence(this.rowPositions);
-    instance.columnIndexMapper.setIndexesSequence(this.columnPositions);
-  }, true);
-  instance.addHookOnce('afterViewRender', undoneCallback);
-  instance.render();
-};
-UndoRedo.RemoveColumnAction.prototype.redo = function (instance, redoneCallback) {
-  instance.addHookOnce('afterRemoveCol', redoneCallback);
-  instance.alter('remove_col', this.index, this.amount, 'UndoRedo.redo');
-};
 
-/**
- * Cell alignment action.
- *
- * @private
- * @param {Array} stateBefore The previous state.
- * @param {object} range The cell range.
- * @param {string} type The type of the alignment ("top", "left", "bottom" or "right").
- * @param {string} alignment The alignment CSS class.
- */
-UndoRedo.CellAlignmentAction = function (stateBefore, range, type, alignment) {
-  this.stateBefore = stateBefore;
-  this.range = range;
-  this.type = type;
-  this.alignment = alignment;
-};
-UndoRedo.CellAlignmentAction.prototype.undo = function (instance, undoneCallback) {
-  (0, _array.arrayEach)(this.range, range => {
-    range.forAll((row, col) => {
-      // Alignment classes should only collected within cell ranges. We skip header coordinates.
-      if (row >= 0 && col >= 0) {
-        instance.setCellMeta(row, col, 'className', this.stateBefore[row][col] || ' htLeft');
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const manualColumnMove = hot.getPlugin('manualColumnMove');
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    const columnMoves = (0, _moves.getMoves)(this.columns, this.finalColumnIndex, hot.columnIndexMapper.getNumberOfIndexes());
+    columnMoves.reverse().forEach(_ref2 => {
+      let {
+        from,
+        to
+      } = _ref2;
+      if (from < to) {
+        to -= 1;
       }
+      manualColumnMove.moveColumn(to, from);
     });
-  });
-  instance.addHookOnce('afterViewRender', undoneCallback);
-  instance.render();
-};
-UndoRedo.CellAlignmentAction.prototype.redo = function (instance, undoneCallback) {
-  (0, _utils.align)(this.range, this.type, this.alignment, (row, col) => instance.getCellMeta(row, col), (row, col, key, value) => instance.setCellMeta(row, col, key, value));
-  instance.addHookOnce('afterViewRender', undoneCallback);
-  instance.render();
-};
+    hot.render();
+    hot.deselectCell();
+    hot.selectColumns(this.columns[0], this.columns[0] + this.columns.length - 1);
+  }
 
-/**
- * Filters action.
- *
- * @private
- * @param {Array} conditionsStack An array of the filter conditions.
- * @param {Array} previousConditionsStack An array of the previous filter conditions.
- */
-UndoRedo.FiltersAction = function (conditionsStack, previousConditionsStack) {
-  this.previousConditionsStack = previousConditionsStack;
-  this.conditionsStack = conditionsStack;
-  this.actionType = 'filter';
-};
-(0, _object.inherit)(UndoRedo.FiltersAction, UndoRedo.Action);
-UndoRedo.FiltersAction.prototype.undo = function (instance, undoneCallback) {
-  const filters = instance.getPlugin('filters');
-  instance.addHookOnce('afterViewRender', undoneCallback);
-  if (this.previousConditionsStack) {
-    filters.conditionCollection.importAllConditions(this.previousConditionsStack);
-  }
-  filters.filter();
-};
-UndoRedo.FiltersAction.prototype.redo = function (instance, redoneCallback) {
-  const filters = instance.getPlugin('filters');
-  instance.addHookOnce('afterViewRender', redoneCallback);
-  filters.conditionCollection.importAllConditions(this.conditionsStack);
-  filters.filter();
-};
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    const manualColumnMove = hot.getPlugin('manualColumnMove');
+    hot.addHookOnce('afterViewRender', redoneCallback);
+    manualColumnMove.moveColumns(this.columns.slice(), this.finalColumnIndex);
+    hot.render();
+    hot.deselectCell();
+    hot.selectColumns(this.finalColumnIndex, this.finalColumnIndex + this.columns.length - 1);
+  }
+}
+exports.ColumnMoveAction = ColumnMoveAction;
+
+/***/ }),
+/* 1086 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
 
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
 /**
- * Merge Cells action.
+ * Action that tracks column sort changes.
  *
- * @util
+ * @class ColumnSortAction
+ * @private
  */
-class MergeCellsAction extends UndoRedo.Action {
-  constructor(instance, cellRange) {
+class ColumnSortAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      currentSortState,
+      newSortState
+    } = _ref;
     super();
-    this.cellRange = cellRange;
-    const topStartCorner = this.cellRange.getTopStartCorner();
-    const bottomEndCorner = this.cellRange.getBottomEndCorner();
-    this.rangeData = instance.getData(topStartCorner.row, topStartCorner.col, bottomEndCorner.row, bottomEndCorner.col);
+    /**
+     * @param {Array} currentSortState The current sort state.
+     */
+    (0, _defineProperty2.default)(this, "previousSortState", void 0);
+    /**
+     * @param {Array} newSortState The new sort state.
+     */
+    (0, _defineProperty2.default)(this, "nextSortState", void 0);
+    this.previousSortState = currentSortState;
+    this.nextSortState = newSortState;
   }
-  undo(instance, undoneCallback) {
-    const mergeCellsPlugin = instance.getPlugin('mergeCells');
-    instance.addHookOnce('afterViewRender', undoneCallback);
-    mergeCellsPlugin.unmergeRange(this.cellRange, true);
-    const topStartCorner = this.cellRange.getTopStartCorner();
-    instance.populateFromArray(topStartCorner.row, topStartCorner.col, this.rangeData, undefined, undefined, 'MergeCells');
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeColumnSort', (currentSortState, newSortState, sortPossible) => {
+      if (!sortPossible) {
+        return;
+      }
+      undoRedoPlugin.done(() => new ColumnSortAction({
+        currentSortState,
+        newSortState
+      }));
+    });
   }
-  redo(instance, redoneCallback) {
-    const mergeCellsPlugin = instance.getPlugin('mergeCells');
-    instance.addHookOnce('afterViewRender', redoneCallback);
-    mergeCellsPlugin.mergeRange(this.cellRange);
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const sortPlugin = hot.getPlugin('columnSorting');
+    const multiSortPlugin = hot.getPlugin('multiColumnSorting');
+    const enabledSortPlugin = multiSortPlugin.isEnabled() ? multiSortPlugin : sortPlugin;
+    if (this.previousSortState.length) {
+      enabledSortPlugin.sort(this.previousSortState);
+    } else {
+      enabledSortPlugin.clearSort();
+    }
+    undoneCallback();
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    const sortPlugin = hot.getPlugin('columnSorting');
+    const multiSortPlugin = hot.getPlugin('multiColumnSorting');
+    const enabledSortPlugin = multiSortPlugin.isEnabled() ? multiSortPlugin : sortPlugin;
+    enabledSortPlugin.sort(this.nextSortState);
+    redoneCallback();
   }
 }
-UndoRedo.MergeCellsAction = MergeCellsAction;
+exports.ColumnSortAction = ColumnSortAction;
+
+/***/ }),
+/* 1087 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
 /**
- * Unmerge Cells action.
+ * Action that tracks column creation.
  *
- * @util
+ * @class CreateColumnAction
+ * @private
  */
-class UnmergeCellsAction extends UndoRedo.Action {
-  constructor(instance, cellRange) {
+class CreateColumnAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      index,
+      amount
+    } = _ref;
     super();
-    this.cellRange = cellRange;
+    /**
+     * @param {number} index The visual column index.
+     */
+    (0, _defineProperty2.default)(this, "index", void 0);
+    /**
+     * @param {number} amount The number of created columns.
+     */
+    (0, _defineProperty2.default)(this, "amount", void 0);
+    this.index = index;
+    this.amount = amount;
   }
-  undo(instance, undoneCallback) {
-    const mergeCellsPlugin = instance.getPlugin('mergeCells');
-    instance.addHookOnce('afterViewRender', undoneCallback);
-    mergeCellsPlugin.mergeRange(this.cellRange, true);
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('afterCreateCol', (index, amount, source) => {
+      undoRedoPlugin.done(() => new CreateColumnAction({
+        index,
+        amount
+      }), source);
+    });
   }
-  redo(instance, redoneCallback) {
-    const mergeCellsPlugin = instance.getPlugin('mergeCells');
-    instance.addHookOnce('afterViewRender', redoneCallback);
-    mergeCellsPlugin.unmergeRange(this.cellRange, true);
-    instance.render();
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    hot.addHookOnce('afterRemoveCol', undoneCallback);
+    hot.alter('remove_col', this.index, this.amount, 'UndoRedo.undo');
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    hot.addHookOnce('afterCreateCol', redoneCallback);
+    hot.alter('insert_col_start', this.index, this.amount, 'UndoRedo.redo');
   }
 }
-UndoRedo.UnmergeCellsAction = UnmergeCellsAction;
+exports.CreateColumnAction = CreateColumnAction;
+
+/***/ }),
+/* 1088 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
 /**
- * ManualRowMove action.
+ * Action that tracks row creation.
  *
- * @TODO removeRow undo should works on logical index
+ * @class CreateRowAction
  * @private
- * @param {number[]} rows An array with moved rows.
- * @param {number} finalIndex The destination index.
  */
-UndoRedo.RowMoveAction = function (rows, finalIndex) {
-  this.rows = rows.slice();
-  this.finalRowIndex = finalIndex;
-  this.actionType = 'row_move';
-};
-(0, _object.inherit)(UndoRedo.RowMoveAction, UndoRedo.Action);
-UndoRedo.RowMoveAction.prototype.undo = function (instance, undoneCallback) {
-  const manualRowMove = instance.getPlugin('manualRowMove');
-  instance.addHookOnce('afterViewRender', undoneCallback);
-  const rowMoves = (0, _moves.getMoves)(this.rows, this.finalRowIndex, instance.rowIndexMapper.getNumberOfIndexes());
-  rowMoves.reverse().forEach(_ref4 => {
+class CreateRowAction extends _base.BaseAction {
+  constructor(_ref) {
     let {
-      from,
-      to
-    } = _ref4;
-    if (from < to) {
-      to -= 1;
+      index,
+      amount
+    } = _ref;
+    super();
+    /**
+     * @param {number} index The visual row index.
+     */
+    (0, _defineProperty2.default)(this, "index", void 0);
+    /**
+     * @param {number} amount The number of created rows.
+     */
+    (0, _defineProperty2.default)(this, "amount", void 0);
+    this.index = index;
+    this.amount = amount;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('afterCreateRow', (index, amount, source) => {
+      undoRedoPlugin.done(() => new CreateRowAction({
+        index,
+        amount
+      }), source);
+    });
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const rowCount = hot.countRows();
+    const minSpareRows = hot.getSettings().minSpareRows;
+    if (this.index >= rowCount && this.index - minSpareRows < rowCount) {
+      this.index -= minSpareRows; // work around the situation where the needed row was removed due to an 'undo' of a made change
     }
-    manualRowMove.moveRow(to, from);
-  });
-  instance.render();
-  instance.deselectCell();
-  instance.selectRows(this.rows[0], this.rows[0] + this.rows.length - 1);
-};
-UndoRedo.RowMoveAction.prototype.redo = function (instance, redoneCallback) {
-  const manualRowMove = instance.getPlugin('manualRowMove');
-  instance.addHookOnce('afterViewRender', redoneCallback);
-  manualRowMove.moveRows(this.rows.slice(), this.finalRowIndex);
-  instance.render();
-  instance.deselectCell();
-  instance.selectRows(this.finalRowIndex, this.finalRowIndex + this.rows.length - 1);
-};
+    hot.addHookOnce('afterRemoveRow', undoneCallback);
+    hot.alter('remove_row', this.index, this.amount, 'UndoRedo.undo');
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    hot.addHookOnce('afterCreateRow', redoneCallback);
+    hot.alter('insert_row_above', this.index, this.amount, 'UndoRedo.redo');
+  }
+}
+exports.CreateRowAction = CreateRowAction;
 
+/***/ }),
+/* 1089 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+__webpack_require__(283);
+__webpack_require__(311);
+__webpack_require__(519);
+__webpack_require__(530);
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
+var _object = __webpack_require__(499);
+var _array = __webpack_require__(495);
 /**
- * ManualColumnMove action.
+ * Action that tracks data changes.
  *
+ * @class DataChangeAction
  * @private
- * @param {number[]} columns An array with moved columns.
- * @param {number} finalIndex The destination index.
  */
-UndoRedo.ColumnMoveAction = function (columns, finalIndex) {
-  this.columns = columns.slice();
-  this.finalColumnIndex = finalIndex;
-  this.actionType = 'col_move';
-};
-(0, _object.inherit)(UndoRedo.ColumnMoveAction, UndoRedo.Action);
-UndoRedo.ColumnMoveAction.prototype.undo = function (instance, undoneCallback) {
-  const manualColumnMove = instance.getPlugin('manualColumnMove');
-  instance.addHookOnce('afterViewRender', undoneCallback);
-  const columnMoves = (0, _moves.getMoves)(this.columns, this.finalColumnIndex, instance.columnIndexMapper.getNumberOfIndexes());
-  columnMoves.reverse().forEach(_ref5 => {
+class DataChangeAction extends _base.BaseAction {
+  constructor(_ref) {
     let {
-      from,
-      to
-    } = _ref5;
-    if (from < to) {
-      to -= 1;
+      changes,
+      selected
+    } = _ref;
+    super();
+    /**
+     * @param {Array} changes 2D array containing information about each of the edited cells.
+     */
+    (0, _defineProperty2.default)(this, "changes", void 0);
+    /**
+     * @param {number[]} selected The cell selection.
+     */
+    (0, _defineProperty2.default)(this, "selected", void 0);
+    this.changes = changes;
+    this.selected = selected;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('afterChange', function (changes, source) {
+      const changesLen = changes && changes.length;
+      if (!changesLen) {
+        return;
+      }
+      const hasDifferences = changes.find(change => {
+        const [,, oldValue, newValue] = change;
+        return oldValue !== newValue;
+      });
+      if (!hasDifferences) {
+        return;
+      }
+      const wrappedAction = () => {
+        const clonedChanges = changes.reduce((arr, change) => {
+          arr.push([...change]);
+          return arr;
+        }, []);
+        (0, _array.arrayEach)(clonedChanges, change => {
+          change[1] = hot.propToCol(change[1]);
+        });
+        const selected = changesLen > 1 ? this.getSelected() : [[clonedChanges[0][0], clonedChanges[0][1]]];
+        return new DataChangeAction({
+          changes: clonedChanges,
+          selected
+        });
+      };
+      undoRedoPlugin.done(wrappedAction, source);
+    });
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const data = (0, _object.deepClone)(this.changes);
+    const emptyRowsAtTheEnd = hot.countEmptyRows(true);
+    const emptyColsAtTheEnd = hot.countEmptyCols(true);
+    for (let i = 0, len = data.length; i < len; i++) {
+      data[i].splice(3, 1);
     }
-    manualColumnMove.moveColumn(to, from);
-  });
-  instance.render();
-  instance.deselectCell();
-  instance.selectColumns(this.columns[0], this.columns[0] + this.columns.length - 1);
-};
-UndoRedo.ColumnMoveAction.prototype.redo = function (instance, redoneCallback) {
-  const manualColumnMove = instance.getPlugin('manualColumnMove');
-  instance.addHookOnce('afterViewRender', redoneCallback);
-  manualColumnMove.moveColumns(this.columns.slice(), this.finalColumnIndex);
-  instance.render();
-  instance.deselectCell();
-  instance.selectColumns(this.finalColumnIndex, this.finalColumnIndex + this.columns.length - 1);
-};
+    hot.addHookOnce('afterChange', undoneCallback);
+    hot.setDataAtCell(data, null, null, 'UndoRedo.undo');
+    for (let i = 0, len = data.length; i < len; i++) {
+      const [row, column] = data[i];
+      if (hot.getSettings().minSpareRows && row + 1 + hot.getSettings().minSpareRows === hot.countRows() && emptyRowsAtTheEnd === hot.getSettings().minSpareRows) {
+        hot.alter('remove_row', parseInt(row + 1, 10), hot.getSettings().minSpareRows);
+        hot.getPlugin('undoRedo').doneActions.pop();
+      }
+      if (hot.getSettings().minSpareCols && column + 1 + hot.getSettings().minSpareCols === hot.countCols() && emptyColsAtTheEnd === hot.getSettings().minSpareCols) {
+        hot.alter('remove_col', parseInt(column + 1, 10), hot.getSettings().minSpareCols);
+        hot.getPlugin('undoRedo').doneActions.pop();
+      }
+    }
+    hot.scrollToFocusedCell();
+    hot.selectCells(this.selected, false, false);
+  }
 
-/**
- * ColumnSort action.
- *
- * @private
- * @param {Array} currentSortState The current sort state.
- * @param {Array} newSortState The new sort state.
- */
-UndoRedo.ColumnSortAction = function (currentSortState, newSortState) {
-  this.previousSortState = currentSortState;
-  this.nextSortState = newSortState;
-};
-(0, _object.inherit)(UndoRedo.ColumnSortAction, UndoRedo.Action);
-UndoRedo.ColumnSortAction.prototype.undo = function (instance, undoneCallback) {
-  const sortPlugin = instance.getPlugin('columnSorting');
-  const multiSortPlugin = instance.getPlugin('multiColumnSorting');
-  const enabledSortPlugin = multiSortPlugin.isEnabled() ? multiSortPlugin : sortPlugin;
-  if (this.previousSortState.length) {
-    enabledSortPlugin.sort(this.previousSortState);
-  } else {
-    enabledSortPlugin.clearSort();
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    const data = (0, _object.deepClone)(this.changes);
+    for (let i = 0, len = data.length; i < len; i++) {
+      data[i].splice(2, 1);
+    }
+    hot.addHookOnce('afterChange', redoneCallback);
+    hot.setDataAtCell(data, null, null, 'UndoRedo.redo');
+    if (this.selected) {
+      hot.selectCells(this.selected, false, false);
+    }
   }
-  undoneCallback();
-};
-UndoRedo.ColumnSortAction.prototype.redo = function (instance, redoneCallback) {
-  const sortPlugin = instance.getPlugin('columnSorting');
-  const multiSortPlugin = instance.getPlugin('multiColumnSorting');
-  const enabledSortPlugin = multiSortPlugin.isEnabled() ? multiSortPlugin : sortPlugin;
-  enabledSortPlugin.sort(this.nextSortState);
-  redoneCallback();
-};
+}
+exports.DataChangeAction = DataChangeAction;
 
+/***/ }),
+/* 1090 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+__webpack_require__(311);
+__webpack_require__(323);
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
 /**
- * Enabling and disabling plugin and attaching its to an instance.
+ * Action that tracks filter changes.
  *
+ * @class FiltersAction
  * @private
  */
-UndoRedo.prototype.init = function () {
-  const settings = this.instance.getSettings().undo;
-  const pluginEnabled = typeof settings === 'undefined' || settings;
-  if (!this.instance.undoRedo) {
-    this.instance.undoRedo = this;
+class FiltersAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      conditionsStack,
+      previousConditionsStack
+    } = _ref;
+    super();
+    /**
+     * @param {Array} previousConditionsStack An array of the previous filter conditions.
+     */
+    (0, _defineProperty2.default)(this, "conditionsStack", void 0);
+    /**
+     * @param {Array} conditionsStack An array of the filter conditions.
+     */
+    (0, _defineProperty2.default)(this, "previousConditionsStack", void 0);
+    this.conditionsStack = conditionsStack;
+    this.previousConditionsStack = previousConditionsStack;
   }
-  if (pluginEnabled) {
-    this.instance.undoRedo.enable();
-  } else {
-    this.instance.undoRedo.disable();
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeFilter', (conditionsStack, previousConditionsStack) => {
+      undoRedoPlugin.done(() => new FiltersAction({
+        conditionsStack,
+        previousConditionsStack
+      }));
+    });
   }
-};
 
-/**
- * Registers shortcuts responsible for performing undo/redo.
- *
- * @private
- */
-UndoRedo.prototype.registerShortcuts = function () {
-  const shortcutManager = this.instance.getShortcutManager();
-  const gridContext = shortcutManager.getContext('grid');
-  const runOnlyIf = event => {
-    return !event.altKey; // right ALT in some systems triggers ALT+CTR
-  };
-  const config = {
-    runOnlyIf,
-    group: SHORTCUTS_GROUP
-  };
-  gridContext.addShortcuts([{
-    keys: [['Control/Meta', 'z']],
-    callback: () => {
-      this.undo();
-    }
-  }, {
-    keys: [['Control/Meta', 'y'], ['Control/Meta', 'Shift', 'z']],
-    callback: () => {
-      this.redo();
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const filters = hot.getPlugin('filters');
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    if (this.previousConditionsStack) {
+      filters.conditionCollection.importAllConditions(this.previousConditionsStack);
     }
-  }], config);
-};
+    filters.filter();
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    const filters = hot.getPlugin('filters');
+    hot.addHookOnce('afterViewRender', redoneCallback);
+    filters.conditionCollection.importAllConditions(this.conditionsStack);
+    filters.filter();
+  }
+}
+exports.FiltersAction = FiltersAction;
+
+/***/ }),
+/* 1091 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
 
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
 /**
- * Unregister shortcuts responsible for performing undo/redo.
+ * Action that tracks changes in merged cells.
  *
+ * @class MergeCellsAction
  * @private
  */
-UndoRedo.prototype.unregisterShortcuts = function () {
-  const shortcutManager = this.instance.getShortcutManager();
-  const gridContext = shortcutManager.getContext('grid');
-  gridContext.removeShortcutsByGroup(SHORTCUTS_GROUP);
-};
-
-/**
- * @param {Array} changes 2D array containing information about each of the edited cells.
- * @param {string} source String that identifies source of hook call.
- * @returns {boolean}
- */
-function onAfterChange(changes, source) {
-  const instance = this;
-  if (source === 'loadData') {
-    return instance.undoRedo.clear();
+class MergeCellsAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      data,
+      cellRange
+    } = _ref;
+    super();
+    (0, _defineProperty2.default)(this, "cellRange", void 0);
+    this.cellRange = cellRange;
+    this.data = data;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeMergeCells', (cellRange, auto) => {
+      if (auto) {
+        return;
+      }
+      const topStartCorner = cellRange.getTopStartCorner();
+      const bottomEndCorner = cellRange.getBottomEndCorner();
+      const data = hot.getData(topStartCorner.row, topStartCorner.col, bottomEndCorner.row, bottomEndCorner.col);
+      undoRedoPlugin.done(() => new MergeCellsAction({
+        data,
+        cellRange
+      }));
+    });
   }
-}
 
-/**
- * @param {Core} instance The Handsontable instance.
- */
-function exposeUndoRedoMethods(instance) {
   /**
-   * {@link UndoRedo#undo}.
-   *
-   * @alias undo
-   * @memberof! Core#
-   * @returns {boolean}
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
    */
-  instance.undo = function () {
-    return instance.undoRedo.undo();
-  };
+  undo(hot, undoneCallback) {
+    const mergeCellsPlugin = hot.getPlugin('mergeCells');
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    mergeCellsPlugin.unmergeRange(this.cellRange, true);
+    const topStartCorner = this.cellRange.getTopStartCorner();
+    hot.populateFromArray(topStartCorner.row, topStartCorner.col, this.data, undefined, undefined, 'MergeCells');
+  }
 
   /**
-   * {@link UndoRedo#redo}.
-   *
-   * @alias redo
-   * @memberof! Core#
-   * @returns {boolean}
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
    */
-  instance.redo = function () {
-    return instance.undoRedo.redo();
-  };
+  redo(hot, redoneCallback) {
+    const mergeCellsPlugin = hot.getPlugin('mergeCells');
+    hot.addHookOnce('afterViewRender', redoneCallback);
+    mergeCellsPlugin.mergeRange(this.cellRange);
+  }
+}
+exports.MergeCellsAction = MergeCellsAction;
 
-  /**
-   * {@link UndoRedo#isUndoAvailable}.
-   *
-   * @alias isUndoAvailable
-   * @memberof! Core#
-   * @returns {boolean}
-   */
-  instance.isUndoAvailable = function () {
-    return instance.undoRedo.isUndoAvailable();
-  };
+/***/ }),
+/* 1092 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+__webpack_require__(283);
+__webpack_require__(311);
+__webpack_require__(329);
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
+var _utils = __webpack_require__(1093);
+var _number = __webpack_require__(534);
+var _array = __webpack_require__(495);
+/**
+ * Action that tracks changes in column removal.
+ *
+ * @class RemoveColumnAction
+ * @private
+ */
+class RemoveColumnAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      index,
+      indexes,
+      data,
+      headers,
+      columnPositions,
+      rowPositions,
+      fixedColumnsStart,
+      removedCellMetas
+    } = _ref;
+    super();
+    /**
+     * @param {number} index The visual column index.
+     */
+    (0, _defineProperty2.default)(this, "index", void 0);
+    /**
+     * @param {number[]} indexes The visual column indexes.
+     */
+    (0, _defineProperty2.default)(this, "indexes", void 0);
+    /**
+     * @param {Array} data The removed data.
+     */
+    (0, _defineProperty2.default)(this, "data", void 0);
+    /**
+     * @param {number} amount The number of removed columns.
+     */
+    (0, _defineProperty2.default)(this, "amount", void 0);
+    /**
+     * @param {Array} headers The header values.
+     */
+    (0, _defineProperty2.default)(this, "headers", void 0);
+    /**
+     * @param {number[]} columnPositions The column position.
+     */
+    (0, _defineProperty2.default)(this, "columnPositions", void 0);
+    /**
+     * @param {number[]} rowPositions The row position.
+     */
+    (0, _defineProperty2.default)(this, "rowPositions", void 0);
+    /**
+     * @param {number} fixedColumnsStart Number of fixed columns on the left. Remove column action change it sometimes.
+     */
+    (0, _defineProperty2.default)(this, "fixedColumnsStart", void 0);
+    /**
+     * @param {Array} removedCellMetas List of removed cell metas.
+     */
+    (0, _defineProperty2.default)(this, "removedCellMetas", void 0);
+    this.index = index;
+    this.indexes = indexes;
+    this.data = data;
+    this.amount = this.data[0].length;
+    this.headers = headers;
+    this.columnPositions = columnPositions.slice(0);
+    this.rowPositions = rowPositions.slice(0);
+    this.fixedColumnsStart = fixedColumnsStart;
+    this.removedCellMetas = removedCellMetas;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeRemoveCol', (index, amount, logicColumns, source) => {
+      const wrappedAction = () => {
+        const originalData = hot.getSourceDataArray();
+        const columnIndex = (hot.countCols() + index) % hot.countCols();
+        const lastColumnIndex = columnIndex + amount - 1;
+        const removedData = [];
+        const headers = [];
+        const indexes = [];
+        (0, _number.rangeEach)(originalData.length - 1, i => {
+          const column = [];
+          const origRow = originalData[i];
+          (0, _number.rangeEach)(columnIndex, lastColumnIndex, j => {
+            column.push(origRow[hot.toPhysicalColumn(j)]);
+          });
+          removedData.push(column);
+        });
+        (0, _number.rangeEach)(amount - 1, i => {
+          indexes.push(hot.toPhysicalColumn(columnIndex + i));
+        });
+        if (Array.isArray(hot.getSettings().colHeaders)) {
+          (0, _number.rangeEach)(amount - 1, i => {
+            headers.push(hot.getSettings().colHeaders[hot.toPhysicalColumn(columnIndex + i)] || null);
+          });
+        }
+        const columnsMap = hot.columnIndexMapper.getIndexesSequence();
+        const rowsMap = hot.rowIndexMapper.getIndexesSequence();
+        return new RemoveColumnAction({
+          index: columnIndex,
+          indexes,
+          data: removedData,
+          headers,
+          columnPositions: columnsMap,
+          rowPositions: rowsMap,
+          fixedColumnsStart: hot.getSettings().fixedColumnsStart,
+          removedCellMetas: (0, _utils.getCellMetas)(hot, 0, hot.countRows(), columnIndex, lastColumnIndex)
+        });
+      };
+      undoRedoPlugin.done(wrappedAction, source);
+    });
+  }
 
   /**
-   * {@link UndoRedo#isRedoAvailable}.
-   *
-   * @alias isRedoAvailable
-   * @memberof! Core#
-   * @returns {boolean}
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
    */
-  instance.isRedoAvailable = function () {
-    return instance.undoRedo.isRedoAvailable();
-  };
+  undo(hot, undoneCallback) {
+    const settings = hot.getSettings();
+
+    // Changing by the reference as `updateSettings` doesn't work the best.
+    settings.fixedColumnsStart = this.fixedColumnsStart;
+    const ascendingIndexes = this.indexes.slice(0).sort();
+    const sortByIndexes = (elem, j, arr) => arr[this.indexes.indexOf(ascendingIndexes[j])];
+    const removedDataLength = this.data.length;
+    const sortedData = [];
+    for (let rowIndex = 0; rowIndex < removedDataLength; rowIndex++) {
+      sortedData.push((0, _array.arrayMap)(this.data[rowIndex], sortByIndexes));
+    }
+    const sortedHeaders = (0, _array.arrayMap)(this.headers, sortByIndexes);
+    const changes = [];
+    hot.alter('insert_col_start', this.indexes[0], this.indexes.length, 'UndoRedo.undo');
+    (0, _array.arrayEach)(hot.getSourceDataArray(), (rowData, rowIndex) => {
+      (0, _array.arrayEach)(ascendingIndexes, (changedIndex, contiquesIndex) => {
+        rowData[changedIndex] = sortedData[rowIndex][contiquesIndex];
+        changes.push([rowIndex, changedIndex, rowData[changedIndex]]);
+      });
+    });
+    hot.setSourceDataAtCell(changes, undefined, undefined, 'UndoRedo.undo');
+    if (typeof this.headers !== 'undefined') {
+      (0, _array.arrayEach)(sortedHeaders, (headerData, columnIndex) => {
+        hot.getSettings().colHeaders[ascendingIndexes[columnIndex]] = headerData;
+      });
+    }
+    this.removedCellMetas.forEach(_ref2 => {
+      let [rowIndex, columnIndex, cellMeta] = _ref2;
+      hot.setCellMetaObject(rowIndex, columnIndex, cellMeta);
+    });
+    hot.batchExecution(() => {
+      // Restore row sequence in a case when all columns are removed. the original
+      // row sequence is lost in that case.
+      hot.rowIndexMapper.setIndexesSequence(this.rowPositions);
+      hot.columnIndexMapper.setIndexesSequence(this.columnPositions);
+    }, true);
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    hot.render();
+  }
 
   /**
-   * {@link UndoRedo#clear}.
-   *
-   * @alias clearUndo
-   * @memberof! Core#
-   * @returns {boolean}
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
    */
-  instance.clearUndo = function () {
-    return instance.undoRedo.clear();
-  };
+  redo(hot, redoneCallback) {
+    hot.addHookOnce('afterRemoveCol', redoneCallback);
+    hot.alter('remove_col', this.index, this.amount, 'UndoRedo.redo');
+  }
 }
+exports.RemoveColumnAction = RemoveColumnAction;
+
+/***/ }),
+/* 1093 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
 
+exports.__esModule = true;
+exports.getCellMetas = getCellMetas;
+__webpack_require__(283);
+__webpack_require__(1094);
+__webpack_require__(311);
+__webpack_require__(323);
+var _number = __webpack_require__(534);
 /**
- * @param {Core} instance The Handsontable instance.
- */
-function removeExposedUndoRedoMethods(instance) {
-  delete instance.undo;
-  delete instance.redo;
-  delete instance.isUndoAvailable;
-  delete instance.isRedoAvailable;
-  delete instance.clearUndo;
-}
-const hook = _hooks.Hooks.getSingleton();
-hook.add('afterUpdateSettings', function () {
-  var _this$getPlugin;
-  (_this$getPlugin = this.getPlugin('undoRedo')) === null || _this$getPlugin === void 0 || _this$getPlugin.init();
-});
-hook.register('beforeUndo');
-hook.register('afterUndo');
-hook.register('beforeRedo');
-hook.register('afterRedo');
-UndoRedo.PLUGIN_KEY = PLUGIN_KEY;
-UndoRedo.SETTING_KEYS = true;
-var _default = exports["default"] = UndoRedo;
+ * Gets all cell metas from the provided range.
+ *
+ * @param {Core} hot The Handsontable instance.
+ * @param {number} fromRow The starting row index.
+ * @param {number} toRow The ending row index.
+ * @param {number} fromColumn The starting column index.
+ * @param {number} toColumn The ending column index.
+ * @returns {Array} Returns an array of cell metas.
+ */
+function getCellMetas(hot, fromRow, toRow, fromColumn, toColumn) {
+  const genericKeys = ['visualRow', 'visualCol', 'row', 'col', 'prop'];
+  const genericKeysLength = genericKeys.length;
+  const cellMetas = [];
+  (0, _number.rangeEach)(fromColumn, toColumn, columnIndex => {
+    (0, _number.rangeEach)(fromRow, toRow, rowIndex => {
+      const cellMeta = hot.getCellMeta(rowIndex, columnIndex);
+      if (Object.keys(cellMeta).length !== genericKeysLength) {
+        const uniqueMeta = Object.fromEntries(Object.entries(cellMeta).filter(_ref => {
+          let [key] = _ref;
+          return genericKeys.includes(key) === false;
+        }));
+        cellMetas.push([cellMeta.visualRow, cellMeta.visualCol, uniqueMeta]);
+      }
+    });
+  });
+  return cellMetas;
+}
 
 /***/ }),
-/* 1082 */
+/* 1094 */
 /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => {
 
 "use strict";
@@ -152093,7 +152396,278 @@ $({ target: 'Object', stat: true }, {
 
 
 /***/ }),
-/* 1083 */
+/* 1095 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+__webpack_require__(283);
+__webpack_require__(311);
+__webpack_require__(329);
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
+var _utils = __webpack_require__(1093);
+var _object = __webpack_require__(499);
+/**
+ * Action that tracks changes in row removal.
+ *
+ * @class RemoveRowAction
+ * @private
+ */
+class RemoveRowAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      index,
+      data,
+      fixedRowsBottom,
+      fixedRowsTop,
+      rowIndexesSequence,
+      removedCellMetas
+    } = _ref;
+    super();
+    /**
+     * @param {number} index The visual row index.
+     */
+    (0, _defineProperty2.default)(this, "index", void 0);
+    /**
+     * @param {Array} data The removed data.
+     */
+    (0, _defineProperty2.default)(this, "data", void 0);
+    /**
+     * @param {number} fixedRowsBottom Number of fixed rows on the bottom. Remove row action change it sometimes.
+     */
+    (0, _defineProperty2.default)(this, "fixedRowsBottom", void 0);
+    /**
+     * @param {number} fixedRowsTop Number of fixed rows on the top. Remove row action change it sometimes.
+     */
+    (0, _defineProperty2.default)(this, "fixedRowsTop", void 0);
+    /**
+     * @param {Array} rowIndexesSequence Row index sequence taken from the row index mapper.
+     */
+    (0, _defineProperty2.default)(this, "rowIndexesSequence", void 0);
+    /**
+     * @param {Array} removedCellMetas List of removed cell metas.
+     */
+    (0, _defineProperty2.default)(this, "removedCellMetas", void 0);
+    this.index = index;
+    this.data = data;
+    this.fixedRowsBottom = fixedRowsBottom;
+    this.fixedRowsTop = fixedRowsTop;
+    this.rowIndexesSequence = rowIndexesSequence;
+    this.removedCellMetas = removedCellMetas;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeRemoveRow', (index, amount, logicRows, source) => {
+      const wrappedAction = () => {
+        const physicalRowIndex = hot.toPhysicalRow(index);
+        const lastRowIndex = physicalRowIndex + amount - 1;
+        const removedData = (0, _object.deepClone)(hot.getSourceData(physicalRowIndex, 0, physicalRowIndex + amount - 1, hot.countSourceCols() - 1));
+        return new RemoveRowAction({
+          index: physicalRowIndex,
+          data: removedData,
+          fixedRowsBottom: hot.getSettings().fixedRowsBottom,
+          fixedRowsTop: hot.getSettings().fixedRowsTop,
+          rowIndexesSequence: hot.rowIndexMapper.getIndexesSequence(),
+          removedCellMetas: (0, _utils.getCellMetas)(hot, physicalRowIndex, lastRowIndex, 0, hot.countCols() - 1)
+        });
+      };
+      undoRedoPlugin.done(wrappedAction, source);
+    });
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const settings = hot.getSettings();
+    const changes = [];
+
+    // Changing by the reference as `updateSettings` doesn't work the best.
+    settings.fixedRowsBottom = this.fixedRowsBottom;
+    settings.fixedRowsTop = this.fixedRowsTop;
+
+    // Prepare the change list to fill the source data.
+    this.data.forEach((dataRow, rowIndexDelta) => {
+      Object.keys(dataRow).forEach(columnProp => {
+        const columnIndex = parseInt(columnProp, 10);
+        changes.push([this.index + rowIndexDelta, isNaN(columnIndex) ? columnProp : columnIndex, dataRow[columnProp]]);
+      });
+    });
+    hot.alter('insert_row_above', this.index, this.data.length, 'UndoRedo.undo');
+    this.removedCellMetas.forEach(_ref2 => {
+      let [rowIndex, columnIndex, cellMeta] = _ref2;
+      hot.setCellMetaObject(rowIndex, columnIndex, cellMeta);
+    });
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    hot.setSourceDataAtCell(changes, null, null, 'UndoRedo.undo');
+    hot.rowIndexMapper.setIndexesSequence(this.rowIndexesSequence);
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    hot.addHookOnce('afterRemoveRow', redoneCallback);
+    hot.alter('remove_row', this.index, this.data.length, 'UndoRedo.redo');
+  }
+}
+exports.RemoveRowAction = RemoveRowAction;
+
+/***/ }),
+/* 1096 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+__webpack_require__(311);
+__webpack_require__(329);
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
+var _moves = __webpack_require__(993);
+/**
+ * Action that tracks row move changes.
+ *
+ * @class RowMoveAction
+ * @private
+ */
+class RowMoveAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      rows,
+      finalIndex
+    } = _ref;
+    super();
+    /**
+     * @param {number[]} rows An array with moved rows.
+     */
+    (0, _defineProperty2.default)(this, "rows", void 0);
+    /**
+     * @param {number} finalIndex The destination index.
+     */
+    (0, _defineProperty2.default)(this, "finalRowIndex", void 0);
+    this.rows = rows.slice();
+    this.finalRowIndex = finalIndex;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('beforeRowMove', (rows, finalIndex) => {
+      if (rows === false) {
+        return;
+      }
+      undoRedoPlugin.done(() => new RowMoveAction({
+        rows,
+        finalIndex
+      }));
+    });
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const manualRowMove = hot.getPlugin('manualRowMove');
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    const rowMoves = (0, _moves.getMoves)(this.rows, this.finalRowIndex, hot.rowIndexMapper.getNumberOfIndexes());
+    rowMoves.reverse().forEach(_ref2 => {
+      let {
+        from,
+        to
+      } = _ref2;
+      if (from < to) {
+        to -= 1;
+      }
+      manualRowMove.moveRow(to, from);
+    });
+    hot.render();
+    hot.deselectCell();
+    hot.selectRows(this.rows[0], this.rows[0] + this.rows.length - 1);
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    const manualRowMove = hot.getPlugin('manualRowMove');
+    hot.addHookOnce('afterViewRender', redoneCallback);
+    manualRowMove.moveRows(this.rows.slice(), this.finalRowIndex);
+    hot.render();
+    hot.deselectCell();
+    hot.selectRows(this.finalRowIndex, this.finalRowIndex + this.rows.length - 1);
+  }
+}
+exports.RowMoveAction = RowMoveAction;
+
+/***/ }),
+/* 1097 */
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+
+var _interopRequireDefault = __webpack_require__(197);
+exports.__esModule = true;
+var _defineProperty2 = _interopRequireDefault(__webpack_require__(504));
+var _base = __webpack_require__(1084);
+/**
+ * Action that tracks changes in merged cells.
+ *
+ * @class UnmergeCellsAction
+ * @private
+ */
+class UnmergeCellsAction extends _base.BaseAction {
+  constructor(_ref) {
+    let {
+      cellRange
+    } = _ref;
+    super();
+    (0, _defineProperty2.default)(this, "cellRange", void 0);
+    this.cellRange = cellRange;
+  }
+  static startRegisteringEvents(hot, undoRedoPlugin) {
+    hot.addHook('afterUnmergeCells', (cellRange, auto) => {
+      if (auto) {
+        return;
+      }
+      undoRedoPlugin.done(() => new UnmergeCellsAction({
+        cellRange
+      }));
+    });
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} undoneCallback The callback to be called after the action is undone.
+   */
+  undo(hot, undoneCallback) {
+    const mergeCellsPlugin = hot.getPlugin('mergeCells');
+    hot.addHookOnce('afterViewRender', undoneCallback);
+    mergeCellsPlugin.mergeRange(this.cellRange, true);
+  }
+
+  /**
+   * @param {Core} hot The Handsontable instance.
+   * @param {function(): void} redoneCallback The callback to be called after the action is redone.
+   */
+  redo(hot, redoneCallback) {
+    const mergeCellsPlugin = hot.getPlugin('mergeCells');
+    hot.addHookOnce('afterViewRender', redoneCallback);
+    mergeCellsPlugin.unmergeRange(this.cellRange, true);
+    hot.render();
+  }
+}
+exports.UnmergeCellsAction = UnmergeCellsAction;
+
+/***/ }),
+/* 1098 */
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";